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

 *

 * Parser for syntax highlighting 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

**/

%option never-interactive

%option case-insensitive

%option prefix="fortrancodeYY"

%{

/*

 *	includes

 */

#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"

#include "memberlist.h"

#include "config.h"

#include "groupdef.h"

#include "classlist.h"

#include "filedef.h"

#include "namespacedef.h"

#include "tooltip.h"

#include "fortrancode.h"

// Toggle for some debugging info

//#define DBG_CTX(x) fprintf x

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

#define YY_NO_TOP_STATE 1

#define YY_NO_INPUT 1

#define YY_NO_UNISTD_H 1

/*

 * For fixed formatted code position 6 is of importance (continuation character).

 * The following variables and macros keep track of the column number

 * YY_USER_ACTION is always called for each scan action

 * YY_FTN_RESET   is used to handle end of lines and reset the column counter

 * YY_FTN_REJECT  resets the column counters when a pattern is rejected and thus rescanned.

 */

int yy_old_start = 0;

int yy_my_start  = 0;

int yy_end       = 1;

#define YY_USER_ACTION {yy_old_start = yy_my_start; yy_my_start = yy_end; yy_end += yyleng;}

#define YY_FTN_RESET   {yy_old_start = 0; yy_my_start = 0; yy_end = 1;}

#define YY_FTN_REJECT  {yy_end = yy_my_start; yy_my_start = yy_old_start; REJECT;}

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

/**

  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 QCString  currentClass=0;             //!< name of the current enclosing class

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 int	     g_contLineNr;      //!< current, local, line number for continuation determination

static int	    *g_hasContLine = NULL;     //!< signals whether or not a line has a continuation line (fixed source form)

static bool          g_needsTermination;

static Definition   *g_searchCtx;

static bool          g_collectXRefs;

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;

static bool      g_endComment;

static void endFontClass()

{

  if (g_currentFontClass)

  {

    g_code->endFontClass();

    g_currentFontClass=0;

  }

}

static void startFontClass(const char *s)

{

  // if font class is already set don't stop and start it.

  // strcmp does not like null pointers as input.

  if (!g_currentFontClass || !s || strcmp(g_currentFontClass,s))

  {

    endFontClass();

    g_code->startFontClass(s);

    g_currentFontClass=s;

  }

}

static void setCurrentDoc(const QCString &anchor)

{

  if (Doxygen::searchIndex)

  {

    if (g_searchCtx)

    {

      Doxygen::searchIndex->setCurrentDoc(g_searchCtx,g_searchCtx->anchor(),FALSE);

    }

    else

    {

      Doxygen::searchIndex->setCurrentDoc(g_sourceFileDef,anchor,TRUE);

    }

  }

}

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_endComment = 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(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);

    }

  }

  g_code->startCodeLine(g_sourceFileDef); 

  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;

  const char *  tmp_currentFontClass = g_currentFontClass;

  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

      {

	startCodeLine();

      }

      if (tmp_currentFontClass)

      {

        startFontClass(tmp_currentFontClass);

      }

    }

    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,

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

      endCodeLine();

      if (g_yyLineNr

      {

	startCodeLine();

      }

    }

    else

    {

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

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

      done=TRUE;

    }

  }

}

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

/**

  searches for definition of a module (Namespace)

  @param mname the name of the module

  @param cd the entry, if found or null

  @returns true, if module is found

*/

static bool getFortranNamespaceDefs(const QCString &mname,

                               NamespaceDef *&cd)

{

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

  // search for module

  if ((cd=Doxygen::namespaceSDict->find(mname))) return TRUE;

  return FALSE;

}

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

/**

  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

  QListIterator<Scope> it(scopeStack);

  Scope *scope;

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

  {

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

      return FALSE;

  }

  // search for function

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

  if (!mn)

  {

    mn = Doxygen::memberNameSDict->find(memberName);

  }

  if (mn) // name is known

  {

      MemberNameIterator mli(*mn);

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

      {

        FileDef  *fd=md->getFileDef();

        GroupDef *gd=md->getGroupDef();

        ClassDef *cd=md->getClassDef();

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

             if(cd == 0) { // Skip if bound to type

                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 == (*it).utf8())

	           {

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

  QCString memberName= removeRedundantWhiteSpace(memberText);

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

  { 

    if (md->isVariable() && (md->getLanguage()!=SrcLangExt_Fortran)) return FALSE; // Non Fortran variables aren't handled yet,

                                                                                   // see also linkifyText in util.cpp

    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 && g_collectXRefs)

      { 

	addDocCrossReference(g_currentMemberDef,md); 

      }     

      writeMultiLineCodeLink(ol,md,text ? text : memberText);

      addToSearchIndex(text ? text : memberText);

      return TRUE;

    } 

  }

  return FALSE;

}

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

{

  ClassDef *cd=0;

  NamespaceDef *nsd=0;

  QCString tmp = lname;

  tmp = removeRedundantWhiteSpace(tmp.lower());

  // check if lowercase lname is a linkable type or interface

  if ( (getFortranTypeDefs(tmp, currentModule, cd, useMembers)) && cd->isLinkable() )

  {

    if ( (cd->compoundType() == ClassDef::Class) && // was  Entry::INTERFACE_SEC) &&

         (getGenericProcedureLink(cd, tmp, ol)) ) 

    {

      //cout << "=== generic procedure resolved" << endl; 

    } 

    else 

    { // write type or interface link

      writeMultiLineCodeLink(ol,cd,tmp);

      addToSearchIndex(tmp.data());

    }

  }

  // check for module

  else if ( (getFortranNamespaceDefs(tmp, nsd)) && nsd->isLinkable() )

  { // write module link

    writeMultiLineCodeLink(ol,nsd,tmp);

    addToSearchIndex(tmp.data());

  }

  // check for function/variable

  else if (getLink(useMembers, tmp, ol, tmp)) 

  {

    //cout << "=== found link for lowercase " << lname << endl;

  }

  else 

  {

    // nothing found, just write out the word

    //startFontClass("charliteral"); //test

    codifyLines(tmp);

    //endFontClass(); //test

    addToSearchIndex(tmp.data());

  }

}

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

}

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

/** start scope */

static void startScope() 

{

  DBG_CTX((stderr, "===> startScope %s",yytext));

  Scope *scope = new Scope;

  scopeStack.append(scope);

}

/** end scope */

static void endScope() 

{

  DBG_CTX((stderr,"===> endScope %s",yytext));

  if (scopeStack.isEmpty()) 

  {

    DBG_CTX((stderr,"WARNING: fortrancode.l: stack empty!\n")); 

    return;

  }

  Scope *scope = scopeStack.getLast();

  scopeStack.removeLast();

  for ( QStringList::Iterator it = scope->useNames.begin(); it != scope->useNames.end(); ++it) 

  {

    useMembers->remove((*it).utf8());

  }

  delete scope;

}

static void addUse(const QCString &moduleName) 

{

  if (!scopeStack.isEmpty())

    scopeStack.getLast()->useNames.append(moduleName);

}

static void addLocalVar(const QCString &varName) 

{

  if (!scopeStack.isEmpty())

    scopeStack.getLast()->localVars.insert(varName, (void*)1);

}

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

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

#undef	YY_INPUT

#define	YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);

static int yyread(char *buf,int max_size)

{

    int c=0;

    while( c < max_size && g_inputString[g_inputPosition] )

    {

	*buf = g_inputString[g_inputPosition++] ;

	c++; buf++;

    }

    return c;

}

%}

