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

 *

 * 

 *

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

 *

 */

#include "qtbc.h"

#include <ctype.h>

#include <qregexp.h>

#include <md5.h>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include "config.h"

#include "definition.h"

#include "doxygen.h"

#include "language.h"

#include "message.h"

#include "outputlist.h"

#include "code.h"

#include "util.h"

#include "groupdef.h"

#include "pagedef.h"

#include "section.h"

#include "htags.h"

#include "parserintf.h"

#include "marshal.h"

#include "debug.h"

#define START_MARKER 0x4445465B // DEF[

#define END_MARKER   0x4445465D // DEF]

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

class DefinitionImpl

{

  public:

    DefinitionImpl();

   ~DefinitionImpl();

    void init(const char *df,int dl,

         const char *n);

    SectionDict *sectionDict;  // dictionary of all sections, not accessible

    MemberSDict *sourceRefByDict;       

    MemberSDict *sourceRefsDict;        

    QList<ListItemInfo> *xrefListItems; 

    GroupList *partOfGroups;            

    DocInfo   *details;    // not exported

    DocInfo   *inbodyDocs; // not exported

    BriefInfo *brief;      // not exported

    BodyInfo  *body;       // not exported

    QCString   docSignatures;

    QCString localName;      // local (unqualified) name of the definition

                             // in the future m_name should become m_localName

    QCString qualifiedName;

    QCString ref;   // reference to external documentation

    bool hidden;

    bool isArtificial;

    Definition *outerScope;  // not owner

    // where the item was found

    QCString defFileName;

    int      defLine;

    QCString defFileExt;

};

DefinitionImpl::DefinitionImpl() 

  : sectionDict(0), sourceRefByDict(0), sourceRefsDict(0), 

    xrefListItems(0), partOfGroups(0),

    details(0), inbodyDocs(0), brief(0), body(0), 

    outerScope(0)

{

}

DefinitionImpl::~DefinitionImpl()

{

  delete sectionDict;

  delete sourceRefByDict;

  delete sourceRefsDict;

  delete partOfGroups;

  delete xrefListItems;

  delete brief;

  delete details;

  delete body;

  delete inbodyDocs;

}

void DefinitionImpl::init(const char *df,int dl,

                          const char *n)

{

  defFileName = df;

  int lastDot = defFileName.findRev('.');

  if (lastDot!=-1)

  {

    defFileExt = defFileName.mid(lastDot);

  }

  defLine = dl;

  QCString name = n;

  if (name!="<globalScope>") 

  {

    //extractNamespaceName(m_name,m_localName,ns);

    localName=stripScope(n);

  }

  else

  {

    localName=n;

  }

  //printf("m_localName=%s\n",m_localName.data());

  brief           = 0;

  details         = 0;

  body            = 0;

  inbodyDocs      = 0;

  sourceRefByDict = 0;

  sourceRefsDict  = 0;

  sectionDict     = 0, 

  outerScope      = Doxygen::globalScope;

  partOfGroups    = 0;

  xrefListItems   = 0;

  hidden          = FALSE;

  isArtificial    = FALSE;

}

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

static bool matchExcludedSymbols(const char *name)

