Release-1.2.11

Doxyfile

@@ -148,7 +148,7 @@ PERL_PATH              = /usr/bin/perl
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool   
 #---------------------------------------------------------------------------
-HAVE_DOT               = YES
+HAVE_DOT               = NO
 CLASS_GRAPH            = YES
 COLLABORATION_GRAPH    = YES
 INCLUDE_GRAPH          = YES

INSTALL

-DOXYGEN Version 1.2.10-20010923
+DOXYGEN Version 1.2.11
 
 Please read the installation section of the manual for instructions.
 
 --------
-Dimitri van Heesch (23 September 2001)
+Dimitri van Heesch (30 September 2001)

Makefile.in

@@ -76,5 +76,8 @@ archive: clean
 src/version.cpp: Makefile
 	echo "char versionString[]=\"$(VERSION)\";" > src/version.cpp
 
+addon/doxywizard/version.cpp: Makefile
+	echo "char versionString[]=\"$(VERSION)\";" > addon/doxywizard/version.cpp
+
 FORCE:
 

README

-DOXYGEN Version 1.2.10_20010923
+DOXYGEN Version 1.2.11
 
 Please read INSTALL for compilation instructions.
 
@@ -17,4 +17,4 @@ to subscribe to the lists or to visit the archives.
 
 Enjoy,
 
-Dimitri van Heesch (dimitri@stack.nl) (23 September 2001)
+Dimitri van Heesch (dimitri@stack.nl) (30 September 2001)

VERSION

-1.2.10-20010923
+1.2.11

addon/xmlparse/dochandler.cpp

@@ -372,6 +372,95 @@ void ParameterListHandler::startParameterDescription(const QXmlAttributes& attri
   m_curParam->startParameterDescription(attrib);
 }
 
+//----------------------------------------------------------------------
+// LinkHandler
+//----------------------------------------------------------------------
+
+LinkHandler::LinkHandler(IBaseHandler *parent)
+  : DocNode(Link), m_parent(parent)
+{
+  addEndHandler("link",this,&LinkHandler::endLink);
+}
+
+LinkHandler::~LinkHandler()
+{
+}
+
+void LinkHandler::startLink(const QXmlAttributes& attrib)
+{
+  m_parent->setDelegate(this);
+  printf("Start link\n");
+  m_ref = attrib.value("linkend");
+  m_curString="";
+}
+
+void LinkHandler::endLink()
+{
+  m_text = m_curString;
+  m_curString="";
+  m_parent->setDelegate(0);
+  printf("End link\n");
+}
+
+//----------------------------------------------------------------------
+// EMailHandler
+//----------------------------------------------------------------------
+
+EMailHandler::EMailHandler(IBaseHandler *parent)
+  : DocNode(EMail), m_parent(parent)
+{
+  addEndHandler("email",this,&EMailHandler::endEMail);
+}
+
+EMailHandler::~EMailHandler()
+{
+}
+
+void EMailHandler::startEMail(const QXmlAttributes& /*attrib*/)
+{
+  m_parent->setDelegate(this);
+  printf("Start email\n");
+  m_curString="";
+}
+
+void EMailHandler::endEMail()
+{
+  m_address = m_curString;
+  m_curString="";
+  m_parent->setDelegate(0);
+  printf("End email\n");
+}
+
+//----------------------------------------------------------------------
+// ULinkHandler
+//----------------------------------------------------------------------
+
+ULinkHandler::ULinkHandler(IBaseHandler *parent)
+  : DocNode(ULink), m_parent(parent)
+{
+  addEndHandler("ulink",this,&ULinkHandler::endULink);
+}
+
+ULinkHandler::~ULinkHandler()
+{
+}
+
+void ULinkHandler::startULink(const QXmlAttributes& attrib)
+{
+  m_parent->setDelegate(this);
+  printf("Start ulink\n");
+  m_url = attrib.value("url");
+  m_curString="";
+}
+
+void ULinkHandler::endULink()
+{
+  m_text = m_curString;
+  m_curString="";
+  m_parent->setDelegate(0);
+  printf("End ulink\n");
+}
+
 //----------------------------------------------------------------------
 // LineBreakHandler
 //----------------------------------------------------------------------
