commentscan.l File Reference

#include <stdint.h>
#include <map>
#include <stack>
#include <string>
#include <mutex>
#include <functional>
#include <unordered_map>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include "dstring.h"
#include "fileinfo.h"
#include "cite.h"
#include "commentscan.h"
#include "condparser.h"
#include "config.h"
#include "debug.h"
#include "docgroup.h"
#include "doxygen.h"
#include "entry.h"
#include "formula.h"
#include "language.h"
#include "mermaid.h"
#include "message.h"
#include "parserintf.h"
#include "reflist.h"
#include "section.h"
#include "regex.h"
#include "util.h"
#include "trace.h"
#include "stringutil.h"
#include "markdown.h"
#include "doxygen_lex.h"
#include "commentscan.l.h"

Include dependency graph for commentscan.l:

Go to the source code of this file.

Classes
struct	DocCmdMap
struct	HtmlContextInfo
struct	commentscanYY_state
struct	CommentScanner::Private

Macros
#define	YY_TYPEDEF_YY_SCANNER_T
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	YY_NEVER_INTERACTIVE   1
#define	unput_string(yytext, yyleng)
#define	YY_INPUT(buf, result, max_size)

Typedefs
typedef yyguts_t *	yyscan_t
typedef bool(*)	DocCmdFunc(yyscan_t yyscanner, const DString &name, const StringVector &optList)
typedef EntryType(*)	MakeEntryType()
using	HtmlContextStack = std::vector<HtmlContextInfo>

Enumerations
enum	CommandSpacing { Invisible , Inline , Block , XRef }
enum	SectionHandling { Allowed , Replace , Escape , Break }
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_ElseIf }

