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

 *

 * 

 *

 *

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

#include <qregexp.h>

#include <assert.h>

#include <md5.h>

#include "memberdef.h"

#include "membername.h"

#include "doxygen.h"

#include "util.h"

#include "code.h"

#include "message.h"

#include "htmlhelp.h"

#include "language.h"

#include "outputlist.h"

#include "example.h"

#include "membergroup.h"

#include "groupdef.h"

#include "defargs.h"

#include "docparser.h"

#include "dot.h"

#include "searchindex.h"

#include "parserintf.h"

#include "marshal.h"

#include "objcache.h"

#include "vhdlscanner.h"

#include "vhdldocgen.h"

#define START_MARKER 0x4D454D5B // MEM[

#define END_MARKER   0x4D454D5D // MEM]

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

int MemberDef::s_indentLevel = 0;

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

static QCString addTemplateNames(const QCString &s,const QCString &n,const QCString &t)

{

  QCString result;

  QCString clRealName=n;

  int p=0,i;

  if ((i=clRealName.find('<'))!=-1)

  {

    clRealName=clRealName.left(i); // strip template specialization

  }

  if ((i=clRealName.findRev("::"))!=-1)

  {

    clRealName=clRealName.right(clRealName.length()-i-2);

  }

  while ((i=s.find(clRealName,p))!=-1)

  {

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

    uint j=clRealName.length()+i;

    if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))

    { // add template names

      //printf("Adding %s+%s\n",clRealName.data(),t.data());

      result+=clRealName+t; 

    }

    else 

    { // template names already present

      //printf("Adding %s\n",clRealName.data());

      result+=clRealName;

    }

    p=i+clRealName.length();

  }

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

  //printf("addTemplateNames(%s,%s,%s)=%s\n",s.data(),n.data(),t.data(),result.data());

  return result;

}

static bool writeDefArgumentList(OutputList &ol,ClassDef *cd,

                                 const QCString & /*scopeName*/,MemberDef *md)

