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

 *

 * 

 *

 * Copyright (C) 1997-2015 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.

 *

 */

%option never-interactive

%option prefix="codeYY"

%{

/*

 *	includes

 */

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <qregexp.h>

#include <qdir.h>

#include "entry.h"

#include "doxygen.h"

#include "message.h"

#include "outputlist.h"

#include "util.h"

#include "membername.h"

#include "searchindex.h"

#include "arguments.h"

#include "config.h"

#include "groupdef.h"

#include "classlist.h"

#include "filedef.h"

#include "filename.h"

#include "namespacedef.h"

#include "tooltip.h"

// Toggle for some debugging info

//#define DBG_CTX(x) fprintf x

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

#define YY_NO_UNISTD_H 1

#define CLASSBLOCK (int *)4

#define SCOPEBLOCK (int *)8

#define INNERBLOCK (int *)12

/* -----------------------------------------------------------------

 *	statics

 */

static CodeOutputInterface * g_code;

static ClassSDict    *g_codeClassSDict = 0;

static QCString      g_curClassName;

static QStrList      g_curClassBases;

static QCString      g_parmType;

static QCString      g_parmName;

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

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

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

static int	     g_yyLineNr;        //!< current line number

static int	     g_yyColNr;         //!< current column number

static bool          g_needsTermination;

static bool          g_exampleBlock;

static QCString      g_exampleName;

static QCString      g_exampleFile;

static bool          g_insideTemplate = FALSE;

static QCString      g_type;

static QCString      g_name;

static QCString      g_args;

static QCString      g_classScope;

static QCString      g_realScope;

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

                                        //   2 for internal blocks 

static int           g_anchorCount;

static FileDef *     g_sourceFileDef;

static bool          g_lineNumbers;

static Definition *  g_currentDefinition;

static MemberDef *   g_currentMemberDef;

static bool          g_includeCodeFragment;

static const char *  g_currentFontClass;

static bool          g_searchingForBody;

static bool          g_insideBody;

static int           g_bodyCurlyCount;

static QCString      g_saveName;

static QCString      g_saveType;

static QCString      g_delimiter;

static int	     g_bracketCount = 0;

static int	     g_curlyCount   = 0;

static int	     g_sharpCount   = 0;

static bool          g_inFunctionTryBlock = FALSE;

static bool          g_inForEachExpression = FALSE;

static int           g_lastTemplCastContext;

static int	     g_lastSpecialCContext;

static int           g_lastStringContext;

static int           g_lastSkipCppContext;

static int           g_lastVerbStringContext;

static int           g_lastObjCCallContext;

static int           g_memCallContext;

static int	     g_lastCContext;

static int           g_skipInlineInitContext;

static bool          g_insideObjC;

static bool          g_insideJava;

static bool          g_insideCS;

static bool          g_insidePHP;

static bool          g_insideProtocolList;

static bool          g_lexInit = FALSE;

static QStack<int>   g_classScopeLengthStack;

static int           g_prefixed_with_this_keyword = FALSE;

static Definition   *g_searchCtx;

static bool          g_collectXRefs;

// context for an Objective-C method call

struct ObjCCallCtx

{

  int id;

  QCString methodName;

  QCString objectTypeOrName;

  QGString comment;

  ClassDef *objectType;

  MemberDef *objectVar;

  MemberDef *method;

  QCString format;

  int lexState;

  int braceCount;

};

// globals for objective-C method calls 

static ObjCCallCtx *g_currentCtx=0;

static int g_currentCtxId=0;

static int g_currentNameId=0;

static int g_currentObjId=0;

static int g_currentWordId=0;

static int g_currentCommentId=0;

static QStack<ObjCCallCtx> g_contextStack;

static QIntDict<ObjCCallCtx> g_contextDict;

static QIntDict<QCString> g_nameDict;

static QIntDict<QCString> g_objectDict;

static QIntDict<QCString> g_wordDict;

static QIntDict<QCString> g_commentDict;

static int g_braceCount=0;

static void saveObjCContext();

static void restoreObjCContext();

static QCString g_forceTagReference;

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

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

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

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

 *  for variable using findVariable().

 */

class VariableContext

{

  public:

    static const ClassDef *dummyContext;

    class Scope : public SDict<ClassDef>

    {

      public:

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

    };

    VariableContext() 

    {

      m_scopes.setAutoDelete(TRUE);

    }

    virtual ~VariableContext()

    {

    }

    void pushScope()

    {

      m_scopes.append(new Scope);

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

    }

    void popScope()

    {

      if (m_scopes.count()>0)

      {

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

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

      }

      else

      {

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

      }

    }

    void clear()

    {

      m_scopes.clear();

      m_globalScope.clear();

    }

    void clearExceptGlobal()

    {

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

      m_scopes.clear();

    }

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

    ClassDef *findVariable(const QCString &name);

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

  private:

    Scope        m_globalScope;

    QList<Scope> m_scopes;

};

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

{

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

  QCString ltype = type.simplifyWhiteSpace();

  QCString lname = name.simplifyWhiteSpace();

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

  {

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

  }

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

  {

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

  }

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

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

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

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

  ClassDef *varType;

  int i=0;

  if (

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

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

     ) 

  {

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

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

  }

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

  {

    // probably a template class

    QCString typeName(ltype.left(i));

    ClassDef* newDef = 0;

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

    if (  

         ( // look for class definitions inside the code block

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

           // otherwise look for global class definitions

           (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,typeName,0,0,TRUE,TRUE))

	 ) && // and it must be a template

         varType->templateArguments())

    {

      newDef = varType->getVariableInstance( templateArgs );

    }

    if (newDef)

    {

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

      scope->append(lname, newDef);

    }

    else

    {

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

      addVariable(typeName,name);

    }

  }

  else 

  {

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

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

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

    {

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

      scope->append(lname,dummyContext);

    }

    else

    {

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

    }

  }

}

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

