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

 *

 * 

 *

 *

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

#include <ctype.h>

#include <errno.h>

#include <md5.h>

#include "qtbc.h"

#include <qregexp.h>

#include <qfileinfo.h>

#include <qdir.h>

#include <qdatetime.h>

#include <qcache.h>

#include "util.h"

#include "message.h"

#include "classdef.h"

#include "filedef.h"

#include "doxygen.h"

#include "outputlist.h"

#include "defargs.h"

#include "language.h"

#include "config.h"

#include "htmlhelp.h"

#include "example.h"

#include "version.h"

#include "groupdef.h"

#include "reflist.h"

#include "pagedef.h"

#include "debug.h"

#include "searchindex.h"

#include "doxygen.h"

#include "textdocvisitor.h"

#include "portable.h"

#include "parserintf.h"

#include "bufstr.h"

#define ENABLE_TRACINGSUPPORT 0

#if defined(_OS_MAC_) && ENABLE_TRACINGSUPPORT

#define TRACINGSUPPORT

#endif

#ifdef TRACINGSUPPORT

#include <execinfo.h>

#include <unistd.h>

#endif

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

// selects one of the name to sub-dir mapping algorithms that is used

// to select a sub directory when CREATE_SUBDIRS is set to YES.

#define ALGO_COUNT 1

#define ALGO_CRC16 2

#define ALGO_MD5   3

//#define MAP_ALGO ALGO_COUNT

//#define MAP_ALGO ALGO_CRC16

#define MAP_ALGO ALGO_MD5

#define REL_PATH_TO_ROOT "../../"

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

// TextGeneratorOLImpl implementation

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

TextGeneratorOLImpl::TextGeneratorOLImpl(OutputDocInterface &od) : m_od(od) 

{

}

void TextGeneratorOLImpl::writeString(const char *s,bool keepSpaces) const

{ 

  if (keepSpaces)

  {

    const char *p=s;

    if (p)

    {

      char cs[2];

      char c;

      cs[1]='\0';

      while ((c=*p++))

      {

        if (c==' ') m_od.writeNonBreakableSpace(1); 

        else cs[0]=c,m_od.docify(cs);

      }

    }

  }

  else

  {

    m_od.docify(s); 

  }

}

void TextGeneratorOLImpl::writeBreak() const

{ 

  m_od.pushGeneratorState();

  m_od.disableAllBut(OutputGenerator::Html);

  m_od.lineBreak("typebreak");

  m_od.popGeneratorState();

}

void TextGeneratorOLImpl::writeLink(const char *extRef,const char *file,

                                    const char *anchor,const char *text

                                   ) const

{

  m_od.writeObjectLink(extRef,file,anchor,text);

}

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

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

// an inheritance tree of depth of 100000 should be enough for everyone :-)

const int maxInheritanceDepth = 100000; 

/*! 

  Removes all anoymous scopes from string s

  Possible examples:

\verbatim

   "bla::@10::blep"      => "bla::blep"

   "bla::@10::@11::blep" => "bla::blep"

   "@10::blep"           => "blep"

   " @10::blep"          => "blep"

   "@9::@10::blep"       => "blep"

   "bla::@1"             => "bla"

   "bla::@1::@2"         => "bla"

   "bla @1"              => "bla"

\endverbatim

 */

QCString removeAnonymousScopes(const QCString &s)

{

  QCString result;

  if (s.isEmpty()) return result;

  static QRegExp re("[ :]*@[0-9]+[: ]*");

  int i,l,sl=s.length();

  int p=0;

  while ((i=re.match(s,p,&l))!=-1)

  {

    result+=s.mid(p,i-p);

    int c=i;

    bool b1=FALSE,b2=FALSE;

    while (c<i+l && s.at(c)!='@') if (s.at(c++)==':') b1=TRUE;

    c=i+l-1;

    while (c>=i && s.at(c)!='@') if (s.at(c--)==':') b2=TRUE;

    if (b1 && b2) 

    { 

      result+="::"; 

    }

    p=i+l;

  }

  result+=s.right(sl-p);

  //printf("removeAnonymousScopes(`%s')=`%s'\n",s.data(),result.data());

  return result;

}