{

  LockingPtr<ArgumentList> defArgList=(md->isDocsForDefinition()) ? 

                             md->argumentList() : md->declArgumentList();

  //printf("writeDefArgumentList `%s' isDocsForDefinition()=%d\n",md->name().data(),md->isDocsForDefinition());

  if (defArgList==0 || md->isProperty()) 

  {

    return FALSE; // member has no function like argument list

  }

  if (!md->isDefine()) ol.docify(" ");

  //printf("writeDefArgList(%d)\n",defArgList->count());

  ol.pushGeneratorState();

  ol.disableAllBut(OutputGenerator::Html);

  {

    // html

    ol.endMemberDocName();

    ol.startParameterList(!md->isObjCMethod()); 

  }

  ol.enableAll();

  ol.disable(OutputGenerator::Html);

  {

    // other formats

    if (!md->isObjCMethod()) ol.docify("("); // start argument list

    ol.endMemberDocName();

  }

  ol.popGeneratorState();

  //printf("===> name=%s isDefine=%d\n",md->name().data(),md->isDefine());

  Argument *a=defArgList->first();

  QCString cName;

  if (cd)

  {

    cName=cd->name();

    int il=cName.find('<');

    int ir=cName.findRev('>');

    if (il!=-1 && ir!=-1 && ir>il)

    {

      cName=cName.mid(il,ir-il+1);

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

    }

    else if (cd->templateArguments())

    {

      cName=tempArgListToString(cd->templateArguments()); 

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

    }

    else // no template specifier

    {

      cName.resize(0);

    }

  }

  //printf("~~~ %s cName=%s\n",md->name().data(),cName.data());

  //if (!md->isDefine()) ol.startParameter(TRUE); else ol.docify(" ");

  bool first=TRUE;

  bool paramTypeStarted=FALSE;

  while (a)

  {

    if (md->isDefine() || first) 

    {

      ol.startParameterType(first,md->isObjCMethod()?"dummy":0);

      paramTypeStarted=TRUE;

    }

    QRegExp re(")("),res("(.*\\*");

    int vp=a->type.find(re);

    int wp=a->type.find(res);

    // use the following to put the function pointer type before the name

    bool hasFuncPtrType=FALSE; 

    // or use the following to put the function pointer as it appears in

    // the prototype.

    //bool hasFuncPtrType=vp!=-1 && wp!=-1 && wp<vp; 

    if (!a->attrib.isEmpty() && !md->isObjCMethod()) // argument has an IDL attribute

    {

      ol.docify(a->attrib+" ");

    }

    if (hasFuncPtrType) // argument type is a function pointer

    {

      //printf("a->type=`%s' a->name=`%s'\n",a->type.data(),a->name.data());

      QCString n=a->type.left(vp);

      if (hasFuncPtrType) n=a->type.left(wp);

      if (md->isObjCMethod()) { n.prepend("("); n.append(")"); }

      if (!cName.isEmpty()) n=addTemplateNames(n,cd->name(),cName);

      linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md->name(),n);

    }

    else // non-function pointer type

    {

      QCString n=a->type;

      if (md->isObjCMethod()) { n.prepend("("); n.append(")"); }

      if (a->type!="...")

      {

        if (!cName.isEmpty()) n=addTemplateNames(n,cd->name(),cName);

        linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md->name(),n);

      }

    }

    if (!md->isDefine())

    {

      if (paramTypeStarted) 

      {

        ol.endParameterType();

        paramTypeStarted=FALSE;

      }

      ol.startParameterName(defArgList->count()<2);

    }

    if (hasFuncPtrType)

    {

      ol.docify(a->type.mid(wp,vp-wp)); 

    }

    if (!a->name.isEmpty() || (a->name.isEmpty() && a->type=="...")) // argument has a name

    { 

      if (!hasFuncPtrType)

      {

        ol.docify(" ");

      }

      ol.disable(OutputGenerator::Man);

      ol.startEmphasis();

      ol.enable(OutputGenerator::Man);

      if (a->name.isEmpty()) ol.docify(a->type); else ol.docify(a->name);

      ol.disable(OutputGenerator::Man);

      ol.endEmphasis();

      ol.enable(OutputGenerator::Man);

    }

    if (!a->array.isEmpty())

    {

      ol.docify(a->array);

    }

    if (hasFuncPtrType) // write the part of the argument type 

                        // that comes after the name

    {

      linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),

                  md->name(),a->type.right(a->type.length()-vp));

    }

    if (!a->defval.isEmpty()) // write the default value

    {

      QCString n=a->defval;

      if (!cName.isEmpty()) n=addTemplateNames(n,cd->name(),cName);

      ol.docify(" = ");

      ol.startTypewriter();

      linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md->name(),n,FALSE,TRUE,TRUE); 

      ol.endTypewriter();

    }

    a=defArgList->next();

    if (a) 

    {

      if (!md->isObjCMethod()) ol.docify(", "); // there are more arguments

      if (!md->isDefine()) 

      {

        QCString key;

        if (md->isObjCMethod() && a->attrib.length()>=2)

        {

          //printf("Found parameter keyword %s\n",a->attrib.data());

          // strip [ and ]

          key=a->attrib.mid(1,a->attrib.length()-2);

          if (key!=",") key+=":"; // for normal keywords add colon

        }

        ol.endParameterName(FALSE,FALSE,!md->isObjCMethod());

        if (paramTypeStarted) 

        {

          ol.endParameterType();

        }

        ol.startParameterType(FALSE,key);

        paramTypeStarted=TRUE;

      }

      else

      {

        ol.endParameterName(FALSE,FALSE,TRUE);

      }

    }

    first=FALSE;

  }

  ol.pushGeneratorState();

  bool htmlOn = ol.isEnabled(OutputGenerator::Html);

  ol.disable(OutputGenerator::Html);

  //if (!first) ol.writeString(" ");

  if (!md->isObjCMethod()) ol.docify(")"); // end argument list

  ol.enableAll();

  ol.disableAllBut(OutputGenerator::Html);

  if (!htmlOn) ol.disable(OutputGenerator::Html);

  if (!md->isDefine()) 

  {

    if (first) ol.startParameterName(defArgList->count()<2);

    ol.endParameterName(TRUE,defArgList->count()<2,!md->isObjCMethod());

  }

  else 

  {

    ol.endParameterType();

    ol.startParameterName(TRUE);

    ol.endParameterName(TRUE,TRUE,!md->isObjCMethod());

  }

  ol.popGeneratorState();

  if (md->extraTypeChars())

  {

    ol.docify(md->extraTypeChars());

  }

  if (defArgList->constSpecifier)

  {

    ol.docify(" const");

  }

  if (defArgList->volatileSpecifier)

  {

    ol.docify(" volatile");

  }

  return TRUE;

}