Functions
static bool	handleBrief (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleFn (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleDef (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleOverload (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleEnum (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleDefGroup (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleAddToGroup (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleWeakGroup (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRequirement (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleSatisfies (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleVerifies (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleNamespace (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePackage (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleConcept (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleClass (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHeaderFile (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleProtocol (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCategory (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleUnion (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleStruct (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleInterface (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIdlException (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePage (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleMainpage (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleFile (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleDir (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleExample (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleDetails (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRaiseWarning (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleNoop (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleName (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleTodo (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleTest (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleBug (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleSubpage (yyscan_t yyscanner, const DString &s, const StringVector &)
static bool	handleDeprecated (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleXRefItem (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRelated (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRelatedAlso (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleMemberOf (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRefItem (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleSection (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleAnchor (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleImage (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCite (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleFormatBlock (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleMermaidFile (yyscan_t yyscanner, const DString &s, const StringVector &)
static bool	handleAddIndex (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIf (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIfNot (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleElseIf (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleElse (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleEndIf (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIngroup (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleNoSubGrouping (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleShowInitializer (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideInitializer (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCallgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideCallgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCallergraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideCallergraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIncludegraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIncludedBygraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleShowEnumValues (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideEnumValues (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleShowInlineSource (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideInlineSource (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideIncludegraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideIncludedBygraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleDirectoryGraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideDirectoryGraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCollaborationgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideCollaborationgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleInheritanceGraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideInheritanceGraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleReferencedByRelation (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideReferencedByRelation (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleReferencesRelation (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideReferencesRelation (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleGroupgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleHideGroupgraph (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleInternal (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleStatic (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePure (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePrivate (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePrivateSection (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleProtected (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleProtectedSection (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handlePublic (yyscan_t yyscanner, const DString &s, const StringVector &)
static bool	handlePublicSection (yyscan_t yyscanner, const DString &s, const StringVector &)
static bool	handleQualifier (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleToc (yyscan_t yyscanner, const DString &s, const StringVector &)
static bool	handleInherit (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleExtends (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCopyDoc (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCopyBrief (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleCopyDetails (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleParBlock (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleEndParBlock (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleParam (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleRetval (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleFileInfo (yyscan_t yyscanner, const DString &cmdName, const StringVector &optList)
static bool	handleFileInfoSection (yyscan_t yyscanner, const DString &cmdName, const StringVector &optList)
static bool	handleFileInfoResult (yyscan_t yyscanner, const DString &, const StringVector &optList, bool isSection)
static bool	handleLineInfo (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleModule (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIFile (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleILine (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIRaise (yyscan_t yyscanner, const DString &, const StringVector &)
static bool	handleIPrefix (yyscan_t yyscanner, const DString &, const StringVector &)
static const char *	stateToString (int state)
static DString	fileInfoLookup (const FileInfo &fi, const std::string &name)
static DString	stripQuotes (const char *s)
static SectionType	sectionLevelToType (int level)
static void	stripTrailingWhiteSpace (DString &s)
static void	initParser (yyscan_t yyscanner)
static bool	checkStructuralIndicator (yyscan_t yyscanner)
static bool	makeStructuralIndicator (yyscan_t yyscanner, MakeEntryType maker)
static void	lineCount (yyscan_t yyscanner)
static void	addRequirementId (yyscan_t yyscanner)
static void	addXRefItem (yyscan_t yyscanner, const DString &listName, const DString &itemTitle, const DString &listTitle, bool append)
static DString	addFormula (yyscan_t yyscanner)
static void	checkFormula (yyscan_t yyscanner)
static void	addSection (yyscan_t yyscanner, bool addYYtext=true)
static void	setOutput (yyscan_t yyscanner, OutputContext ctx)
static void	addAnchor (yyscan_t yyscanner, const DString &anchor, const DString &title="")
static void	addOutput (yyscan_t yyscanner, const char *s)
static void	addOutput (yyscan_t yyscanner, const DString &s)
static void	addOutput (yyscan_t yyscanner, char c)
static void	endBrief (yyscan_t yyscanner)
static void	handleGuard (yyscan_t yyscanner, const DString &expr)
static int	yyread (yyscan_t yyscanner, char *buf, int max_size)
static void	addCite (yyscan_t yyscanner)
static void	addIline (yyscan_t yyscanner, int lineNr)
static void	addIlineBreak (yyscan_t yyscanner, int lineNr)
static void	escapeLabel (DString &label)
static const char *	getLexerFILE ()
int	yylex (yyscan_t yyscanner)
static void	addXRefItemToEntry (Entry *current, const DString &docs, const DString &listName, const DString &itemTitle, const DString &listTitle, bool append, bool inBody, int lineNr)

Variables
static const std::unordered_map< std::string, DocCmdMap >	docCmdMap
static std::mutex	g_sectionMutex
static std::mutex	g_formulaMutex
static std::mutex	g_citeMutex
static const reg::Ex	nonBrief_re (R"( *[\\@]ifile \"[^\"]*\" [\\@]iline (\d+) [\\@]ilinebr ([ \n]*))")

Macro Definition Documentation

unput_string

#define unput_string	(		yytext,
			yyleng )

Value:

do { for (int i=(int)yyleng-1;i>=0;i--) unput(yytext[i]); } while(0)

Definition at line 574 of file commentscan.l.

Referenced by DocTokenizer::unputString().

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size )

Value:

result=yyread(yyscanner,buf,max_size);

Definition at line 579 of file commentscan.l.

YY_NEVER_INTERACTIVE

#define YY_NEVER_INTERACTIVE   1

Definition at line 424 of file commentscan.l.

YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 422 of file commentscan.l.

YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 423 of file commentscan.l.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 23 of file commentscan.l.

Typedef Documentation

DocCmdFunc

typedef bool(*) DocCmdFunc(yyscan_t yyscanner, const DString &name, const StringVector &optList)

Definition at line 186 of file commentscan.l.

HtmlContextStack

using HtmlContextStack = std::vector<HtmlContextInfo>

Definition at line 464 of file commentscan.l.

MakeEntryType

typedef EntryType(*) MakeEntryType()

Definition at line 187 of file commentscan.l.

yyscan_t

typedef yyguts_t* yyscan_t

Definition at line 25 of file commentscan.l.

Enumeration Type Documentation

CommandSpacing

enum CommandSpacing

strong

Enumerator
Invisible	command sets some property but does not appear in the output.
Inline	command appears inline in the output which can be a brief description.
Block	command starts a new paragraphs / ends a brief description.
XRef	command is a cross reference (todo, bug, test, deprecated, xrefitem).

Definition at line 189 of file commentscan.l.

{
  Invisible, //!< command sets some property but does not appear in the output.
  Inline,    //!< command appears inline in the output which can be a brief description.
  Block,     //!< command starts a new paragraphs / ends a brief description.
  XRef       //!< command is a cross reference (todo, bug, test, deprecated, xrefitem).
};

GuardType

enum GuardType

Enumerator
Guard_If
Guard_IfNot
Guard_ElseIf

Definition at line 445 of file commentscan.l.

{
  Guard_If,
  Guard_IfNot,
  Guard_ElseIf
};

OutputContext

enum OutputContext

Enumerator
OutputDoc
OutputBrief
OutputXRef
OutputInbody

Definition at line 437 of file commentscan.l.

{
  OutputDoc,
  OutputBrief,
  OutputXRef,
  OutputInbody
};

SectionHandling

enum SectionHandling

strong

Enumerator
Allowed	command is allowed without restrictions in section title
Replace	command will be handled in here / needs special handling here
Escape	command is not-allowed in section title, it will be escaped
Break	command is not-allowed in section title, it will end the section title

Definition at line 197 of file commentscan.l.

{
  Allowed, //!< command is allowed without restrictions in section title
  Replace, //!< command will be handled in here / needs special handling here
  Escape,  //!< command is not-allowed in section title, it will be escaped
  Break    //!< command is not-allowed in section title, it will end the section title
};

XRefKind

enum XRefKind

Enumerator
XRef_Item
XRef_Todo
XRef_Test
XRef_Bug
XRef_Deprecated
XRef_None

Definition at line 427 of file commentscan.l.

{
  XRef_Item,
  XRef_Todo,
  XRef_Test,
  XRef_Bug,
  XRef_Deprecated,
  XRef_None
};

Function Documentation

addAnchor()

void addAnchor ( yyscan_t yyscanner, const DString & anchor, const DString & title = "" )

static

Definition at line 4835 of file commentscan.l.

{
  std::unique_lock<std::mutex> lock(g_sectionMutex);
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  SectionManager &sm = SectionManager::instance();
  const SectionInfo *si = sm.find(anchor);
  if (si)
  {
    if (!si->ref().empty()) // we are from a tag file
    {
      si = sm.replace(anchor,yyextra->fileName,yyextra->lineNr,DString(),SectionType::Anchor,0);
      yyextra->current->anchors.push_back(si);
    }
    else if (si->lineNr() != -1)
    {
      warn(yyextra->fileName,yyextra->lineNr,
          "multiple use of section label '{}' while adding anchor, (first occurrence: {}, line {})",
          anchor,si->fileName(),si->lineNr());
    }
    else
    {
      warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding anchor, (first occurrence: {})",
          anchor,si->fileName());
    }
  }
  else
  {
    si = sm.add(anchor,yyextra->fileName,yyextra->lineNr,title,SectionType::Anchor,0);
    yyextra->current->anchors.push_back(si);
  }
}

References SectionManager::add(), addAnchor(), SectionType::Anchor, DString::empty(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, SectionManager::instance(), SectionInfo::lineNr(), SectionInfo::ref(), SectionManager::replace(), and warn.

Referenced by addAnchor(), and handleImage().

addCite()

void addCite ( yyscan_t yyscanner )

static

Definition at line 4638 of file commentscan.l.

{
  std::unique_lock<std::mutex> lock(g_citeMutex);
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  DString name(yytext);
  if (yytext[0] =='"')
  {
    name=yytext+1;
    name=name.left((int)yyleng-2);
  }
  CitationManager::instance().insert(name);
}

References addCite(), g_citeMutex, CitationManager::insert(), CitationManager::instance(), and DString::left().

Referenced by addCite().

addFormula()

DString addFormula ( yyscan_t yyscanner )

static

Definition at line 4562 of file commentscan.l.

{
  std::unique_lock<std::mutex> lock(g_formulaMutex);
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  DString formLabel;
  DString formula = (yyextra->formulaPreText +
                      yyextra->formulaText.stripLeadingAndTrailingEmptyLines() +
                      yyextra->formulaPostText).stripWhiteSpace();
  //printf("formulaText=\n=1=\n{%s}\n=2=\n{%s}\n=3=\n{%s}\n===",
  //    qPrint(yyextra->formulaText),
  //    qPrint(yyextra->formulaText.stripLeadingAndTrailingEmptyLines()),
  //    qPrint(formula)
  //    );
  int id = FormulaManager::instance().addFormula(formula);
  formLabel.sprintf("\\_form#%d",id);
  for (int i=0;i<yyextra->formulaNewLines;i++) formLabel+="@_fakenl"; // add fake newlines to
                                                         // keep the warnings
                                                         // correctly aligned.
  return formLabel;
}

References addFormula(), FormulaManager::addFormula(), g_formulaMutex, FormulaManager::instance(), DString::sprintf(), and DString::stripWhiteSpace().

Referenced by addFormula().

addIline()

void addIline ( yyscan_t yyscanner, int lineNr )

static

Definition at line 4890 of file commentscan.l.

{
  char cmd[30];
  snprintf(cmd,30," \\iline %d ",lineNr);
  addOutput(yyscanner, cmd);
}

References addIline(), and addOutput().

Referenced by addIline(), and endBrief().

addIlineBreak()

void addIlineBreak ( yyscan_t yyscanner, int lineNr )

static

Definition at line 4897 of file commentscan.l.

{
  char cmd[30];
  snprintf(cmd,30," \\iline %d \\ilinebr ",lineNr);
  addOutput(yyscanner, cmd);
}

References addIlineBreak(), and addOutput().

Referenced by addIlineBreak().

addOutput() [1/3]

void addOutput ( yyscan_t yyscanner, char c )

inlinestatic

Definition at line 4884 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  *yyextra->pOutputString+=c;
}

References addOutput().

addOutput() [2/3]

void addOutput ( yyscan_t yyscanner, const char * s )

inlinestatic

Definition at line 4868 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  //printf("addOutput(yyscanner,%s)\n",s);
  *yyextra->pOutputString+=s;
}

References addOutput().

Referenced by addIline(), addIlineBreak(), addOutput(), addOutput(), addOutput(), endBrief(), handleAddIndex(), handleAnchor(), handleCite(), handleCopyBrief(), handleCopyDetails(), handleCopyDoc(), handleDetails(), handleEndIf(), handleEndParBlock(), handleFileInfoResult(), handleFormatBlock(), handleIFile(), handleILine(), handleImage(), handleInternal(), handleIPrefix(), handleLineInfo(), handleMermaidFile(), handleParam(), handleParBlock(), handleRefItem(), handleRetval(), handleSection(), handleSubpage(), and CommentScanner::parseCommentBlock().

addOutput() [3/3]

void addOutput ( yyscan_t yyscanner, const DString & s )

inlinestatic

Definition at line 4876 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  //printf("addOutput(yyscanner,%s)\n",s);
  *yyextra->pOutputString+=s;
}

References addOutput().

addRequirementId()

void addRequirementId ( yyscan_t yyscanner )

static

Definition at line 4420 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  std::unique_lock<std::mutex> lock(g_sectionMutex);
 
  DString reqId = yyextra->current->name;
  //printf("### add reqId='%s' reqTitle='%s'\n",qPrint(reqId),qPrint(yyextra->current->type));
  SectionManager &sm = SectionManager::instance();
  const SectionInfo *si = sm.find(reqId);
  if (si==nullptr)
  {
    si = sm.add(reqId,"requirements",yyextra->lineNr,
               yyextra->current->type,SectionType::Requirement,1);
  }
  else // duplicate requirement
  {
    warn(yyextra->fileName,yyextra->lineNr,"duplicate requirement ID '{}' found at {} line {}, (first occurrence: {}, line {})",
         reqId,
         yyextra->fileName,yyextra->lineNr,
         si->fileName(),si->lineNr());
  }
}

References SectionManager::add(), addRequirementId(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, SectionManager::instance(), SectionInfo::lineNr(), SectionType::Requirement, and warn.

Referenced by addRequirementId().

addSection()

void addSection ( yyscan_t yyscanner, bool addYYtext = true )

static

Definition at line 4591 of file commentscan.l.

{
  std::unique_lock<std::mutex> lock(g_sectionMutex);
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  SectionManager &sm = SectionManager::instance();
  const SectionInfo *si = sm.find(yyextra->sectionLabel);
  if (si)
  {
    if (!si->ref().empty()) // we are from a tag file
    {
      // create a new section element
      if (addYYtext) yyextra->sectionTitle+=yytext;
      yyextra->sectionTitle=yyextra->sectionTitle.stripWhiteSpace();
      si = sm.replace(yyextra->sectionLabel,yyextra->fileName,yyextra->lineNr,
                      yyextra->sectionTitle,sectionLevelToType(yyextra->sectionLevel),
                      yyextra->sectionLevel);
 
      // add section to this entry
      yyextra->current->anchors.push_back(si);
    }
    else if (si->lineNr() != -1)
    {
      warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding section, (first occurrence: {}, line {})",
          yyextra->sectionLabel,si->fileName(),si->lineNr());
    }
    else
    {
      warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding section, (first occurrence: {})",
          yyextra->sectionLabel,si->fileName());
    }
  }
  else
  {
    // create a new section element
    if (addYYtext) yyextra->sectionTitle+=yytext;
    yyextra->sectionTitle=yyextra->sectionTitle.stripWhiteSpace();
    si = sm.add(yyextra->sectionLabel,yyextra->fileName,yyextra->lineNr,
                yyextra->sectionTitle,sectionLevelToType(yyextra->sectionLevel),
                yyextra->sectionLevel);
 
    // add section to this entry
    yyextra->current->anchors.push_back(si);
  }
}

References SectionManager::add(), addSection(), DString::empty(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, SectionManager::instance(), SectionInfo::lineNr(), SectionInfo::ref(), SectionManager::replace(), sectionLevelToType(), and warn.

Referenced by addSection().

addXRefItem()

void addXRefItem ( yyscan_t yyscanner, const DString & listName, const DString & itemTitle, const DString & listTitle, bool append )

static

Definition at line 4527 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addXRefItemToEntry(yyextra->current,yyextra->outputXRef,listName,itemTitle,listTitle,append,yyextra->inBody,yyextra->lineNr);
  yyextra->outputXRef.clear();
}

References addXRefItem(), and addXRefItemToEntry().

Referenced by addXRefItem(), and setOutput().

addXRefItemToEntry()

void addXRefItemToEntry ( Entry * current, const DString & docs, const DString & listName, const DString & itemTitle, const DString & listTitle, bool append, bool inBody, int lineNr )

static

Definition at line 4445 of file commentscan.l.

{
  if (listName.empty()) return;
  //printf("addXRefItem(listName=%s,itemTitle=%s,listTitle=%s,append=%d,inbody=%d)\n",
  //    qPrint(listName),qPrint(itemTitle),qPrint(listTitle),append,inBody);
 
  std::unique_lock<std::mutex> lock(g_sectionMutex);
 
  RefList *refList = RefListManager::instance().add(listName,listTitle,itemTitle);
  RefItem *item = nullptr;
  for (auto it = current->sli.rbegin(); it != current->sli.rend(); ++it)
  {
    RefItem *i = *it;
    if (i && i->list()->listName()==listName)
    {
      //printf("found %s lii->type=%s\n",listName,qPrint(i->list()->listName()));
      item = i;
      break;
    }
  }
  if (item && append) // already found item of same type just before this one
  {
    //printf("listName=%s item id = %d existing\n",listName,item->id());
    item->setText(item->text() + " <p>" + docs);
    //printf("%s: text +=%s\n",listName,qPrint(item->text));
  }
  else // new item
  {
    // if we have already an item from the same list type (e.g. a second @todo)
    // in the same Entry (i.e. lii!=0) then we reuse its link anchor.
    item = refList->add();
    //printf("listName=%s item id = %d new yyextra->current=%p\n",listName,item->id(),yyextra->current);
    DString anchorLabel;
    anchorLabel.sprintf("_%s%06d",listName.data(),item->id());
    item->setText(docs);
    item->setAnchor(anchorLabel);
    current->sli.push_back(item);
    DString cmdString;
    cmdString.sprintf("\\ilinebr \\xrefitem %s %d.",qPrint(listName),item->id());
    if (inBody)
    {
      current->inbodyDocs += cmdString;
    }
    else
    {
      current->doc += cmdString;
    }
 
    {
      SectionManager &sm = SectionManager::instance();
      const SectionInfo *si = sm.find(anchorLabel);
      if (si)
      {
        if (!si->ref().empty()) // we are from a tag file
        {
          si = sm.replace(anchorLabel,listName,lineNr,"",SectionType::Anchor,0);
          current->anchors.push_back(si);
        }
        else if (si->lineNr() != -1)
        {
          warn(listName,lineNr,"multiple use of section label '{}', (first occurrence: {}, line {})",
              anchorLabel,si->fileName(),si->lineNr());
        }
        else
        {
          warn(listName,lineNr,"multiple use of section label '{}', (first occurrence: {})",
              anchorLabel,si->fileName());
        }
      }
      else
      {
        si = sm.add(anchorLabel,listName,lineNr,"",SectionType::Anchor,0);
        current->anchors.push_back(si);
      }
    }
  }
}

References LinkedMap< T, Hash, KeyEqual, Map >::add(), RefList::add(), SectionManager::add(), addXRefItemToEntry(), SectionType::Anchor, Entry::anchors, DString::data(), Entry::doc, DString::empty(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, RefItem::id(), Entry::inbodyDocs, RefListManager::instance(), SectionManager::instance(), SectionInfo::lineNr(), RefItem::list(), RefList::listName(), qPrint(), SectionInfo::ref(), SectionManager::replace(), RefItem::setAnchor(), RefItem::setText(), Entry::sli, DString::sprintf(), RefItem::text(), and warn.

Referenced by CommentScanner::addDeprecatedDocs(), addXRefItem(), and addXRefItemToEntry().

checkFormula()

void checkFormula ( yyscan_t yyscanner )

static

Definition at line 4950 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (YY_START==ReadFormulaShort || YY_START==ReadFormulaShortSection ||
      YY_START==ReadFormulaRound || YY_START==ReadFormulaRoundSection ||
      YY_START==ReadFormulaLong)
  {
    warn(yyextra->fileName,yyextra->lineNr,"End of comment block while inside formula.");
  }
}

References checkFormula(), and warn.

Referenced by checkFormula(), and CommentScanner::parseCommentBlock().

checkStructuralIndicator()

bool checkStructuralIndicator ( yyscan_t yyscanner )

static

Definition at line 4364 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  //printf("yyextra->current->section=%x\n",yyextra->current->section);
  return yyextra->current->section.isDoc();
}

References checkStructuralIndicator().

Referenced by checkStructuralIndicator(), handleCategory(), handleClass(), handleConcept(), handleDef(), handleEnum(), handleFn(), handleIdlException(), handleInterface(), handleModule(), handleNamespace(), handleProtocol(), handleStruct(), and handleUnion().

endBrief()

void endBrief ( yyscan_t yyscanner )

static

Definition at line 4904 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  std::string_view str = yyextra->current->brief.view();
  reg::Match match;
  if (!stripWhiteSpace(str).empty() && !reg::match(str,match,nonBrief_re))
  { // only go to the detailed description if we have
    // found some brief description and not just whitespace
    yyextra->briefEndsAtDot=false;
    setOutput(yyscanner,OutputDoc);
    if (yyextra->current->doc.stripWhiteSpace().empty())
    {
      yyextra->current->docLine = yyextra->lineNr;
      yyextra->current->doc = "";
    }
    else
    {
      addIline(yyscanner,yyextra->lineNr);
    }
    addOutput(yyscanner,yytext);
  }
  else
  {
    int saveLineNr = yyextra->lineNr;
    lineCount(yyscanner);
    yyextra->current->briefLine = yyextra->lineNr;
    yyextra->lineNr = saveLineNr;
  }
}

References addIline(), addOutput(), endBrief(), lineCount, reg::match(), nonBrief_re, OutputDoc, setOutput(), and stripWhiteSpace().

Referenced by endBrief().

escapeLabel()

void escapeLabel ( DString & label )

static

Definition at line 4539 of file commentscan.l.

{
  if (label.empty()) return;
  char c = label[0];
  if (!((c>='a' && c<='z') || (c>='A' && c<='Z') || c=='_' || c<0))
  {
    label[0]='_'; // replace invalid starting char by _
  }
  for (size_t i=1; i<label.size(); i++)
  {
    c = label[i];
    if (!((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='_' || c<0))
    {
      label[i]='_'; // replace invalid char by _
    }
  }
}

References DString::empty(), escapeLabel(), and DString::size().

Referenced by escapeLabel().

fileInfoLookup()

DString fileInfoLookup ( const FileInfo & fi, const std::string & name )

static

Definition at line 3663 of file commentscan.l.

{
  using OptionFunc = std::function<DString(const FileInfo &)>;
  static std::unordered_map<std::string,OptionFunc> options =
  {
    // name,       function producing the value
    { "name",      [](const FileInfo &fi_) -> DString { return fi_.baseName();      } },
    { "extension", [](const FileInfo &fi_) -> DString { return fi_.extension(true); } },
    { "filename",  [](const FileInfo &fi_) -> DString { return fi_.fileName();      } },
    { "directory", [](const FileInfo &fi_) -> DString { return fi_.dirPath();       } },
    { "full",      [](const FileInfo &fi_) -> DString { return fi_.absFilePath();   } }
  };
  auto it = options.find(optionName);
  return (it!=options.end()) ? it->second(fi) : DString();
}

References DString::DString(), fileInfoLookup(), and DString::find().

Referenced by fileInfoLookup(), handleFileInfoResult(), and stateToString().

getLexerFILE()

const char * getLexerFILE ( )

inlinestatic

Definition at line 582 of file commentscan.l.

{return __FILE__;}

References getLexerFILE().

Referenced by getLexerFILE(), getLexerFILE(), getLexerFILE(), and getLexerFILE().

handleAddIndex()

bool handleAddIndex ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3646 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,yytext);
  BEGIN(LineParam);
  return false;
}

References addOutput(), and handleAddIndex().

Referenced by handleAddIndex().

handleAddToGroup()

bool handleAddToGroup ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3103 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeGroupDoc);
  yyextra->current->groupDocType = Entry::GROUPDOC_ADD;
  BEGIN( GroupDocArg1 );
  return stop;
}

References Entry::GROUPDOC_ADD, handleAddToGroup(), and makeStructuralIndicator().

Referenced by handleAddToGroup().

handleAnchor()

bool handleAnchor ( yyscan_t yyscanner, const DString & s, const StringVector & optList )

static

Definition at line 3550 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,"@"+s+" ");
  if (optList.empty())
  {
    yyextra -> anchorTitle = "";
  }
  else
  {
    yyextra -> anchorTitle = join(optList," ");
  }
  BEGIN(AnchorLabel);
  return false;
}

References addOutput(), handleAnchor(), and join().

Referenced by handleAnchor().

handleBrief()

bool handleBrief ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3049 of file commentscan.l.

{
  //printf("handleBrief\n");
  setOutput(yyscanner,OutputBrief);
  return false;
}

References handleBrief(), OutputBrief, and setOutput().

Referenced by handleBrief().

handleBug()

bool handleBug ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3368 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->newXRefKind = XRef_Bug;
  setOutput(yyscanner,OutputXRef);
  yyextra->xrefKind = XRef_Bug;
  return false;
}

References handleBug(), OutputXRef, setOutput(), and XRef_Bug.

Referenced by handleBug().

handleCallergraph()

bool handleCallergraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3950 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_callerGraph(true); // ON
  return false;
}

References handleCallergraph().

Referenced by handleCallergraph().

handleCallgraph()

bool handleCallgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3936 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_callGraph(true); // ON
  return false;
}

References handleCallgraph().

Referenced by handleCallgraph().

handleCategory()

bool handleCategory ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3180 of file commentscan.l.

{ // Obj-C category
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeCategoryDoc;
  BEGIN( CategoryDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleCategory().

Referenced by handleCategory().

handleCite()

bool handleCite ( yyscan_t yyscanner, const DString & s, const StringVector & optList )

static

Definition at line 3591 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  if (optList.empty())
  {
    addOutput(yyscanner,"@"+s+" ");
  }
  else
  {
    addOutput(yyscanner,"@"+s+"{"+DString(join(optList,","))+"} ");
  }
  BEGIN(CiteLabel);
  return false;
}

References addOutput(), DString::DString(), handleCite(), and join().

Referenced by handleCite().

handleClass()

bool handleClass ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3137 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeClassDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleClass().

Referenced by handleClass().

handleCollaborationgraph()

bool handleCollaborationgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4034 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_collaborationGraph(true); // ON
  return false;
}

References handleCollaborationgraph().

Referenced by handleCollaborationgraph().

handleConcept()

bool handleConcept ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3146 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeConceptDoc;
  BEGIN( ConceptDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleConcept().

Referenced by handleConcept().

handleCopyBrief()

bool handleCopyBrief ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4299 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->current->brief.stripWhiteSpace().empty() && yyextra->current->doc.stripWhiteSpace().empty())
  { // if we don't have a brief or detailed description yet,
    // then the @copybrief should end up in the brief description.
    // otherwise it will be copied inline (see bug691315 & bug700788)
    setOutput(yyscanner,OutputBrief);
  }
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,"\\copybrief ");
  return false;
}

References addOutput(), handleCopyBrief(), OutputBrief, and setOutput().

Referenced by handleCopyBrief().

handleCopyDetails()

bool handleCopyDetails ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4317 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  setOutput(yyscanner,OutputDoc);
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,"\\copydetails ");
  return false;
}

References addOutput(), handleCopyDetails(), OutputDoc, and setOutput().

Referenced by handleCopyDetails().

handleCopyDoc()

bool handleCopyDoc ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4330 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->current->brief.stripWhiteSpace().empty() && yyextra->current->doc.stripWhiteSpace().empty())
  { // if we don't have a brief or detailed description yet,
    // then the @copybrief should end up in the brief description.
    // otherwise it will be copied inline (see bug691315 & bug700788)
    setOutput(yyscanner,OutputBrief);
  }
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,"\\copybrief ");
  yyextra->copyDocArg.clear();
  yyextra->braceCount = 0;
  BEGIN(CopyDoc);
  return false;
}

References addOutput(), handleCopyDoc(), OutputBrief, and setOutput().

Referenced by handleCopyDoc().

handleDef()

bool handleDef ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3067 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->functionProto.clear();
  yyextra->braceCount=0;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeDefineDoc;
  BEGIN( FnParam );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleDef().

Referenced by handleDef().

handleDefGroup()

bool handleDefGroup ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3094 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeGroupDoc);
  yyextra->current->groupDocType = Entry::GROUPDOC_NORMAL;
  BEGIN( GroupDocArg1 );
  return stop;
}

References Entry::GROUPDOC_NORMAL, handleDefGroup(), and makeStructuralIndicator().

Referenced by handleDefGroup().

handleDeprecated()

bool handleDeprecated ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3377 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->newXRefKind = XRef_Deprecated;
  setOutput(yyscanner,OutputXRef);
  yyextra->xrefKind = XRef_Deprecated;
  yyextra->current->spec.setDeprDoc(true);
  return false;
}

References handleDeprecated(), OutputXRef, setOutput(), and XRef_Deprecated.

Referenced by handleDeprecated().

handleDetails()

bool handleDetails ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3307 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->inContext!=OutputBrief)
  {
    addOutput(yyscanner," \\ilinebr\\ilinebr "); // treat @details outside brief description
                                                // as a new paragraph
  }
  setOutput(yyscanner,OutputDoc);
  return false;
}

References addOutput(), handleDetails(), OutputBrief, OutputDoc, and setOutput().

Referenced by handleDetails().

handleDir()

bool handleDir ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3276 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeDirDoc);
  if (!stop) yyextra->current->name = yyextra->fileName;
  BEGIN( FileDocArg1 );
  return stop;
}

References handleDir(), and makeStructuralIndicator().

Referenced by handleDir().

handleDirectoryGraph()

bool handleDirectoryGraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4020 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_directoryGraph(true); // ON
  return false;
}

References handleDirectoryGraph().

Referenced by handleDirectoryGraph().

handleElse()

bool handleElse ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3838 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->guards->empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\else without matching start command");
  }
  else if (yyextra->guards->top().hasElse())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found multiple \\else commands in same \\if construct");
    yyextra->guards->top().setEnabled(false);
    yyextra->guards->top().setElse();
    BEGIN( SkipGuardedSection );
  }
  else
  {
    yyextra->guards->top().setElse();
    yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
    if (yyextra->guards->top().isEnabledFound())
    {
      yyextra->guards->top().setEnabled(false);
      BEGIN( SkipGuardedSection );
    }
    else
    {
      yyextra->guards->top().setEnabled(true);
      BEGIN( GuardParamEnd );
    }
  }
  return false;
}

References handleElse(), and warn.

Referenced by handleElse().

handleElseIf()

bool handleElseIf ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3811 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->guards->empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\elseif without matching start command");
  }
  else if (yyextra->guards->top().hasElse())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\elseif command after \\else command was given in \\if construct");
    yyextra->guardType = Guard_ElseIf;
    yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
    yyextra->guards->top().setEnabled(false);
    BEGIN(GuardParam);
  }
  else
  {
    yyextra->guardType = Guard_ElseIf;
    yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
    yyextra->guards->top().setEnabled(false);
    BEGIN(GuardParam);
  }
  return false;
}

References Guard_ElseIf, handleElseIf(), and warn.

Referenced by handleElseIf().

handleEndIf()

bool handleEndIf ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3872 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->guards->empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\endif without matching start command");
  }
  else
  {
    yyextra->guards->pop();
  }
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  if (yyextra->guards->empty())
  {
    BEGIN( GuardParamEnd );
  }
  else
  {
    if (yyextra->guards->top().isEnabled())
    {
      BEGIN( GuardParamEnd );
    }
    else
    {
      BEGIN( SkipGuardedSection );
    }
  }
  return false;
}

References addOutput(), handleEndIf(), and warn.

Referenced by handleEndIf().

handleEndParBlock()

bool handleEndParBlock ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3413 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->insideParBlock)
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\endparblock command without matching \\parblock!");
  }
  addOutput(yyscanner,"@endparblock");
  setOutput(yyscanner,OutputDoc); // to end a parblock inside a xrefitem like context
  yyextra->insideParBlock = false;
  return false;
}

References addOutput(), handleEndParBlock(), OutputDoc, setOutput(), and warn.

Referenced by handleEndParBlock().

handleEnum()

bool handleEnum ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3086 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentMakeEntryType = EntryType::makeEnumDoc;
  BEGIN( EnumDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleEnum().

Referenced by handleEnum().

handleExample()

bool handleExample ( yyscan_t yyscanner, const DString & cmd, const StringVector & optList )

static

Definition at line 3285 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  MakeEntryType sectionMaker = EntryType::makeExample;
  for (const auto &opt : optList)
  {
    if (opt=="lineno")
    {
      sectionMaker=EntryType::makeExampleLineno;
    }
    else
    {
      warn(yyextra->fileName,yyextra->lineNr,
          "unsupported option '{}' for command '\\{}'",opt,cmd);
    }
  }
  bool stop=makeStructuralIndicator(yyscanner,sectionMaker);
  if (!stop) yyextra->current->name = yyextra->fileName;
  BEGIN( FileDocArg1 );
  return stop;
}

References handleExample(), makeStructuralIndicator(), and warn.

Referenced by handleExample().

handleExtends()

bool handleExtends ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 4291 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  BEGIN(ExtendsParam);
  return false;
}

References handleExtends().

Referenced by handleExtends().

handleFile()

bool handleFile ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3246 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeFileDoc);
  if (!stop)
  {
    yyextra->current->name = yyextra->fileName;
  }
  BEGIN( FileDocArg1 );
  return stop;
}

References handleFile(), and makeStructuralIndicator().

Referenced by handleFile().

handleFileInfo()

bool handleFileInfo ( yyscan_t yyscanner, const DString & cmdName, const StringVector & optList )

static

Definition at line 3654 of file commentscan.l.

{
  return handleFileInfoResult(yyscanner,cmdName, optList, false);
}

References handleFileInfo(), and handleFileInfoResult().

Referenced by handleFileInfo().

handleFileInfoResult()

bool handleFileInfoResult ( yyscan_t yyscanner, const DString & , const StringVector & optList, bool isSection )

static

Definition at line 3679 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->spaceBeforeCmd.empty())
  {
    if (isSection) yyextra->sectionTitle+=yyextra->spaceBeforeCmd;
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  bool first = true;
  FileInfo fi(yyextra->fileName.str());
  for (const auto &opt_ : optList)
  {
    DString optStripped = DString(opt_).stripWhiteSpace();
    std::string opt = optStripped.lower().str();
    DString result = fileInfoLookup(fi,opt);
    if (!result.empty())
    {
      if (!first)
      {
        warn(yyextra->fileName,yyextra->lineNr,"Multiple options specified with \\fileinfo, discarding '{}'", optStripped);
      }
      else
      {
        addOutput(yyscanner,result);
        if (isSection)
        {
          yyextra->sectionTitle+=result;
        }
      }
      first = false;
    }
    else
    {
      warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\fileinfo: '{}'", optStripped);
    }
  }
  if (first) // no options specified
  {
    if (Config_getBool(FULL_PATH_NAMES))
    {
      if (isSection) yyextra->sectionTitle+=stripFromPath(yyextra->fileName);
      addOutput(yyscanner,stripFromPath(yyextra->fileName));
    }
    else
    {
      if (isSection) yyextra->sectionTitle+=yyextra->fileName;
      addOutput(yyscanner,yyextra->fileName);
    }
  }
  return false;
}

References addOutput(), Config_getBool, DString::DString(), DString::empty(), fileInfoLookup(), handleFileInfoResult(), DString::lower(), DString::str(), stripFromPath(), DString::stripWhiteSpace(), and warn.

Referenced by handleFileInfo(), handleFileInfoResult(), and handleFileInfoSection().

handleFileInfoSection()

bool handleFileInfoSection ( yyscan_t yyscanner, const DString & cmdName, const StringVector & optList )

static

Definition at line 3658 of file commentscan.l.

{
  return handleFileInfoResult(yyscanner,cmdName, optList, true);
}

References handleFileInfoResult(), and handleFileInfoSection().

Referenced by handleFileInfoSection().

handleFn()

bool handleFn ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3056 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->braceCount=0;
  yyextra->functionProto.clear();
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeMemberDoc;
  BEGIN( FnParam );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleFn().

Referenced by handleFn().

handleFormatBlock()

bool handleFormatBlock ( yyscan_t yyscanner, const DString & s, const StringVector & optList )

static

Definition at line 3611 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  if (s=="mermaid")
  {
    MermaidManager::instance().setHasInlineDiagrams();
  }
  if (optList.empty())
  {
    addOutput(yyscanner,"@"+s+" ");
  }
  else
  {
    addOutput(yyscanner,"@"+s+"{"+DString(join(optList,","))+"} ");
  }
  //printf("handleFormatBlock(%s) with option(%s)\n",qPrint(s),qPrint(opt));
  yyextra->blockName=s;
  yyextra->commentCount=0;
  BEGIN(FormatBlock);
  return false;
}

References addOutput(), DString::DString(), handleFormatBlock(), MermaidManager::instance(), join(), and MermaidManager::setHasInlineDiagrams().

Referenced by handleFormatBlock().

handleGroupgraph()

bool handleGroupgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4048 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_groupGraph(true); // ON
  return false;
}

References handleGroupgraph().

Referenced by handleGroupgraph().

handleGuard()

void handleGuard ( yyscan_t yyscanner, const DString & expr )

static

Definition at line 5112 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  CondParser prs;
  bool sectionEnabled = false;
  if (!expr.empty())
  {
    sectionEnabled=prs.parse(yyextra->fileName,yyextra->lineNr,expr.stripWhiteSpace());
  }
  bool parentEnabled = yyextra->guards->top().parentVisible();
  if (parentEnabled)
  {
    if (
        (sectionEnabled && yyextra->guardType==Guard_If) ||
        (!sectionEnabled && yyextra->guardType==Guard_IfNot)
       ) // section is visible
    {
 
      yyextra->guards->top().setEnabled(true);
      yyextra->guards->top().setEnabledFound();
      BEGIN( GuardParamEnd );
    }
    else if (yyextra->guardType==Guard_ElseIf)
    {
      if (yyextra->guards->top().isEnabledFound())
      {
        yyextra->guards->top().setEnabled(false);
        BEGIN( SkipGuardedSection );
      }
      else if (sectionEnabled)
      {
        yyextra->guards->top().setEnabled(true);
        yyextra->guards->top().setEnabledFound();
        BEGIN( GuardParamEnd );
      }
      else
      {
        yyextra->guards->top().setEnabled(false);
        BEGIN( SkipGuardedSection );
      }
    }
    else // section is invisible
    {
      BEGIN( SkipGuardedSection );
    }
  }
  else // invisible because of parent
  {
    BEGIN( SkipGuardedSection );
  }
}

References DString::empty(), Guard_ElseIf, Guard_If, Guard_IfNot, handleGuard(), CondParser::parse(), and DString::stripWhiteSpace().

Referenced by handleGuard().

handleHeaderFile()

bool handleHeaderFile ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3164 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN( ClassDocArg2 );
  return false;
}

References handleHeaderFile().

Referenced by handleHeaderFile().

handleHideCallergraph()

bool handleHideCallergraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3957 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_callerGraph(false); // OFF
  return false;
}

References handleHideCallergraph().

Referenced by handleHideCallergraph().

handleHideCallgraph()

bool handleHideCallgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3943 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_callGraph(false); // OFF
  return false;
}

References handleHideCallgraph().

Referenced by handleHideCallgraph().

handleHideCollaborationgraph()

bool handleHideCollaborationgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4041 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_collaborationGraph(false); // OFF
  return false;
}

References handleHideCollaborationgraph().

Referenced by handleHideCollaborationgraph().

handleHideDirectoryGraph()

bool handleHideDirectoryGraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4027 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_directoryGraph(false); // OFF
  return false;
}

References handleHideDirectoryGraph().

Referenced by handleHideDirectoryGraph().

handleHideEnumValues()

bool handleHideEnumValues ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3971 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_enumValues(false); // OFF
  return false;
}

References handleHideEnumValues().

Referenced by handleHideEnumValues().

handleHideGroupgraph()

bool handleHideGroupgraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4055 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_groupGraph(false); // OFF
  return false;
}

References handleHideGroupgraph().

Referenced by handleHideGroupgraph().

handleHideIncludedBygraph()

bool handleHideIncludedBygraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4013 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_includedByGraph(false); // OFF
  return false;
}

References handleHideIncludedBygraph().

Referenced by handleHideIncludedBygraph().

handleHideIncludegraph()

bool handleHideIncludegraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4006 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_includeGraph(false); // OFF
  return false;
}

References handleHideIncludegraph().

Referenced by handleHideIncludegraph().

handleHideInheritanceGraph()

bool handleHideInheritanceGraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4101 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::NO); // OFF
  return false;
}

References handleHideInheritanceGraph().

Referenced by handleHideInheritanceGraph().

handleHideInitializer()

bool handleHideInitializer ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3929 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->initLines = 0; // OFF
  return false;
}

References handleHideInitializer().

Referenced by handleHideInitializer().

handleHideInlineSource()

bool handleHideInlineSource ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3985 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_inlineSource(false); // OFF
  return false;
}

References handleHideInlineSource().

Referenced by handleHideInlineSource().

handleHideReferencedByRelation()

bool handleHideReferencedByRelation ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4115 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_referencedByRelation(false); // OFF
  return false;
}

References handleHideReferencedByRelation().

Referenced by handleHideReferencedByRelation().

handleHideReferencesRelation()

bool handleHideReferencesRelation ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4129 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_referencesRelation(false); // OFF
  return false;
}

References handleHideReferencesRelation().

Referenced by handleHideReferencesRelation().

handleIdlException()

bool handleIdlException ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3216 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeExceptionDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleIdlException().

Referenced by handleIdlException().

handleIf()

bool handleIf ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3775 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->guardType = Guard_If;
  yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
  if (yyextra->guards->empty())
  {
    yyextra->guards->emplace(true);
  }
  else
  {
    bool enabled  = yyextra->guards->top().isEnabled();
    yyextra->guards->emplace(enabled);
  }
  BEGIN(GuardParam);
  return false;
}

References Guard_If, and handleIf().

Referenced by handleIf().

handleIFile()

bool handleIFile ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3752 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,yytext);
  BEGIN(IFile);
  return false;
}

References addOutput(), and handleIFile().

Referenced by handleIFile().

handleIfNot()

bool handleIfNot ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3793 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->guardType = Guard_IfNot;
  yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
  if (yyextra->guards->empty())
  {
    yyextra->guards->emplace(true);
  }
  else
  {
    bool enabled  = yyextra->guards->top().isEnabled();
    yyextra->guards->emplace(enabled);
  }
  BEGIN(GuardParam);
  return false;
}

References Guard_IfNot, and handleIfNot().

Referenced by handleIfNot().

handleILine()

bool handleILine ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3744 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,yytext);
  BEGIN(ILine);
  return false;
}

References addOutput(), and handleILine().

Referenced by handleILine().

handleImage()

bool handleImage ( yyscan_t yyscanner, const DString & s, const StringVector & optList )

static

Definition at line 3566 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  for (const auto &opt : optList)
  {
    DString locOpt(opt);
    locOpt = locOpt.stripWhiteSpace();
    if (locOpt.lower().startsWith("anchor:"))
    {
      addAnchor(yyscanner,locOpt.mid(7));
      break; // real option handling will be done later on
    }
  }
  if (optList.empty())
  {
    addOutput(yyscanner,"@"+s+" ");
  }
  else
  {
    addOutput(yyscanner,"@"+s+"{"+DString(join(optList,","))+"} ");
  }
  BEGIN(Comment);
  return false;
}

References addAnchor(), addOutput(), DString::DString(), handleImage(), join(), DString::lower(), DString::mid(), DString::startsWith(), and DString::stripWhiteSpace().

Referenced by handleImage().

handleIncludedBygraph()

bool handleIncludedBygraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3999 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_includedByGraph(true); // ON
  return false;
}

References handleIncludedBygraph().

Referenced by handleIncludedBygraph().

handleIncludegraph()

bool handleIncludegraph ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3992 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_includeGraph(true); // ON
  return false;
}

References handleIncludegraph().

Referenced by handleIncludegraph().

handleIngroup()

bool handleIngroup ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3907 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->inGroupParamFound=false;
  BEGIN( InGroupParam );
  return false;
}

References handleIngroup().

Referenced by handleIngroup().

handleInherit()

bool handleInherit ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4284 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN(InheritParam);
  return false;
}

References handleInherit().

Referenced by handleInherit().

handleInheritanceGraph()

bool handleInheritanceGraph ( yyscan_t yyscanner, const DString & , const StringVector & optList )

static

Definition at line 4062 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::YES);
  for (const auto &opt_ : optList)
  {
    DString opt = DString(opt_).stripWhiteSpace().lower();
    if (!opt.empty())
    {
      if (opt == "yes")
      {
        yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::YES);
      }
      else if (opt == "graph")
      {
        yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::GRAPH);
      }
      else if (opt == "builtin")
      {
        yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::BUILTIN);
      }
      else if (opt == "text")
      {
        yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::TEXT);
      }
      else if (opt == "no")
      {
        yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::NO);
      }
      else
      {
        warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\inheritancegraph: '{}'",
            DString(opt_).stripWhiteSpace());
      }
    }
  }
  return false;
}

References DString::DString(), DString::empty(), handleInheritanceGraph(), DString::lower(), DString::stripWhiteSpace(), stripWhiteSpace(), and warn.

Referenced by handleInheritanceGraph().

handleInterface()

bool handleInterface ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3207 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeInterfaceDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleInterface().

Referenced by handleInterface().

handleInternal()

bool handleInternal ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4144 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!Config_getBool(INTERNAL_DOCS))
  {
    // make sure some whitespace before a \internal command
    // is not treated as "documentation"
    if (yyextra->current->doc.stripWhiteSpace().empty())
    {
      yyextra->current->doc.clear();
    }
    yyextra->condCount=0;
    BEGIN( SkipInternal );
  }
  else
  {
    // re-enabled for bug640828
    addOutput(yyscanner," \\internal ");
    yyextra->inInternalDocs = true;
  }
  return false;
}