@@ -379,6 +468,7 @@ void ParameterListHandler::startParameterDescription(const QXmlAttributes& attri
 LineBreakHandler::LineBreakHandler(IBaseHandler *parent)
   : DocNode(LineBreak), m_parent(parent)
 {
+  addEndHandler("linebreak",this,&LineBreakHandler::endLineBreak);
 }
 
 LineBreakHandler::~LineBreakHandler()
@@ -388,7 +478,6 @@ LineBreakHandler::~LineBreakHandler()
 void LineBreakHandler::startLineBreak(const QXmlAttributes& /*attrib*/)
 {
   m_parent->setDelegate(this);
-  addEndHandler("linebreak",this,&LineBreakHandler::endLineBreak);
   printf("Start linebreak\n");
 }
 
@@ -405,6 +494,7 @@ void LineBreakHandler::endLineBreak()
 HRulerHandler::HRulerHandler(IBaseHandler *parent)
   : DocNode(HRuler), m_parent(parent)
 {
+  addEndHandler("hruler",this,&HRulerHandler::endHRuler);
 }
 
 HRulerHandler::~HRulerHandler()
@@ -414,7 +504,6 @@ HRulerHandler::~HRulerHandler()
 void HRulerHandler::startHRuler(const QXmlAttributes& /*attrib*/)
 {
   m_parent->setDelegate(this);
-  addEndHandler("hruler",this,&HRulerHandler::endHRuler);
   printf("Start hruler\n");
 }
 
@@ -431,6 +520,7 @@ void HRulerHandler::endHRuler()
 RefHandler::RefHandler(IBaseHandler *parent)
   : DocNode(Ref), m_parent(parent)
 {
+  addEndHandler("ref",this,&RefHandler::endRef);
 }
 
 RefHandler::~RefHandler()
@@ -440,7 +530,6 @@ RefHandler::~RefHandler()
 void RefHandler::startRef(const QXmlAttributes& attrib)
 {
   m_parent->setDelegate(this);
-  addEndHandler("ref",this,&RefHandler::endRef);
   m_refId = attrib.value("idref");
   m_anchor = attrib.value("anchor");
   printf("Start ref refId=%s anchor=%s\n",m_refId.data(),m_anchor.data());
@@ -466,6 +555,7 @@ TitleHandler::TitleHandler(IBaseHandler *parent)
   m_markupHandler = new MarkupHandler(m_children,m_curString);
   setFallBackHandler(m_markupHandler);
   addStartHandler("ref",this,&TitleHandler::startRef);
+  addEndHandler("title",this,&TitleHandler::endTitle);
 }
 
 TitleHandler::~TitleHandler()
@@ -476,7 +566,6 @@ TitleHandler::~TitleHandler()
 void TitleHandler::startTitle(const QXmlAttributes& /*attrib*/)
 {
   m_parent->setDelegate(this);
-  addEndHandler("title",this,&TitleHandler::endTitle);
   printf("Start title\n");
   m_curString="";
 }
@@ -515,6 +604,7 @@ SimpleSectHandler::SimpleSectHandler(IBaseHandler *parent)
 {
   addStartHandler("title",this,&SimpleSectHandler::startTitle);
   addStartHandler("para",this,&SimpleSectHandler::startParagraph);
+  addEndHandler("simplesect",this,&SimpleSectHandler::endSimpleSect);
 }
 
 SimpleSectHandler::~SimpleSectHandler()
@@ -524,7 +614,6 @@ SimpleSectHandler::~SimpleSectHandler()
 void SimpleSectHandler::startSimpleSect(const QXmlAttributes& attrib)
 {
   m_type = g_typeMapper.stringToType(attrib.value("kind"));
-  addEndHandler("simplesect",this,&SimpleSectHandler::endSimpleSect);
   printf("start simple section %s\n",attrib.value("kind").data());
   m_parent->setDelegate(this);
 }
@@ -559,6 +648,8 @@ VariableListEntryHandler::VariableListEntryHandler(IBaseHandler *parent)
   addStartHandler("term",this,&VariableListEntryHandler::startTerm);
   addEndHandler("term",this,&VariableListEntryHandler::endTerm);
   addStartHandler("para",this,&VariableListEntryHandler::startParagraph);
+  addEndHandler("varlistentry",this,&VariableListEntryHandler::endVarListEntry);
+  addEndHandler("listitem",this,&VariableListEntryHandler::endListItem);
 }
 
 VariableListEntryHandler::~VariableListEntryHandler()
@@ -570,7 +661,6 @@ void VariableListEntryHandler::startVarListEntry(const QXmlAttributes& /*attrib*
 {
   m_parent->setDelegate(this);
   printf("start varlistentry\n");
-  addEndHandler("varlistentry",this,&VariableListEntryHandler::endVarListEntry);
 }
 
 void VariableListEntryHandler::endVarListEntry()
@@ -583,7 +673,6 @@ void VariableListEntryHandler::startListItem(const QXmlAttributes& /*attrib*/)
 {
   m_parent->setDelegate(this);
   printf("start listitem\n");
-  addEndHandler("listitem",this,&VariableListEntryHandler::endListItem);
 }
 
 void VariableListEntryHandler::endListItem()