{

  if (name.isEmpty()) return 0;

  ClassDef *result = 0;

  QListIterator<Scope> sli(m_scopes);

  Scope *scope;

  QCString key = name;

  // search from inner to outer scope

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

  {

    result = scope->find(key);

    if (result)

    {

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

      return result;

    }

  }

  // nothing found -> also try the global scope

  result=m_globalScope.find(name);

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

  return result;

}

static VariableContext g_theVarContext;

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

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

class CallContext

{

  public:

    struct Ctx

    {

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

      QCString name;

      QCString type;

      Definition *d;

    };

    CallContext() 

    {

      m_defList.append(new Ctx);

      m_defList.setAutoDelete(TRUE);

    }

    virtual ~CallContext() {}

    void setScope(Definition *d)

    {

      Ctx *ctx = m_defList.getLast();

      if (ctx)

      {

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

        ctx->d=d;

      }

    }

    void pushScope()

    {

      m_defList.append(new Ctx);

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

    }

    void popScope()

    {

      if (m_defList.count()>1)

      {

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

	Ctx *ctx = m_defList.getLast();

	if (ctx)

	{

	  g_name = ctx->name;

	  g_type = ctx->type;

	}

	m_defList.removeLast();

      }

      else

      {

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

      }

    }

    void clear()

    {

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

      m_defList.clear();

      m_defList.append(new Ctx);

    }

    Definition *getScope() const

    {

      Ctx *ctx = m_defList.getLast();

      if (ctx) return ctx->d; else return 0;

    }

  private:

    QList<Ctx> m_defList;

};

static CallContext g_theCallContext;

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

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

static void pushScope(const char *s)

{

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

  if (g_classScope.isEmpty() || leftScopeMatch(s,g_classScope))

  {

    g_classScope = s;

  }

  else

  {

    g_classScope += "::";

    g_classScope += s;

  }

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

}

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

static void popScope()

{

  if (!g_classScopeLengthStack.isEmpty())

  {

    int *pLength = g_classScopeLengthStack.pop();

    g_classScope.truncate(*pLength);

    delete pLength;

  }

  else

  {

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

  }

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

}

static void setCurrentDoc(const QCString &anchor)

{

  if (Doxygen::searchIndex)

  {

    if (g_searchCtx)

    {

      g_code->setCurrentDoc(g_searchCtx,g_searchCtx->anchor(),FALSE);

    }

    else

    {

      g_code->setCurrentDoc(g_sourceFileDef,anchor,TRUE);

    }

  }

}

static void addToSearchIndex(const char *text)

{

  if (Doxygen::searchIndex)

  {

    g_code->addWord(text,FALSE);

  }

}

