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

 *

 * Parser for syntax hightlighting and references for Fortran90 F subset

 *

 * Copyright (C) by Anke Visser

 * based on the work of 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.

 *

 */

/**

 @todo - continutation lines not always recognized

       - merging of use-statements with same module name and different only-names

       - rename part of use-statement

       - links to interface functions 

       - references to variables

**/

%{

/*

 *	includes

 */

#include "qtbc.h"

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <qregexp.h>

#include <qdir.h>

#include <qstringlist.h>

#include "entry.h"

#include "doxygen.h"

#include "message.h"

#include "outputlist.h"

#include "util.h"

#include "membername.h"

#include "searchindex.h"

#include "defargs.h"

#define YY_NEVER_INTERACTIVE 1

#define YY_NO_TOP_STATE 1

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

/**

  data of an use-statement

*/

class UseEntry 

{

 public: 

   QCString module; // just for debug

   QStringList onlyNames;   /* entries of the ONLY-part */

};

/**

  module name -> list of ONLY/remote entries

  (module name = name of the module, which can be accessed via use-directive)

*/

class UseSDict : public SDict<UseEntry> 

{

  public:

    UseSDict() : SDict<UseEntry>(17) {}

};

/**

  Contains names of used modules and names of local variables.

*/

class Scope 

{

  public:

    QStringList useNames; //!< contains names of used modules

    QDict<void> localVars; //!< contains names of local variables

    Scope() : localVars(7, FALSE /*caseSensitive*/) {}

};

/*===================================================================*/

/* 

 *	statics

 */

static QCString  docBlock;                   //!< contents of all lines of a documentation block

static QCString  currentModule=0;            //!< name of the current enclosing module

static UseSDict  *useMembers= new UseSDict;  //!< info about used modules

static UseEntry  *useEntry = 0;              //!< current use statement info

static QList<Scope> scopeStack;

// static QStringList *currentUseNames= new QStringList; //! contains names of used modules of current program unit

static QCString str="";         //!> contents of fortran string

static CodeOutputInterface * g_code;

// TODO: is this still needed? if so, make it work

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_isFixedForm;

static bool          g_insideBody;      //!< inside subprog/program body? => create links

static const char *  g_currentFontClass;

static bool          g_exampleBlock;

static QCString      g_exampleName;

static QCString      g_exampleFile;

static FileDef *     g_sourceFileDef;

static Definition *  g_currentDefinition;

static MemberDef *   g_currentMemberDef;

static bool          g_includeCodeFragment;

static char          stringStartSymbol; // single or double quote

// count in variable declaration to filter out

//  declared from referenced names

static int 	     bracketCount = 0; 

// simplified way to know if this is fixed form

// duplicate in fortranscanner.l

static bool recognizeFixedForm(const char* contents)

{

  int column=0;

  bool skipLine=FALSE;

  for (int i=0;;i++) 

  {

    column++;

    switch(contents[i]) 

    {

      case '\n':

        column=0;

        skipLine=FALSE;

        break;

      case ' ':

        break;

      case '\000':

        return FALSE;

      case 'C':

      case 'c':

      case '*':

        if(column==1) return TRUE;

        if(skipLine) break;

        return FALSE;

      case '!':

        if(column>1 && column<7) return FALSE;

        skipLine=TRUE;

        break;

      default:

        if(skipLine) break;

        if(column==7) return TRUE;

        return FALSE;

    }

  }

  return FALSE;

}

static void endFontClass()

{

  if (g_currentFontClass)

  {

    g_code->endFontClass();

    g_currentFontClass=0;

  }

}

static void startFontClass(const char *s)

{

  endFontClass();

  g_code->startFontClass(s);

  g_currentFontClass=s;

}

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

  }

}

/*! 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_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=%s\n", g_yyLineNr,d ? d->name().data() : "<null>");

    if (!g_includeCodeFragment && d)

    {

      g_currentDefinition = d;

      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);

      g_insideBody = FALSE;

      g_parmType.resize(0);

      g_parmName.resize(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 endCodeLine()

{

  endFontClass();

  g_code->endCodeLine();

}

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

 * line numbers for each line.

 */

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

      endCodeLine();

      if (g_yyLineNr<g_inputLines) 

      {

	startCodeLine();

      }

    }

    else

    {

      g_code->codify(sp);

      done=TRUE;

    }

  }

}

static void codifyLines(QCString str)

{

  char *tmp= (char *) malloc(str.length()+1);

  strcpy(tmp, str);

  codifyLines(tmp);

  free(tmp);

}

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

{

  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,0);

      endCodeLine();

      if (g_yyLineNr<g_inputLines) 

      {

	startCodeLine();

      }

    }

    else

    {

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

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

      done=TRUE;

    }

  }

}

/**

  generates dictionay entries that are used if REFERENCED_BY_RELATION ... options are set

  (e.g. the "referenced by ..." list after the function documentation) 

*/

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

  {

    dst->addSourceReferencedBy(src);

  }

  if ((Config_getBool("REFERENCES_RELATION") || Config_getBool("CALL_GRAPH")) && (src->isFunction()))

  {

    src->addSourceReferences(dst);

  }

}

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

