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

 *

 *

 * 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

 * 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 "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::trVhdlType

static QDict<QCString> g_vhdlKeyDict0(17,FALSE); 

static QDict<QCString> g_vhdlKeyDict1(17,FALSE); 

static QDict<QCString> g_vhdlKeyDict2(17,FALSE);

static  QCString g_vhdlkeyword("vhdlkeyword");

static  QCString g_vhdltype("comment");

static  QCString g_vhdllogic("vhdllogic");

// keywords

static const char* g_vhdlKeyWordMap0[] = 

{ 

  "std","ieee","work","standard","textio","std_logic_1164",

  "std_logic_arith","std_logic_misc","std_logic_signed","std_logic_textio",

  "std_logic_unsigned","numeric_bit","numeric_std","math_complex","math_real",

  "vital_primitives","vital_timing","severity_level","time","delay_length",

  "natural", "positive", "bit_vector","file_open_kind","file_open_status",

  "line","text","side", "width","event","rising_edge", "falling_edge",

  "access","after","alias", "all","architecture","array", "assert","attribute",

  "begin","block","body", "buffer", "bus", "case", "component", "configuration", 

  "constant", "disconnect", "downto", "else", "elsif", "end", "entity", "exit",

  "file", "for", "function", "generate", "generic", "group", "guarded", "if", 

  "impure", "in", "inertial", "inout", "is","label", "library", "linkage", 

  "literal", "loop","map", "new", "next", "null", "of", "on", "open", "others", 

  "out", "package", "port", "postponed", "procedure", "process", "pure",

  "range", "record", "register", "reject", "report", "return","select", 

  "severity", "shared", "signal", "subtype", "then", "to", "transport", 

  "type","unaffected", "units", "until", "use","variable", "wait", "when", 

  "while", "with","true","false","protected",0

};

// type

static const char* g_vhdlKeyWordMap1[] = 

{ 

  "natural","unsigned","signed","string","boolean", "bit","character",

  "std_ulogic","std_ulogic_vector","sTd_logic","std_logic_vector","integer",

  "real","zzz",0

};

// logic

static const char* g_vhdlKeyWordMap2[] = 

{

  "abs","and","or","not","mod", "xor","rem","xnor","ror","rol","sla",

  "sll",0

};

VhdlDocGen::VhdlDocGen()

{

}

VhdlDocGen::~VhdlDocGen()

{

}

void VhdlDocGen::init()

{

  int j=0;

  g_vhdlKeyDict0.setAutoDelete(TRUE);

  g_vhdlKeyDict1.setAutoDelete(TRUE);

  g_vhdlKeyDict2.setAutoDelete(TRUE);

  j=0;

  while (g_vhdlKeyWordMap0[j])

  {

    g_vhdlKeyDict0.insert(g_vhdlKeyWordMap0[j],

	               new QCString(g_vhdlKeyWordMap0[j]));

    j++;

  }

  j=0;

  while (g_vhdlKeyWordMap1[j])

  {

    g_vhdlKeyDict1.insert(g_vhdlKeyWordMap1[j],

	               new QCString(g_vhdlKeyWordMap1[j]));

    j++;

  }

  j=0;

  while (g_vhdlKeyWordMap2[j])

  {

    g_vhdlKeyDict2.insert(g_vhdlKeyWordMap2[j],

	               new QCString(g_vhdlKeyWordMap2[j]));

    j++;

  }

}// buildKeyMap

/*!

 * returns the color of a keyword 

 */ 

QCString* VhdlDocGen::findKeyWord(const QCString& word)

{

  if (word.isEmpty() || word.at(0)=='\0') return 0;

  //printf("VhdlDocGen::findKeyWord(%s)\n",word.data());

  if (g_vhdlKeyDict0.find(word.lower()))

    return &g_vhdlkeyword;

  if (g_vhdlKeyDict1.find(word.lower()))

    return &g_vhdltype;

  if (g_vhdlKeyDict2.find(word.lower()))

    return &g_vhdllogic;

  return 0;

}

/*!

 * returns the parsed entry at line xxx

 */

void VhdlDocGen::debugClassName(ClassSDict* mDict)

{

  // for each class

  ClassSDict::Iterator cli(*mDict);

  ClassDef *cd;

  for ( ; (cd=cli.current()) ; ++cli )

  {

    printf("\n -------------------------class----------------------------------------\n");

    QCString nnn=cd->className();

    QCString qref=cd->getReference();

    QCString outBase=cd->getOutputFileBase();

    QCString fileBase=cd->getFileBase();

    QCString compType=cd->compoundTypeString();

    QCString inDoc=cd->documentation();//->inbodyDocumentation();

    printf("\n refernz [%p]",cd);

    printf("\n compType [%s]",compType.data());

    printf("\n Name [%s]",nnn.data());

    printf("\n TYPE[%d ",cd->definitionType());

    printf("\n Ref [%s] ",qref.data());

    printf("\n OutBase [%s] fileBase [%s]",outBase.data(),fileBase.data());

    printf("\n -------------------------------------------------------------------\n");

  }// for

}// Debug Class Name