static void setClassScope(const QCString &name)

{

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

  QCString n=name;

  n=n.simplifyWhiteSpace();

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

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

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

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

  {

    // remove template from scope

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

  }

  while (!g_classScopeLengthStack.isEmpty())

  {

    popScope();

  }

  g_classScope.resize(0);

  int i;

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

  {

    pushScope(n.left(i));

    n = n.mid(i+2);

  }

  pushScope(n);

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

}

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

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

 * number is linked to the documentation of that definition.

 */

static void startCodeLine()

{

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

  if (g_sourceFileDef && g_lineNumbers)

  {

    //QCString lineNumber,lineAnchor;

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

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

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

    //printf("%s:startCodeLine(%d)=%p\n",g_sourceFileDef->name().data(),g_yyLineNr,d);

    if (!g_includeCodeFragment && d)

    {

      g_currentDefinition = d;

      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

      g_insideBody = FALSE;

      g_searchingForBody = TRUE;

      g_realScope = d->name();

      //g_classScope = "";

      g_type.resize(0);

      g_name.resize(0);

      g_args.resize(0);

      g_parmType.resize(0);

      g_parmName.resize(0);

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

      g_bodyCurlyCount = 0;

      QCString lineAnchor;

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

      if (g_currentMemberDef)

      {

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

	                        g_currentMemberDef->getOutputFileBase(),

	                        g_currentMemberDef->anchor(),g_yyLineNr);

        setCurrentDoc(lineAnchor);

      }

      else if (d->isLinkableInProject())

      {

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

	                        d->getOutputFileBase(),

	                        0,g_yyLineNr);

        setCurrentDoc(lineAnchor);

      }

    }

    else

    {

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

    }

  }

  DBG_CTX((stderr,"startCodeLine(%d)\n",g_yyLineNr));

  g_code->startCodeLine(g_sourceFileDef && g_lineNumbers); 

  if (g_currentFontClass)

  {

    g_code->startFontClass(g_currentFontClass);

  }

}

static void endFontClass();

static void startFontClass(const char *s);

static void endCodeLine()

{

  DBG_CTX((stderr,"endCodeLine(%d)\n",g_yyLineNr));

  endFontClass();

  g_code->endCodeLine();

}

static void nextCodeLine()

