initial version

1 files changed, 3386 insertions, 0 deletions

diff --git a/src/scanner.l b/src/scanner.l
new file mode 100644
index 0000000..0beadae
--- /dev/null
+++ b/src/scanner.l
@@ -0,0 +1,3386 @@
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+  
+%{
+
+/*
+ *	includes
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <qarray.h>
+#include <qstring.h>  
+#include <qstack.h>
+#include <qregexp.h>
+  
+#include "scanner.h"
+#include "entry.h"
+#include "doxygen.h"
+#include "message.h"
+#include "config.h"
+#include "util.h"
+#include "index.h"
+#include "defargs.h"
+#include "language.h"
+
+#ifndef WIN32
+#include <unistd.h>
+#endif
+  
+#define YY_NEVER_INTERACTIVE 1
+  
+/* -----------------------------------------------------------------
+ *
+ *	statics
+ */
+static bool             insideArgumentList;
+static QString          className;
+static QString          memberName;
+static QString          refName;
+static OutputList *     outDoc;
+static QString          code;
+static QString          linkRef;
+static QString          linkText;
+static QString          codeBlock;
+static const char *     inputString;
+static int		inputPosition;
+static int		lastContext;
+static int		lastCContext;
+static int              lastDocContext;
+static int              lastDocRelContext;
+static int              lastCPPContext;
+static int              lastSkipSharpContext;
+static int              lastSkipRoundContext;
+static int              lastBriefContext;
+static int              lastVerbState;
+static int              lastStringContext;
+static int              lastCurlyContext;
+static int              lastCodeState;
+static int              lastAfterDocContext;
+static int              lastGroupContext;
+static int              lastFormulaContext;
+static int              nextDefContext;
+static Protection	protection;
+static Protection	baseProt;
+static int		bracketCount = 0 ;
+static int		sharpCount   = 0 ;
+static int		roundCount   = 0 ;
+static int              ifCount      = 0 ;
+static Entry*		current_root = 0 ;
+static Entry*		global_root  = 0 ;
+static Entry*		current      = 0 ;
+static int		yyLineNr     = 0 ;
+static int              anonCount    = 0 ;        
+static char		yyFileName[2048] ;
+static bool    		sig;
+static bool    		slot;
+static bool    		gstat;
+static bool             removeSlashes;
+static Specifier 	virt;
+static Specifier 	baseVirt;
+static bool             exampleDoc;
+static QString          exampleName;
+static QString          htmlUrl,htmlText;
+static QString          currentIncludeFile;
+static QString          msType,msName,msArgs;
+static int              includeFileOffset = 0;
+static int              includeFileLength = 0;
+static bool             firstLine;
+static bool             isTypedef;
+static bool             inParamBlock;
+static bool             inExceptionBlock;
+static bool             inSeeBlock;
+static bool             inReturnBlock;
+static bool             inAuthorBlock;
+static bool             inVersionBlock;
+static bool             inDateBlock;
+static bool             inBugBlock;
+static bool             inWarningBlock;
+static bool             inParBlock;
+static bool             firstSeeArg;
+static bool             javaDocSee;
+static char             afterDocTerminator;
+static int              tmpDocType;
+static QString          sectionLabel;
+static QString		sectionTitle;
+static bool             isSubsection;
+static QString          funcPtrType;
+static QString          templateStr;
+static QString          baseName;
+static QString         *specName;
+static QString          formulaText;
+static QString          sectionRef;
+
+// state variable for reading the argument list of a function
+static int              argRoundCount;
+static int              argSharpCount;
+static int              currentArgumentContext;
+static int              lastCopyArgStringContext;
+static int              lastCopyArgContext;
+static QString         *copyArgString;
+
+
+
+//-----------------------------------------------------------------------------
+
+static void initParser()
+{
+  insideArgumentList=FALSE;
+  className.resize(0);
+  memberName.resize(0);
+  refName.resize(0);
+  code.resize(0);
+  linkRef.resize(0);
+  linkText.resize(0);
+  codeBlock.resize(0);
+  htmlUrl.resize(0);
+  htmlText.resize(0);
+  currentIncludeFile.resize(0);
+  sectionLabel.resize(0);
+  sectionTitle.resize(0);
+  baseName.resize(0);
+  formulaText.resize(0);
+  protection = Public;
+  baseProt = Public;
+  bracketCount = 0;
+  sharpCount = 0;
+  roundCount = 0;
+  ifCount = 0;
+  sig = FALSE;
+  slot = FALSE;
+  gstat = FALSE;
+  virt = Normal;
+  baseVirt = Normal;
+  includeFileOffset = 0;
+  includeFileLength = 0;
+  firstLine = TRUE;
+  isTypedef = FALSE;
+  inParamBlock = FALSE;
+  inExceptionBlock = FALSE;
+  inSeeBlock = FALSE;
+  inReturnBlock = FALSE;
+  inAuthorBlock = FALSE;
+  inVersionBlock = FALSE;
+  inDateBlock = FALSE;
+  inBugBlock = FALSE;
+  inWarningBlock = FALSE;
+  inParBlock = FALSE;
+  firstSeeArg = FALSE;
+  javaDocSee = FALSE;
+  isSubsection = FALSE;
+}
+
+//-----------------------------------------------------------------------------
+
+void scanString(const char *s);
+
+//-----------------------------------------------------------------------------
+
+class TableElem
+{
+  public:
+    TableElem(int r,int c);
+   ~TableElem();
+    int getRow() { return row; }
+    int getCol() { return col; }
+    OutputList *outputList() { return ol; }
+   
+  private:
+    OutputList *ol;
+    int row;
+    int col;
+};
+
+TableElem::TableElem(int r,int c)
+{
+  //printf("TableElem::TableElem(%d,%d)\n",r,c);
+  ol=new OutputList(outDoc);
+  outDoc=ol;
+  row=r;
+  col=c;
+}
+
+TableElem::~TableElem()
+{
+  //printf("TableElem::~TableElem(%d,%d)\n",row,col);
+  delete ol; 
+}
+
+class Table
+{
+  public:
+    Table();
+   ~Table();
+    void newRow();
+    void newElem();
+    
+  private:
+    OutputList *parentDoc;
+    QList<TableElem> *elemList;
+    int curRow;
+    int curCol;
+    int rows;
+    int cols;
+};  
+
+Table::Table() 
+{
+  parentDoc=outDoc;
+  elemList=new QList<TableElem>;
+  elemList->setAutoDelete(TRUE);
+  curRow=curCol=rows=cols=0;
+}
+
+Table::~Table()
+{
+  //printf("Table::~Table()\n");
+  // use elemList & cols & rows
+  if (cols>0 && rows>0)
+  {
+    parentDoc->startTable(cols);
+    TableElem *e=elemList->first();
+    while (e)
+    {
+      if (e->getRow()>0)
+      {
+	if (e->getCol()==0) 
+	{
+	  if (e->getRow()>1) parentDoc->endTableRow();
+	  parentDoc->nextTableRow();
+	}
+	else
+	{
+	  parentDoc->nextTableColumn();
+	}
+	*parentDoc+=*e->outputList();
+	parentDoc->endTableColumn();
+      }
+      e=elemList->next();
+    }
+    parentDoc->endTable();
+  }
+  delete elemList;
+  outDoc=parentDoc;
+}
+
+void Table::newRow()
+{
+  //printf("Table::newRow()\n");
+  curRow++;
+  if (curRow>rows) rows=curRow;
+  curCol=0;
+}
+
+void Table::newElem()
+{
+  //printf("Table::newElem(%d,%d)\n",curRow,curCol);
+  TableElem *te = new TableElem(curRow,curCol);
+  elemList->append(te);
+
+  curCol++;
+  if (curCol>cols) cols=curCol;
+}
+
+static QStack<Table> tableStack;
+static Table *curTable;
+
+static void startTable()
+{
+  //printf("startTable()\n");
+  curTable=new Table;
+  tableStack.push(curTable);
+}
+
+static void endTable()
+{
+  //printf("endTable()\n");
+  delete tableStack.pop(); // the destructor adds the table to the stream!
+  curTable=tableStack.top();
+}
+
+//-----------------------------------------------------------------------------
+
+static void lineCount()
+{
+  for( const char* c = yytext ; *c ; ++c )
+    yyLineNr += (*c == '\n') ;
+}
+
+static void endArgumentList()
+{
+  if (insideArgumentList)
+  {
+    insideArgumentList=FALSE;
+    outDoc->endItemList();
+  }
+}
+
+static void addType( Entry* current )
+{
+    if( current->type.length() )
+	current->type += ' ' ;
+    current->type += current->name ;
+    current->name.resize(0) ;
+    if( current->type.length() )
+	current->type += ' ' ;
+    current->type += current->args ;
+    current->args.resize(0) ;
+    current->argList->clear();
+}
+
+static void includeFile(OutputList &ol,const char *fileName,bool quiet)
+{
+  //FileInfo *f;
+  bool ambig;
+  FileDef *fd;
+  if ((fd=findFileDef(&exampleNameDict,fileName,ambig)))
+  {
+    currentIncludeFile=fileToString(fd->absFilePath());
+    includeFileOffset=0;
+    includeFileLength=currentIncludeFile.length();
+    OutputList codeFrag(&ol);
+    parseCode(codeFrag,0,currentIncludeFile,exampleDoc,exampleName);
+    if (!quiet)
+    {
+      ol.startCodeFragment();
+      ol+=codeFrag;
+      ol.endCodeFragment();
+    }
+  }
+  else if (ambig)
+  {
+    warn("Include file name %s is ambigious.\n",fileName);
+    warn("Possible candidates:\n");
+    //includeFileList.writeMatches(fileName);
+    showFileDefMatches(&exampleNameDict,fileName);
+  }
+  else
+  {
+    warn("Warning: example file %s is not found. ",fileName);
+    warn("Check your EXAMPLE_PATH\n");
+  }
+}
+
+static void verbIncludeFile(OutputList &ol,const char *name)
+{
+  //FileInfo *f;
+  bool ambig;
+  FileDef *fd;
+  if ((fd=findFileDef(&exampleNameDict,name,ambig)))
+  {
+    ol.startCodeFragment();
+    ol.codify(fileToString(fd->absFilePath()));
+    ol.endCodeFragment();
+  }
+  else if (ambig)
+  {
+    warn("Include file name %s is ambigious.\n",name);
+    warn("Possible candidates:\n");
+    showFileDefMatches(&exampleNameDict,name);
+  }
+  else
+  {
+    warn("Warning: example file %s is not found. ",name);
+    warn("Check your EXAMPLE_PATH\n");
+  }
+}
+
+
+static QString stripQuotes(const char *s)
+{
+  QString name;
+  if (s==0 || *s==0) return name;
+  name=s;
+  if (name.at(0)=='"' && name.at(name.length()-1)=='"')
+  {
+    name=name.mid(1,name.length()-2);
+  }
+  return name;
+}
+
+static QString stripKnownExtensions(const char *text)
+{
+  QString result=text;
+  if (result.right(4)==".tex")       result=result.left(result.length()-4);
+  else if (result.right(5)==".html") result=result.left(result.length()-5);
+  //printf("%s stripKnowExtensions(%s)\n",result.data(),text); 
+  return result;
+}
+
+static void skipLine(OutputList &ol,const char *key)
+{
+  bool found=FALSE;
+  while (!found)
+  {
+    QString s;
+    char c;
+    while ( includeFileOffset<includeFileLength && 
+	    (c=currentIncludeFile[includeFileOffset++])!='\n' && c!=0
+	  ) s+=c;
+    if (s.find(key)!=-1)
+    {
+      found=TRUE;
+      ol.writeString("    ");
+      parseCode(ol,className,s,exampleDoc,exampleName);
+      ol.writeString("\n");
+    }
+    else if (includeFileOffset==includeFileLength) found=TRUE;
+  }
+}
+
+static void skipUntil(const char *key)
+{
+  bool found=FALSE;
+  while (!found)
+  {
+    QString s;
+    int i=includeFileOffset;
+    char c;
+    while ( i<includeFileLength &&
+	    (c=currentIncludeFile[i++])!='\n' && c!=0
+	  ) s+=c;
+    if (s.find(key)!=-1 || i==includeFileLength)
+    {
+      found=TRUE;
+    }
+    else
+    {
+      includeFileOffset=i;
+    }
+  }
+}
+
+static void showLine(OutputList &ol,const char *key)
+{
+  QString s;
+  char c;
+  bool found=FALSE;
+  while (!found)
+  {
+    while ( includeFileOffset<includeFileLength && 
+	(c=currentIncludeFile[includeFileOffset++])!='\n' && c!=0
+	  ) s+=c;
+    if (s.stripWhiteSpace().length()>0 || 
+	includeFileOffset==includeFileLength) found=TRUE;
+  }
+  if (s.find(key)!=-1)
+  {
+    ol.writeString("    ");
+    parseCode(ol,className,s,exampleDoc,exampleName);
+    ol.writeString("\n");
+  }
+}
+
+static void showUntil(OutputList &ol,const char *key)
+{
+  bool found=FALSE;
+  while (!found)
+  {
+    QString s;
+    char c;
+    while ( includeFileOffset<includeFileLength && 
+	    (c=currentIncludeFile[includeFileOffset++])!='\n' && c!=0
+	  ) s+=c;
+    if (s.stripWhiteSpace().length()>0)
+    {
+      ol.writeString("    ");
+      parseCode(ol,className,s,exampleDoc,exampleName);
+      ol.writeString("\n");
+      if (s.find(key)!=-1) found=TRUE; 
+    }
+    if (includeFileOffset==includeFileLength) found=TRUE;
+  }
+}
+
+static void newDocState();
+
+//-----------------------------------------------------------------
+
+static bool inBlock()
+{
+  return inParamBlock || inSeeBlock || inReturnBlock || inAuthorBlock ||
+         inVersionBlock || inDateBlock || inWarningBlock || inBugBlock ||
+	 inParBlock || inExceptionBlock;
+}
+
+static void endBlock()
+{
+    outDoc->endDescList();
+    inParamBlock=inSeeBlock=inReturnBlock=inAuthorBlock=
+    inVersionBlock=inDateBlock=inBugBlock=inWarningBlock=
+    inParBlock=inExceptionBlock=FALSE;
+}
+
+static void addSection()
+{
+  //printf("New section pageName=%s label=%s title=%s\n",
+  //    current->name.data(),sectionLabel.data(),sectionTitle.data());
+  SectionInfo *si=new SectionInfo(current->name,
+                   sectionLabel,sectionTitle,isSubsection);
+  sectionDict.insert(sectionLabel,si);
+}
+
+
+// Adds a formula text to the list/dictionary of formulas if it was
+// not already added. Returns the label of the formula.
+static QString addFormula()
+{
+  QString formLabel;
+  QString fText=formulaText.simplifyWhiteSpace();
+  Formula *f=0;
+  if ((f=formulaDict[fText])==0)
+  {
+    f = new Formula(fText);
+    formulaList.append(f);
+    formulaDict.insert(fText,f);
+    formLabel.sprintf("\\form#%d",f->getId());
+    formulaNameDict.insert(formLabel,f);
+  }
+  else
+  {
+    formLabel.sprintf("\\form#%d",f->getId());
+  }
+  return formLabel;
+}
+
+/* -----------------------------------------------------------------
+ */
+#undef	YY_INPUT
+#define	YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
+
+static int yyread(char *buf,int max_size)
+{
+    int c=0;
+    while( c < max_size && inputString[inputPosition] )
+    {
+	*buf = inputString[inputPosition++] ;
+	//printf("%d (%c)\n",*buf,*buf);
+	c++; buf++;
+    }
+    return c;
+}
+
+//ATTR      ((({BN}+[^\>]+)/">")?)
+%}
+
+BN        [ \t\n\r]
+BL        [ \t\r]*"\n"
+B         [ \t]
+BS        ^(({B}*"//")?)(({B}*"*"+)?){B}*
+FILE      ([a-z_A-Z0-9\.\\:\/\-\+]+)|("\""[^\n\"]+"\"")
+FILEMASK  [a-z_A-Z0-9\.\\:\/\-\+]+"."[a-z_A-Z0-9\.\-\+]*[a-z_A-Z0-9\-\+]
+ID        [a-z_A-Z][a-z_A-Z0-9]*
+SCOPEID   {ID}({ID}*{BN}*"::"{BN}*)*({ID}?)
+SCOPENAME (({ID}?{BN}*"::"{BN}*)*)((~{BN}*)?{ID})
+SCOPEMASK {ID}?(("::"|"#")?(~)?{ID})+
+URLMASK   [a-z_A-Z0-9\~\:\@\#\.\-\+\/]+
+ATTR      ({B}+[^>\n]*)?
+A         [aA]
+BOLD	  [bB]
+BODY	  [bB][oO][dD][yY]
+BR	  [bB][rR]
+EM	  [eE][mM]
+CENTER    [cC][eE][nN][tT][eE][rR]
+CODE      [cC][oO][dD][eE]
+DL	  [dD][lL]
+DD	  [dD][dD]
+DT	  [dD][tT]
+DFN       [dD][fF][nN]
+FORM	  [fF][oO][rR][mM]
+H1	  [hH]1
+H2	  [hH]2
+H3	  [hH][3-6]
+HEAD	  [hH][eE][aA][dD]
+HR	  [hH][rR]
+HREF      [hH][rR][eE][fF]
+I         [iI]
+IMG       [iI][mM][gG]
+INPUT     [iI][nN][pP][uU][tT]
+LI	  [lL][iI]
+META	  [mM][eE][tT][aA]
+MULTICOL  [mM][uU][lL][tT][iI][cC][oO][lL]
+NAME      [nN][aA][mM][eE]
+OL        [oO][lL]
+P	  [pP]
+PRE       [pP][rR][eE]
+SMALL	  [sS][mM][aA][lL][lL]
+STRONG    [sS][tT][rR][oO][nN][gG]
+SUB	  [sS][uU][bB]
+SUP	  [sS][uU][pP]
+SRC       [sS][rR][cC]
+TABLE	  [tT][aA][bB][lL][eE]
+TITLE     [tT][iI][tT][lL][eE]
+TD	  [tT][dD]
+TR	  [tT][rR]
+TT	  [tT][tT]
+UL	  [uU][lL]
+VAR	  [vV][aA][rR]
+
+%x	Define
+%x      DefineArg
+%x	DefineEnd
+%x	Include
+%x	ClassName
+%x	ClassVar
+%x	Bases
+%x	NextSemi
+%x	FindMembers
+%x	FindMemberName
+%x      FindFields
+%x      FindFieldArg
+%x	Function
+%x	FuncRound
+%x	ExcpRound
+%x	FuncQual
+%x	Operator
+%x	Array
+%x	Curly
+%x	Using
+%x	NameSpaceDocArg1
+%x	SkipCurly
+%x	SkipCurlyCpp
+%x      SkipString
+%x	SkipInits
+%x	SkipCPP
+%x	SkipCPPBlock
+%x	SkipComment
+%x	SkipCxxComment
+%x      SkipBlock
+%x	SkipCode
+%x	Sharp
+%x      SkipSharp
+%x	SkipRound
+%x	TypedefName
+%x	Comment
+%x      Doc
+%x	JavaDoc
+%x      ClassDoc
+%x      LineDoc
+%x      DefLineDoc
+%x      ClassDocArg1
+%x      ClassDocArg2
+%x      ClassDocArg3
+%x      ClassDocFunc
+%x      ClassDocFuncPtr
+%x      ClassDocFuncQual
+%x      ClassDocFuncExc
+%x	ClassDocDefine
+%x      ClassDocRelates
+%x      ClassDocBrief
+%x      ClassDocOverload
+%x	ClassDefineArgs
+%x	GroupDocArg1
+%x	GroupDocArg2
+%x	GroupName
+%x	AfterDoc
+%x	AfterDocBrief
+%x	AfterDocLine
+%x      PageDoc
+%x      PageDocTitle
+%x      PageDocArg1
+%x      PageDocArg2
+%x      FileDocArg1
+%x      FileDocArg2
+%x      ExampleDoc
+%x	ExampleDocArg1
+%x      EnumDoc
+%x	EnumDocArg1
+%x	FuncPtr
+%x	EndFuncPtr
+%x	FuncFunc
+%x	FuncFuncEnd
+%x	FuncFuncType
+%x      MemberSpec
+%x      MemberSpecSkip
+%x	SkipVerbatim
+%x      DocScan
+%x	DocParam
+%x	DocException
+%x	DocHtmlScan
+%x	DocLatexScan
+%x      DocEmphasis
+%x      DocBold
+%x      DocCode
+%x      DocCodeBlock
+%x      DocInternal
+%x      DocLink
+%x      DocLinkText
+%x      DocSkipWord
+%x      DocInclude
+%x      DocDontInclude
+%x      DocDescItem
+%x      DocHtmlLink
+%x      DocHtmlAnchor
+%x      DocHtmlHref1
+%x      DocHtmlHref2
+%x	DocBaseClass
+%x	DocSkiplineKey
+%x	DocSkipKey
+%x	DocLineKey
+%x	DocUntilKey
+%x	DocKeyEnd
+%x	DocPar
+%x	DocRefName
+%x	DocVerbatim
+%x	DocVerbInc
+%x	DocIndexWord
+%x	DocRef
+%x      DocRefItem
+%x      DocRefItemName
+%x	SectionLabel
+%x	SectionTitle
+%x	EndTemplate
+%x      CopyArgString
+%x	CopyArgRound
+%x	CopyArgSharp
+%x	ReadFuncArgType
+%x	ReadTempArgs
+%x	Specialization
+%x      DocSkipHtmlComment
+%x      ReadFormulaShort
+%x	ReadFormulaLong
+
+%%
+
+<*>\x06[^\x06]*\x06			{ // new file
+  					  yyLineNr= 1 ; 
+					  int i; 
+					  for( i = 0 ; yytext[i+1] != 6 ; i++ )
+					    yyFileName[i] = yytext[i+1] ;
+					  yyFileName[i] = 0 ;
+					  msg("Parsing file %s...\n",yyFileName);
+					  current_root  = global_root ;
+					  initParser();
+					  current->reset();
+					  int sec=guessSection(yyFileName);
+					  if (sec)
+					  {
+					    current->name    = yyFileName;
+					    current->name    = current->name;
+					    current->section = sec;
+					    current_root->addSubEntry(current);
+					    current          = new Entry;
+					  }
+					  BEGIN( FindMembers );
+					}
+<*>\x0d
+  /*
+<DocScan>^{BL} 	                        { 
+  					  if (insideArgumentList)
+					  {
+					    insideArgumentList=FALSE;
+					    outDoc->endItemList();
+					  }
+					  else
+					  {
+					    outDoc->newParagraph();
+					  }
+					  if (inBlock()) endBlock();
+					}
+  */
+<DocScan>"<!--"				{ BEGIN(DocSkipHtmlComment); }
+<DocSkipHtmlComment>"--"[!]?">"		{ BEGIN(DocScan); }
+<DocSkipHtmlComment>.
+<DocScan>"&copy;"			{ outDoc->writeCopyright(); }
+<DocScan>"&quot;"			{ outDoc->writeQuote(); }
+<DocScan>"&"[AEIOUYaeiouy]"uml;"	{ outDoc->writeUmlaut(yytext[1]); }
+<DocScan>"&"[AEIOUYaeiouy]"acute;"	{ outDoc->writeAcute(yytext[1]);  }
+<DocScan>"&"[AEIOUaeiou]"grave;"	{ outDoc->writeGrave(yytext[1]);  }
+<DocScan>"&"[AEIOUaeiou]"circ;"		{ outDoc->writeCirc(yytext[1]);   }
+<DocScan>"&"[ANOano]"tilde;"		{ outDoc->writeTilde(yytext[1]);  }
+<DocScan,DocHtmlScan,DocLatexScan>"$("[a-z_A-Z]+")"	{ 
+  					  QString envvar=&yytext[2];
+  					  envvar=envvar.left(envvar.length()-1);
+					  outDoc->docify(getenv(envvar));
+					}
+<DocScan>("\\"|"@")"htmlonly"/[^a-z_A-Z0-9]	{
+  					  outDoc->disableAllBut(OutputGenerator::Html); 
+					  BEGIN(DocHtmlScan);
+  					}
+<DocHtmlScan>("\\"|"@")"endhtmlonly"/[^a-z_A-Z0-9] {
+  					  outDoc->enableAll();
+					  BEGIN(DocScan);
+  					}
+<DocScan>("\\"|"@")"latexonly"/[^a-z_A-Z0-9]	{
+  					  outDoc->disableAllBut(OutputGenerator::Latex);
+					  BEGIN(DocLatexScan);
+  					}
+<DocHtmlScan,DocLatexScan>"//"|"/*"|"*/"	{
+  					  outDoc->writeString(yytext);
+  					}
+<DocHtmlScan,DocLatexScan>.		{
+  					  char c[2];
+					  c[0]=*yytext;c[1]='\0';
+  					  outDoc->writeString(c);
+  					}
+<DocLatexScan>("\\"|"@")"endlatexonly"/[^a-z_A-Z0-9] {
+  					  outDoc->enableAll();
+					  BEGIN(DocScan);
+  					}
+<DocScan>"\\postheader"/{BN}
+<DocScan>"\\functionindex"/{BN}		{ writeMemberList(*outDoc); }
+<DocScan>"\\classhierarchy"/{BN}	{ writeClassHierarchy(*outDoc); }
+<DocScan>"\\annotatedclasslist"/{BN}	{ writeAnnotatedClassList(*outDoc); }
+<DocScan>"\\headerfilelist"/{BN}	{ /*TODO: fix this writeHeaderFileList(*outDoc); */ }
+<DocScan>"\\header"/{BN}                { BEGIN( DocSkipWord ); }
+<DocScan>"\\define"/{BN}	        { BEGIN( DocSkipWord ); }
+<DocScan>("\\"|"@")"verbinclude"/{BN}	{ BEGIN( DocVerbInc ); }
+<DocVerbInc>{FILE}			{
+  					  verbIncludeFile(*outDoc,stripQuotes(yytext));
+					  BEGIN( DocScan ); 
+  					}
+<DocScan>("\\"|"@")"verbatim"/[^a-z_A-Z0-9]	{
+  					  outDoc->startCodeFragment();
+					  BEGIN(DocVerbatim);
+  					}
+<DocVerbatim>("\\"|"@")"endverbatim"/[^a-z_A-Z0-9]	{
+  					  outDoc->endCodeFragment();
+  					  BEGIN(DocScan);
+  					}
+<DocVerbatim>[^\n\\]*"\n"		{
+  					  //printf("docifying: %s\n",yytext);
+  					  outDoc->codify(yytext);
+  					}
+<DocVerbatim>"\n"|"//"|"/*"|"*/"	{
+					  outDoc->codify(yytext);  
+  					}
+<DocVerbatim>.				{
+  					  //printf("char %c\n",*yytext);
+					  char c[2];c[0]=*yytext;c[1]='\0';
+  					  outDoc->codify(c);
+  					}
+<DocScan>("\\"|"@")"internal"/{BN}      { 
+					  if (!internalDocsFlag)
+					  {
+					    outDoc->newParagraph();
+					    scanString(theTranslator->trForInternalUseOnly()+"\n");
+					    //outDoc->writeString("For internal use only.\n");
+  					    BEGIN( DocInternal ); 
+					  }
+					}
+<DocScan>"\\reimp"/{BN}			{
+  					  outDoc->newParagraph();
+					  scanString(theTranslator->trReimplementedForInternalReasons()+"\n");
+  					}
+<DocScan>("\\"|"@")"link"/{BN}	        { BEGIN( DocLink ); }
+<DocSkipWord>[a-z_A-Z0-9.:()]+		{ BEGIN( DocScan ); }
+<DocLink>[a-z_A-Z0-9:#.~/()\-\+]+       { 
+  					  linkRef  = stripKnownExtensions(yytext);
+					  linkText = "";
+  					  BEGIN( DocLinkText ); 
+					}
+<DocLinkText>.				{ linkText += *yytext; }
+<DocLinkText>"\n"			{ linkText += " "; }
+<DocLink,DocLinkText>("\\"|"@")"endlink"/[^a-z_A-Z0-9] { // <- needed for things like \endlink. 
+					  generateLink(*outDoc,className,linkRef,inSeeBlock,linkText);
+  					  BEGIN( DocScan ); 
+					}
+<DocScan>"@ref"{B}+			{
+  					  BEGIN(DocRef);
+  					}
+<DocRef>{SCOPENAME}			{
+  					  generateLink(*outDoc,className,yytext,TRUE,0);
+					  BEGIN( DocScan );
+  					}
+<DocScan>("\\"|"@")"endlink"/[^a-z_A-Z0-9]      { warn("Warning: \\endlink without \\link "
+    					         "in documentation of %s\n", refName.data()); 
+					}
+<DocScan>("\\"|"@")"addindex"/{BN}		{
+  					  BEGIN(DocIndexWord);
+  					}
+<DocScan>"\\form#"[0-9]+		{
+  					  Formula *formula=formulaNameDict[yytext];
+					  if (formula)
+					  {
+					    QString formName;
+					    formName.sprintf("form-%d.gif",formula->getId());
+					    outDoc->writeFormula(formName,formula->getFormulaText());
+					  }
+  					}
+<DocIndexWord>[^\n\t ]+			{
+  					  //printf("Adding %s to index\n",yytext);
+					  outDoc->addToIndex(yytext,0);
+  					  BEGIN(DocScan);
+  					}
+<DocScan>("\\"|"@")"arg"{BN}+	        { 
+  					  if (insideArgumentList)
+					  {
+					    outDoc->writeListItem();
+					  }
+					  else 
+					  {
+					    outDoc->startItemList();
+					    outDoc->writeListItem();
+					    insideArgumentList=TRUE;
+					  }
+					}
+<DocScan>("\\"|"@")"par"{B}+			{
+  					  BEGIN(DocPar);
+  					}
+<DocPar>[^\n]*{BN}+			{
+  				          endArgumentList();
+					  if (inBlock()) endBlock();  
+					  inParBlock=TRUE;
+  					  outDoc->startDescList();
+					  outDoc->startBold();
+					  outDoc->docify(((QString)yytext).stripWhiteSpace());
+					  outDoc->endBold();
+					  outDoc->endDescTitle();
+					  outDoc->writeDescItem();
+					  BEGIN(DocScan);
+  					}
+<DocScan>("\\"|"@")"warning"{BN}+	{ 
+  				          endArgumentList();
+  					  if (!inWarningBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inWarningBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Warning: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trWarning()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+  					    outDoc->writeDescItem();
+					  }
+				        }
+<DocScan>("\\"|"@")"bug"{BN}+		{
+  				          endArgumentList();
+  					  if (!inBugBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inBugBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Bugs and limitations: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trBugsAndLimitations()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+  					    outDoc->writeDescItem();
+					  }
+  					}
+<DocScan>("\\"|"@")"version"{BN}+	{
+  				          endArgumentList();
+  					  if (!inVersionBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inVersionBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Version: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trVersion()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+  					    outDoc->writeDescItem();
+					  }
+  					}
+<DocScan>("\\"|"@")"date"{BN}+		{
+  				          endArgumentList();
+  					  if (!inDateBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inDateBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Date: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trDate()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+  					    outDoc->writeDescItem();
+					  }
+  					}
+<DocScan>("\\"|"@")"author"{BN}+	{
+  				          endArgumentList();
+  					  if (!inAuthorBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inAuthorBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Author(s): ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trAuthors()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+					    outDoc->docify(", ");
+					  }
+  					}
+<DocScan>("\\"|"@")"return"{BN}+	{
+  				          endArgumentList();
+  					  if (!inReturnBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inReturnBlock=TRUE;
+  					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Returns: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trReturns()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+  					}
+<DocScan>("\\sa"|"@see"){BN}+           { 
+  				          endArgumentList();
+  					  if (!inSeeBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inSeeBlock=TRUE;
+					    //firstSeeArg=TRUE;
+					    //javaDocSee=!strcmp(yytext,"@see");
+					    outDoc->startDescList();
+					    //outDoc->writeBoldString("See also: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trSeeAlso()+": ");
+					    outDoc->endBold();
+					    outDoc->endDescTitle();
+					    outDoc->writeDescItem();
+					  }
+					  else
+					  {
+					    outDoc->docify(", ");
+					  }
+					}
+<DocScan>("\\"|"@")"param"{BN}+		{
+  				          endArgumentList();
+  					  if (!inParamBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inParamBlock=TRUE;
+					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Parameters: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trParameters()+": ");
+					    outDoc->endBold();
+  					    outDoc->endDescTitle();
+					  }
+  				          BEGIN(DocParam); 
+  					}
+<DocScan>("\\"|"@")"exception"{BN}+	{
+  					  endArgumentList();
+					  if (!inExceptionBlock)
+					  {
+					    if (inBlock()) endBlock();
+					    inExceptionBlock=TRUE;
+					    outDoc->startDescList();
+					    //outDoc->writeBoldString("Exceptions: ");
+					    outDoc->startBold();
+					    scanString(theTranslator->trExceptions()+": ");
+					    outDoc->endBold();
+  					    outDoc->endDescTitle();
+					  }
+					  BEGIN(DocException);
+  					}
+<DocScan>"\\capt".*
+<DocParam>{SCOPENAME}			{
+  					  outDoc->writeDescItem();
+					  outDoc->startEmphasis();
+  					  outDoc->docify(yytext); 
+					  outDoc->endEmphasis();
+					  outDoc->docify(" - ");
+					  BEGIN(DocScan);
+  					}
+<DocException>{SCOPENAME}		{
+  					  outDoc->writeDescItem();
+					  outDoc->startEmphasis();
+  					  outDoc->docify(yytext); 
+					  outDoc->endEmphasis();
+					  outDoc->docify(" - ");
+					  BEGIN(DocScan);
+  					}
+<DocScan>("\\"|"@")"section "{ID}"\n"	{
+  					  QString secName=&yytext[9];               // skip "\section "
+					  secName=secName.left(secName.length()-1); // remove \n
+					  //printf("SectionName %s found\n",secName.data());
+					  SectionInfo *sec;
+					  if ((sec=sectionDict[secName]))
+					  {
+					    //printf("Title %s\n",sec->title.data());
+					    outDoc->writeSection(sec->label,sec->title,sec->isSubsection);
+					  }
+  					}
+<DocScan>"\\ref"			{
+  					  BEGIN(DocRefName);
+  					}
+<DocScan>"\\refitem"			{
+  					  BEGIN(DocRefItem);
+  					}
+<DocRefName>{ID}			{
+  					  QString ref=yytext;
+					  SectionInfo *sec;
+					  if ((sec=sectionDict[ref]))
+					  {
+					    outDoc->writeSectionRef(sec->pageName,sec->label,sec->title);
+					  }
+					  else
+					  {
+					    warn("Warning: reference to unknown section %s!\n",yytext);
+					    outDoc->writeBoldString("unknown reference!");
+					  }
+					  BEGIN(DocScan);
+  					}
+<DocRefItem>{ID}			{
+  					  sectionRef=yytext;
+					  BEGIN(DocRefItemName);
+  					}
+<DocRefItemName>.*/"\n"			{
+					  SectionInfo *sec;
+					  if ((sec=sectionDict[sectionRef]))
+					  {
+					    outDoc->writeSectionRefItem(sec->pageName,sec->label,yytext);
+					  }
+					  else
+					  {
+					    warn("Warning: reference to unknown section %s!\n",sectionRef.data());
+					    outDoc->writeBoldString("unknown reference!");
+					  }
+					  BEGIN(DocScan);
+  					}
+<DocScan>("\\"|"@")"code"/{BN}+	        { 
+					  outDoc->startCodeFragment();
+  					  codeBlock.resize(0);
+					  BEGIN( DocCodeBlock ); 
+					}
+<DocScan>("\\"|"@")"endcode"/[^a-z_A-Z0-9] 	{ 
+  					  warn("Warning: \\endcode without <PRE> or \\code "
+    					       "in the documentation of %s\n",refName.data()); 
+					}
+<DocScan>{SCOPEMASK}"("[a-z_A-Z,\<\> \t\*\&]+")"	{
+  					  generateRef(*outDoc,className,yytext,inSeeBlock);
+  					}
+<DocScan>{SCOPEMASK}(("()")?)          	{ 
+					  generateRef(*outDoc,className,yytext,inSeeBlock);
+					} 
+<DocScan>({SCOPEMASK}"::")?"operator"[^(\r\n.,]*"("[a-z_A-Z,\<\> \t\*\&]*")"	{ 
+    					  QString oName=yytext;
+					  generateRef(*outDoc,className,
+					              removeRedundantWhiteSpace(oName),inSeeBlock);
+					}
+<DocScan>({SCOPEMASK}"::")?"operator()("[a-z_A-Z,\<\> \t\*\&]*")"	{ 
+				          QString oName=yytext;
+					  generateRef(*outDoc,className,
+					              removeRedundantWhiteSpace(oName),inSeeBlock);
+					}
+<DocScan>{FILEMASK}			{
+					  generateFileRef(*outDoc,yytext);
+					}
+<DocCodeBlock>{BN}*("\\"|"@")"endcode"/[^a-z_A-Z0-9]  { // needed to match things like \endcode. (note the dot)
+				          parseCode(*outDoc,className,codeBlock,exampleDoc,exampleName);
+					  //printf("Code block\n-------------\n%s\n--------------\n",codeBlock.data());
+					  outDoc->endCodeFragment();
+					  BEGIN( DocScan ); 
+					}
+<DocCodeBlock>"</"{PRE}{ATTR}">"	{ 
+				          parseCode(*outDoc,className,codeBlock,exampleDoc,exampleName);
+					  //printf("Code block\n-------------\n%s\n--------------\n",codeBlock.data());
+					  outDoc->endCodeFragment();
+					  BEGIN( DocScan ); 
+					}
+<DocScan>("\\"|"@")"e"{BN}+	                { BEGIN( DocEmphasis ); }
+<DocScan>("\\"|"@")"a"{BN}+                     { BEGIN( DocEmphasis ); }
+<DocScan>("\\"|"@")"b"{BN}+			{ BEGIN( DocBold ); }
+<DocScan>("\\"|"@")"c"{BN}+                     { BEGIN( DocCode ); }
+<DocScan>("\\"|"@")"l"{BN}+		
+<DocScan>("\\"|"@")"include"{BN}+		{ BEGIN( DocInclude ); }
+<DocScan>("\\"|"@")"dontinclude"{BN}+		{ BEGIN( DocDontInclude ); }
+<DocScan>("\\"|"@")"skip"{BN}+		 	{ BEGIN( DocSkipKey ); }	
+<DocScan>("\\"|"@")"skipline"{BN}+		{ BEGIN( DocSkiplineKey ); firstLine=TRUE; }
+<DocScan>("\\"|"@")"line"{BN}+			{ BEGIN( DocLineKey ); firstLine=TRUE; }
+<DocScan>("\\"|"@")"until"{BN}+			{ BEGIN( DocUntilKey ); firstLine=TRUE; }
+<DocSkipKey>[^ \t\r\n]+			{ 
+  					  if (includeFileLength>0) 
+					    skipUntil(yytext); 
+  					  BEGIN( DocScan );
+					}
+<DocLineKey>[^ \t\r\n]+			{ 
+  					  if (includeFileLength>0) 
+					  {
+					    if (firstLine) outDoc->startCodeFragment();
+					    firstLine=FALSE;
+					    showLine(*outDoc,yytext); 
+					    BEGIN( DocKeyEnd );
+					  }
+					  else
+					  {
+  					    BEGIN( DocScan );
+					  }
+					}
+<DocSkiplineKey>[^ \t\r\n]+		{ 
+  					  if (includeFileLength>0) 
+					  {
+					    if (firstLine) outDoc->startCodeFragment();
+					    firstLine=FALSE;
+					    skipLine(*outDoc,yytext); 
+					    BEGIN( DocKeyEnd );
+					  }
+					  else
+					  {
+  					    BEGIN( DocScan );
+					  }
+					}
+<DocUntilKey>[^ \t\r\n]+		{ 
+  					  if (includeFileLength>0) 
+					  {
+					    if (firstLine) outDoc->startCodeFragment();
+					    firstLine=FALSE;
+					    showUntil(*outDoc,yytext); 
+					    BEGIN( DocKeyEnd );
+					  }
+					  else
+					  {
+  					    BEGIN( DocScan );
+					  }
+					}
+<DocKeyEnd>("\\"|"@")"line"{BN}+		{ BEGIN(DocLineKey); }
+<DocKeyEnd>("\\"|"@")"until"{BN}+		{ BEGIN(DocUntilKey); }
+<DocKeyEnd>("\\"|"@")"skipline"{BN}+		{ BEGIN(DocSkiplineKey); }
+<DocKeyEnd>\n
+<DocKeyEnd>.				{
+  					  unput(*yytext);
+  					  if (!firstLine) outDoc->endCodeFragment();
+					  BEGIN( DocScan );
+  					}
+<DocScan>"<"{MULTICOL}{ATTR}">"		
+<DocScan>"</"{MULTICOL}{ATTR}">"
+<DocScan>"<"{STRONG}{ATTR}">"		{ outDoc->startBold(); }
+<DocScan>"</"{STRONG}{ATTR}">"		{ outDoc->endBold(); }
+<DocScan>"<"{CENTER}{ATTR}">"		{ outDoc->startCenter(); }
+<DocScan>"</"{CENTER}{ATTR}">"		{ outDoc->endCenter(); }
+<DocScan>"<"{TABLE}{ATTR}">"		{ 
+  					  startTable();
+  					  /*outDoc->startTable();*/ }
+<DocScan>"</"{TABLE}{ATTR}">"		{
+ 					  endTable(); 
+  					  /*outDoc->endTable();*/ 
+					}
+<DocScan>"<"{INPUT}{ATTR}">"
+<DocScan>"<"{SMALL}{ATTR}">"		{ outDoc->startSmall(); }
+<DocScan>"</"{SMALL}{ATTR}">"		{ outDoc->endSmall(); }
+<DocScan>"<"{META}{ATTR}">"
+<DocScan>"<"{FORM}{ATTR}">"
+<DocScan>"</"{FORM}{ATTR}">"
+<DocScan>"<"{HEAD}{ATTR}">"			
+<DocScan>"</"{HEAD}{ATTR}">"			
+<DocScan>"<"{BODY}{ATTR}">"
+<DocScan>"</"{BODY}{ATTR}">"
+<DocScan>"<"{CODE}{ATTR}">"		{ outDoc->startTypewriter(); }
+<DocScan>"</"{CODE}{ATTR}">"		{ outDoc->endTypewriter(); }
+<DocScan>"<"{DFN}{ATTR}">"		{ outDoc->startTypewriter(); }
+<DocScan>"</"{DFN}{ATTR}">"		{ outDoc->endTypewriter(); }
+<DocScan>"<"{VAR}{ATTR}">"		{ outDoc->startEmphasis(); }
+<DocScan>"</"{VAR}{ATTR}">"		{ outDoc->endEmphasis(); }
+<DocScan>"<"{IMG}{ATTR}">"		{ outDoc->disableAllBut(OutputGenerator::Html);
+					  outDoc->writeString(yytext); 
+					  outDoc->enableAll();
+					}
+<DocScan>"<"{PRE}{ATTR}">"			{ 
+  					  outDoc->startCodeFragment();
+  					  codeBlock.resize(0);
+					  BEGIN( DocCodeBlock ); 
+					}
+<DocScan>"</"{PRE}{ATTR}">"		 	{ 
+  					  warn("Warning: </PRE> without <PRE> or \\code"
+    					         "in the documentation of %s\n",refName.data()); 
+					}
+<DocScan>"<"{SUB}{ATTR}">"		{ outDoc->startSubscript(); }
+<DocScan>"</"{SUB}{ATTR}">"		{ outDoc->endSubscript(); }
+<DocScan>"<"{SUP}{ATTR}">"		{ outDoc->startSuperscript(); }
+<DocScan>"</"{SUP}{ATTR}">"		{ outDoc->endSuperscript(); }
+<DocScan>"<"{TR}{ATTR}">"		{ if (curTable) curTable->newRow(); }
+<DocScan>"</"{TR}{ATTR}">"			
+<DocScan>"<"{TD}{ATTR}">"		{ if (curTable) curTable->newElem(); }
+<DocScan>"</"{TD}{ATTR}">"
+<DocScan>"<"{OL}{ATTR}">"		{ outDoc->startEnumList(); }
+<DocScan>"</"{OL}{ATTR}">"		{ outDoc->endEnumList(); }
+<DocScan>"<"{UL}{ATTR}">"		{ outDoc->startItemList(); }
+<DocScan>"</"{UL}{ATTR}">"		{ outDoc->endItemList(); }
+<DocScan>"<"{LI}{ATTR}">"		{ outDoc->writeListItem(); }
+<DocScan>"</"{LI}{ATTR}">"		
+<DocScan>"<"{TT}{ATTR}">"		{ outDoc->startTypewriter(); }
+<DocScan>"</"{TT}{ATTR}">"		{ outDoc->endTypewriter(); }
+<DocScan>"<"{EM}{ATTR}">"		{ outDoc->startEmphasis(); }
+<DocScan>"</"{EM}{ATTR}">"		{ outDoc->endEmphasis(); }
+<DocScan>"<"{HR}{ATTR}">"		{ outDoc->writeRuler(); }
+<DocScan>"<"{DL}{ATTR}">"		{ outDoc->startDescription(); }
+<DocScan>"</"{DL}{ATTR}">"		{ outDoc->endDescription(); }
+<DocScan>"<"{DT}{ATTR}">"		{ outDoc->startDescItem(); }
+<DocScan>"</"{DT}{ATTR}">"	
+<DocScan>"<"{DD}{ATTR}">"		{ outDoc->endDescItem(); }
+<DocScan>"</"{DD}{ATTR}">"
+<DocScan>"<"{BR}{ATTR}">"		{ outDoc->lineBreak(); }
+<DocScan>"<"{I}{ATTR}">"		{ outDoc->startEmphasis(); }
+<DocScan>"</"{I}{ATTR}">"		{ outDoc->endEmphasis(); }
+<DocScan>"</"{A}{ATTR}">"			
+<DocScan>"<"{A}				{ BEGIN(DocHtmlLink); }
+<DocScan>"<"{BOLD}{ATTR}">"		{ outDoc->startBold(); }
+<DocScan>"</"{BOLD}{ATTR}">"		{ outDoc->endBold(); }
+<DocScan>"<"{P}{ATTR}">"		{ 
+  					  if (inBlock()) endBlock();
+  					  outDoc->newParagraph(); }
+<DocScan>"</"{P}{ATTR}">"
+<DocScan>"<"{H1}{ATTR}">"		{ outDoc->startTitle(); }
+<DocScan>"</"{H1}{ATTR}">"		{ outDoc->endTitle(); }
+<DocScan>"<"{H2}{ATTR}">"		{ outDoc->startSubsection(); }
+<DocScan>"</"{H2}{ATTR}">"		{ outDoc->endSubsection(); }
+<DocScan>"<"{H3}{ATTR}">"		{ outDoc->startSubsubsection(); }
+<DocScan>"</"{H3}{ATTR}">"		{ outDoc->endSubsubsection(); }
+<DocHtmlLink>{NAME}{BN}*"="{BN}*("\""?)	{ BEGIN(DocHtmlAnchor); }
+<DocHtmlAnchor>[a-z_A-Z0-9.\-\+\/]+	{ outDoc->writeAnchor(yytext); } 
+<DocHtmlLink>{HREF}{BN}*"="{BN}*("\""?)	{ 
+  					  htmlUrl.resize(0);
+					  htmlText.resize(0);
+  					  BEGIN(DocHtmlHref1); }
+<DocHtmlHref1>{URLMASK}+		{ 
+  					  htmlUrl=yytext; 
+					}
+<DocHtmlHref1>">"			{ BEGIN(DocHtmlHref2); }
+<DocHtmlHref2>[^<]*			{ htmlText+=yytext; }
+  /*
+<DocHtmlHref2>\n			{ htmlText+='\n'; }
+  */
+<DocHtmlHref2>"<"			{ 
+  					  outDoc->writeHtmlLink(htmlUrl,htmlText);
+  					  unput(*yytext); 
+					  BEGIN(DocScan); 
+					}
+<DocHtmlLink,DocHtmlAnchor>">"		{ BEGIN(DocScan); }
+
+<DocScan>"\\\\"				{
+  					  outDoc->docify("\\");
+  					}
+<DocScan>"\\@"				{
+  					  outDoc->docify("@");
+  					}
+<DocScan>"\\<"			        { 
+					  outDoc->docify("<");
+					}
+<DocScan>"\\>"				{ 
+  					  outDoc->docify(">");
+					}
+<DocScan>"\\&"				{ 
+  					  outDoc->docify("&");
+					}
+<DocScan>"\\$"				{
+  					  outDoc->docify("$");
+  					}
+<DocScan>"\\#"				{
+  					  outDoc->docify("#");
+  					}
+<DocScan>"\\%"				{
+  					  outDoc->docify("%");
+  					}
+<DocScan>"%"[a-zA-Z_0-9\-]+		{
+  					  outDoc->docify(yytext+1);
+  					}
+<DocEmphasis>[^ \t\n\r]+		{ 
+  					  outDoc->startEmphasis();
+  					  generateRef(*outDoc,className,yytext,inSeeBlock);
+					  outDoc->endEmphasis();
+					  BEGIN( DocScan );
+					  //addToIndex(yytext);
+					}
+<DocBold>[^ \t\n\r]+			{
+  					  outDoc->startBold();
+  					  generateRef(*outDoc,className,yytext,inSeeBlock);
+					  outDoc->endBold();
+					  BEGIN( DocScan );
+  					}
+<DocCode>[^ \t\n\r]+			{ 
+					  outDoc->startTypewriter();
+  					  generateRef(*outDoc,className,yytext,inSeeBlock);
+					  outDoc->endTypewriter();
+					  BEGIN( DocScan );
+					}
+<DocInclude>{FILE}			{
+					  includeFile(*outDoc,stripQuotes(yytext),FALSE); 
+					  BEGIN( DocScan );
+  					}
+<DocDontInclude>{FILE}			{
+  					  includeFile(*outDoc,stripQuotes(yytext),TRUE);
+					  BEGIN( DocScan );
+  					}
+<DocCodeBlock>"//"			{ codeBlock += yytext; }
+<DocCodeBlock>"/*"			{ codeBlock += yytext; }
+<DocCodeBlock>\n			{ codeBlock += '\n'; }
+<DocCodeBlock>[^\/\\\<\n]*		{ codeBlock += yytext; }
+<DocCodeBlock>.				{ codeBlock += *yytext; }
+<DocCode,DocEmphasis,DocScan,DocBold>"//"       { 
+					  outDoc->docify(yytext);
+					}
+<DocCode,DocEmphasis,DocScan,DocBold>"/*"       { 
+  					  outDoc->docify(yytext);
+					}
+<DocCode,DocEmphasis,DocBold>"\n"	{ outDoc->writeChar('\n'); }
+<DocScan>({B}*"\n"{B}*){2,}		{ 
+  					  if (insideArgumentList)
+					  {
+					    insideArgumentList=FALSE;
+					    outDoc->endItemList();
+					  }
+					  else
+					  {
+					    outDoc->newParagraph(); 
+					  }
+					  if (inBlock()) endBlock();
+					}
+<DocScan>{BN}+				{ 
+  					  outDoc->writeChar(' '); 
+					}
+<DocCode,DocEmphasis,DocBold,DocScan>.  { 
+					  outDoc->writeChar(*yytext);
+					}
+<NextSemi>"{"				{ BEGIN(SkipBlock); }
+<SkipBlock>"{"				{ ++bracketCount ; }
+<SkipBlock>"}"				{ if( bracketCount )
+					    --bracketCount ;
+					  else
+					    BEGIN( NextSemi ) ;
+					}
+<NextSemi>\"				{
+  					  lastStringContext=NextSemi;
+					  BEGIN(SkipString);
+  					}
+<NextSemi>[;,]				{ 
+  					  unput(*yytext);
+  					  BEGIN( FindMembers ) ; 
+					}
+<FindMembers>{B}*"signals"{BN}*":"{BN}* { current->sig = sig = TRUE;
+					  current->slot = slot = FALSE;
+					  current->protection = protection = Public ;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount() ;
+					}
+
+<FindMembers>{B}*"public"{BN}*"slots"{BN}*":"{BN}* {
+					  current->protection = protection = Public ;
+					  current->slot = slot = TRUE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount();
+					}
+
+<FindMembers>{B}*"protected"{BN}*"slots"{BN}*":"{BN}* {
+					  current->protection = protection = Protected ;
+					  current->slot = slot = TRUE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount();
+					}
+
+<FindMembers>{B}*"private"{BN}*"slots"{BN}*":"{BN}* {
+					  current->protection = protection = Private ;
+					  current->slot = slot = TRUE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount();
+					}
+
+<FindMembers>{B}*"public"{BN}*":"{BN}*	{ 
+					  current->protection = protection = Public ;
+					  current->slot = slot = FALSE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount() ;
+					}
+<FindMembers>{B}*"protected"{BN}*":"{BN}* { 
+  					  current->protection = protection = Protected ;
+					  current->slot = slot = FALSE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount() ;
+					}
+<FindMembers>{B}*"private"{BN}*":"{BN}*	{ 
+  					  current->protection = protection = Private ;
+					  current->slot = slot = FALSE;
+					  current->sig = sig = FALSE;
+					  current->type.resize(0); 
+					  current->name.resize(0); 
+					  current->args.resize(0);
+					  current->argList->clear();
+					  lineCount() ;
+					}
+  /*
+<FindMembers>"inline"     		
+  */
+<FindMembers>{B}*"static"{BN}+     	{ //current->type += " static ";
+  					  current->stat = TRUE;
+					  lineCount();
+					}
+<FindMembers>{B}*"extern"{BN}+		{
+  					  current->stat = FALSE;
+					  lineCount();
+  					}
+<FindMembers>{B}*"virtual"{BN}+    	{ current->type += " virtual ";
+					  current->virt = Virtual;
+					  lineCount();
+					}
+<FindMembers>{B}*"inline"{BN}+		{ lineCount(); }
+<FindMembers>{B}*"typename"{BN}+	{ lineCount(); }
+<FindMembers>{B}*"namespace"{BN}+	{ 
+  					  isTypedef=FALSE;
+					  current->section = Entry::NAMESPACE_SEC;
+					  current->type = "namespace" ;
+					  current->fileName  = yyFileName;
+					  current->startLine = yyLineNr;
+					  lineCount();
+  					  BEGIN( ClassName ); 
+					}
+<FindMembers>{B}*(("typedef"{BN}+)?)"class"{BN}+ { 
+					  isTypedef=((QString)yytext).find("typedef")!=-1;
+  					  current->section = Entry::CLASS_SEC ;
+					  addType( current ) ;
+					  current->type += " class" ;
+					  current->fileName  = yyFileName;
+					  current->startLine = yyLineNr;
+					  lineCount() ;
+					  BEGIN( ClassName ) ;
+					}
+<FindMembers>{B}*(("typedef"{BN}+)?)"struct"{BN}+ { 
+					  isTypedef=((QString)yytext).find("typedef")!=-1;
+  					  current->section = Entry::STRUCT_SEC ;
+					  addType( current ) ;
+					  current->type += " struct" ;
+					  current->fileName  = yyFileName;
+					  current->startLine = yyLineNr;
+					  lineCount() ;
+					  BEGIN( ClassName ) ;
+					}
+<FindMembers>{B}*(("typedef"{BN}+)?)"union"{BN}+ { 
+					  isTypedef=((QString)yytext).find("typedef")!=-1;
+  					  current->section = Entry::UNION_SEC ;
+					  addType( current ) ;
+					  current->type += " union" ;
+					  current->fileName  = yyFileName;
+					  current->startLine = yyLineNr;
+					  lineCount() ;
+					  BEGIN( ClassName ) ;
+					}
+<FindMembers>{B}*(("typedef"{BN}+)?)"enum"{BN}+	{ 
+					  isTypedef=((QString)yytext).find("typedef")!=-1;
+  					  current->section = Entry::ENUM_SEC ;
+					  addType( current ) ;
+					  current->type += " enum" ;
+					  current->fileName  = yyFileName;
+					  current->startLine = yyLineNr;
+					  lineCount() ;
+					  BEGIN( ClassName ) ;
+					}
+<Operator>"("{BN}*")"{BN}*/"("		{
+  					  lineCount();
+    					  current->name += yytext ;
+					  current->name = current->name.simplifyWhiteSpace();
+					  BEGIN( FindMembers ) ;
+  					}
+<Operator>[^(]				{ 
+    					  current->name += *yytext ;
+					}
+<Operator>"<>"				{ /* skip guided templ specifiers */ }
+<Operator>"("				{
+					  current->name = current->name.simplifyWhiteSpace();
+					  unput(*yytext);
+					  BEGIN( FindMembers ) ;
+					}
+<FindMembers>"template"({BN}*)"<"/[>]?	{ 
+  					  lineCount();
+					  if (current->tArgList)
+					  {
+					    //printf("scanner.l current->tArgList->clear() %p\n",current->tArgList);
+					    current->tArgList->clear();
+					  }
+					  else
+					  {
+					    current->tArgList = new ArgumentList;
+					    current->tArgList->setAutoDelete(TRUE);
+					    //printf("scanner.l new tArgList %p\n",current->tArgList);
+					  }
+					  templateStr="<";
+					  copyArgString=&templateStr;
+					  currentArgumentContext = FindMembers;
+					  //printf("Start template list\n");
+					  BEGIN( ReadTempArgs );
+  					}
+  /*
+<FindMembers>({ID}{BN}*"::")*{BN}*"operator"{BN}*[<=]+ {
+					  lineCount();
+					  addType( current );
+					  current->name = yytext;
+					}
+<FindMembers>"operator"{BN}*"/"[=]?/[^/ *] {  space added!
+					  lineCount();
+					  addType( current );
+					  current->name = yytext;
+					}
+<FindMembers>"operator"{BN}*"({B}*)"{BN}* /"(" {  space added!  
+					  lineCount();
+					  addType( current );
+					  current->name = yytext;
+					}
+<FindMembers>"operator"{BN}*[^(/]+	{ 
+  					  lineCount();
+  				          addType( current ) ;
+					  current->name  = yytext ;
+					}
+  */
+<FindMembers>"using"{BN}+		{ lineCount(); BEGIN(Using); }
+<Using>";"				{ BEGIN(FindMembers); }
+<FindMembers>{SCOPENAME}{BN}*"<>"	{ // guided template decl
+					  QString n=yytext;
+					  addType( current );
+					  current->name=n.left(n.length()-2);
+					}
+<FindMembers>{SCOPENAME}{BN}*/"<"	{
+  					  sharpCount=0;
+					  lineCount();
+					  addType( current );
+  					  current->name=yytext;
+					  current->name=current->name.stripWhiteSpace();
+					  if (current->name.right(8)=="operator") 
+					    BEGIN( Operator );
+					  else
+					    BEGIN( EndTemplate );
+					}
+<EndTemplate>"<"			{ 
+  					  current->name+='<'; 
+					  sharpCount++; 
+					}
+  /*
+<EndTemplate>">"({BN}*"::"{SCOPENAME})?	{
+  */
+<EndTemplate>">"			{
+					  current->name+=*yytext;
+					  if (--sharpCount<=0)
+					  {  
+					    //printf("Found %s\n",current->name.data());
+					    BEGIN(FindMembers);
+					  }
+					}
+<EndTemplate>">"{BN}*"("		{ 
+  					  lineCount();
+					  current->name+='>';
+					  if (--sharpCount<=0)
+					  {
+					    current->args = "(";
+					    currentArgumentContext = FuncQual;
+					    copyArgString=&current->args;
+					    //printf("Found %s\n",current->name.data());
+					    BEGIN( ReadFuncArgType ) ;
+					  }
+					}
+<EndTemplate>">"{BN}*/"::"		{
+  					  lineCount();
+  					  current->name+='>';
+					  if (--sharpCount<=0)
+					  {
+					    BEGIN(FindMemberName);
+					  }
+  					}
+<EndTemplate>.				{ current->name+=*yytext; }
+<FindMembers,FindMemberName>{SCOPENAME}	{ 
+					  lineCount();
+					  if (YY_START==FindMembers)
+					  {
+					    addType( current ) ;
+					    current->name  = yytext;
+					  }
+					  else
+					  {
+					    current->name += yytext;
+					  }
+				          QString tmp=yytext;
+					  if (tmp.right(8)=="operator") 
+					    BEGIN( Operator );
+					  else
+					    BEGIN(FindMembers);
+					}
+<FindMembers>^{B}*"#"			{ lastCPPContext = YY_START; 
+					  BEGIN( SkipCPP ) ; 
+					}
+<FindMembers>^{B}*"#define"		{
+  					  BEGIN( Define );
+  					}
+<SkipCPP>.
+<SkipCPP>\\[\r]*"\n"[\r]*		{ yyLineNr++ ; }
+<SkipCPP>[\r]*\n[\r]*			{ yyLineNr++ ;
+					  BEGIN( lastCPPContext) ;
+					}
+<Define>{ID}/"("			{
+  					  current->name = yytext;
+					  BEGIN( DefineArg );
+  					}
+<DefineArg>")"				{
+  					  //printf("Define with args\n");
+  					  current->args += ')';
+  					  BEGIN( DefineEnd );
+  					}
+<DefineArg>.				{
+  					  current->args += *yytext;
+  					}
+<Define>{ID}				{
+  					  //printf("Define `%s' without args\n",yytext);
+  					  current->name = yytext;
+					  BEGIN(DefineEnd);
+  					}
+<DefineEnd>\n				{
+  					  //printf("End define\n");
+					  current->fileName   = yyFileName;
+					  current->startLine  = yyLineNr;
+					  current->type.resize(0);
+  					  current->args       = current->args.simplifyWhiteSpace();
+  					  current->name       = current->name.stripWhiteSpace();
+					  current->section    = Entry::DEFINE_SEC;
+					  current_root->addSubEntry(current);
+					  current             = new Entry ;
+					  current->protection = protection ;
+				          current->sig        = sig;
+					  current->virt       = virt;
+					  current->stat       = gstat;
+					  current->slot       = slot;
+					  BEGIN(FindMembers);
+  					}
+<DefineEnd>\\\n
+<DefineEnd>.				
+					
+<FindMembers>[*&]+			{ current->name += yytext ; }
+<FindMembers,MemberSpec,Function,NextSemi>";"{BN}*("/**"|"//!"|"/*!")"<" {
+  					  lineCount();
+					  current->doc.resize(0);
+					  current->brief.resize(0);
+					  lastAfterDocContext = YY_START;
+					  afterDocTerminator = ';';
+					  if (yytext[yyleng-3]=='/')
+					    BEGIN(AfterDocLine);
+					  else if (yytext[yyleng-2]=='*')
+					    BEGIN(AfterDocBrief);
+					  else
+					    BEGIN(AfterDoc);
+  					}
+<MemberSpec,FindFields,FindMembers,NextSemi>","{BN}*("/**"|"//!"|"/*!")"<" {
+  					  lineCount();
+					  current->doc.resize(0);
+					  current->brief.resize(0);
+					  lastAfterDocContext = YY_START;
+					  afterDocTerminator = ',';
+					  if (yytext[yyleng-3]=='/')
+					    BEGIN(AfterDocLine);
+					  else if (yytext[yyleng-2]=='*')
+					    BEGIN(AfterDocBrief);
+					  else
+					    BEGIN(AfterDoc);
+  					}
+<DefineEnd,FindFields,FindFieldArg>{BN}*("/**"|"//!"|"/*!")"<" {
+  					  lineCount();
+					  current->doc.resize(0);
+					  current->brief.resize(0);
+					  lastAfterDocContext = YY_START;
+					  if (YY_START==DefineEnd)
+					    afterDocTerminator = '\n';
+					  else
+					    afterDocTerminator = 0;
+					  if (yytext[yyleng-3]=='/')
+					    BEGIN(AfterDocLine);
+					  else if (yytext[yyleng-2]=='*')
+					    BEGIN(AfterDocBrief);
+					  else
+					    BEGIN(AfterDoc);
+  					}
+<FindMembers>"="			{
+  					  BEGIN(NextSemi);
+  					}
+<FindMembers>[:;,]			{ 
+  					  QString oldType = current->type.copy();
+					  QString oldDocs = current->doc.copy();
+  					  current->type=current->type.simplifyWhiteSpace();
+  					  current->args=current->args.simplifyWhiteSpace();
+  					  current->name=current->name.stripWhiteSpace();
+  					  current->section = Entry::VARIABLE_SEC ;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  current_root->addSubEntry( current ) ;
+					  current = new Entry ;
+					  // variable found 
+					  current->section = Entry::EMPTY_SEC ;
+  					  current->protection = protection;
+					  current->slot = slot = FALSE;
+					  current->sig = sig = FALSE;
+					  current->virt = Normal; 
+					  current->stat = gstat;
+					  // skip expression or bitfield if needed
+					  if ( *yytext == ':') 
+					    BEGIN( NextSemi );
+					  else 
+					  {
+					    if ( *yytext == ',' )
+					    {
+					      int i=oldType.length(); 
+					      while (i>0 && (oldType[i-1]=='*' || oldType[i-1]==' ')) i--;
+					      current->type = oldType.left(i);
+					      current->doc  = oldDocs;
+					    }
+					    BEGIN( FindMembers ) ;
+					  }
+					}
+
+<FindMembers>"["			{ current->args += yytext ;
+					  sharpCount=1;
+					  BEGIN( Array ) ;
+					}
+<Array>"]"				{ current->args += *yytext ;
+					  if (--sharpCount<=0)
+	                                     BEGIN( FindMembers ) ;
+					}
+<Array>"["				{ current->args += *yytext ;
+					  sharpCount++;	
+					}
+<Array>.				{ current->args += *yytext ; }
+
+<FindMembers>"<"			{ addType( current ) ;
+					  current->type += yytext ;
+					  BEGIN( Sharp ) ;
+					}
+<Sharp>">"				{ current->type += *yytext ;
+					  if (--sharpCount<=0)
+	                                     BEGIN( FindMembers ) ;
+					}
+<Sharp>"<"				{ current->type += *yytext ;
+					  sharpCount++;	
+					}
+<Sharp>{BN}+				{
+  					  lineCount();
+					}
+<Sharp>.				{ current->type += *yytext ; }
+<FindFields>{ID}			{
+  					  current->name = yytext;
+					}
+<FindFields>"="				{
+  					  BEGIN(FindFieldArg);
+  					}
+<FindFields>","				{
+					  //printf("adding `%s' `%s' `%s' to enum `%s'\n",
+					  //     current->type.data(), current->name.data(),
+					  //     current->args.data(), current_root->name.data());
+					  current->fileName   = yyFileName;
+					  current->startLine  = yyLineNr;
+					  current->type       = "@"; // enum marker
+  					  current->args       = current->args.simplifyWhiteSpace();
+  					  current->name       = current->name.stripWhiteSpace();
+					  current->section    = Entry::VARIABLE_SEC;
+					  // add to the scope of the enum
+					  current_root->addSubEntry(current);
+					  current             = new Entry(*current);
+					  // add to the scope surrounding the enum (copy!)
+					  current_root->parent->addSubEntry(current);
+					  current             = new Entry ;
+					  current->protection = protection ;
+				          current->sig        = sig;
+					  current->virt       = virt;
+					  current->stat       = gstat;
+					  current->slot       = slot;
+  					}
+<FindFieldArg>","			{ unput(*yytext); BEGIN(FindFields); }
+<Curly>[^\r\n{}"/]*			{ current->program += yytext ; }
+<Curly>"//".*				{ current->program += yytext ; }
+<Curly>\"[^\r\n"]*\"			{ current->program += yytext ; }
+<Curly>"/*"{B}*				{ current->program += yytext ;
+					  lastContext = Curly ;
+					  BEGIN( Comment ) ;
+					}
+<Curly>"/*"{BL}				{ current->program += yytext ;
+					  ++yyLineNr ;
+					  lastContext = Curly ;
+					  BEGIN( Comment ) ;
+					}
+<Curly>"{"				{ current->program += yytext ;
+					  ++bracketCount ;
+					}
+<Curly>"}"				{ if ( bracketCount )
+					  {
+					    current->program += yytext ;
+					    --bracketCount ;
+					  }
+					  else
+					  {
+					    QString &cn = current->name;
+					    QString &rn = current_root->name;
+					    //printf("current->name=`%s' current_root->name=`%s'\n",
+					    //	   cn.data(),rn.data());
+					    if (cn && cn[0]!='@' &&  
+					      (current_root->section & Entry::SCOPE_MASK))
+					    {
+					      cn.prepend(rn+"::");
+					    }
+					    if (isTypedef && cn.length()==0)
+					    {
+					      //printf("Typedef Name\n");
+					      BEGIN( TypedefName );
+					    }
+					    else
+					    {
+					      if (current->section == Entry::ENUM_SEC)
+					      {
+					        current->program+=','; // add field terminator
+					      }
+					      // add compound definition to the tree
+  					      current->args = current->args.simplifyWhiteSpace();
+  					      current->type = current->type.simplifyWhiteSpace();
+  					      current->name = current->name.stripWhiteSpace();
+					      //printf("adding `%s' `%s' `%s' brief=%s\n",current->type.data(),current->name.data(),current->args.data(),current->brief.data());
+					      current_root->addSubEntry( current ) ;
+					      current = new Entry(*current);
+					      if (current->section == Entry::NAMESPACE_SEC)
+					      { // a namespace ends with a closing bracket
+						current->reset();
+						current->protection = protection ;
+						current->sig = sig;
+						current->virt = virt;
+						current->stat = gstat;
+						current->slot = slot;
+						BEGIN( FindMembers ) ;
+					      }
+					      else
+						BEGIN( MemberSpec ) ;
+					    }
+					  }
+					}
+<TypedefName>{ID}			{
+  					  if (current->section == Entry::ENUM_SEC)
+					  {
+					    current->program+=","; // add field terminator
+					  }
+  				          current->name=yytext;
+					  if (current_root->section & Entry::SCOPE_MASK)
+					  {
+					    current->name.prepend(current_root->name+"::");
+					  }
+  					  current->args = current->args.simplifyWhiteSpace();
+  					  current->type = current->type.simplifyWhiteSpace();
+					  //printf("Adding compound %s %s %s\n",current->type.data(),current->name.data(),current->args.data());
+					  current_root->addSubEntry( current ) ;
+					  current = new Entry;
+					  current->protection = protection ;
+					  current->sig = sig;
+					  current->virt = virt;
+					  current->stat = gstat;
+					  current->slot = slot;
+  					  BEGIN(MemberSpecSkip); 
+  					}
+<MemberSpec>([*&]*{BN}*)*{ID}("["[a-z_A-Z0-9]*"]")* { // the [] part could be improved.
+  					  lineCount();
+  					  int i=0,l=yyleng,j;
+					  while (i<l && (!isalpha(yytext[i]))) i++;
+					  msName = yytext; 
+					  msName = msName.right(msName.length()-i);
+					  j=msName.find("[");
+					  if (j!=-1) 
+					  {
+					    msArgs=msName.right(msName.length()-j);
+					    msName=msName.left(j);
+					  }
+					  msType = yytext; msType=msType.left(i);
+					}
+<MemberSpec>[,;]			{
+					  if (msName.length()>0)
+					  {
+  					    Entry *varEntry=new Entry;
+					    varEntry->protection = current->protection ;
+					    varEntry->sig = current->sig;
+					    varEntry->virt = current->virt;
+					    varEntry->stat = current->stat;
+					    varEntry->slot = current->slot;
+					    varEntry->section = Entry::VARIABLE_SEC;
+					    varEntry->name = msName.stripWhiteSpace();
+					    varEntry->type = current->type.simplifyWhiteSpace()+" ";
+					    varEntry->args = msArgs; //current->args.simplifyWhiteSpace();
+					    //if (current->name.length()>0 && current->name[0]!='@' && 
+					    //    current->parent->section & Entry::COMPOUND_MASK)
+					    //  varEntry->type+=current->parent->name+"::";
+					    if (isTypedef)
+					      varEntry->type.prepend("typedef ");
+					    varEntry->type+=current->name+msType;
+					    varEntry->fileName = yyFileName;
+					    varEntry->startLine = yyLineNr;
+					    varEntry->doc = current->doc.copy();
+					    varEntry->brief = current->brief.copy();
+					    //printf("Add: type=`%s',name=`%s',args=`%s'\n",
+					    //      varEntry->type.data(),varEntry->name.data(),varEntry->args.data());
+					    current_root->addSubEntry(varEntry);
+					  }
+					  if (*yytext==';')
+					  {
+					    msType.resize(0);
+					    msName.resize(0);
+					    msArgs.resize(0);
+					    isTypedef=FALSE;
+					    current->reset();
+					    current->protection = protection ;
+					    current->sig = sig;
+					    current->virt = virt;
+					    current->stat = gstat;
+					    current->slot = slot;
+					    BEGIN( FindMembers );
+					  }
+  					}					
+<MemberSpec>"="				{ BEGIN(MemberSpecSkip); }
+<MemberSpecSkip>"{"			{
+  					  bracketCount=0;
+					  lastCurlyContext = MemberSpecSkip;
+  					  BEGIN(SkipCurly);
+  					}
+<MemberSpecSkip>","			{ BEGIN(MemberSpec); }
+<MemberSpecSkip>";"		        { unput(';'); BEGIN(MemberSpec); }
+<Curly>\n				{ current->program += yytext ;
+					  yyLineNr++ ;
+					}
+<Curly>.				{ current->program += yytext ; }
+
+<FindMembers>"("({ID}{BN}*"::"{BN}*)*("*"{BN}*)+ {
+  					  lineCount();
+  					  addType(current);
+					  funcPtrType=yytext;
+					  //current->type += yytext;
+					  BEGIN( FuncPtr );
+  					}
+<FuncPtr>{SCOPENAME}			{
+  					  current->name = yytext;
+					  BEGIN( EndFuncPtr );
+  					}
+<FuncPtr>.				{
+  					  //printf("Error: FuncPtr `%c' unexpected at line %d of %s\n",*yytext,yyLineNr,yyFileName);
+  					}
+<EndFuncPtr>")"{BN}*/";"		{ // a variable with extra braces
+ 					  lineCount();
+					  current->type+=funcPtrType.data()+1;
+  					  BEGIN(FindMembers);
+  					}
+<EndFuncPtr>")"{BN}*/"("		{ // a variable function
+  					  lineCount();
+					  current->type+=funcPtrType+")";
+					  BEGIN(FindMembers);
+  					}
+<EndFuncPtr>"("				{ // a function returning a function
+  					  current->args += *yytext ;
+					  bracketCount=0;
+					  BEGIN( FuncFunc );
+  					}
+<EndFuncPtr>")"				{
+  					  BEGIN(FindMembers);
+  					}
+<FuncFunc>"("				{
+  					  current->args += *yytext ;
+  					  ++bracketCount;
+					}
+<FuncFunc>")"				{
+  					  current->args += *yytext ;
+  					  if ( bracketCount )
+					    --bracketCount;
+					  else
+					  {
+					    BEGIN(FuncFuncEnd);
+					  }
+  					}
+<FuncFuncEnd>")"{BN}*"("		{
+  					  lineCount();
+					  current->type+=funcPtrType+")(";
+					  BEGIN(FuncFuncType);
+  					}
+<FuncFuncEnd>")"{BN}*/[;{]		{
+  					  lineCount();
+					  current->type+=funcPtrType.data()+1;
+  					  BEGIN(Function);
+  					}
+<FuncFuncEnd>.				{
+  					  current->args += *yytext;
+  					}
+<FuncFuncType>"("			{
+  					  current->type += *yytext;
+					  bracketCount++;
+  					}
+<FuncFuncType>")"			{
+  					  current->type += *yytext;
+  					  if (bracketCount)
+					    --bracketCount;
+					  else
+					    BEGIN(Function);
+					}
+<FuncFuncType>{BN}*","{BN}*		{ lineCount() ; current->type += ", " ; }
+<FuncFuncType>{BN}+			{ lineCount() ; current->type += ' ' ; }
+<FuncFuncType>.				{
+  					  current->type += *yytext;
+  					}
+<FindMembers>"("			{ current->args = yytext;
+					  currentArgumentContext = FuncQual;
+					  copyArgString=&current->args;
+					  BEGIN( ReadFuncArgType ) ;
+					  //printf(">>> Read function arguments!\n");
+					}
+  /*
+<FindMembers>"("{BN}*("void"{BN}*)?")"	{
+  					  lineCount();
+  					  current->args = "()"; 
+  					  BEGIN( FuncQual );
+  					}
+  */
+
+  /*- Function argument reading rules ---------------------------------------*/
+
+<ReadFuncArgType>[^ \/\r\t\n\)\(\"\']+	{ *copyArgString+=yytext; }
+<CopyArgString>[^\n\\\"\']+		{ *copyArgString+=yytext; }
+<CopyArgRound>[^\/\n\)\(\"\']+		{ *copyArgString+=yytext; }
+<ReadFuncArgType,ReadTempArgs>{BN}*	{
+  					  *copyArgString+=" ";
+  					  lineCount();
+  					}
+<ReadFuncArgType,CopyArgRound,CopyArgSharp,ReadTempArgs>\"	{
+  					  *copyArgString+=*yytext;
+					  lastCopyArgStringContext = YY_START;
+  					  BEGIN( CopyArgString );
+  					}
+<ReadFuncArgType,ReadTempArgs>"("	{
+  					  *copyArgString+=*yytext;
+  					  argRoundCount=0; 
+					  lastCopyArgContext = YY_START;
+					  BEGIN( CopyArgRound ); 
+  					}
+<ReadFuncArgType>")"			{ 
+  					  *copyArgString+=*yytext;
+					  stringToArgumentList(*copyArgString,current->argList);
+					  BEGIN( currentArgumentContext );
+					}
+<ReadTempArgs>"<"			{
+					  *copyArgString+=*yytext;
+					  argSharpCount=0;
+					  BEGIN( CopyArgSharp );
+					}
+<ReadTempArgs>">"			{
+					  *copyArgString+=*yytext;
+					  //printf("end template list %s\n",copyArgString->data());
+					  stringToArgumentList(*copyArgString,current->tArgList);
+					  BEGIN( currentArgumentContext );
+					}
+<CopyArgRound>"("			{
+  					  argRoundCount++;
+					  *copyArgString+=*yytext;
+  					}
+<CopyArgRound>")"			{
+					  *copyArgString+=*yytext;
+					  if (argRoundCount>0) 
+					    argRoundCount--;
+					  else 
+					    BEGIN( lastCopyArgContext );
+  					}
+<CopyArgSharp>"<"			{
+  					  argSharpCount++;
+					  *copyArgString+=*yytext;
+  					}
+<CopyArgSharp>">"			{
+  					  *copyArgString+=*yytext;
+					  if (argRoundCount>0)
+					    argRoundCount--;
+					  else
+					    BEGIN( ReadTempArgs );
+  					}
+<CopyArgString>\\.			{
+  					  *copyArgString+=yytext;
+  					}
+<CopyArgString>\"			{
+  					  *copyArgString+=*yytext;
+					  BEGIN( lastCopyArgStringContext );
+  					}
+<ReadFuncArgType,ReadTempArgs,CopyArgRound,CopyArgSharp>"'"\\[0-7]{1,3}"'" { *copyArgString+=yytext; }
+<ReadFuncArgType,ReadTempArgs,CopyArgRound,CopyArgSharp>"'"\\."'"   { *copyArgString+=yytext; }
+<ReadFuncArgType,ReadTempArgs,CopyArgRound,CopyArgSharp>"'"."'"     { *copyArgString+=yytext; }
+<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgRound,CopyArgSharp>\n  { yyLineNr++; *copyArgString+=*yytext; }
+<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgRound,CopyArgSharp>.	  { *copyArgString+=*yytext; }
+
+
+
+  /*------------------------------------------------------------------------*/
+
+
+<FuncRound>"("				{ current->args += *yytext ;
+					  ++bracketCount ;
+					}
+<FuncRound>")"                          { current->args += *yytext ; 
+					  if ( bracketCount )
+					    --bracketCount ;
+				          else
+					    BEGIN( FuncQual ) ;
+					}
+  /*
+<FuncQual>"#"				{ lastCPPContext = YY_START;
+  					  BEGIN(SkipCPP);
+					}
+  */
+<FuncQual>[{:;]                         { unput(*yytext); BEGIN( Function ); }
+<FuncQual>{BN}*"const"{BN}*       	{ 
+  					  lineCount() ; 
+  					  current->args += " const "; 
+					  current->argList->constSpecifier=TRUE;
+					}
+<FuncQual>{BN}*"volatile"{BN}*    	{ 
+  					  lineCount() ; 
+  					  current->args += " volatile "; 
+					  current->argList->volatileSpecifier=TRUE;
+					}
+<FuncQual>{BN}*"="{BN}*"0"{BN}*  	{ 
+  					  lineCount() ; 
+					  current->args += " = 0"; 
+					  current->virt = Pure; 
+					  current->argList->pureSpecifier=TRUE;
+					}
+<FuncRound,FuncFunc>{BN}*","{BN}*	{ 
+  					  lineCount() ; 
+					  current->args += ", " ; 
+					}
+<FuncQual,FuncRound,FuncFunc>{BN}+   	{ 
+  					  lineCount() ; 
+					  current->args += ' ' ; 
+					}
+<FuncQual,FuncRound,FuncFunc>.		{ current->args += *yytext; }
+<FuncQual>{BN}*"throw"{BN}*"("		{ 
+  					  current->exception = " throw(" ;
+					  lineCount() ;
+					  BEGIN( ExcpRound ) ;
+					}
+<ExcpRound>"("				{ current->exception += *yytext ;
+					  ++bracketCount ;
+					}
+<ExcpRound>")"                          { current->exception += *yytext ; 
+					  if ( bracketCount )
+					    --bracketCount ;
+				          else
+					    BEGIN( FuncQual ) ;
+					}
+<ExcpRound>.				{
+  					  current->exception += yytext;
+  					}
+<Function>"("				{ current->type += current->name ;
+					  current->name  = current->args ;
+					  current->args  = yytext ;
+					  BEGIN( FuncRound ) ;
+					}
+<Function>"#"				{ lastCPPContext = YY_START;
+  					  BEGIN(SkipCPP);
+					}	
+<Function>[:;{]				{ 
+					  current->name=current->name.simplifyWhiteSpace();
+  					  current->type=current->type.simplifyWhiteSpace();
+  					  current->args=current->args.simplifyWhiteSpace();
+					  QString &cn=current->name;
+					  QString &rn=current_root->name;
+					  //printf("current_root->name=`%s'\n",rn.data());
+  					  //printf("Function: `%s' `%s' `%s'\n",current->type.data(),cn.data(),current->args.data());
+					  int i;
+					  if ((i=cn.findRev("::"))!=-1) // name contains scope
+					  {
+					    if (cn.left(i)==rn.right(i)) // scope name is redundant
+					    {
+                                              cn=cn.right(cn.length()-i-2); // strip scope
+					      //printf("new name=`%s'\n",cn.data());
+					    }
+					  }
+					  //if (cname.left(current_root->name.length()+2)==current_root->name+"::") 
+					  //{ // strip redundant scope
+					  //  current->name=current->name.right(current->name.length()-current_root->name.length()-2);
+					  //  printf("new name=`%s'\n",current->name.data());
+					  //}
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  if (*yytext!=';' || (current_root->section&Entry::SCOPE_MASK) )
+					  {
+					    int tempArg=current->name.find('<');
+					    QString tempName;
+					    if (tempArg==-1) 
+					      tempName=current->name;
+					    else
+					      tempName=current->name.left(tempArg);
+					    if (current->type.isNull() && tempName.find("operator")==-1 && 
+						(tempName.find('*')!=-1 || tempName.find('&')!=-1))
+					    {
+					      //printf("Scanner.l: found in class variable: `%s' `%s' `%s'\n",
+					      //   current->type.data(),current->name.data(),current->args.data());
+					      current->section = Entry::VARIABLE_SEC ;
+					    }
+					    else	      
+					    {
+					      //printf("Scanner.l: found in class function: `%s' `%s' `%s'\n",
+					      //   current->type.data(),current->name.data(),current->args.data());
+					      current->section = Entry::FUNCTION_SEC ;
+					    }
+					  }
+					  else // a global function prototype or function variable
+					  {
+					    //printf("Scanner.l: prototype? type=`%s' name=`%s' args=`%s'\n",current->type.data(),current->name.data(),current->args.data());
+					    QRegExp re("([^)])");
+					    if (!current->type.isNull() && current->type.find(re,0)!=-1)
+					    {
+					      //printf("Scanner.l: found function variable!\n");
+					      current->section = Entry::VARIABLE_SEC;
+					    }
+					    else
+					    {
+					      //printf("Scanner.l: found prototype\n");
+  					      current->section = Entry::FUNCTION_SEC;
+					      current->proto = TRUE;
+					    }
+					  }
+					  current_root->addSubEntry(current);
+					  current = new Entry ;
+					  current->protection = protection;
+				          current->sig = sig;
+					  current->virt = virt;
+					  current->stat = gstat;
+					  current->slot = slot;
+					  lastCurlyContext = FindMembers;
+					  if( *yytext == '{' )
+					      BEGIN( SkipCurly ) ;
+					  else if( *yytext == ':' )
+					      BEGIN( SkipInits ) ;
+					  else
+					      BEGIN( FindMembers ) ;
+					}
+
+<SkipInits>"{"				{ 
+  				          lastCurlyContext = FindMembers;
+  					  BEGIN( SkipCurly ) ; 
+					}
+<SkipCurly,SkipCurlyCpp>"{"		{ ++bracketCount ; }
+<SkipCurly,SkipCurlyCpp>"}"		{ if( bracketCount )
+					    --bracketCount ;
+					  else
+					    //BEGIN( FindMembers ) ;
+					    BEGIN( lastCurlyContext ) ;
+					}
+<SkipCurly>\'.\'
+<SkipCurly>\"			        { 
+  					  lastStringContext=SkipCurly;
+  				          BEGIN( SkipString ); 
+					}
+<SkipCurly>^{B}*"#"			{ BEGIN( SkipCurlyCpp ); }
+<SkipCurlyCpp>\n			{ yyLineNr++; 
+  					  lastCurlyContext = FindMembers;
+  					  BEGIN( SkipCurly ); 
+					}
+<SkipCurlyCpp>\\[\r]*"\n"[\r]*		{ yyLineNr++; }
+<SkipCurlyCpp>"/*"
+<SkipCurlyCpp>"*/"
+<SkipCurlyCpp>"//"                      
+<SkipString>\\.
+<SkipString>\"				{ BEGIN( lastStringContext ); }
+<SkipString>"/*"
+<SkipString>"*/"
+<SkipString>"//"                        
+
+<Bases,ClassName>";"			{ 
+					  current->section = Entry::EMPTY_SEC ;
+					  current->type.resize(0) ;
+					  current->name.resize(0) ;
+					  current->args.resize(0) ;
+					  current->argList->clear();
+					  BEGIN( FindMembers ) ;
+					}
+<ClassName>{ID}				{ 
+					  current->name = yytext ;
+					  BEGIN( ClassVar );
+					}
+  /*
+<ClassVar>{ID}/{BN}*"{"			{ // we probably got some M$ extension
+  					  current->name = yytext ;
+  					}
+<ClassVar>{ID}/{BN}*":"			{ // we probably got some M$ extension
+  					  current->name = yytext ;
+  					}
+  */
+<ClassVar>{ID}				{
+					  if (isTypedef)
+					  {
+					    typedefDict.insert(yytext,new QString(current->name));
+					    current->type.prepend("typedef ");
+					  }
+  					  current->type += ' ' ;
+					  current->type += current->name ;
+					  current->name = yytext ;
+					  //BEGIN( FindMembers );
+  					}
+<ClassVar>"("				{
+					  roundCount=1;
+					  lastSkipRoundContext=YY_START;
+					  BEGIN(SkipRound);
+					}
+<ClassVar>":"				{ 
+  					  current->type.resize(0);
+                                          baseProt=Private;
+                                          baseVirt=Normal;
+					  baseName.resize(0);
+					  BEGIN( Bases ) ;
+					}
+<ClassVar>[;=*&]			{
+    					  unput(*yytext);
+					  BEGIN( FindMembers );
+    					}
+<ClassName,ClassVar>{B}*"{"{B}*		{ current->fileName = yyFileName ;
+					  current->startLine = yyLineNr ;
+					  if (current->name.length()==0 && !isTypedef) // anonymous compound
+					    current->name.sprintf("@%d",anonCount++);
+					  BEGIN( Curly ) ;
+					}
+<Bases>"virtual"                        { baseVirt = Virtual; }
+<Bases>"public"                         { baseProt = Public; }
+<Bases>"protected"                      { baseProt = Protected; }
+<Bases>"private"                        { baseProt = Private; }
+<Bases>({ID}{BN}*"::"{BN}*)*{ID}	{ 
+  					  //current->extends->append(
+					  //  new BaseInfo(yytext,baseProt,baseVirt)
+					  //) ;
+  					  baseName += yytext;
+					  current->args += ' ' ;
+					  current->args += yytext ;
+					}
+<ClassVar>"<"   	                { current->name += *yytext;
+  					  sharpCount=1; 
+					  lastSkipSharpContext = YY_START;
+					  specName = &current->name;
+					  BEGIN ( Specialization );
+					}
+<Bases>"<"   	       	                { baseName += *yytext;
+  					  sharpCount=1; 
+					  lastSkipSharpContext = YY_START;
+					  specName = &baseName;
+					  BEGIN ( Specialization );
+					}
+<Specialization>"<"			{ *specName += *yytext;
+  					  sharpCount++;
+  					}
+<Specialization>">"			{
+  					  *specName += *yytext;
+  					  if (--sharpCount<=0)
+					    BEGIN(lastSkipSharpContext);
+  					}
+<Specialization>{BN}+			{ lineCount(); *specName +=' '; }
+<Specialization>.			{
+  					  *specName += *yytext;
+  					}
+<SkipSharp>"<"				{ ++sharpCount; }
+<SkipSharp>">"				{ if (--sharpCount<=0)
+					    BEGIN ( lastSkipSharpContext );
+					}
+<SkipRound>"("				{ ++roundCount; }
+<SkipRound>")"				{ if (--roundCount<=0)
+					    BEGIN ( lastSkipRoundContext );
+					}
+<Bases>","				{ current->args += ',' ; 
+  					  if (baseName.length()>0)
+  					    current->extends->append(
+					      new BaseInfo(baseName,baseProt,baseVirt)
+					    );
+					  baseProt=Private;
+					  baseVirt=Normal;
+					  baseName.resize(0);
+					}
+<Bases>{B}*"{"{B}*			{ current->fileName = yyFileName ;
+					  current->startLine = yyLineNr ;
+  					  if (baseName.length()>0)
+  					    current->extends->append(
+					      new BaseInfo(baseName,baseProt,baseVirt)
+					    );
+					  BEGIN( Curly ) ;
+					}
+<Comment>\n				{ current->program += yytext ;
+					  yyLineNr++ ;
+					}
+<Comment>"/*"				{ current->program += yytext ; } 
+<Comment>"//"				{ current->program += yytext ; }
+<Comment>.				{ current->program += *yytext ; }
+<Comment>.*"*/"				{ current->program += yytext ;
+					  BEGIN( Curly ) ;
+					}
+
+<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,Operator>("//"{B}*)?"/*!" { 
+					  removeSlashes=(yytext[1]=='/');
+					  tmpDocType=-1;
+					  if (YY_START==Curly)
+					    current->doc+="\n\n";
+					  else
+  					    current->doc.resize(0);
+					  lastDocContext = YY_START;
+					  if (current_root->section & Entry::SCOPE_MASK)
+					    current->inside = current_root->name+"::";
+					  BEGIN( Doc );
+					}
+<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,Operator>("//"{B}*)?"/**"/[^/*] {
+  					  removeSlashes=(yytext[1]=='/');
+					  if (current_root->section & Entry::SCOPE_MASK)
+					    current->inside = current_root->name+"::";
+					  if (YY_START==Curly)
+					  {
+					    tmpDocType=-1;
+					    current->doc+="\n\n";
+					    lastDocContext = Curly;
+					    BEGIN( Doc );
+					  }
+					  else
+					  {  
+					    tmpDocType=Doc;
+					    current->doc.resize(0);
+					    current->brief.resize(0);
+					    lastDocContext = YY_START;
+					    BEGIN( JavaDoc );
+					  }
+  					}
+<FindMembers,FindFields,MemberSpec,FuncQual,Operator>"//!" { 
+  					  current->brief.resize(0);
+					  tmpDocType=-1;
+					  lastDocContext = YY_START;
+					  if (current_root->section & Entry::SCOPE_MASK)
+					    current->inside = current_root->name+"::";
+					  BEGIN( LineDoc );
+					}
+<FindMembers,FindFields,MemberSpec,FuncQual,Operator>"///"/[^/] { 
+  					  current->brief.resize(0);
+					  tmpDocType=-1;
+					  lastDocContext = YY_START;
+					  if (current_root->section & Entry::SCOPE_MASK)
+					    current->inside = current_root->name+"::";
+					  BEGIN( LineDoc );
+					}
+<FindMembers>"extern"{BN}+"\"C"("++")?"\""{BN}+("{")?
+<FindMembers>"{"			{
+  					  current->type.resize(0);
+  					  current->name.resize(0);
+  					  current->args.resize(0);
+					  current->argList->clear();
+					  bracketCount=0;
+					  BEGIN( SkipBlock );
+					  	
+  					}
+<JavaDoc>"@short"{B}+			{
+  					  lastBriefContext=Doc;
+  					  BEGIN( ClassDocBrief ); 
+					}
+<JavaDoc>^(({B}*"*"+)?){BL}		{
+					  lineCount();
+					  if (!current->brief.stripWhiteSpace().isEmpty())
+					  {
+					    BEGIN( tmpDocType );
+					  }
+ 					} 
+<JavaDoc>"@"				{
+  					  unput(*yytext);
+					  BEGIN(Doc);
+  					}
+<JavaDoc>^{B}*"*"+/[^/]			{
+  					  //printf("---> removing %s\n",yytext);
+  					}
+  /*
+<JavaDoc>[^\n\@\*\.\\]+			{
+  					  current->brief+=yytext;
+  					}
+  */
+<JavaDoc>.				{
+  				          //printf("---> copy %c\n",*yytext);
+  					  current->brief+=*yytext;
+  					}
+<JavaDoc>\n				{
+  					  current->brief+=' ';
+					  lineCount();
+  					}
+<JavaDoc>"."[ \t\r\n]			{
+  					  lineCount();
+					  current->brief+=".";
+					  BEGIN( tmpDocType );
+					}
+<JavaDoc>("\\"|"@")"internal"		{
+  					  current->doc+="\\internal";
+  					  BEGIN( tmpDocType );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")("fn"|"var"|"typedef"){B}*	{
+					  current->section = Entry::MEMBERDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+  					  BEGIN( ClassDocFunc ); 
+					}
+<LineDoc,Doc,JavaDoc>{B}*("\\"|"@")"def"{B}*	{
+  					  nextDefContext = YY_START==LineDoc ? DefLineDoc : ClassDoc;
+  					  current->section = Entry::DEFINEDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+  					  BEGIN( ClassDocDefine );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"overload"{B}* { 
+  					  BEGIN( ClassDocOverload ); 
+					}
+<ClassDocOverload>{B}*"\n"	        {
+					  QString orgDoc = current->doc;
+					  current->doc = getOverloadDocs();
+					  current->doc += "\n\n";
+					  current->doc += orgDoc;
+  					  yyLineNr++;
+  					  BEGIN( Doc );
+  				        }
+<ClassDocOverload>.                     { unput(*yytext);
+  					  current->section = Entry::OVERLOADDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( ClassDocFunc ); 
+					}
+<Doc,JavaDoc>{B}*("\\"|"@")"enum"{B}*	{
+  					  current->section = Entry::ENUMDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( EnumDocArg1 );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"defgroup"{B}* {
+  					  current->section = Entry::GROUPDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( GroupDocArg1 );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"namespace"{B}*	{
+  					  current->section = Entry::NAMESPACEDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+  					  BEGIN( NameSpaceDocArg1 );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"class"{B}*  {
+  					  current->section = Entry::CLASSDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( ClassDocArg1 ); 
+					}
+<Doc,JavaDoc>{B}*("\\"|"@")"union"{B}*  {
+  					  current->section = Entry::UNIONDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( ClassDocArg1 ); 
+					}
+<Doc,JavaDoc>{B}*("\\"|"@")"struct"{B}* {
+  					  current->section = Entry::STRUCTDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( ClassDocArg1 ); 
+					}
+<Doc,JavaDoc>{B}*("\\"|"@")"page"{B}*   {
+  					  current->section = Entry::PAGEDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( PageDocArg1 );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"file"{B}*	{
+  					  current->section = Entry::FILEDOC_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+					  BEGIN( FileDocArg1 );
+  					}
+<Doc,JavaDoc>{B}*("\\"|"@")"example"{B}* {
+ 					  current->section = Entry::EXAMPLE_SEC;
+					  current->fileName = yyFileName;
+					  current->startLine = yyLineNr;
+ 					  BEGIN( ExampleDocArg1 );
+					}
+<ExampleDocArg1>{FILE}			{
+				          current->name = stripQuotes(yytext);	
+					  BEGIN( ExampleDoc );
+					}
+<ClassDoc,Doc,JavaDoc>{B}*("\\"|"@")"relate"[sd]{B}*    { 
+  					  lastDocRelContext = YY_START;
+  					  BEGIN( ClassDocRelates ); 
+					}
+<ClassDocRelates>{ID}			{ 
+  					  current->relates = yytext;
+					  BEGIN( lastDocRelContext );
+					}
+<NameSpaceDocArg1>{SCOPENAME}		{
+  					  current->name = yytext;
+					  newDocState();
+  					}
+<NameSpaceDocArg1>"\n"			{
+  					  warn("Warning: missing argument after "
+					       "\\namespace at line %d of %s.\n",yyLineNr,yyFileName);
+  					  yyLineNr++;
+  					}
+<ClassDocArg1>{SCOPENAME}		{
+					  current->name = yytext;
+					  // prepend outer scope name 
+					  if (current_root->section & Entry::SCOPE_MASK)
+					  {
+					    current->name.prepend(current_root->name+"::");
+					  }
+					  BEGIN( ClassDocArg2 );
+					}
+<ClassDocArg1>"\n"			{
+  					  warn("Warning: missing argument after "
+					       "\\class at line %d of %s.\n",yyLineNr,yyFileName);
+  					  yyLineNr++;
+					  
+  					}
+<GroupDocArg1>{ID}(".html"?)		{
+  					  current->name = yytext;
+					  if (current->name.right(5)==".html") 
+					    current->name=current->name.left(current->name.length()-5);
+					  BEGIN(GroupDocArg2);
+  					}
+<GroupDocArg1>"\n"			{
+  					  warn("Warning: missing argument after "
+					       "\\defgroup at line %d of %s.\n",yyLineNr,yyFileName);
+					  yyLineNr++;
+					  BEGIN( Doc );
+  					}
+<GroupDocArg2>.*			{
+					  current->type = yytext;
+					  current->type = current->type.stripWhiteSpace();
+					  newDocState();
+  					}
+<GroupDocArg2>"\n"			{
+ 					  newDocState();
+  					}
+<ClassDocArg2>{FILE}			{
+  					  //printf("ClassDocArg2=%s\n",yytext);
+					  current->includeFile = stripQuotes(yytext);
+					  BEGIN( ClassDocArg3 );
+					}
+<ClassDocArg2>{BL}			{ yyLineNr++; 
+					  newDocState();
+					}
+<ClassDocArg3>{FILE}			{
+  					  //printf("ClassDocArg3=%s\n",yytext);
+ 					  current->includeName = stripQuotes(yytext);
+  					  newDocState();
+					}
+<ClassDocArg3>{BL}			{ yyLineNr++; 
+  					  newDocState();
+					}
+<FileDocArg1>{FILE}			{
+  					  current->name = stripQuotes(yytext);
+					  newDocState();
+  				        }
+<FileDocArg1>"\n"			{
+  					  //warn("Warning: missing argument after "
+					  //     "\\file at line %d of %s.\n",yyLineNr,yyFileName);
+  					  current->name = yyFileName;
+  					  yyLineNr++;
+					  newDocState();
+  					}
+<PageDocArg1>{FILE}			{
+					  current->name = stripQuotes(yytext);
+					  BEGIN( PageDocArg2 ); 
+					}
+<PageDocArg1>"\n"			{
+  					  warn("Warning: missing argument after "
+					       "\\page at line %d of %s.\n",yyLineNr,yyFileName);
+  					  yyLineNr++;
+					  BEGIN( Doc );
+  					}
+<PageDocArg2>.*"\n"			{
+  				          yyLineNr++;
+					  current->args = yytext;
+					  BEGIN( PageDoc );
+					}
+<EnumDocArg1>{SCOPEID}			{
+  					  current->name = yytext;
+					  if (current_root->section & Entry::SCOPE_MASK)
+					  {
+					    current->name.prepend(current_root->name+"::");
+					  }
+  					  newDocState();
+  					}
+<EnumDocArg1>"\n"			{
+  					  warn("Warning: missing argument after "
+					       "\\enum at line %d of %s.\n",yyLineNr,yyFileName);
+  					  yyLineNr++;
+					  BEGIN( Doc );
+  					}
+<PageDoc>"\\refitem".*"\n"		{
+  					  current->doc+=yytext;
+  					}
+<PageDoc>("\\"|"@")"section"{B}+	{
+  					  isSubsection=FALSE;
+  					  BEGIN(SectionLabel);
+  					}
+<PageDoc>("\\"|"@")"subsection"{B}+	{
+  					  isSubsection=TRUE;
+  					  BEGIN(SectionLabel);
+  					}
+<Doc,PageDoc,JavaDoc,ClassDoc>"\\\\verbatim"/[^a-z_A-Z0-9] {
+					  current->doc+="\\\\verbatim";
+					}
+<Doc,PageDoc,JavaDoc,ClassDoc>("\\"|"@")"verbatim"/[^a-z_A-Z0-9] {
+					  lastVerbState=YY_START;
+					  current->doc+="\\verbatim";
+  					  BEGIN(SkipVerbatim);
+  					}
+<Doc,PageDoc,JavaDoc,ClassDoc>"\\\\code"/[^a-z_A-Z0-9] {
+  					  current->doc+="\\\\code";
+  					}
+<Doc,PageDoc,JavaDoc,ClassDoc>("\\"|"@")"code"/[^a-z_A-Z0-9] {
+  					  lastCodeState=YY_START;
+					  current->doc+="\\code";
+					  BEGIN(SkipCode);
+					}
+<Doc,PageDoc,JavaDoc,ClassDoc>"<"{PRE}{ATTR}">" {
+  					  lastCodeState=YY_START;
+					  current->doc+="<PRE>";
+					  BEGIN(SkipCode);
+  					}
+<SkipVerbatim>("\\"|"@")"endverbatim"/[^a-z_A-Z0-9] {
+  					  current->doc+=yytext;
+  					  BEGIN(lastVerbState);
+  					}
+<SkipVerbatim>[^ \t\/\\\n]*		{
+  					  current->doc+=yytext;
+  					}
+<SkipVerbatim>^"//"			{
+  					  if (!removeSlashes)
+					    current->doc+=yytext;
+  					}
+  /*
+<SkipVerbatim>^"//"({B}*"*"+)?		{
+  					  if (!removeSlashes)
+					    current->doc+=yytext;
+  					}
+<SkipVerbatim>^{B}*"*"+			
+  */
+<SkipVerbatim>"//"|"/*"			{ 
+  					  current->doc+=yytext; 
+  					}
+<SkipVerbatim>"\n"			{
+  					  yyLineNr++;
+					  current->doc+=*yytext;
+  					}
+<SkipVerbatim>.				{
+  					  current->doc+=*yytext;
+  					}
+<SkipCode>("\\"|"@")"endcode"		{
+  					  current->doc+="\\endcode";
+					  BEGIN(lastCodeState);
+  					}
+<SkipCode>"</"{PRE}{ATTR}">"		{
+  					  current->doc+="</PRE>";
+					  BEGIN(lastCodeState);
+  					}
+<SkipCode>^"//"({B}*"*"+)?		{
+  					  if (!removeSlashes)
+					    current->doc+=yytext;
+  					}
+<SkipCode>^{B}*"*"+		
+<SkipCode>"//"				{
+  					  current->doc+=yytext;
+  					}
+<SkipCode>[^ \*\t\/\\\n]+		{
+  					  current->doc+=yytext;
+  					}
+<SkipCode>\n				{
+  					  yyLineNr++;
+					  current->doc+=*yytext;
+  					}
+<SkipCode>.				{
+  					  current->doc+=*yytext;
+  					}
+<SectionLabel>[a-z_A-Z0-9]+		{
+  					  sectionLabel=yytext;
+					  sectionTitle.resize(0);
+					  BEGIN(SectionTitle);
+  					}
+<SectionTitle>[^\n*]*/"\n"		{
+					  sectionTitle+=yytext;
+					  sectionTitle=sectionTitle.stripWhiteSpace();
+					  addSection();
+					  current->doc += "\\section "+sectionLabel+"\n";
+					  BEGIN(PageDoc);
+  					}
+<SectionTitle>"*"			{
+  					  sectionTitle+=yytext;
+  					}
+<ExampleDoc,PageDoc,ClassDoc>"\n"			{ yyLineNr++ ; current->doc+=yytext; }
+<ExampleDoc,PageDoc,ClassDoc>[a-z_A-Z0-9 \t]+		{ current->doc += yytext; }
+<ExampleDoc,PageDoc,ClassDoc>.    	 	        { current->doc += yytext; }
+<Doc,JavaDoc,LineDoc,ExampleDoc,PageDoc,ClassDoc>^{B}*"//" 
+<Doc,JavaDoc,LineDoc,ExampleDoc,PageDoc,ClassDoc>"//"  	{ current->doc += yytext; }
+<Doc,JavaDoc,LineDoc,ExampleDoc,ClassDocBrief,PageDoc,ClassDoc>"\\\\f"[$\[\]] {
+							  current->doc += &yytext[1]; 
+							}
+<Doc,JavaDoc,LineDoc,ExampleDoc,ClassDocBrief,PageDoc,ClassDoc>"\\f$"	{ 
+  							  lastFormulaContext = YY_START;
+  							  formulaText="$"; 
+							  BEGIN(ReadFormulaShort); 
+							}
+<Doc,JavaDoc,LineDoc,ExampleDoc,ClassDocBrief,PageDoc,ClassDoc>"\\f["	{ 
+  							  lastFormulaContext = YY_START;
+  							  formulaText="\\["; 
+							  BEGIN(ReadFormulaLong); 
+							}
+<ReadFormulaShort>"\\f$"				{
+  							  formulaText+="$";
+							  if (lastFormulaContext==ClassDocBrief)
+							    current->brief += addFormula();
+							  else
+							    current->doc += addFormula();
+							  BEGIN(lastFormulaContext);
+  							}
+<ReadFormulaLong>"\\f]"					{
+							  formulaText+="\\]";
+							  if (lastFormulaContext==ClassDocBrief)
+							    current->brief += addFormula();
+							  else
+							    current->doc += addFormula();
+							  BEGIN(lastFormulaContext);
+  							}
+<ReadFormulaLong,ReadFormulaShort>.                     { formulaText+=*yytext; }
+<ExampleDoc,PageDoc,ClassDocBrief,ClassDoc>"*/"    	{
+  					  if (YY_START==ClassDocBrief &&
+					      lastBriefContext==Doc)
+					  {
+  					    current->doc += "\n\n";
+  					    BEGIN( lastDocContext ); 
+					  }
+					  else
+					  {
+  					    current->doc += "\n\n";
+					    //printf("Add docs for class %s\n",current->name.data());
+					    current_root->addSubEntry(current);
+					    current = new Entry ;
+					    current->protection = protection ;
+				            current->sig = sig;
+					    current->virt = virt;
+					    current->stat = gstat;
+					    current->slot = slot;
+					  }
+					  BEGIN( FindMembers );
+					}
+<PageDoc>"<"{TITLE}">"			{ 
+  					  current->args.resize(0); 
+					  current->argList->clear();
+  					  BEGIN( PageDocTitle); 
+					}
+<PageDocTitle>\n			{ yyLineNr++; current->args+=" "; }
+<PageDocTitle>[^\n\<]			{ current->args+=yytext; }
+<PageDocTitle>"</"{TITLE}">"		{ BEGIN( PageDoc ); }
+<ClassDoc,Doc,JavaDoc>("\\"|"@")"ingroup"{B}+   { 
+  					  lastGroupContext = YY_START;
+  					  lineCount();
+  					  BEGIN( GroupName ); 
+					}
+<GroupName>{ID}				{
+  					  current->groups->append(
+					    new QString(yytext)
+					  );
+  					}
+<GroupName>\n				{
+  					  yyLineNr++; BEGIN( lastGroupContext );
+  					}
+<ClassDoc,Doc>{B}*("\\brief"|"@short")	{ 
+  					  lastBriefContext=YY_START;
+  					  BEGIN( ClassDocBrief ); 
+					}
+<ClassDoc>{B}*"\\inherit"{B}+	        { BEGIN( DocBaseClass ); }
+<DocBaseClass>{ID}			{
+					  //printf("Adding base class %s\n",yytext);
+					  current->extends->append(
+					    new BaseInfo(yytext,Public,Normal)
+					  );
+					}
+<DocBaseClass>\n			{ yyLineNr++; BEGIN( ClassDoc ); }
+<ClassDocBrief>{BS}{BL}			{ 
+  					  current->brief=current->brief.stripWhiteSpace();
+  					  yyLineNr++; 
+					  BEGIN( lastBriefContext );
+					}
+<ClassDocBrief>"\n"			{ yyLineNr++ ; current->brief += " "; }
+<ClassDocBrief>"<"{BR}{ATTR}">"
+<ClassDocBrief>{BS}/("\\"|"@")"ingroup"	{
+  					  current->brief=current->brief.stripWhiteSpace();
+					  BEGIN( lastBriefContext ); 
+  					}
+<ClassDocBrief>{BS}/("\\"|"@")"author"	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"internal" { BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"version"	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/"\\date"	        { BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"param"	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"exception" { BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"return"	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\sa"|"@see")	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"bug"	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"warning"	        { BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\"|"@")"par"{BN}+	{ BEGIN( lastBriefContext ); }
+<ClassDocBrief>{BS}/("\\brief"|"@short"){BN}+ {
+  					  lastBriefContext=YY_START;
+  					  BEGIN( ClassDocBrief ); 
+					}
+<ClassDocBrief>.			{ current->brief += *yytext; }
+<ClassDocDefine>{ID}/"("		{
+  					  current->name = yytext;
+					  BEGIN( ClassDefineArgs );
+  					}
+<ClassDocDefine>{ID}			{
+  					  current->name = yytext;
+					  if (nextDefContext==ClassDoc)
+					    newDocState();
+					  else 
+					    BEGIN( nextDefContext );
+  					}
+<ClassDefineArgs>")"			{
+  					  current->args+=")";
+					  if (nextDefContext==ClassDoc)
+					    newDocState();
+					  else
+					    BEGIN( nextDefContext );
+  					}
+<ClassDefineArgs>.			{
+  					  current->args+= yytext;
+  					}
+<ClassDocFunc>"\n"			{ 
+  					  yyLineNr++; 
+					  current->name = current->name.stripWhiteSpace();
+					  if (current->section == Entry::MEMBERDOC_SEC && current->args.length()==0)
+					    current->section = Entry::VARIABLEDOC_SEC;
+					  newDocState();
+					}
+<ClassDocFunc>"("			{
+  					  current->args+=*yytext;
+					  currentArgumentContext = ClassDocFuncQual;
+					  copyArgString=&current->args;
+					  BEGIN( ReadFuncArgType ) ;
+  					}
+<ClassDocFunc>"("({B}*"*")+		{
+  					  current->name+="(*";
+  					  BEGIN( ClassDocFuncPtr );
+  					}
+<ClassDocFuncPtr>{SCOPENAME}		{
+  					  current->name+=yytext;
+  					}
+<ClassDocFuncPtr>")"			{
+  					  current->name+=')';
+  					  BEGIN( ClassDocFunc );
+  					}
+<ClassDocFuncQual>{B}*"const"{B}*    	{ 
+  					  current->args += " const "; 
+					  current->argList->constSpecifier=TRUE;
+					}
+<ClassDocFuncQual>{B}*"volatile"{B}* 	{ 
+  					  current->args += " volatile "; 
+					  current->argList->volatileSpecifier=TRUE;
+					}
+<ClassDocFuncQual>{B}*"="{B}*"0"{B}*	{ 
+					  current->args += " = 0"; 
+					  current->virt = Pure; 
+					  current->argList->pureSpecifier=TRUE;
+					}
+<ClassDocFuncQual>"throw"{B}*"("	{
+  					  current->exception = "throw(";
+					  BEGIN(ClassDocFuncExc);
+  					}
+<ClassDocFuncExc>")"			{
+  					  current->exception += ')';
+					  BEGIN(ClassDocFuncQual);
+  					}
+<ClassDocFuncExc>.			{
+  					  current->exception += *yytext;
+  					}
+<ClassDocFunc,ClassDocFuncQual>.	{
+  					  current->name += *yytext;
+  					}
+<ClassDocFuncQual>"\n"			{
+  					  yyLineNr++; 
+					  current->name = current->name.stripWhiteSpace();
+					  newDocState();
+  					}
+<Doc>.					{ current->doc += *yytext; }
+<DefLineDoc,LineDoc>.			{ current->brief += *yytext; }
+<Doc>\n					{ yyLineNr++; current->doc += *yytext; }
+<LineDoc>\n				{ 
+					  yyLineNr++;  
+					  BEGIN( lastDocContext );
+					}
+<DefLineDoc>\n				{
+  					  yyLineNr++; 
+					  unput('/');unput('*');
+					  BEGIN( ClassDoc );
+  					}
+
+<AfterDocLine>"/*"|"//"			{ current->brief+=yytext; }
+<AfterDocLine>\n			{
+                                          if (afterDocTerminator!=0)
+					    unput(afterDocTerminator);
+					  BEGIN(lastAfterDocContext);
+  					}
+<AfterDocLine>.				{ current->brief+=yytext; }
+<AfterDocBrief>"/*"|"//"		{ current->brief+=yytext; }
+<AfterDocBrief>^{B}*"*"+/[^/\n]            
+<AfterDocBrief>\n			{ current->brief+=yytext; yyLineNr++; }
+<AfterDocBrief>.			{ current->brief+=*yytext; }
+<AfterDocBrief>^{B}*"*"/[^/\n]{BL}	{ yyLineNr++; 
+  					  if (!current->brief.stripWhiteSpace().isEmpty())
+					    BEGIN(AfterDoc); 
+					}
+<AfterDocBrief>"*/"			{
+                                          if (afterDocTerminator!=0)
+					    unput(afterDocTerminator);
+					  BEGIN(lastAfterDocContext);
+  					}
+<AfterDocBrief>"."/{BN}			{ BEGIN(AfterDoc); }
+<AfterDoc>("\\"|"@")"brief"		{ BEGIN(AfterDocBrief); }
+<AfterDoc>"/*"|"//"			{ current->doc+=yytext; }
+<AfterDoc>^{B}*"*"+/[^/]			
+<AfterDoc>\n				{ current->doc+=yytext; yyLineNr++; }
+<AfterDoc>.				{ current->doc+=*yytext; }
+<AfterDoc>"*/"				{
+                                          if (afterDocTerminator!=0)
+					    unput(afterDocTerminator);
+					  BEGIN(lastAfterDocContext);
+  					}
+<ClassDocRelates,ClassDocFunc,ClassDocDefine,GroupDocArg1,ClassDocArg1,SectionTitle,EnumDocArg1,FileDocArg1,PageDocArg1,ExampleDocArg1,ClassDefineArgs>"*/" {
+					  current->doc += "\n\n";
+					  err("Warning: unexpected end of "
+				              "documentation block found in "
+					      "file %s at line %d\n",yyFileName,yyLineNr);
+					  BEGIN( lastDocContext );
+					}
+<Doc>"*/"				{ 
+  					  current->doc += "\n\n";
+  					  BEGIN( lastDocContext ); 
+					}
+<JavaDoc>"*/"				{ 
+					  unput('/');unput('*');
+					  BEGIN( tmpDocType );
+					}
+<Doc,JavaDoc,ClassDoc,PageDoc,ExampleDoc,ReadFormulaShort,ReadFormulaLong,ClassDocBrief>^{B}*(("//"{B}*)?)"*"+/[^/]
+<DefLineDoc,LineDoc,ClassDoc,Doc>"/*"              { current->doc += yytext; }
+
+<SkipCxxComment>.*\n			{ yyLineNr++ ;
+					  BEGIN( lastCContext ) ;
+					}
+<*>.
+<*>\n					{ yyLineNr++ ; }
+<SkipComment>"//"|"/*"
+<*>"/*"					{ lastCContext = YY_START ;
+					  BEGIN( SkipComment ) ;
+					}
+<SkipComment>{B}*"*/"			{ BEGIN( lastCContext ) ; }
+<*>"//"				        {	
+  					  lastCContext = YY_START ;
+					  BEGIN( SkipCxxComment ) ;
+					}
+%%
+
+//----------------------------------------------------------------------------
+
+void scanString(const char *s)
+{
+  const char *oldInputString = inputString;
+  int oldInputPosition = inputPosition;
+  YY_BUFFER_STATE oldBuffer = YY_CURRENT_BUFFER;
+  yy_switch_to_buffer(yy_create_buffer(scanYYin, YY_BUF_SIZE));  
+  inputString  = s;
+  inputPosition = 0;
+  scanYYlex();
+  yy_delete_buffer(YY_CURRENT_BUFFER);
+  yy_switch_to_buffer(oldBuffer);
+  inputString = oldInputString;
+  inputPosition = oldInputPosition;
+}
+
+//----------------------------------------------------------------------------
+
+static void newDocState()
+{
+  if (tmpDocType!=-1)
+  {
+    tmpDocType=ClassDoc;
+    BEGIN(JavaDoc);
+  }
+  else
+  {
+    BEGIN(ClassDoc);
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void parseCompounds(Entry *rt)
+{
+  //printf("parseCompounds(%s)\n",rt->name.data());
+  EntryListIterator eli(*rt->sublist);
+  Entry *ce;
+  for (;(ce=eli.current());++eli)
+  {
+    if (ce->program.length()>0)
+    {
+      //printf("-- %s ---------\n%s\n---------------\n",
+      //  ce->name.data(),ce->program.data());
+      // init scanner state
+      inputString = ce->program;
+      inputPosition = 0;
+      scanYYrestart( scanYYin ) ;
+      if (ce->section==Entry::ENUM_SEC)
+	BEGIN( FindFields ) ;
+      else
+	BEGIN( FindMembers ) ;
+      current_root = ce ;
+      strcpy( yyFileName, ce->fileName ) ;
+      yyLineNr = ce->startLine ;
+      //current->reset();
+      current = new Entry;
+      // set default protection based on the compound type
+      if( ce->section==Entry::CLASS_SEC ) // class
+        current->protection = protection = Private ;
+      else if (ce->section == Entry::ENUM_SEC ) // enum
+	current->protection = protection = ce->protection;
+      else if (ce->name.length()>0 && ce->name.at(0)=='@') // anonymous union
+	current->protection = protection = ce->protection;
+      else // named struct or union
+	current->protection = protection = Public ;
+      sig = FALSE;
+      slot = FALSE;
+      gstat = FALSE;
+      virt = Normal;
+      scanYYlex() ;
+      delete current;
+      ce->program.resize(0);
+    }
+    parseCompounds(ce);
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void parseMain(Entry *rt)
+{
+  initParser();
+  anonCount     = 0;
+  protection    = Public;
+  sig           = FALSE;
+  slot          = FALSE;
+  gstat         = FALSE;
+  virt          = Normal;
+  current_root  = rt;
+  global_root   = rt;
+  current       = new Entry;
+  inputString   = rt->program;
+  inputPosition = 0;
+  ifCount=0;
+  scanYYrestart( scanYYin );
+  BEGIN( FindMembers );
+  scanYYlex();
+  rt->program.resize(0);
+  delete current;
+  parseCompounds(rt);
+}
+
+//----------------------------------------------------------------------------
+
+void parseDocument(OutputList &ol,const QString &docString)
+{
+  //inParamBlock=inSeeBlock=inReturnBlock=FALSE;
+  curTable = 0;
+  outDoc = new OutputList(&ol);
+  currentIncludeFile.resize(0);
+  includeFileOffset=0;
+  includeFileLength=0;
+  if (!docString) return;
+  linkRef  = "";
+  linkText = "";
+  inputString = docString;
+  inputPosition = 0;
+  scanYYrestart( scanYYin ); 
+  BEGIN( DocScan );
+  insideArgumentList = FALSE;
+  scanYYlex();
+  if (insideArgumentList) { insideArgumentList=FALSE; outDoc->endItemList(); }
+  if (inBlock()) endBlock();
+  ol+=*outDoc;
+  delete outDoc;
+  return;
+}
+
+//----------------------------------------------------------------------------
+
+void parseDoc(OutputList &ol,const char *clName,
+              const char *memName,const QString &docString)
+{
+  initParser();
+  initParseCodeContext();
+  exampleDoc=FALSE;           // do not cross reference with member docs
+  className=clName;
+  memberName=memName;
+  if (memName)
+  {
+    refName=className+"::"+memberName;
+  }
+  else
+  {
+    refName=className;
+  }
+  parseDocument(ol,docString);
+}
+
+//----------------------------------------------------------------------------
+
+void parseExample(OutputList &ol,const QString &docString, 
+                  const char *fileName)
+{
+  initParser();
+  initParseCodeContext();
+  exampleDoc=TRUE;            // cross reference with member docs
+  exampleName=fileName;
+  parseDocument(ol,docString); 
+}
+
+//----------------------------------------------------------------------------
+
+extern "C" { // some sillyness to keep the compiler happy
+int	scanYYwrap()	{ return 1 ; }
+void    bogus() { yy_flex_realloc(0,0); }
+}
+