// replace anonymous scopes with __anonymous__ or replacement if provided

QCString replaceAnonymousScopes(const QCString &s,const char *replacement)

{

  QCString result;

  if (s.isEmpty()) return result;

  static QRegExp re("@[0-9]+");

  int i,l,sl=s.length();

  int p=0;

  while ((i=re.match(s,p,&l))!=-1)

  {

    result+=s.mid(p,i-p);

    if (replacement)

    {

      result+=replacement;

    }

    else

    {

      result+="__anonymous__";

    }

    p=i+l;

  }

  result+=s.right(sl-p);

  //printf("replaceAnonymousScopes(`%s')=`%s'\n",s.data(),result.data());

  return result;

}

// strip annonymous left hand side part of the scope

QCString stripAnonymousNamespaceScope(const QCString &s)

{

  int i,p=0,l;

  QCString newScope;

  while ((i=getScopeFragment(s,p,&l))!=-1)

  {

    //printf("Scope fragment %s\n",s.mid(i,l).data());

    if (Doxygen::namespaceSDict->find(s.left(i+l))!=0)

    {

      if (s.at(i)!='@')

      {

        if (!newScope.isEmpty()) newScope+="::";

        newScope+=s.mid(i,l);

      }

    }

    else

    {

      if (!newScope.isEmpty()) newScope+="::";

      newScope+=s.right(s.length()-i);

      goto done;

    }

    p=i+l;

  }

done:

  //printf("stripAnonymousNamespaceScope(`%s')=`%s'\n",s.data(),newScope.data());

  return newScope;

}

void writePageRef(OutputDocInterface &od,const char *cn,const char *mn)

{

  od.pushGeneratorState();

  od.disable(OutputGenerator::Html);

  od.disable(OutputGenerator::Man);

  if (Config_getBool("PDF_HYPERLINKS")) od.disable(OutputGenerator::Latex);

  if (Config_getBool("RTF_HYPERLINKS")) od.disable(OutputGenerator::RTF);

  od.startPageRef();

  od.docify(theTranslator->trPageAbbreviation());

  od.endPageRef(cn,mn);

  od.popGeneratorState();

}

/*! Generate a place holder for a position in a list. Used for

 *  translators to be able to specify different elements orders

 *  depending on whether text flows from left to right or visa versa.

 */

QCString generateMarker(int id)

{

  QCString result;

  result.sprintf("@%d",id);

  return result;

}

static QCString stripFromPath(const QCString &path,QStrList &l)

{

  // look at all the strings in the list and strip the longest match  

  const char *s=l.first();

  QCString potential;

  unsigned int length = 0;

  while (s)

  {

    QCString prefix = s;

    if (prefix.length() > length &&

        stricmp(path.left(prefix.length()),prefix)==0) // case insensitive compare

    {

      length = prefix.length();

      potential = path.right(path.length()-prefix.length());

    }

    s = l.next();

  }

  if (length) return potential;

  return path;

}

/*! strip part of \a path if it matches

 *  one of the paths in the Config_getList("STRIP_FROM_PATH") list

 */

QCString stripFromPath(const QCString &path)

{

  return stripFromPath(path,Config_getList("STRIP_FROM_PATH"));

}

/*! strip part of \a path if it matches

 *  one of the paths in the Config_getList("INCLUDE_PATH") list

 */

QCString stripFromIncludePath(const QCString &path)

{

  return stripFromPath(path,Config_getList("STRIP_FROM_INC_PATH"));

}

/*! try to determine if \a name is a source or a header file name by looking

 * at the extension. A number of variations is allowed in both upper and 

 * lower case) If anyone knows or uses another extension please let me know :-)

 */

int guessSection(const char *name)