{

  const char * fc = g_currentFontClass;

  endCodeLine();

  if (g_yyLineNr

  {

    g_currentFontClass = fc;

    startCodeLine();

  }

}

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

 * line numbers for each line.

 */

static void codifyLines(const char *text)

{

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

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

  char c;

  bool done=FALSE;

  while (!done)

  {

    sp=p;

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

    if (c=='\n')

    {

      g_yyLineNr++;

      g_yyColNr=1;

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

      int l = (int)(p-sp-1);

      char *tmp = (char*)malloc(l+1);

      memcpy(tmp,sp,l);

      tmp[l]='\0';

      g_code->codify(tmp);

      free(tmp);

      nextCodeLine();

    }

    else

    {

      g_code->codify(sp);

      done=TRUE;

    }

  }

}

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

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

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

 */

static void writeMultiLineCodeLink(CodeOutputInterface &ol,

                                   Definition *d,

                                   const char *text)

{

  static bool sourceTooltips = Config_getBool(SOURCE_TOOLTIPS);

  TooltipManager::instance()->addTooltip(d);

  QCString ref  = d->getReference();

  QCString file = d->getOutputFileBase();

  QCString anchor = d->anchor();

  QCString tooltip; 

  if (!sourceTooltips) // fall back to simple "title" tooltips

  {

    tooltip = d->briefDescriptionAsTooltip();

  }

  bool done=FALSE;

  char *p=(char *)text;

  while (!done)

  {

    char *sp=p;

    char c;

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

    if (c=='\n')

    {

      g_yyLineNr++;

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

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

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

      nextCodeLine();

    }

    else

    {

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

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

      done=TRUE;

    }

  }

}

static void addType()

{

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

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

  g_type += g_name ;

  g_name.resize(0) ;

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

  g_type += g_args ;

  g_args.resize(0) ;

}

static void addParmType()

{

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

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

  g_parmType += g_parmName ;

  g_parmName.resize(0) ;

}

static void addUsingDirective(const char *name)

{

  if (g_sourceFileDef && name)

  {

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

    if (nd)

    {

      g_sourceFileDef->addUsingDirective(nd);

    }

  }

}

static void setParameterList(MemberDef *md)

{

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

  ArgumentList *al = md->argumentList();

  if (al==0) return;

  ArgumentListIterator it(*al);

  Argument *a;

  for (;(a=it.current());++it)

  {

    g_parmName = a->name.copy();

    g_parmType = a->type.copy();

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

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

    i = g_parmType.find('&';;

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

    g_parmType.stripPrefix("const ");

    g_parmType=g_parmType.stripWhiteSpace();

    g_theVarContext.addVariable(g_parmType,g_parmName);

  }

}

static ClassDef *stripClassName(const char *s,Definition *d=g_currentDefinition)

{

  int pos=0;

  QCString type = s;

  QCString className;

  QCString templSpec;

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

  {

    QCString clName=className+templSpec;

    ClassDef *cd=0;

    if (!g_classScope.isEmpty())

    {

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

    }

    if (cd==0)

    {

      cd=getResolvedClass(d,g_sourceFileDef,clName);

    }

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

    if (cd)

    {

      return cd;

    }

  }

  return 0;

}

static MemberDef *setCallContextForVar(const QCString &name)

{

  if (name.isEmpty()) return 0;

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

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

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

  {

    QCString scope   = name.left(scopeEnd);

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

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

    ClassDef *mcd = getClass(scope); 

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

    {

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

      if (md)

      {

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

        g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));

        return md;

      }

    }

    else // check namespace as well

    {

      NamespaceDef *mnd = getResolvedNamespace(scope);

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

      {

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

	if (md)

	{

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

	  g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));

	  return md;

	}

      }

    }

  }

  MemberName *mn;

  ClassDef *mcd = g_theVarContext.findVariable(name);

  if (mcd) // local variable

  {

    DBG_CTX((stderr,"local variable?\n"));

    if (mcd!=VariableContext::dummyContext)

    {

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

      g_theCallContext.setScope(mcd);

    }

  }

  else

  {

    DBG_CTX((stderr,"class member? scope=%s\n",g_classScope.data()));

    // look for a class member 

    mcd = getClass(g_classScope);

    if (mcd)

    {

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

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

      if (md) 

      {

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

	if (g_scopeStack.top()!=CLASSBLOCK)

	{

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

	  g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));

	}

	return md;

      }

    }

  }

  // look for a global member

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

  {

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

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

    {

      MemberDef *md=mn->getFirst();

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

      {

        g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));

        return md;

      }

      return 0;

    }

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

    {

      MemberNameIterator it(*mn);

      MemberDef *md;

      for (;(md=it.current());++it)

      {

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

	//    mn,md,

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

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

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

	// defined as external.

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

	    (g_forceTagReference.isEmpty() || g_forceTagReference==md->getReference())

	   )

        {

          g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));

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

          return md;

        }

      }

      return 0;

    }

  }

  return 0;

}

static void updateCallContextForSmartPointer()

{

  Definition *d = g_theCallContext.getScope();

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

  MemberDef *md;

  if (d && d->definitionType()==Definition::TypeClass && (md=((ClassDef*)d)->isSmartPointer()))

  {

    ClassDef *ncd = stripClassName(md->typeString(),md->getOuterScope());

    if (ncd)

    {

      g_theCallContext.setScope(ncd);

      //printf("Found smart pointer call %s->%s!\n",cd->name().data(),ncd->name().data());

    }

  }

}

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

                           const QCString &m,  // member

			   const char *memberText, // exact text

			   CodeOutputInterface &ol,

			   const char *text,

			   bool varOnly=FALSE

			  )

{

  MemberDef    *md;

  ClassDef     *cd;

  FileDef      *fd;

  NamespaceDef *nd;

  GroupDef     *gd;

  DBG_CTX((stderr,"getLinkInScope: trying `%s'::`%s' varOnly=%d\n",c.data(),m.data(),varOnly));

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

      (!varOnly || md->isVariable()))

  {

    if (md->isLinkable())

    {

      //printf("found it %s!\n",md->qualifiedName().data());

      if (g_exampleBlock)

      {

        QCString anchor;

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

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

        //                                  g_exampleFile.data());

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

        {