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

 *

 * 

 *

 * 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 <stdlib.h>

#include <assert.h>

#include <ctype.h>

#include "qtbc.h"

#include <qarray.h>

#include <qstack.h>

#include <qregexp.h>

#include <unistd.h>

#include <qfile.h>

#include "scanner.h"

#include "entry.h"

#include "message.h"

#include "config.h"

#include "doxygen.h"

#include "util.h"

#include "defargs.h"

#include "language.h"

#include "commentscan.h"

#include "code.h"

#define YY_NEVER_INTERACTIVE 1

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

 *

 *	statics

 */

static ParserInterface *g_thisParser;

static const char *     inputString;

static int		inputPosition;

static QFile            inputFile;

static int		lastContext;

static int		lastCContext;

static int              lastDocContext;

static int              lastCPPContext;

static int              lastSkipSharpContext;

static int              lastSkipRoundContext;

static int              lastStringContext;

static int              lastCurlyContext;

static int              lastRoundContext;

static int              lastSquareContext;

static int              lastInitializerContext;

static int              lastClassTemplSpecContext;

static int              lastPreLineCtrlContext;

static int              lastSkipVerbStringContext;

static int              lastCommentInArgContext;

static int              lastCSConstraint;

static Protection	protection;

static Protection	baseProt;

static int		sharpCount   = 0 ;

static int		roundCount   = 0 ;

static int		curlyCount   = 0 ;

static int		squareCount  = 0 ;

static int              padCount     = 0 ;

static QCString         slString;

static Entry*		current_root = 0 ;

static Entry*		global_root  = 0 ;

static Entry*		current      = 0 ;

static Entry*		previous     = 0 ;

static Entry*		tempEntry    = 0 ;

static Entry*		firstTypedefEntry = 0 ;

static Entry*		memspecEntry = 0 ;

static int		yyLineNr     = 1 ;

static int              anonCount    = 0 ;        

static int              anonNSCount  = 0 ;        

static QCString		yyFileName;

static MethodTypes 	mtype;

static bool    		gstat;

static bool             removeSlashes;

static Specifier 	virt;

static Specifier 	baseVirt;

static QCString         msType,msName,msArgs;

static bool             isTypedef;

static int              tmpDocType;

static QCString         sectionLabel;

static QCString		sectionTitle;

static QCString         funcPtrType;

static QCString         templateStr;

static QCString         aliasName;

static QCString         baseName;

static QCString*        specName;

static QCString         formulaText;

static QCString         formulaEnd;

static bool             useOverrideCommands = FALSE;

static bool             insideIDL   = FALSE;		//!< processing IDL code?

static bool             insideJava  = FALSE;		//!< processing Java code?

static bool             insideCS    = FALSE;		//!< processing C# code?

static bool             insideD     = FALSE;		//!< processing D code?

static bool             insidePHP   = FALSE;		//!< processing PHP code?

static bool             insideObjC  = FALSE;            //!< processing Objective C code?

static bool             insideCli   = FALSE;            //!< processing C++/CLI code?

static bool             insideJS    = FALSE;            //!< processing JavaScript code?

static bool             insideCppQuote = FALSE;

static bool             insideProtocolList = FALSE;

static int              argRoundCount;

static int              argSharpCount;

static int              currentArgumentContext;

static int              lastCopyArgStringContext;

static int              lastCopyArgContext;

static QCString         *copyArgString;

static QCString         fullArgString;

static ArgumentList     *currentArgumentList;

static char             lastCopyArgChar;

static QCString         *pCopyQuotedString;

static QCString         *pCopyRoundString;

static QCString         *pCopyCurlyString;

static QGString         *pCopyCurlyGString;

static QGString         *pCopyRoundGString;

static QGString         *pCopyQuotedGString;

static QGString         *pSkipVerbString;

static QStack<Grouping> autoGroupStack;

static bool             insideFormula;

static bool  	        insideTryBlock=FALSE;

