/******************************************************************************

 *

 * 

 *

 * Copyright (C) 1997-2008 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.

 *

 * Documents produced by Doxygen are derivative works derived from the

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

 *

 */

%{

/*

 *	includes

 */

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include "qtbc.h"

#include <qarray.h>

#include <qstack.h>

#include <qfile.h>

#include <qstrlist.h>

#include <qdict.h>

#include <qregexp.h>

#include <qfileinfo.h>

#include <qdir.h>

#include "pre.h"

#include "constexp.h"

#include "define.h"

#include "doxygen.h"

#include "message.h"

#include "util.h"

#include "defargs.h"

#include "debug.h"

#include "bufstr.h"

#include "portable.h"

#include "bufstr.h"

#define YY_NEVER_INTERACTIVE 1

struct FileState

{

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

  int lineNr;

  //FILE *filePtr;

  BufStr fileBuf;

  //FILE *oldYYin;

  BufStr *oldFileBuf;

  int oldFileBufPos;

  //bool isPlainFile;

  YY_BUFFER_STATE bufState;

  QCString fileName;

};  

/* -----------------------------------------------------------------

 *

 *	scanner's state

 */

static int                g_yyLineNr   = 1;

static QCString           g_yyFileName;

static FileDef           *g_yyFileDef;

static FileDef           *g_inputFileDef;

static int                g_ifcount    = 0;

static QStrList          *g_pathList = 0;  

static QStack<FileState>  g_includeStack;

static QDict<int>        *g_argDict;

static int                g_defArgs = -1;

static QCString           g_defName;

static QCString           g_defText;

static QCString           g_defLitText;

static QCString           g_defArgsStr;

static bool               g_defVarArgs;

static int                g_level;

static int                g_lastCContext;

static int                g_lastCPPContext;

static QArray<int>        g_levelGuard;

static BufStr            *g_inputBuf;

static int                g_inputBufPos;

static BufStr            *g_outputBuf;

static int                g_roundCount;

static bool               g_quoteArg;

static DefineDict        *g_fileDefineDict = new DefineDict(10009);

static DefineDict        *g_expandedDict;

static int                g_findDefArgContext;

static QCString           g_lastGuardName;

static QCString           g_incName;

static QCString           g_guardExpr;

static int                g_curlyCount;

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

static bool               g_macroExpansion; // from the configuration

static bool               g_expandOnlyPredef; // from the configuration

static int                g_commentCount;

static bool               g_insideComment;

static bool               g_isImported;

static QCString           g_blockName;

static int                g_condCtx;

static bool               g_skip;

static QStack<bool>       g_condStack;

static bool               g_insideCS; // C# has simpler preprocessor

static bool               g_lexInit = FALSE;

DefineDict* getFileDefineDict() 

{

  return g_fileDefineDict;

}

static void setFileName(const char *name)

{

  bool ambig;

  QFileInfo fi(name);

  g_yyFileName=convertToQCString(fi.absFilePath());

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

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

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

}

static void incrLevel()

{

  g_level++;

  g_levelGuard.resize(g_level);

  g_levelGuard[g_level-1]=FALSE;

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

}

static void decrLevel()

{

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

  if (g_level > 0)

  {

    g_level--;

    g_levelGuard.resize(g_level);

  }

  else

  {

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

	g_yyFileName.data(),g_yyLineNr);

  }

}

static bool otherCaseDone()

{

  if (g_level==0)

  {

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

	g_yyFileName.data(),g_yyLineNr);

    return TRUE;

  }

  else

  {

    return g_levelGuard[g_level-1];

  }

}

static void setCaseDone(bool value)

{

  g_levelGuard[g_level-1]=value;

}

static Define *isDefined(const char *name)

{

  if (name)

  {

    Define *def;

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

    //	return def;

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

  }

  return 0;

}

static QDict<void> g_allIncludes(10009);

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

{

  alreadyIncluded = FALSE;

  FileState *fs = 0;

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

  QFileInfo fi(fileName);

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

  {

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

    // global guard

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

    {

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

      {

        alreadyIncluded = TRUE;

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

        return 0; // already done

      }

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

    }

    // check include stack for absName

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

	// TRUE if absName matches any filename

    QStack<FileState> tmpStack;

    g_includeStack.setAutoDelete(FALSE);

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

    {

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

      tmpStack.push(fs);

    }

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

    {

      g_includeStack.push(fs);

    }

    g_includeStack.setAutoDelete(TRUE);

    if (alreadyIncluded)

    {

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

      return 0;

    }

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

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

    alreadyIncluded = FALSE;

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

    { // error

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

      delete fs;

      fs=0;

    }

    else

    {

      fs->oldFileBuf    = g_inputBuf;

      fs->oldFileBufPos = g_inputBufPos;

    }

#if 0

    QCString filterName = getFileFilter(absName);

    if (!filterName.isEmpty())

    {

      fs->isPlainFile = FALSE;

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

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

      if (!fs->filePtr)

      {

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

            strerror(errno));

      }

    }

    else

    {

      fs->isPlainFile = TRUE;

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

      if (!fs->filePtr)

      {

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

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

      }

    }

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

    {

      delete fs;

      fs=0;

    }

    else

    {

      fs->oldYYin = preYYin;

    }

#endif

  }

  return fs;

}

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

{

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

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

  {

    QFileInfo fi(g_yyFileName);

    if (fi.exists())

    {

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

      FileState *fs = checkAndOpenFile(absName,alreadyIncluded);

      if (fs)

      {

	setFileName(absName);

	g_yyLineNr=1;

	return fs;

      }

      else if (alreadyIncluded)

      {

	return 0;

      }

    }

  }

  if (g_pathList==0) 

  {

    return 0;

  }

  char *s=g_pathList->first();

  while (s)

  {

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

    FileState *fs = checkAndOpenFile(absName,alreadyIncluded);

    if (fs)

    {

      setFileName(absName);

      g_yyLineNr=1;

      return fs;

    }

    else if (alreadyIncluded)

    {

      return 0;

    }

    s=g_pathList->next();

  } 

  return 0;

}

static QCString extractTrailingComment(const char *s)

{

  if (s==0) return "";

  int i=strlen(s)-1;

  while (i>=0)

  {

    char c=s[i];

    switch (c)

    {

      case '/':

	{

	  i--;

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

	  {

	    i--;

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

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

	  }

	  else

	  {

	    return "";

	  }

	} 

	break;

	// whitespace or line-continuation

      case ' ':

      case '\t': 

      case '\r':

      case '\n':

      case '\\':

	break;

      default:

	return "";

    }

    i--;

  }

  return "";

}

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

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

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

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

static QCString stringize(const QCString &s)

{

  QCString 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(QCString &expr)

{

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

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

  int l,n,i=0;

  if (expr.isEmpty()) return;

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

  {

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

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

    {

      // remove no-rescan marker after ID

      l+=2;

    }

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

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

  }

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

}

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

static void returnCharToStream(char c)

{

  unput(c);

}

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

                                       uint &pos,char term,QCString &arg)

{

  int cc;

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

  {

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

    else if (cc==term) return;

    arg+=(char)cc;

  }

}

/*! 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.

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

 * 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 QCString &expr,QCString *rest,int pos,int &len,const Define *def,QCString &result)

{

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

  uint j=pos;

  len=0;

  result.resize(0);

  int cc;

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

  { 

    len++; 

    getNextChar(expr,rest,j); 

  }

  if (cc!='(') 

  { 

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

    return FALSE; 

  }

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

  QDict<QCString> argTable;  // list of arguments