IDSYM	  [a-z_A-Z0-9]

ID        [a-z_A-Z]+{IDSYM}*

SUBPROG   (subroutine|function)

B         [ \t]

BS        [ \t]*

BS_       [ \t]+

COMMA     {BS},{BS}

ARGS_L0   ("("[^)]*")")

ARGS_L1a  [^()]*"("[^)]*")"[^)]*

ARGS_L1   ("("{ARGS_L1a}*")")

ARGS_L2   "("({ARGS_L0}|[^()]|{ARGS_L1a}|{ARGS_L1})*")"

ARGS      {BS}({ARGS_L0}|{ARGS_L1}|{ARGS_L2})

NUM_TYPE  (complex|integer|logical|real)

LOG_OPER  (\.and\.|\.eq\.|\.eqv\.|\.ge\.|\.gt\.|\.le\.|\.lt\.|\.ne\.|\.neqv\.|\.or\.|\.not\.)

KIND      {ARGS}

CHAR      (CHARACTER{ARGS}?|CHARACTER{BS}"*"({BS}[0-9]+|{ARGS}))

TYPE_SPEC (({NUM_TYPE}({BS}"*"{BS}[0-9]+)?)|({NUM_TYPE}{KIND})|DOUBLE{BS}COMPLEX|DOUBLE{BS}PRECISION|{CHAR}|TYPE|CLASS|PROCEDURE)