static void writeTemplatePrefix(OutputList &ol,ArgumentList *al)

{

  ol.docify("template<");

  Argument *a=al->first();

  while (a)

  {

    ol.docify(a->type);

    ol.docify(" ");

    ol.docify(a->name);

    if (a->defval.length()!=0)

    {

      ol.docify(" = ");

      ol.docify(a->defval);

    } 

    a=al->next();

    if (a) ol.docify(", ");

  }

  ol.docify("> ");

}

QCString extractDirection(QCString &docs)

{

  QRegExp re("\\[[^\\]]+\\]"); // [...]

  int l=0;

  if (re.match(docs,0,&l)==0)

  {

    int  inPos  = docs.find("in", 1,FALSE);

    int outPos  = docs.find("out",1,FALSE);

    bool input  =  inPos!=-1 &&  inPos<l;

    bool output = outPos!=-1 && outPos<l;

    if (input || output) // in,out attributes

    {

      docs = docs.mid(l); // strip attributes

      if (input && output) return "[in,out]";

      else if (input)      return "[in]";

      else if (output)     return "[out]";

    }

  }

  return QCString();

}

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

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

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

class MemberDefImpl

{

  public:

    MemberDefImpl();

   ~MemberDefImpl();

    void init(Definition *def,const char *t,const char *a,const char *e,

              Protection p,Specifier v,bool s,Relationship r,

              MemberDef::MemberType mt,const ArgumentList *tal,

              const ArgumentList *al

             );

    ClassDef     *classDef;   // member of or related to 

    FileDef      *fileDef;    // member of file definition 

    NamespaceDef *nspace;     // the namespace this member is in.

    MemberDef  *enumScope;    // the enclosing scope, if this is an enum field

    MemberDef  *annEnumType;  // the annonymous enum that is the type of this member

    MemberList *enumFields;   // enumeration fields

    MemberDef  *redefines;    // the members that this member redefines 

    MemberList *redefinedBy;  // the list of members that redefine this one

    MemberDef  *memDef;       // member definition for this declaration

    MemberDef  *memDec;       // member declaration for this definition

    ClassDef   *relatedAlso;  // points to class marked by relatedAlso

    ExampleSDict *exampleSDict; // a dictionary of all examples for quick access

    QCString type;            // return type

    QCString args;            // function arguments/variable array specifiers

    QCString def;             // member definition in code (fully qualified name)

    QCString anc;             // HTML anchor name

    Specifier virt;           // normal/virtual/pure virtual

    Protection prot;          // protection type [Public/Protected/Private]

    QCString decl;            // member declaration in class

    QCString bitfields;       // struct member bitfields

    QCString read;            // property read accessor

    QCString write;           // property write accessor

    QCString exception;       // exceptions that can be thrown

    QCString initializer;     // initializer

    QCString extraTypeChars;  // extra type info found after the argument list

    int initLines;            // number of lines in the initializer

    int  memSpec;             // The specifiers present for this member

    MemberDef::MemberType mtype;         // returns the kind of member

    int maxInitLines;         // when the initializer will be displayed 

    int userInitLines;        // result of explicit \hideinitializer or \showinitializer

    MemberDef  *annMemb;

    ArgumentList *defArgList;    // argument list of this member definition

    ArgumentList *declArgList;   // argument list of this member declaration

    ArgumentList *tArgList;      // template argument list of function template

    ArgumentList *typeConstraints; // type constraints for template parameters