{

  QCString n=((QCString)name).lower();

  if (n.right(2)==".c"    || // source

      n.right(3)==".cc"   ||

      n.right(4)==".cxx"  ||

      n.right(4)==".cpp"  ||

      n.right(4)==".c++"  ||

      n.right(5)==".java" ||

      n.right(3)==".ii"   || // inline

      n.right(4)==".ixx"  ||

      n.right(4)==".ipp"  ||

      n.right(4)==".i++"  ||

      n.right(4)==".inl"  ||

      n.right(4)==".xml"

     ) return Entry::SOURCE_SEC;

  if (n.right(2)==".h"   || // header

      n.right(3)==".hh"  ||

      n.right(4)==".hxx" ||

      n.right(4)==".hpp" ||

      n.right(4)==".h++" ||

      n.right(4)==".idl" ||

      n.right(4)==".ddl" ||

      n.right(5)==".pidl"

     ) return Entry::HEADER_SEC;

  return 0;

}

QCString resolveTypeDef(Definition *context,const QCString &qualifiedName,

                        Definition **typedefContext)

{

  //printf("<<resolveTypeDef(%s,%s)\n",

  //          context ? context->name().data() : "<none>",qualifiedName.data());

  QCString result;

  if (qualifiedName.isEmpty()) 

  {

    //printf("  qualified name empty!\n");

    return result;

  }

  Definition *mContext=context;

  if (typedefContext) *typedefContext=context;

  // see if the qualified name has a scope part

  int scopeIndex = qualifiedName.findRev("::");

  QCString resName=qualifiedName;

  if (scopeIndex!=-1) // strip scope part for the name

  {

    resName=qualifiedName.right(qualifiedName.length()-scopeIndex-2);

    if (resName.isEmpty())

    {

      // qualifiedName was of form A:: !

      //printf("  qualified name of form A::!\n");

      return result;

    }

  }

  MemberDef *md=0;

  while (mContext && md==0)

  {

    // step 1: get the right scope

    Definition *resScope=mContext;

    if (scopeIndex!=-1) 

    {

      // split-off scope part

      QCString resScopeName = qualifiedName.left(scopeIndex);

      //printf("resScopeName=`%s'\n",resScopeName.data());

      // look-up scope in context

      int is,ps=0;

      int l;

      while ((is=getScopeFragment(resScopeName,ps,&l))!=-1)

      {

        QCString qualScopePart = resScopeName.mid(is,l);

        QCString tmp = resolveTypeDef(mContext,qualScopePart);

        if (!tmp.isEmpty()) qualScopePart=tmp;

        resScope = resScope->findInnerCompound(qualScopePart);

        //printf("qualScopePart=`%s' resScope=%p\n",qualScopePart.data(),resScope);

        if (resScope==0) break;

        ps=is+l;

      }

    }

    //printf("resScope=%s\n",resScope?resScope->name().data():"<none>");

    // step 2: get the member

    if (resScope) // no scope or scope found in the current context 

    {

      //printf("scope found: %s, look for typedef %s\n",

      //     resScope->qualifiedName().data(),resName.data());

      MemberNameSDict *mnd=0;

      if (resScope->definitionType()==Definition::TypeClass)

      {

        mnd=Doxygen::memberNameSDict;

      }

      else

      {

        mnd=Doxygen::functionNameSDict;

      }

      MemberName *mn=mnd->find(resName);

      if (mn)

      {

        MemberNameIterator mni(*mn);

        MemberDef *tmd=0;

        int minDist=-1;

        for (;(tmd=mni.current());++mni)

        {

          //printf("Found member %s resScope=%s outerScope=%s mContext=%p\n",

          //    tmd->name().data(), resScope->name().data(), 

          //    tmd->getOuterScope()->name().data(), mContext);

          if (tmd->isTypedef() /*&& tmd->getOuterScope()==resScope*/)

          {

            int dist=isAccessibleFrom(resScope,0,tmd);

            if (dist!=-1 && (md==0 || dist<minDist))

            {

              md = tmd;

              minDist = dist;

            }

          }

        }

      }

    }

    mContext=mContext->getOuterScope();

  }

  // step 3: get the member's type

  if (md)

  {

    //printf(">>resolveTypeDef: Found typedef name `%s' in scope `%s' value=`%s'\n",

    //    qualifiedName.data(),context->name().data(),md->typeString()

    //    );

    result=md->typeString();

    if (result.find("*)")!=-1) // typedef of a function/member pointer

    {

      result+=md->argsString();

    }

    if (typedefContext) *typedefContext=md->getOuterScope();

  }

  else

  {

    //printf(">>resolveTypeDef: Typedef `%s' not found in scope `%s'!\n",

    //    qualifiedName.data(),context ? context->name().data() : "<global>");

  }

  return result;

}

