1 /******************************************************************************

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 by Dimitri van Heesch.

     6  *

     7  * Permission to use, copy, modify, and distribute this software and its

     8  * documentation under the terms of the GNU General Public License is hereby 

     9  * granted. No representations are made about the suitability of this software 

    10  * for any purpose. It is provided "as is" without express or implied warranty.

    11  * See the GNU General Public License for more details.

    12  *

    13  * Documents produced by Doxygen are derivative works derived from the

    14  * input used in their production; they are not affected by this license.

    15  *

    16  */

    17 

    18 %{

    19 

    20 /*

    21  *	includes

    22  */

    23 

    24 #include <stdio.h>

    25 #include <assert.h>

    26 #include <ctype.h>

    27 #include <errno.h>

    28 

    29 #include "qtbc.h"

    30 #include <qarray.h>

    31 #include <qstack.h>

    32 #include <qfile.h>

    33 #include <qstrlist.h>

    34 #include <qdict.h>

    35 #include <qregexp.h>

    36 #include <qfileinfo.h>

    37 #include <qdir.h>

    38 #include <qmap.h>

    39   

    40 #include "pre.h"

    41 #include "constexp.h"

    42 #include "define.h"

    43 #include "doxygen.h"

    44 #include "message.h"

    45 #include "util.h"

    46 #include "defargs.h"

    47 #include "debug.h"

    48 #include "bufstr.h"

    49 #include "portable.h"

    50 #include "bufstr.h"

    51 

    52 #define YY_NEVER_INTERACTIVE 1

    53 

    54 struct FileState

    55 {

    56   FileState(int size) : fileBuf(size), oldFileBuf(0), oldFileBufPos(0) {}

    57   int lineNr;

    58   //FILE *filePtr;

    59   BufStr fileBuf;

    60   //FILE *oldYYin;

    61   BufStr *oldFileBuf;

    62   int oldFileBufPos;

    63   //bool isPlainFile;

    64   YY_BUFFER_STATE bufState;

    65   QCString fileName;

    66 };  

    67 

    68 /* -----------------------------------------------------------------

    69  *

    70  *	scanner's state

    71  */

    72 

    73 static int                g_yyLineNr   = 1;

    74 static QCString           g_yyFileName;

    75 static FileDef           *g_yyFileDef;

    76 static FileDef           *g_inputFileDef;

    77 static int                g_ifcount    = 0;

    78 static QStrList          *g_pathList = 0;  

    79 static QStack<FileState>  g_includeStack;

    80 static QDict<int>        *g_argDict;

    81 static int                g_defArgs = -1;

    82 static QCString           g_defName;

    83 static QCString           g_defText;

    84 static QCString           g_defLitText;

    85 static QCString           g_defArgsStr;

    86 static bool               g_defVarArgs;

    87 static int                g_level;

    88 static int                g_lastCContext;

    89 static int                g_lastCPPContext;

    90 static QArray<int>        g_levelGuard;

    91 static BufStr            *g_inputBuf;

    92 static int                g_inputBufPos;

    93 static BufStr            *g_outputBuf;

    94 static int                g_roundCount;

    95 static bool               g_quoteArg;

    96 static DefineDict        *g_fileDefineDict = new DefineDict(10009);

    97 static DefineDict        *g_expandedDict;

    98 static int                g_findDefArgContext;

    99 static QCString           g_lastGuardName;

   100 static QCString           g_incName;

   101 static QCString           g_guardExpr;

   102 static int                g_curlyCount;

   103 static bool               g_nospaces; // add extra spaces during macro expansion

   104 

   105 static bool               g_macroExpansion; // from the configuration

   106 static bool               g_expandOnlyPredef; // from the configuration

   107 static int                g_commentCount;

   108 static bool               g_insideComment;

   109 static bool               g_isImported;

   110 static QCString           g_blockName;

   111 static int                g_condCtx;

   112 static bool               g_skip;

   113 static QStack<bool>       g_condStack;

   114 static bool               g_insideCS; // C# has simpler preprocessor

   115 

   116 static bool               g_lexInit = FALSE;

   117 

   118 DefineDict* getFileDefineDict() 

   119 {

   120   return g_fileDefineDict;

   121 }

   122 

   123 static void setFileName(const char *name)

   124 {

   125   bool ambig;

   126   QFileInfo fi(name);

   127   g_yyFileName=convertToQCString(fi.absFilePath());

   128   g_yyFileDef=findFileDef(Doxygen::inputNameDict,g_yyFileName,ambig);

   129   if (g_yyFileDef == 0 && Config_getBool("PREPROCESS_INCLUDES")) {

   130 		// Search again using Doxygen::includeNameDict

   131 	    // First insert the include file in the Doxygen::includeNameDict if

   132 	    // it is not there already. This can happen if the Doxygen::includeNameDict

   133 	    // has scanned .../inc but the #include "usr/usr.h"

   134 	    // The Doxygen::includeNameDict will not have usr.h in it so we poke it in.

   135 		if (!Doxygen::includeNameDict->find(g_yyFileName.data())) {

   136 			//Debug::print(Debug::IncludeGraph, 0, "pre.l setFileName() inserting in Doxygen::includeNameDict: %s\n", name);

   137 			FileDef  *fd=new FileDef(fi.dirPath()+"/", fi.fileName());

   138             FileName *fn=0;

   139             if (!fi.absFilePath().isEmpty() && (fn=(*Doxygen::includeNameDict)[name])) {

   140 				fn->append(fd);

   141             } else {

   142 				fn = new FileName(fi.absFilePath(), name);

   143 				fn->append(fd);

   144 				Doxygen::includeNameDict->insert(name, fn);

   145             }

   146 			g_yyFileDef = fd;

   147 		} else {

   148 			// Search the dictionary

   149 			FileName *fn = Doxygen::includeNameDict->find(g_yyFileName.data());

   150 			FileNameIterator fni(*fn);

   151 			FileDef *fd = 0;

   152 			for (fni.toFirst(); (fd=fni.current()); ++fni) {

   153 				if (fd && fd->absFilePath() == g_yyFileName) {

   154 					break;

   155 				}

   156 				fd = 0;

   157 			}

   158 			g_yyFileDef = fd;

   159 		}

   160 		//printf("pre.l setFileName() searching Doxygen::includeNameDict for %s, result=%p\n", name, g_yyFileDef);

   161 		//Debug::print(Debug::IncludeGraph, 0, "pre.l setFileName() searching Doxygen::includeNameDict for %s, result=%p\n", name, g_yyFileDef);

   162   }

   163   if (g_yyFileDef && g_yyFileDef->isReference()) g_yyFileDef=0;

   164   g_insideCS = g_yyFileName.right(3)==".cs";

   165 }

   166 

   167 static void incrLevel()

   168 {

   169   g_level++;

   170   g_levelGuard.resize(g_level);

   171   g_levelGuard[g_level-1]=FALSE;

   172   //printf("%s line %d: incrLevel %d\n",g_yyFileName.data(),g_yyLineNr,g_level);

   173 }

   174 

   175 static void decrLevel()

   176 {

   177   //printf("%s line %d: decrLevel %d\n",g_yyFileName.data(),g_yyLineNr,g_level);

   178   if (g_level > 0)

   179   {

   180     g_level--;

   181     g_levelGuard.resize(g_level);

   182   }

   183   else

   184   {

   185     err("%s:%d: Error: More #endif's than #if's found.\n",

   186 	g_yyFileName.data(),g_yyLineNr);

   187   }

   188 }

   189 

   190 static bool otherCaseDone()

   191 {

   192   if (g_level==0)

   193   {

   194     err("%s:%d: Error: Found an #else without a preceding #if.\n",

   195 	g_yyFileName.data(),g_yyLineNr);

   196     return TRUE;

   197   }

   198   else

   199   {

   200     return g_levelGuard[g_level-1];

   201   }

   202 }

   203 

   204 static void setCaseDone(bool value)

   205 {

   206   g_levelGuard[g_level-1]=value;

   207 }

   208 

   209 static Define *isDefined(const char *name)

   210 {

   211   if (name)

   212   {

   213     Define *def;

   214     //if ((def=fileDefineCache->findDefine(g_yyFileName,name)) && !def->undef) 

   215     //	return def;

   216     if ((def=g_fileDefineDict->find(name)) && !def->undef) return def; 

   217   }

   218   return 0;

   219 }

   220 

   221 static QDict<void> g_allIncludes(10009);

   222 

   223 static FileState *checkAndOpenFile(const QCString &fileName,bool &alreadyIncluded)

   224 {

   225   alreadyIncluded = FALSE;

   226   FileState *fs = 0;

   227   //msg("checkAndOpenFile(%s)\n", fileName.data());

   228   QFileInfo fi(fileName);

   229   if (fi.exists() && fi.isFile())

   230   {

   231     QCString absName = convertToQCString(fi.absFilePath());

   232 	//msg("checkAndOpenFile() found: %s\n", absName.data());

   233     // global guard

   234     if (g_curlyCount==0) // not #include inside { ... }

   235     {

   236       if (g_allIncludes.find(absName)!=0)

   237       {

   238         alreadyIncluded = TRUE;

   239         //printf("  already included 1\n");

   240         if (!Config_getBool("PREPROCCESS_FULL_TU")) {

   241 			return 0; // already done

   242 		}

   243       } else {

   244 		g_allIncludes.insert(absName,(void *)0x8);

   245 	  }

   246     }

   247     // check include stack for absName

   248 	// This is equivelent to walking the stack and setting alreadyIncluded to

   249 	// TRUE if absName matches any filename

   250     QStack<FileState> tmpStack;

   251     g_includeStack.setAutoDelete(FALSE);

   252     while ((fs=g_includeStack.pop()))

   253     {

   254       if (fs->fileName==absName) alreadyIncluded=TRUE;

   255       tmpStack.push(fs);

   256     }

   257     while ((fs=tmpStack.pop()))

   258     {

   259       g_includeStack.push(fs);

   260     }

   261     g_includeStack.setAutoDelete(TRUE);

   262 

   263     if (alreadyIncluded)

   264     {

   265       //printf("  already included 2\n");

   266       return 0;

   267     }

   268     //printf("#include %s\n",absName.data());

   269 

   270     fs = new FileState(fi.size()+4096);

   271     alreadyIncluded = FALSE;

   272     if (!readInputFile(absName,fs->fileBuf))

   273     { // error

   274       //printf("  error reading\n");

   275       delete fs;

   276       fs=0;

   277     }

   278     else

   279     {

   280       fs->oldFileBuf    = g_inputBuf;

   281       fs->oldFileBufPos = g_inputBufPos;

   282     }

   283 

   284 #if 0

   285     QCString filterName = getFileFilter(absName);

   286     if (!filterName.isEmpty())

   287     {

   288       fs->isPlainFile = FALSE;

   289       QCString cmd = filterName+" \""+absName+"\"";

   290       fs->filePtr=portable_popen(cmd,"r");

   291       if (!fs->filePtr)

   292       {

   293         err("Error: could not execute filter %s, reason: %s\n",cmd.data(),

   294             strerror(errno));

   295       }

   296     }

   297     else

   298     {

   299       fs->isPlainFile = TRUE;

   300       fs->filePtr=fopen(absName,"r");

   301       if (!fs->filePtr)

   302       {

   303         err("Error: could not open file %s for reading, reason: %s \n",

   304             absName.data(),strerror(errno));

   305       }

   306     }

   307     if (!fs->filePtr) // error -> cleanup

   308     {

   309       delete fs;

   310       fs=0;

   311     }

   312     else

   313     {

   314       fs->oldYYin = preYYin;

   315     }

   316 #endif

   317 

   318   }

   319   return fs;

   320 }

   321 

   322 static FileState *findFile(const char *fileName,bool localInclude,bool &alreadyIncluded)

   323 {

   324   //msg("** findFile(%s,%d) g_yyFileName=%s\n",fileName,localInclude,g_yyFileName.data());

   325   if (localInclude && !g_yyFileName.isEmpty())

   326   {

   327     QFileInfo fi(g_yyFileName);

   328     if (fi.exists())

   329     {

   330       QCString absName = QCString(fi.dirPath(TRUE).data())+"/"+fileName;

   331       FileState *fs = checkAndOpenFile(absName,alreadyIncluded);

   332       if (fs)

   333       {

   334 	setFileName(absName);

   335 	g_yyLineNr=1;

   336 	return fs;

   337       }

   338       else if (alreadyIncluded)

   339       {

   340 	return 0;

   341       }

   342     }

   343   }

   344   if (g_pathList==0) 

   345   {

   346     return 0;

   347   }

   348   char *s=g_pathList->first();

   349   while (s)

   350   {

   351     QCString absName = (QCString)s+"/"+fileName;

   352     FileState *fs = checkAndOpenFile(absName,alreadyIncluded);

   353     if (fs)

   354     {

   355       setFileName(absName);

   356       g_yyLineNr=1;

   357       return fs;

   358     }

   359     else if (alreadyIncluded)

   360     {

   361       return 0;

   362     }

   363 

   364     s=g_pathList->next();

   365   } 

   366   return 0;

   367 }

   368 

   369 static QCString extractTrailingComment(const char *s)

   370 {

   371   if (s==0) return "";

   372   int i=strlen(s)-1;

   373   while (i>=0)

   374   {

   375     char c=s[i];

   376     switch (c)

   377     {

   378       case '/':

   379 	{

   380 	  i--;

   381 	  if (i>=0 && s[i]=='*') // end of a comment block

   382 	  {

   383 	    i--;

   384 	    while (i>0 && !(s[i-1]=='/' && s[i]=='*')) i--;

   385 	    if (i==0) return s; else return &s[i-1];

   386 	  }

   387 	  else

   388 	  {

   389 	    return "";

   390 	  }

   391 	} 

   392 	break;

   393 	// whitespace or line-continuation

   394       case ' ':

   395       case '\t': 

   396       case '\r':

   397       case '\n':

   398       case '\\':

   399 	break;

   400       default:

   401 	return "";

   402     }

   403     i--;

   404   }

   405   return "";

   406 }

   407 

   408 static int getNextChar(const QCString &expr,QCString *rest,uint &pos);

   409 static int getCurrentChar(const QCString &expr,QCString *rest,uint pos);

   410 static void unputChar(const QCString &expr,QCString *rest,uint &pos,char c);

   411 static void expandExpression(QCString &expr,QCString *rest,int pos);

   412 

   413 static QCString stringize(const QCString &s)

   414 {

   415   QCString result;

   416   uint i=0;

   417   bool inString=FALSE;

   418   bool inChar=FALSE;

   419   char c,pc;

   420   while (i<s.length())

   421   {

   422     if (!inString && !inChar)

   423     {

   424       while (i<s.length() && !inString && !inChar)

   425       {

   426 	c=s.at(i++);

   427 	if (c=='"')

   428 	{

   429 	  result+="\\\"";

   430 	  inString=TRUE;

   431 	}

   432 	else if (c=='\'')

   433 	{

   434 	  result+=c;

   435 	  inChar=TRUE;

   436 	}

   437 	else

   438 	{

   439 	  result+=c;

   440 	}

   441       }

   442     }

   443     else if (inChar)

   444     {

   445       while (i<s.length() && inChar)

   446       {

   447 	c=s.at(i++);

   448 	if (c=='\'')

   449 	{

   450 	  result+='\'';

   451 	  inChar=FALSE;

   452 	}

   453 	else if (c=='\\')

   454 	{

   455 	  result+="\\\\";

   456 	}

   457 	else

   458 	{

   459 	  result+=c;

   460 	}

   461       }

   462     }

   463     else

   464     {

   465       pc=0;

   466       while (i<s.length() && inString)

   467       {

   468 	char c=s.at(i++);

   469 	if (c=='"') 

   470 	{

   471 	  result+="\\\"";

   472 	  inString= pc=='\\';

   473 	}

   474 	else if (c=='\\')

   475 	  result+="\\\\";

   476 	else

   477 	  result+=c;

   478 	pc=c;

   479       }

   480     }

   481   }

   482   //printf("stringize `%s'->`%s'\n",s.data(),result.data());

   483   return result;

   484 }

   485 

   486 /*! Execute all ## operators in expr. 

   487  * If the macro name before or after the operator contains a no-rescan 

   488  * marker (@-) then this is removed (before the concatenated macro name

   489  * may be expanded again.

   490  */

   491 static void processConcatOperators(QCString &expr)

   492 {

   493   //printf("processConcatOperators: in=`%s'\n",expr.data());

   494   QRegExp r("[ \\t\\n]*##[ \\t\\n]*"); 

   495   int l,n,i=0;

   496   if (expr.isEmpty()) return;

   497   while ((n=r.match(expr,i,&l))!=-1)

   498   {

   499     //printf("Match: `%s'\n",expr.data()+i);

   500     if (n+l+1<(int)expr.length() && expr.at(n+l)=='@' && expr.at(n+l+1)=='-')

   501     {

   502       // remove no-rescan marker after ID

   503       l+=2;

   504     }

   505     //printf("found `%s'\n",expr.mid(n,l).data());

   506     // remove the ## operator and the surrounding whitespace

   507     expr=expr.left(n)+expr.right(expr.length()-n-l);

   508     int k=n-1;

   509     while (k>=0 && isId(expr.at(k))) k--; 

   510     if (k>0 && expr.at(k)=='-' && expr.at(k-1)=='@')

   511     {

   512       // remove no-rescan marker before ID

   513       expr=expr.left(k-1)+expr.right(expr.length()-k-1);

   514       n-=2;

   515     }

   516     i=n;

   517   }

   518   //printf("processConcatOperators: out=`%s'\n",expr.data());

   519 }

   520 

   521 static void yyunput (int c,char *buf_ptr  );

   522 static void returnCharToStream(char c)

   523 {

   524   unput(c);

   525 }

   526 

   527 static inline void addTillEndOfString(const QCString &expr,QCString *rest,

   528                                        uint &pos,char term,QCString &arg)

   529 {

   530   int cc;

   531   while ((cc=getNextChar(expr,rest,pos))!=EOF)

   532   {

   533     if (cc=='\\') arg+=(char)cc,cc=getNextChar(expr,rest,pos);

   534     else if (cc==term) return;

   535     arg+=(char)cc;

   536   }

   537 }

   538 

   539 /*! replaces the function macro \a def whose argument list starts at

   540  * \a pos in expression \a expr. 

   541  * Notice that this routine may scan beyond the \a expr string if needed.

   542  * In that case the characters will be read from the input file.

   543  * The replacement string will be returned in \a result and the 

   544  * length of the (unexpanded) argument list is stored in \a len.

   545  */ 

   546 static bool replaceFunctionMacro(const QCString &expr,QCString *rest,int pos,int &len,const Define *def,QCString &result)

   547 {

   548   //printf("replaceFunctionMacro(expr=%s,rest=%s,pos=%d,def=%s) level=%d\n",expr.data(),rest ? rest->data() : 0,pos,def->name.data(),g_level);

   549   uint j=pos;

   550   len=0;

   551   result.resize(0);

   552   int cc;

   553   while ((cc=getCurrentChar(expr,rest,j))!=EOF && isspace(cc)) 

   554   { 

   555     len++; 

   556     getNextChar(expr,rest,j); 

   557   }

   558   if (cc!='(') 

   559   { 

   560     unputChar(expr,rest,j,' '); 

   561     return FALSE; 

   562   }

   563   getNextChar(expr,rest,j); // eat the `(' character

   564 

   565   QDict<QCString> argTable;  // list of arguments

   566   argTable.setAutoDelete(TRUE);

   567   QCString arg;

   568   int argCount=0;

   569   bool done=FALSE;

   570   

   571   // PHASE 1: read the macro arguments

   572   if (def->nargs==0)

   573   {

   574     while ((cc=getNextChar(expr,rest,j))!=EOF)

   575     {

   576       char c = (char)cc;

   577       if (c==')') break;

   578     }

   579   }

   580   else

   581   {

   582     while (!done && (argCount<def->nargs || def->varArgs) && 

   583 	((cc=getNextChar(expr,rest,j))!=EOF)

   584 	  )

   585     {

   586       char c=(char)cc;

   587       if (c=='(') // argument is a function => search for matching )

   588       {

   589 	int level=1;

   590 	arg+=c;

   591 	//char term='\0';

   592 	while ((cc=getNextChar(expr,rest,j))!=EOF)

   593 	{

   594 	  char c=(char)cc;

   595 	  //printf("processing %c: term=%c (%d)\n",c,term,term);

   596 	  if (c=='\'' || c=='\"') // skip ('s and )'s inside strings

   597 	  {

   598 	    arg+=c;

   599 	    addTillEndOfString(expr,rest,j,c,arg);

   600 	  }

   601 	  if (c==')')

   602 	  {

   603 	    level--;

   604 	    arg+=c;

   605 	    if (level==0) break;

   606 	  }

   607 	  else if (c=='(')

   608 	  {

   609 	    level++;

   610 	    arg+=c;

   611 	  }

   612 	  else

   613 	    arg+=c;

   614 	}

   615       }

   616       else if (c==')' || c==',') // last or next argument found

   617       {

   618 	if (c==',' && argCount==def->nargs-1 && def->varArgs)

   619 	{

   620 	  arg=arg.stripWhiteSpace();

   621 	  arg+=',';

   622 	}

   623 	else

   624 	{

   625 	  QCString argKey;

   626 	  argKey.sprintf("@%d",argCount++); // key name

   627 	  arg=arg.stripWhiteSpace();

   628 	  // add argument to the lookup table

   629 	  argTable.insert(argKey, new QCString(arg));

   630 	  arg.resize(0);

   631 	  if (c==')') // end of the argument list

   632 	  {

   633 	    done=TRUE;

   634 	  }

   635 	}

   636       } 

   637       else if (c=='\"') // append literal strings

   638       {

   639 	arg+=c; 

   640 	bool found=FALSE;

   641 	while (!found && (cc=getNextChar(expr,rest,j))!=EOF)

   642 	{

   643 	  found = cc=='"';

   644 	  if (cc=='\\')

   645 	  {

   646 	    c=(char)cc;	  

   647 	    arg+=c;

   648 	    if ((cc=getNextChar(expr,rest,j))==EOF) break;

   649 	  }

   650 	  c=(char)cc;	  

   651 	  arg+=c;

   652 	}

   653       }

   654       else if (c=='\'') // append literal characters

   655       {

   656 	arg+=c;

   657 	bool found=FALSE;

   658 	while (!found && (cc=getNextChar(expr,rest,j))!=EOF)

   659 	{

   660 	  found = cc=='\'';

   661 	  if (cc=='\\')

   662 	  {

   663 	    c=(char)cc;	  

   664 	    arg+=c;

   665 	    if ((cc=getNextChar(expr,rest,j))==EOF) break;

   666 	  }

   667 	  c=(char)cc;

   668 	  arg+=c;

   669 	}

   670       }	    

   671       else // append other characters

   672       {

   673 	arg+=c;

   674       }

   675     }

   676   }

   677 

   678   // PHASE 2: apply the macro function

   679   if (argCount==def->nargs || 

   680       (argCount>def->nargs && def->varArgs)) // matching parameters lists

   681   {

   682     uint k=0;

   683     // substitution of all formal arguments

   684     QCString resExpr;

   685     const QCString d=def->definition.stripWhiteSpace();

   686     //printf("Macro definition: %s\n",d.data());

   687     bool inString=FALSE;

   688     while (k<d.length())

   689     {

   690       if (d.at(k)=='@') // maybe a marker, otherwise an escaped @

   691       {

   692 	if (d.at(k+1)=='@') // escaped @ => copy it (is unescaped later)

   693 	{

   694 	  k+=2;

   695 	  resExpr+="@@"; // we unescape these later

   696 	}

   697 	else if (d.at(k+1)=='-') // no-rescan marker

   698 	{

   699 	  k+=2;

   700 	  resExpr+="@-";

   701 	}

   702 	else // argument marker => read the argument number

   703 	{

   704 	  QCString key="@";

   705 	  QCString *subst=0;

   706 	  bool hash=FALSE;

   707 	  int l=k-1;

   708 	  // search for ## backward

   709 	  if (l>=0 && d.at(l)=='"') l--;

   710 	  while (l>=0 && d.at(l)==' ') l--;

   711 	  if (l>0 && d.at(l)=='#' && d.at(l-1)=='#') hash=TRUE;

   712 	  k++;

   713 	  // scan the number

   714 	  while (k<d.length() && d.at(k)>='0' && d.at(k)<='9') key+=d.at(k++);

   715 	  if (!hash) 

   716 	  {

   717 	    // search for ## forward

   718 	    l=k;

   719 	    if (l<(int)d.length() && d.at(l)=='"') l++;

   720 	    while (l<(int)d.length() && d.at(l)==' ') l++;

   721 	    if (l<(int)d.length()-1 && d.at(l)=='#' && d.at(l+1)=='#') hash=TRUE;

   722 	  }

   723 	  //printf("request key %s result %s\n",key.data(),argTable[key]->data());

   724 	  if (key.length()>1 && (subst=argTable[key])) 

   725 	  {

   726 	    QCString substArg=*subst;

   727 	    //printf("substArg=`%s'\n",substArg.data());

   728 	    // only if no ## operator is before or after the argument

   729 	    // marker we do macro expansion.

   730 	    if (!hash) expandExpression(substArg,0,0);

   731 	    if (inString)

   732 	    {

   733 	      //printf("`%s'=stringize(`%s')\n",stringize(*subst).data(),subst->data());

   734 

   735 	      // if the marker is inside a string (because a # was put 

   736 	      // before the macro name) we must escape " and \ characters

   737 	      resExpr+=stringize(substArg);

   738 	    }

   739 	    else

   740 	    {

   741 	      if (hash && substArg.isEmpty())

   742 	      {

   743 		resExpr+="@E"; // empty argument will be remove later on

   744 	      }

   745 	      else if (g_nospaces)

   746 	      {

   747 	        resExpr+=substArg;

   748 	      }

   749 	      else

   750 	      {

   751 	        resExpr+=" "+substArg+" ";

   752 	      }

   753 	    }

   754 	  }

   755 	}

   756       }

   757       else // no marker, just copy

   758       {

   759 	if (!inString && d.at(k)=='\"') 

   760 	{

   761 	  inString=TRUE; // entering a literal string

   762 	}

   763 	else if (inString && d.at(k)=='\"' && (d.at(k-1)!='\\' || d.at(k-2)=='\\'))

   764 	{

   765 	  inString=FALSE; // leaving a literal string

   766 	}

   767 	resExpr+=d.at(k++);

   768       }

   769     }

   770     len=j-pos;

   771     result=resExpr;

   772     //printf("result after substitution `%s' expr=`%s'\n",

   773     //       result.data(),expr.mid(pos,len).data());

   774     return TRUE;

   775   }

   776   return FALSE;

   777 }

   778 

   779 

   780 /*! returns the next identifier in string \a expr by starting at position \a p.

   781  * The position of the identifier is returned (or -1 if nothing is found)

   782  * and \a l is its length. Any quoted strings are skipping during the search.

   783  */

   784 static int getNextId(const QCString &expr,int p,int *l)

   785 {

   786   int n;

   787   while (p<(int)expr.length())

   788   {

   789     char c=expr.at(p++);

   790     if (isdigit(c)) // skip number

   791     {

   792       while (p<(int)expr.length() && isId(expr.at(p))) p++;

   793     }

   794     else if (isalpha(c) || c=='_') // read id

   795     {

   796       n=p-1;

   797       while (p<(int)expr.length() && isId(expr.at(p))) p++;

   798       *l=p-n;

   799       return n; 

   800     }

   801     else if (c=='"') // skip string

   802     {

   803       char ppc=0,pc=c;

   804       if (p<(int)expr.length()) c=expr.at(p);

   805       while (p<(int)expr.length() && (c!='"' || (pc=='\\' && ppc!='\\'))) 

   806 	// continue as long as no " is found, but ignoring \", but not \\"

   807       {

   808 	ppc=pc;

   809 	pc=c;

   810 	c=expr.at(p);

   811 	p++;

   812       }

   813       if (p<(int)expr.length()) ++p; // skip closing quote

   814     }

   815     else if (c=='/') // skip C Comment

   816     {

   817       char pc=c;

   818       if (p<(int)expr.length()) 

   819       {

   820 	c=expr.at(++p);

   821         if (c=='*')  // Start of C comment

   822         { 

   823   	  while (p<(int)expr.length() && !(pc=='*' && c=='/'))

   824 	  {

   825 	    pc=c;

   826 	    c=expr.at(++p);

   827 	  }

   828 	  p++;

   829         }

   830       }

   831     }

   832   }

   833   return -1;

   834 }

   835 

   836 /*! preforms recursive macro expansion on the string \a expr

   837  *  starting at position \a pos.

   838  *  May read additional characters from the input while re-scanning!

   839  *  If \a expandAll is \c TRUE then all macros in the expression are

   840  *  expanded, otherwise only the first is expanded.

   841  */

   842 static void expandExpression(QCString &expr,QCString *rest,int pos)

   843 {

   844   //printf("expandExpression(%s,%s)\n",expr.data(),rest ? rest->data() : 0);

   845   QCString macroName;

   846   QCString expMacro;

   847   bool definedTest=FALSE;

   848   int i=pos,l,p,len;

   849   while ((p=getNextId(expr,i,&l))!=-1) // search for an macro name

   850   {

   851     bool replaced=FALSE;

   852     macroName=expr.mid(p,l);

   853     if (p<2 || !(expr.at(p-2)=='@' && expr.at(p-1)=='-')) // no-rescan marker?

   854     {

   855       if (g_expandedDict->find(macroName)==0) // expand macro

   856       {

   857 	Define *def=isDefined(macroName);

   858 	if (definedTest) // macro name was found after defined 

   859 	{

   860 	  if (def) expMacro = " 1 "; else expMacro = " 0 ";

   861 	  replaced=TRUE;

   862 	  len=l;

   863 	  definedTest=FALSE;

   864 	}

   865 	else if (def && def->nargs==-1) // simple macro

   866 	{

   867 	  // substitute the definition of the macro

   868 	  //printf("macro `%s'->`%s'\n",macroName.data(),def->definition.data());

   869 	  if (g_nospaces)

   870 	  {

   871 	    expMacro=def->definition.stripWhiteSpace();

   872 	  }

   873 	  else

   874 	  {

   875 	    expMacro=" "+def->definition.stripWhiteSpace()+" ";

   876 	  }

   877 	  //expMacro=def->definition.stripWhiteSpace();

   878 	  replaced=TRUE;

   879 	  len=l;

   880 	  //printf("simple macro expansion=`%s'->`%s'\n",macroName.data(),expMacro.data());

   881 	}

   882 	else if (def && def->nargs>=0) // function macro

   883 	{

   884 	  replaced=replaceFunctionMacro(expr,rest,p+l,len,def,expMacro);

   885 	  len+=l;

   886 	}

   887         else if (macroName=="defined")

   888         {

   889   	  //printf("found defined inside macro definition '%s'\n",expr.right(expr.length()-p).data());

   890 	  definedTest=TRUE;

   891         }

   892 

   893 	if (replaced) // expand the macro and rescan the expression

   894 	{

   895 	    

   896 	  //printf("replacing `%s'->`%s'\n",expr.mid(p,len).data(),expMacro.data());

   897 	  QCString resultExpr=expMacro;

   898 	  QCString restExpr=expr.right(expr.length()-len-p);

   899 	  processConcatOperators(resultExpr);

   900 	  if (def && !def->nonRecursive)

   901 	  {

   902 	    g_expandedDict->insert(macroName,def);

   903 	    expandExpression(resultExpr,&restExpr,0);

   904 	    g_expandedDict->remove(macroName);

   905 	  }

   906 	  expr=expr.left(p)+resultExpr+restExpr;

   907 	  i=p;

   908 	  //printf("new expression: %s\n",expr.data());

   909 	}

   910 	else // move to the next macro name

   911 	{

   912 	  //printf("moving to the next macro old=%d new=%d\n",i,p+l);

   913 	  i=p+l;

   914 	}

   915       }

   916       else // move to the next macro name

   917       {

   918 	expr=expr.left(p)+"@-"+expr.right(expr.length()-p);

   919 	//printf("macro already expanded, moving to the next macro expr=%s\n",expr.data());

   920 	i=p+l+2;

   921 	//i=p+l;

   922       }

   923     }

   924     else // no re-scan marker found, skip the macro name

   925     {

   926       //printf("skipping marked macro\n");

   927       i=p+l;

   928     }

   929   }

   930 }

   931 

   932 /*! replaces all occurrences of @@@@ in \a s by @@

   933  *  and removes all occurrences of @@E.

   934  *  All identifiers found are replaced by 0L

   935  */

   936 QCString removeIdsAndMarkers(const char *s)

   937 {

   938   //printf("removeIdsAndMarkers(%s)\n",s);

   939   const char *p=s;

   940   char c;

   941   bool inNum=FALSE;

   942   QCString result;

   943   if (p)

   944   {

   945     while ((c=*p))

   946     {

   947       if (c=='@') // replace @@ with @ and remove @E

   948       {

   949 	if (*(p+1)=='@')

   950 	{

   951 	  result+=c; 

   952 	}

   953 	else if (*(p+1)=='E')

   954 	{

   955 	  // skip

   956 	}

   957 	p+=2;

   958       }

   959       else if (isdigit(c)) // number

   960       {

   961 	result+=c;

   962 	p++;

   963         inNum=TRUE;	

   964       }

   965       else if (c=='d' && !inNum) // identifier starting with a `d'

   966       {

   967 	if (strncmp(p,"defined ",8)==0 || strncmp(p,"defined(",8)==0) 

   968 	           // defined keyword

   969 	{

   970 	  p+=7; // skip defined

   971 	}

   972 	else

   973 	{

   974 	  result+="0L";

   975 	  p++;

   976 	  while ((c=*p) && isId(c)) p++;

   977 	}

   978       }

   979       else if ((isalpha(c) || c=='_') && !inNum) // replace identifier with 0L

   980       {

   981 	result+="0L";

   982 	p++;

   983 	while ((c=*p) && isId(c)) p++;

   984       }

   985       else if (c=='/') // skip C comments

   986       {

   987 	char pc=c;

   988 	c=*++p;

   989 	if (c=='*') // start of C comment

   990 	{ 

   991 	  while (*p && !(pc=='*' && c=='/')) // search end of comment

   992 	  {

   993 	    pc=c;

   994 	    c=*++p;

   995 	  }

   996 	  p++;

   997 	}

   998 	else // oops, not comment but division

   999 	{

  1000 	  result+=pc;

  1001 	  goto nextChar;

  1002 	}

  1003       }

  1004       else 

  1005       {

  1006 nextChar:

  1007 	result+=c;

  1008 	char lc=tolower(c);

  1009 	if (!isId(lc) && lc!='.' && lc!='-' && lc!='+') inNum=FALSE;

  1010 	p++;

  1011       }

  1012     }

  1013   }

  1014   //printf("removeIdsAndMarkers(%s)=%s\n",s,result.data());

  1015   return result;

  1016 }

  1017 

  1018 /*! replaces all occurrences of @@ in \a s by @

  1019  *  \par assumption: 

  1020  *   \a s only contains pairs of @@'s

  1021  */

  1022 QCString removeMarkers(const char *s)

  1023 {

  1024   const char *p=s;

  1025   char c;

  1026   QCString result;

  1027   if (p)

  1028   {

  1029     while ((c=*p))

  1030     {

  1031       switch(c)

  1032       {

  1033 	case '@': // replace @@ with @

  1034 	  {

  1035 	    if (*(p+1)=='@')

  1036 	    {

  1037 	      result+=c; 

  1038 	    }

  1039 	    p+=2;

  1040 	  }

  1041 	  break;

  1042 	case '/': // skip C comments

  1043 	  {

  1044 	    result+=c;

  1045 	    char pc=c;

  1046 	    c=*++p;

  1047 	    if (c=='*') // start of C comment

  1048 	    { 

  1049 	      while (*p && !(pc=='*' && c=='/')) // search end of comment

  1050 	      {

  1051 		if (*p=='@' && *(p+1)=='@') 

  1052 		  result+=c,p++;

  1053 		else 

  1054 		  result+=c;

  1055 		pc=c;

  1056 		c=*++p;

  1057 	      }

  1058 	      if (*p)

  1059 	      {

  1060 	        result+=c;

  1061 	        p++;

  1062 	      }

  1063 	    }

  1064 	  }

  1065 	  break;

  1066 	case '"': // skip string literals

  1067 	  {

  1068 	    result+=c;

  1069 	    char pc=c;

  1070 	    c=*++p;

  1071 	    while (*p && (c!='"' || pc=='\\')) // no end quote

  1072 	    {

  1073 	      result+=c;

  1074 	      c=*++p;

  1075 	    }

  1076 	  }

  1077 	  break;

  1078 	case '\'': // skip char literals

  1079 	  {

  1080 	    result+=c;

  1081 	    char pc=c;

  1082 	    c=*++p;

  1083 	    while (*p && (c!='\'' || pc=='\\')) // no end quote

  1084 	    {

  1085 	      result+=c;

  1086 	      c=*++p;

  1087 	    }

  1088 	  }

  1089 	  break;

  1090 	default:

  1091 	  {

  1092 	    result+=c;

  1093 	    p++;

  1094 	  }

  1095 	  break;

  1096       }

  1097     }

  1098   }

  1099   //printf("RemoveMarkers(%s)=%s\n",s,result.data());

  1100   return result;

  1101 }

  1102 

  1103 /*! compute the value of the expression in string \a expr.

  1104  *  If needed the function may read additional characters from the input.

  1105  */

  1106 

  1107 bool computeExpression(const QCString &expr)

  1108 {

  1109   QCString e=expr;

  1110   expandExpression(e,0,0);

  1111   //printf("after expansion `%s'\n",e.data());

  1112   e = removeIdsAndMarkers(e);

  1113   if (e.isEmpty()) return FALSE;

  1114   //printf("parsing `%s'\n",e.data());

  1115   return parseCppExpression(g_yyFileName,g_yyLineNr,e);

  1116 }

  1117 

  1118 /*! expands the macro definition in \a name

  1119  *  If needed the function may read additional characters from the input

  1120  */

  1121 

  1122 QCString expandMacro(const QCString &name)

  1123 {

  1124   QCString n=name;

  1125   expandExpression(n,0,0);

  1126   n=removeMarkers(n);

  1127   //printf("expandMacro `%s'->`%s'\n",name.data(),n.data());

  1128   return n;

  1129 }

  1130 

  1131 Define *newDefine()

  1132 {

  1133   Define *def=new Define;

  1134   def->name = g_defName;