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

 *

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

 *

 */

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

 * Parser for syntax hightlighting and references for vhdl subset

 * written by M. Kreis

 * supports VHDL-87

 * does not support VHDL-AMS 

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

%{

/*

 *        includes

 */

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <qregexp.h>

#include <qdir.h>

#include <qstringlist.h>

#include "qtbc.h"

#include "entry.h"

#include "doxygen.h"

#include "message.h"

#include "outputlist.h"

#include "util.h"

#include "membername.h"

#include "searchindex.h"

#include "vhdldocgen.h"

#define YY_NEVER_INTERACTIVE 1

// Toggle for some debugging info

//#define DBG_CTX(x) fprintf x

#define DBG_CTX(x) do { } while(0)

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

 *        statics

 */

// ----------------- <vhdl> ----------------------------------

//static bool isPackBody=FALSE;

//static bool isStartMap;

static bool isFuncProto=FALSE;

static bool isComponent=FALSE;

static bool isPackageBody=FALSE;

static bool isProto = FALSE;

static QCString   g_PrevString;

static QCString   g_CurrClass;

static QDict<QCString>g_vhdlKeyDict;   

static QCString   g_tempClass;

static QCString   g_tempComp;

static QCString   g_PortMapComp;

static MemberDef *g_vhdlMember;

static QCString   g_FuncProto;

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

static CodeOutputInterface * g_code;

static QCString      g_curClassName;

static QCString      g_parmType;

static QCString      g_parmName;

static const char *  g_inputString;     //!< the code fragment as text

static int           g_inputPosition;   //!< read offset during parsing 

static int           g_inputLines;      //!< number of line in the code fragment

static int           g_yyLineNr;        //!< current line number

static bool          g_needsTermination;

static QCString      g_exampleName;

static QCString      g_exampleFile;

static QCString      g_type;

static QCString      g_name;

static QCString      g_args;

static QCString      g_classScope;

static QCString      g_CurrScope;

static FileDef *     g_sourceFileDef;

static Definition *  g_currentDefinition;

static MemberDef *   g_currentMemberDef;

static bool          g_includeCodeFragment;

static const char *  g_currentFontClass;

static bool          g_lexInit = FALSE;

static int           g_braceCount=0;

static void writeFont(const char *s,const char* text);

static void generateMemLink(CodeOutputInterface &ol,QCString &clName,QCString& memberName);

static bool writeColoredWord(QCString& word );

static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName, bool typeOnly=FALSE);

static void endFontClass();

static void startFontClass(const char *s);

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

static void setCurrentDoc(const QCString &name,const QCString &base,const QCString &anchor="")

{

  if (Doxygen::searchIndex)

  {

    Doxygen::searchIndex->setCurrentDoc(name,base,anchor);

  }

}

static bool checkString(QCString &name)

{

  if (name.isEmpty()) return FALSE;

  static QRegExp regg("[\\s\"]");

  int len=name.length();

  if (name.at(0)=='"' && name.at(len-1)=='"' && len > 2)

  {

    QStringList qrl=QStringList::split(regg,name,FALSE);

    if (VhdlDocGen::isNumber((QCString)qrl[0]))

    {

      g_code->codify("\""); 

      startFontClass("vhdllogic");

      QCString mid=name.mid(1,len-2); //" 1223 "

      g_code->codify(mid.data());

      endFontClass();

      g_code->codify("\""); 

    }

    else

    {

      startFontClass("keyword");

      g_code->codify(name.data());

      endFontClass();

    }

    return TRUE;

  }

  if (VhdlDocGen::isNumber(name))

  {

    startFontClass("vhdllogic");

    g_code->codify(name.data());

    endFontClass();

    return TRUE;

  }

  return FALSE;

}

static void addToSearchIndex(const char *text)

{

  if (Doxygen::searchIndex)

  {

    Doxygen::searchIndex->addWord(text,FALSE);

  }

}

/*! start a new line of code, inserting a line number if g_sourceFileDef

 * is TRUE. If a definition starts at the current line, then the line

 * number is linked to the documentation of that definition.

 */

static void startCodeLine()