INTENT_SPEC intent{BS}"("{BS}(in|out|in{BS}out){BS}")"

ATTR_SPEC (IMPLICIT|ALLOCATABLE|DIMENSION{ARGS}|EXTERNAL|{INTENT_SPEC}|INTRINSIC|OPTIONAL|PARAMETER|POINTER|PROTECTED|PRIVATE|PUBLIC|SAVE|TARGET|RECURSIVE|PURE|IMPURE|ELEMENTAL|VALUE|NOPASS|DEFERRED|CONTIGUOUS|VOLATILE)

ACCESS_SPEC (PROTECTED|PRIVATE|PUBLIC)

/* Assume that attribute statements are almost the same as attributes. */

ATTR_STMT {ATTR_SPEC}|DIMENSION

FLOW      (DO|SELECT|CASE|SELECT{BS}(CASE|TYPE)|WHERE|IF|THEN|ELSE|WHILE|FORALL|ELSEWHERE|ELSEIF|RETURN|CONTINUE|EXIT|GO{BS}TO)

COMMANDS  (FORMAT|CONTAINS|MODULE{BS_}PROCEDURE|WRITE|READ|ALLOCATE|ALLOCATED|ASSOCIATED|PRESENT|DEALLOCATE|NULLIFY|SIZE|INQUIRE|OPEN|CLOSE|FLUSH|DATA|COMMON)

IGNORE    (CALL)

PREFIX    (RECURSIVE{BS_}|IMPURE{BS_}|PURE{BS_}|ELEMENTAL{BS_}){0,3}(RECURSIVE|IMPURE|PURE|ELEMENTAL)?

/* |  */

%option noyywrap

%option stack

%option caseless

/*%option debug*/

%x Start

%x SubCall

%x FuncDef

%x ClassName

%x ClassVar

%x Subprog

%x DocBlock

%x Use

%x UseOnly

%x Import

%x Declaration

%x DeclarationBinding

%x DeclContLine

%x Parameterlist

%x String

%x Subprogend

%%

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

 /*-------- ignore ------------------------------------------------------------*/

<Start>{IGNORE}/{BS}"("                 { // do not search keywords, intrinsics... TODO: complete list

                                          codifyLines(yytext);

                                        }

 /*-------- inner construct ---------------------------------------------------*/