static bool             insideCode;

static bool             needsSemi;

static int              depthIf;

static int  	        initBracketCount;

static QCString         memberGroupRelates;

static QCString         memberGroupInside;

static QCString         xrefItemKey;

static QCString         xrefItemTitle;

static QCString         xrefListTitle;

static QCString         g_skipBlockName;

static QCString         oldStyleArgType;

static QCString         docBackup;

static QCString         briefBackup;

static bool             g_inputFromFile;

static int              docBlockContext;

static QCString         docBlock;

static QCString         docBlockName;

static bool             docBlockInBody;

static bool             docBlockAutoBrief;

static char             docBlockTerm;

static QCString         idlAttr;

static QCString         idlProp;

static bool             g_lexInit = FALSE;

static bool             externC;

//-----------------------------------------------------------------------------

// forward declarations

//static void handleGroupStartCommand(const char *header);

//static void handleGroupEndCommand();

//-----------------------------------------------------------------------------

static void initParser()

{

  sectionLabel.resize(0);

  sectionTitle.resize(0);

  baseName.resize(0);

  formulaText.resize(0);

  protection = Public;

  baseProt = Public;

  sharpCount = 0;

  roundCount = 0;

  curlyCount = 0;

  mtype = Method;

  gstat = FALSE;

  virt = Normal;

  baseVirt = Normal;

  isTypedef = FALSE;

  autoGroupStack.clear();

  insideTryBlock = FALSE;

  autoGroupStack.setAutoDelete(TRUE);

  insideFormula = FALSE;

  insideCode=FALSE;

  insideCli=Config_getBool("CPP_CLI_SUPPORT");

  previous = 0;

}

static void initEntry()

{

  if (insideJava) 

  {

    protection = (current_root->spec & Entry::Interface) ?  Public : Package;

  }

  current->protection = protection ;

  current->mtype      = mtype;

  current->virt       = virt;

  current->stat       = gstat;

  current->objc       = insideObjC;

  //if (!autoGroupStack.isEmpty())

  //{

  //  //printf("Appending group %s\n",autoGroupStack.top()->groupname.data());

  //  current->groups->append(new Grouping(*autoGroupStack.top()));

  //}

  initGroupInfo(current);

  isTypedef=FALSE;

}

//-----------------------------------------------------------------------------

///// remove any automatic grouping and add new one (if given)

//static void setCurrentGroup( QCString *newgroup, Grouping::GroupPri_t pri )

//{

//   /* remove auto group name from current entry and discard it */

//   Grouping *g = current->groups->first();

//   int i=0; 

//   while (g)

//   {

//     if (g->pri <= Grouping::GROUPING_AUTO_DEF)

//     {

//       current->groups->remove(i);

//       i--;

//     }

//     g=current->groups->next();

//     i++;

//   }

//

//   /* use new group name instead? */

//   if ( newgroup )

//   {

//      current->groups->append(new Grouping(*newgroup, pri));

//   } 

//}

//

//static int newMemberGroupId()

//{

//  static int curGroupId=0;

//  return curGroupId++;

//}

//

// forward declarations

//static void startGroupInDoc();

//static void endGroup();

//-----------------------------------------------------------------------------

static void lineCount()

{

  for( const char* c = yytext ; *c ; ++c )

    yyLineNr += (*c == '\n') ;

}

static void addType( Entry* current )

{

    uint tl=current->type.length();

    if( tl>0 && !current->name.isEmpty() && current->type.at(tl-1)!='.') 

    {

      current->type += ' ' ;

    }

    current->type += current->name ;

    current->name.resize(0) ;

    tl=current->type.length();

    if( tl>0 && !current->args.isEmpty() && current->type.at(tl-1)!='.') 

    {

      current->type += ' ' ;

    }

    current->type += current->args ;

    current->args.resize(0) ;

    current->argList->clear();

}

static QCString stripQuotes(const char *s)