/**

  searches for definition of a type

  @param tname the name of the type

  @param moduleName name of enclosing module or null, if global entry

  @param cd the entry, if found or null

  @param useDict dictionary of data of USE-statement

  @returns true, if type is found 

*/

static bool getFortranTypeDefs(const QCString &tname, const QCString &moduleName, 

                               ClassDef *&cd, UseSDict *usedict=0)

{

  if (tname.isEmpty()) return FALSE; /* empty name => nothing to link */

  //cout << "=== search for type: " << tname << endl;

  // search for type  

  if ((cd=Doxygen::classSDict->find(tname))) 

  {

    //cout << "=== type found in global module" << endl;

    return TRUE;

  }

  else if (moduleName && (cd= Doxygen::classSDict->find(moduleName+"::"+tname))) 

  {

    //cout << "=== type found in local module" << endl;

    return TRUE;

  }

  else 

  {

    UseEntry *use;

    for (UseSDict::Iterator di(*usedict); (use=di.current()); ++di)

      if ((cd= Doxygen::classSDict->find(use->module+"::"+tname))) 

      {

 	//cout << "===  type found in used module" << endl;

        return TRUE;

      }

  }

  return FALSE;

}

/**

  searches for definition of function memberName

  @param memberName the name of the function/variable

  @param moduleName name of enclosing module or null, if global entry

  @param md the entry, if found or null

  @param usedict array of data of USE-statement

  @returns true, if found 

*/

static bool getFortranDefs(const QCString &memberName, const QCString &moduleName, 

                           MemberDef *&md, UseSDict *usedict=0)

{

  if (memberName.isEmpty()) return FALSE; /* empty name => nothing to link */

  // look in local variables

  for (Scope *scope=scopeStack.last(); scope!=NULL; scope=scopeStack.prev())

  {

    if(scope->localVars.find(memberName))

      return FALSE;

  }

  // search for function

  MemberName *mn = Doxygen::functionNameSDict->find(memberName);

  if (mn) // name is known

  {

      MemberListIterator mli(*mn);

      for (mli.toFirst();(md=mli.current());++mli) // all found functions with given name

      {

        FileDef  *fd=md->getFileDef();

        GroupDef *gd=md->getGroupDef();

 //cout << "found link with same name: " << fd->fileName() << "  " <<  memberName;

 //if (md->getNamespaceDef() != 0) cout << " in namespace " << md->getNamespaceDef()->name();cout << endl;

        if ((gd && gd->isLinkable()) || (fd && fd->isLinkable()))

        {

           NamespaceDef *nspace= md->getNamespaceDef();

           if (nspace == 0) 

	   { // found function in global scope

             return TRUE;

           }

           else if (moduleName == nspace->name()) 

	   { // found in local scope

             return TRUE;

           }

           else 

	   { // else search in used modules

	     QCString moduleName= nspace->name();

	     UseEntry *ue= usedict->find(moduleName);

	     if (ue) 

	     {

               // check if only-list exists and if current entry exists is this list

	       QStringList &only= ue->onlyNames;

	       if (only.isEmpty()) 

	       {

               //cout << " found in module " << moduleName << " entry " << memberName <<  endl;

                 return TRUE; // whole module used

               }

               else

	       {

	         for ( QStringList::Iterator it = only.begin(); it != only.end(); ++it)

                 {

                   //cout << " search in only: " << moduleName << ":: " << memberName << "==" << (*it)<<  endl;

		   if (memberName == (QCString)(*it))

                     return TRUE; // found in ONLY-part of use list

	         }

	       }

             }

           }

        } // if linkable

      } // for

  }

  return FALSE;

}

/**

 gets the link to a generic procedure which depends not on the name, but on the parameter list

 @todo implementation

*/

static bool getGenericProcedureLink(const ClassDef *cd, 

                                    const char *memberText, 

				    CodeOutputInterface &ol) 

{

  (void)cd;

  (void)memberText;

  (void)ol;

  return FALSE;

}

static bool getLink(UseSDict *usedict, // dictonary with used modules

                    const char *memberText,  // exact member text

		    CodeOutputInterface &ol,

		    const char *text)

{

  MemberDef *md;

  QCString memberName= removeRedundantWhiteSpace(memberText);

  if (getFortranDefs(memberName, currentModule, md, usedict) && md->isLinkable())

  { 

    //if (md->isVariable()) return FALSE; // variables aren't handled yet	

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

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

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

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

    {

      if (g_currentDefinition && g_currentMemberDef && md!=g_currentMemberDef && g_insideBody)

      { 

	addDocCrossReference(g_currentMemberDef,md); 

      }     

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

	                g_currentMemberDef ? g_currentMemberDef : g_currentDefinition);

      writeMultiLineCodeLink(ol,md->getReference(),

	                        md->getOutputFileBase(),

	                        md->anchor(),

				text ? text : memberText);

      addToSearchIndex(text ? text : memberText);

      return TRUE;

    } 

  }

  return FALSE;

}

static void generateLink(CodeOutputInterface &ol, char *lname)

{

  ClassDef *cd=0;