<Start>{COMMANDS}/{BS}[,( \t\n]         {  // highlight

   					  /* font class is defined e.g. in doxygen.css */

  					  startFontClass("keyword");

  					  codifyLines(yytext);

					  endFontClass();

					}

<Start>{FLOW}/{BS}[,( \t\n]               {

                                          if (g_isFixedForm)

                                          {

                                            if ((yy_my_start == 1) && ((yytext[0] == 'c') || (yytext[0] == 'C'))) YY_FTN_REJECT;

                                          }

   					  /* font class is defined e.g. in doxygen.css */

  					  startFontClass("keywordflow");

  					  codifyLines(yytext);

					  endFontClass();

					}

<Start>{BS}(CASE|CLASS|TYPE){BS_}(IS|DEFAULT) {

                                          startFontClass("keywordflow");

                                          codifyLines(yytext);

                                          endFontClass();

                                        }

<Start>{BS}"end"({BS}{FLOW})/[ \t\n]       { // list is a bit long as not all have possible end

  					  startFontClass("keywordflow");

  					  codifyLines(yytext);

					  endFontClass();

					}

<Start>"implicit"{BS}("none"|{TYPE_SPEC})  { 

  					  startFontClass("keywordtype"); 

  					  codifyLines(yytext);

					  endFontClass();

                                        }

<Start>^{BS}"namelist"/[//]             {  // Namelist specification

                                          startFontClass("keywordtype");

                                          codifyLines(yytext);

                                          endFontClass();

                                        }

 /*-------- use statement -------------------------------------------*/

<Start>"use"{BS_}                       { 

  					  startFontClass("keywordtype"); 

  					  codifyLines(yytext);

					  endFontClass();

                                          yy_push_state(YY_START);

					  BEGIN(Use);     

                                        }

<Use>"ONLY"                             { // TODO: rename

                                          startFontClass("keywordtype");

                                          codifyLines(yytext);

                                          endFontClass();

                                          yy_push_state(YY_START);

                                          BEGIN(UseOnly);

                                        }

<Use>{ID}                               {

                                          QCString tmp = yytext;

                                          tmp = tmp.lower();

					  g_insideBody=TRUE;

                                          generateLink(*g_code, yytext);

					  g_insideBody=FALSE;

					  /* append module name to use dict */

                                          useEntry = new UseEntry();

					  //useEntry->module = yytext;

                                          //useMembers->append(yytext, useEntry);

					  //addUse(yytext);

					  useEntry->module = tmp;

                                          useMembers->append(tmp, useEntry);

					  addUse(tmp);

                                        }           

<Use,UseOnly,Import>{BS},{BS}           { codifyLines(yytext); }

<UseOnly,Import>{BS}&{BS}"\n"           { codifyLines(yytext);

                                          g_contLineNr++;

                                          YY_FTN_RESET}

<UseOnly>{ID}                           {

                                          QCString tmp = yytext;

                                          tmp = tmp.lower();

                                          useEntry->onlyNames.append(tmp);

                                          g_insideBody=TRUE;

                                          generateLink(*g_code, yytext);

                                          g_insideBody=FALSE;

                                        }

<Use,UseOnly,Import>"\n"                {

                                          unput(*yytext);

                                          yy_pop_state();YY_FTN_RESET

                                        }

<Start>"import"{BS_}                    {

                                          startFontClass("keywordtype");

                                          codifyLines(yytext);

                                          endFontClass();

                                          yy_push_state(YY_START);

                                          BEGIN(Import);

                                        }

<Import>{ID}                            {

                                          g_insideBody=TRUE;

                                          generateLink(*g_code, yytext);

                                          g_insideBody=FALSE;

                                        }

 /*-------- fortran module  -----------------------------------------*/

<Start>("block"{BS}"data"|"program"|"module"|"interface")/{BS_}|({COMMA}{ACCESS_SPEC})|\n {  //

                                          startScope();

  					  startFontClass("keyword"); 

  					  codifyLines(yytext);

					  endFontClass();

                                          yy_push_state(YY_START);

					  BEGIN(ClassName); 

	                                  if (!qstricmp(yytext,"module")) currentModule="module";

					}

<Start>("type")/{BS_}|({COMMA}({ACCESS_SPEC}|ABSTRACT|EXTENDS))|\n {  //

            startScope();

              startFontClass("keyword");

              codifyLines(yytext);

            endFontClass();

                                          yy_push_state(YY_START);

            BEGIN(ClassName);

            currentClass="class";

          }

<ClassName>{ID}               	        {

	                                  if (currentModule == "module")

                                          {

                                            currentModule=yytext;

                                            currentModule = currentModule.lower();

                                          }

					  generateLink(*g_code,yytext);

                                          yy_pop_state();

 					}

<ClassName>({ACCESS_SPEC}|ABSTRACT|EXTENDS)/[,:( ] { //| variable deklaration

              startFontClass("keyword");

            g_code->codify(yytext);

            endFontClass();

            }

<ClassName>\n				{ // interface may be without name

                                          yy_pop_state();

					  YY_FTN_REJECT;

					}

<Start>^{BS}"end"({BS_}"type").*        { // just reset currentClass, rest is done in following rule

                                          currentClass=0;

            YY_FTN_REJECT;

                                        }

<Start>^{BS}"end"({BS_}"module").*      { // just reset currentModule, rest is done in following rule

                                          currentModule=0;

					  YY_FTN_REJECT;

                                        }

 /*-------- subprog definition -------------------------------------*/

<Start>({PREFIX}{BS_})?{TYPE_SPEC}{BS_}({PREFIX}{BS_})?{BS}/{SUBPROG}{BS_}  {   // TYPE_SPEC is for old function style function result

   					  startFontClass("keyword");

  					  codifyLines(yytext);

					  endFontClass();

                                       }              

<Start>({PREFIX}{BS_})?{SUBPROG}{BS_}                  {  // Fortran subroutine or function found

   					  startFontClass("keyword");