References addOutput(), Config_getBool, and handleInternal().

Referenced by handleInternal().

handleIPrefix()

bool handleIPrefix ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3767 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,"@iprefix ");
  BEGIN(IRaisePrefix);
  return false;
}

References addOutput(), and handleIPrefix().

Referenced by handleIPrefix().

handleIRaise()

bool handleIRaise ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3760 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN(IRaise);
  return false;
}

References handleIRaise().

Referenced by handleIRaise().

handleLineInfo()

bool handleLineInfo ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3732 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,DString().setNum(yyextra->lineNr));
  return false;
}

References addOutput(), DString::DString(), and handleLineInfo().

Referenced by handleLineInfo().

handleMainpage()

bool handleMainpage ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3233 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeMainpageDoc);
  if (!stop)
  {
    yyextra->current->name = "mainpage";
  }
  setOutput(yyscanner,OutputDoc);
  BEGIN( PageDocArg2 );
  return stop;
}

References handleMainpage(), makeStructuralIndicator(), OutputDoc, and setOutput().

Referenced by handleMainpage().

handleMemberOf()

bool handleMemberOf ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3455 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->current->relates.empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
  }
  yyextra->current->relatesType = RelatesType::MemberOf;
  yyextra->currentCmd = cmd;
  BEGIN(RelatesParam1);
  return false;
}

References handleMemberOf(), and warn.

Referenced by handleMemberOf().

handleMermaidFile()

bool handleMermaidFile ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 3638 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  MermaidManager::instance().setHasInlineDiagrams();
  addOutput(yyscanner,yytext);
  return false;
}

References addOutput(), handleMermaidFile(), MermaidManager::instance(), and MermaidManager::setHasInlineDiagrams().

Referenced by handleMermaidFile().

handleModule()

bool handleModule ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3155 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeModuleDoc;
  BEGIN( ModuleDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleModule().

Referenced by handleModule().

handleName()

bool handleName ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3334 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeMemberGrp);
  if (!stop)
  {
    yyextra->docGroup.clearHeader();
    BEGIN( NameParam );
    if (!yyextra->docGroup.empty()) // end of previous member group
    {
      yyextra->docGroup.close(yyextra->current,yyextra->fileName,yyextra->lineNr,true,true);
    }
  }
  return stop;
}

References handleName(), and makeStructuralIndicator().

Referenced by handleName().

handleNamespace()

bool handleNamespace ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3121 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentMakeEntryType = EntryType::makeNamespaceDoc;
  BEGIN( NameSpaceDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleNamespace().

Referenced by handleNamespace().

handleNoop()

bool handleNoop ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3327 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN( Noop );
  return false;
}

References handleNoop().

Referenced by handleNoop().

handleNoSubGrouping()

bool handleNoSubGrouping ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3915 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->subGrouping = false;
  return false;
}

References handleNoSubGrouping().

Referenced by handleNoSubGrouping().

handleOverload()

bool handleOverload ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3078 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->functionProto.clear();
  BEGIN(OverloadParam);
  return false;
}

References handleOverload().

Referenced by handleOverload().

handlePackage()

bool handlePackage ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3129 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makePackageDoc);
  BEGIN( PackageDocArg1 );
  return stop;
}

References handlePackage(), and makeStructuralIndicator().

Referenced by handlePackage().

handlePage()

bool handlePage ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3225 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makePageDoc);
  BEGIN( PageDocArg1 );
  return stop;
}

References handlePage(), and makeStructuralIndicator().

Referenced by handlePage().

handleParam()

bool handleParam ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3258 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  // we need process param and retval arguments to escape leading underscores in case of
  // markdown processing, see bug775493
  addOutput(yyscanner,"@param ");
  BEGIN( ParamArg1 );
  return false;
}

References addOutput(), and handleParam().

Referenced by handleParam().

handleParBlock()

bool handleParBlock ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3395 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->insideParBlock)
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\parblock command while already in a parblock!");
  }
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,"@parblock ");
  yyextra->insideParBlock = true;
  return false;
}

References addOutput(), handleParBlock(), and warn.

Referenced by handleParBlock().

handlePrivate()

bool handlePrivate ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4181 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = Protection::Private;
  return false;
}

References handlePrivate().

Referenced by handlePrivate().

handlePrivateSection()

bool handlePrivateSection ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4188 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = yyextra->protection = Protection::Private;
  return false;
}

References handlePrivateSection().

Referenced by handlePrivateSection().

handleProtected()

bool handleProtected ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4195 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = Protection::Protected;
  return false;
}

References handleProtected().

Referenced by handleProtected().

handleProtectedSection()

bool handleProtectedSection ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4202 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = yyextra->protection = Protection::Protected ;
  return false;
}

References handleProtectedSection().

Referenced by handleProtectedSection().

handleProtocol()

bool handleProtocol ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3171 of file commentscan.l.

{ // Obj-C protocol
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeProtocolDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleProtocol().

Referenced by handleProtocol().

handlePublic()

bool handlePublic ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 4209 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = Protection::Public;
  return false;
}

References handlePublic().

Referenced by handlePublic().

handlePublicSection()

bool handlePublicSection ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 4216 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->protection = yyextra->protection = Protection::Public;
  return false;
}

References handlePublicSection().

Referenced by handlePublicSection().

handlePure()

bool handlePure ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4174 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->virt = Specifier::Pure;
  return false;
}

References handlePure().

Referenced by handlePure().

handleQualifier()

bool handleQualifier ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 4136 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  BEGIN(Qualifier);
  return false;
}

References handleQualifier().

Referenced by handleQualifier().

handleRaiseWarning()

bool handleRaiseWarning ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3319 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->raiseWarning = "";
  BEGIN( RaiseWarning );
  return false;
}

References handleRaiseWarning().

Referenced by handleRaiseWarning().

handleReferencedByRelation()

bool handleReferencedByRelation ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4108 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_referencedByRelation(true); // ON
  return false;
}

References handleReferencedByRelation().

Referenced by handleReferencedByRelation().

handleReferencesRelation()

bool handleReferencesRelation ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4122 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_referencesRelation(true); // ON
  return false;
}

References handleReferencesRelation().

Referenced by handleReferencesRelation().

handleRefItem()

bool handleRefItem ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3469 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,"@refitem ");
  BEGIN(LineParam);
  return false;
}

References addOutput(), and handleRefItem().

Referenced by handleRefItem().

handleRelated()

bool handleRelated ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3427 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->current->relates.empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
  }
  yyextra->current->relatesType = RelatesType::Simple;
  yyextra->currentCmd = cmd;
  BEGIN(RelatesParam1);
  return false;
}

References handleRelated(), and warn.

Referenced by handleRelated().

handleRelatedAlso()

bool handleRelatedAlso ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3441 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->current->relates.empty())
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
  }
  yyextra->current->relatesType = RelatesType::Duplicate;
  yyextra->currentCmd = cmd;
  BEGIN(RelatesParam1);
  return false;
}

References handleRelatedAlso(), and warn.

Referenced by handleRelatedAlso().

handleRequirement()

bool handleRequirement ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 3507 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeRequirementDoc);
  BEGIN( RequirementLabel );
  return stop;
}

References handleRequirement(), and makeStructuralIndicator().

Referenced by handleRequirement().

handleRetval()

bool handleRetval ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3268 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  addOutput(yyscanner,"@retval ");
  BEGIN( ParamArg1 );
  return false;
}

References addOutput(), and handleRetval().

Referenced by handleRetval().

handleSatisfies()

bool handleSatisfies ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3515 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN( SatisfiesLabel );
  return false;
}

References handleSatisfies().

Referenced by handleSatisfies().

handleSection()

