1 /******************************************************************************

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 by Dimitri van Heesch.

     6  *

     7  * Permission to use, copy, modify, and distribute this software and its

     8  * documentation under the terms of the GNU General Public License is hereby 

     9  * granted. No representations are made about the suitability of this software 

    10  * for any purpose. It is provided "as is" without express or implied warranty.

    11  * See the GNU General Public License for more details.

    12  *

    13  * Documents produced by Doxygen are derivative works derived from the

    14  * input used in their production; they are not affected by this license.

    15  *

    16  */

    17 

    18 %{

    19 

    20 /*

    21  *	includes

    22  */

    23 #include <stdio.h>

    24 #include <assert.h>

    25 #include <ctype.h>

    26 #include <qregexp.h>

    27 #include <qdir.h>

    28 

    29 #include "qtbc.h"

    30 #include "entry.h"

    31 #include "doxygen.h"

    32 #include "message.h"

    33 #include "outputlist.h"

    34 #include "util.h"

    35 #include "membername.h"

    36 #include "searchindex.h"

    37 

    38 #define YY_NEVER_INTERACTIVE 1

    39   

    40 // Toggle for some debugging info

    41 //#define DBG_CTX(x) fprintf x

    42 #define DBG_CTX(x) do { } while(0)

    43   

    44 #define CLASSBLOCK (int *)4

    45 #define SCOPEBLOCK (int *)8

    46 #define INNERBLOCK (int *)12

    47 

    48 /* -----------------------------------------------------------------

    49  *	statics

    50  */

    51   

    52 static CodeOutputInterface * g_code;

    53 

    54 static ClassSDict    *g_codeClassSDict = 0;

    55 static QCString      g_curClassName;

    56 static QStrList      g_curClassBases;

    57 

    58 static QCString      g_parmType;

    59 static QCString      g_parmName;

    60 

    61 static const char *  g_inputString;     //!< the code fragment as text

    62 static int	     g_inputPosition;   //!< read offset during parsing 

    63 static int           g_inputLines;      //!< number of line in the code fragment

    64 static int	     g_yyLineNr;        //!< current line number

    65 static bool          g_needsTermination;

    66 

    67 static bool          g_exampleBlock;

    68 static QCString      g_exampleName;

    69 static QCString      g_exampleFile;

    70 

    71 static bool          g_insideTemplate = FALSE;

    72 static QCString      g_type;

    73 static QCString      g_name;

    74 static QCString      g_args;

    75 static QCString      g_classScope;

    76 static QCString      g_realScope;

    77 static QStack<int>   g_scopeStack;      //!< 1 if bracket starts a scope, 

    78                                         //   2 for internal blocks 

    79 static int           g_anchorCount;

    80 static FileDef *     g_sourceFileDef;

    81 static bool          g_lineNumbers;

    82 static Definition *  g_currentDefinition;

    83 static MemberDef *   g_currentMemberDef;

    84 static bool          g_includeCodeFragment;

    85 static const char *  g_currentFontClass;

    86 static bool          g_searchingForBody;

    87 static bool          g_insideBody;

    88 static int           g_bodyCurlyCount;

    89 static QCString      g_saveName;

    90 static QCString      g_saveType;

    91 

    92 static int	     g_bracketCount = 0;

    93 static int	     g_curlyCount   = 0;

    94 static int	     g_sharpCount   = 0;

    95 static bool          g_inFunctionTryBlock = FALSE;

    96 static bool          g_inForEachExpression = FALSE;

    97 

    98 static int           g_lastTemplCastContext;

    99 static int	     g_lastSpecialCContext;

   100 static int           g_lastStringContext;

   101 static int           g_lastSkipCppContext;

   102 static int           g_lastVerbStringContext;

   103 static int           g_memCallContext;

   104 static int	     g_lastCContext;

   105 

   106 static bool          g_insideObjC;

   107 static bool          g_insideProtocolList;

   108 

   109 static bool          g_lexInit = FALSE;

   110 

   111 static QStack<int>   g_classScopeLengthStack;

   112 

   113 // context for an Objective-C method call

   114 struct ObjCCallCtx

   115 {

   116   int id;

   117   QCString methodName;

   118   QCString objectTypeOrName;

   119   ClassDef *objectType;

   120   MemberDef *objectVar;

   121   MemberDef *method;

   122   QCString format;

   123   int lexState;

   124   int braceCount;

   125 };

   126 

   127 // globals for objective-C method calls 

   128 static ObjCCallCtx *g_currentCtx=0;

   129 static int g_currentCtxId=0;

   130 static int g_currentNameId=0;

   131 static int g_currentObjId=0;

   132 static int g_currentWordId=0;

   133 static QStack<ObjCCallCtx> g_contextStack;

   134 static QIntDict<ObjCCallCtx> g_contextDict;

   135 static QIntDict<QCString> g_nameDict;

   136 static QIntDict<QCString> g_objectDict;

   137 static QIntDict<QCString> g_wordDict;

   138 static int g_braceCount=0;

   139   

   140 static void saveObjCContext();

   141 static void restoreObjCContext();

   142 

   143 

   144 

   145 //-------------------------------------------------------------------

   146 

   147 /*! Represents a stack of variable to class mappings as found in the

   148  *  code. Each scope is enclosed in pushScope() and popScope() calls.

   149  *  Variables are added by calling addVariables() and one can search

   150  *  for variable using findVariable().

   151  */

   152 class VariableContext

   153 {

   154   public:

   155     static const ClassDef *dummyContext;

   156     

   157     class Scope : public SDict<ClassDef>

   158     {

   159       public:

   160 	Scope() : SDict<ClassDef>(17) {}

   161     };

   162     

   163     VariableContext() 

   164     {

   165       m_scopes.setAutoDelete(TRUE);

   166     }

   167     virtual ~VariableContext()

   168     {

   169     }

   170     

   171     void pushScope()

   172     {

   173       m_scopes.append(new Scope);

   174       DBG_CTX((stderr,"** Push var context %d\n",m_scopes.count()));

   175     }

   176 

   177     void popScope()

   178     {

   179       if (m_scopes.count()>0)

   180       {

   181         DBG_CTX((stderr,"** Pop var context %d\n",m_scopes.count()));

   182 	m_scopes.remove(m_scopes.count()-1);

   183       }

   184       else

   185       {

   186         DBG_CTX((stderr,"** ILLEGAL: Pop var context\n"));

   187       }

   188     }

   189 

   190     void clear()

   191     {

   192       m_scopes.clear();

   193       m_globalScope.clear();

   194     }

   195 

   196     void clearExceptGlobal()

   197     {

   198       DBG_CTX((stderr,"** Clear var context\n"));

   199       m_scopes.clear();

   200     }

   201 

   202     void addVariable(const QCString &type,const QCString &name);

   203     ClassDef *findVariable(const QCString &name);

   204 

   205     int count() const { return m_scopes.count(); }

   206     

   207   private:

   208     Scope        m_globalScope;

   209     QList<Scope> m_scopes;

   210 };

   211 

   212 void VariableContext::addVariable(const QCString &type,const QCString &name)

   213 {

   214   //printf("VariableContext::addVariable(%s,%s)\n",type.data(),name.data());

   215   QCString ltype = type.simplifyWhiteSpace();

   216   QCString lname = name.simplifyWhiteSpace();

   217   if (ltype.left(7)=="struct ") 

   218   {

   219     ltype = ltype.right(ltype.length()-7);

   220   }

   221   else if (ltype.left(6)=="union ")

   222   {

   223     ltype = ltype.right(ltype.length()-6);

   224   }

   225   if (ltype.isEmpty() || lname.isEmpty()) return;

   226   DBG_CTX((stderr,"** addVariable trying: type='%s' name='%s' g_currentDefinition=%s\n",

   227 	ltype.data(),lname.data(),g_currentDefinition?g_currentDefinition->name().data():"<none>"));

   228   Scope *scope = m_scopes.count()==0 ? &m_globalScope : m_scopes.getLast();

   229   ClassDef *varType;

   230   int i=0;

   231   if (

   232       (varType=g_codeClassSDict->find(ltype)) ||  // look for class definitions inside the code block

   233       (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,ltype)) // look for global class definitions

   234      ) 

   235   {

   236     DBG_CTX((stderr,"** addVariable type='%s' name='%s'\n",ltype.data(),lname.data()));

   237     scope->append(lname,varType); // add it to a list

   238   }

   239   else if ((i=ltype.find('<'))!=-1)

   240   {

   241     // probably a template class

   242     QCString typeName(ltype.left(i));

   243     ClassDef* newDef = 0;

   244     QCString templateArgs(ltype.right(ltype.length() - i));

   245     if (  

   246          ( // look for class definitions inside the code block

   247 	   (varType=g_codeClassSDict->find(typeName)) ||

   248            // otherwise look for global class definitions

   249            (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,typeName))

   250 	 ) && // and it must be a template

   251          varType->templateArguments())

   252     {

   253       newDef = varType->getVariableInstance( templateArgs );

   254     }

   255     if (newDef)

   256     {

   257       DBG_CTX((stderr,"** addVariable type='%s' templ='%s' name='%s'\n",typeName.data(),templateArgs.data(),lname.data()));

   258       scope->append(lname, newDef);

   259     }

   260     else

   261     {

   262       // Doesn't seem to be a template. Try just the base name.

   263       addVariable(typeName,name);

   264     }

   265   }

   266   else 

   267   {

   268     if (m_scopes.count()>0) // for local variables add a dummy entry so the name 

   269                             // is hidden to avoid false links to global variables with the same name

   270                             // TODO: make this work for namespaces as well!

   271     {

   272       DBG_CTX((stderr,"** addVariable: dummy context for '%s'\n",lname.data()));

   273       scope->append(lname,dummyContext);

   274     }

   275     else

   276     {

   277       DBG_CTX((stderr,"** addVariable: not adding variable!\n"));

   278     }

   279   }

   280 }

   281 

   282 ClassDef *VariableContext::findVariable(const QCString &name)

   283 {

   284   if (name.isEmpty()) return 0;

   285   ClassDef *result = 0;

   286   QListIterator<Scope> sli(m_scopes);

   287   Scope *scope;

   288   QCString key = name;

   289   // search from inner to outer scope

   290   for (sli.toLast();(scope=sli.current());--sli)

   291   {

   292     result = scope->find(key);

   293     if (result) 

   294     {

   295       DBG_CTX((stderr,"** findVariable(%s)=%p\n",name.data(),result));

   296       return result;

   297     }

   298   }

   299   // nothing found -> also try the global scope

   300   result=m_globalScope.find(name);

   301   DBG_CTX((stderr,"** findVariable(%s)=%p\n",name.data(),result));

   302   return result;

   303 }

   304 

   305 static VariableContext g_theVarContext;

   306 const ClassDef *VariableContext::dummyContext = (ClassDef*)0x8;

   307 

   308 //-------------------------------------------------------------------

   309 

   310 class CallContext

   311 {

   312   public:

   313     struct Ctx

   314     {

   315       Ctx() : name(g_name), type(g_type), cd(0) {}

   316       QCString name;

   317       QCString type;

   318       ClassDef *cd;

   319     };

   320 

   321     CallContext() 

   322     {

   323       m_classList.append(new Ctx);

   324       m_classList.setAutoDelete(TRUE);

   325     }

   326     virtual ~CallContext() {}

   327     void setClass(ClassDef *cd)

   328     {

   329       Ctx *ctx = m_classList.getLast();

   330       if (ctx)

   331       {

   332 	DBG_CTX((stderr,"** Set call context %s (%p)\n",cd==0 ? "<null>" : cd->name().data(),cd));

   333         ctx->cd=cd;

   334       }

   335     }

   336     void pushScope()

   337     {

   338       m_classList.append(new Ctx);

   339       DBG_CTX((stderr,"** Push call context %d\n",m_classList.count()));

   340     }

   341     void popScope()

   342     {

   343       if (m_classList.count()>1)

   344       {

   345         DBG_CTX((stderr,"** Pop call context %d\n",m_classList.count()));

   346 	Ctx *ctx = m_classList.getLast();

   347 	if (ctx)

   348 	{

   349 	  g_name = ctx->name;

   350 	  g_type = ctx->type;

   351 	}

   352 	m_classList.removeLast();

   353       }

   354       else

   355       {

   356         DBG_CTX((stderr,"** ILLEGAL: Pop call context\n"));

   357       }

   358     }

   359     void clear()

   360     {

   361       DBG_CTX((stderr,"** Clear call context\n"));

   362       m_classList.clear();

   363       m_classList.append(new Ctx);

   364     }

   365     ClassDef *getClass() const

   366     {

   367       Ctx *ctx = m_classList.getLast();

   368       if (ctx) return ctx->cd; else return 0;

   369     }

   370 

   371   private:

   372     QList<Ctx> m_classList;    

   373 };

   374 

   375 static CallContext g_theCallContext;

   376 

   377 //-------------------------------------------------------------------

   378 

   379 /*! add class/namespace name s to the scope */

   380 static void pushScope(const char *s)

   381 {

   382   g_classScopeLengthStack.push(new int(g_classScope.length()));

   383   if (g_classScope.isEmpty())

   384   {

   385     g_classScope = s;

   386   }

   387   else

   388   {

   389     g_classScope += "::";

   390     g_classScope += s;

   391   }

   392   //printf("pushScope(%s) result: `%s'\n",s,g_classScope.data());

   393 }

   394 

   395 /*! remove the top class/namespace name from the scope */

   396 static void popScope()

   397 {

   398   if (!g_classScopeLengthStack.isEmpty())

   399   {

   400     int *pLength = g_classScopeLengthStack.pop();

   401     g_classScope.truncate(*pLength);

   402     delete pLength;

   403   }

   404   else

   405   {

   406     //err("Error: Too many end of scopes found!\n");

   407   }

   408   //printf("popScope() result: `%s'\n",g_classScope.data());

   409 }

   410 

   411 static void setCurrentDoc(const QCString &name,const QCString &base,const QCString &anchor="")

   412 {

   413   if (Doxygen::searchIndex)

   414   {

   415     Doxygen::searchIndex->setCurrentDoc(name,base,anchor);

   416   }

   417 }

   418 

   419 static void addToSearchIndex(const char *text)

   420 {

   421   if (Doxygen::searchIndex)

   422   {

   423     Doxygen::searchIndex->addWord(text,FALSE);

   424   }

   425 }

   426 

   427 static void setClassScope(const QCString &name)

   428 {

   429   //printf("setClassScope(%s)\n",name.data());

   430   QCString n=name;

   431   n=n.simplifyWhiteSpace();

   432   int ts=n.find('<'); // start of template

   433   int te=n.findRev('>'); // end of template

   434   //printf("ts=%d te=%d\n",ts,te);

   435   if (ts!=-1 && te!=-1 && te>ts)

   436   {

   437     // remove template from scope

   438     n=n.left(ts)+n.right(n.length()-te-1);

   439   }

   440   while (!g_classScopeLengthStack.isEmpty())

   441   {

   442     popScope();

   443   }

   444   g_classScope.resize(0);

   445   int i;

   446   while ((i=n.find("::"))!=-1)

   447   {

   448     pushScope(n.left(i));

   449     n = n.mid(i+2);

   450   }

   451   pushScope(n);

   452   //printf("--->New class scope `%s'\n",g_classScope.data());

   453 }

   454 

   455 /*! start a new line of code, inserting a line number if g_sourceFileDef

   456  * is TRUE. If a definition starts at the current line, then the line

   457  * number is linked to the documentation of that definition.

   458  */

   459 static void startCodeLine()

   460 {

   461   //if (g_currentFontClass) { g_code->endFontClass(); }

   462   if (g_sourceFileDef && g_lineNumbers)

   463   {

   464     //QCString lineNumber,lineAnchor;

   465     //lineNumber.sprintf("%05d",g_yyLineNr);

   466     //lineAnchor.sprintf("l%05d",g_yyLineNr);

   467    

   468     Definition *d   = g_sourceFileDef->getSourceDefinition(g_yyLineNr);

   469     if (!g_includeCodeFragment && d)

   470     {

   471       g_currentDefinition = d;

   472       g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

   473       g_insideBody = FALSE;

   474       g_searchingForBody = TRUE;

   475       g_realScope = d->name().copy();

   476       g_type.resize(0);

   477       g_name.resize(0);

   478       g_args.resize(0);

   479       g_parmType.resize(0);

   480       g_parmName.resize(0);

   481       //printf("Real scope: `%s'\n",g_realScope.data());

   482       g_bodyCurlyCount = 0;

   483       QCString lineAnchor;

   484       lineAnchor.sprintf("l%05d",g_yyLineNr);

   485       if (g_currentMemberDef)

   486       {

   487         g_code->writeLineNumber(g_currentMemberDef->getReference(),

   488 	                        g_currentMemberDef->getOutputFileBase(),

   489 	                        g_currentMemberDef->anchor(),g_yyLineNr);

   490         setCurrentDoc(

   491                                 g_currentMemberDef->qualifiedName(),

   492 	                        g_sourceFileDef->getSourceFileBase(),

   493 	                        lineAnchor);

   494       }

   495       else if (d->isLinkableInProject())

   496       {

   497         g_code->writeLineNumber(d->getReference(),

   498 	                        d->getOutputFileBase(),

   499 	                        0,g_yyLineNr);

   500         setCurrentDoc(

   501                                 d->qualifiedName(),

   502 	                        g_sourceFileDef->getSourceFileBase(),

   503 	                        lineAnchor);

   504       }

   505     }

   506     else

   507     {

   508       g_code->writeLineNumber(0,0,0,g_yyLineNr);

   509     }

   510   }

   511   g_code->startCodeLine(); 

   512   if (g_currentFontClass)

   513   {

   514     g_code->startFontClass(g_currentFontClass);

   515   }

   516 }

   517 

   518 

   519 static void endFontClass();

   520 static void startFontClass(const char *s);

   521 

   522 static void endCodeLine()

   523 {

   524   endFontClass();

   525   g_code->endCodeLine();

   526 }

   527 

   528 static void nextCodeLine()

   529 {

   530   const char * fc = g_currentFontClass;

   531   endCodeLine();

   532   if (g_yyLineNr<g_inputLines) 

   533   {

   534     g_currentFontClass = fc;

   535     startCodeLine();

   536   }

   537 }

   538 

   539 /*! write a code fragment `text' that may span multiple lines, inserting

   540  * line numbers for each line.

   541  */

   542 static void codifyLines(char *text)

   543 {

   544   //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text);

   545   char *p=text,*sp=p;

   546   char c;

   547   bool done=FALSE;

   548   while (!done)

   549   {

   550     sp=p;

   551     while ((c=*p++) && c!='\n') { }

   552     if (c=='\n')

   553     {

   554       g_yyLineNr++;

   555       *(p-1)='\0';

   556       g_code->codify(sp);

   557       nextCodeLine();

   558     }

   559     else

   560     {

   561       g_code->codify(sp);

   562       done=TRUE;

   563     }

   564   }

   565 }

   566 

   567 /*! writes a link to a fragment \a text that may span multiple lines, inserting

   568  * line numbers for each line. If \a text contains newlines, the link will be 

   569  * split into multiple links with the same destination, one for each line.

   570  */

   571 static void writeMultiLineCodeLink(CodeOutputInterface &ol,

   572                   const char *ref,const char *file,

   573                   const char *anchor,const char *text,

   574 		  const char *tooltip)

   575 {

   576   bool done=FALSE;

   577   char *p=(char *)text;

   578   while (!done)

   579   {

   580     char *sp=p;

   581     char c;

   582     while ((c=*p++) && c!='\n') { }

   583     if (c=='\n')

   584     {

   585       g_yyLineNr++;

   586       *(p-1)='\0';

   587       //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);

   588       ol.writeCodeLink(ref,file,anchor,sp,tooltip);

   589       nextCodeLine();

   590     }

   591     else

   592     {

   593       //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);

   594       ol.writeCodeLink(ref,file,anchor,sp,tooltip);

   595       done=TRUE;

   596     }

   597   }

   598 }

   599 

   600 static void addType()

   601 {

   602   if (g_name=="const") { g_name.resize(0); return; }

   603   if (!g_type.isEmpty()) g_type += ' ' ;

   604   g_type += g_name ;

   605   g_name.resize(0) ;

   606   if (!g_type.isEmpty()) g_type += ' ' ;

   607   g_type += g_args ;

   608   g_args.resize(0) ;

   609 }

   610 

   611 static void addParmType()

   612 {

   613   if (g_parmName=="const") { g_parmName.resize(0); return; }

   614   if (!g_parmType.isEmpty()) g_parmType += ' ' ;

   615   g_parmType += g_parmName ;

   616   g_parmName.resize(0) ;

   617 }

   618 

   619 static void addUsingDirective(const char *name)

   620 {

   621   if (g_exampleBlock && g_sourceFileDef && name)

   622   {

   623     NamespaceDef *nd = Doxygen::namespaceSDict->find(name);

   624     if (nd)

   625     {

   626       g_sourceFileDef->addUsingDirective(nd);

   627     }

   628   }

   629 }

   630 

   631 static void setParameterList(MemberDef *md)

   632 {

   633   g_classScope = md->getClassDef() ? md->getClassDef()->name().data() : "";

   634   LockingPtr<ArgumentList> al = md->argumentList();

   635   if (al==0) return; 

   636   Argument *a = al->first();

   637   while (a)

   638   {

   639     g_parmName = a->name.copy();

   640     g_parmType = a->type.copy();

   641     int i = g_parmType.find('*');

   642     if (i!=-1) g_parmType = g_parmType.left(i);

   643     i = g_parmType.find('&');

   644     if (i!=-1) g_parmType = g_parmType.left(i);

   645     g_parmType.stripPrefix("const ");

   646     g_parmType=g_parmType.stripWhiteSpace();

   647     g_theVarContext.addVariable(g_parmType,g_parmName);

   648     a = al->next();

   649   }

   650 }

   651 

   652 static ClassDef *stripClassName(const char *s)

   653 {

   654   int pos=0;

   655   QCString type = s;

   656   QCString className;

   657   QCString templSpec;

   658   while (extractClassNameFromType(type,pos,className,templSpec)!=-1)

   659   {

   660     QCString clName=className+templSpec;

   661     ClassDef *cd=0;

   662     if (!g_classScope.isEmpty())

   663     {

   664       cd=getResolvedClass(g_currentDefinition,g_sourceFileDef,g_classScope+"::"+clName);

   665     }

   666     if (cd==0)

   667     {

   668       cd=getResolvedClass(g_currentDefinition,g_sourceFileDef,clName);

   669     }

   670     //printf("stripClass trying `%s' = %p\n",clName.data(),cd);

   671     if (cd)

   672     {

   673       return cd;

   674     }

   675   }

   676 

   677   return 0;

   678 }

   679 

   680 static MemberDef *setCallContextForVar(const QCString &name)

   681 {

   682   if (name.isEmpty()) return 0;

   683   //fprintf(stderr,"setCallContextForVar(%s) g_classScope=%s\n",name.data(),g_classScope.data());

   684 

   685   int scopeEnd = name.findRev("::");

   686   if (scopeEnd!=-1) // name with explicit scope

   687   {

   688     QCString scope   = name.left(scopeEnd);

   689     QCString locName = name.right(name.length()-scopeEnd-2);

   690     //printf("explicit scope: name=%s scope=%s\n",locName.data(),scope.data());

   691     ClassDef *mcd = getClass(scope); 

   692     if (mcd && !locName.isEmpty())

   693     {

   694       MemberDef *md=mcd->getMemberByName(locName);

   695       if (md)

   696       {

   697         //printf("name=%s scope=%s\n",locName.data(),scope.data());

   698         g_theCallContext.setClass(stripClassName(md->typeString()));

   699         return md;

   700       }

   701     }

   702     else // check namespace as well

   703     {

   704       NamespaceDef *mnd = getResolvedNamespace(scope);

   705       if (mnd && !locName.isEmpty())

   706       {

   707 	MemberDef *md=mnd->getMemberByName(locName);

   708 	if (md)

   709 	{

   710 	  //printf("name=%s scope=%s\n",locName.data(),scope.data());

   711 	  g_theCallContext.setClass(stripClassName(md->typeString()));

   712 	  return md;

   713 	}

   714       }

   715     }

   716   }

   717   

   718   MemberName *mn;

   719   ClassDef *mcd = g_theVarContext.findVariable(name);

   720   if (mcd) // local variable

   721   {

   722     //fprintf(stderr,"local variable\n");

   723     if (mcd!=VariableContext::dummyContext)

   724     {

   725       //fprintf(stderr,"local var `%s' mcd=%s\n",name.data(),mcd->name().data());

   726       g_theCallContext.setClass(mcd);

   727     }

   728   }

   729   else

   730   {

   731     // look for a class member 

   732     mcd = getClass(g_classScope);

   733     if (mcd)

   734     {

   735       //fprintf(stderr,"Inside class %s\n",mcd->name().data());

   736       MemberDef *md=mcd->getMemberByName(name);

   737       if (md) 

   738       {

   739         //fprintf(stderr,"Found member %s\n",md->name().data());

   740 	if (g_scopeStack.top()!=CLASSBLOCK)

   741 	{

   742           //fprintf(stderr,"class member `%s' mcd=%s\n",name.data(),mcd->name().data());

   743 	  g_theCallContext.setClass(stripClassName(md->typeString()));

   744 	}

   745 	return md;

   746       }

   747     }

   748   }

   749 

   750   // look for a global member

   751   if ((mn=Doxygen::functionNameSDict->find(name)))

   752   {

   753     //printf("global var `%s'\n",name.data());

   754     if (mn->count()==1) // global defined only once

   755     {

   756       MemberDef *md=mn->getFirst();

   757       if (!md->isStatic() || md->getBodyDef()==g_sourceFileDef)

   758       {

   759         g_theCallContext.setClass(stripClassName(md->typeString()));

   760         return md;

   761       }

   762       return 0;

   763     }

   764     else if (mn->count()>1) // global defined more than once

   765     {

   766       MemberDef *md=mn->first();

   767       while (md)

   768       {

   769 	//printf("mn=%p md=%p md->getBodyDef()=%p g_sourceFileDef=%p\n",

   770 	//    mn,md,

   771 	//    md->getBodyDef(),g_sourceFileDef);

   772 	

   773 	// in case there are multiple members we could link to, we 

   774 	// only link to members if defined in the same file or 

   775 	// defined as external.

   776         if (!md->isStatic() || md->getBodyDef()==g_sourceFileDef)

   777         {

   778           g_theCallContext.setClass(stripClassName(md->typeString()));

   779 	  //printf("returning member %s in source file %s\n",md->name().data(),g_sourceFileDef->name().data());

   780           return md;

   781         }

   782 	md=mn->next();

   783       }

   784       return 0;

   785     }

   786   }

   787   return 0;

   788 }

   789 

   790 static void addDocCrossReference(MemberDef *src,MemberDef *dst)

   791 {

   792   static bool referencedByRelation = Config_getBool("REFERENCED_BY_RELATION");

   793   static bool referencesRelation   = Config_getBool("REFERENCES_RELATION");

   794   static bool callerGraph          = Config_getBool("CALLER_GRAPH");

   795   static bool callGraph            = Config_getBool("CALL_GRAPH");

   796 

   797   //printf("--> addDocCrossReference src=%s,dst=%s\n",src->name().data(),dst->name().data());

   798   if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types

   799   if ((referencedByRelation || callerGraph || dst->hasCallerGraph()) && 

   800       (src->isFunction() || src->isSlot()) 

   801      )

   802   {

   803     dst->addSourceReferencedBy(src);

   804     MemberDef *mdDef = dst->memberDefinition();

   805     if (mdDef)

   806     {

   807       mdDef->addSourceReferencedBy(src);

   808     }

   809     MemberDef *mdDecl = dst->memberDeclaration();

   810     if (mdDecl)

   811     {

   812       mdDecl->addSourceReferencedBy(src);

   813     }

   814   }

   815   if ((referencesRelation || callGraph || src->hasCallGraph()) && 

   816       (src->isFunction() || src->isSlot())

   817      )

   818   {

   819     src->addSourceReferences(dst);

   820     MemberDef *mdDef = src->memberDefinition();

   821     if (mdDef)

   822     {

   823       mdDef->addSourceReferences(dst);

   824     }

   825     MemberDef *mdDecl = src->memberDeclaration();

   826     if (mdDecl)

   827     {

   828       mdDecl->addSourceReferences(dst);

   829     }

   830   }

   831 

   832 }

   833 

   834 static bool getLinkInScope(const QCString &c,  // scope

   835                            const QCString &m,  // member

   836 			   const char *memberText, // exact text

   837 			   CodeOutputInterface &ol,

   838 			   const char *text

   839 			  )

   840 {

   841   MemberDef    *md;

   842   ClassDef     *cd;

   843   FileDef      *fd;

   844   NamespaceDef *nd;

   845   GroupDef     *gd;

   846   //fprintf(stderr,"getLinkInScope: trying `%s'::`%s'\n",c.data(),m.data());

   847   if (getDefs(c,m,"()",md,cd,fd,nd,gd,FALSE,g_sourceFileDef) && 

   848       md->isLinkable())

   849   {

   850     if (g_exampleBlock)

   851     {

   852       QCString anchor;

   853       anchor.sprintf("a%d",g_anchorCount);

   854       //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),

   855       //                                  g_exampleFile.data());

   856       if (md->addExample(anchor,g_exampleName,g_exampleFile))

   857       {

   858 	ol.writeCodeAnchor(anchor);

   859 	g_anchorCount++;

   860       }

   861     }

   862 

   863     Definition *d = md->getOuterScope()==Doxygen::globalScope ?

   864 	            md->getBodyDef() : md->getOuterScope();

   865     if (md->getGroupDef()) d = md->getGroupDef();

   866     //fprintf(stderr,"d=%p linkable=%d\n",d,d?d->isLinkable():0);

   867     if (d && d->isLinkable())

   868     {

   869       g_theCallContext.setClass(stripClassName(md->typeString()));

   870       //printf("g_currentDefinition=%p g_currentMemberDef=%p g_insideBody=%d\n",

   871       //        g_currentDefinition,g_currentMemberDef,g_insideBody);

   872 

   873       if (g_currentDefinition && g_currentMemberDef &&

   874 	  md!=g_currentMemberDef && g_insideBody)

   875       {

   876 	addDocCrossReference(g_currentMemberDef,md);

   877       }

   878       //printf("d->getReference()=`%s' d->getOutputBase()=`%s' name=`%s' member name=`%s'\n",d->getReference().data(),d->getOutputFileBase().data(),d->name().data(),md->name().data());

   879      

   880       ol.linkableSymbol(g_yyLineNr,md->name(),md,

   881 	                g_currentMemberDef ? g_currentMemberDef : g_currentDefinition);

   882       writeMultiLineCodeLink(ol,md->getReference(),

   883 	                        md->getOutputFileBase(),

   884 	                        md->anchor(),

   885 				text ? text : memberText,

   886 				md->briefDescriptionAsTooltip());

   887       addToSearchIndex(text ? text : memberText);

   888       return TRUE;

   889     } 

   890   }

   891   return FALSE;

   892 }

   893 

   894 static bool getLink(const char *className,

   895                     const char *memberName,

   896 		    CodeOutputInterface &ol,

   897 		    const char *text=0)

   898 {

   899   //printf("getLink(%s,%s) g_curClassName=%s\n",className,memberName,g_curClassName.data());

   900   QCString m=removeRedundantWhiteSpace(memberName);

   901   QCString c=className;

   902   if (!getLinkInScope(c,m,memberName,ol,text))

   903   {

   904     if (!g_curClassName.isEmpty())

   905     {

   906       if (!c.isEmpty()) c.prepend("::");

   907       c.prepend(g_curClassName);

   908       return getLinkInScope(c,m,memberName,ol,text);

   909     }

   910     return FALSE;

   911   }

   912   return TRUE;

   913 }

   914 

   915 static void generateClassOrGlobalLink(CodeOutputInterface &ol,char *clName,

   916                                       bool typeOnly=FALSE)

   917 {

   918   int i=0;

   919   if (*clName=='~') // correct for matching negated values i.s.o. destructors.

   920   {

   921     g_code->codify("~");

   922     clName++;

   923   }

   924   QCString className=clName;

   925   if (className.isEmpty()) return;

   926   if (g_insideProtocolList) // for Obj-C

   927   {

   928     className+="-p";

   929   }

   930   ClassDef *cd=0,*lcd=0;

   931   MemberDef *md=0;

   932   bool isLocal=FALSE;

   933 

   934   //printf("generateClassOrGlobalLink(className=%s)\n",className.data());

   935   if ((lcd=g_theVarContext.findVariable(className))==0) // not a local variable

   936   {

   937     Definition *d = g_currentDefinition;

   938     //printf("d=%p g_sourceFileDef=%p\n",d,g_currentDefinition);

   939     cd = getResolvedClass(d,g_sourceFileDef,className,&md);

   940     //fprintf(stderr,"non-local variable name=%s context=%d cd=%s md=%s!\n",

   941     //	className.data(),g_theVarContext.count(),cd?cd->name().data():"<none>",

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

   943     if (cd==0 && md==0 && (i=className.find('<'))!=-1)

   944     {

   945       QCString bareName = className.left(i); //stripTemplateSpecifiersFromScope(className);

   946       //fprintf(stderr,"bareName=%s\n",bareName.data());

   947       if (bareName!=className)

   948       {

   949 	cd=getResolvedClass(d,g_sourceFileDef,bareName,&md); // try unspecialized version

   950       }

   951     }

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

   953     //fprintf(stderr,"is found as a type %s\n",cd?cd->name().data():"<null>");

   954     if (cd==0 && md==0) // also see if it is variable or enum or enum value

   955     {

   956       if (getLink(g_classScope,clName,ol,clName))

   957       {

   958 	return;

   959       }

   960     }

   961   }

   962   else

   963   {

   964     //printf("local variable!\n");

   965     if (lcd!=VariableContext::dummyContext) 

   966     {

   967       //printf("non-dummy context lcd=%s!\n",lcd->name().data());

   968       g_theCallContext.setClass(lcd);

   969 

   970       // to following is needed for links to a global variable, but is

   971       // no good for a link to a local variable that is also a global symbol.

   972        

   973       //if (getLink(g_classScope,clName,ol,clName))

   974       //{

   975 	//return;

   976       //}

   977     }

   978     isLocal=TRUE;

   979     //fprintf(stderr,"is a local variable cd=%p!\n",cd);

   980   }

   981   if (cd && cd->isLinkable()) // is it a linkable class

   982   {

   983     //fprintf(stderr,"is linkable class %s\n",clName);

   984     if (g_exampleBlock)

   985     {

   986       QCString anchor;

   987       anchor.sprintf("_a%d",g_anchorCount);

   988       //printf("addExampleClass(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),

   989       //                                   g_exampleFile.data());

   990       if (cd->addExample(anchor,g_exampleName,g_exampleFile))

   991       {

   992 	ol.writeCodeAnchor(anchor);

   993 	g_anchorCount++;

   994       }

   995     }

   996     ol.linkableSymbol(g_yyLineNr,cd->name(),cd,

   997                       g_currentMemberDef ? g_currentMemberDef : g_currentDefinition);

   998     writeMultiLineCodeLink(ol,cd->getReference(),cd->getOutputFileBase(),0,clName,cd->briefDescriptionAsTooltip());

   999     addToSearchIndex(className);

  1000     if (md)

  1001     {

  1002       Definition *d = md->getOuterScope()==Doxygen::globalScope ?

  1003                       md->getBodyDef() : md->getOuterScope();

  1004       if (md->getGroupDef()) d = md->getGroupDef();

  1005       if (d && d->isLinkable() && md->isLinkable() && g_currentMemberDef)

  1006       {

  1007         addDocCrossReference(g_currentMemberDef,md);

  1008       }

  1009     }

  1010   }

  1011   else // not a class, maybe a global member

  1012   {

  1013     //fprintf(stderr,"class %s not linkable! cd=%p md=%p typeOnly=%d\n",clName,cd,md,typeOnly);

  1014     if (!isLocal && (md!=0 || (cd==0 && !typeOnly))) // not a class, see if it is a global enum/variable/typedef.

  1015     {

  1016       if (md==0) // not found as a typedef

  1017       {

  1018 	md = setCallContextForVar(clName);

  1019 	//printf("setCallContextForVar(%s) md=%p g_currentDefinition=%p\n",clName,md,g_currentDefinition);

  1020 	if (md && g_currentDefinition)

  1021 	{

  1022 	  //fprintf(stderr,"%s accessible from %s? %d md->getOuterScope=%s\n",

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

  1024 	  //    isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md),

  1025 	  //    md->getOuterScope()->name().data());

  1026 	}

  1027 	     

  1028         if (md && g_currentDefinition && 

  1029 	    isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md)==-1)

  1030 	{

  1031 	  md=0; // variable not accessible

  1032 	}

  1033       }

  1034       if (md)

  1035       {

  1036         //fprintf(stderr,"is a global md=%p g_currentDefinition=%s linkable=%d\n",md,g_currentDefinition?g_currentDefinition->name().data():"<none>",md->isLinkable());

  1037 	if (md->isLinkable())

  1038 	{

  1039           ol.linkableSymbol(g_yyLineNr,md->name(),md,

  1040 	                    g_currentMemberDef ? g_currentMemberDef : g_currentDefinition);

  1041 	  writeMultiLineCodeLink(ol,md->getReference(),md->getOutputFileBase(),md->anchor(),clName,md->briefDescriptionAsTooltip());

  1042           addToSearchIndex(clName);

  1043 	  if (g_currentMemberDef)

  1044 	  {

  1045 	    addDocCrossReference(g_currentMemberDef,md);

  1046 	  }

  1047 	  return;

  1048 	}

  1049       }

  1050     }

  1051     

  1052     // nothing found, just write out the word

  1053     //fprintf(stderr,"not found!\n");

  1054     ol.linkableSymbol(g_yyLineNr,clName,0,

  1055 	              g_currentMemberDef?g_currentMemberDef:g_currentDefinition);

  1056     codifyLines(clName);

  1057     addToSearchIndex(clName);

  1058   }

  1059 }

  1060 

  1061 static bool generateClassMemberLink(CodeOutputInterface &ol,MemberDef *xmd,const char *memName)

  1062 {

  1063   // extract class definition of the return type in order to resolve

  1064   // a->b()->c() like call chains

  1065 

  1066   //printf("type=`%s' args=`%s' class=%s\n",

  1067   //  xmd->typeString(),xmd->argsString(),

  1068   //  xmd->getClassDef()->name().data());

  1069 

  1070   if (g_exampleBlock)

  1071   {

  1072     QCString anchor;

  1073     anchor.sprintf("a%d",g_anchorCount);

  1074     //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),

  1075     //                                  g_exampleFile.data());

  1076     if (xmd->addExample(anchor,g_exampleName,g_exampleFile))

  1077     {

  1078       ol.writeCodeAnchor(anchor);

  1079       g_anchorCount++;

  1080     }

  1081   }

  1082 

  1083   ClassDef *typeClass = stripClassName(removeAnonymousScopes(xmd->typeString()));

  1084   //fprintf(stderr,"%s -> typeName=%p\n",xmd->typeString(),typeClass);

  1085   g_theCallContext.setClass(typeClass);

  1086 

  1087   Definition *xd = xmd->getOuterScope()==Doxygen::globalScope ?

  1088     xmd->getBodyDef() : xmd->getOuterScope();

  1089   if (xmd->getGroupDef()) xd = xmd->getGroupDef();

  1090   if (xd && xd->isLinkable())

  1091   {

  1092 

  1093     //printf("g_currentDefiniton=%p g_currentMemberDef=%p xmd=%p g_insideBody=%d\n",g_currentDefinition,g_currentMemberDef,xmd,g_insideBody);

  1094 

  1095     if (xmd->templateMaster()) xmd = xmd->templateMaster();

  1096 

  1097     if (xmd->isLinkable())

  1098     {

  1099       // add usage reference

  1100       if (g_currentDefinition && g_currentMemberDef &&

  1101 	  /*xmd!=g_currentMemberDef &&*/ g_insideBody)

  1102       {

  1103 	addDocCrossReference(g_currentMemberDef,xmd);

  1104       }

  1105 

  1106       // write the actual link

  1107       ol.linkableSymbol(g_yyLineNr,xmd->name(),xmd,

  1108 	  g_currentMemberDef ? g_currentMemberDef : g_currentDefinition);

  1109       writeMultiLineCodeLink(ol,xmd->getReference(),

  1110 	  xmd->getOutputFileBase(),xmd->anchor(),memName,xmd->briefDescriptionAsTooltip());

  1111       addToSearchIndex(memName);

  1112       return TRUE;

  1113     }

  1114   }

  1115 

  1116   return FALSE;

  1117 }

  1118 

  1119 static bool generateClassMemberLink(CodeOutputInterface &ol,ClassDef *mcd,const char *memName)

  1120 {

  1121   if (mcd)

  1122   {

  1123     MemberDef *xmd = mcd->getMemberByName(memName);

  1124     //printf("generateClassMemberLink(class=%s,member=%s)=%p\n",mcd->name().data(),memName,xmd);

  1125     if (xmd)

  1126     {

  1127       return generateClassMemberLink(ol,xmd,memName);

  1128     }

  1129   }

  1130   

  1131   return FALSE;

  1132 }

  1133 

  1134 static void generateMemberLink(CodeOutputInterface &ol,const QCString &varName,