bool found =FALSE;

static Entry eMerge;

ClassDef *VhdlDocGen::getClass(const char *name)

{

  if (name==0 || name[0]=='\0') return 0;

  ClassDef *cd=0;   

  QCString temp(name);

  //temp=temp.lower();

  temp=temp.stripWhiteSpace();

  cd= Doxygen::classSDict->find(temp.data());

  return cd;

}

/*!

 * adds architectures to their entity

 */

void VhdlDocGen::computeVhdlComponentRelations()

{

  ClassSDict::Iterator cli(*Doxygen::classSDict);

  for (cli.toFirst();cli.current();++cli)

  {

    cli.current()->visited=FALSE;

    ClassDef * cd = cli.current();

    {

      QCString bName=cd->name();

      int i=bName.find("::");

      if (i>0)

      {

        QCString entityName=bName.left(i);

        ClassDef *classEntity=Doxygen::classSDict->find(entityName);

        // entity for architecutre ?

        if (classEntity)

        {

          classEntity->insertBaseClass(cd,bName,Public,Normal,0);

          cd->insertSubClass(classEntity,Public,Normal,0);

        }

      }

    }

  }

} // computeVhdlComponentRelations

/*

 * returns a reference, if one class [package(body),entity or an architecture is found]

 */

ClassDef* VhdlDocGen::findComponent(int type)

{

  ClassSDict::Iterator cli(*Doxygen::classSDict);

  ClassDef *cd=0;

  for ( ; (cd=cli.current()) ; ++cli )

  {

    if (cd->protection()==type)

      return cd;

  }

  return cd;

}

ClassDef* VhdlDocGen::getPackageName(const QCString & name)

{

  ClassDef* cd=0;

  QStringList ql=QStringList::split(".",name,FALSE);

  cd=getClass(name);

  return cd;

}

MemberDef* VhdlDocGen::findMember(const QCString& className, const QCString& memName)

{

  QDict<QCString> packages(17,FALSE);   

  packages.setAutoDelete(TRUE);

  ClassDef* cd;

  MemberDef *mdef=0;

  cd=getClass(className);

  //printf("VhdlDocGen::findMember(%s,%s)=%p\n",className.data(),memName.data(),cd);

  if (cd==0) return 0;

  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::variableMembers);

  if (mdef) return mdef;

  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::pubMethods);

  if (mdef) return mdef;

  // nothing found so far 

  // if we are an architecture or package body search in entitiy

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

      (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)

  {

    Definition *d = cd->getOuterScope();

     // searching upper/lower case names

    QCString tt=d->name();   

    ClassDef *ecd =getClass(tt);

    if (!ecd)

    {

      tt=tt.upper();

      ecd =getClass(tt);

    }

    else if (!ecd)

    {

      tt=tt.lower();

      ecd =getClass(tt);  

    }

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

    {

      //ClassDef *ecd = (ClassDef*)d;

      mdef=VhdlDocGen::findMemberDef(ecd,memName,MemberList::variableMembers);

      if (mdef) return mdef;

       mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::pubMethods);

       if (mdef) return mdef;

    }

    //cd=getClass(getClassName(cd));

    //if (!cd) return 0;

  }

  // nothing found , so we are now searching all included packages 

  VhdlDocGen::findAllPackages(className,packages);

  //cd=getClass(className.data());

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

      (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)

  {

    Definition *d = cd->getOuterScope();

    QCString tt=d->name();

    ClassDef *ecd =getClass(tt);

    if (!ecd)

    {

      tt=tt.upper();

      ecd =getClass(tt);

    }

    if (!ecd)

    {

      tt=tt.lower();

      ecd =getClass(tt);  

    }

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

    {

      VhdlDocGen::findAllPackages(ecd->className(),packages); 

    }

  }

  QDictIterator<QCString> packli(packages);

  QCString *curString;

  for (packli.toFirst();(curString=packli.current());++packli)

  {

    if (curString)

    {

      cd=VhdlDocGen::getPackageName(*curString);

      if (!cd)

      {

        *curString=curString->upper();

        cd=VhdlDocGen::getPackageName(*curString);

      }

      if (!cd)

      {

        *curString=curString->lower();

        cd=VhdlDocGen::getPackageName(*curString);  

      }

    }

    if (cd)

    {    

      mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::variableMembers);

      if (mdef)  return mdef;

      mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::pubMethods);

      if (mdef) return mdef;

    }

  } // for

  return 0;

}//findMember

/**

 *  This function returns the entity|package

 *  in which the key (type) is found

 */

