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

 *

 * 

 *

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

 *

 */

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

 */

%option never-interactive

%option prefix="pycodeYY"

%{

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

#include "config.h"

#include "groupdef.h"

#include "classlist.h"

#include "filedef.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_INPUT 1

#define YY_NO_UNISTD_H 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 Definition   *g_searchCtx;

static bool          g_collectXRefs;

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_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 QCString      g_docBlock;     //!< contents of all lines of a documentation block

static bool          g_endComment;

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

  }

}

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

    }

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

      }

      else

      {

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

	                        d->getOutputFileBase(),

	                        0,g_yyLineNr);

        setCurrentDoc(lineAnchor);

      }

    }

    else

    {

      //g_code->codify(lineNumber);

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

    }

    //g_code->endLineNumber();

  }

  g_code->startCodeLine(g_sourceFileDef); 

  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_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,

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

{

  if (g_currentFontClass)

  {

    g_code->endFontClass();

    g_currentFontClass=0;

  }

}

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(const QCString &str)

{

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

  qstrcpy(tmp, str);

  codifyLines(tmp);

  free(tmp);

}

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

  {

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

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

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

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

    {

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

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

      //        g_currentDefinition,g_currentMemberDef);

      if (g_currentDefinition && g_currentMemberDef &&

	  md!=g_currentMemberDef && g_collectXRefs)

      {

	addDocCrossReference(g_currentMemberDef,md);

      }

      //printf("d->getReference()=`%s' d->getOutputBase()=`%s' name=`%s' member name=`%s'\n",d->getReference().data(),d->getOutputFileBase().data(),d->name().data(),md->name().data());

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

      addToSearchIndex(text ? text : memberText);

      return TRUE;

    } 

  }

  return FALSE;

}

static bool getLink(const char *className,

                    const char *memberName,

		    CodeOutputInterface &ol,

		    const char *text=0)

{

  QCString m=removeRedundantWhiteSpace(memberName);

  QCString c=className;

  if (!getLinkInScope(c,m,memberName,ol,text))

  {

    if (!g_curClassName.isEmpty())

    {

      if (!c.isEmpty()) c.prepend("::");

      c.prepend(g_curClassName);

      return getLinkInScope(c,m,memberName,ol,text);

    }

    return FALSE;

  }

  return TRUE;

}

/*

  For a given string in the source code,

  finds its class or global id and links to it.

*/

static void generateClassOrGlobalLink(CodeOutputInterface &ol,char *clName,

                                      bool typeOnly=FALSE)

{

  QCString className=clName;

  // Don't do anything for empty text

  if (className.isEmpty()) return;

  DBG_CTX((stderr,"generateClassOrGlobalLink(className=%s)\n",className.data()));

  ClassDef *cd=0,*lcd=0;  /** Class def that we may find */

  MemberDef *md=0;        /** Member def that we may find */

  //bool isLocal=FALSE;

  if ((lcd=g_theVarContext.findVariable(className))==0) // not a local variable

  {

    Definition *d = g_currentDefinition;

    QCString scope = substitute(className,".","::");

    cd = getResolvedClass(d,g_sourceFileDef,substitute(className,".","::"),&md);

    DBG_CTX((stderr,"d=%s g_sourceFileDef=%s\n",

        d?d->displayName().data():"<null>",

        g_currentDefinition?g_currentDefinition->displayName().data():"<null>"));

    DBG_CTX((stderr,"is found as a type %s\n",cd?cd->name().data():"<null>"));

    if (cd==0 && md==0) // also see if it is variable or enum or enum value

    {

      NamespaceDef *nd = getResolvedNamespace(scope);

      if (nd)

      {

        writeMultiLineCodeLink(ol,nd,clName);

        addToSearchIndex(className);

        return;

      }

      else if (getLink(g_classScope,clName,ol,clName))

      {

	return;

      }

    }

  }

  else

  {

    if (lcd!=PyVariableContext::dummyContext) 

    {

      g_theCallContext.setClass(lcd);

    }

    //isLocal=TRUE;

    DBG_CTX((stderr,"is a local variable cd=%p!\n",cd));

  }

  if (cd && cd->isLinkable()) // is it a linkable class

  {

    writeMultiLineCodeLink(ol,cd,clName);

    addToSearchIndex(className);

    if (md)

    {

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

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

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

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

          g_currentMemberDef && g_collectXRefs)

      {

        addDocCrossReference(g_currentMemberDef,md);

      }

    }

  }

  else // not a class, maybe a global member

  {

    int scopeEnd = className.findRev(".");

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

    {

      QCString scope = substitute(className.left(scopeEnd),".","::");

      QCString locName = className.right(className.length()-scopeEnd-1);

      ClassDef *mcd = getClass(scope);

      DBG_CTX((stderr,"scope=%s locName=%s mcd=%p\n",scope.data(),locName.data(),mcd));

      if (mcd)

      {

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

	if (md)

	{

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

          writeMultiLineCodeLink(ol,md,clName);

          addToSearchIndex(className);

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

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

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

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

              g_currentMemberDef && g_collectXRefs)

	  {

	    addDocCrossReference(g_currentMemberDef,md);

	  }

	  return;

	}

      }

      else // check namespace as well

      {

        NamespaceDef *mnd = getResolvedNamespace(scope);

        if (mnd)

        {

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

	  if (md)

          {

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

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

            writeMultiLineCodeLink(ol,md,clName);

            addToSearchIndex(className);

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

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

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

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

                g_currentMemberDef && g_collectXRefs)

	    {

	      addDocCrossReference(g_currentMemberDef,md);

	    }

	    return;

          }

        }

      }

    }

    // nothing found, just write out the word

    codifyLines(clName);

    addToSearchIndex(clName);

  }

}

