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

 *

 * 

 *

 *

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

 */

%{

/*

 *	includes

 */

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <ctype.h>

#include "qtbc.h"

#include <qarray.h>

#include <qstack.h>

#include <qregexp.h>

#include <unistd.h>

#include <qfile.h>

#include <qfileinfo.h>

#include "pyscanner.h"

#include "entry.h"

#include "message.h"

#include "config.h"

#include "doxygen.h"

#include "util.h"

#include "defargs.h"

#include "language.h"

#include "commentscan.h"

#include "pycode.h"

#define YY_NEVER_INTERACTIVE 1

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

 *

 *	statics

 */

static ParserInterface *g_thisParser;

static const char *     inputString;

static int		inputPosition;

static QFile            inputFile;

static Protection	protection;

static Entry*		current_root = 0 ;

static Entry*		current      = 0 ;

static Entry*		previous     = 0 ;

static Entry*		bodyEntry    = 0 ;

static int		yyLineNr     = 1 ;

static QCString		yyFileName;

static MethodTypes 	mtype;

static bool    		gstat;

static Specifier 	virt;

static int              docBlockContext;

static QCString         docBlock;

static QCString         docBlockName;

static bool             docBlockInBody;

static bool             docBlockJavaStyle;

static bool             docBrief;

static bool             docBlockSpecial;

static bool             g_doubleQuote;

static bool             g_specialBlock;

static int              g_stringContext;

static QGString *       g_copyString;

static int              g_indent = 0;

static int              g_curIndent = 0;

static QDict<QCString>  g_packageNameCache(257);

static QCString         g_packageScope;

static char             g_atomStart;

static char             g_atomEnd;

static int              g_atomCount;

//static bool             g_insideConstructor;

static QCString         g_moduleScope;

static QCString         g_packageName;

static bool             g_hideClassDocs;

static QCString         g_defVal;

static int              g_braceCount;

static bool             g_lexInit = FALSE;

static bool             g_packageCommentAllowed;

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

static void initParser()

{

  protection = Public;

  mtype = Method;

  gstat = FALSE;

  virt = Normal;

  previous = 0;

  g_packageCommentAllowed = TRUE;

  g_packageNameCache.setAutoDelete(TRUE);

}

static void initEntry()

{

  //current->python = TRUE;

  current->protection = protection ;

  current->mtype      = mtype;

  current->virt       = virt;

  current->stat       = gstat;

  current->objc       = FALSE; //insideObjC;

  current->setParent(current_root);

  initGroupInfo(current);

}

static void newEntry()

{

  previous = current;

  current_root->addSubEntry(current);

  current = new Entry ;

  initEntry();

}

static void newVariable()

{

  if (!current->name.isEmpty() && current->name.at(0)=='_') // mark as private

  {

    current->protection=Private;

  }

  if (current_root->section&Entry::COMPOUND_MASK) // mark as class variable

  {

    current->stat = TRUE;

  }

  newEntry();

}

static void newFunction()

{

  if (current->name.left(2)=="__" && current->name.right(2)=="__")

  {

    // special method name, see

    // http://docs.python.org/ref/specialnames.html

    current->protection=Public;

  }

  else if (current->name.at(0)=='_')

  {

    current->protection=Private;

  }

}

static inline int computeIndent(const char *s)

{

  int col=0;

  static int tabSize=Config_getInt("TAB_SIZE");

  const char *p=s;

  char c;

  while ((c=*p++))

  {

    if (c==' ') col++;

    else if (c=='\t') col+=tabSize-(col%tabSize);

    else break;

  }

  return col;

}

static QCString findPackageScopeFromPath(const QCString &path)

{

  QCString *pScope = g_packageNameCache.find(path);

  if (pScope)

  {

    return *pScope;

  }

  QFileInfo pf(path+"/__init__.py"); // found package initialization file

  if (pf.exists())

  {

    int i=path.findRev('/');

    if (i!=-1)

    {

      QCString scope = findPackageScopeFromPath(path.left(i));

      if (!scope.isEmpty())

      {

	scope+="::";

      }

      scope+=path.mid(i+1);

      g_packageNameCache.insert(path,new QCString(scope));

      return scope;

    }

  }

  return "";

}

static QCString findPackageScope(const char *fileName)

{

  if (fileName==0) return "";

  QFileInfo fi(fileName);

  return findPackageScopeFromPath(fi.dirPath(TRUE).data());

}

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

static void lineCount()

{

  for( const char* c = yytext ; *c ; ++c )

    yyLineNr += (*c == '\n') ;

}

#if 0

// Appends the current-name to current-type;

// Destroys current-name.

// Destroys current->args and current->argList

static void addType( Entry* current )

{

    uint tl=current->type.length();

    if ( tl>0 && !current->name.isEmpty() && current->type.at(tl-1)!='.') 

    {

      current->type += ' ' ;

    }

    current->type += current->name ;

    current->name.resize(0) ;

    tl=current->type.length();

    if ( tl>0 && !current->args.isEmpty() && current->type.at(tl-1)!='.') 

    {

      current->type += ' ' ;

    }

    current->type += current->args ;

    current->args.resize(0) ;

    current->argList->clear();

}

static QCString stripQuotes(const char *s)

{

  QCString name;

  if (s==0 || *s==0) return name;

  name=s;

  if (name.at(0)=='"' && name.at(name.length()-1)=='"')

  {

    name=name.mid(1,name.length()-2);

  }

  return name;

}

#endif

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

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

static void startCommentBlock(bool brief)

{

  if (brief)

  {

    current->briefFile = yyFileName;

    current->briefLine = yyLineNr;

  }

  else

  {

    current->docFile = yyFileName;

    current->docLine = yyLineNr;

  }

}

/*

static void appendDocBlock() {

  previous = current;

  current_root->addSubEntry(current);

  current = new Entry;

  initEntry();

}

*/

static void handleCommentBlock(const QCString &doc,bool brief)

{

  //printf("handleCommentBlock(doc=[%s] brief=%d docBlockInBody=%d docBlockJavaStyle=%d\n",

  //    doc.data(),brief,docBlockInBody,docBlockJavaStyle);

  // TODO: Fix me

  docBlockInBody=FALSE;

  if (docBlockInBody && previous && !previous->doc.isEmpty())

  {

    previous->doc=previous->doc.stripWhiteSpace()+"\n\n";

  }

  int position = 0;

  bool needsEntry;

  int lineNr = brief ? current->briefLine : current->docLine;

  while (parseCommentBlock(

	g_thisParser,

	(docBlockInBody && previous) ? previous : current,

	doc,     // text

	yyFileName, // file

	lineNr,

	docBlockInBody ? FALSE : brief, 

    docBlockJavaStyle, // javadoc style // or FALSE,

	docBlockInBody,

	protection,

        position,

        needsEntry)

     ) // need to start a new entry

  {

    if (needsEntry)

    {

      newEntry();

    }

  }

  if (needsEntry)

  {

    newEntry();

  }

}

static void endOfDef()

{

  if (bodyEntry)

  {

    bodyEntry->endBodyLine  = yyLineNr;

    bodyEntry = 0;

  }

  newEntry();

  //g_insideConstructor = FALSE;

}

static inline void addToString(const char *s)

{

  if (g_copyString) (*g_copyString)+=s;

}

static void initTriDoubleQuoteBlock()

{

  docBlockContext   = YY_START;

  docBlockInBody    = FALSE;

  docBlockJavaStyle = TRUE;

  docBlockSpecial   = yytext[3]=='!';

  docBlock.resize(0);

  g_doubleQuote = TRUE;

  startCommentBlock(FALSE);

}

static void initTriSingleQuoteBlock()

{

  docBlockContext   = YY_START;

  docBlockInBody    = FALSE;

  docBlockJavaStyle = TRUE;

  docBlockSpecial   = yytext[3]=='!';

  docBlock.resize(0);

  g_doubleQuote = FALSE;

  startCommentBlock(FALSE);

}

static void initSpecialBlock()

{

  docBlockContext   = YY_START;

  docBlockInBody    = FALSE;

  docBlockJavaStyle = TRUE;

  docBrief = TRUE;

  docBlock.resize(0);

  startCommentBlock(TRUE);

}

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

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

#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 && inputString[inputPosition] )

  {

    *buf = inputString[inputPosition++] ;

    //printf("%d (%c)\n",*buf,*buf);

    c++; buf++;

  }

  return c;

}

