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

 *

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

 *

 */

%{

/*

 *	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 "scanner.h"

#include "entry.h"

#include "doxygen.h"

#include "message.h"

#include "config.h"

#include "util.h"

#include "index.h"

#include "defargs.h"

#include "language.h"

#include "outputlist.h"

#include "membergroup.h"

#include "reflist.h"

#include "debug.h"

#include "parserintf.h"

// forward declarations

static bool handleBrief(const QCString &);

static bool handleFn(const QCString &);

static bool handleDef(const QCString &);

static bool handleOverload(const QCString &);

static bool handleEnum(const QCString &);

static bool handleDefGroup(const QCString &);

static bool handleAddToGroup(const QCString &);

static bool handleWeakGroup(const QCString &);

static bool handleNamespace(const QCString &);

static bool handlePackage(const QCString &);

static bool handleClass(const QCString &);

static bool handleHeaderFile(const QCString &);

static bool handleProtocol(const QCString &);

static bool handleCategory(const QCString &);

static bool handleUnion(const QCString &);

static bool handleStruct(const QCString &);

static bool handleInterface(const QCString &);

static bool handleIdlException(const QCString &);

static bool handlePage(const QCString &);

static bool handleMainpage(const QCString &);

static bool handleFile(const QCString &);

static bool handleDir(const QCString &);

static bool handleExample(const QCString &);

static bool handleDetails(const QCString &);

static bool handleName(const QCString &);

static bool handleTodo(const QCString &);

static bool handleTest(const QCString &);

static bool handleBug(const QCString &);

static bool handleSubpage(const QCString &s);

static bool handleDeprecated(const QCString &);

static bool handleXRefItem(const QCString &);

static bool handleRelated(const QCString &);

static bool handleRelatedAlso(const QCString &);

static bool handleMemberOf(const QCString &);

static bool handleRefItem(const QCString &);

static bool handleSection(const QCString &);

static bool handleAnchor(const QCString &);

static bool handleFormatBlock(const QCString &);

static bool handleAddIndex(const QCString &);

static bool handleIf(const QCString &);

static bool handleIfNot(const QCString &);

static bool handleElseIf(const QCString &);

static bool handleElse(const QCString &);

static bool handleEndIf(const QCString &);

static bool handleIngroup(const QCString &);

static bool handleNoSubGrouping(const QCString &);

static bool handleShowInitializer(const QCString &);

static bool handleHideInitializer(const QCString &);

static bool handleCallgraph(const QCString &);

static bool handleCallergraph(const QCString &);

static bool handleInternal(const QCString &);

static bool handleLineBr(const QCString &);

static bool handleStatic(const QCString &);

static bool handlePure(const QCString &);

static bool handlePrivate(const QCString &);

static bool handlePrivateSection(const QCString &);

static bool handleProtected(const QCString &);

static bool handleProtectedSection(const QCString &);

static bool handlePublic(const QCString &s);

static bool handlePublicSection(const QCString &s);

static bool handleInherit(const QCString &);

static bool handleExtends(const QCString &);

typedef bool (*DocCmdFunc)(const QCString &name);

struct DocCmdMap

{

  const char *cmdName;

  DocCmdFunc handler;

  bool endsBrief;

};

// map of command to handler function

static DocCmdMap docCmdMap[] =

{

  // command name      handler function         ends brief description

  { "brief",           &handleBrief,            FALSE },

  { "short",           &handleBrief,            FALSE },

  { "fn",              &handleFn,               FALSE },

  { "var",             &handleFn,               FALSE },

  { "typedef",         &handleFn,               FALSE },

  { "property",        &handleFn,               FALSE },

  { "def",             &handleDef,              FALSE },

  { "overload",        &handleOverload,         FALSE },

  { "enum",            &handleEnum,             FALSE },

  { "defgroup",        &handleDefGroup,         FALSE },

  { "addtogroup",      &handleAddToGroup,       FALSE },

  { "weakgroup",       &handleWeakGroup,        FALSE },

  { "namespace",       &handleNamespace,        FALSE },

  { "package",         &handlePackage,          FALSE },

  { "class",           &handleClass,            FALSE },

  { "headerfile",      &handleHeaderFile,       FALSE },

  { "protocol",        &handleProtocol,         FALSE },

  { "category",        &handleCategory,         FALSE },

  { "union",           &handleUnion,            FALSE },

  { "struct",          &handleStruct,           FALSE },

  { "interface",       &handleInterface,        FALSE },

  { "idlexcept",       &handleIdlException,     FALSE },

  { "page",            &handlePage,             FALSE },

  { "mainpage",        &handleMainpage,         FALSE },

  { "file",            &handleFile,             FALSE },

  { "dir",             &handleDir,              FALSE },

  { "example",         &handleExample,          FALSE },

  { "details",         &handleDetails,          TRUE  },

  { "name",            &handleName,             FALSE },

  { "todo",            &handleTodo,             FALSE }, // end brief will be done differently

  { "test",            &handleTest,             FALSE }, // end brief will be done differently

  { "bug",             &handleBug,              FALSE }, // end brief will be done differently

  { "deprecated",      &handleDeprecated,       FALSE }, // end brief will be done differently

  { "xrefitem",        &handleXRefItem,         FALSE }, // end brief will be done differently

  { "related",         &handleRelated,          TRUE  },

  { "relates",         &handleRelated,          TRUE  },

  { "relatedalso",     &handleRelatedAlso,      TRUE  },

  { "relatesalso",     &handleRelatedAlso,      TRUE  },

  { "refitem",         &handleRefItem,          TRUE  },

  { "subpage",         &handleSubpage,          TRUE  },

  { "section",         &handleSection,          TRUE  },

  { "subsection",      &handleSection,          TRUE  },

  { "subsubsection",   &handleSection,          TRUE  },

  { "paragraph",       &handleSection,          TRUE  },

  { "anchor",          &handleAnchor,           TRUE  },

  { "verbatim",        &handleFormatBlock,      TRUE },

  { "latexonly",       &handleFormatBlock,      FALSE },

  { "htmlonly",        &handleFormatBlock,      FALSE },

  { "xmlonly",         &handleFormatBlock,      FALSE },

  { "rtfonly",         &handleFormatBlock,      FALSE },

  { "manonly",         &handleFormatBlock,      FALSE },

  { "dot",             &handleFormatBlock,      TRUE  },

  { "msc",             &handleFormatBlock,      TRUE  },

  { "code",            &handleFormatBlock,      TRUE  },

  { "addindex",        &handleAddIndex,         FALSE },

  { "if",              &handleIf,               FALSE },

  { "ifnot",           &handleIfNot,            FALSE },

  { "elseif",          &handleElseIf,           FALSE },

  { "else",            &handleElse,             FALSE },

  { "endif",           &handleEndIf,            FALSE },

  { "ingroup",         &handleIngroup,          FALSE },

  { "nosubgrouping",   &handleNoSubGrouping,    FALSE },

  { "showinitializer", &handleShowInitializer,  FALSE },

  { "hideinitializer", &handleHideInitializer,  FALSE },

  { "callgraph",       &handleCallgraph,        FALSE },

  { "callergraph",     &handleCallergraph,      FALSE },

  { "internal",        &handleInternal,         TRUE  },

  { "_linebr",         &handleLineBr,           FALSE },

  { "static",          &handleStatic,           FALSE },

  { "pure",            &handlePure,             FALSE },

  { "private",         &handlePrivate,          FALSE },

  { "privatesection",  &handlePrivateSection,   FALSE },

  { "protected",       &handleProtected,        FALSE },

  { "protectedsection",&handleProtectedSection, FALSE },

  { "public",          &handlePublic,           FALSE },

  { "publicsection",   &handlePublicSection,    FALSE },

  { "inherit",         &handleInherit,          TRUE  },

  { "extends",         &handleExtends,          TRUE  },

  { "implements",      &handleExtends,          TRUE  },

  { "memberof",        &handleMemberOf,         TRUE  },

  { "arg",             0,                       TRUE  },

  { "attention",       0,                       TRUE  },

  { "author",          0,                       TRUE  },

  { "authors",         0,                       TRUE  },

  { "copydoc",         0,                       TRUE  },

  { "copybrief",       0,                       FALSE },

  { "copydetails",     0,                       TRUE  },

  { "date",            0,                       TRUE  },

  { "dotfile",         0,                       TRUE  },

  { "htmlinclude",     0,                       TRUE  },

  { "image",           0,                       TRUE  },

  { "include",         0,                       TRUE  },

  { "includelineno",   0,                       TRUE  },

  { "invariant",       0,                       TRUE  },

  { "li",              0,                       TRUE  },

  { "line",            0,                       TRUE  },

  { "note",            0,                       TRUE  },

  { "par",             0,                       TRUE  },

  { "param",           0,                       TRUE  },

  { "tparam",          0,                       TRUE  },

  { "post",            0,                       TRUE  },

  { "pre",             0,                       TRUE  },

  { "remark",          0,                       TRUE  },

  { "remarks",         0,                       TRUE  },

  { "result",          0,                       TRUE  },

  { "return",          0,                       TRUE  },

  { "returns",         0,                       TRUE  },

  { "retval",          0,                       TRUE  },

  { "sa",              0,                       TRUE  },

  { "see",             0,                       TRUE  },

  { "since",           0,                       TRUE  },

  { "throw",           0,                       TRUE  },

  { "throws",          0,                       TRUE  },

  { "until",           0,                       TRUE  },

  { "verbinclude",     0,                       TRUE  },

  { "version",         0,                       TRUE  },

  { "warning",         0,                       TRUE  },

  { 0, 0, FALSE }

};

/** @brief Command mapper.

 *

 *  Maps a command name (as found in a comment block) onto a

 *  specific handler function.

 */

class DocCmdMapper

{

  public:

    struct Cmd

    {

      DocCmdFunc func;

      bool endsBrief;

    };

    /** maps a command name to a handler function */

    static Cmd *map(const char *name)

    {

      return instance()->find(name);

    }

    /** release the singleton */

    static void freeInstance()

    {

      delete s_instance; s_instance=0;

    }

  private:

    static DocCmdMapper *instance()

    {

      if (s_instance==0) s_instance = new DocCmdMapper;

      return s_instance;

    }

    DocCmdMapper() : m_map(113)

    {

      m_map.setAutoDelete(TRUE);

      DocCmdMap *p = docCmdMap;

      while (p->cmdName)

      {

	if (m_map.find(p->cmdName)!=0)

	{

	  printf("Error: DocCmdMapper: command %s already added\n",p->cmdName);

	  exit(1);

	}

	Cmd *cmd = new Cmd;

	cmd->func = p->handler;

	cmd->endsBrief = p->endsBrief;

	m_map.insert(p->cmdName,cmd);

	p++;

      }

    }

    Cmd *find(const char *name)

    {

      return m_map.find(name);

    }

    QDict<Cmd> m_map;

    static DocCmdMapper *s_instance;

};

DocCmdMapper *DocCmdMapper::s_instance=0;

#define YY_NEVER_INTERACTIVE 1

enum XRefKind

{

  XRef_Item,

  XRef_Todo,

  XRef_Test,

  XRef_Bug,

  XRef_Deprecated,

  XRef_None

};

enum OutputContext

{

  OutputDoc,

  OutputBrief,

  OutputXRef,

  OutputInbody

};

enum GuardType

{

  Guard_If,

  Guard_IfNot,

  Guard_Skip

};

class GuardedSection

{

  public:

    GuardedSection(bool enabled,bool parentVisible) 

      : m_enabled(enabled),m_parentVisible(parentVisible) {}

    bool isEnabled() const { return m_enabled; }

    bool parentVisible() const { return m_parentVisible; }

  private:

    bool m_enabled;

    bool m_parentVisible;

};

void openGroup(Entry *e,const char *file,int line);

void closeGroup(Entry *e,const char *file,int line);

void initGroupInfo(Entry *e);

static void groupAddDocs(Entry *e,const char *fileName);

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

 *

 *	statics

 */

static ParserInterface *langParser;          // the language parser that is calling us

static QCString         inputString;         // input string

static int		inputPosition;       // read pointer

static QCString		yyFileName;          // file name that is read from

static int		yyLineNr;            // line number in the input

static bool             inBody;              // was the comment found inside the body of a function?

static OutputContext    inContext;           // are we inside the brief, details or xref part

static bool             briefEndsAtDot;      // does the brief description stop at a dot?

static QCString         formulaText;         // Running text of a formula

static QCString         formulaEnv;          // environment name

static int              formulaNewLines;     // amount of new lines in the formula

static QCString        *pOutputString;       // pointer to string to which the output is appended.

static QCString         outputXRef;          // temp argument of todo/test/../xrefitem commands

static QCString         blockName;           // preformatted block name (e.g. verbatim, latexonly,...)

static XRefKind         xrefKind;            // kind of cross-reference command

static XRefKind         newXRefKind;         // 

static GuardType        guardType;           // kind of guard for conditional section

static bool             enabledSectionFound;

static QCString         functionProto;       // function prototype

static QStack<GuardedSection> guards;        // tracks nested conditional sections (if,ifnot,..)

static Entry*		current      = 0 ;   // working entry

//static Entry*		current_root = 0 ;   // parent of working entry

//static Entry*		previous     = 0 ;   // TODO: remove need for this

static bool             needNewEntry;

static QCString         sectionLabel;

static QCString		sectionTitle;

static QCString         xrefItemKey;

static QCString         newXRefItemKey;

static QCString         xrefItemTitle;

static QCString         xrefListTitle;

static Protection	protection;

static bool             xrefAppendFlag;

static bool             inGroupParamFound;

static int              braceCount;

static bool             insidePre;

static bool             parseMore;

static int              g_commentCount;

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

static QStack<Grouping> g_autoGroupStack;

static int              g_memberGroupId = DOX_NOGROUP;

static QCString         g_memberGroupHeader;

static QCString         g_memberGroupDocs;

static QCString         g_memberGroupRelates;

static QCString         g_compoundName;

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

static void initParser()

{

  sectionLabel.resize(0);

  sectionTitle.resize(0);

  g_memberGroupHeader.resize(0);

}

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

static QCString getDocSectionName(int s)

{

  switch(s)

  {

    case Entry::CLASSDOC_SEC:       return "\\class";

    case Entry::STRUCTDOC_SEC:      return "\\struct";

    case Entry::UNIONDOC_SEC:       return "\\union";

    case Entry::EXCEPTIONDOC_SEC:   return "\\exception";

    case Entry::NAMESPACEDOC_SEC:   return "\\namespace";

    case Entry::PROTOCOLDOC_SEC:    return "\\protocol";

    case Entry::CATEGORYDOC_SEC:    return "\\category";

    case Entry::ENUMDOC_SEC:        return "\\enum";

    case Entry::PAGEDOC_SEC:        return "\\page";

    case Entry::MEMBERDOC_SEC:      return "\\fn";

    case Entry::OVERLOADDOC_SEC:    return "\\overload";

    case Entry::FILEDOC_SEC:        return "\\file";

    case Entry::DEFINEDOC_SEC:      return "\\def";

    case Entry::GROUPDOC_SEC:       return "\\defgroup";

    case Entry::MAINPAGEDOC_SEC:    return "\\mainpage";

    case Entry::PACKAGEDOC_SEC:     return "\\package";

    case Entry::DIRDOC_SEC:         return "\\dir";

    case Entry::EXAMPLE_SEC:        return "\\example";

    case Entry::MEMBERGRP_SEC:      return "\\name";

    default: return "";

  }

}

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

static bool makeStructuralIndicator(Entry::Sections s)

{

  if (!getDocSectionName(current->section).isEmpty())

  {

    return TRUE;

  }

  else

  {

    needNewEntry = TRUE;

    current->section = s;

    current->fileName = yyFileName;

    current->startLine = yyLineNr;

    return FALSE;

  }

}

static void lineCount()

{

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

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

}

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;

}

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