@@ -622,6 +711,7 @@ VariableListHandler::VariableListHandler(IBaseHandler *parent)
   m_entries.setAutoDelete(TRUE);
   addStartHandler("varlistentry",this,&VariableListHandler::startVarListEntry);
   addStartHandler("listitem",this,&VariableListHandler::startListItem);
+  addEndHandler("variablelist",this,&VariableListHandler::endVariableList);
 }
 
 VariableListHandler::~VariableListHandler()
@@ -632,7 +722,6 @@ void VariableListHandler::startVariableList(const QXmlAttributes& /*attrib*/)
 {
   m_parent->setDelegate(this);
   printf("start variablelist\n");
-  addEndHandler("variablelist",this,&VariableListHandler::endVariableList);
 }
 
 void VariableListHandler::endVariableList()
@@ -655,6 +744,101 @@ void VariableListHandler::startListItem(const QXmlAttributes& attrib)
   m_curEntry->startListItem(attrib);
 }
 
+//----------------------------------------------------------------------
+// CodeLineHandler
+//----------------------------------------------------------------------
+
+CodeLineHandler::CodeLineHandler(IBaseHandler *parent)
+  : DocNode(CodeLine), m_parent(parent)
+{
+  m_children.setAutoDelete(TRUE);
+  addEndHandler("codeline",this,&CodeLineHandler::endCodeLine);
+  addEndHandler("linenumber",this,&CodeLineHandler::endLineNumber);
+}
+
+CodeLineHandler::~CodeLineHandler()
+{
+}
+
+void CodeLineHandler::startCodeLine(const QXmlAttributes& /*attrib*/)
+{
+  m_parent->setDelegate(this);
+  printf("start codeline\n");
+}
+
+void CodeLineHandler::endCodeLine()
+{
+  printf("end codeline\n");
+  m_parent->setDelegate(0);
+}
+
+void CodeLineHandler::startLineNumber(const QXmlAttributes& /*attrib*/)
+{
+  m_parent->setDelegate(this);
+  printf("start linenumber\n");
+}
+
+void CodeLineHandler::endLineNumber()
+{
+  printf("end linenumber\n");
+  m_parent->setDelegate(0);
+}
+//----------------------------------------------------------------------
+// ProgramListingHandler
+//----------------------------------------------------------------------
+
+ProgramListingHandler::ProgramListingHandler(IBaseHandler *parent)
+  : DocNode(ProgramListing), m_parent(parent)
+{
+  m_children.setAutoDelete(TRUE);
+  m_hasLineNumber=FALSE;
+  addEndHandler("programlisting",this,&ProgramListingHandler::endProgramListing);
+
+  addStartHandler("linenumber",this,&ProgramListingHandler::startLineNumber);
+  addStartHandler("codeline",this,&ProgramListingHandler::startCodeLine);
+}
+
+ProgramListingHandler::~ProgramListingHandler()
+{
+}
+
+void ProgramListingHandler::startProgramListing(const QXmlAttributes& /*attrib*/)
+{
+  m_parent->setDelegate(this);
+  printf("start programlisting\n");
+}
+
+void ProgramListingHandler::endProgramListing()
+{
+  printf("end programlisting\n");
+  m_parent->setDelegate(0);
+}
+
+void ProgramListingHandler::startLineNumber(const QXmlAttributes& attrib)
+{
+  CodeLineHandler *clh = new CodeLineHandler(this);
+  m_children.append(clh);
+  m_hasLineNumber=TRUE;
+  clh->startLineNumber(attrib);
+}
+  
+void ProgramListingHandler::startCodeLine(const QXmlAttributes& attrib)
+{
+  CodeLineHandler *clh = 0;
+  if (!m_hasLineNumber) 
+  {
+    clh = new CodeLineHandler(this);
+    m_children.append(clh);
+  }
+  else
+  {
+    clh = m_children.getLast();
+  }
+  ASSERT(clh!=0);
+  clh->startCodeLine(attrib);
+  m_hasLineNumber=FALSE; 
+}
+
 //----------------------------------------------------------------------
 // ParagraphHandler
 //----------------------------------------------------------------------
@@ -677,6 +861,10 @@ ParagraphHandler::ParagraphHandler(IBaseHandler *parent)
   addStartHandler("variablelist",this,&ParagraphHandler::startVariableList);
   addStartHandler("hruler",this,&ParagraphHandler::startHRuler);
   addStartHandler("linebreak",this,&ParagraphHandler::startLineBreak);
+  addStartHandler("ulink",this,&ParagraphHandler::startULink);
+  addStartHandler("email",this,&ParagraphHandler::startEMail);
+  addStartHandler("link",this,&ParagraphHandler::startLink);
+  addStartHandler("programlisting",this,&ParagraphHandler::startProgramListing);
 }
 
 ParagraphHandler::~ParagraphHandler()
