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

 *

 * 

 *

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

 *

 */

/*  This code is based on the work done by the MoxyPyDoxy team

 *  (Linda Leong, Mike Rivera, Kim Truong, and Gabriel Estrada)

 *  in Spring 2005 as part of CS 179E: Compiler Design Project

 *  at the University of California, Riverside; the course was

 *  taught by Peter H. Froehlich <phf@acm.org>.

 */

%{

#include <stdio.h>

#include <qvaluestack.h>

#include "pycode.h"

#include "message.h"

#include "scanner.h"

#include "entry.h"

#include "doxygen.h"

#include "outputlist.h"

#include "util.h"

#include "membername.h"

#include "searchindex.h"

#define YY_NEVER_INTERACTIVE 1

static ClassSDict    g_codeClassSDict(17);

static QCString      g_curClassName;

static QStrList      g_curClassBases;

static CodeOutputInterface * g_code;

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

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

static const char *  g_currentFontClass;

static bool          g_needsTermination;

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

static int	     g_yyLineNr;        //!< current line number

static FileDef *     g_sourceFileDef;

static Definition *  g_currentDefinition;

static MemberDef *   g_currentMemberDef;

static bool          g_includeCodeFragment;

static QCString      g_realScope;

static bool          g_insideBody;

static int           g_bodyCurlyCount;

static bool          g_searchingForBody;

static QCString      g_classScope;

static int           g_paramParens;

//static int           g_anchorCount;

static bool          g_exampleBlock;

static QCString      g_exampleName;

static QCString      g_exampleFile;

static QCString      g_type;

static QCString      g_name;

static bool          g_doubleStringIsDoc;

static bool          g_doubleQuote;

static bool          g_noSuiteFound;

static int           g_stringContext;

static QValueStack<uint> g_indents;  //!< Tracks indentation levels for scoping in python

static void endFontClass();

static void adjustScopesAndSuites(unsigned indentLength);

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

{

  public:

    static const ClassDef *dummyContext;    

    class Scope : public SDict<ClassDef> 

    {

      public:

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

    };

    PyVariableContext() 

    {

      m_scopes.setAutoDelete(TRUE);

    }

    virtual ~PyVariableContext() 

    {

    }

    void pushScope() 

    {

      m_scopes.append(new Scope);

    }

    void popScope() 

    {

      if (m_scopes.count()>0) 

      {

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

      }

    }

    void clear() 

    {

      m_scopes.clear();

      m_globalScope.clear();

    }

    void clearExceptGlobal() 

    {

      m_scopes.clear();

    }

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

    ClassDef *findVariable(const QCString &name);

  private:

    Scope        m_globalScope;

    QList<Scope> m_scopes;

};

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

{

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

  QCString ltype = type.simplifyWhiteSpace();

  QCString lname = name.simplifyWhiteSpace();

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

  ClassDef *varType;

  if (

      (varType=g_codeClassSDict[ltype]) ||  // look for class definitions inside the code block

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

     ) 

  {

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

  }

  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!

    {

      scope->append(lname,dummyContext);

    }

  }

}

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

{

  if (name.isEmpty()) return 0;

  ClassDef *result = 0;

  QListIterator<Scope> sli(m_scopes);

  Scope *scope;

  // search from inner to outer scope

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

  {

    result = scope->find(name);

    if (result) 

    {

      return result;

    }

  }

  // nothing found -> also try the global scope

  result=m_globalScope.find(name);

  return result;

}

static PyVariableContext g_theVarContext;

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

class PyCallContext

{

  public:

    struct Ctx

    {

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

      QCString name;

      QCString type;

      ClassDef *cd;

    };

    PyCallContext() 

    {

      m_classList.append(new Ctx);

      m_classList.setAutoDelete(TRUE);

    }

    virtual ~PyCallContext() {}

    void setClass(ClassDef *cd)

    {

      Ctx *ctx = m_classList.getLast();

      if (ctx) 

      {

        ctx->cd=cd;

      }

    }

    void pushScope()

    {

      m_classList.append(new Ctx);

    }

    void popScope()