{

  static QStrList &exclSyms = Config_getList("EXCLUDE_SYMBOLS");

  if (exclSyms.count()==0) return FALSE; // nothing specified

  const char *pat = exclSyms.first();

  QCString symName = name;

  while (pat)

  {

    QCString pattern = pat;

    bool forceStart=FALSE;

    bool forceEnd=FALSE;

    if (pattern.at(0)=='^') 

      pattern=pattern.mid(1),forceStart=TRUE;

    if (pattern.at(pattern.length()-1)=='$') 

      pattern=pattern.left(pattern.length()-1),forceEnd=TRUE;

    if (pattern.find('*')!=-1) // wildcard mode

    {

      QRegExp re(substitute(pattern,"*",".*"),TRUE);

      int i,pl;

      i = re.match(symName,0,&pl);

      //printf("  %d = re.match(%s) pattern=%s\n",i,symName.data(),pattern.data());

      if (i!=-1) // wildcard match

      {

        int sl=symName.length();

        // check if it is a whole word match

        if ((i==0     || pattern.at(0)=='*'    || (!isId(symName.at(i-1))  && !forceStart)) &&

            (i+pl==sl || pattern.at(i+pl)=='*' || (!isId(symName.at(i+pl)) && !forceEnd))

           )

        {

          //printf("--> name=%s pattern=%s match at %d\n",symName.data(),pattern.data(),i);

          return TRUE;

        }

      }

    }

    else if (!pattern.isEmpty()) // match words

    {

      int i = symName.find(pattern);

      if (i!=-1) // we have a match!

      {

        int pl=pattern.length();

        int sl=symName.length();

        // check if it is a whole word match

        if ((i==0     || (!isId(symName.at(i-1))  && !forceStart)) &&

            (i+pl==sl || (!isId(symName.at(i+pl)) && !forceEnd))

           )

        {

          //printf("--> name=%s pattern=%s match at %d\n",symName.data(),pattern.data(),i);

          return TRUE; 

        }

      }

    }

    pat = exclSyms.next();

  }

  //printf("--> name=%s: no match\n",name);

  return FALSE;

}

void Definition::addToMap(const char *name,Definition *d)

{

  bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");

  QCString symbolName = name;

  int index=computeQualifiedIndex(symbolName);

  if (!vhdlOpt && index!=-1) symbolName=symbolName.mid(index+2);

  if (!symbolName.isEmpty()) 

  {

    //printf("******* adding symbol `%s' (%p)\n",symbolName.data(),d);

    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);

    //printf("  addToMap(%p): looking for symbol %s: %p\n",d,symbolName.data(),di);

    if (di==0) // new Symbol

    {

      //printf("  new symbol!\n");

      Doxygen::symbolMap->insert(symbolName,d);

    }

    else // existing symbol

    {

      //printf("  existing symbol: ");

      if (di->definitionType()==DefinitionIntf::TypeSymbolList) // already multiple symbols

      {

        //printf("adding to exiting list\n");

        DefinitionList *dl = (DefinitionList*)di;

        dl->append(d);

      }

      else // going from one to two symbols

      {

        Doxygen::symbolMap->take(symbolName);

        DefinitionList *dl = new DefinitionList;

        //printf("replacing symbol by list %p with elements %p and %p\n",dl,di,d);

        dl->append((Definition*)di);

        dl->append(d);

        Doxygen::symbolMap->insert(symbolName,dl);

      }

    }

    // auto resize if needed

    static int sizeIndex=9;

    if (Doxygen::symbolMap->size()>SDict_primes[sizeIndex])

    {

      Doxygen::symbolMap->resize(SDict_primes[++sizeIndex]);

    }

    d->_setSymbolName(symbolName);

  }

}

void Definition::removeFromMap(Definition *d)

{

  QCString symbolName = d->symbolName();

  int index=computeQualifiedIndex(symbolName);

  if (index!=-1) symbolName=symbolName.mid(index+2);

  if (!symbolName.isEmpty()) 

  {

    //printf("******* removing symbol `%s' (%p)\n",symbolName.data(),d);

    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);

    if (di)

    {

      ASSERT(di!=0);

      if (di!=d) // symbolName not unique

      {

        //printf("  removing from list: %p!\n",di);

        DefinitionList *dl = (DefinitionList*)di;

        bool b = dl->removeRef(d);

        ASSERT(b==TRUE);

        if (dl->isEmpty())

        {

          Doxygen::symbolMap->take(symbolName);

        }

      }

      else // symbolName unique

      {

        //printf("  removing symbol %p\n",di);

        Doxygen::symbolMap->take(symbolName);

      }

    }

  }

}

Definition::Definition(const char *df,int dl,

                       const char *name,const char *b,

                       const char *d,bool isSymbol)