/*

   As of June 1, this function seems to work

   for file members, but scopes are not

   being correctly tracked for classes

   so it doesn't work for classes yet.

*/

static void generateFunctionLink(CodeOutputInterface &ol,char *funcName)

{

  //CodeClassDef *ccd=0;

  ClassDef *ccd=0;

  QCString locScope=g_classScope.copy();

  QCString locFunc=removeRedundantWhiteSpace(funcName);

  DBG_CTX((stdout,"*** locScope=%s locFunc=%s\n",locScope.data(),locFunc.data()));

  int i=locFunc.findRev("::");

  if (i>0)

  {

    locScope=locFunc.left(i);

    locFunc=locFunc.right(locFunc.length()-i-2).stripWhiteSpace();

  }

  //printf("generateFunctionLink(%s) classScope=`%s'\n",locFunc.data(),locScope.data());

  if (!locScope.isEmpty() && (ccd=g_codeClassSDict[locScope]))

  {

    //printf("using classScope %s\n",g_classScope.data());

    if (ccd->baseClasses())

    {

      BaseClassListIterator bcli(*ccd->baseClasses());

      for ( ; bcli.current() ; ++bcli)

      {

	if (getLink(bcli.current()->classDef->name(),locFunc,ol,funcName)) 

	{

	  return;

	}

      }

    }

  }

  if (!getLink(locScope,locFunc,ol,funcName))

  {

    generateClassOrGlobalLink(ol,funcName);

  }

  return;

}

static bool findMemberLink(CodeOutputInterface &ol,Definition *sym,const char *symName)

{

  //printf("sym %s outerScope=%s equal=%d\n",

  //    sym->name().data(),sym->getOuterScope()->name().data(),

  //    sym->getOuterScope()==g_currentDefinition);

  if (sym->getOuterScope() &&

      sym->getOuterScope()->definitionType()==Definition::TypeClass &&

      g_currentDefinition->definitionType()==Definition::TypeClass)

  {

    ClassDef *cd = (ClassDef*)sym->getOuterScope();

    ClassDef *thisCd = (ClassDef *)g_currentDefinition;

    if (sym->definitionType()==Definition::TypeMember)

    {

      if (g_currentMemberDef && g_collectXRefs)

      {

	addDocCrossReference(g_currentMemberDef,(MemberDef*)sym);

      }

    }

    DBG_CTX((stderr,"cd=%s thisCd=%s\n",cd?cd->name().data():"<none>",thisCd?thisCd->name().data():"<none>"));

    // TODO: find the nearest base class in case cd is a base class of

    // thisCd 

    if (cd==thisCd || (thisCd && thisCd->isBaseClass(cd,TRUE)))

    {

      writeMultiLineCodeLink(ol,sym,symName);

      return TRUE;

    }

  }

  return FALSE;

}

static void findMemberLink(CodeOutputInterface &ol,char *symName)

{

  //printf("Member reference: %s scope=%s member=%s\n",

  //    yytext,

  //    g_currentDefinition?g_currentDefinition->name().data():"<none>",

  //    g_currentMemberDef?g_currentMemberDef->name().data():"<none>"

  //    );

  if (g_currentDefinition)

  {

    DefinitionIntf *di = Doxygen::symbolMap->find(symName);

    if (di)

    {

      if (di->definitionType()==DefinitionIntf::TypeSymbolList) // multiple symbols

      {

	DefinitionListIterator dli(*(DefinitionList*)di);

	Definition *sym;

	for (dli.toFirst();(sym=dli.current());++dli)

	{

	  if (findMemberLink(ol,sym,symName)) return;

	}

      }

      else // single symbol

      {

	if (findMemberLink(ol,(Definition*)di,symName)) return;

      }

    }

  }

  //printf("sym %s not found\n",&yytext[5]);

  codify(symName);

}

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

}

%}

BB                [ \t]+

B                 [ \t]*

NEWLINE           \n

DIGIT             [0-9]

LETTER            [A-Za-z\x80-\xFF]

NONEMPTY          [A-Za-z0-9_\x80-\xFF]

EXPCHAR           [#(){}\[\],:.%/\\=`*~|&<>!;+-]

NONEMPTYEXP       [^ \t\n:]

PARAMNONEMPTY     [^ \t\n():]

IDENTIFIER        ({LETTER}|"_")({LETTER}|{DIGIT}|"_")*  

BORDER            ([^A-Za-z0-9])

POUNDCOMMENT      "##"

TRISINGLEQUOTE    "'''"

TRIDOUBLEQUOTE    "\"\"\""

LONGSTRINGCHAR    [^\\"']

ESCAPESEQ         ("\\")(.)

LONGSTRINGITEM    ({LONGSTRINGCHAR}|{ESCAPESEQ})

SMALLQUOTE        ("\"\""|"\""|"'"|"''")

LONGSTRINGBLOCK   ({LONGSTRINGITEM}+|{SMALLQUOTE})