    {

      if (m_classList.count()>1)

      {

	Ctx *ctx = m_classList.getLast();

	if (ctx)

	{

	  g_name = ctx->name;

	  g_type = ctx->type;

	}

	m_classList.removeLast();

      }

      else

      {

      }

    }

    void clear()

    {

      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 PyCallContext g_theCallContext;

/*! counts the number of lines in the input */

static int countLines()

{

  const char *p=g_inputString;

  char c;

  int count=1;

  while ((c=*p)) 

  { 

    p++ ; 

    if (c=='\n') count++;  

  }

  if (p>g_inputString && *(p-1)!='\n') 

  { // last line does not end with a \n, so we add an extra

    // line and explicitly terminate the line after parsing.

    count++, 

    g_needsTermination=TRUE; 

  } 

  return count;

}

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 ClassDef *stripClassName(const char *s)

{

  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(g_currentDefinition,g_sourceFileDef,g_classScope+"::"+clName);

    }

    if (cd==0)

    {

      cd=getResolvedClass(g_currentDefinition,g_sourceFileDef,clName);

    }

    if (cd)

    {

      return cd;

    }

  }

  return 0;

}

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

  {

    //QCString lineNumber,lineAnchor;

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

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

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

    //printf("startCodeLine %d d=%p\n",g_yyLineNr,d);

    //g_code->startLineNumber();

    if (!g_includeCodeFragment && d && d->isLinkableInProject())

    {

      g_currentDefinition = d;

      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

      g_insideBody = FALSE;

      g_searchingForBody = TRUE;

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

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

      //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

      {

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

	                        d->getOutputFileBase(),

	                        0,g_yyLineNr);

        setCurrentDoc(

                                d->qualifiedName(),

	                        g_sourceFileDef->getSourceFileBase(),

	                        lineAnchor);

      }

    }

    else

    {

      //g_code->codify(lineNumber);

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

    }

    //g_code->endLineNumber();

  }

  g_code->startCodeLine(); 

  if (g_currentFontClass)

  {

    g_code->startFontClass(g_currentFontClass);

  }

}

static void codify(const char* text) 

{ 

  g_code->codify(text);

}

static void endCodeLine()

{

  endFontClass();

  g_code->endCodeLine();

}

static void nextCodeLine()

{

  const char *fc = g_currentFontClass;

  endCodeLine();

  if (g_yyLineNr<g_inputLines) 

  {

    g_currentFontClass = fc;

    startCodeLine();

  }

}

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

                  const char *ref,const char *file,

                  const char *anchor,const char *text,

                  const char *tooltip)

{

  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 codifyLines(char *text)

{

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

  char *p=text,*sp=p;

  char c;

  bool done=FALSE;

  while (!done)

  {

    sp=p;

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

    if (c=='\n')

    {

      g_yyLineNr++;

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

      g_code->codify(sp);

      nextCodeLine();

    }

    else

    {

      g_code->codify(sp);

      done=TRUE;

    }

  }

}

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

{

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

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

  if ((Config_getBool("REFERENCED_BY_RELATION") || Config_getBool("CALLER_GRAPH")) && 

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

     )

  {

    dst->addSourceReferencedBy(src);

  }

  if ((Config_getBool("REFERENCES_RELATION") || Config_getBool("CALL_GRAPH")) && 

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

     )

  {

    src->addSourceReferences(dst);

  }

}

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

                           const QCString &m,  // member

			   const char *memberText, // exact text

			   CodeOutputInterface &ol,

			   const char *text

			  )

{

  MemberDef    *md;

  ClassDef     *cd;

  FileDef      *fd;

  NamespaceDef *nd;

  GroupDef     *gd;

  //printf("Trying `%s'::`%s'\n",c.data(),m.data());

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

      md->isLinkable())

  {

    //printf("Found!\n");

    //Definition *d=0;

    //if (cd) d=cd; else if (nd) d=nd; else if (fd) d=fd; else d=gd;

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

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

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

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

    {

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

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

      //        g_currentDefinition,g_currentMemberDef,g_insideBody);

      if (g_currentDefinition && g_currentMemberDef &&

	  md!=g_currentMemberDef && g_insideBody)

      {

	addDocCrossReference(g_currentMemberDef,md);

      }