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

 *

 *

 * 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 VHDL subset

 * written by M. Kreis

 * supports VHDL-87/93

 * does not support VHDL-AMS 

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

%{

// global includes

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include <qcstring.h>

#include <qfileinfo.h>

#include <qstringlist.h>

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

// local includes

#include "vhdlscanner.h"

#include "vhdlcode.h"

#include "vhdldocgen.h"

#include "message.h"

#include "config.h"

#include "doxygen.h"

#include "util.h"

#include "language.h"

#include "commentscan.h"

#include "index.h"

#include "definition.h"

#include "searchindex.h"

#include "outputlist.h"

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

//#define theTranslator_vhdlType theTranslator->trVhdlType

#define theTranslator_vhdlType VhdlDocGen::getVhdlType

static QStringList      qrl;

static int              openGroups;

static ParserInterface *g_thisParser;

static const char *     inputString;

static int              inputPosition;

static int              startComment  = 0;

static QFile            inputFile;

static QCString         inbuf;

static Entry*           global_root   = 0;

static Entry*           current_root  = 0;

static Entry*           current       = 0;

static Entry*           previous      = 0;

static Entry*           functionEntry = 0;

static Entry*           lastEntity    = 0;

static Entry*           lastCompound  = 0;

static int              genPort       = 0;

static QCString         yyFileName;

static int              iFuncLine     = 1;

static bool             g_inputFromFile ;

static bool             g_lexInit     = FALSE;

static int              isBody=0;

static int              isFunc=0;

static int              yyLineNr      = 1;

static char *           g_buf         = 0;

static uint             g_bufSize     = 0;

static int              iTextCounter  = 0;

static int              iCounter      = 0;

static int              bropen        = 0;

static int              scantype      = 0;

static int              g_lastCommentContext = 0;

static bool             docBlockAutoBrief;

static char             docBlockTerm;

static int              iDocLine      = -1;

//#define YY_A_INTERACTIVE 1

#define YY_NEVER_INTERACTIVE 1

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

static void parserInit();

static void deleteSpecChars(char* str,char *buf);

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

static void newEntry();

static void initEntry(Entry *e);

static void addSubEntry(Entry* root, Entry* e)

{

  if (e==0 || root==0) return;

  //if (isPrevDoc) 

  //{

  //  e->brief=prevDocEntry.brief;

  //  e->briefLine=prevDocEntry.briefLine;

  //  prevDocEntry.reset();

  //  isPrevDoc=FALSE;

  //}

  root->addSubEntry(e);

} 

static void bufferClear()

{

  int j;

  for (j=0;j<iCounter+1;j++)

  {

    g_buf[j]=0;

  }

  iCounter=0;

}

static void  addText (char *word, int llen)

{

  if ((uint)(iCounter + llen) > g_bufSize)

  {

    char *pTmp = (char*)realloc(g_buf,iCounter+llen+2048);

    if (pTmp)

    {

      g_buf = pTmp;

    }

    else

    {

      fprintf(stderr,"\n not enough memory for realloc\n");

      return; 

    }

  }

  while (llen>0)

  {

    g_buf[iCounter]=*word++;

    iCounter++;

    llen--;

  }    

  g_buf[iCounter]='\0'; 

} 

static void getBufText(QCString& qc,int start)

{

  while (start < iCounter)

  {

    qc+=(g_buf[start]);

    start++;

  }

}

static void lineCount()

{

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

  {

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

  }

}

static void deleteSpecChars(char* str,char *buf)

{

  while (*str)

  {

    if ((*str == '\t') || (*str == '\n') || (*str == '\r') || (*str == ' ')) 

    {

      *str++;

    }

    else

    {

      *buf++ = *str++;

    }

  }

  *buf='\0';

}

void getType(Entry* p,char* text)

{

  QCString name(text);

  name=name.stripWhiteSpace();           

  if (stricmp(name.data(),"signal" )==0)

  {

    p->spec=VhdlDocGen::SIGNAL;

  }

  else if (stricmp(name.data(),"type" )==0)

  {

    p->spec=VhdlDocGen::TYPE; 

  }

  else if (stricmp(name.data(),"subtype" )==0)

  {

    p->spec=VhdlDocGen::SUBTYPE;   

  }

  else if (stricmp(name.data(),"constant" )==0)

  {

    p->spec=VhdlDocGen::CONSTANT;    

  }

  else if (stricmp(name.data(),"attribute" )==0)

  {

    p->spec=VhdlDocGen::ATTRIBUTE;

  }

  else if (stricmp(name.data(),"function" )==0)

  {

    p->spec=VhdlDocGen::FUNCTION;    

  }

  else if (stricmp(name.data(),"procedure" )==0)

  {

    p->spec=VhdlDocGen::PROCEDURE;

  }

  else if (stricmp(name.data(),"units" )==0)

  {

    p->spec=VhdlDocGen::UNITS;

  }

  else if (name.contains("shared",false) && name.contains("variable",false))

  {

    p->spec=VhdlDocGen::SHAREDVARIABLE;

  }

  else if (stricmp(name.data(),"file" )==0) 

  {

    p->spec=VhdlDocGen::VFILE;

  }

  else if (stricmp(name.data(),"group" )==0) 

  {

    p->spec=VhdlDocGen::GROUP; 

  }

  else if (stricmp(name.data(),"alias" )==0) 

  {

    p->spec=VhdlDocGen::ALIAS; 

  }

  else 

  {

    err("wrong type");

  }

  p->section=Entry::VARIABLE_SEC;

}

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

/*

 * adds signals found in entities|records|units

 */

void addSignals(const char* str,int line, Entry *e,const char *comment=0)

{

  //printf("===> addSignals (%s) comment='%s'\n",str,comment);

  QList<QCString> ql;

  QCString bufio;

  ql.setAutoDelete(TRUE);

  VhdlDocGen::getSigName(ql,str,bufio);

  int count = ql.count();

  QCString brief  = current->brief;

  QCString doc    = current->doc;

  Entry *tmpEntry = current;

  current = new Entry;

  initEntry(current);

  handleCommentBlock(comment,TRUE);

  if (!current->brief.isEmpty())

  {

    if (doc.isEmpty())

    {

      doc = brief;

    }

    else if (!brief.isEmpty())

    {

      doc = brief + "<p>" + doc;

    }

    brief = current->brief;

  }

  delete current;

  current = tmpEntry;

  current->brief.resize(0);

  current->doc.resize(0);

  if (genPort!=3) // not a unit

  {

    for (int k=1;k<count;k++)

    {

      //printf("adding '%s' '%s'\n",ql.at(0)->data(),ql.at(k)->data());

      Entry *pTemp=new Entry;

      initEntry(pTemp);

      pTemp->startLine = line;

      pTemp->bodyLine  = line;

      pTemp->name      = ql.at(k)->data();

      pTemp->section   = Entry::VARIABLE_SEC;

      pTemp->brief     = brief;

      pTemp->doc       = doc;

      pTemp->mGrpId    = current->mGrpId; // copy member group id

      QCString stSpec  = ql.at(0)->data();

      if (genPort==1) // found port

      {

	pTemp->spec    = VhdlDocGen::PORT;

	stSpec.stripPrefix(bufio.data()); 

	stSpec=stSpec.stripWhiteSpace();

	pTemp->args    = stSpec;

	pTemp->type    = bufio;

	addSubEntry(e,pTemp);

      }

      else if (genPort==2) // found record

      {

	pTemp->spec    = VhdlDocGen::RECORD;

	pTemp->type    = stSpec;

	pTemp->name.prepend(VhdlDocGen::getRecordNumber());

	delete current;

	current = new Entry(*pTemp); // make a deep copy of pTemp

	newEntry();                  // add it to lastCompound and make a new current

	delete pTemp;

      }

      else 

      {

	pTemp->spec    = VhdlDocGen::GENERIC;

	pTemp->type    = stSpec;

	addSubEntry(e,pTemp);

      }

    }// for

  }

  else // found a unit 

  {

    Entry *pTemp=new Entry;

    initEntry(pTemp);

    QCString tt(str);

    QStringList ql=QStringList::split("=",tt,FALSE);

    pTemp->spec      = VhdlDocGen::UNITS;

    pTemp->section   = Entry::VARIABLE_SEC;

    pTemp->startLine = line;

    pTemp->bodyLine  = line;

    pTemp->brief     = brief; // adds brief description to the unit member

    pTemp->doc       = doc;   // adds doc to the unit member

    pTemp->type      = ql[1];

    pTemp->name      = ql[0].stripWhiteSpace();

    pTemp->name.prepend(VhdlDocGen::getRecordNumber());

    delete current;

    current = new Entry(*pTemp); // make a deep copy

    newEntry();                  // add it to lastCompound

    delete pTemp;

  }

}                                              

/*

 * this function parses a process prototype

 * and adds the signal to the process

 */

static void parseProcessProto()

{

  QStringList ql;

  QCString qcs;

  bool sem=FALSE;

  //Entry* ppEntry=new Entry;

  //ppEntry->fileName=yyFileName;

  //processEntry=ppEntry;

  QCString name; 

  scantype=0;

  getBufText(qcs,0);

  if (qcs.contains('(') != qcs.contains(')')) return; 

  VhdlDocGen::deleteAllChars(qcs,'\n');

  VhdlDocGen::parseProcessProto(qcs,name,ql);

  current->section=Entry::FUNCTION_SEC;

  //current->stat=TRUE;

  current->spec=VhdlDocGen::PROCESS;

  current->startLine=iFuncLine;

  current->bodyLine=iFuncLine;

  current->fileName=yyFileName;

  if (!name.isEmpty())

  {

    current->name=name.stripWhiteSpace();

  }

  else // found an anonymous process, so we add a generated name  

  {

    current->name=VhdlDocGen::getProcessNumber(); 

  }

  current->args+=" ( "; 

  if (!ql.isEmpty())

  {

    QValueList<QString>::Iterator iter = ql.begin();

    for ( ; iter != ql.end(); ++iter)

    {

      if (sem)

      {

        current->args+=',';

      }

      Argument *arg=new Argument;

      arg->name=((QCString)*iter).stripWhiteSpace();    

      current->argList->append(arg);

      current->args+=(QCString)*iter; 

      sem = TRUE;

    }    

  }

  current->args+=" ) ";

  bufferClear();

}//parseProcessProto

/*

 * parses a function|procedure protoype

 */

static void parseFunctionProto()

{

  QCString name,ret,qcs,temp;

  bool sem=FALSE;

  QList<Argument> ql;

  ql.setAutoDelete(TRUE);

  getBufText(qcs,0);

  if (qcs.contains('(') != qcs.contains(')')) 

    return; // function without a prototype 

  if (qcs.contains("function",FALSE)==0 && qcs.contains("procedure",FALSE)==0) 

    return; 

  qcs=qcs.stripWhiteSpace();

  temp=qcs.lower();

  if (temp.stripPrefix("impure"))

  {

    current->exception="impure";

    qcs=qcs.remove(0,6);

  }

  else if (temp.stripPrefix("pure")) 

  {

    current->exception="pure";

    qcs=qcs.remove(0,4);

  }

  VhdlDocGen::parseFuncProto(qcs.data(),ql,name,ret); 

  //printf("parseFuncProto(%s)=%s,%s\n",qcs.data(),name.data(),ret.data());

  VhdlDocGen::deleteAllChars(name,';');

  current->name=name;

  current->startLine=iFuncLine;

  current->bodyLine=iFuncLine;

  int count = ql.count(); 

  current->args+" ( "; 

  for (int k=0;k<count;k++)

  {

    if (sem)

    {

      current->args+=",";

    }

    Argument *arg=new Argument;

    Argument *hh=(Argument*)ql.at(k);

    arg->name=hh->name;

    arg->type=hh->type;

    arg->defval=hh->defval;

    arg->attrib=hh->attrib;

    current->argList->append(arg);

    current->args+=hh->name;

    sem=TRUE;

  }

  current->args+" )";

  if (!ret.isEmpty()) 

    current->spec=VhdlDocGen::FUNCTION;

  else

    current->spec=VhdlDocGen::PROCEDURE;

  current->section=Entry::FUNCTION_SEC;

  current->type=ret;

  //addSubEntry(ee,ppEntry); 

  if (lastCompound)

  {

    lastCompound->addSubEntry(current);

    current = new Entry;

    initEntry(current);

  }

  else

  {

    newEntry();

  }

  bufferClear();

}//parseFunctionProto

static Entry* getEntryAtLine(const Entry* ce,int line)

{

  EntryListIterator eli(*ce->children());

  Entry *found=0;

  Entry *rt;

  for (;(rt=eli.current());++eli)

  {

    if (rt->bodyLine==line)

    {

      found=rt;

    } // if

    if (!found) 

    {

      found=getEntryAtLine(rt,line);

    }

  }

  return found;

}// getEntryAtLine

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

void parserInit()

{

  iCounter=0; 

  iTextCounter=0;

  yyLineNr=1;

  current=0;

  previous=0;

  isFunc=0;

  isBody=0;

  scantype=0;

  //pEntry=0;

  //pp=0; 

  lastCompound=0;

  lastEntity=0;

  bropen=0;

  openGroups=0;

  iDocLine=-1;

  //isPrevDoc=FALSE;

  //prevDocEntry.reset();

  qrl.clear();

  if (!g_lexInit) 

  {

    VhdlDocGen::init();

  }

  g_bufSize=inputFile.size()+1024;

  if (g_buf==0) free(g_buf);

  g_buf=(char*)(calloc(g_bufSize,sizeof(char)));

  if (g_buf==0)

  {

    fprintf(stderr,"\n not enough memory");