{

  m_name = name;

  m_impl = new DefinitionImpl;

  m_impl->init(df,dl,name);

  m_isSymbol = isSymbol;

  if (isSymbol) addToMap(name,this);

  _setBriefDescription(b,df,dl);

  _setDocumentation(d,df,dl,TRUE,FALSE);

  if (matchExcludedSymbols(name)) 

  {

    m_impl->hidden = TRUE;

  }

}

Definition::~Definition()

{

  if (m_isSymbol) 

  {

    removeFromMap(this);

  }

  if (m_impl)

  {

    delete m_impl;

    m_impl=0;

  }

}

void Definition::setName(const char *name)

{

  if (name==0) return;

  m_name = name;

}

void Definition::addSectionsToDefinition(QList<SectionInfo> *anchorList)

{

  if (!anchorList) return;

  makeResident();

  //printf("%s: addSectionsToDefinition(%d)\n",name().data(),anchorList->count());

  SectionInfo *si=anchorList->first();

  while (si)

  {

    //printf("Add section `%s' to definition `%s'\n",

    //    si->label.data(),name().data());

    SectionInfo *gsi=Doxygen::sectionDict.find(si->label);

    if (gsi==0)

    {

      gsi = new SectionInfo(*si);

      Doxygen::sectionDict.insert(si->label,gsi);

    }

    if (m_impl->sectionDict==0) 

    {

      m_impl->sectionDict = new SectionDict(17);

    }

    if (m_impl->sectionDict->find(gsi->label)==0)

    {

      m_impl->sectionDict->insert(gsi->label,gsi);

      gsi->definition = this;

    }

    si=anchorList->next();

  }

}

void Definition::writeDocAnchorsToTagFile()

{

  makeResident();

  if (!Config_getString("GENERATE_TAGFILE").isEmpty() && m_impl->sectionDict)

  {

    //printf("%s: writeDocAnchorsToTagFile(%d)\n",name().data(),m_sectionDict->count());

    QDictIterator<SectionInfo> sdi(*m_impl->sectionDict);

    SectionInfo *si;

    for (;(si=sdi.current());++sdi)

    {

      if (!si->generated)

      {

        //printf("write an entry!\n");

        if (definitionType()==TypeMember) Doxygen::tagFile << "  ";

        Doxygen::tagFile << "    <docanchor file=\"" 

                         << si->fileName << "\">" << si->label 

                         << "</docanchor>" << endl;

      }

    }

  }

}

bool Definition::_docsAlreadyAdded(const QCString &doc)

{

  uchar md5_sig[16];

  QCString sigStr(33);

  // to avoid mismatches due to differences in indenting, we first remove

  // double whitespaces...

  QCString docStr = doc.simplifyWhiteSpace();

  MD5Buffer((const unsigned char *)docStr.data(),docStr.length(),md5_sig);

  MD5SigToString(md5_sig,sigStr.data(),33);

  if (m_impl->docSignatures.find(sigStr)==-1) // new docs, add signature to prevent re-adding it

  {

    m_impl->docSignatures+=":"+sigStr;

    return FALSE;

  }

  else

  {

    return TRUE;

  }

}

void Definition::_setDocumentation(const char *d,const char *docFile,int docLine,

                                   bool stripWhiteSpace,bool atTop)

{

  if (d==0) return;

  //printf("Definition::setDocumentation(%s,%s,%d,%d)\n",d,docFile,docLine,stripWhiteSpace);

  QCString doc = d;

  if (stripWhiteSpace)

  {

    doc = stripLeadingAndTrailingEmptyLines(doc);

  }

  else // don't strip whitespace

  {

    doc=d;

  }

  if (!_docsAlreadyAdded(doc))

  {

    //printf("setting docs for %s: `%s'\n",name().data(),m_doc.data());

    if (m_impl->details==0)

    {

      m_impl->details = new DocInfo;

    }

    if (m_impl->details->doc.isEmpty()) // fresh detailed description

    {

      m_impl->details->doc = doc;

    }

    else if (atTop) // another detailed description, append it to the start

    {

      m_impl->details->doc = doc+"\n\n"+m_impl->details->doc;

    }

    else // another detailed description, append it to the end

    {

      m_impl->details->doc += "\n\n"+doc;

    }

    if (docLine!=-1) // store location if valid

    {

      m_impl->details->file = docFile;

      m_impl->details->line = docLine;

    }

    else

    {

      m_impl->details->file = docFile;

      m_impl->details->line = 1;

    }

  }

}