/*! Get a class definition given its name. 

 *  Returns 0 if the class is not found.

 */

ClassDef *getClass(const char *name)

{

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

  return Doxygen::classSDict->find(name);

}

NamespaceDef *getResolvedNamespace(const char *name)

{

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

  QCString *subst = Doxygen::namespaceAliasDict[name];

  if (subst)

  {

    int count=0; // recursion detection guard

    QCString *newSubst;

    while ((newSubst=Doxygen::namespaceAliasDict[*subst]) && count<10)

    {

      subst=newSubst;

      count++;

    }

    if (count==10)

    {

      warn_cont("Warning: possible recursive namespace alias detected for %s!\n",name);

    }

    return Doxygen::namespaceSDict->find(subst->data());

  }

  else

  {

    return Doxygen::namespaceSDict->find(name);

  }

}

static QDict<MemberDef> g_resolvedTypedefs;

static QDict<Definition> g_visitedNamespaces;

// forward declaration

ClassDef *getResolvedClassRec(Definition *scope,

                              FileDef *fileScope,

                              const char *n,

                              MemberDef **pTypeDef,

                              QCString *pTemplSpec,

                              QCString *pResolvedType

                             );

int isAccessibleFromWithExpScope(Definition *scope,FileDef *fileScope,Definition *item,

                     const QCString &explicitScopePart);

/*! Returns the class representing the value of the typedef represented by \a md

 *  within file \a fileScope.

 *

 *  Example: typedef A T; will return the class representing A if it is a class.

 * 

 *  Example: typedef int T; will return 0, since "int" is not a class.

 */

ClassDef *newResolveTypedef(FileDef *fileScope,MemberDef *md,

                            MemberDef **pMemType,QCString *pTemplSpec,

                            QCString *pResolvedType,

                            ArgumentList *actTemplParams)

{

  //printf("newResolveTypedef(md=%p,cachedVal=%p)\n",md,md->getCachedTypedefVal());

  bool isCached = md->isTypedefValCached(); // value already cached

  if (isCached)

  {

    //printf("Already cached %s->%s [%s]\n",

    //    md->name().data(),

    //    md->getCachedTypedefVal()?md->getCachedTypedefVal()->name().data():"<none>",

    //    md->getCachedResolvedTypedef()?md->getCachedResolvedTypedef().data():"<none>");

    if (pTemplSpec)    *pTemplSpec    = md->getCachedTypedefTemplSpec();

    if (pResolvedType) *pResolvedType = md->getCachedResolvedTypedef();

    return md->getCachedTypedefVal();

  }

  //printf("new typedef\n");

  QCString qname = md->qualifiedName();

  if (g_resolvedTypedefs.find(qname)) return 0; // typedef already done

  g_resolvedTypedefs.insert(qname,md); // put on the trace list

  ClassDef *typeClass = md->getClassDef();

  QCString type = md->typeString(); // get the "value" of the typedef

  if (typeClass && typeClass->isTemplate() && 

      actTemplParams && actTemplParams->count()>0)

  {

    type = substituteTemplateArgumentsInString(type,

            typeClass->templateArguments(),actTemplParams);

  }