{

  QCString name;

  if (s==0 || *s==0) return name;

  name=s;

  if (name.at(0)=='"' && name.at(name.length()-1)=='"')

  {

    name=name.mid(1,name.length()-2);

  }

  return name;

}

//-----------------------------------------------------------------

static void startCommentBlock(bool);

static void handleCommentBlock(const QCString &doc,bool brief);

static void handleParametersCommentBlocks(ArgumentList *al);

//-----------------------------------------------------------------

static bool nameIsOperator(QCString &name)

{

  int i=name.find("operator");

  if (i==-1) return FALSE;

  if (i==0 && !isId(name.at(8))) return TRUE; // case operator ::X

  if (i>0 && !isId(name.at(i-1)) && !isId(name.at(i+8))) return TRUE; // case X::operator

  return FALSE; // case TEXToperatorTEXT

}

//-----------------------------------------------------------------------------

static void setContext()

{

  QCString fileName = yyFileName;

  SrcLangExt langExt = getLanguageFromFileName(fileName);

  insideIDL  = langExt==SrcLangExt_IDL;

  insideJava = langExt==SrcLangExt_Java;

  insideCS   = langExt==SrcLangExt_CSharp; 

  insideD    = langExt==SrcLangExt_D;

  insidePHP  = langExt==SrcLangExt_PHP;

  insideObjC = langExt==SrcLangExt_ObjC;

  insideJS   = langExt==SrcLangExt_JS;

  if ( insidePHP )

  {

    useOverrideCommands = TRUE;

  }

  //printf("setContext(%s) insideIDL=%d insideJava=%d insideCS=%d "

  //       "insideD=%d insidePHP=%d insideObjC=%d\n",

  //       yyFileName.data(),insideIDL,insideJava,insideCS,insideD,insidePHP,insideObjC

  //	);

}

//-----------------------------------------------------------------------------

static void prependScope()

{

  if (current_root->section & Entry::SCOPE_MASK)

  {

    //printf("--- prependScope %s to %s\n",current_root->name.data(),current->name.data());

    current->name.prepend(current_root->name+"::");

    if (current_root->tArgLists)

    {

      if (current->tArgLists==0)

      {

	current->tArgLists = new QList<ArgumentList>;

	current->tArgLists->setAutoDelete(TRUE);

      }

      //printf("prependScope #=%d #current=%d\n",current_root->tArgLists->count(),current->tArgLists->count());

      QListIterator<ArgumentList> talsi(*current_root->tArgLists);

      ArgumentList *srcAl=0;

      for (talsi.toLast();(srcAl=talsi.current());--talsi)

      {

        ArgumentList *dstAl = new ArgumentList;

	QListIterator<Argument> tali(*srcAl);

        Argument *a;

        for (;(a=tali.current());++tali)

        {

          dstAl->append(new Argument(*a));

        //printf("appending argument %s %s\n",a->type.data(),a->name.data());

        }	  

        current->tArgLists->insert(0,dstAl);	

      }

    }

  }

}

//-----------------------------------------------------------------------------

/*! Returns TRUE iff the current entry could be a K&R style C function */

static bool checkForKnRstyleC()

{

  if (((QCString)yyFileName).right(2).lower()!=".c") return FALSE; // must be a C file

  if (!current->argList) return FALSE; // must have arguments

  ArgumentListIterator ali(*current->argList);

  Argument *a;

  for (ali.toFirst();(a=ali.current());++ali)

  {

    // in K&R style argument do not have a type, but doxygen expects a type

    // so it will think the argument has no name

    if (a->type.isEmpty() || !a->name.isEmpty()) return FALSE;

  }

  return TRUE;

}

//-----------------------------------------------------------------------------

static void splitKnRArg(QCString &oldStyleArgPtr,QCString &oldStyleArgName)