void Definition::setDocumentation(const char *d,const char *docFile,int docLine,bool stripWhiteSpace)

{

  if (d==0) return;

  makeResident();

  _setDocumentation(d,docFile,docLine,stripWhiteSpace,FALSE);

}

#define uni_isupper(c) (QChar(c).category()==QChar::Letter_Uppercase)

void Definition::_setBriefDescription(const char *b,const char *briefFile,int briefLine)

{

  static QCString outputLanguage = Config_getEnum("OUTPUT_LANGUAGE");

  static bool needsDot = outputLanguage!="Japanese" && 

                         outputLanguage!="Chinese" &&

                         outputLanguage!="Korean";

  QCString brief = b;

  brief = brief.stripWhiteSpace();

  if (brief.isEmpty()) return;

  int bl = brief.length();

  if (bl>0 && needsDot) // add punctuation if needed

  {

    switch(brief.at(bl-1))

    {

      case '.': case '!': case '?': break;

      default: 

        if (uni_isupper(brief.at(0))) brief+='.'; 

        break;

    }

  }

  if (m_impl->brief && !m_impl->brief->doc.isEmpty())

  {

      //printf("adding to details\n");

      _setDocumentation(brief,briefFile,briefLine,FALSE,TRUE);

  }

  else if (!_docsAlreadyAdded(brief))

  {

    //fprintf(stderr,"Definition::setBriefDescription(%s,%s,%d)\n",b,briefFile,briefLine);

    if (m_impl->brief==0)

    {

      m_impl->brief = new BriefInfo;

    }

    m_impl->brief->doc=brief;

    if (briefLine!=-1)

    {

      m_impl->brief->file = briefFile;

      m_impl->brief->line = briefLine;

    }

  }

}

void Definition::setBriefDescription(const char *b,const char *briefFile,int briefLine) 

{ 

  if (b==0) return;

  makeResident();

  _setBriefDescription(b,briefFile,briefLine);

}

void Definition::_setInbodyDocumentation(const char *doc,const char *inbodyFile,int inbodyLine)

{

  if (m_impl->inbodyDocs==0)

  {

    m_impl->inbodyDocs = new DocInfo;

  }

  if (m_impl->inbodyDocs->doc.isEmpty()) // fresh inbody docs

  {

    m_impl->inbodyDocs->doc  = doc;

    m_impl->inbodyDocs->file = inbodyFile;

    m_impl->inbodyDocs->line = inbodyLine;

  }

  else // another inbody documentation fragment, append this to the end

  {

    m_impl->inbodyDocs->doc += QCString("\n\n")+doc;

  }

}

void Definition::setInbodyDocumentation(const char *d,const char *inbodyFile,int inbodyLine)

{

  if (d==0) return;

  makeResident();

  _setInbodyDocumentation(d,inbodyFile,inbodyLine);

}

/*! Reads a fragment of code from file \a fileName starting at 

 * line \a startLine and ending at line \a endLine (inclusive). The fragment is

 * stored in \a result. If FALSE is returned the code fragment could not be

 * found.

 *

 * The file is scanned for a opening bracket ('{') from \a startLine onward

 * The line actually containing the bracket is returned via startLine.

 * The file is scanned for a closing bracket ('}') from \a endLine backward.

 * The line actually containing the bracket is returned via endLine.

 * Note that for VHDL code the bracket search is not done.

 */

static bool readCodeFragment(const char *fileName,

                      int &startLine,int &endLine,QCString &result)

{

  static bool vhdlOpt           = Config_getBool("OPTIMIZE_OUTPUT_VHDL");