{

  //if (g_currentFontClass) { g_code->endFontClass(); }

  if (g_sourceFileDef)

  {

    //QCString lineNumber,lineAnchor;

    //lineNumber.sprintf("%05d",g_yyLineNr);

    //lineAnchor.sprintf("l%05d",g_yyLineNr);

    //  if ((g_yyLineNr % 500) == 0) 

    //         fprintf(stderr,"\n starting Line %d:",g_yyLineNr);

    Definition *d   = g_sourceFileDef->getSourceDefinition(g_yyLineNr);

    //printf("startCodeLine %d d=%s\n", g_yyLineNr,d ? d->name().data() : "<null>");

    if (!g_includeCodeFragment && d)

    {

      g_currentDefinition = d;

      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

      if (!g_tempComp.isEmpty() && g_currentMemberDef )

      {

        //ClassDef *cf=VhdlDocGen::getClass(g_tempComp.data());

        QCString nn=g_currentMemberDef->name();

        MemberDef* mdeff=VhdlDocGen::findMember(g_tempComp,nn);

        if (mdeff)

        {

          g_currentMemberDef=mdeff;

        }

      }

      g_parmType.resize(0);

      g_parmName.resize(0);

      QCString lineAnchor;

      lineAnchor.sprintf("l%05d",g_yyLineNr);

      if (g_currentMemberDef)

      {

        g_code->writeLineNumber(g_currentMemberDef->getReference(),

                                g_currentMemberDef->getOutputFileBase(),

                                g_currentMemberDef->anchor(),g_yyLineNr);

        setCurrentDoc(g_currentMemberDef->qualifiedName(),

                      g_sourceFileDef->getSourceFileBase(),

                      lineAnchor);

      }

      else if (d->isLinkableInProject())

      {

        g_code->writeLineNumber(d->getReference(),

                                d->getOutputFileBase(),

                                0,g_yyLineNr);

        setCurrentDoc(d->qualifiedName(),

                      g_sourceFileDef->getSourceFileBase(),

                      lineAnchor);

      }

    }

    else

    {

      g_code->writeLineNumber(0,0,0,g_yyLineNr);

    }

  }

  g_code->startCodeLine(); 

  if (g_currentFontClass)

  {

    g_code->startFontClass(g_currentFontClass);

  }

}

static void endFontClass();

static void endCodeLine()

{

  endFontClass();

  g_code->endCodeLine();

}

static void nextCodeLine()

{

  const char *fc = g_currentFontClass;

  endCodeLine();

  if (g_yyLineNr<g_inputLines) 

  {

    g_currentFontClass = fc;

    startCodeLine();

  }

}

/*! writes a word to the output.

 *  If curr_class is defined, the word belongs to a class

 *  and will be linked.

 */

static void writeWord(const char *word,const char* curr_class=0,bool classLink=FALSE)

{

  bool found=FALSE;

  QCString temp; 

  QCString tclass(curr_class);

  QCString ttt(word);

  if (ttt.isEmpty()) return;

  for (unsigned int j=0;j<ttt.length();j++)

  {

    char c=ttt.at(j);

    if (c==' '|| c==',' || c==';' || c==':' || c=='(' || c==')' || c=='\r' || c=='\t' || c=='.')

    {

      if (found)

      {

        if (!writeColoredWord(temp)) // is it a keyword ?

        {

          //if (VhdlDocGen::findKeyWord(temp))

          // writeFont("vhdlkeyword",temp.data());

	  //printf("writeWord: %s\n",temp.data());

          if (!tclass.isEmpty())

          {

            if (!classLink)

	    {

              generateMemLink(*g_code,tclass,temp);

	    }

            else

            {

              generateClassOrGlobalLink(*g_code,temp);

            }

          }

          else                                                                          

	  {

          if (!checkString(temp))

            g_code->codify(temp.data());

	  }

        }

        temp.resize(0);

        found=FALSE;

      }

      char cc[2];

      cc[0]=c;

      cc[1]=0;

      g_code->codify(cc);

    }

    else

    {

      found=TRUE;

      temp+=c;

    }

  } // for

  if (!temp.isEmpty())

  {

    if (!writeColoredWord(temp))

    {

      if (!tclass.isEmpty())

      {

        if (!classLink)

        {

          generateMemLink(*g_code,tclass,temp); // generateMemLink(*g_code,g_CurrClass,left); 

        }

        else

        {

          generateClassOrGlobalLink(*g_code,temp);

        }

      }

      else                 

      {

         QCString qc(temp.data());

         if (VhdlDocGen::isNumber(qc)){

                         startFontClass("vhdllogic");

                         g_code->codify(temp.data());

                         endFontClass();

                              }

         else     

        g_code->codify(temp.data());

      }

    }

  }

}// writeWord

/*! write a code fragment `text' that may span multiple lines, inserting

 * line numbers for each line.

 */

static void codifyLines(const char *text,const char *cl=0,bool classlink=FALSE)

{

  if (text==0) return;

  //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text);

  const char *p=text,*sp=p;

  char c;

  bool done=FALSE;

  while (!done)

  {

    sp=p;

    while ((c=*p++) && c!='\n') {}

    if (c=='\n')

    {

      g_yyLineNr++;

      QCString line = sp;

      line = line.left(p-sp-1);

      //*(p-1)='\0';

      //g_code->codify(sp);

      writeWord(line,cl,classlink);

      nextCodeLine();

    }

    else

    {

      //g_code->codify(sp);

      writeWord(sp,cl,classlink);

      done=TRUE;

    }

  }

}

/*! writes a link to a fragment \a text that may span multiple lines, inserting

 * line numbers for each line. If \a text contains newlines, the link will be 

 * split into multiple links with the same destination, one for each line.

 */