bool handleSection ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 3477 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  setOutput(yyscanner,OutputDoc);
  //printf("handleSection(%s) raiseLevel=%d\n",qPrint(s),yyextra->raiseLevel);
  BEGIN(SectionLabel);
  yyextra->sectionLabel.clear();
  // determine natural section level
  if      (s=="section")         yyextra->sectionLevel=SectionType::Section;
  else if (s=="subsection")      yyextra->sectionLevel=SectionType::Subsection;
  else if (s=="subsubsection")   yyextra->sectionLevel=SectionType::Subsubsection;
  else if (s=="paragraph")       yyextra->sectionLevel=SectionType::Paragraph;
  else if (s=="subparagraph")    yyextra->sectionLevel=SectionType::Subparagraph;
  else if (s=="subsubparagraph") yyextra->sectionLevel=SectionType::Subsubparagraph;
  // raise it if requested
  yyextra->sectionLevel = std::min(yyextra->sectionLevel + yyextra->raiseLevel,SectionType::MaxLevel);
  // rewrite the update section level to the output
  switch (yyextra->sectionLevel)
  {
    case SectionType::Section:         addOutput(yyscanner,"@section ");         break;
    case SectionType::Subsection:      addOutput(yyscanner,"@subsection ");      break;
    case SectionType::Subsubsection:   addOutput(yyscanner,"@subsubsection ");   break;
    case SectionType::Paragraph:       addOutput(yyscanner,"@paragraph ");       break;
    case SectionType::Subparagraph:    addOutput(yyscanner,"@subparagraph ");    break;
    case SectionType::Subsubparagraph: addOutput(yyscanner,"@subsubparagraph "); break;
    default: addOutput(yyscanner,"@"+s+" ");           break;
  }
  return false;
}

References addOutput(), handleSection(), SectionType::MaxLevel, OutputDoc, SectionType::Paragraph, SectionType::Section, setOutput(), SectionType::Subparagraph, SectionType::Subsection, SectionType::Subsubparagraph, and SectionType::Subsubsection.

Referenced by handleSection().

handleShowEnumValues()

bool handleShowEnumValues ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3964 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_enumValues(true); // ON
  return false;
}

References handleShowEnumValues().

Referenced by handleShowEnumValues().

handleShowInitializer()

bool handleShowInitializer ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3922 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->initLines = 100000; // ON
  return false;
}

References handleShowInitializer().

Referenced by handleShowInitializer().

handleShowInlineSource()

bool handleShowInlineSource ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3978 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->commandOverrides.override_inlineSource(true); // ON
  return false;
}

References handleShowInlineSource().

Referenced by handleShowInlineSource().

handleStatic()

bool handleStatic ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 4167 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->current->isStatic = true;
  return false;
}

References handleStatic().

Referenced by handleStatic().

handleStruct()

bool handleStruct ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3198 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeStructDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleStruct().

Referenced by handleStruct().

handleSubpage()

bool handleSubpage ( yyscan_t yyscanner, const DString & s, const StringVector &  )

static

Definition at line 3529 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->current->section.isEmpty() &&
      !yyextra->current->section.isPageDoc() &&
      !yyextra->current->section.isMainpageDoc()
     )
  {
    warn(yyextra->fileName,yyextra->lineNr,
        "found \\subpage command in a comment block that is not marked as a page!");
  }
  if (!yyextra->spaceBeforeCmd.empty())
  {
    addOutput(yyscanner,yyextra->spaceBeforeCmd);
    yyextra->spaceBeforeCmd.clear();
  }
  addOutput(yyscanner,"@"+s+" ");
  BEGIN(SubpageLabel);
  return false;
}

References addOutput(), handleSubpage(), and warn.

Referenced by handleSubpage().

handleTest()

bool handleTest ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3359 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->newXRefKind = XRef_Test;
  setOutput(yyscanner,OutputXRef);
  yyextra->xrefKind = XRef_Test;
  return false;
}

References handleTest(), OutputXRef, setOutput(), and XRef_Test.

Referenced by handleTest().

handleToc()

bool handleToc ( yyscan_t yyscanner, const DString & s, const StringVector & optList )

static

Definition at line 4223 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->current->section.isPageDoc() ||
      yyextra->current->section.isMainpageDoc())
  {
    for (const auto &opt_ : optList)
    {
      DString opt = DString(opt_).stripWhiteSpace().lower();
      int level = SectionType::MaxLevel;
      size_t i = opt.find(':');
      if (i!=DString::npos && i>0)  // found ':' but not on position 0 what would mean just a level
      {
        char dum=0;
        if (sscanf(opt.mid(i+1).data(),"%d%c",&level,&dum) != 1)
        {
          warn(yyextra->fileName,yyextra->lineNr,"Unknown option:level specified with \\tableofcontents: '{}'",
              qPrint(DString(opt_).stripWhiteSpace()));
          opt = "";
        }
        else
        {
          level = level<=0 ? SectionType::MaxLevel : std::min(level,SectionType::MaxLevel);
          opt = opt.left(i).stripWhiteSpace();
        }
      }
      if (!opt.empty())
      {
        if (opt == "html")
        {
          yyextra->current->localToc.enableHtml(level);
        }
        else if (opt == "latex")
        {
          yyextra->current->localToc.enableLatex(level);
        }
        else if (opt == "xml")
        {
          yyextra->current->localToc.enableXml(level);
        }
        else if (opt == "docbook")
        {
          yyextra->current->localToc.enableDocbook(level);
        }
        else
        {
          warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\tableofcontents: '{}'",
              DString(opt_).stripWhiteSpace());
        }
      }
    }
    if (yyextra->current->localToc.nothingEnabled())
    {
      // for backward compatibility
      yyextra->current->localToc.enableHtml(SectionType::MaxLevel);
      yyextra->current->localToc.enableXml(SectionType::MaxLevel);
    }
  }
  return false;
}

References DString::data(), DString::DString(), DString::empty(), DString::find(), handleToc(), DString::left(), DString::lower(), SectionType::MaxLevel, DString::mid(), DString::npos, qPrint(), DString::stripWhiteSpace(), stripWhiteSpace(), and warn.

Referenced by handleToc().

handleTodo()

bool handleTodo ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3350 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->newXRefKind = XRef_Todo;
  setOutput(yyscanner,OutputXRef);
  yyextra->xrefKind = XRef_Todo;
  return false;
}

References handleTodo(), OutputXRef, setOutput(), and XRef_Todo.

Referenced by handleTodo().

handleUnion()

bool handleUnion ( yyscan_t yyscanner, const DString & cmd, const StringVector &  )

static

Definition at line 3189 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->currentCmd = cmd;
  yyextra->currentMakeEntryType = EntryType::makeUnionDoc;
  BEGIN( ClassDocArg1 );
  return checkStructuralIndicator(yyscanner);
}

References checkStructuralIndicator(), and handleUnion().

Referenced by handleUnion().

handleVerifies()

bool handleVerifies ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3522 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  BEGIN( VerifiesLabel );
  return false;
}

References handleVerifies().

Referenced by handleVerifies().

handleWeakGroup()

bool handleWeakGroup ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3112 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool stop=makeStructuralIndicator(yyscanner,EntryType::makeGroupDoc);
  yyextra->current->groupDocType = Entry::GROUPDOC_WEAK;
  BEGIN( GroupDocArg1 );
  return stop;
}

References Entry::GROUPDOC_WEAK, handleWeakGroup(), and makeStructuralIndicator().

Referenced by handleWeakGroup().

handleXRefItem()

bool handleXRefItem ( yyscan_t yyscanner, const DString & , const StringVector &  )

static

Definition at line 3387 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->newXRefKind = XRef_Item;
  BEGIN(XRefItemParam1);
  return false;
}

References handleXRefItem(), and XRef_Item.

Referenced by handleXRefItem().

initParser()

void initParser ( yyscan_t yyscanner )

static

Definition at line 4353 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->sectionLabel.clear();
  yyextra->sectionTitle.clear();
  yyextra->docGroup.clearHeader();
  yyextra->insideParBlock = false;
}

References initParser().

Referenced by initParser(), initParser(), initParser(), CommentScanner::parseCommentBlock(), parseMain(), parseMain(), and stateToString().

lineCount()

void lineCount ( yyscan_t yyscanner )

static

Definition at line 4397 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  for( const char* c = yytext ; *c ; ++c )
    yyextra->lineNr += (*c == '\n') ;
}

References lineCount.

makeStructuralIndicator()

bool makeStructuralIndicator ( yyscan_t yyscanner, MakeEntryType maker )

static

Definition at line 4371 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  assert(maker!=nullptr); // detect programming error
  //printf("yyextra->current->section=%x\n",yyextra->current->section);
  if (yyextra->current->section.isDoc())
  {
    return true;
  }
  else if (maker)
  {
    yyextra->needNewEntry = true;
    yyextra->current->section = maker();
    yyextra->current->fileName = yyextra->fileName;
    yyextra->current->startLine = yyextra->lineNr;
    if (yyextra->current->docLine == -1) yyextra->current->docLine = yyextra->lineNr;
    return false;
  }
  else
  {
    return false;
  }
}

References makeStructuralIndicator().

Referenced by handleAddToGroup(), handleDefGroup(), handleDir(), handleExample(), handleFile(), handleMainpage(), handleName(), handlePackage(), handlePage(), handleRequirement(), handleWeakGroup(), and makeStructuralIndicator().

sectionLevelToType()

SectionType sectionLevelToType ( int level )

static

Definition at line 4585 of file commentscan.l.

{
  if (level>=0 && level<SectionType::MaxLevel) return SectionType(level);
  return SectionType::Anchor;
}

References SectionType::Anchor, SectionType::MaxLevel, sectionLevelToType(), and SectionType::SectionType().

Referenced by addSection(), and sectionLevelToType().

setOutput()

void setOutput ( yyscan_t yyscanner, OutputContext ctx )

inlinestatic

Definition at line 4683 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  bool xrefAppendToPrev = yyextra->xrefAppendFlag;
  // determine append flag for the next item (i.e. the end of this item)
  yyextra->xrefAppendFlag = !yyextra->inBody &&
                   yyextra->inContext==OutputXRef && ctx==OutputXRef && // two consecutive xref items
                   yyextra->newXRefKind==yyextra->xrefKind &&           // of the same kind
                   (yyextra->xrefKind!=XRef_Item ||
                    yyextra->newXRefItemKey==yyextra->xrefItemKey);     // with the same key if \xrefitem
  //printf("%d && %d && %d && (%d || %d)\n",
  //                 yyextra->inContext==OutputXRef,
  //                 ctx==OutputXRef,
  //                 yyextra->newXRefKind==yyextra->xrefKind,
  //                 yyextra->xrefKind!=XRef_Item,
  //                 yyextra->newXRefItemKey==yyextra->xrefItemKey);
  //printf("refKind=%d yyextra->newXRefKind=%d xrefAppendToPrev=%d yyextra->xrefAppendFlag=%d\n",
  //             yyextra->xrefKind,yyextra->newXRefKind,xrefAppendToPrev,yyextra->xrefAppendFlag);
 
  //printf("setOutput(yyscanner,yyextra->inContext=%d ctx=%d)\n",yyextra->inContext,ctx);
  if (yyextra->inContext==OutputXRef) // end of XRef section => add the item
  {
    // See if we can append this new xref item to the previous one.
    // We know this at the start of the next item of the same
    // type and need to remember this until the end of that item.
    switch(yyextra->xrefKind)
    {
      case XRef_Todo:
        addXRefItem(yyscanner,DString("todo"),
            theTranslator->trTodo(),
            theTranslator->trTodoList(),
            xrefAppendToPrev
            );
        break;
      case XRef_Test:
        addXRefItem(yyscanner,DString("test"),
            theTranslator->trTest(),
            theTranslator->trTestList(),
            xrefAppendToPrev
            );
        break;
      case XRef_Bug:
        addXRefItem(yyscanner,DString("bug"),
            theTranslator->trBug(),
            theTranslator->trBugList(),
            xrefAppendToPrev
            );
        break;
      case XRef_Deprecated:
        addXRefItem(yyscanner,DString("deprecated"),
            theTranslator->trDeprecated(),
            theTranslator->trDeprecatedList(),
            xrefAppendToPrev || yyextra->current->spec.isDeprAttr()
            );
        break;
      case XRef_Item:  // user defined list
        addXRefItem(yyscanner,yyextra->xrefItemKey,
            yyextra->xrefItemTitle,
            yyextra->xrefListTitle,
            xrefAppendToPrev
            );
        break;
      case XRef_None:
        ASSERT(0);
        break;
    }
  }
  yyextra->xrefItemKey = yyextra->newXRefItemKey;
 
  int oldContext = yyextra->inContext;
  yyextra->inContext = ctx;
  if (yyextra->inContext!=OutputXRef && yyextra->inBody) yyextra->inContext=OutputInbody;
  switch(yyextra->inContext)
  {
    case OutputDoc:
      if (oldContext!=yyextra->inContext)
      {
        stripTrailingWhiteSpace(yyextra->current->doc);
        if (yyextra->current->doc.empty()) yyextra->current->docLine = yyextra->lineNr;
        if (yyextra->current->docFile.empty())
        {
          yyextra->current->docFile = yyextra->fileName;
          yyextra->current->docLine = yyextra->lineNr;
        }
      }
      yyextra->pOutputString = &yyextra->current->doc;
      break;
    case OutputBrief:
      {
        if (oldContext!=yyextra->inContext)
        {
          if (yyextra->current->brief.empty()) yyextra->current->briefLine = yyextra->lineNr;
          if (yyextra->current->briefFile.empty())
          {
            yyextra->current->briefFile = yyextra->fileName;
            yyextra->current->briefLine = yyextra->lineNr;
          }
        }
        bool foundMatch = false;
        if (yyextra->current->brief.stripWhiteSpace().empty()) // we only want one brief
          // description even if multiple
          // are given...
        {
          foundMatch = true;
        }
        else
        {
          std::string str = yyextra->current->brief.str();
          reg::Match match;
          if (reg::match(str,match,nonBrief_re)) // match found
          {
            size_t cnt = 0;
            for (size_t i = 0; i < match[2].str().size(); i++)
            {
              if (match[2].str()[i] == '\n') cnt++;
            }
            if (cnt>0)
            {
              yyextra->current->brief = yyextra->current->brief.left(yyextra->current->brief.length()-cnt);
              // set warning line correct
              yyextra->current->brief += " \\iline " + DString().setNum(cnt + static_cast<int>(std::stoul(match[1].str()))) + " \\ilinebr ";
            }
            foundMatch = true;
          }
        }
        if (foundMatch)
        {
            yyextra->pOutputString = &yyextra->current->brief;
        }
        else
        {
          if (!yyextra->current->doc.empty()) // when appending parts add a new line
          {
            yyextra->current->doc += "\n";
          }
          yyextra->pOutputString = &yyextra->current->doc;
          yyextra->inContext = OutputDoc; // need to switch to detailed docs, see bug 631380
        }
      }
      break;
    case OutputXRef:
      yyextra->pOutputString = &yyextra->outputXRef;
      // first item found, so can't append to previous
      //yyextra->xrefAppendFlag = false;
      break;
    case OutputInbody:
      yyextra->pOutputString = &yyextra->current->inbodyDocs;
      break;
  }
}

References addXRefItem(), ASSERT, DString::DString(), reg::match(), nonBrief_re, OutputBrief, OutputDoc, OutputInbody, OutputXRef, setOutput(), stripTrailingWhiteSpace(), theTranslator, Translator::trBug(), Translator::trBugList(), Translator::trDeprecated(), Translator::trDeprecatedList(), Translator::trTest(), Translator::trTestList(), Translator::trTodo(), Translator::trTodoList(), XRef_Bug, XRef_Deprecated, XRef_Item, XRef_None, XRef_Test, and XRef_Todo.

Referenced by endBrief(), handleBrief(), handleBug(), handleCopyBrief(), handleCopyDetails(), handleCopyDoc(), handleDeprecated(), handleDetails(), handleEndParBlock(), handleMainpage(), handleSection(), handleTest(), handleTodo(), CommentScanner::parseCommentBlock(), and setOutput().

stateToString()

const char * stateToString ( int state )

static

References fileInfoLookup(), and stateToString().

Referenced by scanner_abort(), stateToString(), stateToString(), stateToString(), and stateToString().

stripQuotes()

DString stripQuotes ( const char * s )

static

Definition at line 4406 of file commentscan.l.

{
  DString name;
  if (s==nullptr || *s==0) return name;
  name=s;
  if (name.at(0)=='"' && name.at(name.length()-1)=='"')
  {
    name=name.mid(1,name.length()-2);
  }
  return name;
}

References DString::at(), DString::length(), DString::mid(), and stripQuotes().

Referenced by stateToString(), stripQuotes(), and stripQuotes().

stripTrailingWhiteSpace()

void stripTrailingWhiteSpace ( DString & s )

static

Definition at line 4655 of file commentscan.l.

{
  size_t len = s.length();
  int i = (int)len-1;
  while (i>=0)
  {
    char c = s.at(i);
    if (c==' ' || c=='\t' || c=='\r') // normal whitespace
    {
      i--;
    }
    else if (c=='r' && i>=7 && literal_at(s.data()+i-7,"\\ilinebr")) // special line break marker
    {
      i-=8;
    }
    else // non-whitespace
    {
      break;
    }
  }
  //printf("stripTrailingWhitespace(%s) i=%d len=%d\n",qPrint(s),i,len);
  if (i!=(int)len-1)
  {
    s.resize(i+1); // string up to and including char at pos i
  }
}

References DString::at(), DString::data(), DString::length(), literal_at(), DString::resize(), and stripTrailingWhiteSpace().

