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

 *

 * 

 *

 *

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

 *

 */

%{

/*

 *	includes

 */

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <qregexp.h>

#include <qdir.h>

#include "qtbc.h"

#include "entry.h"

#include "doxygen.h"

#include "message.h"

#include "outputlist.h"

#include "util.h"

#include "membername.h"

#include "searchindex.h"

#define YY_NEVER_INTERACTIVE 1

// Toggle for some debugging info

//#define DBG_CTX(x) fprintf x

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

#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 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 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_memCallContext;

static int	     g_lastCContext;

static bool          g_insideObjC;

static bool          g_insideProtocolList;

static bool          g_lexInit = FALSE;

static QStack<int>   g_classScopeLengthStack;

// context for an Objective-C method call

struct ObjCCallCtx

{

  int id;

  QCString methodName;

  QCString objectTypeOrName;

  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 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 int g_braceCount=0;

static void saveObjCContext();

static void restoreObjCContext();

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

/*! 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))

	 ) && // 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), cd(0) {}

      QCString name;

      QCString type;

      ClassDef *cd;

    };

    CallContext() 

    {

      m_classList.append(new Ctx);

      m_classList.setAutoDelete(TRUE);

    }

    virtual ~CallContext() {}

    void setClass(ClassDef *cd)

    {

      Ctx *ctx = m_classList.getLast();

      if (ctx)

      {

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

        ctx->cd=cd;

      }

    }

    void pushScope()

    {

      m_classList.append(new Ctx);

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

    }

    void popScope()

    {

      if (m_classList.count()>1)

      {

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

	Ctx *ctx = m_classList.getLast();

	if (ctx)

	{

	  g_name = ctx->name;

	  g_type = ctx->type;

	}

	m_classList.removeLast();

      }

      else

      {

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

      }

    }

    void clear()

    {

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

      m_classList.clear();

      m_classList.append(new Ctx);

    }

    ClassDef *getClass() const

    {

      Ctx *ctx = m_classList.getLast();

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

    }

  private:

    QList<Ctx> m_classList;    

};

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())

  {

    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("Error: Too many end of scopes found!\n");

  }

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

}

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

{

  if (Doxygen::searchIndex)

  {

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

  }

}

static void addToSearchIndex(const char *text)

{

  if (Doxygen::searchIndex)

  {

    Doxygen::searchIndex->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);

    if (!g_includeCodeFragment && d)

    {

      g_currentDefinition = d;

      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

      g_insideBody = FALSE;

      g_searchingForBody = TRUE;

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

      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(

                                g_currentMemberDef->qualifiedName(),

	                        g_sourceFileDef->getSourceFileBase(),

	                        lineAnchor);

      }

      else if (d->isLinkableInProject())

      {

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

	                        d->getOutputFileBase(),

	                        0,g_yyLineNr);

        setCurrentDoc(

                                d->qualifiedName(),

	                        g_sourceFileDef->getSourceFileBase(),

	                        lineAnchor);

      }

    }

    else

    {

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

    }

  }

  g_code->startCodeLine(); 

  if (g_currentFontClass)

  {

    g_code->startFontClass(g_currentFontClass);

  }

}

static void endFontClass();

static void startFontClass(const char *s);

static void endCodeLine()

{

  endFontClass();

  g_code->endCodeLine();

}

static void nextCodeLine()