static void writeMultiLineCodeLink(CodeOutputInterface &ol,

                  const char *ref,const char *file,

                  const char *anchor,const char *text,

		  const char *tooltip)

{

  bool done=FALSE;

  char *p=(char *)text;

  while (!done)

  {

    char *sp=p;

    char c;

    while ((c=*p++) && c!='\n') {}

    if (c=='\n')

    {

      g_yyLineNr++;

      *(p-1)='\0';

      // printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);

      ol.writeCodeLink(ref,file,anchor,sp,tooltip);

      nextCodeLine();

    }

    else

    {

      ol.writeCodeLink(ref,file,anchor,sp,tooltip);

      done=TRUE;

    }

  }

}

static void setParameterList(MemberDef *md)

{

  g_classScope = md->getClassDef() ? md->getClassDef()->name().data() : "";

  LockingPtr<ArgumentList> al = md->argumentList();

  if (al==0) return; 

  Argument *a = al->first();

  while (a)

  {

    g_parmName = a->name.copy();

    g_parmType = a->type.copy();

    int i = g_parmType.find('*');

    if (i!=-1) g_parmType = g_parmType.left(i);

    i = g_parmType.find('&');

    if (i!=-1) g_parmType = g_parmType.left(i);

    g_parmType.stripPrefix("const ");

    g_parmType=g_parmType.stripWhiteSpace();

   // g_theVarContext.addVariable(g_parmType,g_parmName);

    a = al->next();

  }

}

/*! writes a link to a function or procedure

 */

static void generateFuncLink(CodeOutputInterface &ol,MemberDef* mdef)

{

  //printf("generateFuncLink(FuncName=%s)\n",mdef->name().data());

  QCString memberName=mdef->name();

  if (mdef && mdef->isLinkable()) // is it a linkable class

  {

    writeMultiLineCodeLink(ol,mdef->getReference(),

	                      mdef->getOutputFileBase(),

			      mdef->anchor(),

			      mdef->name(),

			      mdef->briefDescriptionAsTooltip());

    addToSearchIndex(memberName);

    return;

  }

  ol.linkableSymbol(g_yyLineNr,memberName,0,g_currentMemberDef?g_currentMemberDef:g_currentDefinition);

  codifyLines(memberName.data());

  addToSearchIndex(memberName);

} // generateFuncLink

static void generateMemLink(CodeOutputInterface &ol,QCString &clName,QCString& memberName)

{

  if (clName.isEmpty() || memberName.isEmpty()) return; 

  QCString className=clName;

  MemberDef *md=0;

  //MemberDef *comp=0;

  //bool isLocal=FALSE;

  md=VhdlDocGen::findMember(className,memberName);

  ClassDef *po=VhdlDocGen::getClass(className.data());

  if (md==0 && po && (VhdlDocGen::VhdlClasses)po->protection()==VhdlDocGen::PACKBODYCLASS) 

  {

    QCString temp=className;//.stripPrefix("_");

    temp.stripPrefix("_");

    md=VhdlDocGen::findMember(temp,memberName);

  }

  if (md && md->isLinkable()) // is it a linkable class

  {

    writeMultiLineCodeLink(ol,md->getReference(),

	                      md->getOutputFileBase(),

			      md->anchor(),

			      memberName,

			      md->briefDescriptionAsTooltip());

    addToSearchIndex(memberName);

    return;

  }

  // nothing found, just write out the word

  ol.linkableSymbol(g_yyLineNr,memberName,0,g_currentMemberDef?g_currentMemberDef:g_currentDefinition);

  codifyLines(memberName.data());

  addToSearchIndex(memberName);

}// generateMemLink

static void generateClassOrGlobalLink(CodeOutputInterface &ol,const char *clName, bool /*typeOnly*/)

{

  QCString className=clName;

  if (className.isEmpty()) return;

  ClassDef *cd=0;

  //MemberDef *md=0;

  //bool isLocal=FALSE;

  className.stripPrefix("_");

  cd = getClass(className.data()); 

  while (cd)

  {

    //className.stripPrefix("_");

    QCString temp(clName);

    temp.stripPrefix("_");

    if (cd && cd->isLinkable()) // is it a linkable class

    {

      //if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ARCHITECTURECLASS)

      //{

      //  temp=VhdlDocGen::getClassName(cd);

      //}

      ol.linkableSymbol(g_yyLineNr,temp,cd,

                        g_currentMemberDef ? 

			g_currentMemberDef : 

			g_currentDefinition);

      writeMultiLineCodeLink(ol,cd->getReference(),

	                        cd->getOutputFileBase(),

				0,

				temp,

				cd->briefDescriptionAsTooltip());

      addToSearchIndex(className);

      return;

    }

    Definition *d = cd->getOuterScope();

    if (d && d->definitionType()==Definition::TypeClass)

    {

      cd = (ClassDef*)d;

    }

    else

    {