{

  int si = current->args.length();

  if (oldStyleArgType.isEmpty()) // new argument

  {

    static QRegExp re("([^)]*)");

    int bi1 = current->args.findRev(re);

    int bi2 = bi1!=-1 ? current->args.findRev(re,bi1-1) : -1; 

    char c;

    if (bi1!=-1 && bi2!=-1) // found something like "int (*func)(int arg)"

    {

      int s=bi2+1;

      oldStyleArgType = current->args.left(s);

      int i=s;

      while (i<si && ((c=current->args.at(i))=='*' || isspace((uchar)c))) i++;

      oldStyleArgType += current->args.mid(s,i-s);

      s=i;

      while (i<si && isId(current->args.at(i))) i++;

      oldStyleArgName = current->args.mid(s,i-s);

      oldStyleArgType+=current->args.mid(i);

    }

    else if (bi1!=-1) // redundant braces like in "int (*var)"

    {

      int s=bi1;

      oldStyleArgType = current->args.left(s);

      s++;

      int i=s+1;

      while (i<si && ((c=current->args.at(i))=='*' || isspace((uchar)c))) i++;

      oldStyleArgType += current->args.mid(s,i-s);

      s=i;

      while (i<si && isId(current->args.at(i))) i++;

      oldStyleArgName = current->args.mid(s,i-s);

    }

    else // normal "int *var"

    {

      int l=si,i=l-1,j;

      char c;

      // look for start of name in "type *name"

      while (i>=0 && isId(current->args.at(i))) i--;

      j=i+1;

      // look for start of *'s

      while (i>=0 && ((c=current->args.at(i))=='*' || isspace((uchar)c))) i--;

      i++;

      if (i!=l)

      {

	oldStyleArgType=current->args.left(i);

	oldStyleArgPtr=current->args.mid(i,j-i);

	oldStyleArgName=current->args.mid(j).stripWhiteSpace();

      }

      else

      {

	oldStyleArgName=current->args.copy().stripWhiteSpace();

      }

    }

  }

  else // continuation like *arg2 in "int *args,*arg2"

  {

    int l=si,j=0;

    char c;

    while (j<l && ((c=current->args.at(j))=='*' || isspace((uchar)c))) j++;

    if (j>0)

    {

      oldStyleArgPtr=current->args.left(j);

      oldStyleArgName=current->args.mid(j).stripWhiteSpace();

    }

    else

    {

      oldStyleArgName=current->args.copy().stripWhiteSpace();

    }

  }

  //fprintf(stderr,"type=%s ptr=%s name=%s\n",oldStyleArgType.data(),oldStyleArgPtr.data(),oldStyleArgName.data());

}

//-----------------------------------------------------------------------------

/*! Update the argument \a name with additional \a type info. For K&R style

 *  function the type is found \e after the argument list, so this routine

 *  in needed to fix up.

 */

static void addKnRArgInfo(const QCString &type,const QCString &name,

                          const QCString &brief,const QCString &docs)

{

  if (current->argList==0) return;

  ArgumentListIterator ali(*current->argList);

  Argument *a;

  for (ali.toFirst();(a=ali.current());++ali)

  {

    if (a->type==name)

    {

      a->type=type.stripWhiteSpace();

      if (a->type.left(9)=="register ") // strip keyword

      {

	a->type=a->type.mid(9);

      }

      a->name=name.stripWhiteSpace();

      if (!brief.isEmpty() && !docs.isEmpty())

      {

        a->docs=brief+"\n\n"+docs;

      }

      else if (!brief.isEmpty())

      {

        a->docs=brief;

      }

      else

      {

	a->docs=docs;

      }

    }

  }

}

//-----------------------------------------------------------------------------

void fixArgumentListForJavaScript(ArgumentList *al)

{

  if (al==0) return;

  ArgumentListIterator ali(*al);

  Argument *a;

  for (ali.toFirst();(a=ali.current());++ali)

  {

    if (!a->type.isEmpty() && a->name.isEmpty())

    { // a->type is actually the (typeless) parameter name, so move it

      a->name=a->type;

      a->type.resize(0);

    }

  }

}