static void addXRefItem(const char *listName,const char *itemTitle,

                        const char *listTitle,bool append)

{

  Entry *docEntry = current; // inBody && previous ? previous : current;

  if (listName==0) return;

  //printf("addXRefItem(%s,%s,%s,%d)\n",listName,itemTitle,listTitle,append);

  ListItemInfo *lii=0;

  RefList *refList = Doxygen::xrefLists->find(listName);

  if (refList==0) // new list

  {

    refList = new RefList(listName,listTitle,itemTitle);

    Doxygen::xrefLists->insert(listName,refList);

    //printf("new list!\n");

  }

  if (docEntry->sli)

  {

    QListIterator<ListItemInfo> slii(*docEntry->sli);

    for (slii.toFirst();(lii=slii.current());++slii)

    {

      if (strcmp(lii->type,listName)==0) 

      {

        //printf("found %s lii->type=%s\n",listName,lii->type);

        break;

      }

    }

  }

  if (lii && append) // already found item of same type just before this one

  {

    //printf("listName=%s item id = %d existing\n",listName,lii->itemId);

    RefItem *item = refList->getRefItem(lii->itemId);

    ASSERT(item!=0);

    item->text += " <p>";

    item->text += outputXRef;

    //printf("%s: text +=%s\n",listName,item->text.data());

  }

  else // new item

  {

    int itemId  = refList->addRefItem();

    //printf("listName=%s item id = %d new current=%p\n",listName,itemId,current);

    // if we have already an item from the same list type (e.g. a second @todo)