@@ -757,6 +945,34 @@ void ParagraphHandler::startLineBreak(const QXmlAttributes& attrib)
   m_children.append(lb);
 }
 
+void ParagraphHandler::startULink(const QXmlAttributes& attrib)
+{
+  ULinkHandler *uh = new ULinkHandler(this);
+  uh->startULink(attrib);
+  m_children.append(uh);
+}
+
+void ParagraphHandler::startEMail(const QXmlAttributes& attrib)
+{
+  EMailHandler *eh = new EMailHandler(this);
+  eh->startEMail(attrib);
+  m_children.append(eh);
+}
+
+void ParagraphHandler::startLink(const QXmlAttributes& attrib)
+{
+  LinkHandler *lh = new LinkHandler(this);
+  lh->startLink(attrib);
+  m_children.append(lh);
+}
+
+void ParagraphHandler::startProgramListing(const QXmlAttributes& attrib)
+{
+  ProgramListingHandler *pl = new ProgramListingHandler(this);
+  pl->startProgramListing(attrib);
+  m_children.append(pl);
+}
+
 void ParagraphHandler::addTextNode()
 {
   if (!m_curString.isEmpty())

addon/xmlparse/dochandler.h

@@ -59,7 +59,12 @@ class DocNode
       VariableList,
       VariableListEntry,
       HRuler,
-      LineBreak
+      LineBreak,
+      ULink,
+      EMail,
+      Link,
+      ProgramListing,
+      CodeLine
     };
     DocNode(NodeKind k) : m_kind(k) {}
     virtual ~DocNode() {}
@@ -247,6 +252,67 @@ class LineBreakHandler : public DocNode, public BaseHandler<LineBreakHandler>
 
 //-----------------------------------------------------------------------------
 
+/* \brief Node representing a link to section
+ *
+ */
+class LinkHandler : public DocNode, public BaseHandler<LinkHandler>
+{
+  public:
+    LinkHandler(IBaseHandler *parent);
+    virtual ~LinkHandler();
+
+    void startLink(const QXmlAttributes& attrib);
+    void endLink();
+
+  private:
+    IBaseHandler   *m_parent;
+    QString         m_ref;
+    QString         m_text;
+};
+
+
+//-----------------------------------------------------------------------------
+
+/* \brief Node representing a link to an email address
+ *
+ */
+class EMailHandler : public DocNode, public BaseHandler<EMailHandler>
+{
+  public:
+    EMailHandler(IBaseHandler *parent);
+    virtual ~EMailHandler();
+
+    void startEMail(const QXmlAttributes& attrib);
+    void endEMail();
+
+  private:
+    IBaseHandler   *m_parent;
+    QString         m_address;
+};
+
+
+//-----------------------------------------------------------------------------
+
+/* \brief Node representing a link to an URL
+ *
+ */
+class ULinkHandler : public DocNode, public BaseHandler<ULinkHandler>
+{
+  public:
+    ULinkHandler(IBaseHandler *parent);
+    virtual ~ULinkHandler();
+
+    void startULink(const QXmlAttributes& attrib);
+    void endULink();
+
+  private:
+    IBaseHandler   *m_parent;
+    QString         m_url;
+    QString         m_text;
+};
+
+//-----------------------------------------------------------------------------
+
 /* \brief Node representing a horizontal ruler
  *
  */
@@ -385,15 +451,56 @@ class VariableListHandler : public DocNode, public BaseHandler<VariableListHandl
 
 //-----------------------------------------------------------------------------
 
+class CodeLineHandler : public DocNode, public BaseHandler<CodeLineHandler>
+{
+  public:
+
+    virtual void startCodeLine(const QXmlAttributes&);
+    virtual void endCodeLine();
+    virtual void startLineNumber(const QXmlAttributes&);
+    virtual void endLineNumber();
+    
+    CodeLineHandler(IBaseHandler *parent);
+    virtual ~CodeLineHandler();
+  private:
+    IBaseHandler   *m_parent;
+    int            m_lineNumber;
+    QString        m_anchor;
+    QString        m_ref;
+    QList<DocNode> m_children;
+};
+
+//-----------------------------------------------------------------------------
+
+/*! \brief Node representing a program listing
+ *
+ */
+class ProgramListingHandler : public DocNode, public BaseHandler<ProgramListingHandler>
+{
+  public:
+    virtual void startProgramListing(const QXmlAttributes& attrib);
+    virtual void endProgramListing();
+    virtual void startCodeLine(const QXmlAttributes&);
+    virtual void startLineNumber(const QXmlAttributes&);
+
+    ProgramListingHandler(IBaseHandler *parent);
+    virtual ~ProgramListingHandler();
+  private:
+    IBaseHandler   *m_parent;
+    QList<CodeLineHandler> m_children;
+    bool m_hasLineNumber;
+};
+
+//-----------------------------------------------------------------------------
+
 /*! \brief Node representing a paragraph of text and commands.
  *
  */
 // children: itemizedlist, orderedlist, parameterlist, simplesect, ref,
