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   

    39 #include "pre.h"

    40 #include "constexp.h"

    41 #include "define.h"

    42 #include "doxygen.h"

    43 #include "message.h"

    44 #include "util.h"

    45 #include "defargs.h"

    46 #include "debug.h"

    47 #include "bufstr.h"

    48 #include "portable.h"

    49 #include "bufstr.h"

    50 

    51 #define YY_NEVER_INTERACTIVE 1

    52   

    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 && g_yyFileDef->isReference()) g_yyFileDef=0;

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

   131 }

   132 

   133 static void incrLevel()

   134 {

   135   g_level++;

   136   g_levelGuard.resize(g_level);

   137   g_levelGuard[g_level-1]=FALSE;

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

   139 }

   140 

   141 static void decrLevel()

   142 {

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

   144   if (g_level > 0)

   145   {

   146     g_level--;

   147     g_levelGuard.resize(g_level);

   148   }

   149   else

   150   {

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

   152 	g_yyFileName.data(),g_yyLineNr);

   153   }

   154 }

   155 

   156 static bool otherCaseDone()

   157 {

   158   if (g_level==0)

   159   {

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

   161 	g_yyFileName.data(),g_yyLineNr);

   162     return TRUE;

   163   }

   164   else

   165   {

   166     return g_levelGuard[g_level-1];

   167   }

   168 }

   169 

   170 static void setCaseDone(bool value)

   171 {

   172   g_levelGuard[g_level-1]=value;

   173 }

   174 

   175 static Define *isDefined(const char *name)

   176 {

   177   if (name)

   178   {

   179     Define *def;

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

   181     //	return def;

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

   183   }

   184   return 0;

   185 }

   186 

   187 static QDict<void> g_allIncludes(10009);

   188 

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

   190 {

   191   alreadyIncluded = FALSE;

   192   FileState *fs = 0;

   193   //printf("checkAndOpenFile(%s)\n",fileName.data());

   194   QFileInfo fi(fileName);

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

   196   {

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

   198 

   199     // global guard

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

   201     {

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

   203       {

   204         alreadyIncluded = TRUE;

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

   206         return 0; // already done

   207       }

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

   209     }

   210     // check include stack for absName

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

   212 	// TRUE if absName matches any filename

   213     QStack<FileState> tmpStack;

   214     g_includeStack.setAutoDelete(FALSE);

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

   216     {

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

   218       tmpStack.push(fs);

   219     }

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

   221     {

   222       g_includeStack.push(fs);

   223     }

   224     g_includeStack.setAutoDelete(TRUE);

   225 

   226     if (alreadyIncluded)

   227     {

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

   229       return 0;

   230     }

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

   232 

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

   234     alreadyIncluded = FALSE;

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

   236     { // error

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

   238       delete fs;

   239       fs=0;

   240     }

   241     else

   242     {

   243       fs->oldFileBuf    = g_inputBuf;

   244       fs->oldFileBufPos = g_inputBufPos;

   245     }

   246 

   247 #if 0

   248     QCString filterName = getFileFilter(absName);

   249     if (!filterName.isEmpty())

   250     {

   251       fs->isPlainFile = FALSE;

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

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

   254       if (!fs->filePtr)

   255       {

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

   257             strerror(errno));

   258       }

   259     }

   260     else

   261     {

   262       fs->isPlainFile = TRUE;

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

   264       if (!fs->filePtr)

   265       {

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

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

   268       }

   269     }

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

   271     {

   272       delete fs;

   273       fs=0;

   274     }

   275     else

   276     {

   277       fs->oldYYin = preYYin;

   278     }

   279 #endif

   280 

   281   }

   282   return fs;

   283 }

   284 

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

   286 {

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

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

   289   {

   290     QFileInfo fi(g_yyFileName);

   291     if (fi.exists())

   292     {

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

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

   295       if (fs)

   296       {

   297 	setFileName(absName);

   298 	g_yyLineNr=1;

   299 	return fs;

   300       }

   301       else if (alreadyIncluded)

   302       {

   303 	return 0;

   304       }

   305     }

   306   }

   307   if (g_pathList==0) 

   308   {

   309     return 0;

   310   }

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

   312   while (s)

   313   {

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

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

   316     if (fs)

   317     {

   318       setFileName(absName);

   319       g_yyLineNr=1;

   320       return fs;

   321     }

   322     else if (alreadyIncluded)

   323     {

   324       return 0;

   325     }

   326 

   327     s=g_pathList->next();

   328   } 

   329   return 0;

   330 }

   331 

   332 static QCString extractTrailingComment(const char *s)

   333 {

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

   335   int i=strlen(s)-1;

   336   while (i>=0)

   337   {

   338     char c=s[i];

   339     switch (c)

   340     {

   341       case '/':

   342 	{

   343 	  i--;

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

   345 	  {

   346 	    i--;

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

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

   349 	  }

   350 	  else

   351 	  {

   352 	    return "";

   353 	  }

   354 	} 

   355 	break;

   356 	// whitespace or line-continuation

   357       case ' ':

   358       case '\t': 

   359       case '\r':

   360       case '\n':

   361       case '\\':

   362 	break;

   363       default:

   364 	return "";

   365     }

   366     i--;

   367   }

   368   return "";

   369 }

   370 

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

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

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

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

   375 

   376 static QCString stringize(const QCString &s)

   377 {

   378   QCString result;

   379   uint i=0;

   380   bool inString=FALSE;

   381   bool inChar=FALSE;

   382   char c,pc;

   383   while (i<s.length())

   384   {

   385     if (!inString && !inChar)

   386     {

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

   388       {

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

   390 	if (c=='"')

   391 	{

   392 	  result+="\\\"";

   393 	  inString=TRUE;

   394 	}

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

   396 	{

   397 	  result+=c;

   398 	  inChar=TRUE;

   399 	}

   400 	else

   401 	{

   402 	  result+=c;

   403 	}

   404       }

   405     }

   406     else if (inChar)

   407     {

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

   409       {

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

   411 	if (c=='\'')

   412 	{

   413 	  result+='\'';

   414 	  inChar=FALSE;

   415 	}

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

   417 	{

   418 	  result+="\\\\";

   419 	}

   420 	else

   421 	{

   422 	  result+=c;

   423 	}

   424       }

   425     }

   426     else

   427     {

   428       pc=0;

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

   430       {

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

   432 	if (c=='"') 

   433 	{

   434 	  result+="\\\"";

   435 	  inString= pc=='\\';

   436 	}

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

   438 	  result+="\\\\";

   439 	else

   440 	  result+=c;

   441 	pc=c;

   442       }

   443     }

   444   }

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

   446   return result;

   447 }

   448 

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

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

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

   452  * may be expanded again.

   453  */

   454 static void processConcatOperators(QCString &expr)

   455 {

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

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

   458   int l,n,i=0;

   459   if (expr.isEmpty()) return;

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

   461   {

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

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

   464     {

   465       // remove no-rescan marker after ID

   466       l+=2;

   467     }

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

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

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

   471     int k=n-1;

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

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

   474     {

   475       // remove no-rescan marker before ID

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

   477       n-=2;

   478     }

   479     i=n;

   480   }

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

   482 }

   483 

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

   485 static void returnCharToStream(char c)

   486 {

   487   unput(c);

   488 }

   489 

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

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

   492 {

   493   int cc;

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

   495   {

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

   497     else if (cc==term) return;

   498     arg+=(char)cc;

   499   }

   500 }

   501 

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

   503  * \a pos in expression \a expr. 

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

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

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

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

   508  */ 

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

   510 {

   511   //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);

   512   uint j=pos;

   513   len=0;

   514   result.resize(0);

   515   int cc;

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

   517   { 

   518     len++; 

   519     getNextChar(expr,rest,j); 

   520   }

   521   if (cc!='(') 

   522   { 

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

   524     return FALSE; 

   525   }

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

   527 

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

   529   argTable.setAutoDelete(TRUE);

   530   QCString arg;

   531   int argCount=0;

   532   bool done=FALSE;

   533   

   534   // PHASE 1: read the macro arguments

   535   if (def->nargs==0)

   536   {

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

   538     {

   539       char c = (char)cc;

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

   541     }

   542   }

   543   else

   544   {

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

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

   547 	  )

   548     {

   549       char c=(char)cc;

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

   551       {

   552 	int level=1;

   553 	arg+=c;

   554 	//char term='\0';

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

   556 	{

   557 	  char c=(char)cc;

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

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

   560 	  {

   561 	    arg+=c;

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

   563 	  }

   564 	  if (c==')')

   565 	  {

   566 	    level--;

   567 	    arg+=c;

   568 	    if (level==0) break;

   569 	  }

   570 	  else if (c=='(')

   571 	  {

   572 	    level++;

   573 	    arg+=c;

   574 	  }

   575 	  else

   576 	    arg+=c;

   577 	}

   578       }

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

   580       {

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

   582 	{

   583 	  arg=arg.stripWhiteSpace();

   584 	  arg+=',';

   585 	}

   586 	else

   587 	{

   588 	  QCString argKey;

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

   590 	  arg=arg.stripWhiteSpace();

   591 	  // add argument to the lookup table

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

   593 	  arg.resize(0);

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

   595 	  {

   596 	    done=TRUE;

   597 	  }

   598 	}

   599       } 

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

   601       {

   602 	arg+=c; 

   603 	bool found=FALSE;

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

   605 	{

   606 	  found = cc=='"';

   607 	  if (cc=='\\')

   608 	  {

   609 	    c=(char)cc;	  

   610 	    arg+=c;

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

   612 	  }

   613 	  c=(char)cc;	  

   614 	  arg+=c;

   615 	}

   616       }

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

   618       {

   619 	arg+=c;

   620 	bool found=FALSE;

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

   622 	{

   623 	  found = cc=='\'';

   624 	  if (cc=='\\')

   625 	  {

   626 	    c=(char)cc;	  

   627 	    arg+=c;

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

   629 	  }

   630 	  c=(char)cc;

   631 	  arg+=c;

   632 	}

   633       }	    

   634       else // append other characters

   635       {

   636 	arg+=c;

   637       }

   638     }

   639   }

   640 

   641   // PHASE 2: apply the macro function

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

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

   644   {

   645     uint k=0;

   646     // substitution of all formal arguments

   647     QCString resExpr;

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

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

   650     bool inString=FALSE;

   651     while (k<d.length())

   652     {

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

   654       {

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

   656 	{

   657 	  k+=2;

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

   659 	}

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

   661 	{

   662 	  k+=2;

   663 	  resExpr+="@-";

   664 	}

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

   666 	{

   667 	  QCString key="@";

   668 	  QCString *subst=0;

   669 	  bool hash=FALSE;

   670 	  int l=k-1;

   671 	  // search for ## backward

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

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

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

   675 	  k++;

   676 	  // scan the number

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

   678 	  if (!hash) 

   679 	  {

   680 	    // search for ## forward

   681 	    l=k;

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

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

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

   685 	  }

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

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

   688 	  {

   689 	    QCString substArg=*subst;

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

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

   692 	    // marker we do macro expansion.

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

   694 	    if (inString)

   695 	    {

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

   697 

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

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

   700 	      resExpr+=stringize(substArg);

   701 	    }

   702 	    else

   703 	    {

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

   705 	      {

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

   707 	      }

   708 	      else if (g_nospaces)

   709 	      {

   710 	        resExpr+=substArg;

   711 	      }

   712 	      else

   713 	      {

   714 	        resExpr+=" "+substArg+" ";

   715 	      }

   716 	    }

   717 	  }

   718 	}

   719       }

   720       else // no marker, just copy

   721       {

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

   723 	{

   724 	  inString=TRUE; // entering a literal string

   725 	}

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

   727 	{

   728 	  inString=FALSE; // leaving a literal string

   729 	}

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

   731       }

   732     }

   733     len=j-pos;

   734     result=resExpr;

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

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

   737     return TRUE;

   738   }

   739   return FALSE;

   740 }

   741 

   742 

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

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

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

   746  */

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

   748 {

   749   int n;

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

   751   {

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

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

   754     {

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

   756     }

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

   758     {

   759       n=p-1;

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

   761       *l=p-n;

   762       return n; 

   763     }

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

   765     {

   766       char ppc=0,pc=c;

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

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

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

   770       {

   771 	ppc=pc;

   772 	pc=c;

   773 	c=expr.at(p);

   774 	p++;

   775       }

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

   777     }

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

   779     {

   780       char pc=c;

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

   782       {

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

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

   785         { 

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

   787 	  {

   788 	    pc=c;

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

   790 	  }

   791 	  p++;

   792         }

   793       }

   794     }

   795   }

   796   return -1;

   797 }

   798 

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

   800  *  starting at position \a pos.

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

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

   803  *  expanded, otherwise only the first is expanded.

   804  */

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

   806 {

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

   808   QCString macroName;

   809   QCString expMacro;

   810   bool definedTest=FALSE;

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

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

   813   {

   814     bool replaced=FALSE;

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

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

   817     {

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

   819       {

   820 	Define *def=isDefined(macroName);

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

   822 	{

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

   824 	  replaced=TRUE;

   825 	  len=l;

   826 	  definedTest=FALSE;

   827 	}

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

   829 	{

   830 	  // substitute the definition of the macro

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

   832 	  if (g_nospaces)

   833 	  {

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

   835 	  }

   836 	  else

   837 	  {

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

   839 	  }

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

   841 	  replaced=TRUE;

   842 	  len=l;

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

   844 	}

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

   846 	{

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

   848 	  len+=l;

   849 	}

   850         else if (macroName=="defined")

   851         {

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

   853 	  definedTest=TRUE;

   854         }

   855 

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

   857 	{

   858 	    

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

   860 	  QCString resultExpr=expMacro;

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

   862 	  processConcatOperators(resultExpr);

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

   864 	  {

   865 	    g_expandedDict->insert(macroName,def);

   866 	    expandExpression(resultExpr,&restExpr,0);

   867 	    g_expandedDict->remove(macroName);

   868 	  }

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

   870 	  i=p;

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

   872 	}

   873 	else // move to the next macro name

   874 	{

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

   876 	  i=p+l;

   877 	}

   878       }

   879       else // move to the next macro name

   880       {

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

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

   883 	i=p+l+2;

   884 	//i=p+l;

   885       }

   886     }

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

   888     {

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

   890       i=p+l;

   891     }

   892   }

   893 }

   894 

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

   896  *  and removes all occurrences of @@E.

   897  *  All identifiers found are replaced by 0L

   898  */

   899 QCString removeIdsAndMarkers(const char *s)

   900 {

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

   902   const char *p=s;

   903   char c;

   904   bool inNum=FALSE;

   905   QCString result;

   906   if (p)

   907   {

   908     while ((c=*p))

   909     {

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

   911       {

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

   913 	{

   914 	  result+=c; 

   915 	}

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

   917 	{

   918 	  // skip

   919 	}

   920 	p+=2;

   921       }

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

   923       {

   924 	result+=c;

   925 	p++;

   926         inNum=TRUE;	

   927       }

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

   929       {

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

   931 	           // defined keyword

   932 	{

   933 	  p+=7; // skip defined

   934 	}

   935 	else

   936 	{

   937 	  result+="0L";

   938 	  p++;

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

   940 	}

   941       }

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

   943       {

   944 	result+="0L";

   945 	p++;

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

   947       }

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

   949       {

   950 	char pc=c;

   951 	c=*++p;

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

   953 	{ 

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

   955 	  {

   956 	    pc=c;

   957 	    c=*++p;

   958 	  }

   959 	  p++;

   960 	}

   961 	else // oops, not comment but division

   962 	{

   963 	  result+=pc;

   964 	  goto nextChar;

   965 	}

   966       }

   967       else 

   968       {

   969 nextChar:

   970 	result+=c;

   971 	char lc=tolower(c);

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

   973 	p++;

   974       }

   975     }

   976   }

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

   978   return result;

   979 }

   980 

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

   982  *  \par assumption: 

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

   984  */

   985 QCString removeMarkers(const char *s)

   986 {

   987   const char *p=s;

   988   char c;

   989   QCString result;

   990   if (p)

   991   {

   992     while ((c=*p))

   993     {

   994       switch(c)

   995       {

   996 	case '@': // replace @@ with @

   997 	  {

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

   999 	    {

  1000 	      result+=c; 

  1001 	    }

  1002 	    p+=2;

  1003 	  }

  1004 	  break;

  1005 	case '/': // skip C comments

  1006 	  {

  1007 	    result+=c;

  1008 	    char pc=c;

  1009 	    c=*++p;

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

  1011 	    { 

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

  1013 	      {

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

  1015 		  result+=c,p++;

  1016 		else 

  1017 		  result+=c;

  1018 		pc=c;

  1019 		c=*++p;

  1020 	      }

  1021 	      if (*p)

  1022 	      {

  1023 	        result+=c;

  1024 	        p++;

  1025 	      }

  1026 	    }

  1027 	  }

  1028 	  break;

  1029 	case '"': // skip string literals

  1030 	  {

  1031 	    result+=c;

  1032 	    char pc=c;

  1033 	    c=*++p;

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

  1035 	    {

  1036 	      result+=c;

  1037 	      c=*++p;

  1038 	    }

  1039 	  }

  1040 	  break;

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

  1042 	  {

  1043 	    result+=c;

  1044 	    char pc=c;

  1045 	    c=*++p;

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

  1047 	    {

  1048 	      result+=c;

  1049 	      c=*++p;

  1050 	    }

  1051 	  }

  1052 	  break;

  1053 	default:

  1054 	  {

  1055 	    result+=c;

  1056 	    p++;

  1057 	  }

  1058 	  break;

  1059       }

  1060     }

  1061   }

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

  1063   return result;

  1064 }

  1065 

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

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

  1068  */

  1069 

  1070 bool computeExpression(const QCString &expr)

  1071 {

  1072   QCString e=expr;

  1073   expandExpression(e,0,0);

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

  1075   e = removeIdsAndMarkers(e);

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

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

  1078   return parseCppExpression(g_yyFileName,g_yyLineNr,e);

  1079 }

  1080 

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

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

  1083  */

  1084 

  1085 QCString expandMacro(const QCString &name)

  1086 {

  1087   QCString n=name;

  1088   expandExpression(n,0,0);

  1089   n=removeMarkers(n);

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

  1091   return n;

  1092 }

  1093 

  1094 Define *newDefine()

  1095 {

  1096   Define *def=new Define;

  1097   def->name = g_defName;

  1098   def->definition = g_defText.stripWhiteSpace();

  1099   def->nargs = g_defArgs;

  1100   def->fileName = g_yyFileName; 

  1101   def->lineNr = g_yyLineNr;

  1102   def->varArgs = g_defVarArgs;

  1103   //printf("newDefine: `%s'->`%s'\n",def->name.data(),def->definition.data());

  1104   if (!def->name.isEmpty() && Doxygen::expandAsDefinedDict[def->name])

  1105   {

  1106     def->isPredefined=TRUE;

  1107   }

  1108   return def;

  1109 }

  1110 

  1111 void addDefine()

  1112 {

  1113   if (g_skip) return; // do not add this define as it is inside a 

  1114                       // conditional section (cond command) that is disabled.

  1115   if (!Doxygen::gatherDefines) return;

  1116 

  1117   //printf("addDefine %s %s\n",g_defName.data(),g_defArgsStr.data());

  1118   //ArgumentList *al = new ArgumentList;

  1119   //stringToArgumentList(g_defArgsStr,al);

  1120   MemberDef *md=new MemberDef(

  1121       g_yyFileName,g_yyLineNr,

  1122       "#define",g_defName,g_defArgsStr,0,

  1123       Public,Normal,FALSE,Member,MemberDef::Define,0,0);

  1124   if (!g_defArgsStr.isEmpty())

  1125   {

  1126     ArgumentList *argList = new ArgumentList;

  1127     //printf("addDefine() g_defName=`%s' g_defArgsStr=`%s'\n",g_defName.data(),g_defArgsStr.data());

  1128     stringToArgumentList(g_defArgsStr,argList);

  1129     md->setArgumentList(argList);

  1130   }

  1131   //printf("Setting initializer for `%s' to `%s'\n",g_defName.data(),g_defText.data());

  1132   int l=g_defLitText.find('\n');

  1133   if (l>0 && g_defLitText.left(l).stripWhiteSpace()=="\\")

  1134   {