MemberDef* VhdlDocGen::findMemberDef(ClassDef* cd,const QCString& key,MemberList::ListType type)

{

  //    return cd->getMemberByName(key);//does not work 

  MemberDef *md=0;

  MemberList *ml=    cd->getMemberList(type);

  if (ml==0) return 0;

  MemberListIterator fmni(*ml);

  for (fmni.toFirst();(md=fmni.current());++fmni)

  {

    if (stricmp(key.data(),md->name().data())==0)

      return md;

  } 

  return 0;

}//findMemberDef

/*!

 * finds all included packages of an Entity or Package

 */

void VhdlDocGen::findAllPackages(const QCString& className,QDict<QCString>& qdict)

{

  ClassDef *cdef=getClass(className);

  if (cdef)

  {

    MemberList *mem=cdef->getMemberList(MemberList::variableMembers); 

    MemberDef *md;

    if (mem)

    {

      MemberListIterator fmni(*mem);

      for (fmni.toFirst();(md=fmni.current());++fmni)

      {

	if (VhdlDocGen::isPackage(md))

	{

	  QCString *temp1=new QCString(md->name().data());

	  //*temp1=temp1->lower();

	  QCString p(md->name().data());

	  //p=p.lower();

	  ClassDef* cd=VhdlDocGen::getPackageName(*temp1);

	  if (cd) 

	  { 

	    QCString *ss=qdict.find(*temp1);

	    if (ss==0)

	    {

	      qdict.insert(p,temp1);

	      QCString tmp=cd->className();

	      VhdlDocGen::findAllPackages(tmp,qdict);

	    }

	    else delete temp1;

	  }

	  else delete temp1;

	}

      }//for

    }//if

  }//cdef

}// findAllPackages

/*!

 * returns the function with the matching argument list

 * is called in vhdlcode.l

 */

MemberDef* VhdlDocGen::findFunction(const QList<Argument> &ql,

                                    const QCString& funcname,

				    const QCString& package, bool type)

{

  MemberDef* mdef=0;

  int funcType;

  ClassDef *cdef=getClass(package.data());

  if (cdef==0) return 0;

  if (type)

    funcType=VhdlDocGen::PROCEDURE;

  else

    funcType=VhdlDocGen::FUNCTION;

  MemberList *mem=cdef->getMemberList(MemberList::pubMethods); 

  if (mem)

  {

    MemberListIterator fmni(*mem);

    for (fmni.toFirst();(mdef=fmni.current());++fmni)

    {

      QCString mname=mdef->name();

      if ((VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isVhdlFunction(mdef)) && (VhdlDocGen::compareString(funcname,mname)==0))

      {

	LockingPtr<ArgumentList> alp = mdef->argumentList();

	//  ArgumentList* arg2=mdef->getArgumentList();

	if (alp==0) break;

	ArgumentListIterator ali(*alp.pointer());

	ArgumentListIterator ali1(ql);

	if (ali.count() != ali1.count()) break;

	Argument *arg,*arg1;

	int equ=0;

	for (;(arg=ali.current());++ali)

	{

	  arg1=ali1.current(); ++ali1;

	  equ+=abs(VhdlDocGen::compareString(arg->type,arg1->type));

	  QCString s1=arg->type;

	  QCString s2=arg1->type;

	  VhdlDocGen::deleteAllChars(s1,' ');

	  VhdlDocGen::deleteAllChars(s2,' ');

	  equ+=abs(VhdlDocGen::compareString(s1,s2));

	  s1=arg->attrib;

	  s2=arg1->attrib;

	  VhdlDocGen::deleteAllChars(s1,' ');

	  VhdlDocGen::deleteAllChars(s2,' ');

	  equ+=abs(VhdlDocGen::compareString(s1,s2));

	  // printf("\n 1. type [%s] name [%s] attrib [%s]",arg->type,arg->name,arg->attrib);

	  // printf("\n 2. type [%s] name [%s] attrib [%s]",arg1->type,arg1->name,arg1->attrib);

	} // for

	if (equ==0) return mdef;

      }//if

    }//for       

  }//if 

  return mdef;

} //findFunction

/*!

 * returns the function with the matching argument list

 * is called in vhdscan.l

 */

Entry* VhdlDocGen::findFunction( Entry* root, Entry* func)

{

  //bool found=FALSE;

  Entry *found=0;

  int functype=func->spec;

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

  Entry *rt;

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

  { 

    if (rt->spec==functype && VhdlDocGen::compareString(rt->name,func->name)==0 && rt!=func )

    {

      if (VhdlDocGen::compareArgList(func->argList,rt->argList))

      {

	found=rt;

	return found;

      }

    }//if1

    if (!found)  

    {

      found = VhdlDocGen::findFunction(rt,func);

    }

  } // for

  return found;