-//           variablelist, hruler, linebreak,
+//           variablelist, hruler, linebreak, ulink, email, link
 // TODO:
-//           ulink, email, link
-//           table,
 //           programlisting, 
+//           table,
 //           indexentry, formula, image, dotfile
 // children handled by MarkupHandler: 
 //           bold, computeroutput, emphasis, center,
@@ -411,6 +518,10 @@ class ParagraphHandler : public DocNode, public BaseHandler<ParagraphHandler>
     virtual void startVariableList(const QXmlAttributes& attrib);
     virtual void startHRuler(const QXmlAttributes& attrib);
     virtual void startLineBreak(const QXmlAttributes& attrib);
+    virtual void startULink(const QXmlAttributes& attrib);
+    virtual void startEMail(const QXmlAttributes& attrib);
+    virtual void startLink(const QXmlAttributes& attrib);
+    virtual void startProgramListing(const QXmlAttributes& attrib);
 
     ParagraphHandler(IBaseHandler *parent);
     virtual ~ParagraphHandler();

doc/arch.doc

@@ -14,9 +14,9 @@
  * input used in their production; they are not affected by this license.
  *
  */
-/*! \page arch
+/*! \page arch Doxygen's Internals
 
-\section arch Doxygen's Internals 
+<h3>Doxygen's internals</h3>
 
 <B>Note that this section is still under construction!</B>
 

examples/group.cpp

@@ -12,7 +12,7 @@ class C2 {};
 /** function in group 1 */
 void func() {}
 
-/** @} end of group1 */
+/** @} */ // end of group1
 
 /**
  *  @defgroup group2 The Second Group
@@ -70,7 +70,7 @@ namespace N1 {};
  *  Text of the second section
  */
 
-/** @} */
+/** @} */ // end of group5
 
 /** @addtogroup group1
  *  
@@ -84,5 +84,5 @@ void func2() {}
 /** yet another function in group 1 */
 void func3() {}
 
-/** @} */
+/** @} */ // end of group1
 

packages/rpm/doxygen.spec

 Name: doxygen
-Version: 1.2.10_20010923
+Version: 1.2.11
 Summary: documentation system for C, C++ and IDL
 Release: 4
 Source: doxygen-%{version}.src.tar.gz

src/classdef.cpp

@@ -2342,21 +2342,12 @@ QCString ClassDef::qualifiedNameWithTemplateParameters(
 
 QCString ClassDef::className() const
 {
-  if (!m_className.isEmpty())
-  {
-    return m_className;
-  }
-  else
-  {
-    ClassDef *that = (ClassDef *)this; 
-    // m_className is a cache value, so we fake that this function is "const".
-    that->m_className=m_localName.copy();
+  QCString className=m_localName;
   Definition *p=getOuterScope();
   while (p && p->definitionType()==TypeClass)
   {
-      that->m_className.prepend(p->localName()+"::");
+    className.prepend(p->localName()+"::");
     p=p->getOuterScope();
   }
-    return m_className;
-  }
+  return className;
 };

src/classdef.h

@@ -401,8 +401,6 @@ class ClassDef : public Definition
     /*! Is this an abstact class? */
     bool m_isAbstract;
 
-    QCString m_className;
-
     /*! Is the class part of an unnamed namespace? */
     bool m_isStatic;
 };

src/classlist.cpp

@@ -35,18 +35,22 @@ int ClassList::compareItems(GCI item1, GCI item2)
 {
   ClassDef *c1=(ClassDef *)item1;
   ClassDef *c2=(ClassDef *)item2;
-  return stricmp(c1->localName().data()+getPrefixIndex(c1->localName()),
-                 c2->localName().data()+getPrefixIndex(c2->localName())
-                );
+  //return stricmp(c1->localName().data()+getPrefixIndex(c1->localName()),
+  //               c2->localName().data()+getPrefixIndex(c2->localName())
+  //              );
+  return stricmp(c1->className().data()+getPrefixIndex(c1->className()),
+                 c2->className().data()+getPrefixIndex(c2->className()));
 }
 
 int ClassSDict::compareItems(GCI item1, GCI item2)
 {
   ClassDef *c1=(ClassDef *)item1;
   ClassDef *c2=(ClassDef *)item2;
-  return stricmp(c1->localName().data()+getPrefixIndex(c1->localName()),
-                 c2->localName().data()+getPrefixIndex(c2->localName())
-                );
+  //return stricmp(c1->localName().data()+getPrefixIndex(c1->localName()),
+  //               c2->localName().data()+getPrefixIndex(c2->localName())
+  //              );
+  return stricmp(c1->className().data()+getPrefixIndex(c1->className()),
+                 c2->className().data()+getPrefixIndex(c2->className()));
 }
 
 ClassListIterator::ClassListIterator(const ClassList &cllist) :