    MemberDef *templateMaster;

    QList<ArgumentList> *defTmpArgLists; // lists of template argument lists 

                                         // (for template functions in nested template classes)

    ClassDef *cachedAnonymousType; // if the member has an anonymous compound

                                   // as its type then this is computed by

                                   // getClassDefOfAnonymousType() and 

                                   // cached here. 

    SDict<MemberList> *classSectionSDict; // not accessible

    MemberDef *groupAlias;    // Member containing the definition

    int grpId;                // group id

    MemberGroup *memberGroup; // group's member definition

    GroupDef *group;          // group in which this member is in

    Grouping::GroupPri_t grouppri; // priority of this definition

    QCString groupFileName;   // file where this grouping was defined

    int groupStartLine;       // line  "      "      "     "     "

    MemberDef *groupMember;

    bool isTypedefValCached;

    ClassDef *cachedTypedefValue;

    QCString cachedTypedefTemplSpec;

    QCString cachedResolvedType;

    // inbody documentation

    //int inbodyLine;

    //QCString inbodyFile;

    //QCString inbodyDocs;

    // documentation inheritance

    MemberDef *docProvider;

    // to store the output file base from tag files

    QCString explicitOutputFileBase;

    // objective-c

    bool implOnly; // function found in implementation but not 

                     // in the interface

    bool hasDocumentedParams;

    bool hasDocumentedReturnType;

    bool isDMember;

    Relationship related;     // relationship of this to the class

    bool stat;                // is it a static function?

    bool proto;               // is it a prototype;

    bool docEnumValues;       // is an enum with documented enum values.

    bool annScope;            // member is part of an annoymous scope

    bool annUsed;             

    bool hasCallGraph;

    bool hasCallerGraph;

    bool explExt;             // member was explicitly declared external

    bool tspec;               // member is a template specialization

    bool groupHasDocs;        // true if the entry that caused the grouping was documented

    bool docsForDefinition;   // TRUE => documentation block is put before

                              //         definition.

                              // FALSE => block is put before declaration.

    ClassDef *category;

};

MemberDefImpl::MemberDefImpl() :

    enumFields(0),

    redefinedBy(0),

    exampleSDict(0),

    defArgList(0),

    declArgList(0),

    tArgList(0),

    typeConstraints(0),

    defTmpArgLists(0),

    classSectionSDict(0),

    category(0)

{

}

MemberDefImpl::~MemberDefImpl()

{

  delete redefinedBy;

  delete exampleSDict;

  delete enumFields;

  delete defArgList;

  delete tArgList;

  delete typeConstraints;

  delete defTmpArgLists;

  delete classSectionSDict;

  delete declArgList;

}

void MemberDefImpl::init(Definition *def,

                     const char *t,const char *a,const char *e,

                     Protection p,Specifier v,bool s,Relationship r,

                     MemberDef::MemberType mt,const ArgumentList *tal,

                     const ArgumentList *al

                    )

{

  classDef=0;

  fileDef=0;

  redefines=0;

  relatedAlso=0;

  redefinedBy=0;

  nspace=0;

  memDef=0;

  memDec=0;

  group=0;

  grpId=-1;

  exampleSDict=0;

  enumFields=0;

  enumScope=0;

  defTmpArgLists=0;

  hasCallGraph = FALSE;

  hasCallerGraph = FALSE;

  initLines=0;

  type=t;

  if (mt==MemberDef::Typedef) type.stripPrefix("typedef ");

  //  type.stripPrefix("struct ");

  //  type.stripPrefix("class " );

  //  type.stripPrefix("union " );

  type=removeRedundantWhiteSpace(type);

  args=a;

  args=removeRedundantWhiteSpace(args);

  if (type.isEmpty()) decl=def->name()+args; else decl=type+" "+def->name()+args;

  memberGroup=0;

  virt=v;

  prot=p;

  related=r;

  stat=s;

  mtype=mt;

  exception=e;

  proto=FALSE;

  annScope=FALSE;

  memSpec=0;

  annMemb=0;

  annUsed=FALSE;