summaryrefslogtreecommitdiffstats
path: root/src/pre.l
diff options
context:
space:
mode:
Diffstat (limited to 'src/pre.l')
-rw-r--r--src/pre.l1636
1 files changed, 1636 insertions, 0 deletions
diff --git a/src/pre.l b/src/pre.l
new file mode 100644
index 0000000..92f7553
--- /dev/null
+++ b/src/pre.l
@@ -0,0 +1,1636 @@
+/******************************************************************************
+ *
+ * $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 <iostream.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <qarray.h>
+#include <qstring.h>
+#include <qstack.h>
+#include <qfile.h>
+#include <qstrlist.h>
+#include <qdict.h>
+#include <qregexp.h>
+
+#include "constexp.h"
+#include "define.h"
+#include "doxygen.h"
+#include "message.h"
+#include "util.h"
+
+#if defined(_MSC_VER)
+#define popen _popen
+#define pclose _pclose
+#endif
+
+#define YY_NEVER_INTERACTIVE 1
+
+#define DUMP_OUTPUT 0 // set this to one to see what the preprocessor
+ // produces.
+#define SHOW_INCLUDES 0 // set this to one to list all parsed include files
+
+struct FileState
+{
+ int lineNr;
+ FILE *filePtr;
+ YY_BUFFER_STATE bufState;
+ QString fileName;
+};
+
+/* -----------------------------------------------------------------
+ *
+ * statics
+ */
+
+static int yyLineNr = 1;
+static QString yyFileName;
+static int ifcount = 0;
+static QStrList *pathList = 0;
+static QStack<FileState> includeStack;
+static QDict<int> *argDict;
+static int defArgs = 0;
+static QString defName;
+static QString defText;
+static QString defArgsStr;
+static bool defVarArgs;
+static int level;
+static int lastCContext;
+static int lastCPPContext;
+static QArray<int> levelGuard;
+static QString guardExpr;
+static BufStr *outputBuf;
+//static DefineCache *fileDefineCache;
+static int roundCount;
+//static const Define *expandDefine;
+static bool quoteArg;
+static DefineDict *fileDefineDict;
+static DefineDict *expandedDict;
+static int findDefArgContext;
+
+
+static void incrLevel()
+{
+ level++;
+ levelGuard.resize(level);
+ levelGuard[level-1]=FALSE;
+ //printf("%s line %d: incrLevel %d\n",yyFileName.data(),yyLineNr,level);
+}
+
+static void decrLevel()
+{
+ //printf("%s line %d: decrLevel %d\n",yyFileName.data(),yyLineNr,level);
+ if (level > 0)
+ {
+ level--;
+ levelGuard.resize(level);
+ }
+ else
+ {
+ err("Error: More #endif's than #if's found.\n");
+ }
+}
+
+static bool otherCaseDone()
+{
+ return levelGuard[level-1];
+}
+
+static void setCaseDone(bool value)
+{
+ levelGuard[level-1]=value;
+}
+
+static Define *isDefined(const char *name)
+{
+ if (name)
+ {
+ Define *def;
+ //if ((def=fileDefineCache->findDefine(yyFileName,name)) && !def->undef)
+ // return def;
+ if ((def=fileDefineDict->find(name)) && !def->undef) return def;
+ }
+ return 0;
+}
+
+static FILE *findFile(const char *fileName)
+{
+ if (pathList==0)
+ {
+ return 0;
+ }
+ char *s=pathList->first();
+ while (s)
+ {
+ QString absName=(QString)s+"/"+fileName;
+ QFileInfo fi(absName);
+ if (fi.exists())
+ {
+ FILE *f;
+ if (!inputFilter.isEmpty())
+ {
+ QString cmd = inputFilter+" "+absName;
+ f=popen(cmd,"r");
+ if (!f) warn("Warning: could not execute filter %s\n",cmd.data());
+ }
+ else
+ {
+ f=fopen(absName,"r");
+ if (!f) warn("Warning: could not open file %s for reading\n",absName.data());
+ }
+ if (f)
+ {
+ yyFileName=absName;
+ yyLineNr=1;
+ return f;
+ }
+ }
+ s=pathList->next();
+ }
+ return 0;
+}
+
+
+static int getNextChar(const QString &expr,QString *rest,uint &pos);
+static int getCurrentChar(const QString &expr,QString *rest,uint pos);
+static void unputChar(const QString &expr,QString *rest,uint &pos,char c);
+static void expandExpression(QString &expr,QString *rest,int pos);
+
+static QString stringize(const QString &s)
+{
+ QString result;
+ uint i=0;
+ bool inString=FALSE;
+ bool inChar=FALSE;
+ char c,pc;
+ while (i<s.length())
+ {
+ if (!inString && !inChar)
+ {
+ while (i<s.length() && !inString && !inChar)
+ {
+ c=s.at(i++);
+ if (c=='"')
+ {
+ result+="\\\"";
+ inString=TRUE;
+ }
+ else if (c=='\'')
+ {
+ result+=c;
+ inChar=TRUE;
+ }
+ else
+ {
+ result+=c;
+ }
+ }
+ }
+ else if (inChar)
+ {
+ while (i<s.length() && inChar)
+ {
+ c=s.at(i++);
+ if (c=='\'')
+ {
+ result+='\'';
+ inChar=FALSE;
+ }
+ else if (c=='\\')
+ {
+ result+="\\\\";
+ }
+ else
+ {
+ result+=c;
+ }
+ }
+ }
+ else
+ {
+ pc=0;
+ while (i<s.length() && inString)
+ {
+ char c=s.at(i++);
+ if (c=='"')
+ {
+ result+="\\\"";
+ inString= pc=='\\';
+ }
+ else if (c=='\\')
+ result+="\\\\";
+ else
+ result+=c;
+ pc=c;
+ }
+ }
+ }
+ //printf("stringize `%s'->`%s'\n",s.data(),result.data());
+ return result;
+}
+
+/*! Execute all ## operators in expr.
+ * If the macro name before or after the operator contains a no-rescan
+ * marker (@-) then this is removed (before the concatenated macro name
+ * may be expanded again.
+ */
+static void processConcatOperators(QString &expr)
+{
+ QRegExp r("[ \\t\\n]*##[ \\t\\n]*");
+ int l,n,i=0;
+ while ((n=r.match(expr,i,&l))!=-1)
+ {
+ if (n+l+1<(int)expr.length() && expr.at(n+l)=='@' && expr.at(n+l+1)=='-')
+ {
+ // remove no-rescan marker after ID
+ l+=2;
+ }
+ // remove the ## operator and the surrounding whitespace
+ expr=expr.left(n)+expr.right(expr.length()-n-l);
+ int k=n-1;
+ while (k>=0 && isId(expr.at(k))) k--;
+ if (k>0 && expr.at(k)=='-' && expr.at(k-1)=='@')
+ {
+ // remove no-rescan marker before ID
+ expr=expr.left(k-1)+expr.right(expr.length()-k-1);
+ n-=2;
+ }
+ i=n+l;
+ }
+}
+
+/*! replaces the function macro \a def whose argument list starts at
+ * \a pos in expression \a expr.
+ * Notice that this routine may scan beyond the \a expr string if needed.
+ * The characters from the input file will be read.
+ * The replacement string will be returned in \a result and the
+ * length of the (unexpanded) argument list is stored in \a len.
+ */
+static bool replaceFunctionMacro(const QString &expr,QString *rest,int pos,int &len,const Define *def,QString &result)
+{
+ //printf("replaceFunctionMacro(expr=%s,rest=%s,pos=%d,def=%s) level=%d\n",expr.data(),rest ? rest->data() : 0,pos,def->name.data(),level);
+ //bool replaced=FALSE;
+ uint j=pos;
+ len=0;
+ result.resize(0);
+ int cc;
+ // TODO: use a checkNextChar function.
+ //while ((cc=getNextChar(expr,rest,j))!=EOF && cc==' ') len++;
+ //if (cc!='(') return FALSE;
+ while ((cc=getCurrentChar(expr,rest,j))!=EOF && cc==' ')
+ {
+ len++;
+ getNextChar(expr,rest,j);
+ }
+ if (cc!='(')
+ {
+ unputChar(expr,rest,j,' ');
+ return FALSE;
+ }
+ getNextChar(expr,rest,j); // eat the `(' character
+
+ //while (j<expr.length() && expr.at(j)!='(') j++;
+ //j++; // skip opening paren
+
+ QDict<QString> argTable; // list of arguments
+ argTable.setAutoDelete(TRUE);
+ QString arg;
+ int argCount=0;
+ bool done=FALSE;
+ // FASE 1: read the macro arguments
+ while ((argCount<def->nargs || def->varArgs) &&
+ ((cc=getNextChar(expr,rest,j))!=EOF) && !done
+ )
+ {
+ char c=(char)cc;
+ if (c=='(') // argument is a function => search for matching )
+ {
+ int level=1;
+ arg+=c;
+ char term='\0';
+ while ((cc=getNextChar(expr,rest,j))!=EOF)
+ {
+ char c=(char)cc;
+ if (c=='\'' || c=='\"') // skip ('s and )'s inside strings
+ {
+ if (term!='\0')
+ {
+ if (c==term && expr.at(j-2)!='\\') term='\0';
+ }
+ else
+ {
+ term=c;
+ }
+ }
+ if (term=='\0' && c==')')
+ {
+ level--;
+ arg+=c;
+ if (level==0) break;
+ }
+ else if (term=='\0' && c=='(')
+ {
+ level++;
+ arg+=c;
+ }
+ else
+ arg+=c;
+ }
+ }
+ else if (c==')' || c==',') // last or next argument found
+ {
+ if (c==',' && argCount==def->nargs-1 && def->varArgs)
+ {
+ arg=arg.stripWhiteSpace();
+ arg+=',';
+ }
+ else
+ {
+ QString argKey;
+ argKey.sprintf("@%d",argCount++); // key name
+ arg=arg.stripWhiteSpace();
+ // add argument to the lookup table
+ argTable.insert(argKey, new QString(arg));
+ arg.resize(0);
+ if (c==')') // end of the argument list
+ {
+ done=TRUE;
+ }
+ }
+ }
+ else if (c=='\"') // append literal strings
+ {
+ arg+=c;
+ char pc=c;
+ bool found=FALSE;
+ while (!found && (cc=getNextChar(expr,rest,j))!=EOF)
+ {
+ found = pc!='\\' && cc=='"';
+ c=(char)cc;
+ pc=c;
+ arg+=c;
+ }
+ }
+ else if (c=='\'') // append literal characters
+ {
+ arg+=c;
+ char pc=c;
+ bool found=FALSE;
+ while (!found && (cc=getNextChar(expr,rest,j))!=EOF)
+ {
+ found = pc!='\\' && cc=='\'';
+ c=(char)cc;
+ pc=c;
+ arg+=c;
+ }
+ }
+ else // append other characters
+ {
+ arg+=c;
+ }
+ }
+
+ // FASE 2: apply the macro function
+ if (argCount==def->nargs ||
+ (argCount>def->nargs && def->varArgs)) // matching parameters lists
+ {
+ uint k=0;
+ // substitution of all formal arguments
+ QString resExpr;
+ const QString d=def->definition.stripWhiteSpace();
+ bool inString=FALSE;
+ while (k<d.length())
+ {
+ if (d.at(k)=='@') // maybe a marker, otherwise an escaped @
+ {
+ if (d.at(k+1)=='@') // escaped @ => copy it (is unescaped later)
+ {
+ k+=2;
+ resExpr+="@@"; // we unescape these later
+ }
+ else if (d.at(k+1)=='-') // no-rescan marker
+ {
+ k+=2;
+ resExpr+="@-";
+ }
+ else // argument marker => read the argument number
+ {
+ QString key="@";
+ QString *subst=0;
+ bool hash=FALSE;
+ int l=k-1;
+ // search for ## backward
+ if (l>=0 && d.at(l)=='"') l--;
+ while (l>=0 && d.at(l)==' ') l--;
+ if (l>0 && d.at(l)=='#' && d.at(l-1)=='#') hash=TRUE;
+ k++;
+ // scan the number
+ while (k<d.length() && d.at(k)>='0' && d.at(k)<='9') key+=d.at(k++);
+ if (!hash)
+ {
+ // search for ## forward
+ l=k;
+ if (l<(int)d.length() && d.at(l)=='"') l++;
+ while (l<(int)d.length() && d.at(l)==' ') l++;
+ if (l<(int)d.length()-1 && d.at(l)=='#' && d.at(l+1)=='#') hash=TRUE;
+ }
+ //printf("request key %s result %s\n",key.data(),args[key]->data());
+ if (key.length()>1 && (subst=argTable[key]))
+ {
+ QString substArg=*subst;
+ // only if no ## operator is before or after the argument
+ // marker we do macro expansion.
+ if (!hash) expandExpression(substArg,0,0);
+ if (inString)
+ {
+ //printf("`%s'=stringize(`%s')\n",stringize(*subst).data(),subst->data());
+
+ // if the marker is inside a string (because a # was put
+ // before the macro name) we must escape " and \ characters
+ resExpr+=stringize(substArg);
+ }
+ else
+ {
+ resExpr+=substArg;
+ }
+ }
+ }
+ }
+ else // no marker, just copy
+ {
+ if (!inString && d.at(k)=='\"')
+ {
+ inString=TRUE; // entering a literal string
+ }
+ else if (inString && d.at(k)=='\"' && d.at(k-1)!='\\')
+ {
+ inString=FALSE; // leaving a literal string
+ }
+ resExpr+=d.at(k++);
+ }
+ }
+ len=j-pos;
+ result=resExpr;
+ //printf("result after substitution `%s' expr=`%s'\n",
+ // result.data(),expr.mid(pos,len).data());
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+
+/*! returns the next identifier in string \a expr by starting at position \a p.
+ * The position of the identifier is returned (or -1 if nothing is found)
+ * and \a l is its length. Any quoted strings are skipping during the search.
+ */
+static int getNextId(const QString &expr,int p,int *l)
+{
+ int n;
+ while (p<(int)expr.length())
+ {
+ char c=expr.at(p++);
+ if (isalpha(c) || c=='_') // read id
+ {
+ n=p-1;
+ while (p<(int)expr.length() && isId(expr.at(p))
+ ) p++;
+ *l=p-n;
+ return n;
+ }
+ else if (c=='"') // skip string
+ {
+ char pc=c;
+ if (p<(int)expr.length()) c=expr.at(p);
+ while (p<(int)expr.length() && (c!='"' || pc=='\\'))
+ {
+ pc=c;
+ c=expr.at(p);
+ p++;
+ }
+ }
+ }
+ return -1;
+}
+
+/*! preforms recursive macro expansion on the string \a expr
+ * starting at position \a pos.
+ * May read additional characters from the input while re-scanning!
+ * If \a expandAll is \c TRUE then all macros in the expression are
+ * expanded, otherwise only the first is expanded.
+ */
+static void expandExpression(QString &expr,QString *rest,int pos)
+{
+ //printf("expandExpression(%s,%s)\n",expr.data(),rest ? rest->data() : 0);
+ QString macroName;
+ QString expMacro;
+ int i=pos,l,p,len;
+ while ((p=getNextId(expr,i,&l))!=-1) // search for an macro name
+ {
+ bool replaced=FALSE;
+ macroName=expr.mid(p,l);
+ //printf("macroName %s found\n",macroName.data());
+ if (p<2 || !(expr.at(p-2)=='@' && expr.at(p-1)=='-')) // no-rescan marker?
+ {
+ if (expandedDict->find(macroName)==0) // expand macro
+ {
+ Define *def=isDefined(macroName);
+ //printf("name is not an expanded macro def=%s\n",def ? def->name.data() : 0);
+ if (def && def->nargs==0) // simple macro
+ {
+ // substitute the definition of the macro
+ expMacro=def->definition.stripWhiteSpace();
+ replaced=TRUE;
+ len=l;
+ //printf("simple macro expansion=`%s'->`%s'\n",macroName.data(),expMacro.data());
+ }
+ else if (def && def->nargs>0) // function macro
+ {
+ replaced=replaceFunctionMacro(expr,rest,p+l,len,def,expMacro);
+ len+=l;
+ }
+
+ if (replaced) // expand the macro and rescan the expression
+ {
+ //printf("replacing `%s'->`%s'\n",expr.mid(p,len).data(),expMacro.data());
+ QString resultExpr=expMacro;
+ QString restExpr=expr.right(expr.length()-len-p);
+ processConcatOperators(resultExpr);
+ expandedDict->insert(macroName,def);
+ expandExpression(resultExpr,&restExpr,0);
+ expandedDict->remove(macroName);
+ expr=expr.left(p)+resultExpr+restExpr;
+ i=p;
+ //printf("new expression: %s\n",expr.data());
+ }
+ else // move to the next macro name
+ {
+ //printf("moving to the next macro old=%d new=%d\n",i,p+l);
+ i=p+l;
+ }
+ }
+ else // move to the next macro name
+ {
+ expr=expr.left(p)+"@-"+expr.right(expr.length()-p);
+ //printf("macro already expanded, moving to the next macro expr=%s\n",expr.data());
+ i=p+l+2;
+ //i=p+l;
+ }
+ }
+ else // no re-scan marker found, skip the macro name
+ {
+ //printf("skipping marked macro\n");
+ i=p+l;
+ }
+ }
+}
+
+/*! replaces all occurrences of @@ in \a s by @
+ * All identifiers found are replaced by 0L
+ * \par assumption:
+ * \a s only contains pairs of @@'s.
+ */
+QString removeIdsAndMarkers(const char *s)
+{
+ //printf("removeIdsAndMarkers(%s)\n",s);
+ const char *p=s;
+ char c;
+ bool inNum=FALSE;
+ QString result;
+ if (p)
+ {
+ while ((c=*p))
+ {
+ if (c=='@') // replace @@ with @
+ {
+ if (*(p+1)=='@')
+ {
+ result+=c;
+ }
+ p+=2;
+ }
+ else if (isdigit(c))
+ {
+ result+=c;
+ p++;
+ inNum=TRUE;
+ }
+ else if ((isalpha(c) || c=='_') && !inNum) // replace identifier with 0L
+ {
+ result+="0L";
+ p++;
+ while ((c=*p) && isId(c)) p++;
+ }
+ else
+ {
+ result+=c;
+ char lc=tolower(c);
+ if (lc!='l' && lc!='u') inNum=FALSE;
+ p++;
+ }
+ }
+ }
+ return result;
+}
+
+/*! replaces all occurrences of @@ in \a s by @
+ * \par assumption:
+ * \a s only contains pairs of @@'s
+ */
+QString removeMarkers(const char *s)
+{
+ const char *p=s;
+ char c;
+ QString result;
+ if (p)
+ {
+ while ((c=*p))
+ {
+ if (c=='@') // replace @@ with @
+ {
+ if (*(p+1)=='@')
+ {
+ result+=c;
+ }
+ p+=2;
+ }
+ else
+ {
+ result+=c;
+ p++;
+ }
+ }
+ }
+ return result;
+}
+
+/*! compute the value of the expression in string \a expr.
+ * If needed the function may read additional characters from the input.
+ */
+
+bool computeExpression(const QString &expr)
+{
+ QString e=expr;
+ expandExpression(e,0,0);
+ e = removeIdsAndMarkers(e);
+ if (e.length()==0) return FALSE;
+ //printf("computeExpession(%s)\n",e.data());
+ return parseCppExpression(e);
+}
+
+/*! expands the macro definition in \a name
+ * If needed the function may read additional characters from the input
+ */
+
+QString expandMacro(const QString &name)
+{
+ QString n=name;
+ expandExpression(n,0,0);
+ n=removeMarkers(n);
+ //printf("expandMacro `%s'->`%s'\n",name.data(),n.data());
+ return n;
+}
+
+Define *newDefine()
+{
+ Define *def=new Define;
+ def->name = defName;
+ def->definition = defText.stripWhiteSpace();
+ def->nargs = defArgs;
+ def->fileName = yyFileName;
+ def->lineNr = yyLineNr;
+ def->varArgs = defVarArgs;
+ return def;
+}
+
+void addDefine()
+{
+ bool ambig;
+ FileDef *fd=findFileDef(&inputNameDict,yyFileName,ambig);
+ MemberDef *md=new MemberDef("#define",defName,defArgsStr,0,
+ Public,Normal,FALSE,FALSE,MemberDef::Define,0,0);
+ md->setDefFile(yyFileName);
+ md->setDefLine(yyLineNr);
+ md->setFileDef(fd);
+ md->setDefinition("#define "+defName+defArgsStr);
+
+ MemberName *mn=functionNameDict[defName];
+ if (mn==0)
+ {
+ mn = new MemberName(defName);
+ functionNameList.inSort(mn);
+ functionNameDict.insert(defName,mn);
+ }
+ mn->append(md);
+ if (fd) fd->insertMember(md);
+
+ Define *d;
+ if ((d=defineDict[defName])==0) defineDict.insert(defName,newDefine());
+
+}
+
+static void outputChar(char c)
+{
+ if (includeStack.isEmpty()) outputBuf->addChar(c);
+}
+
+static void outputArray(const char *a,int len)
+{
+ if (includeStack.isEmpty()) outputBuf->addArray(a,len);
+}
+
+static void readIncludeFile(const QString &inc)
+{
+ if (!searchIncludeFlag) return; // do not read include files
+ uint i=0;
+ // find the start of the include file name
+ while (i<inc.length() &&
+ (inc.at(i)==' ' || inc.at(i)=='"' || inc.at(i)=='<')
+ ) i++;
+ uint s=i;
+ // find the end of the include file name
+ while (i<inc.length() &&
+ inc.at(i)!='"' && inc.at(i)!='>') i++;
+ if (s<inc.length() && i>s) // valid include file name found
+ {
+ QString incFileName=inc.mid(s,i-s).stripWhiteSpace();
+
+ FILE *f;
+ QString oldFileName=yyFileName.copy();
+ if ((f=findFile(incFileName))) // see if the include file can be found
+ {
+#if SHOW_INCLUDES
+ for (i=0;i<includeStack.count();i++) msg(" ");
+ msg("#include %s: parsing...\n",incFileName.data());
+#endif
+ // store the state of the old file
+ FileState *fs=new FileState;
+ fs->bufState=YY_CURRENT_BUFFER;
+ fs->lineNr=yyLineNr;
+ fs->fileName=oldFileName;
+ fs->filePtr=f;
+ // push the state on the stack
+ includeStack.push(fs);
+ // set the scanner to the include file
+ preYYin=f;
+ yy_switch_to_buffer(yy_create_buffer(preYYin, YY_BUF_SIZE));
+ }
+ else
+ {
+#if SHOW_INCLUDES
+ msg("#include %s: not found! skipping...\n",incFileName.data());
+ //printf("Error: include file %s not found\n",yytext);
+#endif
+ }
+ }
+}
+
+/* ----------------------------------------------------------------- */
+
+%}
+
+ID [a-z_A-Z][a-z_A-Z0-9]*
+B [ \t]
+BN [ \t\r\n]
+
+%x Start
+%x Command
+%x SkipCommand
+%x SkipLine
+%x CopyLine
+%x Include
+%x IncludeID
+%x DefineName
+%x DefineArg
+%x DefineText
+%x SkipCPPBlock
+%x Ifdef
+%x Ifndef
+%x SkipCComment
+%x SkipCPPComment
+%x RemoveCComment
+%x RemoveCPPComment
+%x Guard
+%x DefinedExpr1
+%x DefinedExpr2
+%x SkipDoubleQuote
+%x SkipSingleQuote
+%x UndefName
+%x IgnoreLine
+%x FindDefineArgs
+%x ReadString
+
+%%
+
+<*>\x06
+<*>\x00
+<*>\r
+ /*
+<Start>^{B}*([^ \t#\n\/][^\n]*)?"\n" {
+ //printf("%s line %d: %s",yyFileName.data(),yyLineNr,yytext);
+ if (includeStack.isEmpty())
+ {
+ //preprocessedFile+=yytext;
+ //char *s=yytext,c;
+ //if (s) while ((c=*s++)) *dataPtr++=c;
+ outputBuf->addArray(yytext,yyleng);
+ }
+ yyLineNr++;
+ }
+ */
+<Start>^{B}*"#" { BEGIN(Command); }
+<Start>^{B}*/[^#] {
+ outputArray(yytext,yyleng);
+ BEGIN(CopyLine);
+ }
+ /*
+<CopyLine>[^\n/]+ {
+ outputArray(yytext,yyleng);
+ }
+ */
+<CopyLine>{ID}/{BN}*"(" {
+ if (includeStack.isEmpty() &&
+ macroExpansionFlag &&
+ /* (expandDefine=fileDefineCache->findDefine(yyFileName,yytext)) */
+ fileDefineDict->find(yytext)
+ )
+ {
+ roundCount=0;
+ defArgsStr=yytext;
+ findDefArgContext = CopyLine;
+ BEGIN(FindDefineArgs);
+ }
+ else
+ {
+ outputArray(yytext,yyleng);
+ }
+ }
+<CopyLine>{ID} {
+ Define *def=0;
+ if (includeStack.isEmpty() &&
+ macroExpansionFlag &&
+ (def=fileDefineDict->find(yytext)) &&
+ def->nargs==0
+ )
+ {
+ QString name=yytext;
+ QString result=expandMacro(name);
+ outputArray(result,result.length());
+ }
+ else
+ {
+ outputArray(yytext,yyleng);
+ }
+ }
+<CopyLine>. {
+ outputChar(*yytext);
+ }
+<CopyLine>\n {
+ outputChar('\n');
+ BEGIN(Start);
+ yyLineNr++;
+ }
+<FindDefineArgs>"(" {
+ defArgsStr+='(';
+ roundCount++;
+ }
+<FindDefineArgs>")" {
+ defArgsStr+=')';
+ roundCount--;
+ if (roundCount==0)
+ {
+ QString result=expandMacro(defArgsStr);
+ if (findDefArgContext==CopyLine)
+ {
+ outputArray(result,result.length());
+ BEGIN(findDefArgContext);
+ }
+ else // findDefArgContext==IncludeID
+ {
+ readIncludeFile(result);
+ BEGIN(Start);
+ }
+ }
+ }
+ /*
+<FindDefineArgs>")"{B}*"(" {
+ defArgsStr+=yytext;
+ }
+ */
+<FindDefineArgs>"\"" {
+ defArgsStr+=*yytext;
+ BEGIN(ReadString);
+ }
+<FindDefineArgs>\n {
+ yyLineNr++;
+ outputChar('\n');
+ }
+<FindDefineArgs>"@" {
+ defArgsStr+="@@";
+ }
+<FindDefineArgs>. {
+ defArgsStr+=*yytext;
+ }
+<ReadString>"\\\"" {
+ defArgsStr+=yytext;
+ }
+<ReadString>"\"" {
+ defArgsStr+=*yytext;
+ BEGIN(FindDefineArgs);
+ }
+<ReadString>. {
+ defArgsStr+=*yytext;
+ }
+<Command>"include"{B}*/{ID} {
+ if (macroExpansionFlag)
+ BEGIN(IncludeID);
+ }
+<Command>"include"{B}*[<"] {
+ BEGIN(Include);
+ }
+<Command>"define"{B}+ {
+ //printf("!!!DefineName\n");
+ BEGIN(DefineName);
+ }
+<Command>"ifdef"/{B}*"(" {
+ incrLevel();
+ guardExpr.resize(0);
+ BEGIN(DefinedExpr2);
+ }
+<Command>"ifdef"/{B}+ {
+ //printf("Pre.l: ifdef\n");
+ incrLevel();
+ guardExpr.resize(0);
+ BEGIN(DefinedExpr1);
+ }
+<Command>"ifndef"/{B}*"(" {
+ incrLevel();
+ guardExpr="! ";
+ BEGIN(DefinedExpr2);
+ }
+<Command>"ifndef"/{B}+ {
+ incrLevel();
+ guardExpr="! ";
+ BEGIN(DefinedExpr1);
+ }
+<Command>"if"/[ \t(] {
+ incrLevel();
+ guardExpr.resize(0);
+ BEGIN(Guard);
+ }
+<Command>"elif"/[ \t(] {
+ if (!otherCaseDone())
+ {
+ guardExpr.resize(0);
+ BEGIN(Guard);
+ }
+ else
+ {
+ ifcount=0;
+ BEGIN(SkipCPPBlock);
+ }
+ }
+<Command>"else"/[^a-z_A-Z0-9] {
+ //printf("else levelGuard[%d]=%d\n",level-1,levelGuard[level-1]);
+ if (otherCaseDone())
+ {
+ ifcount=0;
+ BEGIN(SkipCPPBlock);
+ }
+ else
+ {
+ setCaseDone(TRUE);
+ //levelGuard[level-1]=TRUE;
+ }
+ }
+<Command>"undef"{B}+ {
+ BEGIN(UndefName);
+ }
+<Command>"elif"/[ \t(] {
+ if (!otherCaseDone())
+ {
+ guardExpr.resize(0);
+ BEGIN(Guard);
+ }
+ }
+<Command>"endif"/[^a-z_A-Z0-9] {
+ //printf("Pre.l: #endif\n");
+ decrLevel();
+ }
+<Command,IgnoreLine>\n {
+ outputChar('\n');
+ BEGIN(Start);
+ yyLineNr++;
+ }
+<Command>{ID} { // unknown directive
+ BEGIN(IgnoreLine);
+ }
+<IgnoreLine>.
+<Command>.
+<UndefName>{ID} {
+ Define *def;
+ if ((def=isDefined(yytext)))
+ {
+ //printf("undefining %s\n",yytext);
+ def->undef=TRUE;
+ }
+ BEGIN(Start);
+ }
+<Guard>\\\n {
+ outputChar('\n');
+ guardExpr+=' ';
+ yyLineNr++;
+ }
+<Guard>"defined"/{B}*"(" {
+ BEGIN(DefinedExpr2);
+ }
+<Guard>"defined"/{B}+ {
+ BEGIN(DefinedExpr1);
+ }
+<Guard>. { guardExpr+=*yytext; }
+<Guard>\n {
+ outputChar('\n');
+ yyLineNr++;
+ //printf("Guard: `%s'\n",
+ // guardExpr.data());
+ bool guard=computeExpression(guardExpr);
+ setCaseDone(guard);
+ //printf("if levelGuard[%d]=%d\n",level-1,levelGuard[level-1]);
+ if (guard)
+ {
+ BEGIN(Start);
+ }
+ else
+ {
+ ifcount=0;
+ BEGIN(SkipCPPBlock);
+ }
+ }
+<DefinedExpr1,DefinedExpr2>\\\n { yyLineNr++; outputChar('\n'); }
+<DefinedExpr1>{ID} {
+ if (isDefined(yytext))
+ guardExpr+=" 1L ";
+ else
+ guardExpr+=" 0L ";
+ BEGIN(Guard);
+ }
+<DefinedExpr2>{ID} {
+ if (isDefined(yytext))
+ guardExpr+=" 1L ";
+ else
+ guardExpr+=" 0L ";
+ }
+<DefinedExpr1,DefinedExpr2>\n { // should not happen, handle anyway
+ ifcount=0;
+ BEGIN(SkipCPPBlock);
+ }
+<DefinedExpr2>")" {
+ BEGIN(Guard);
+ }
+<DefinedExpr1,DefinedExpr2>.
+<SkipCPPBlock>^{B}*"#" { BEGIN(SkipCommand); }
+<SkipCPPBlock>^{B}*/[^#] { BEGIN(SkipLine); }
+<SkipCPPBlock>.
+<SkipCommand>"if"(("n")?("def"))?/[ \t(] {
+ incrLevel();
+ ifcount++;
+ //printf("#if... depth=%d\n",ifcount);
+ }
+<SkipCommand>"else"/[^a-z_A-Z0-9] {
+ //printf("Else! ifcount=%d otherCaseDone=%d\n",ifcount,otherCaseDone());
+ if (ifcount==0 && !otherCaseDone())
+ {
+ setCaseDone(TRUE);
+ //outputChar('\n');
+ BEGIN(Start);
+ }
+ }
+<SkipCommand>"elif"/[ \t(] {
+ if (ifcount==0)
+ {
+ if (!otherCaseDone())
+ {
+ guardExpr.resize(0);
+ BEGIN(Guard);
+ }
+ else
+ {
+ BEGIN(Start);
+ }
+ }
+ }
+<SkipCommand>"endif"/[^a-z_A-Z0-9] {
+ decrLevel();
+ if (--ifcount<0)
+ {
+ //outputChar('\n');
+ BEGIN(Start);
+ }
+ }
+<SkipCommand>\n {
+ outputChar('\n');
+ yyLineNr++;
+ BEGIN(SkipCPPBlock);
+ }
+<SkipCommand>{ID} { // unknown directive
+ BEGIN(SkipLine);
+ }
+<SkipCommand>.
+<SkipLine>[^/\n]+
+<SkipLine>.
+<SkipLine>"//" {
+ lastCPPContext=YY_START;
+ BEGIN(RemoveCPPComment);
+ }
+<SkipLine>"/*" {
+ lastCContext=YY_START;
+ BEGIN(RemoveCComment);
+ }
+<SkipLine>\n {
+ outputChar('\n');
+ yyLineNr++;
+ BEGIN(SkipCPPBlock);
+ }
+<IncludeID>{ID}{B}*/"(" {
+ roundCount=0;
+ defArgsStr=yytext;
+ findDefArgContext = IncludeID;
+ BEGIN(FindDefineArgs);
+ }
+<IncludeID>{ID} {
+ readIncludeFile(expandMacro(yytext));
+ BEGIN(Start);
+ }
+<Include>[^\">\n]+[\">] {
+ QString incName=yytext;
+ //int l=incName.length();
+ //QString incFileName=incName.left(l-1);
+ //if (fileDefineCache->fileCached(incFileName))
+ //{
+ // printf("file already cached!\n");
+ // fileDefineCache->merge(incFileName,yyFileName);
+ //}
+ //else if ((f=findFile(incFileName)))
+ readIncludeFile(incName);
+
+ BEGIN(Start);
+ }
+<DefineName>{ID}/"(" {
+ //printf("Define() `%s'\n",yytext);
+ argDict = new QDict<int>(31);
+ argDict->setAutoDelete(TRUE);
+ defArgs = 0;
+ defArgsStr.resize(0);
+ defText.resize(0);
+ defName = yytext;
+ defVarArgs = FALSE;
+ BEGIN(DefineArg);
+ }
+<DefineName>{ID}/{B}* {
+ //printf("Define `%s'\n",yytext);
+ argDict = 0;
+ defArgs = 0;
+ defArgsStr.resize(0);
+ defText.resize(0);
+ defName = yytext;
+ defVarArgs = FALSE;
+ QString tmp=(QString)"#define "+defName+defArgsStr;
+ outputArray(tmp.data(),tmp.length());
+ quoteArg=FALSE;
+ BEGIN(DefineText);
+ }
+<DefineArg>","{B}* { defArgsStr+=yytext; }
+<DefineArg>"("{B}* { defArgsStr+=yytext; }
+<DefineArg>")"{B}* {
+ defArgsStr+=yytext;
+ QString tmp=(QString)"#define "+defName+defArgsStr;
+ outputArray(tmp.data(),tmp.length());
+ quoteArg=FALSE;
+ BEGIN(DefineText);
+ }
+<DefineArg>{ID}("..."?) {
+ //printf("Define addArg(%s)\n",yytext);
+ QString argName=yytext;
+ defVarArgs = yytext[yyleng-1]=='.';
+ if (defVarArgs)
+ argName=argName.left(argName.length()-3);
+ defArgsStr+=yytext;
+ argDict->insert(argName,new int(defArgs));
+ defArgs++;
+ }
+<DefineText>"/*" {
+ outputChar('/');outputChar('*');
+ defText+=' ';
+ lastCContext=YY_START;
+ BEGIN(SkipCComment);
+ }
+<DefineText>"//" {
+ outputChar('/');outputChar('/');
+ lastCPPContext=YY_START;
+ BEGIN(SkipCPPComment);
+ }
+<SkipCComment>"*/" {
+ outputChar('*');outputChar('/');
+ BEGIN(lastCContext);
+ }
+<SkipCComment>"//" {
+ outputChar('/');outputChar('/');
+ }
+<SkipCComment>"/*" {
+ outputChar('/');outputChar('*');
+ }
+<SkipCComment>[^*\n]+ {
+ outputArray(yytext,yyleng);
+ }
+<SkipCComment>\n {
+ yyLineNr++;
+ outputChar('\n');
+ }
+<SkipCComment>. {
+ outputChar(*yytext);
+ }
+<RemoveCComment>"*/" { BEGIN(lastCContext); }
+<RemoveCComment>"//"
+<RemoveCComment>"/*"
+<RemoveCComment>[^*\n]+
+<RemoveCComment>\n { yyLineNr++; outputChar('\n'); }
+<RemoveCComment>.
+<SkipCPPComment,RemoveCPPComment>\n {
+ unput(*yytext);
+ BEGIN(lastCPPContext);
+ }
+<SkipCPPComment>"/*" {
+ outputChar('/');outputChar('*');
+ }
+<SkipCPPComment>"//" {
+ outputChar('/');outputChar('/');
+ }
+<SkipCPPComment>[^\n]+ {
+ outputArray(yytext,yyleng);
+ }
+<SkipCPPComment>. {
+ outputChar(*yytext);
+ }
+<RemoveCPPComment>"/*"
+<RemoveCPPComment>"//"
+<RemoveCPPComment>[^\n]+
+<RemoveCPPComment>.
+<DefineText>"#" {
+ quoteArg=TRUE;
+ }
+<DefineText>{ID} {
+ //bool quote=FALSE;
+ //char *p=yytext;
+ //if (p[0]=='#')
+ //{
+ // p++;
+ // quote=TRUE;
+ // defText+="\"";
+ //}
+ if (quoteArg)
+ {
+ defText+="\"";
+ }
+ if (defArgs>0)
+ {
+ int *n;
+ if ((n=(*argDict)[yytext]))
+ {
+ if (!quoteArg) defText+=' ';
+ defText+='@';
+ QString numStr;
+ numStr.setNum(*n);
+ defText+=numStr;
+ if (!quoteArg) defText+=' ';
+ }
+ else
+ {
+ defText+=yytext;
+ }
+ }
+ else
+ {
+ defText+=yytext;
+ }
+ if (quoteArg)
+ {
+ defText+="\"";
+ }
+ quoteArg=FALSE;
+ }
+<DefineText>\\\n {
+ outputChar('\n');
+ defText += ' '; yyLineNr++;
+ }
+<DefineText>\n {
+ outputChar('\n');
+ Define *def=0;
+ //printf("Define name=`%s' text=`%s'\n",defName.data(),defText.data());
+ if (includeStack.isEmpty()) addDefine();
+ if (!onlyPredefinedFlag && (def=fileDefineDict->find(defName))==0)
+ {
+ fileDefineDict->insert(defName,newDefine());
+ }
+ //if ((def=fileDefineCache->findDefine(yyFileName,defName))==0)
+ //{
+ // printf("define is not found\n");
+ // fileDefineCache->insertDefine(yyFileName,defName,newDefine());
+ //}
+ else if (def)// name already exists
+ {
+ //printf("define found\n");
+ if (def->undef) // undefined name
+ {
+ def->undef = FALSE;
+ def->name = defName;
+ def->definition = defText.stripWhiteSpace();
+ def->nargs = defArgs;
+ def->fileName = yyFileName;
+ def->lineNr = yyLineNr;
+ }
+ else
+ {
+ //printf("Error: define %s is defined more than once!\n",defName.data());
+ }
+ }
+ delete argDict;
+ yyLineNr++;
+ BEGIN(Start);
+ }
+<DefineText>{B}* { defText += ' '; }
+<DefineText>{B}*"##"{B}* { defText += "##"; }
+<DefineText>"@" { defText += "@@"; }
+<DefineText>\" { defText += *yytext;
+ BEGIN(SkipDoubleQuote);
+ }
+<DefineText>\' { defText += *yytext;
+ BEGIN(SkipSingleQuote);
+ }
+<SkipDoubleQuote>\" {
+ defText += *yytext;
+ BEGIN(DefineText);
+ }
+<SkipSingleQuote>\' {
+ defText += *yytext;
+ BEGIN(DefineText);
+ }
+<SkipDoubleQuote>. { defText += *yytext; }
+<SkipSingleQuote>. { defText += *yytext; }
+<DefineText>. { defText += *yytext; }
+<<EOF>> {
+ //printf("End of include file\n");
+ //printf("Include stack depth=%d\n",includeStack.count());
+ if (includeStack.isEmpty())
+ {
+ //printf("Terminating scanner!\n");
+ yyterminate();
+ }
+ else
+ {
+ FileState *fs=includeStack.pop();
+ //fileDefineCache->merge(yyFileName,fs->fileName);
+ if (inputFilter.isEmpty())
+ fclose(fs->filePtr);
+ else
+ pclose(fs->filePtr);
+ YY_BUFFER_STATE oldBuf = YY_CURRENT_BUFFER;
+ yy_switch_to_buffer( fs->bufState );
+ yy_delete_buffer( oldBuf );
+ yyLineNr=fs->lineNr;
+ yyFileName=fs->fileName.copy();
+ //printf("######## FileName %s\n",yyFileName.data());
+ delete fs;
+ }
+ }
+<*>"/*" {
+ outputChar('/');outputChar('*');
+ lastCContext=YY_START;
+ BEGIN(SkipCComment);
+ }
+<*>"//" {
+ outputChar('/');outputChar('/');
+ lastCPPContext=YY_START;
+ BEGIN(SkipCPPComment);
+ }
+<*>\n {
+ outputChar('\n');
+ yyLineNr++;
+ }
+<*>. {
+ outputChar(*yytext);
+ }
+
+%%
+
+/*@ ----------------------------------------------------------------------------
+ */
+
+static int getNextChar(const QString &expr,QString *rest,uint &pos)
+{
+ //printf("getNextChar(%s,%s,%d)\n",expr.data(),rest ? rest->data() : 0,pos);
+ if (pos<expr.length())
+ {
+ //printf("%c=expr()\n",expr.at(pos));
+ return expr.at(pos++);
+ }
+ else if (rest && rest->length()>0)
+ {
+ int cc=rest->at(0);
+ *rest=rest->right(rest->length()-1);
+ //printf("%c=rest\n",cc);
+ return cc;
+ }
+ else
+ {
+ int cc=yyinput();
+ //printf("%c=yyinput()\n",cc);
+ return cc;
+ }
+}
+
+static int getCurrentChar(const QString &expr,QString *rest,uint pos)
+{
+ //printf("getCurrentChar(%s,%s,%d)\n",expr.data(),rest ? rest->data() : 0,pos);
+ if (pos<expr.length())
+ {
+ //printf("%c=expr()\n",expr.at(pos));
+ return expr.at(pos);
+ }
+ else if (rest && rest->length()>0)
+ {
+ int cc=rest->at(0);
+ //printf("%c=rest\n",cc);
+ return cc;
+ }
+ else
+ {
+ int cc=yyinput();unput(cc);
+ //printf("%c=yyinput()\n",cc);
+ return cc;
+ }
+}
+
+static void unputChar(const QString &expr,QString *rest,uint &pos,char c)
+{
+ //printf("unputChar(%s,%s,%d,%c)\n",expr.data(),rest ? rest->data() : 0,pos,c);
+ if (pos<expr.length())
+ {
+ pos++;
+ }
+ else if (rest)
+ {
+ //printf("Prepending to rest!\n");
+ char cs[2];cs[0]=c;cs[1]='\0';
+ rest->prepend(cs);
+ }
+ else
+ {
+ unput(c);
+ }
+ //printf("result: unputChar(%s,%s,%d,%c)\n",expr.data(),rest ? rest->data() : 0,pos,c);
+}
+
+void addSearchDir(const char *dir)
+{
+ QFileInfo fi(dir);
+ if (fi.isDir()) pathList->append(fi.absFilePath());
+}
+
+void initPreprocessor()
+{
+ pathList = new QStrList;
+ addSearchDir(".");
+ //defineNameList.setAutoDelete(TRUE);
+ //defineNameList.clear();
+ defineDict.clear();
+ //fileDefineCache = new DefineCache(1009);
+ expandedDict = new DefineDict(17);
+ fileDefineDict = new DefineDict(1009);
+}
+
+void cleanupPreprocessor()
+{
+ //delete fileDefineCache;
+ delete fileDefineDict;
+ delete expandedDict;
+ delete pathList;
+}
+
+
+void preprocessFile(const char *fileName,BufStr &output)
+{
+#if DUMP_OUTPUT
+ uint orgOffset=output.curPos();
+#endif
+
+ outputBuf=&output;
+ includeStack.setAutoDelete(TRUE);
+ includeStack.clear();
+ fileDefineDict->setAutoDelete(TRUE);
+ fileDefineDict->clear();
+ expandedDict->setAutoDelete(FALSE);
+ expandedDict->clear();
+
+ // add predefined macros
+ char *defStr = predefined.first();
+ while (defStr)
+ {
+ QString ds = defStr;
+ int i;
+ if ((i=ds.find('='))==-1)
+ {
+ if (ds.length()>0)
+ {
+ Define *def = new Define;
+ def->name = ds;
+ def->definition = "1";
+ def->nargs = 0;
+ fileDefineDict->insert(ds,def);
+ }
+ }
+ else
+ {
+ if (i>0 && (int)ds.length()>i)
+ {
+ Define *def = new Define;
+ def->name = ds.left(i);
+ def->definition = ds.right(ds.length()-i-1);
+ def->nargs = 0;
+ fileDefineDict->insert(ds.left(i),def);
+ }
+ }
+ defStr=predefined.next();
+ }
+
+ if (inputFilter.isEmpty())
+ {
+ preYYin = fopen(fileName,"r");
+ if (!preYYin)
+ {
+ err("Error: could not open file %s\n",fileName);
+ return;
+ }
+ }
+ else
+ {
+ QString cmd = inputFilter+" "+fileName;
+ preYYin = popen(cmd,"r");
+ if (!preYYin)
+ {
+ err("Error: could not execute filter %s\n",cmd.data());
+ return;
+ }
+ }
+ yyLineNr = 1;
+ level = 0;
+ yyFileName = fileName;
+ BEGIN( Start );
+ preYYlex();
+ if (inputFilter.isEmpty())
+ fclose(preYYin);
+ else
+ pclose(preYYin);
+
+#if DUMP_OUTPUT
+ char *orgPos=output.data()+orgOffset;
+ char *newPos=output.data()+output.curPos();
+ printf("Resulting size: %d bytes\n",newPos-orgPos);
+ int line=1;
+ printf("---------\n00001 ");
+ while (orgPos<newPos)
+ {
+ putchar(*orgPos);
+ if (*orgPos=='\n') printf("%05d ",++line);
+ orgPos++;
+ }
+ printf("\n---------\n");
+#endif
+}
+
+
+extern "C" { // some bogus code to keep the compiler happy
+ int preYYwrap() { return 1 ; }
+ void preYYdummy() { yy_flex_realloc(0,0); }
+}
generated by cgit v0.12 at 2024-06-28 17:45:35 (GMT)