src/code.l

@@ -240,6 +240,7 @@ static void endCodeLine()
  */
 static void codifyLines(char *text)
 {
+  //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text);
   char *p=text,*sp=p;
   char c;
   bool done=FALSE;

src/doc.l

@@ -143,6 +143,7 @@ static void initParser()
 //-----------------------------------------------------------------------------
 
 void scanString(const char *s);
+void scanDoc(const char *s);
 void internalParseDocument(const char *s);
 
 //-----------------------------------------------------------------------------
@@ -324,7 +325,7 @@ static void verbIncludeFile(OutputDocInterface &od,const char *name)
   if ((fd=findFileDef(Doxygen::exampleNameDict,name,ambig)))
   {
     od.startCodeFragment();
-    od.codify(fileToString(fd->absFilePath()));
+    od.codify(fileToString(fd->absFilePath())+"\n");
     od.endCodeFragment();
   }
   else if (ambig)
@@ -909,7 +910,7 @@ TT	  [tT][tT]
 UL	  [uU][lL]
 VAR	  [vV][aA][rR]
 BLOCKQUOTE [bB][lL][oO][cC][kK][qQ][uU][oO][tT][eE]
-DOCPARAM  ([a-z_A-Z0-9:\<\>\=\.\-]+)|("\"".*"\"")
+DOCPARAM  ("#")?([a-z_A-Z0-9:\<\>\=\.\-]+)|("\"".*"\"")
 OPNEW     {B}+"new"({B}*"[]")?
 OPDEL     {B}+"delete"({B}*"[]")?
 OPARG     "("[a-z_A-Z0-9,\<\> \t\*\&]*")"
@@ -1567,14 +1568,14 @@ OPMASK    ({B}*{OPNORM}({OPARG}?))|({OPCAST}{OPARG})
 <DocScan>"\\capt".*
 <DocParam>({DOCPARAM}{BN}*","{BN}*)*{DOCPARAM}{BSEP}* {
 					  outDoc->startDescTableTitle();
-  					  outDoc->docify(substitute(yytext,"\"","").stripWhiteSpace()); 
+					  scanDoc(substitute(yytext,"\"","").stripWhiteSpace());
 					  outDoc->endDescTableTitle();
 					  outDoc->startDescTableData();
 					  BEGIN(DocScan);
   					}
 <DocException>{SCOPENAME}		{
 					  outDoc->startDescTableTitle();
-  					  outDoc->docify(yytext); 
+  					  generateRef(*outDoc,className,yytext,FALSE);
 					  outDoc->endDescTableTitle();
 					  outDoc->startDescTableData();
 					  BEGIN(DocScan);
@@ -1938,6 +1939,7 @@ OPMASK    ({B}*{OPNORM}({OPARG}?))|({OPCAST}{OPARG})
 					  }
 					}
 <DocCodeBlock>{BN}*{CMD}"endcode"/[^a-z_A-Z0-9]  { // needed to match things like \endcode. (note the dot)
+  					  codeBlock+="\n";
 				          parseCode(*outDoc,className,codeBlock,exampleDoc,exampleName);
 					  //printf("Code block\n-------------\n%s\n--------------\n",codeBlock.data());
 					  outDoc->endCodeFragment();
@@ -2449,6 +2451,24 @@ void scanString(const char *s)
   BEGIN( oldRule );
 }
 
+void scanDoc(const char *s)
+{
+  const char *oldInputString = inputString;
+  int oldInputPosition = inputPosition;
+  int oldRule = YY_START;
+  YY_BUFFER_STATE oldBuffer = YY_CURRENT_BUFFER;
+  yy_switch_to_buffer(yy_create_buffer(docYYin, YY_BUF_SIZE));  
+  inputString  = s;
+  inputPosition = 0;
+  BEGIN( DocScan );
+  docYYlex();
+  yy_delete_buffer(YY_CURRENT_BUFFER);
+  yy_switch_to_buffer(oldBuffer);
+  inputString = oldInputString;
+  inputPosition = oldInputPosition;
+  BEGIN( oldRule );
+}
+
 void internalParseDocument(const char *s)
 {
   const char *oldInputString = inputString;

src/doxygen.cpp

@@ -937,7 +937,7 @@ static void buildClassList(Entry *root)
 
         // add class to the list
         //printf("ClassDict.insert(%s)\n",resolveDefines(fullName).data());
-        Doxygen::classSDict.inSort(fullName,cd);
+        Doxygen::classSDict.append(fullName,cd);
 
         // also add class to the correct structural context 
         Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,fullName);