%}

       /* start command character */

BB                [ \t]+

B                 [ \t]*

NEWLINE           \n

BN                [ \t\n]

DIGIT             [0-9]

HEXNUMBER         "0"[xX][0-9a-fA-F]+[lL]?

OCTNUMBER         "0"[0-7]+[lL]?

NUMBER            {DIGIT}+[lLjJ]?

INTNUMBER         {HEXNUMBER}|{OCTNUMBER}|{NUMBER}

FLOATNUMBER       {DIGIT}+"."{DIGIT}+([eE][+\-]?{DIGIT}+)?[jJ]?

LETTER            [A-Za-z]

NONEMPTY          [A-Za-z0-9_]

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

NONEMPTYEXP       [^ \t\n:]

PARAMNONEMPTY     [^ \t\n():]

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

SCOPE             {IDENTIFIER}("."{IDENTIFIER})*

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

TRISINGLEQUOTE    "'''"(!)?

TRIDOUBLEQUOTE    "\"\"\""(!)?

LONGSTRINGCHAR    [^\\"']

ESCAPESEQ         ("\\")(.)

LONGSTRINGITEM    ({LONGSTRINGCHAR}|{ESCAPESEQ})

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

LONGSTRINGBLOCK   ({LONGSTRINGITEM}+|{SMALLQUOTE})

SHORTSTRING       ("'"{SHORTSTRINGITEM}*"'"|'"'{SHORTSTRINGITEM}*'"')

SHORTSTRINGITEM   ({SHORTSTRINGCHAR}|{ESCAPESEQ})

SHORTSTRINGCHAR   [^\\\n"]

STRINGLITERAL     {STRINGPREFIX}?( {SHORTSTRING} | {LONGSTRING})  

STRINGPREFIX      ("r"|"u"|"ur"|"R"|"U"|"UR"|"Ur"|"uR")

KEYWORD           ("lambda"|"import"|"class"|"assert"|"as"|"from"|"global"|"def"|"True"|"False")

FLOWKW            ("or"|"and"|"is"|"not"|"print"|"for"|"in"|"if"|"try"|"except"|"yield"|"raise"|"break"|"continue"|"pass"|"if"|"return"|"while"|"elif"|"else"|"finally")

POUNDCOMMENT      {B}"#"[^#\n][^\n]* 

STARTDOCSYMS      ^{B}"##"/[^#]

%option noyywrap

  /* Main start state */

%x Search

%x SearchMemVars

  /* Mid-comment states */

  /* %x FuncDoubleComment */

  /* %x ClassDoubleComment */

%x TryClassDocString

%x TripleComment

%x SpecialComment

  /* Function states */

%x FunctionDec

%x FunctionParams

%x FunctionBody

%x FunctionParamDefVal

  /* Class states */

%x ClassDec

%x ClassInheritance

%x ClassCaptureIndent

%x ClassBody

  /* Variable states */

%x VariableDec

%x VariableEnd

%x VariableAtom

  /* String states */

%x SingleQuoteString

%x DoubleQuoteString

%x TripleString

  /* import */

%x FromMod

%x FromModItem

%x Import

%%

  /* ------------ Function recognition rules -------------- */

<Search>{

    ^{B}"def"{BB}       |

    "def"{BB}           { // start of a function/method definition

      			  g_indent=computeIndent(yytext);

			  current->fileName  = yyFileName;

			  current->startLine = yyLineNr;

			  current->bodyLine  = yyLineNr;

			  current->section = Entry::FUNCTION_SEC;

			  current->protection = protection = Public;

			  current->objc = FALSE;

			  current->virt = Normal;

			  current->stat = FALSE;

			  current->mtype = mtype = Method;

			  current->type.resize(0);

			  current->name.resize(0);

			  current->args.resize(0);

			  current->argList->clear();

			  g_packageCommentAllowed = FALSE;

			  BEGIN( FunctionDec );

                       }

     ^{B}"class"{BB}	|

     "class"{BB}        {  // start of a class definition

      			  g_indent=computeIndent(yytext);

			  current->section = Entry::CLASS_SEC;

			  current->argList->clear();

			  current->type += "class" ;

			  current->fileName  = yyFileName;

			  current->bodyLine  = yyLineNr;

			  g_packageCommentAllowed = FALSE;

			  BEGIN( ClassDec ) ;

                       }

     ^{B}"from"{BB}    |