Referenced by setOutput(), and stripTrailingWhiteSpace().

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 721 of file commentscan.l.

         {CMD}{CMD}[a-z_A-Z]+{B}*       { // escaped command
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{CMD}{CMD}"~"[a-z_A-Z]*        { // escaped command
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{MAILADDR}                     { // mail address
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"\""[^"\n]*"\""                { // quoted text
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>("\\"[a-z_A-Z]+)+"\\"          { // directory (or chain of commands!)
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"<"{DETAILEDHTML}{ATTR}">"     { // HTML command that ends a brief description
                                          DString htmlOpenTag(yytext);
                                          size_t spacePos = htmlOpenTag.find(' '); // check for optional attributes
                                          if (spacePos==DString::npos) spacePos=yyleng-1;
                                          DString htmlTagName = htmlOpenTag.mid(1,spacePos-1);
                                          //printf("found open tag '%s'\n",qPrint(htmlTagName));
                                          yyextra->htmlContextStack.emplace_back(htmlTagName,yyextra->inContext);
                                          if (yyextra->inContext==OutputBrief)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          // continue with the same input
                                          REJECT;
                                        }
<Comment>"</"{DETAILEDHTML}">"          { // HTML command that ends a brief description
                                          DString htmlCloseTag(yytext);
                                          DString htmlTagName = htmlCloseTag.mid(2,htmlCloseTag.length()-3);
                                          //printf("found close tag '%s'\n",qPrint(htmlTagName));
                                          if (!yyextra->htmlContextStack.empty() &&
                                              yyextra->htmlContextStack.back().tagName==htmlTagName)
                                          {
                                            if (yyextra->inContext==OutputXRef && yyextra->htmlContextStack.back().context!=OutputXRef)
                                            {
                                              //printf("switching back to OutputDoc\n");
                                              setOutput(yyscanner,OutputDoc);
                                            }
                                            yyextra->htmlContextStack.pop_back();
                                          }
                                          REJECT;
                                        }
<Comment>"<"{DETAILEDHTMLOPT}">"        { // HTML <code> command that ends a brief description
                                          // without attributes
                                          if (yyextra->current->lang==SrcLangExt::CSharp)
                                          {
                                            yyextra->CScode=true;
                                            setOutput(yyscanner,OutputDoc);
                                            addOutput(yyscanner,"@code{cs}");
                                          }
                                          else
                                          {
                                            // continue with the same input
                                            REJECT;
                                          }
                                        }
<Comment>"<"{DETAILEDHTMLOPTEND}">"     { // HTML command that ends a brief description
                                          if (yyextra->CScode)
                                          {
                                            addOutput(yyscanner,"@endcode");
                                            yyextra->CScode=false;
                                          }
                                          else
                                          {
                                            yyextra->CScode=false;
                                            // continue with the same input
                                            REJECT;
                                          }
                                        }
<Comment>"<"{DETAILEDHTMLOPT}{ATTR}">"  { // HTML <code> command that ends a brief description
                                          // with attributes, so cannot be CS.
                                          if (yyextra->current->lang==SrcLangExt::CSharp)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          // continue with the same input
                                          REJECT;
                                        }
<Comment>"<"{DETAILS}{ATTR}">"          { // start of a HTML style details description
                                          yyextra->htmlDetailsStack.push_back(0);
                                          yyextra->htmlContextStack.emplace_back("details",yyextra->inContext);
                                          if (yyextra->inContext==OutputBrief)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"</"{DETAILS}">"               { // end of a HTML style details description
                                          if (!yyextra->htmlDetailsStack.empty())
                                          {
                                            yyextra->htmlDetailsStack.pop_back();
                                          }
                                          if (!yyextra->htmlContextStack.empty() &&
                                              yyextra->htmlContextStack.back().tagName=="details")
                                          {
                                            if (yyextra->inContext==OutputXRef && yyextra->htmlContextStack.back().context!=OutputXRef)
                                            {
                                              //printf("switching back to OutputDoc\n");
                                              setOutput(yyscanner,OutputDoc);
                                            }
                                            yyextra->htmlContextStack.pop_back();
                                          }
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"<"{AHTML}                     { // potential start of HTML anchor, see issue 9200
                                          yyextra->htmlAnchorStr = yytext;
                                          yyextra->htmlAnchor = false;
                                          BEGIN(HtmlA);
                                        }
<HtmlA>{ANCHTML}                        { // only labels that can be converted to doxygen anchor
                                          yyextra->htmlAnchorStr += yytext;
                                          DString tag(yytext);
                                          size_t s=tag.find("=");
                                          char c=tag[s+1];
                                          DString id;
                                          if (c=='\'' || c=='"') // valid start
                                          {
                                            size_t e=tag.find(c,s+2);
                                            if (e!=DString::npos) // found matching end
                                            {
                                              id=tag.mid(s+2,e-s-2); // extract id
                                              addAnchor(yyscanner,id);
                                            }
                                          }
                                          else
                                          {
                                            id=tag.mid(s+1);
                                            addAnchor(yyscanner,id);
                                          }
                                          if (!id.empty() && !yyextra->htmlAnchor)
                                          {
                                            // only use first analogous to what is in docparser
                                            addOutput(yyscanner,"@anchor ");
                                            addOutput(yyscanner,id.data());
                                            addOutput(yyscanner," ");
                                            yyextra->htmlAnchor = true;
                                          }
                                        }
<HtmlA>("\""[^\n\"]*"\""|"'"[^\n']*"'") {
                                          yyextra->htmlAnchorStr += yytext;
                                        }
<HtmlA>">"|"/>"                         {
                                          if (!yyextra->htmlAnchor)
                                          {
                                            addOutput(yyscanner,yyextra->htmlAnchorStr);
                                            addOutput(yyscanner,yytext);
                                          }
                                          else
                                          {
                                            if (yyleng == 1) // to keep <a></a> pairs, otherwise single </a> present
                                            {
                                              addOutput(yyscanner,"<a>");
                                            }
                                          }
                                          BEGIN(Comment);
                                        }
<HtmlA>{DOCNL}                          { // newline
                                          yyextra->htmlAnchorStr += yytext;
                                          if (*yytext == '\n') yyextra->lineNr++;
                                        }
<HtmlA>.                                { // catch-all for anything else
                                          yyextra->htmlAnchorStr += yytext;
                                        }
<Comment>"<"{SUMMARY}">"                { // start of a .NET XML style brief description
                                          if (yyextra->htmlDetailsStack.empty())
                                          {
                                            setOutput(yyscanner,OutputBrief);
                                          }
                                          else // HTML5 style <summary> as part of <details> section.
                                          {
                                            addOutput(yyscanner,yytext);
                                          }
                                        }
<Comment>"<"{REMARKS}">"                { // start of a .NET XML style detailed description
                                          setOutput(yyscanner,OutputDoc);
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"</"{SUMMARY}">"               { // start of a .NET XML style detailed description
                                          if (!yyextra->htmlDetailsStack.empty())
                                          {
                                            addOutput(yyscanner,yytext);
                                          }
                                          else
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                        }
<Comment>"</"{REMARKS}">"               { // end of a brief or detailed description
                                          setOutput(yyscanner,OutputDoc);
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"<"{CAPTION}{ATTR}">"          {
                                          DString tag(yytext);
                                          size_t s=tag.find("id=");
                                          if (s!=DString::npos) // command has id attribute
                                          {
                                            char c=tag[s+3];
                                            if (c=='\'' || c=='"') // valid start
                                            {
                                              size_t e=tag.find(c,s+4);
                                              if (e!=DString::npos) // found matching end
                                              {
                                                DString id=tag.mid(s+4,e-s-4); // extract id
                                                addAnchor(yyscanner,id);
                                              }
                                            }
                                          }
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"<"{PRE}{ATTR}">"              {
                                          yyextra->insidePre=true;
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"</"{PRE}">"                   {
                                          yyextra->insidePre=false;
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{RCSTAG}                       { // RCS tag which end a brief description
                                          setOutput(yyscanner,OutputDoc);
                                          REJECT;
                                        }
<Comment>"<!--"                         {
                                          BEGIN(HtmlComment);
                                        }
<Comment>"<!\‍[CDATA\‍["                  {
                                          BEGIN(CdataSection);
                                        }
<Comment>{B}*{CMD}"endinternal"{B}*     {
                                          addOutput(yyscanner," \\endinternal ");
                                          if (!yyextra->inInternalDocs)
                                              warn(yyextra->fileName,yyextra->lineNr,
                                               "found \\endinternal without matching \\internal"
                                              );
                                          yyextra->inInternalDocs = false;
                                        }
<Comment>{B}*"\\ilinebr "{B}*           { // preserve spacing around \\ilinebr
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>(\n|"\\ilinebr ")/({B}*(\n|{IFILELINE}?"\\ilinebr "))+ { // at least one blank line (or blank line command)
                                          if (yyextra->inContext==OutputBrief)
                                          {
                                            endBrief(yyscanner);
                                          }
                                          else
                                          {
                                            REJECT;
                                          }
                                        }
<Comment>{B}*{CMD}[a-z_A-Z]+"{"[^}]*"}"{B}*  |
<Comment>{B}*{CMD}[a-z_A-Z]+{B}*        { // potentially interesting command
                                          // the {B}* in the front was added for bug620924
                                          DString fullMatch = yytext;
                                          size_t idx = fullMatch.find('{');
                                          /* handle `f{` command as special case */
                                          if ((idx > 1) && (yytext[idx-1] == 'f') && (yytext[idx-2] == '\\' || yytext[idx-2] =='@')) REJECT;
                                          size_t idxEnd = fullMatch.find('}',idx+1);
                                          DString cmdName;
                                          StringVector optList;
                                          if (idx == DString::npos) // no options
                                          {
                                            cmdName = fullMatch.stripWhiteSpace().mid(1); // to remove {CMD}
                                          }
                                          else // options present
                                          {
                                            cmdName = fullMatch.left(idx).stripWhiteSpace().mid(1); // to remove {CMD}
                                            DString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
                                            optList = split(optStr.str(),",");
                                          }
                                          auto it = docCmdMap.find(cmdName.str());
                                          //printf("lookup command '%s' found=%d\n",qPrint(cmdName),it!=docCmdMap.end());
                                          if (it!=docCmdMap.end()) // special action is required
                                          {
                                            int i=0;
                                            while (yytext[i]==' ' || yytext[i]=='\t') i++;
                                            yyextra->spaceBeforeCmd = fullMatch.left(i);
                                            CommandSpacing spacing = it->second.spacing;
                                            if ((spacing==CommandSpacing::Block || spacing==CommandSpacing::XRef) &&
                                                !(yyextra->inContext==OutputXRef && cmdName=="parblock"))
                                            {
                                              yyextra->briefEndsAtDot=false;
                                              bool insideXRef = yyextra->inContext==OutputXRef && spacing==CommandSpacing::XRef;
                                              // this command forces the end of brief description
                                              setOutput(yyscanner,insideXRef ? OutputXRef : OutputDoc);
                                            }
                                            //if (i>0) addOutput(yyscanner,DString(yytext).left(i)); // removed for bug 689341
                                            if (it->second.handler && it->second.handler(yyscanner, cmdName, optList))
                                            {
                                              // implicit split of the comment block into two
                                              // entries. Restart the next block at the start
                                              // of this command.
                                              yyextra->parseMore=true;
 
                                              yyextra->inputPosition=yyextra->prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf);
                                              yyterminate();
                                            }
                                            else if (it->second.handler==nullptr)
                                            {
                                              // command without handler, to be processed
                                              // later by parsedoc.cpp
                                              addOutput(yyscanner,yytext);
                                            }
                                          }
                                          else // command not relevant
                                          {
                                            addOutput(yyscanner,yytext);
                                          }
                                        }
<Comment>{B}*({CMD}{CMD})"f"[$\‍[{]      { // escaped formula command
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{B}*{CMD}"~"[a-z_A-Z-]*        { // language switch command
                                          DString langId = DString(yytext).stripWhiteSpace().mid(2);
                                          if (!langId.empty() &&
                                              dstricmp(Config_getEnumAsString(OUTPUT_LANGUAGE),langId)!=0)
                                          { // enable language specific section
                                            if (!Config_isAvailableEnum(OUTPUT_LANGUAGE,langId))
                                            {
                                               warn(yyextra->fileName,yyextra->lineNr,
                                               "non supported language '{}' specified in '{}'",langId,DString(yytext).stripWhiteSpace());
                                            }
                                            BEGIN(SkipLang);
                                          }
                                        }
<Comment>{B}*{CMD}"f{"[^}\n]+"}"("{"?)  { // start of a formula with custom environment
                                          setOutput(yyscanner,OutputDoc);
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="\\begin";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaEnv=DString(yytext).stripWhiteSpace().mid(2);
                                          if (yyextra->formulaEnv.at(yyextra->formulaEnv.length()-1)=='{')
                                          {
                                            // remove trailing open brace
                                            yyextra->formulaEnv=yyextra->formulaEnv.left(yyextra->formulaEnv.length()-1);
                                          }
                                          yyextra->formulaPreText+=yyextra->formulaEnv;
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaLong);
                                        }
<Comment>{B}*{CMD}"f$"                  { // start of a inline formula
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="$";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaShort);
                                        }
<Comment>{B}*{CMD}"f("                  { // start of a inline formula
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaRound);
                                        }
<Comment>{B}*{CMD}"f["                  { // start of a block formula
                                          setOutput(yyscanner,OutputDoc);
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="\\[";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaLong);
                                        }
<Comment>{B}*{CMD}"{"                   { // begin of a group
                                          //yyextra->langParser->handleGroupStartCommand(yyextra->memberGroupHeader);
                                          yyextra->docGroup.open(yyextra->current,yyextra->fileName,yyextra->lineNr);
                                        }
<Comment>{B}*{CMD}"}"                   { // end of a group
                                          //yyextra->langParser->handleGroupEndCommand();
                                          yyextra->docGroup.close(yyextra->current,yyextra->fileName,yyextra->lineNr,true);
                                          yyextra->docGroup.clearHeader();
                                          yyextra->parseMore=true;
                                          yyextra->needNewEntry = true;
                                          yyextra->inputPosition=yyextra->prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) + (int)strlen(yytext);
                                          yyterminate();
                                        }
<Comment>{B}*{CMD}[$@\\&~<>#%]          { // escaped character
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>[a-z_A-Z]+                     { // normal word
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>^{B}*"."{Bopt}/\n              { // explicit end autolist: e.g "  ."
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>^{B}*[1-9][0-9]*"."{B}+        |
<Comment>^{B}*[*+]{B}+                  { // start of autolist
                                          if (!yyextra->markdownSupport)
                                          {
                                            REJECT;
                                          }
                                          else
                                          {
                                            if (yyextra->inContext!=OutputXRef)
                                            {
                                              yyextra->briefEndsAtDot=false;
                                              setOutput(yyscanner,OutputDoc);
                                            }
                                            addOutput(yyscanner,yytext);
                                          }
                                          }
<Comment>^{B}*"-"{B}+                        { // start of autolist
                                          if (yyextra->inContext!=OutputXRef)
                                          {
                                            yyextra->briefEndsAtDot=false;
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>^{B}*([\-:|]{B}*)*("--"|"---")({B}*[\-:|])*{Bopt}/\n { // horizontal line (dashed)
                                            addOutput(yyscanner,yytext);
                                        }
<Comment>{CMD}"---"                     { // escaped mdash
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{CMD}"--"                      { // escaped ndash
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"---"                          { // mdash
                                          addOutput(yyscanner,yyextra->insidePre || yyextra->markdownSupport ? yytext : "&mdash;");
                                        }
<Comment>"--"                           { // ndash
                                          addOutput(yyscanner,yyextra->insidePre || yyextra->markdownSupport ? yytext : "&ndash;");
                                        }
<Comment>"-#"{B}+                       { // numbered item
                                          if (yyextra->inContext!=OutputXRef)
                                          {
                                            yyextra->briefEndsAtDot=false;
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>[?!][a-z_A-Z0-9\‍(\‍)=<]         |
<Comment>("."+)[a-z_A-Z0-9\‍)]           { // . at start or in the middle of a word, or ellipsis
                                          // ? or ! in middle of word or followed by equal sign or round bracket.
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>{CMD}[\.?!]                    { // we have to be a bit careful with the special commands
                                          // \. \? and \! as they might otherwise terminate a brief description
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>".\\"[ \t]                     { // . with escaped space.
                                          addOutput(yyscanner,yytext[0]);
                                          addOutput(yyscanner,yytext[2]);
                                        }
<Comment>"."[,:;]                       { // . with some puntuations such as "e.g.," or "e.g.:"
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>"...\\"[ \t]                   { // ellipsis with escaped space.
                                          addOutput(yyscanner,"... ");
                                        }
<Comment>"..."/[^\.]                    { // ellipsis
                                          addOutput(yyscanner,"...");
                                        }
<Comment>".."[\.]?/[^ \t\n]             { // internal ellipsis
                                          addOutput(yyscanner,yytext);
                                        }
<Comment>(\n|"\\ilinebr ")({B}*(\n|"\\ilinebr "))+ { // at least one blank line (or blank line command)
                                          if (yyextra->inContext==OutputXRef)
                                          {
                                            // see bug 613024, we need to put the newlines after ending the XRef section.
                                            if (!yyextra->insideParBlock) setOutput(yyscanner,OutputDoc);
                                            yy_size_t i;
                                            for (i=0;i<(yy_size_t)yyleng;)
                                            {
                                              if (yytext[i]=='\n') addOutput(yyscanner,'\n'),i++;
                                              else if (strncmp(yytext+i,"\\ilinebr ",9)==0) addOutput(yyscanner,"\\ilinebr "),i+=9;
                                              else i++;
                                            }
                                          }
                                          else if (yyextra->inContext!=OutputBrief)
                                          {
                                            yy_size_t i;
                                            for (i=0;i<(yy_size_t)yyleng;)
                                            {
                                              if (yytext[i]=='\n') addOutput(yyscanner,'\n'),i++;
                                              else if (strncmp(yytext+i,"\\ilinebr ",9)==0) addOutput(yyscanner,"\\ilinebr "),i+=9;
                                              else i++;
                                            }
                                            setOutput(yyscanner,OutputDoc);
                                          }
                                          else // yyextra->inContext==OutputBrief
                                          { // only go to the detailed description if we have
                                            // found some brief description and not just whitespace
                                            endBrief(yyscanner);
                                          }
                                          lineCount(yyscanner);
                                        }
<Comment>"."[?!]                        |
<Comment>[\.?!]                         { // potential end of a JavaDoc style comment
                                          addOutput(yyscanner,yytext);
                                          if (yyextra->briefEndsAtDot)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                            yyextra->briefEndsAtDot=false;
                                          }
                                        }
<Comment>{DOCNL}                        { // newline
                                          addOutput(yyscanner,yytext);
                                          if (*yytext == '\n') yyextra->lineNr++;
                                        }
<Comment>"<"[/]?{TABLEDEL}">"           { // In case in xrefitem type some special handling is required
                                          if (yyextra->inContext==OutputXRef)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                            addOutput(yyscanner,yytext);
                                          }
                                          else
                                          {
                                            REJECT;
                                          }
                                        }
<Comment>.                              { // catch-all for anything else
                                          addOutput(yyscanner,*yytext);
                                        }
 
 
 /* --------------   Rules for handling HTML comments ----------- */
 
<HtmlComment>"---"[!]?">"{B}*           {
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "incorrect HTML end comment --->"
                                              );
                                        }
<HtmlComment>"--"[!]?">"{B}*            { BEGIN( Comment ); }
<HtmlComment>{DOCNL}                    {
                                          if (*yytext=='\n')
                                          {
                                            yyextra->lineNr++;
                                            addOutput(yyscanner," \\iline "+DString().setNum(yyextra->lineNr)+" ");
                                          }
                                        }
<HtmlComment>[^\\\n\-]+                 { // ignore unimportant characters
                                        }
<HtmlComment>.                          { // ignore every else
                                        }
 
<CdataSection>"\‍]\‍]>"                   {
                                          BEGIN( Comment );
                                        }
<CdataSection>{DOCNL}                   {
                                          addOutput(yyscanner,'\n');
                                          if (*yytext=='\n') yyextra->lineNr++;
                                        }
<CdataSection>[<>&]                     { // the special XML characters for iwhich the CDATA section is especially used
                                          addOutput(yyscanner,'\\');
                                          addOutput(yyscanner,*yytext);
                                        }
<CdataSection>[^\\\n\‍]<>&]+             {
                                          addOutput(yyscanner,yytext);
                                        }
<CdataSection>.                         {
                                          addOutput(yyscanner,*yytext);
                                        }
 
 /* --------------   Rules for handling formulas ---------------- */
 
<ReadFormulaShort,ReadFormulaShortSection>{CMD}"f$" { // end of inline formula
                                          yyextra->formulaPostText+="$";
                                          DString form = addFormula(yyscanner);
                                          addOutput(yyscanner," "+form);
                                          if (YY_START == ReadFormulaShort)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+= " "+form;
                                            BEGIN(SectionTitle);
                                          }
                                        }
<ReadFormulaRound,ReadFormulaRoundSection>{CMD}"f)" { // end of inline formula
                                          DString form = addFormula(yyscanner);
                                          addOutput(yyscanner," "+form);
                                          if (YY_START == ReadFormulaRound)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+= " "+form;
                                            BEGIN(SectionTitle);
                                          }
                                        }
<ReadFormulaLong>{CMD}"f]"              { // end of block formula
                                          yyextra->formulaPostText+="\\]";
                                          addOutput(yyscanner," "+addFormula(yyscanner));
                                          BEGIN(Comment);
                                        }
<ReadFormulaLong>{CMD}"f}"              { // end of custom env formula
                                          yyextra->formulaPostText+="\\end";
                                          yyextra->formulaPostText+=yyextra->formulaEnv;
                                          addOutput(yyscanner," "+addFormula(yyscanner));
                                          BEGIN(Comment);
                                        }
<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>[^\\@\n]+ { // any non-special character
                                          yyextra->formulaText+=yytext;
                                        }
<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>\n    { // new line
                                          yyextra->formulaNewLines++;
                                          yyextra->formulaText+=*yytext;
                                          yyextra->lineNr++;
                                          addIline(yyscanner,yyextra->lineNr);
                                        }
<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>.     { // any other character
                                          yyextra->formulaText+=*yytext;
                                        }
 
  /* ------------ handle argument of enum command --------------- */
 
<EnumDocArg1>{SCOPEID}                  { // handle argument
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          yyextra->current->name = yytext;
                                          BEGIN( Comment );
                                        }
<EnumDocArg1>{LC}                       { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<EnumDocArg1>{DOCNL}                    { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after '\\enum'."
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<EnumDocArg1>.                          { // ignore other stuff
                                        }
 
  /* ------------ handle argument of namespace command --------------- */
 
<NameSpaceDocArg1>{SCOPENAME}           { // handle argument
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          lineCount(yyscanner);
                                          yyextra->current->name = substitute(removeRedundantWhiteSpace(yytext),".","::");
                                          BEGIN( Comment );
                                        }
<NameSpaceDocArg1>{LC}                  { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<NameSpaceDocArg1>{DOCNL}               { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after '\\namespace'."
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<NameSpaceDocArg1>.                     { // ignore other stuff
                                        }
 
  /* ------------ handle argument of package command --------------- */
 
<PackageDocArg1>{ID}("."{ID})*          { // handle argument
                                          yyextra->current->name = yytext;
                                          BEGIN( Comment );
                                        }
<PackageDocArg1>{LC}                    { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<PackageDocArg1>{DOCNL}                 { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after \\package."
                                              );
                                          unput_string(yytext,yyleng);
                                          //addOutput(yyscanner,'\n');
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          BEGIN( Comment );
                                        }
<PackageDocArg1>.                       { // ignore other stuff
                                        }
 
  /* ------------ handle argument of concept command --------------- */
 
<ConceptDocArg1>{SCOPEID}               { // handle argument
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          yyextra->current->name = yytext;
                                          BEGIN( Comment );
                                        }
<ConceptDocArg1>{LC}                    { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<ConceptDocArg1>{DOCNL}                 { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after '\\concept'."
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ConceptDocArg1>.                       { // ignore other stuff
                                        }
 
  /* ------------ handle argument of module command --------------- */
<ModuleDocArg1>{MODULE_ID}              { // handle argument
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          yyextra->current->name = yytext;
                                          BEGIN( Comment );
                                        }
<ModuleDocArg1>{LC}                     { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<ModuleDocArg1>{DOCNL}                  { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after '\\module'."
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ModuleDocArg1>.                        { // ignore other stuff
                                        }
 
  /* ------ handle argument of class/struct/union command --------------- */
 
<ClassDocArg1>{SCOPENAME}{TMPLSPEC}     {
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          lineCount(yyscanner);
                                          yyextra->current->name = substitute(removeRedundantWhiteSpace(yytext),".","::");
                                          BEGIN( ClassDocArg2 );
                                        }
<ClassDocArg1>{SCOPENAME}               { // first argument
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          lineCount(yyscanner);
                                          yyextra->current->name = substitute(yytext,".","::");
                                          if (yyextra->current->section.isProtocolDoc())
                                          {
                                            yyextra->current->name+="-p";
                                          }
                                          // prepend outer scope name
                                          BEGIN( ClassDocArg2 );
                                        }
<CategoryDocArg1>{SCOPENAME}{B}*"("[^\‍)]+")" {
                                          makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                          lineCount(yyscanner);
                                          yyextra->current->name = substitute(yytext,".","::");
                                          BEGIN( ClassDocArg2 );
                                        }
<ClassDocArg1,CategoryDocArg1>{LC}      { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<ClassDocArg1,CategoryDocArg1>{DOCNL}   {
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after '\\{}'.",yyextra->currentCmd
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ClassDocArg1,CategoryDocArg1>.         { // ignore other stuff
                                        }
 
<ClassDocArg2>{DOCNL}                   {
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ClassDocArg2>{FILE}|"<>"               { // second argument; include file
                                          yyextra->current->includeFile = yytext;
                                          BEGIN( ClassDocArg3 );
                                        }
<ClassDocArg2>{LC}                      { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<ClassDocArg2>.                         { // ignore other stuff
                                        }
 
<ClassDocArg3>[<"]?{FILE}?[">]?         { // third argument; include file name
                                          yyextra->current->includeName = yytext;
                                          BEGIN( Comment );
                                        }
<ClassDocArg3>{LC}                      { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<ClassDocArg3>{DOCNL}                   {
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ClassDocArg3>.                         { // ignore other stuff
                                        }
 
  /* --------- handle arguments of {def,add,weak}group commands --------- */
 
<GroupDocArg1>{LABELID}(".html"|".xhtml")? { // group name
                                           yyextra->current->name = yytext;
                                          //lastDefGroup.groupname = yytext;
                                          //lastDefGroup.pri = yyextra->current->groupingPri();
                                          // the .html stuff is for Qt compatibility
                                          if (yyextra->current->name.endsWith(".html"))
                                          {
                                            yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-5);
                                          }
                                          else if (yyextra->current->name.endsWith(".xhtml"))
                                          {
                                            yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-6);
                                          }
                                          yyextra->current->type.clear();
                                          BEGIN(GroupDocArg2);
                                        }
<GroupDocArg1>"\\"{B}*"\n"              { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<GroupDocArg1>{DOCNL}                   { // missing argument!
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing group name after {}",
                                               yyextra->current->groupDocCmd()
                                              );
                                          //addOutput(yyscanner,'\n');
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<GroupDocArg1>.                         { // ignore other stuff
                                        }
<GroupDocArg2>"\\"{B}*"\n"              { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<GroupDocArg2>[^\n\\‍]+                  { // title (stored in type)
                                          yyextra->current->type += yytext;
                                        }
<GroupDocArg2>{DOCNL}+                  {
                                          yyextra->current->type = yyextra->current->type.stripWhiteSpace();
                                          if ( yyextra->current->groupDocType==Entry::GROUPDOC_NORMAL &&
                                               yyextra->current->type.empty()
                                             ) // defgroup requires second argument
                                          {
                                              warn(yyextra->fileName,yyextra->lineNr,
                                                 "missing title after "
                                                 "\\defgroup {}", yyextra->current->name
                                                );
                                          }
                                          unput_string(yytext,yyleng);
                                          int extraLineNr = 0;
                                          if (yyextra->inContext == OutputBrief)
                                          {
                                            for (int i = 0; i < yyleng; i++)
                                            {
                                              if (yytext[i]=='\n') extraLineNr++;
                                            }
                                          }
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          if ( yyextra->current->groupDocType!=Entry::GROUPDOC_NORMAL)
                                          {
                                            addOutput(yyscanner," \\ifile \""+ yyextra->fileName);
                                            addOutput(yyscanner,"\" \\iline " + DString().setNum(yyextra->lineNr + extraLineNr) + " \\ilinebr ");
                                          }
                                          BEGIN( Comment );
                                        }
<GroupDocArg2>.                         { // title (stored in type)
                                          yyextra->current->type += yytext;
                                        }
 
  /* --------- handle arguments of page/mainpage command ------------------- */
 
<PageDocArg1>[^\n]*"\\ilinebr @ianchor"\{[^\‍]\n]*\}{B}{FILE} { // special case where the Markdown processor has rewritten
                                                               // "@page label Title" as
                                                               // "@page md_label Title\ilinebr @ianchor{Title} label"
                                          DString text = yytext;
                                          size_t start = text.find('{');
                                          size_t end   = text.find('}',start+1);
                                          yyextra->current->name = text.mid(end+2);
                                          size_t istart = yyextra->current->name.find("\\ilinebr");
                                          if (istart != DString::npos)
                                          {
                                            DString rest =  yyextra->current->name.mid(istart);
                                            unput_string(rest,rest.length());
                                            yyextra->current->name = yyextra->current->name.left(istart);
                                          }
                                          yyextra->current->args = text.mid(start+1,end-start-1);
                                          //printf("name='%s' title='%s'\n",qPrint(yyextra->current->name),qPrint(yyextra->current->args));
                                          BEGIN( PageDocArg2 );
                                        }
<PageDocArg1>{FILE}                     { // first argument; page name
                                          yyextra->current->name = stripQuotes(yytext);
                                          yyextra->current->args = "";
                                          BEGIN( PageDocArg2 );
                                        }
<PageDocArg1>{LC}                       { yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<PageDocArg1>{DOCNL}                    {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                               "missing argument after \\page."
                                              );
                                          unput_string(yytext,yyleng);
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<PageDocArg1>.                          { // ignore other stuff
                                        }
<PageDocArg2>{DOCNL}                    { // second argument; page title
                                          unput_string(yytext,yyleng);
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          addOutput(yyscanner," \\ifile \""+ yyextra->fileName);
                                          addOutput(yyscanner,"\" \\iline " + DString().setNum(yyextra->lineNr) + " \\ilinebr ");
                                          BEGIN( Comment );
                                        }
<PageDocArg2>{CMD}[<>]                  {
                                          // bug 748927
                                          DString tmp(yytext);
                                          tmp = substitute(substitute(tmp,"@<","&lt;"),"@>","&gt;");
                                          tmp = substitute(substitute(tmp,"\\<","&lt;"),"\\>","&gt;");
                                          yyextra->current->args += tmp;
                                        }
<PageDocArg2>.                          {
                                          yyextra->current->args += yytext;
                                        }
  /* --------- handle arguments of the param command ------------ */
<ParamArg1>{ID}/{B}*","                 {
                                          addOutput(yyscanner,yytext);
                                        }
<ParamArg1>","                          {
                                          addOutput(yyscanner," , ");
                                        }
<ParamArg1>{DOCNL}                      {
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner," ");
                                        }
<ParamArg1>{ID}                         {
                                          addOutput(yyscanner,yytext);
                                          BEGIN( Comment );
                                        }
<ParamArg1>.                            {
                                          unput(yytext[0]);
                                          BEGIN( Comment );
                                        }
 
  /* --------- handle arguments of the file/dir/example command ------------ */
 
<FileDocArg1>{DOCNL}                    { // no file name specified
                                          unput_string(yytext,yyleng);
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<FileDocArg1>{FILE}                     { // first argument; name
                                          yyextra->current->name = stripQuotes(yytext);
                                          BEGIN( Comment );
                                        }
<FileDocArg1>{LC}                       { yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<FileDocArg1>.                          { // ignore other stuff
                                        }
 
  /* --------- handle arguments of the xrefitem command ------------ */
 
<XRefItemParam1>{LABELID}               { // first argument
                                          yyextra->newXRefItemKey=yytext;
                                          setOutput(yyscanner,OutputXRef);
                                          BEGIN(XRefItemParam2);
                                        }
<XRefItemParam1>{LC}                    { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<XRefItemParam1>{DOCNL}                 { // missing arguments
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "Missing first argument of \\xrefitem"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          yyextra->inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
<XRefItemParam1>.                       { // ignore other stuff
                                        }
 
<XRefItemParam2>"\""[^\n\"]*"\""        { // second argument
                                          yyextra->xrefItemTitle = stripQuotes(yytext);
                                          BEGIN(XRefItemParam3);
                                        }
<XRefItemParam2>{LC}                    { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<XRefItemParam2>{DOCNL}                 { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Missing second argument of \\xrefitem"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          yyextra->inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
<XRefItemParam2>.                       { // ignore other stuff
                                        }
 
<XRefItemParam3>"\""[^\n\"]*"\""        { // third argument
                                          yyextra->xrefListTitle = stripQuotes(yytext);
                                          yyextra->xrefKind = XRef_Item;
                                          BEGIN( Comment );
                                        }
<XRefItemParam2,XRefItemParam3>{LC}     { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<XRefItemParam3>{DOCNL}                 { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Missing third argument of \\xrefitem"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          yyextra->inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
<XRefItemParam3>.                       { // ignore other stuff
                                        }
 
 
  /* ----- handle arguments of the relates(also)/memberof command ------- */
 
<RelatesParam1>({ID}("::"|"."))*{ID}    { // argument
                                          yyextra->current->relates = yytext;
                                          //if (yyextra->current->mGrpId!=DOX_NOGROUP)
                                          //{
                                          //  memberGroupRelates = yytext;
                                          //}
                                          BEGIN( Comment );
                                        }
<RelatesParam1>{LC}                     { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<RelatesParam1>{DOCNL}                  { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Missing argument of '\\{}' command",yyextra->currentCmd
                                              );
                                          unput_string(yytext,yyleng);
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<RelatesParam1>.                        { // ignore other stuff
                                        }
 
 
  /* ----- handle arguments of the qualifier command ----- */
<Qualifier>{LABELID}                    { // unquoted version, simple label
                                          yyextra->current->qualifiers.emplace_back(yytext);
                                          BEGIN( Comment );
                                        }
<Qualifier>"\""[^\"]*"\""               { // quotes version, add without quotes
                                          std::string inp(yytext);
                                          yyextra->current->qualifiers.push_back(inp.substr(1,yyleng-2));
                                          BEGIN( Comment );
                                        }
<Qualifier>{DOCNL}                      { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Missing argument of '\\{}' command",yyextra->currentCmd
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<Qualifier>.                            {
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Argument of '\\{}' command should be quoted",yyextra->currentCmd
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
  /* ----- handle arguments of the iline command ----- */
<ILine>{LINENR}/[\\@\n\.]               |
<ILine>{LINENR}{B}                      {
                                          bool ok = false;
                                          int nr = DString(yytext).toInt(&ok);
                                          if (!ok)
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,"Invalid line number '{}' for iline command",yytext);
                                          }
                                          else
                                          {
                                            yyextra->lineNr = nr;
                                          }
                                          addOutput(yyscanner,yytext);
                                          if (YY_START == ILine)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
<ILine,ILineSection>.                   {
                                          addOutput(yyscanner,yytext);
                                          if (YY_START == ILine)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
 
  /* ----- handle arguments of the iraise command ----- */
<IRaise>{B}*[0-9]+/[\\@\n\.]               |
<IRaise>{B}*[0-9]+{B}                      {
                                          bool ok = false;
                                          int nr = DString(yytext).toInt(&ok);
                                          if (!ok)
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,"Invalid level '{}' for iraise command",yytext);
                                          }
                                          else
                                          {
                                            yyextra->raiseLevel = nr;
                                          }
                                          BEGIN(Comment);
                                        }
<IRaise>.                               {
                                          unput(yytext[0]);
                                          BEGIN(Comment);
                                        }
  /* ----- handle arguments of the iprefix command ----- */
 
<IRaisePrefix>{B}*"\""({LABELID})?"\""  {
                                          DString text(yytext);
                                          yyextra->raisePrefix = text.stripWhiteSpace().mid(1,text.length()-2);
                                          addOutput(yyscanner,yytext);
                                          BEGIN(Comment);
                                        }
<IRaisePrefix>.                         {
                                          unput(yytext[0]);
                                          BEGIN(Comment);
                                        }
 
 
  /* ----- handle arguments of the ifile command ----- */
 
<IFile,IFileSection>{FILE}              {
                                          addOutput(yyscanner,yytext);
                                          DString text(yytext);
                                          if (yytext[0] == '\"') yyextra->fileName = text.mid(1,text.length()-2);
                                          else yyextra->fileName = yytext;
                                          if (YY_START == IFile)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
 
<LinkSection>[^\\@\n]*                  {
                                          yyextra->sectionTitle+=yytext;
                                        }
<LinkSection>{CMD}{CMD}                 {
                                          yyextra->sectionTitle+=yytext;
                                        }
<LinkSection>{DOCNL}                    {
                                          addOutput(yyscanner,yytext);
                                          if (*yytext == '\n') yyextra->lineNr++;
                                          yyextra->sectionTitle+=yytext;
                                        }
<LinkSection>{CMD}"endlink"             {
                                          yyextra->sectionTitle+=yytext;
                                          BEGIN(SectionTitle);
                                        }
<LinkSection>.                          {
                                          yyextra->sectionTitle+=yytext;
                                        }
<LinkSection><<EOF>>                    {
                                          warn(yyextra->fileName,yyextra->lineNr,
                                            "reached end of comment while inside a '\\link' command, missing '\\endlink' command"
                                          );
                                          yyterminate();
                                        }
  /* ----- handle arguments of the relates(also)/addindex commands ----- */
 
<LineParam>{CMD}{CMD}                   { // escaped command
                                          addOutput(yyscanner,yytext);
                                        }
<LineParam>{DOCNL}                      { // end of argument
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<LineParam>{LC}                         { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<LineParam>({CMD}{CMD}){ID}             { // escaped command
                                          addOutput(yyscanner,yytext);
                                        }
<LineParam>.                            { // ignore other stuff
                                          addOutput(yyscanner,*yytext);
                                        }
 
  /* ----- handle arguments of the section/subsection/.. commands ------- */
 
<SectionLabel>{LABELID}                 {
                                          yyextra->sectionLabel+=yytext;
                                        }
<SectionLabel>{CMD}"lineinfo"("{}")?    {
                                          yyextra->sectionLabel += DString().setNum(yyextra->lineNr);
                                        }
<SectionLabel>{CMD}"fileinfo"("{"[^}]*"}")? {
                                          FileInfo fi(yyextra->fileName.str());
                                          bool hasOption = false;
                                          DString label;
                                          if (yytext[yyleng-1] == '}') // has parameters
                                          {
                                            StringVector optList;
                                            DString txt = yytext;
                                            DString optStr = txt.mid(10,yyleng-11).stripWhiteSpace();
                                            optList = split(optStr.str(),",");
                                            for (const auto &opt_ : optList)
                                            {
                                              DString optStripped = DString(opt_).stripWhiteSpace();
                                              std::string opt = optStripped.lower().str();
                                              DString result = fileInfoLookup(fi,opt);
                                              if (!result.empty())
                                              {
                                                if (hasOption) // oops: already found an option
                                                {
                                                  warn(yyextra->fileName,yyextra->lineNr,"Multiple options specified with \\fileinfo, discarding '{}'", optStripped);
                                                }
                                                else
                                                {
                                                  label = result;
                                                }
                                                hasOption = true;
                                              }
                                              else
                                              {
                                                warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\fileinfo: '{}'", optStripped);
                                              }
                                            }
                                          }
                                          if (!hasOption)
                                          {
                                            if (Config_getBool(FULL_PATH_NAMES))
                                            {
                                              label=stripFromPath(yyextra->fileName);
                                            }
                                            else
                                            {
                                              label=yyextra->fileName;
                                            }
                                          }
                                          escapeLabel(label);
                                          yyextra->sectionLabel+=label;
                                        }
<SectionLabel>{DOCNL}                   {
                                          yyextra->sectionTitle.clear();
                                          if (yyextra->sectionLabel.empty())
                                          { // missing argument
                                            warn(yyextra->fileName,yyextra->lineNr,
                                              "\\section command has no label"
                                              );
                                          }
                                          else
                                          {
                                            yyextra->sectionLabel=yyextra->raisePrefix+yyextra->sectionLabel;
                                            addOutput(yyscanner,yyextra->sectionLabel.data());
                                            addSection(yyscanner);
                                          }
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<SectionLabel>.                         { // invalid character for section label
                                          if (yyextra->sectionLabel.empty())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                              "Invalid or missing section label"
                                              );
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionLabel=yyextra->raisePrefix+yyextra->sectionLabel;
                                            addOutput(yyscanner,yyextra->sectionLabel.data());
                                            yyextra->sectionTitle.clear();
                                            unput_string(yytext,yyleng);
                                            BEGIN(SectionTitle);
                                          }
                                        }
<SectionTitle>{STAopt}/"\n"             { // end of section title
                                          addSection(yyscanner);
                                          addOutput(yyscanner,yytext);
                                          BEGIN( Comment );
                                        }
<SectionTitle>{STopt}"\\\\ilinebr"      { // escaped end of section title
                                          yyextra->sectionTitle+=yytext;
                                        }
<SectionTitle>{STopt}/"\\ilinebr"       { // end of section title
                                          addSection(yyscanner);
                                          addOutput(yyscanner,yytext);
                                          BEGIN( Comment );
                                        }
<SectionTitle>{B}*{CMD}"f$"             {
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="$";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaShortSection);
                                        }
<SectionTitle>{B}*{CMD}"f("             { // start of a inline formula
                                          yyextra->formulaText="";
                                          yyextra->formulaPreText="";
                                          yyextra->formulaPostText="";
                                          yyextra->formulaNewLines=0;
                                          BEGIN(ReadFormulaRoundSection);
                                        }
<SectionTitle>{B}*{CMD}"~"[a-z_A-Z-]*   | // language switch command
<SectionTitle>{B}*{CMD}"f"[\‍[{]         { // block formula
                                          setOutput(yyscanner,OutputDoc);
                                          addOutput(yyscanner," \\ilinebr ");
                                          addSection(yyscanner,false);
                                          warn(yyextra->fileName,yyextra->lineNr,
                                                "'\\{}' command is not allowed in section title, ending section title.",
                                               DString(yytext).stripWhiteSpace()
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN(Comment);
                                        }
<SectionTitle>{LC}                      { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<SectionTitle>[^\n@\\‍]*                 { // any character without special meaning
                                          yyextra->sectionTitle+=yytext;
                                          addOutput(yyscanner,yytext);
                                        }
<SectionTitle>{B}*{CMD}{CMD}            {
                                          yyextra->sectionTitle+=yytext;
                                          addOutput(yyscanner,yytext);
                                        }
<SectionTitle>{B}*{CMD}[a-z_A-Z]+"{"[^}]*"}"{B}*  |
<SectionTitle>{B}*{CMD}[a-z_A-Z]+{B}*   { // handling command in section title
                                          DString fullMatch = yytext;
                                          size_t idx = fullMatch.find('{');
                                          /* handle `f{` command as special case */
                                          if ((idx > 1) && (yytext[idx-1] == 'f') && (yytext[idx-2] == '\\' || yytext[idx-2] =='@')) REJECT;
                                          size_t idxEnd = fullMatch.find("}",idx+1);
                                          DString cmdName;
                                          StringVector optList;
                                          if (idx == DString::npos) // no options
                                          {
                                            cmdName = fullMatch.stripWhiteSpace().mid(1); // to remove {CMD}
                                          }
                                          else // options present
                                          {
                                            cmdName = fullMatch.left(idx).stripWhiteSpace().mid(1); // to remove {CMD}
                                            DString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
                                            optList = split(optStr.str(),",");
                                          }
                                          auto it = docCmdMap.find(cmdName.str());
                                          if (it!=docCmdMap.end()) // special action is required
                                          {
                                            switch (it->second.sectionHandling)
                                            {
                                              case SectionHandling::Escape:
                                                {
                                                  int i=0;
                                                  while (yytext[i]==' ' || yytext[i]=='\t') i++;
                                                  yyextra->sectionTitle+=fullMatch.left(i);
                                                  yyextra->sectionTitle+='@';
                                                  yyextra->sectionTitle+=fullMatch.mid(i);
                                                  addOutput(yyscanner,qPrint(fullMatch.left(i)));
                                                  addOutput(yyscanner,'@');
                                                  addOutput(yyscanner,qPrint(fullMatch.mid(i)));
                                                  warn(yyextra->fileName,yyextra->lineNr,
                                                    "'\\{}' command is not allowed in section title, escaping command.",cmdName
                                                  );
                                                }
                                                break;
                                              case SectionHandling::Break:
                                                {
                                                  addSection(yyscanner,false);
                                                  addOutput(yyscanner," \\ilinebr ");
                                                  warn(yyextra->fileName,yyextra->lineNr,
                                                    "'\\{}' command is not allowed in section title, ending section title.",cmdName
                                                  );
                                                  unput_string(yytext,yyleng);
                                                  BEGIN(Comment);
                                                }
                                                break;
                                              case SectionHandling::Replace:
                                                {
                                                  if (cmdName == "fileinfo")
                                                  {
                                                    int i=0;
                                                    while (yytext[i]==' ' || yytext[i]=='\t') i++;
                                                    yyextra->sectionTitle+=fullMatch.left(i);
                                                    addOutput(yyscanner,fullMatch.left(i));
                                                    handleFileInfoSection(yyscanner,cmdName,optList);
                                                    if (idxEnd == DString::npos)
                                                    {
                                                      yyextra->sectionTitle+=fullMatch.mid(i+9);
                                                      addOutput(yyscanner,fullMatch.mid(i+9));
                                                    }
                                                    else
                                                    {
                                                      yyextra->sectionTitle+=fullMatch.mid(idxEnd+1);
                                                      addOutput(yyscanner,fullMatch.mid(idxEnd+1));
                                                    }
                                                  }
                                                  else if (cmdName == "lineinfo")
                                                  {
                                                    int i=0;
                                                    while (yytext[i]==' ' || yytext[i]=='\t') i++;
                                                    yyextra->sectionTitle+=fullMatch.left(i);
                                                    yyextra->sectionTitle+=DString().setNum(yyextra->lineNr);
                                                    yyextra->sectionTitle+=' ';
                                                    yyextra->sectionTitle+=fullMatch.mid(i+9);
                                                    addOutput(yyscanner,fullMatch.left(i));
                                                    addOutput(yyscanner,DString().setNum(yyextra->lineNr));
                                                    addOutput(yyscanner,' ');
                                                    addOutput(yyscanner,fullMatch.mid(i+9));
                                                  }
                                                  else if (cmdName == "raisewarning")
                                                  {
                                                    yyextra->raiseWarning = "";
                                                    BEGIN(RaiseWarningSection);
                                                  }
                                                  else if (cmdName == "noop")
                                                  {
                                                    addSection(yyscanner,false);
                                                    BEGIN(Noop);
                                                  }
                                                  else if (cmdName == "cite")
                                                  {
                                                    yyextra->sectionTitle+=yytext;
                                                    addOutput(yyscanner,yytext);
                                                    BEGIN(CiteLabelSection);
                                                  }
                                                  else if (cmdName == "iline")
                                                  {
                                                    yyextra->sectionTitle+=yytext;
                                                    addOutput(yyscanner,yytext);
                                                    BEGIN(ILineSection);
                                                  }
                                                  else if (cmdName == "ifile")
                                                  {
                                                    yyextra->sectionTitle+=yytext;
                                                    addOutput(yyscanner,yytext);
                                                    BEGIN(IFileSection);
                                                  }
                                                  else if ((cmdName == "anchor") || (cmdName == "ianchor"))
                                                  {
                                                    addOutput(yyscanner,"@"+cmdName);
                                                    if (optList.empty())
                                                    {
                                                      yyextra -> anchorTitle = "";
                                                    }
                                                    else
                                                    {
                                                      addOutput(yyscanner,"{"+join(optList," ")+"}");
                                                      yyextra -> anchorTitle = join(optList," ");
                                                    }
                                                    addOutput(yyscanner," ");
                                                    BEGIN(AnchorLabelSection);
                                                  }
                                                  else if (cmdName == "link")
                                                  {
                                                    yyextra->sectionTitle+=yytext;
                                                    BEGIN(LinkSection);
                                                  }
                                                  else
                                                  {
                                                    yyextra->sectionTitle+=yytext;
                                                    warn(yyextra->fileName,yyextra->lineNr,
                                                      "internal error '\\{}' command is to be replaced in section title.",cmdName
                                                    );
                                                  }
                                                }
                                                break;
                                              case SectionHandling::Allowed:
                                                {
                                                  yyextra->sectionTitle+=yytext;
                                                  addOutput(yyscanner,yytext);
                                                }
                                                break;
                                            }
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            addOutput(yyscanner,yytext);
                                          }
                                        }
<SectionTitle>.                         { // anything else
                                          yyextra->sectionTitle+=yytext;
                                          addOutput(yyscanner,*yytext);
                                        }
 
  /* ----- handle arguments of the subpage command ------- */
 
<SubpageLabel>{FILE}                    { // first argument
                                          addOutput(yyscanner,yytext);
                                          // we add subpage labels as a kind of "inheritance" relation to prevent
                                          // needing to add another list to the Entry class.
                                          yyextra->current->extends.emplace_back(yytext,Protection::Public,Specifier::Normal);
                                          BEGIN(SubpageTitle);
                                        }
<SubpageLabel>{DOCNL}                   { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "\\subpage command has no label"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<SubpageLabel>.                         {
                                          unput(yytext[0]);
                                          BEGIN( Comment );
                                        }
<SubpageTitle>{DOCNL}                   { // no title, end command
                                          addOutput(yyscanner,yytext);
                                          BEGIN( Comment );
                                        }
<SubpageTitle>[ \t]*"\""[^\"\n]*"\""    { // add title, end of command
                                          addOutput(yyscanner,yytext);
                                          BEGIN( Comment );
                                        }
<SubpageTitle>.                         { // no title, end of command
                                          unput(*yytext);
                                          BEGIN( Comment );
                                        }
 
  /* ----- handle arguments of the anchor command ------- */
 
<AnchorLabel,AnchorLabelSection>{LABELID} { // found argument
                                          DString lbl = yyextra->raisePrefix+yytext;
                                          addAnchor(yyscanner,lbl, yyextra->anchorTitle);
                                          addOutput(yyscanner,lbl.data());
                                          if (YY_START == AnchorLabel)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            BEGIN(SectionTitle);
                                          }
                                        }
<AnchorLabel,AnchorLabelSection>{DOCNL} { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "\\anchor command has no label"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          if (YY_START == AnchorLabel)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            BEGIN(SectionTitle);
                                          }
                                        }
<AnchorLabel,AnchorLabelSection>.       { // invalid character for anchor label
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Invalid or missing anchor label"
                                              );
                                          addOutput(yyscanner,yytext);
                                          if (YY_START == AnchorLabel)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            BEGIN(SectionTitle);
                                          }
                                        }
 
  /* ----- handle arguments of the anchor command ------- */
 
<RequirementLabel>{REQID}               { // found argument
                                          yyextra->current->name = yytext;
                                          yyextra->current->type.clear();
                                          BEGIN( RequirementTitle );
                                        }
<SatisfiesLabel>{REQID}                 { // found argument
                                          yyextra->reqId = yytext;
                                          yyextra->reqTitle.clear();
                                          BEGIN( SatisfiesTitle );
                                        }
<VerifiesLabel>{REQID}                  { // found argument
                                          yyextra->reqId = yytext;
                                          yyextra->reqTitle.clear();
                                          BEGIN( VerifiesTitle );
                                        }
<RequirementLabel,SatisfiesLabel,VerifiesLabel>"\\"{B}*"\n"  { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<RequirementLabel,SatisfiesLabel,VerifiesLabel>{DOCNL}       { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                               "missing requirement ID after \\requirement command"
                                              );
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<RequirementLabel,SatisfiesLabel,VerifiesLabel>.  { // invalid character for requirement label
                                        }
 
<RequirementTitle,SatisfiesTitle,VerifiesTitle>"\\"{B}*"\n"          { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<RequirementTitle>[^\n\\‍]+              { // title (stored in type)
                                          yyextra->current->type += yytext;
                                        }
<SatisfiesTitle,VerifiesTitle>[^\n\\@]+ { // title (stored in type)
                                          yyextra->reqTitle += yytext;
                                        }
<RequirementTitle>({CMD}("verifies"|"satisfies"|"requirement"){B}+)|{DOCNL}+              {
                                          yyextra->current->type = yyextra->current->type.stripWhiteSpace();
                                          unput_string(yytext,yyleng);
                                          addRequirementId(yyscanner);
                                          BEGIN( Comment );
                                        }
<SatisfiesTitle>({CMD}("verifies"|"satisfies"|"requirement"){B}+)|{DOCNL}+              {
                                          yyextra->reqTitle = yyextra->reqTitle.stripWhiteSpace();
                                          unput_string(yytext,yyleng);
                                          if (yyextra->current->section.isRequirementDoc())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                 "@satisfies command is not allowed in documentation of a requirement. Put in at the place where the requirement is implemented."
                                                );
                                          }
                                          else
                                          {
                                            yyextra->current->rqli.emplace_back(RequirementRefType::Satisfies,
                                                yyextra->reqId,
                                                yyextra->reqTitle,
                                                yyextra->fileName,
                                                yyextra->lineNr);
                                          }
                                          BEGIN( Comment );
                                        }
<VerifiesTitle>({CMD}("verifies"|"satisfies"|"requirement"){B}+)|{DOCNL}+              {
                                          yyextra->reqTitle = yyextra->reqTitle.stripWhiteSpace();
                                          unput_string(yytext,yyleng);
                                          if (yyextra->current->section.isRequirementDoc())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                 "@verifies command is not allowed in documentation of a requirement. Put in at the place where the requirement is tested."
                                                );
                                          }
                                          else
                                          {
                                            yyextra->current->rqli.emplace_back(RequirementRefType::Verifies,
                                                yyextra->reqId,
                                                yyextra->reqTitle,
                                                yyextra->fileName,
                                                yyextra->lineNr);
                                          }
                                          BEGIN( Comment );
                                        }
<RequirementTitle>.                     { // title (stored in type)
                                          yyextra->current->type += yytext;
                                        }
<SatisfiesTitle,VerifiesTitle>.         { // title (stored in reqTitle)
                                          yyextra->reqTitle += yytext;
                                        }
 
 
  /* ----- handle arguments of the preformatted block commands ------- */
 
<FormatBlock>{CMD}("endverbatim"|"endiverbatim"|"endiliteral"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endrtfonly"|"endmanonly"|"enddot"|"endcode"|"endicode"|"endmsc"|"endmermaid")/{NW} { // possible ends
                                          addOutput(yyscanner,yytext);
                                          if (&yytext[4]==yyextra->blockName) // found end of the block
                                          {
                                              BEGIN(Comment);
                                          }
                                        }
<FormatBlock>{CMD}"enduml"              {
                                          addOutput(yyscanner,yytext);
                                          if (yyextra->blockName=="startuml") // found end of the block
                                          {
                                              BEGIN(Comment);
                                          }
                                        }
<FormatBlock>[^ \@\*\/\\\n]*            { // some word
                                          addOutput(yyscanner,yytext);
                                        }
<FormatBlock>{DOCNL}                    { // new line
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<FormatBlock>{CCS}                       { // start of a C-comment
                                          if (!(yyextra->blockName=="code"  || yyextra->blockName=="verbatim" ||
                                                yyextra->blockName=="icode" || yyextra->blockName=="iverbatim"||
                                                yyextra->blockName=="iliteral"
                                               )
                                             ) yyextra->commentCount++;
                                          addOutput(yyscanner,yytext);
                                        }
<FormatBlock>{CCE}                       { // end of a C-comment
                                          addOutput(yyscanner,yytext);
                                          if (!(yyextra->blockName=="code"  || yyextra->blockName=="verbatim" ||
                                                yyextra->blockName=="icode" || yyextra->blockName=="iverbatim"||
                                                yyextra->blockName=="iliteral"
                                               )
                                             )
                                          {
                                            yyextra->commentCount--;
                                            if (yyextra->commentCount<0)
                                            {
                                              DString endTag = "end"+yyextra->blockName;
                                              if (yyextra->blockName=="startuml") endTag="enduml";
                                              warn(yyextra->fileName,yyextra->lineNr,
                                                 "found */ without matching /* while inside a \\{} block! Perhaps a missing \\{}?",
                                                 yyextra->blockName,endTag);
                                            }
                                          }
                                        }
<FormatBlock>.                          {
                                          addOutput(yyscanner,*yytext);
                                        }
<FormatBlock><<EOF>>                    {
                                          DString endTag = "end"+yyextra->blockName;
                                          if (yyextra->blockName=="startuml") endTag="enduml";
                                          warn(yyextra->fileName,yyextra->lineNr,
                                            "reached end of comment while inside a \\{} block; check for missing \\{} tag!",
                                            yyextra->blockName,endTag
                                          );
                                          yyterminate();
                                        }
 
  /* ----- handle arguments of if/ifnot commands ------- */
 
<GuardParam>{B}*"("                     {
                                          yyextra->guardExpr=yytext;
                                          yyextra->roundCount=1;
                                          BEGIN(GuardExpr);
                                        }
<GuardExpr>[^()]*                       {
                                          yyextra->guardExpr+=yytext;
                                          lineCount(yyscanner);
                                        }
<GuardExpr>"("                          {
                                          yyextra->guardExpr+=yytext;
                                          yyextra->roundCount++;
                                        }
<GuardExpr>")"                          {
                                          yyextra->guardExpr+=yytext;
                                          yyextra->roundCount--;
                                          if (yyextra->roundCount==0)
                                          {
                                            handleGuard(yyscanner,yyextra->guardExpr);
                                          }
                                        }
<GuardExpr>\n                           {
                                          warn(yyextra->fileName,yyextra->lineNr,
                                                "invalid expression '{}' for yyextra->guards",yyextra->guardExpr);
                                          unput(*yytext);
                                          BEGIN(GuardParam);
                                        }
<GuardParam>{B}*{CMD}doxyconfig{B}+{DOXYCFG} {
                                          handleGuard(yyscanner,yytext);
                                        }
<GuardParam>{B}*[a-z_A-Z0-9.\-]+({B}*{CMD}doxyconfig{B}+{DOXYCFG})? { // parameter of if/ifnot yyextra->guards
                                          handleGuard(yyscanner,yytext);
                                        }
<GuardParam>{DOCNL}                     { // end of argument
                                          //next line is commented out due to bug620924
                                          //addOutput(yyscanner,'\n');
                                          addIlineBreak(yyscanner,yyextra->lineNr);
                                          unput_string(yytext,yyleng);
                                          handleGuard(yyscanner,DString());
                                        }
<GuardParam>{LC}                        { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<GuardParam>.                           { // empty condition
                                          unput(*yytext);
                                          handleGuard(yyscanner,DString());
                                        }
<GuardParamEnd>{B}*{DOCNL}              {
                                          lineCount(yyscanner);
                                          yyextra->spaceBeforeIf.clear();
                                          addIlineBreak(yyscanner,yyextra->lineNr);
                                          BEGIN(Comment);
                                        }
<GuardParamEnd>{B}*                     {
                                          if (!yyextra->spaceBeforeIf.empty()) // needed for 665313 in combination with bug620924
                                          {
                                            addOutput(yyscanner,yyextra->spaceBeforeIf);
                                          }
                                          yyextra->spaceBeforeIf.clear();
                                          addIlineBreak(yyscanner,yyextra->lineNr);
                                          BEGIN(Comment);
                                        }
<GuardParamEnd>.                        {
                                          unput(*yytext);
                                          addIlineBreak(yyscanner,yyextra->lineNr);
                                          BEGIN(Comment);
                                        }
 
  /* ----- handle skipping of conditional sections ------- */
 
<SkipGuardedSection>{CMD}"ifnot"/{NW}   {
                                          yyextra->guardType = Guard_IfNot;
                                          yyextra->guards->emplace(false);
                                          BEGIN( GuardParam );
                                        }
<SkipGuardedSection>{CMD}"if"/{NW}      {
                                          yyextra->guardType = Guard_If;
                                          yyextra->guards->emplace(false);
                                          BEGIN( GuardParam );
                                        }
<SkipGuardedSection>{CMD}"endif"/{NW}   {
                                          if (yyextra->guards->empty())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                "found \\endif without matching start command");
                                            BEGIN( Comment );
                                          }
                                          else
                                          {
                                            yyextra->guards->pop();
                                            if (yyextra->guards->empty())
                                            {
                                              BEGIN( GuardParamEnd );
                                            }
                                            else
                                            {
                                              if (yyextra->guards->top().isEnabled())
                                              {
                                                BEGIN( GuardParamEnd );
                                              }
                                              else
                                              {
                                                BEGIN( SkipGuardedSection );
                                              }
                                            }
                                          }
                                        }
<SkipGuardedSection>{CMD}"else"/{NW}    {
                                          if (yyextra->guards->empty())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                "found \\else without matching start command");
                                          }
                                          else if (yyextra->guards->top().hasElse())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                "found multiple \\else commands in same \\if construct");
                                            yyextra->guards->top().setEnabled(false);
                                            BEGIN( SkipGuardedSection );
                                          }
                                          else if (!yyextra->guards->top().parentVisible())
                                          {
                                            yyextra->guards->top().setEnabled(false);
                                            BEGIN( SkipGuardedSection );
                                          }
                                          else
                                          {
                                            yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
                                            yyextra->guards->top().setElse();
                                            if (!yyextra->guards->top().parentVisible())
                                            {
                                              yyextra->guards->top().setEnabled(false);
                                              BEGIN( SkipGuardedSection );
                                            }
                                            else if (yyextra->guards->top().isEnabledFound())
                                            {
                                              yyextra->guards->top().setEnabled(false);
                                              BEGIN( SkipGuardedSection );
                                            }
                                            else
                                            {
                                              yyextra->guards->top().setEnabled(true);
                                              BEGIN( GuardParamEnd );
                                            }
                                          }
                                        }
<SkipGuardedSection>{CMD}"elseif"/{NW}  {
                                          if (yyextra->guards->empty())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                "found \\elseif without matching start command");
                                          }
                                          else if (yyextra->guards->top().hasElse())
                                          {
                                            warn(yyextra->fileName,yyextra->lineNr,
                                                "found \\elseif command after \\else command was given in \\if construct");
                                            yyextra->guardType = Guard_ElseIf;
                                            yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
                                            yyextra->guards->top().setEnabled(false);
                                            BEGIN( GuardParam );
                                          }
                                          else
                                          {
                                            yyextra->guardType = Guard_ElseIf;
                                            yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
                                            yyextra->guards->top().setEnabled(false);
                                            BEGIN( GuardParam );
                                          }
                                        }
<SkipGuardedSection>{DOCNL}             { // skip line
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                        }
<SkipGuardedSection>[^ \\@\n]+          { // skip non-special characters
                                        }
<SkipGuardedSection>{CMD}{CMD}          |
<SkipGuardedSection>.                   { // any other character
                                        }
 
 
  /* ----- handle skipping of internal section ------- */
 
<SkipInternal>{DOCNL}                   { // skip line
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<SkipInternal>{CMD}"if"/[ \t]           {
                                          yyextra->condCount++;
                                          }
<SkipInternal>{CMD}"ifnot"/[ \t]        {
                                          yyextra->condCount++;
                                        }
<SkipInternal>{CMD}/"endif"             {
                                          yyextra->condCount--;
                                          if (yyextra->condCount<0) // handle conditional section around of \internal, see bug607743
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"section"[ \t]      {
                                          if (yyextra->sectionLevel>0)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"subsection"[ \t]   {
                                          if (yyextra->sectionLevel>1)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"subsubsection"[ \t] {
                                          if (yyextra->sectionLevel>2)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"paragraph"[ \t]    {
                                          if (yyextra->sectionLevel>3)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"subparagraph"[ \t] {
                                          if (yyextra->sectionLevel>4)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}/"subsubparagraph"[ \t] {
                                          if (yyextra->sectionLevel>5)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
<SkipInternal>{CMD}"endinternal"[ \t]*  {
                                          BEGIN(Comment);
                                        }
<SkipInternal>[^ \\@\n]+                { // skip non-special characters
                                        }
<SkipInternal>.                         { // any other character
                                        }
 
 
  /* ----- handle argument of name command ------- */
 
<NameParam>{DOCNL}                      { // end of argument
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<NameParam>{LC}                         { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          yyextra->docGroup.appendHeader(' ');
                                        }
<NameParam>.                            { // ignore other stuff
                                          yyextra->docGroup.appendHeader(*yytext);
                                          yyextra->current->name+=*yytext;
                                        }
 
  /* ----- handle argument of noop command ------- */
<Noop>{DOCNL}                           { // end of argument
                                          if (*yytext=='\n')
                                          {
                                            yyextra->lineNr++;
                                            addOutput(yyscanner,'\n');
                                          }
                                          BEGIN( Comment );
                                        }
<Noop>.                                 { // ignore other stuff
                                        }
  /* ----- handle argument of raisewarning command ------- */
<RaiseWarning,RaiseWarningSection>{DOCNL} { // end of argument
                                          warn_doc_error(yyextra->fileName,yyextra->lineNr,
                                                         "{}",yyextra->raiseWarning);
                                          yyextra->raiseWarning = "";
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          if (YY_START == RaiseWarning)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
<RaiseWarning,RaiseWarningSection>.     { // ignore other stuff
                                          yyextra->raiseWarning += yytext;
                                        }
  /* ----- handle argument of ingroup command ------- */
 
<InGroupParam>{LABELID}                 { // group id
                                          yyextra->current->groups.emplace_back(
                                             yytext, Grouping::GROUPING_INGROUP
                                          );
                                          yyextra->inGroupParamFound=true;
                                        }
<InGroupParam>{DOCNL}                   { // missing argument
                                          if (!yyextra->inGroupParamFound)
                                          {
                                             warn(yyextra->fileName,yyextra->lineNr,
                                                "Missing group name for \\ingroup command"
                                                );
                                          }
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<InGroupParam>{LC}                      { // line continuation
                                          yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                        }
<InGroupParam>.                         { // ignore other stuff
                                          addOutput(yyscanner,*yytext);
                                        }
 
  /* ----- handle argument of fn command ------- */
 
<FnParam>{DOCNL}                        { // end of argument
                                          if (yyextra->braceCount==0)
                                          {
                                            if (yyextra->functionProto.stripWhiteSpace().empty())
                                            {
                                              warn(yyextra->fileName,yyextra->lineNr,
                                                   "missing argument after '\\{}'.",yyextra->currentCmd
                                                  );
                                            }
                                            else
                                            {
                                              makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
                                              yyextra->langParser->parsePrototype(yyextra->functionProto);
                                            }
                                            unput_string(yytext,yyleng);
                                            BEGIN( Comment );
                                          }
                                        }
<FnParam>{LC}                           { // line continuation
                                          yyextra->lineNr++;
                                          yyextra->functionProto+=' ';
                                        }
<FnParam>[^@\\\n()]+                    { // non-special characters
                                          yyextra->functionProto+=yytext;
                                        }
<FnParam>"("                            {
                                          yyextra->functionProto+=yytext;
                                          yyextra->braceCount++;
                                        }
<FnParam>")"                            {
                                          yyextra->functionProto+=yytext;
                                          yyextra->braceCount--;
                                        }
<FnParam>.                              { // add other stuff
                                          yyextra->functionProto+=*yytext;
                                        }
 
 
  /* ----- handle argument of overload command ------- */
 
 
<OverloadParam>{DOCNL}                  { // end of argument
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          if (yyextra->functionProto.stripWhiteSpace().empty())
                                          { // plain overload command
                                            addOutput(yyscanner,theTranslator->trOverloadText());
                                            addOutput(yyscanner,'\n');
                                          }
                                          else // overload declaration
                                          {
                                            makeStructuralIndicator(yyscanner,EntryType::makeOverloadDoc);
                                            yyextra->langParser->parsePrototype(yyextra->functionProto);
                                          }
                                          BEGIN( Comment );
                                        }
<OverloadParam>{LC}                     { // line continuation
                                          yyextra->lineNr++;
                                          yyextra->functionProto+=' ';
                                        }
<OverloadParam>.                        { // add other stuff
                                          yyextra->functionProto+=*yytext;
                                        }
 
  /* ----- handle argument of inherit command ------- */
 
<InheritParam>({ID}("::"|"."))*{ID}     { // found argument
                                          yyextra->current->extends.emplace_back(
                                            removeRedundantWhiteSpace(yytext),Protection::Public,Specifier::Normal
                                          );
                                          BEGIN( Comment );
                                        }
<InheritParam>{DOCNL}                   { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "\\inherit command has no argument"
                                              );
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          addOutput(yyscanner,'\n');
                                          BEGIN( Comment );
                                        }
<InheritParam>.                         { // invalid character for anchor label
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "Invalid or missing name for \\inherit command"
                                              );
                                          BEGIN(Comment);
                                        }
 
  /* ----- handle argument of extends and implements commands ------- */
 
<ExtendsParam>({ID}("::"|"."))*{ID}     { // found argument
                                          yyextra->current->extends.emplace_back(
                                            removeRedundantWhiteSpace(yytext),Protection::Public,Specifier::Normal
                                          );
                                          BEGIN( Comment );
                                        }
<ExtendsParam>{DOCNL}                   { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "'\\{}' command has no argument",yyextra->currentCmd
                                              );
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          unput_string(yytext,yyleng);
                                          BEGIN( Comment );
                                        }
<ExtendsParam>.                         { // ignore other stuff
                                        }
 
  /* ----- handle language specific sections ------- */
 
<SkipLang>{CMD}"~"[a-zA-Z-]*            { /* language switch */
                                          DString langId(&yytext[2]);
                                          if (!langId.empty() && !Config_isAvailableEnum(OUTPUT_LANGUAGE,langId))
                                          {
                                             warn(yyextra->fileName,yyextra->lineNr,
                                             "non supported language '{}' specified in '{}'",langId,DString(yytext).stripWhiteSpace());
                                          }
                                          else if (langId.empty() ||
                                              dstricmp(Config_getEnumAsString(OUTPUT_LANGUAGE),langId)==0)
                                          { // enable language specific section
                                            BEGIN(Comment);
                                          }
                                        }
<SkipLang>[^*@\\\n]*                    { /* any character not a *, @, backslash or new line */
                                        }
<SkipLang>{DOCNL}                       { /* new line in verbatim block */
                                          if (*yytext=='\n') yyextra->lineNr++;
                                        }
<SkipLang>.                             { /* any other character */
                                        }
 
  /* ----- handle arguments of the cite command ------- */
 
<CiteLabel,CiteLabelSection>{CITEID}    { // found argument
                                          addCite(yyscanner);
                                          addOutput(yyscanner,yytext);
                                          if (YY_START == CiteLabel)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
<CiteLabel,CiteLabelSection>{DOCNL}     { // missing argument
                                          warn(yyextra->fileName,yyextra->lineNr,
                                              "\\cite command has no label"
                                              );
                                          //if (*yytext=='\n') yyextra->lineNr++;
                                          //addOutput(yyscanner,'\n');
                                          if (YY_START == CiteLabel)
                                          {
                                            unput_string(yytext,yyleng);
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            unput_string(yytext,yyleng);
                                            BEGIN(SectionTitle);
                                          }
                                        }
<CiteLabel,CiteLabelSection>.           { // invalid character for cite label
                                           warn(yyextra->fileName,yyextra->lineNr,
                                              "Invalid or missing cite label"
                                              );
                                          if (YY_START == CiteLabel)
                                          {
                                            BEGIN(Comment);
                                          }
                                          else
                                          {
                                            yyextra->sectionTitle+=yytext;
                                            BEGIN(SectionTitle);
                                          }
                                        }
 
  /* ----- handle argument of the copydoc command ------- */
 
<CopyDoc><<EOF>>                        {
                                          setOutput(yyscanner,OutputDoc);
                                          addOutput(yyscanner," \\ilinebr\\ilinebr\\copydetails ");
                                          addOutput(yyscanner,yyextra->copyDocArg);
                                          addOutput(yyscanner,"\n");
                                          BEGIN(Comment);
                                        }
<CopyDoc>"<"[/]?{TABLEDEL}">"           {
                                          if (yyextra->braceCount==0)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                            addOutput(yyscanner," \\ilinebr\\ilinebr\\copydetails ");
                                            addOutput(yyscanner,yyextra->copyDocArg);
                                            addOutput(yyscanner,yytext);
                                            BEGIN(Comment);
                                          }
                                        }
<CopyDoc>{DOCNL}                        {
                                          if (*yytext=='\n') yyextra->lineNr++;
                                          if (yyextra->braceCount==0)
                                          {
                                            setOutput(yyscanner,OutputDoc);
                                            addOutput(yyscanner," \\ilinebr\\ilinebr\\copydetails ");
                                            addOutput(yyscanner,yyextra->copyDocArg);
                                            addOutput(yyscanner,"\n");
                                            BEGIN(Comment);
                                          }
                                        }
<CopyDoc>{LC}                           { // line continuation
                                          yyextra->lineNr++;
                                        }
<CopyDoc>[^@\\\n()<]+                   { // non-special characters
                                          yyextra->copyDocArg+=yytext;
                                          addOutput(yyscanner,yytext);
                                        }
<CopyDoc>"("                            {
                                          yyextra->copyDocArg+=yytext;
                                          addOutput(yyscanner,yytext);
                                          yyextra->braceCount++;
                                        }
<CopyDoc>")"                            {
                                          yyextra->copyDocArg+=yytext;
                                          addOutput(yyscanner,yytext);
                                          yyextra->braceCount--;
                                        }
<CopyDoc>.                              {
                                          yyextra->copyDocArg+=yytext;
                                          addOutput(yyscanner,yytext);
                                        }
 
 /*
<*>.  { fprintf(stderr,"Lex scanner %s %sdefault rule for state %s: #%s#\n", __FILE__,!yyextra->fileName.empty() ? ("(" + yyextra->fileName +") ").data(): "",stateToString(YY_START),yytext);}
<*>\n  { fprintf(stderr,"Lex scanner %s %sdefault rule newline for state %s.\n", __FILE__, !yyextra->fileName.empty() ? ("(" + yyextra->fileName +") ").data(): "",stateToString(YY_START));}
 */
 
%%

yyread()

int yyread ( yyscan_t yyscanner, char * buf, int max_size )

static

Definition at line 4934 of file commentscan.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->prevPosition=yyextra->inputPosition;
  int c=0;
  while( c < max_size && yyextra->inputString[yyextra->inputPosition] )
  {
    *buf = yyextra->inputString[yyextra->inputPosition++] ;
    //printf("%d (%c)\n",*buf,*buf);
    c++; buf++;
  }
  return c;
}

References yyread().

Referenced by stateToString(), stateToString(), yyread(), yyread(), yyread(), and yyread().

Variable Documentation

docCmdMap

const std::unordered_map< std::string, DocCmdMap > docCmdMap

static

Definition at line 214 of file commentscan.l.

Referenced by CommentScanner::isCommand().

g_citeMutex

std::mutex g_citeMutex

static

Definition at line 542 of file commentscan.l.

Referenced by addCite().

g_formulaMutex

std::mutex g_formulaMutex

static

Definition at line 541 of file commentscan.l.

Referenced by addFormula().

g_sectionMutex

std::mutex g_sectionMutex

static

Definition at line 540 of file commentscan.l.

Referenced by addAnchor(), addRequirementId(), addSection(), and addXRefItemToEntry().

nonBrief_re

const reg::Ex nonBrief_re(R"( *[\\@]ifile \"[^\"]*\" [\\@]iline (\d+) [\\@]ilinebr ([ \n]*))") ( R"( *[\\@]ifile \"[^\"]*\" [\\@]iline (\d+) [\\@]ilinebr ([ \n]*))" )

static

Referenced by endBrief(), and setOutput().