@@ -2543,7 +2543,7 @@ static void findUsedClassesForClass(Entry *root,
                      masterCd->getDefFileName(),masterCd->getDefLine(),
                      usedName,ClassDef::Class);
                   //usedCd->setIsTemplateBaseClass(count);
-                  Doxygen::hiddenClasses.inSort(usedName,usedCd);
+                  Doxygen::hiddenClasses.append(usedName,usedCd);
                 }
                 if (isArtificial) usedCd->setClassIsArtificial();
                 instanceCd->addUsedClass(usedCd,md->name());
@@ -2600,7 +2600,7 @@ static void findUsedClassesForClass(Entry *root,
              usedCd = new ClassDef(
                masterCd->getDefFileName(),masterCd->getDefLine(),
                type,ClassDef::Class);
-             Doxygen::hiddenClasses.inSort(type,usedCd);
+             Doxygen::hiddenClasses.append(type,usedCd);
           }
           if (isArtificial) usedCd->setClassIsArtificial();
           instanceCd->addUsedClass(usedCd,md->name()); 
@@ -2700,7 +2700,7 @@ static bool findTemplateInstanceRelation(Entry *root,
 
   if (freshInstance)
   {
-    Doxygen::classSDict.inSort(instanceClass->name(),instanceClass);
+    Doxygen::classSDict.append(instanceClass->name(),instanceClass);
     instanceClass->setTemplateBaseClassNames(templateNames);
 
     // search for new template instances caused by base classes of 
@@ -2967,7 +2967,7 @@ static bool findClassRelation(
             {
               baseClass=new ClassDef(root->fileName,root->startLine,
                                  baseClassName,ClassDef::Class);
-              Doxygen::hiddenClasses.inSort(baseClassName,baseClass);
+              Doxygen::hiddenClasses.append(baseClassName,baseClass);
               if (isArtificial) baseClass->setClassIsArtificial();
             }
           }
@@ -2975,7 +2975,7 @@ static bool findClassRelation(
           {
             baseClass=new ClassDef(root->fileName,root->startLine,
                                  baseClassName,ClassDef::Class);
-            Doxygen::classSDict.inSort(baseClassName,baseClass);
+            Doxygen::classSDict.append(baseClassName,baseClass);
             if (isArtificial) baseClass->setClassIsArtificial();
           }
           // add base class to this class
@@ -4413,14 +4413,14 @@ static void findMember(Entry *root,
           !findGlobalMember(root,namespaceName,funcName,funcTempList,funcArgs,funcDecl))
       {
         warn(root->fileName,root->startLine,
-             "Warning: class for member %s cannot "
+             "Warning: class for member `%s' cannot "
              "be found.", funcName.data()
             ); 
       }
       else if (!className.isEmpty())
       {
         warn(root->fileName,root->startLine,
-             "Warning: member %s of class %s cannot be found",
+             "Warning: member `%s' of class `%s' cannot be found",
              funcName.data(),className.data());
       }
     }
@@ -7130,9 +7130,11 @@ void parseInput()
   msg("Search for main page...\n");
   findMainPage(root);
 
-  msg("Sorting member lists...\n");
+  msg("Sorting lists...\n");
   Doxygen::memberNameList.sort();
   Doxygen::functionNameList.sort();
+  Doxygen::hiddenClasses.sort();
+  Doxygen::classSDict.sort();
   
   msg("Freeing entry tree\n");
   delete root;

src/latexgen.cpp

@@ -160,16 +160,17 @@ void LatexGenerator::init()
     << endl
     << "refman.ps: refman.dvi" << endl
     << "\tdvips -o refman.ps refman.dvi" << endl
-    << endl
-    << "refman.pdf: refman.ps" << endl;
+    << endl;
     if (Config_getBool("USE_PDFLATEX")) // use pdflatex instead of latex
     {
+      t << "refman.pdf: refman.tex" << endl;
       t << "\tpdflatex refman.tex" << endl;
       t << "\tmakeindex refman.idx" << endl;
       t << "\tpdflatex refman.tex" << endl << endl;
     }
     else // otherwise use ps2pdf: not as nice :(
     {
+      t << "refman.pdf: refman.ps" << endl;
 #if defined(_MSC_VER)
       // ps2pdf.bat does not work properly from a makefile using GNU make!
       t << "\tgswin32c -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite "

src/memberdef.cpp

@@ -288,7 +288,7 @@ MemberDef::MemberDef(const char *df,int dl,
   args=a;
   args=removeRedundantWhiteSpace(args);
   if (type.isEmpty()) decl=name()+args; else decl=type+" "+name()+args;
-  declLine=0;
+  //declLine=0;
   memberGroup=0;
   virt=v;
   prot=p;

src/memberdef.h

@@ -255,8 +255,8 @@ class MemberDef : public Definition
     QCString init;            // initializer
     int initLines;            // number of lines in the initializer
     QCString decl;            // member declaration in class
-    QCString declFile;        // file where the declaration was found
-    int      declLine;        // line where the declaration was found
+    //QCString declFile;        // file where the declaration was found
+    //int      declLine;        // line where the declaration was found
     QCString def;             // member definition in code (fully qualified name)
     QCString anc;             // HTML anchor name
     Specifier virt;           // normal/virtual/pure virtual

src/sortdict.h

@@ -23,6 +23,45 @@
 #include <qlist.h>
 #include <qdict.h>
 
+#define AUTORESIZE 1
+
+#if AUTORESIZE
+const uint SDict_primes[] = 
+{
+  17,
+  29,
+  47,
+  71,
+  113,
+  179,
+  293,
+  457,
+  733,
+  1171,
+  1871,
+  2999,
+  4787,
+  7669,
+  12251,
+  19603,
+  31379,
+  50177,
+  80287,
+  128449,
+  205519,
+  328829,
+  526139,
+  841801,
+  1346881,
+  2155007,
+  3448033,
+  5516827,
+  8826919,
+  14123059,
+  0xffffffff
+};
+#endif
+
 template<class T> class SDict;
 
 /*! internal wrapper class that redirects compareItems() to the 
@@ -51,16 +90,22 @@ class SDict
   private:
     SList<T> *m_list;
     QDict<T> *m_dict;
+    int m_sizeIndex;
     
   public:
     /*! Create an ordered dictionary.
      *  \param size The size of the dictionary. Should be a prime number for
      *              best distribution of elements.
      */
-    SDict(int size) 
+    SDict(int size) : m_sizeIndex(0)
     {
       m_list = new SList<T>(this);
+#if AUTORESIZE
+      while ((uint)size>SDict_primes[m_sizeIndex]) m_sizeIndex++;
+      m_dict = new QDict<T>(SDict_primes[m_sizeIndex]);
+#else
       m_dict = new QDict<T>(size);
+#endif
     }
     /*! Destroys the dictionary */
     virtual ~SDict() 
@@ -78,6 +123,12 @@ class SDict
     {
       m_list->append(d);
       m_dict->insert(key,d);
+#if AUTORESIZE
+      if (m_dict->size()>SDict_primes[m_sizeIndex])
+      {
+        m_dict->resize(SDict_primes[++m_sizeIndex]);
+      }
+#endif
     }
     /*! Sorts the members of the dictionary. First appending a number
      *  of members and then sorting them is faster (O(NlogN) than using 
@@ -96,6 +147,12 @@ class SDict
     {
       m_list->inSort(d);
       m_dict->insert(key,d);
+#if AUTORESIZE
+      if (m_dict->size()>SDict_primes[m_sizeIndex])
+      {
+        m_dict->resize(SDict_primes[++m_sizeIndex]);
+      }
+#endif
     }
     /*! Indicates whether or not the dictionary owns its elements */
     void setAutoDelete(bool val)

src/util.cpp

@@ -891,26 +891,29 @@ void setAnchors(char id,MemberList *ml,int groupId)
 
 //----------------------------------------------------------------------------
 
+/*! takes the \a buf of the given lenght \a len and converts CR LF (DOS)
+ * or CR (MAC) line ending to LF (Unix).  Returns the length of the
+ * converted content (i.e. the same as \a len (Unix, MAC) or
+ * smaller (DOS).
+ */
 int filterCRLF(char *buf,int len)
 {
-  char *ps=buf;
-  char *pd=buf;
-  char c;
-  int i;
-  for (i=0;i<len;i++)
-  {
-    c=*ps++;
-    if (c=='\r')
+  int src = 0;    // source index
+  int dest = 0;   // destination index
+  char c;         // current character
+
+  while (src<len)
   {
-      if (*ps=='\n') ps++; // DOS: CR+LF -> LF
-      *pd++='\n'; // MAC: CR -> LF
-    }
-    else
+    c = buf[src++];            // Remember the processed character.
+    if (c == '\r')             // CR to be solved (MAC, DOS)
     {
-      *pd++=c;
+      c = '\n';                // each CR to LF
+      if (src<len && buf[src] == '\n')
+        ++src;                 // skip LF just after CR (DOS) 
     }
+    buf[dest++] = c;           // copy the (modified) character to dest
   }
-  return len+pd-ps;
+  return dest;                 // length of the valid part of the buf
 }
 
 /*! reads a file with name \a name and returns it as a string. If \a filter