Loading...
Searching...
No Matches
#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 "qcstring.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 "message.h"#include "parserintf.h"#include "reflist.h"#include "section.h"#include "regex.h"#include "util.h"#include "trace.h"#include "stringutil.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 QCString &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 QCString &, const StringVector &) |
| static bool | handleFn (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleDef (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleOverload (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleEnum (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleDefGroup (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleAddToGroup (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleWeakGroup (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleNamespace (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePackage (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleConcept (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleClass (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHeaderFile (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleProtocol (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCategory (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleUnion (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleStruct (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleInterface (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIdlException (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePage (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleMainpage (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleFile (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleDir (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleExample (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleDetails (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleRaiseWarning (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleNoop (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleName (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleTodo (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleTest (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleBug (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleSubpage (yyscan_t yyscanner, const QCString &s, const StringVector &) |
| static bool | handleDeprecated (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleXRefItem (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleRelated (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleRelatedAlso (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleMemberOf (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleRefItem (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleSection (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleAnchor (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleImage (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCite (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleFormatBlock (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleAddIndex (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIf (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIfNot (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleElseIf (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleElse (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleEndIf (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIngroup (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleNoSubGrouping (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleShowInitializer (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideInitializer (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCallgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideCallgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCallergraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideCallergraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIncludegraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIncludedBygraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleShowEnumValues (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideEnumValues (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleShowInlineSource (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideInlineSource (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideIncludegraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideIncludedBygraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleDirectoryGraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideDirectoryGraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCollaborationgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideCollaborationgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleInheritanceGraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideInheritanceGraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleReferencedByRelation (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideReferencedByRelation (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleReferencesRelation (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideReferencesRelation (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleGroupgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleHideGroupgraph (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleInternal (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleStatic (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePure (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePrivate (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePrivateSection (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleProtected (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleProtectedSection (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handlePublic (yyscan_t yyscanner, const QCString &s, const StringVector &) |
| static bool | handlePublicSection (yyscan_t yyscanner, const QCString &s, const StringVector &) |
| static bool | handleQualifier (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleToc (yyscan_t yyscanner, const QCString &s, const StringVector &) |
| static bool | handleInherit (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleExtends (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCopyDoc (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCopyBrief (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleCopyDetails (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleParBlock (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleEndParBlock (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleParam (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleRetval (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleFileInfo (yyscan_t yyscanner, const QCString &cmdName, const StringVector &optList) |
| static bool | handleFileInfoSection (yyscan_t yyscanner, const QCString &cmdName, const StringVector &optList) |
| static bool | handleFileInfoResult (yyscan_t yyscanner, const QCString &, const StringVector &optList, bool isSection) |
| static bool | handleLineInfo (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleModule (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIFile (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleILine (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIRaise (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static bool | handleIPrefix (yyscan_t yyscanner, const QCString &, const StringVector &) |
| static const char * | stateToString (int state) |
| static QCString | stripQuotes (const char *s) |
| static SectionType | sectionLevelToType (int level) |
| static void | stripTrailingWhiteSpace (QCString &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 | addXRefItem (yyscan_t yyscanner, const QCString &listName, const QCString &itemTitle, const QCString &listTitle, bool append) |
| static QCString | 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 QCString &anchor, const QCString &title="") |
| static void | addOutput (yyscan_t yyscanner, const char *s) |
| static void | addOutput (yyscan_t yyscanner, const QCString &s) |
| static void | addOutput (yyscan_t yyscanner, char c) |
| static void | endBrief (yyscan_t yyscanner) |
| static void | handleGuard (yyscan_t yyscanner, const QCString &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 const char * | getLexerFILE () |
| int | yylex (yyscan_t yyscanner) |
Variables | |
| static const std::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 558 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 563 of file commentscan.l.
◆ YY_NEVER_INTERACTIVE
| #define YY_NEVER_INTERACTIVE 1 |
Definition at line 412 of file commentscan.l.
◆ YY_NO_INPUT
| #define YY_NO_INPUT 1 |
Definition at line 410 of file commentscan.l.
◆ YY_NO_UNISTD_H
| #define YY_NO_UNISTD_H 1 |
Definition at line 411 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 QCString &name, const StringVector &optList) |
Definition at line 180 of file commentscan.l.
◆ HtmlContextStack
| using HtmlContextStack = std::vector<HtmlContextInfo> |
Definition at line 452 of file commentscan.l.
◆ MakeEntryType
| typedef EntryType(* MakeEntryType) () |
Definition at line 181 of file commentscan.l.
◆ yyscan_t
| typedef yyguts_t* yyscan_t |
Definition at line 25 of file commentscan.l.
Enumeration Type Documentation
◆ CommandSpacing
|
strong |
Definition at line 183 of file commentscan.l.
184{
@ Inline
command appears inline in the output which can be a brief description.
Definition commentscan.l:186
@ XRef
command is a cross reference (todo, bug, test, deprecated, xrefitem).
Definition commentscan.l:188
@ Invisible
command sets some property but does not appear in the output.
Definition commentscan.l:185
189};
◆ GuardType
| enum GuardType |
| Enumerator | |
|---|---|
| Guard_If | |
| Guard_IfNot | |
| Guard_ElseIf | |
Definition at line 433 of file commentscan.l.
◆ OutputContext
| enum OutputContext |
| Enumerator | |
|---|---|
| OutputDoc | |
| OutputBrief | |
| OutputXRef | |
| OutputInbody | |
Definition at line 425 of file commentscan.l.
◆ SectionHandling
|
strong |
Definition at line 191 of file commentscan.l.
192{
@ Break
command is not-allowed in section title, it will end the section title
Definition commentscan.l:196
197};
◆ XRefKind
| enum XRefKind |
| Enumerator | |
|---|---|
| XRef_Item | |
| XRef_Todo | |
| XRef_Test | |
| XRef_Bug | |
| XRef_Deprecated | |
| XRef_None | |
Definition at line 415 of file commentscan.l.
Function Documentation
◆ addAnchor()
|
static |
Definition at line 4547 of file commentscan.l.
4548{
4549 std::unique_lock<std::mutex> lock(g_sectionMutex);
4550 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4553 if (si)
4554 {
4556 {
4558 yyextra->current->anchors.push_back(si);
4559 }
4561 {
4562 warn(yyextra->fileName,yyextra->lineNr,
4563 "multiple use of section label '{}' while adding anchor, (first occurrence: {}, line {})",
4565 }
4566 else
4567 {
4568 warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding anchor, (first occurrence: {})",
4569 anchor,si->fileName());
4570 }
4571 }
4572 else
4573 {
4575 yyextra->current->anchors.push_back(si);
4576 }
SectionInfo * replace(const QCString &label, const QCString &fileName, int lineNr, const QCString &title, SectionType type, int level, const QCString &ref=QCString())
Definition section.h:154
4577}
References SectionManager::add(), SectionType::Anchor, SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, SectionManager::instance(), QCString::isEmpty(), SectionInfo::lineNr(), SectionInfo::ref(), SectionManager::replace(), and warn.
Referenced by handleImage().
◆ addCite()
|
static |
Definition at line 4350 of file commentscan.l.
4351{
4352 std::unique_lock<std::mutex> lock(g_citeMutex);
4353 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4354 QCString name(yytext);
4355 if (yytext[0] =='"')
4356 {
4357 name=yytext+1;
4358 name=name.left((int)yyleng-2);
4359 }
void insert(const QCString &label)
Insert a citation identified by label into the database.
Definition cite.cpp:90
4361}
References g_citeMutex, CitationManager::insert(), CitationManager::instance(), and QCString::left().
◆ addFormula()
Definition at line 4274 of file commentscan.l.
4275{
4276 std::unique_lock<std::mutex> lock(g_formulaMutex);
4277 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4278 QCString formLabel;
4279 QCString formula = (yyextra->formulaPreText +
4280 yyextra->formulaText.stripLeadingAndTrailingEmptyLines() +
4281 yyextra->formulaPostText).stripWhiteSpace();
4282 //printf("formulaText=\n=1=\n{%s}\n=2=\n{%s}\n=3=\n{%s}\n===",
4283 // qPrint(yyextra->formulaText),
4284 // qPrint(yyextra->formulaText.stripLeadingAndTrailingEmptyLines()),
4285 // qPrint(formula)
4286 // );
4289 for (int i=0;i<yyextra->formulaNewLines;i++) formLabel+="@_fakenl"; // add fake newlines to
4290 // keep the warnings
4291 // correctly aligned.
4292 return formLabel;
int addFormula(const std::string &formulaText, int width=-1, int height=-1)
Definition formula.cpp:691
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:245
4293}
References FormulaManager::addFormula(), g_formulaMutex, FormulaManager::instance(), QCString::sprintf(), QCString::str(), and QCString::stripWhiteSpace().
◆ addIline()
|
static |
Definition at line 4602 of file commentscan.l.
References addOutput(), and qsnprintf.
Referenced by endBrief().
◆ addIlineBreak()
|
static |
Definition at line 4609 of file commentscan.l.
References addOutput(), and qsnprintf.
◆ addOutput() [1/3]
|
inlinestatic |
Definition at line 4596 of file commentscan.l.
4597{
4598 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4599 *yyextra->pOutputString+=c;
4600}
◆ addOutput() [2/3]
|
inlinestatic |
Definition at line 4580 of file commentscan.l.
4581{
4582 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4583 //printf("addOutput(yyscanner,%s)\n",s);
4584 *yyextra->pOutputString+=s;
4585}
Referenced by addIline(), addIlineBreak(), endBrief(), handleAddIndex(), handleAnchor(), handleCite(), handleCopyBrief(), handleCopyDetails(), handleCopyDoc(), handleDetails(), handleEndIf(), handleEndParBlock(), handleFileInfoResult(), handleFormatBlock(), handleIFile(), handleILine(), handleImage(), handleInternal(), handleIPrefix(), handleLineInfo(), handleParam(), handleParBlock(), handleRefItem(), handleRetval(), handleSection(), handleSubpage(), and CommentScanner::parseCommentBlock().
◆ addOutput() [3/3]
Definition at line 4588 of file commentscan.l.
4589{
4590 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4591 //printf("addOutput(yyscanner,%s)\n",s);
4592 *yyextra->pOutputString+=s;
4593}
◆ addSection()
|
static |
Definition at line 4303 of file commentscan.l.
4304{
4305 std::unique_lock<std::mutex> lock(g_sectionMutex);
4306 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4309 if (si)
4310 {
4312 {
4313 // create a new section element
4314 if (addYYtext) yyextra->sectionTitle+=yytext;
4315 yyextra->sectionTitle=yyextra->sectionTitle.stripWhiteSpace();
4316 si = sm.replace(yyextra->sectionLabel,yyextra->fileName,yyextra->lineNr,
4317 yyextra->sectionTitle,sectionLevelToType(yyextra->sectionLevel),
4318 yyextra->sectionLevel);
4319
4320 // add section to this entry
4321 yyextra->current->anchors.push_back(si);
4322 }
4324 {
4325 warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding section, (first occurrence: {}, line {})",
4327 }
4328 else
4329 {
4330 warn(yyextra->fileName,yyextra->lineNr,"multiple use of section label '{}' while adding section, (first occurrence: {})",
4331 yyextra->sectionLabel,si->fileName());
4332 }
4333 }
4334 else
4335 {
4336 // create a new section element
4337 if (addYYtext) yyextra->sectionTitle+=yytext;
4338 yyextra->sectionTitle=yyextra->sectionTitle.stripWhiteSpace();
4339 si = sm.add(yyextra->sectionLabel,yyextra->fileName,yyextra->lineNr,
4340 yyextra->sectionTitle,sectionLevelToType(yyextra->sectionLevel),
4341 yyextra->sectionLevel);
4342
4343 // add section to this entry
4344 yyextra->current->anchors.push_back(si);
4345 }
4346}
References SectionManager::add(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, SectionManager::instance(), QCString::isEmpty(), SectionInfo::lineNr(), SectionInfo::ref(), SectionManager::replace(), sectionLevelToType(), and warn.
◆ addXRefItem()
|
static |
Definition at line 4184 of file commentscan.l.
4187{
4188 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4190 //printf("addXRefItem(%s,%s,%s,%d)\n",listName,itemTitle,listTitle,append);
4191
4192 std::unique_lock<std::mutex> lock(g_sectionMutex);
4193
4196 for (auto it = yyextra->current->sli.rbegin(); it != yyextra->current->sli.rend(); ++it)
4197 {
4198 RefItem *i = *it;
4200 {
4201 //printf("found %s lii->type=%s\n",listName,qPrint(i->list()->listName()));
4202 item = i;
4203 break;
4204 }
4205 }
4206 if (item && append) // already found item of same type just before this one
4207 {
4208 //printf("listName=%s item id = %d existing\n",listName,item->id());
4210 //printf("%s: text +=%s\n",listName,qPrint(item->text));
4211 }
4212 else // new item
4213 {
4214
4215 // if we have already an item from the same list type (e.g. a second @todo)
4216 // in the same Entry (i.e. lii!=0) then we reuse its link anchor.
4217 item = refList->add();
4218 //printf("listName=%s item id = %d new yyextra->current=%p\n",listName,item->id(),yyextra->current);
4219 QCString anchorLabel;
4221 item->setText(yyextra->outputXRef);
4222 item->setAnchor(anchorLabel);
4223 yyextra->current->sli.push_back(item);
4224 QCString cmdString;
4226 if (yyextra->inBody)
4227 {
4228 yyextra->current->inbodyDocs += cmdString;
4229 }
4230 else
4231 {
4232 yyextra->current->doc += cmdString;
4233 }
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:159
4234
4235 {
4238 if (si)
4239 {
4241 {
4242 si = sm.replace(anchorLabel,listName,yyextra->lineNr,
4243 yyextra->sectionTitle,SectionType::Anchor,
4244 yyextra->sectionLevel);
4245 yyextra->current->anchors.push_back(si);
4246 }
4248 {
4249 warn(listName,yyextra->lineNr,"multiple use of section label '{}', (first occurrence: {}, line {})",
4251 }
4252 else
4253 {
4255 anchorLabel,si->fileName());
4256 }
4257 }
4258 else
4259 {
4260 si = sm.add(anchorLabel,listName,yyextra->lineNr,
4261 yyextra->sectionTitle,SectionType::Anchor,
4262 yyextra->sectionLevel);
4263 yyextra->current->anchors.push_back(si);
4264 }
4265 }
4266 }
4267 yyextra->outputXRef.clear();
4268}
References LinkedMap< T, Hash, KeyEqual, Map >::add(), RefList::add(), SectionManager::add(), SectionType::Anchor, QCString::data(), SectionInfo::fileName(), LinkedMap< T, Hash, KeyEqual, Map >::find(), g_sectionMutex, RefItem::id(), RefListManager::instance(), SectionManager::instance(), QCString::isEmpty(), SectionInfo::lineNr(), RefItem::list(), RefList::listName(), qPrint(), SectionInfo::ref(), SectionManager::replace(), RefItem::setAnchor(), RefItem::setText(), QCString::sprintf(), RefItem::text(), and warn.
Referenced by setOutput().
◆ checkFormula()
|
static |
Definition at line 4662 of file commentscan.l.
4663{
4664 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4665 if (YY_START==ReadFormulaShort || YY_START==ReadFormulaShortSection ||
4666 YY_START==ReadFormulaRound || YY_START==ReadFormulaRoundSection ||
4667 YY_START==ReadFormulaLong)
4668 {
4670 }
4671}
References warn.
Referenced by CommentScanner::parseCommentBlock().
◆ checkStructuralIndicator()
|
static |
Definition at line 4128 of file commentscan.l.
4129{
4130 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4131 //printf("yyextra->current->section=%x\n",yyextra->current->section);
4132 return yyextra->current->section.isDoc();
4133}
Referenced by handleCategory(), handleClass(), handleConcept(), handleDef(), handleEnum(), handleFn(), handleIdlException(), handleInterface(), handleModule(), handleNamespace(), handleProtocol(), handleStruct(), and handleUnion().
◆ endBrief()
|
static |
Definition at line 4616 of file commentscan.l.
4617{
4618 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4619 std::string_view str = yyextra->current->brief.view();
4622 { // only go to the detailed description if we have
4623 // found some brief description and not just whitespace
4624 yyextra->briefEndsAtDot=FALSE;
4626 if (yyextra->current->doc.stripWhiteSpace().isEmpty())
4627 {
4628 yyextra->current->docLine = yyextra->lineNr;
4629 yyextra->current->doc = "";
4630 }
4631 else
4632 {
4633 addIline(yyscanner,yyextra->lineNr);
4634 }
4635 addOutput(yyscanner,yytext);
4636 }
4637 else
4638 {
4639 int saveLineNr = yyextra->lineNr;
4640 lineCount(yyscanner);
4641 yyextra->current->briefLine = yyextra->lineNr;
4642 yyextra->lineNr = saveLineNr;
4643 }
static const reg::Ex nonBrief_re(R"( *[\\@]ifile \"[^\"]*\" [\\@]iline (\d+) [\\@]ilinebr ([ \n]*))")
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:759
std::string_view stripWhiteSpace(std::string_view s)
Given a string view s, returns a new, narrower view on that string, skipping over any leading or trai...
Definition stringutil.h:72
4644}
References addIline(), addOutput(), FALSE, lineCount, reg::match(), nonBrief_re, OutputDoc, setOutput(), and stripWhiteSpace().
◆ getLexerFILE()
|
inlinestatic |
Definition at line 566 of file commentscan.l.
566{return __FILE__;}
◆ handleAddIndex()
|
static |
Definition at line 3391 of file commentscan.l.
3392{
3393 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3394 addOutput(yyscanner,yytext);
3395 BEGIN(LineParam);
3397}
References addOutput(), and FALSE.
◆ handleAddToGroup()
|
static |
Definition at line 2891 of file commentscan.l.
2892{
2893 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2895 yyextra->current->groupDocType = Entry::GROUPDOC_ADD;
2896 BEGIN( GroupDocArg1 );
2897 return stop;
static bool makeStructuralIndicator(yyscan_t yyscanner, MakeEntryType maker)
Definition commentscan.l:4135
2898}
References Entry::GROUPDOC_ADD, and makeStructuralIndicator().
◆ handleAnchor()
|
static |
Definition at line 3314 of file commentscan.l.
3315{
3316 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3318 if (optList.empty())
3319 {
3320 yyextra -> anchorTitle = "";
3321 }
3322 else
3323 {
3325 }
3326 BEGIN(AnchorLabel);
std::string join(const StringVector &sv, const std::string &delimiter)
create a string where the string in the vector are joined by the given delimiter
Definition util.cpp:7093
3328}
References addOutput(), FALSE, and join().
◆ handleBrief()
|
static |
Definition at line 2837 of file commentscan.l.
2838{
2839 //printf("handleBrief\n");
2842}
References FALSE, OutputBrief, and setOutput().
◆ handleBug()
|
static |
Definition at line 3156 of file commentscan.l.
3157{
3158 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3159 yyextra->newXRefKind = XRef_Bug;
3161 yyextra->xrefKind = XRef_Bug;
3163}
References FALSE, OutputXRef, setOutput(), and XRef_Bug.
◆ handleCallergraph()
|
static |
Definition at line 3714 of file commentscan.l.
3715{
3716 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3717 yyextra->current->commandOverrides.override_callerGraph(true); // ON
3719}
References FALSE.
◆ handleCallgraph()
|
static |
Definition at line 3700 of file commentscan.l.
3701{
3702 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3703 yyextra->current->commandOverrides.override_callGraph(true); // ON
3705}
References FALSE.
◆ handleCategory()
|
static |
Definition at line 2968 of file commentscan.l.
2969{ // Obj-C category
2970 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2971 yyextra->currentCmd = cmd;
2972 yyextra->currentMakeEntryType = EntryType::makeCategoryDoc;
2973 BEGIN( CategoryDocArg1 );
static bool checkStructuralIndicator(yyscan_t yyscanner)
Definition commentscan.l:4128
2975}
References checkStructuralIndicator().
◆ handleCite()
|
static |
Definition at line 3355 of file commentscan.l.
3356{
3357 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3358 if (!yyextra->spaceBeforeCmd.isEmpty())
3359 {
3360 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3361 yyextra->spaceBeforeCmd.clear();
3362 }
3364 BEGIN(CiteLabel);
3366}
References addOutput(), and FALSE.
◆ handleClass()
|
static |
Definition at line 2925 of file commentscan.l.
2926{
2927 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2928 yyextra->currentCmd = cmd;
2929 yyextra->currentMakeEntryType = EntryType::makeClassDoc;
2930 BEGIN( ClassDocArg1 );
2932}
References checkStructuralIndicator().
◆ handleCollaborationgraph()
|
static |
Definition at line 3798 of file commentscan.l.
3799{
3800 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3801 yyextra->current->commandOverrides.override_collaborationGraph(true); // ON
3803}
References FALSE.
◆ handleConcept()
|
static |
Definition at line 2934 of file commentscan.l.
2935{
2936 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2937 yyextra->currentCmd = cmd;
2938 yyextra->currentMakeEntryType = EntryType::makeConceptDoc;
2939 BEGIN( ConceptDocArg1 );
2941}
References checkStructuralIndicator().
◆ handleCopyBrief()
|
static |
Definition at line 4063 of file commentscan.l.
4064{
4065 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4066 if (yyextra->current->brief.stripWhiteSpace().isEmpty() && yyextra->current->doc.stripWhiteSpace().isEmpty())
4067 { // if we don't have a brief or detailed description yet,
4068 // then the @copybrief should end up in the brief description.
4069 // otherwise it will be copied inline (see bug691315 & bug700788)
4071 }
4072 if (!yyextra->spaceBeforeCmd.isEmpty())
4073 {
4074 addOutput(yyscanner,yyextra->spaceBeforeCmd);
4075 yyextra->spaceBeforeCmd.clear();
4076 }
4079}
References addOutput(), FALSE, OutputBrief, and setOutput().
◆ handleCopyDetails()
|
static |
Definition at line 4081 of file commentscan.l.
4082{
4083 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4085 if (!yyextra->spaceBeforeCmd.isEmpty())
4086 {
4087 addOutput(yyscanner,yyextra->spaceBeforeCmd);
4088 yyextra->spaceBeforeCmd.clear();
4089 }
4092}
References addOutput(), FALSE, OutputDoc, and setOutput().
◆ handleCopyDoc()
|
static |
Definition at line 4094 of file commentscan.l.
4095{
4096 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4097 if (yyextra->current->brief.stripWhiteSpace().isEmpty() && yyextra->current->doc.stripWhiteSpace().isEmpty())
4098 { // if we don't have a brief or detailed description yet,
4099 // then the @copybrief should end up in the brief description.
4100 // otherwise it will be copied inline (see bug691315 & bug700788)
4102 }
4103 if (!yyextra->spaceBeforeCmd.isEmpty())
4104 {
4105 addOutput(yyscanner,yyextra->spaceBeforeCmd);
4106 yyextra->spaceBeforeCmd.clear();
4107 }
4109 yyextra->copyDocArg.clear();
4110 yyextra->braceCount = 0;
4111 BEGIN(CopyDoc);
4113}
References addOutput(), FALSE, OutputBrief, and setOutput().
◆ handleDef()
|
static |
Definition at line 2855 of file commentscan.l.
2856{
2857 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2858 yyextra->functionProto.clear();
2859 yyextra->braceCount=0;
2860 yyextra->currentCmd = cmd;
2861 yyextra->currentMakeEntryType = EntryType::makeDefineDoc;
2862 BEGIN( FnParam );
2864}
References checkStructuralIndicator().
◆ handleDefGroup()
|
static |
Definition at line 2882 of file commentscan.l.
2883{
2884 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2886 yyextra->current->groupDocType = Entry::GROUPDOC_NORMAL;
2887 BEGIN( GroupDocArg1 );
2888 return stop;
2889}
References Entry::GROUPDOC_NORMAL, and makeStructuralIndicator().
◆ handleDeprecated()
|
static |
Definition at line 3165 of file commentscan.l.
3166{
3167 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3168 yyextra->newXRefKind = XRef_Deprecated;
3170 yyextra->xrefKind = XRef_Deprecated;
3172}
References FALSE, OutputXRef, setOutput(), and XRef_Deprecated.
◆ handleDetails()
|
static |
Definition at line 3095 of file commentscan.l.
3096{
3097 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3099 {
3101 // as a new paragraph
3102 }
3105}
References addOutput(), FALSE, OutputBrief, OutputDoc, and setOutput().
◆ handleDir()
|
static |
Definition at line 3064 of file commentscan.l.
3065{
3066 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3068 if (!stop) yyextra->current->name = yyextra->fileName;
3069 BEGIN( FileDocArg1 );
3070 return stop;
3071}
References makeStructuralIndicator().
◆ handleDirectoryGraph()
|
static |
Definition at line 3784 of file commentscan.l.
3785{
3786 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3787 yyextra->current->commandOverrides.override_directoryGraph(true); // ON
3789}
References FALSE.
◆ handleElse()
|
static |
Definition at line 3602 of file commentscan.l.
3603{
3604 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3605 if (yyextra->guards->empty())
3606 {
3607 warn(yyextra->fileName,yyextra->lineNr,
3608 "found \\else without matching start command");
3609 }
3610 else if (yyextra->guards->top().hasElse())
3611 {
3612 warn(yyextra->fileName,yyextra->lineNr,
3613 "found multiple \\else commands in same \\if construct");
3614 yyextra->guards->top().setEnabled(false);
3615 yyextra->guards->top().setElse();
3616 BEGIN( SkipGuardedSection );
3617 }
3618 else
3619 {
3620 yyextra->guards->top().setElse();
3621 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
3622 if (yyextra->guards->top().isEnabledFound())
3623 {
3624 yyextra->guards->top().setEnabled(false);
3625 BEGIN( SkipGuardedSection );
3626 }
3627 else
3628 {
3629 yyextra->guards->top().setEnabled(true);
3630 BEGIN( GuardParamEnd );
3631 }
3632 }
3634}
◆ handleElseIf()
|
static |
Definition at line 3575 of file commentscan.l.
3576{
3577 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3578 if (yyextra->guards->empty())
3579 {
3580 warn(yyextra->fileName,yyextra->lineNr,
3581 "found \\elseif without matching start command");
3582 }
3583 else if (yyextra->guards->top().hasElse())
3584 {
3585 warn(yyextra->fileName,yyextra->lineNr,
3586 "found \\elseif command after \\else command was given in \\if construct");
3587 yyextra->guardType = Guard_ElseIf;
3588 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
3589 yyextra->guards->top().setEnabled(false);
3590 BEGIN(GuardParam);
3591 }
3592 else
3593 {
3594 yyextra->guardType = Guard_ElseIf;
3595 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
3596 yyextra->guards->top().setEnabled(false);
3597 BEGIN(GuardParam);
3598 }
3600}
References FALSE, Guard_ElseIf, and warn.
◆ handleEndIf()
|
static |
Definition at line 3636 of file commentscan.l.
3637{
3638 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3639 if (yyextra->guards->empty())
3640 {
3641 warn(yyextra->fileName,yyextra->lineNr,
3642 "found \\endif without matching start command");
3643 }
3644 else
3645 {
3646 yyextra->guards->pop();
3647 }
3648 if (!yyextra->spaceBeforeCmd.isEmpty())
3649 {
3650 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3651 yyextra->spaceBeforeCmd.clear();
3652 }
3653 if (yyextra->guards->empty())
3654 {
3655 BEGIN( GuardParamEnd );
3656 }
3657 else
3658 {
3659 if (yyextra->guards->top().isEnabled())
3660 {
3661 BEGIN( GuardParamEnd );
3662 }
3663 else
3664 {
3665 BEGIN( SkipGuardedSection );
3666 }
3667 }
3669}
References addOutput(), FALSE, and warn.
◆ handleEndParBlock()
|
static |
Definition at line 3200 of file commentscan.l.
3201{
3202 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3203 if (!yyextra->insideParBlock)
3204 {
3205 warn(yyextra->fileName,yyextra->lineNr,
3206 "found \\endparblock command without matching \\parblock!");
3207 }
3210 yyextra->insideParBlock = FALSE;
3212}
References addOutput(), FALSE, OutputDoc, setOutput(), and warn.
◆ handleEnum()
|
static |
Definition at line 2874 of file commentscan.l.
2875{
2876 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2877 yyextra->currentMakeEntryType = EntryType::makeEnumDoc;
2878 BEGIN( EnumDocArg1 );
2880}
References checkStructuralIndicator().
◆ handleExample()
|
static |
Definition at line 3073 of file commentscan.l.
3074{
3075 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3076 MakeEntryType sectionMaker = EntryType::makeExample;
3077 for (const auto &opt : optList)
3078 {
3079 if (opt=="lineno")
3080 {
3081 sectionMaker=EntryType::makeExampleLineno;
3082 }
3083 else
3084 {
3085 warn(yyextra->fileName,yyextra->lineNr,
3086 "unsupported option '{}' for command '\\{}'",opt,cmd);
3087 }
3088 }
3090 if (!stop) yyextra->current->name = yyextra->fileName;
3091 BEGIN( FileDocArg1 );
3092 return stop;
3093}
References makeStructuralIndicator(), and warn.
◆ handleExtends()
|
static |
Definition at line 4055 of file commentscan.l.
4056{
4057 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4058 yyextra->currentCmd = cmd;
4059 BEGIN(ExtendsParam);
4061}
References FALSE.
◆ handleFile()
|
static |
Definition at line 3034 of file commentscan.l.
3035{
3036 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3038 if (!stop)
3039 {
3040 yyextra->current->name = yyextra->fileName;
3041 }
3042 BEGIN( FileDocArg1 );
3043 return stop;
3044}
References makeStructuralIndicator().
◆ handleFileInfo()
|
static |
Definition at line 3399 of file commentscan.l.
3400{
static bool handleFileInfoResult(yyscan_t yyscanner, const QCString &, const StringVector &optList, bool isSection)
Definition commentscan.l:3407
3402}
References handleFileInfoResult().
◆ handleFileInfoResult()
|
static |
Definition at line 3407 of file commentscan.l.
3408{
3410 static std::unordered_map<std::string,OutputWriter> options =
3411 { // name, writer
3413 if (isSect)
3414 {
3415 struct yyguts_t *yyg = (struct yyguts_t*)s;
3416 yyextra->sectionTitle+=fi.baseName();
3417 }
3418 } },
3420 if (isSect)
3421 {
3422 struct yyguts_t *yyg = (struct yyguts_t*)s;
3423 yyextra->sectionTitle+=fi.extension(true);
3424 }
3425 } },
3427 if (isSect)
3428 {
3429 struct yyguts_t *yyg = (struct yyguts_t*)s;
3430 yyextra->sectionTitle+=fi.fileName();
3431 }
3432 } },
3434 if (isSect)
3435 {
3436 struct yyguts_t *yyg = (struct yyguts_t*)s;
3437 yyextra->sectionTitle+=fi.dirPath();
3438 }
3439 } },
3441 if (isSect)
3442 {
3443 struct yyguts_t *yyg = (struct yyguts_t*)s;
3444 yyextra->sectionTitle+=fi.absFilePath();
3445 }
3446 } },
3447 };
3448
3449 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3450 if (!yyextra->spaceBeforeCmd.isEmpty())
3451 {
3452 if (isSection) yyextra->sectionTitle+=yyextra->spaceBeforeCmd;
3453 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3454 yyextra->spaceBeforeCmd.clear();
3455 }
3456 bool first = true;
3457 FileInfo fi(yyextra->fileName.str());
3458 for (const auto &opt_ : optList)
3459 {
3462 auto it = options.find(opt);
3463 if (it != options.end())
3464 {
3465 if (!first)
3466 {
3467 warn(yyextra->fileName,yyextra->lineNr,"Multiple options specified with \\fileinfo, discarding '{}'", optStripped);
3468 }
3469 else
3470 {
3471 it->second(yyscanner,fi,isSection);
3472 }
3473 first = false;
3474 }
3475 else
3476 {
3477 warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\fileinfo: '{}'", optStripped);
3478 }
3479 }
3480 if (first) // no options specified
3481 {
3483 {
3486 }
3487 else
3488 {
3489 if (isSection) yyextra->sectionTitle+=yyextra->fileName;
3490 addOutput(yyscanner,yyextra->fileName);
3491 }
3492 }
3493 return false;
static QCString stripFromPath(const QCString &p, const StringVector &l)
Definition util.cpp:309
3494}
References addOutput(), Config_getBool, QCString::lower(), QCString::str(), stripFromPath(), QCString::stripWhiteSpace(), and warn.
Referenced by handleFileInfo(), and handleFileInfoSection().
◆ handleFileInfoSection()
|
static |
Definition at line 3403 of file commentscan.l.
References handleFileInfoResult().
◆ handleFn()
|
static |
Definition at line 2844 of file commentscan.l.
2845{
2846 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2847 yyextra->braceCount=0;
2848 yyextra->functionProto.clear();
2849 yyextra->currentCmd = cmd;
2850 yyextra->currentMakeEntryType = EntryType::makeMemberDoc;
2851 BEGIN( FnParam );
2853}
References checkStructuralIndicator().
◆ handleFormatBlock()
|
static |
Definition at line 3368 of file commentscan.l.
3369{
3370 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3371 if (!yyextra->spaceBeforeCmd.isEmpty())
3372 {
3373 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3374 yyextra->spaceBeforeCmd.clear();
3375 }
3376 if (optList.empty())
3377 {
3379 }
3380 else
3381 {
3383 }
3384 //printf("handleFormatBlock(%s) with option(%s)\n",qPrint(s),qPrint(opt));
3385 yyextra->blockName=s;
3386 yyextra->commentCount=0;
3387 BEGIN(FormatBlock);
3389}
References addOutput(), FALSE, and join().
◆ handleGroupgraph()
|
static |
Definition at line 3812 of file commentscan.l.
3813{
3814 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3815 yyextra->current->commandOverrides.override_groupGraph(true); // ON
3817}
References FALSE.
◆ handleGuard()
Definition at line 4824 of file commentscan.l.
4825{
4826 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4827 CondParser prs;
4828 bool sectionEnabled = false;
4830 {
4832 }
4833 bool parentEnabled = yyextra->guards->top().parentVisible();
4834 if (parentEnabled)
4835 {
4836 if (
4837 (sectionEnabled && yyextra->guardType==Guard_If) ||
4838 (!sectionEnabled && yyextra->guardType==Guard_IfNot)
4839 ) // section is visible
4840 {
bool parse(const QCString &fileName, int lineNr, const QCString &expr)
Copyright (C) 1997-2015 by Dimitri van Heesch.
Definition condparser.cpp:36
4841
4842 yyextra->guards->top().setEnabled(true);
4843 yyextra->guards->top().setEnabledFound();
4844 BEGIN( GuardParamEnd );
4845 }
4847 {
4848 if (yyextra->guards->top().isEnabledFound())
4849 {
4850 yyextra->guards->top().setEnabled(false);
4851 BEGIN( SkipGuardedSection );
4852 }
4853 else if (sectionEnabled)
4854 {
4855 yyextra->guards->top().setEnabled(true);
4856 yyextra->guards->top().setEnabledFound();
4857 BEGIN( GuardParamEnd );
4858 }
4859 else
4860 {
4861 yyextra->guards->top().setEnabled(false);
4862 BEGIN( SkipGuardedSection );
4863 }
4864 }
4865 else // section is invisible
4866 {
4867 BEGIN( SkipGuardedSection );
4868 }
4869 }
4870 else // invisible because of parent
4871 {
4872 BEGIN( SkipGuardedSection );
4873 }
4874}
References Guard_ElseIf, Guard_If, Guard_IfNot, QCString::isEmpty(), CondParser::parse(), and QCString::stripWhiteSpace().
◆ handleHeaderFile()
|
static |
Definition at line 2952 of file commentscan.l.
2953{
2954 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2955 BEGIN( ClassDocArg2 );
2957}
References FALSE.
◆ handleHideCallergraph()
|
static |
Definition at line 3721 of file commentscan.l.
3722{
3723 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3724 yyextra->current->commandOverrides.override_callerGraph(false); // OFF
3726}
References FALSE.
◆ handleHideCallgraph()
|
static |
Definition at line 3707 of file commentscan.l.
3708{
3709 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3710 yyextra->current->commandOverrides.override_callGraph(false); // OFF
3712}
References FALSE.
◆ handleHideCollaborationgraph()
|
static |
Definition at line 3805 of file commentscan.l.
3806{
3807 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3808 yyextra->current->commandOverrides.override_collaborationGraph(false); // OFF
3810}
References FALSE.
◆ handleHideDirectoryGraph()
|
static |
Definition at line 3791 of file commentscan.l.
3792{
3793 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3794 yyextra->current->commandOverrides.override_directoryGraph(false); // OFF
3796}
References FALSE.
◆ handleHideEnumValues()
|
static |
Definition at line 3735 of file commentscan.l.
3736{
3737 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3738 yyextra->current->commandOverrides.override_enumValues(false); // OFF
3740}
References FALSE.
◆ handleHideGroupgraph()
|
static |
Definition at line 3819 of file commentscan.l.
3820{
3821 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3822 yyextra->current->commandOverrides.override_groupGraph(false); // OFF
3824}
References FALSE.
◆ handleHideIncludedBygraph()
|
static |
Definition at line 3777 of file commentscan.l.
3778{
3779 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3780 yyextra->current->commandOverrides.override_includedByGraph(false); // OFF
3782}
References FALSE.
◆ handleHideIncludegraph()
|
static |
Definition at line 3770 of file commentscan.l.
3771{
3772 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3773 yyextra->current->commandOverrides.override_includeGraph(false); // OFF
3775}
References FALSE.
◆ handleHideInheritanceGraph()
|
static |
Definition at line 3865 of file commentscan.l.
3866{
3867 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3868 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::NO); // OFF
3870}
References FALSE.
◆ handleHideInitializer()
|
static |
Definition at line 3693 of file commentscan.l.
3694{
3695 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3696 yyextra->current->initLines = 0; // OFF
3698}
References FALSE.
◆ handleHideInlineSource()
|
static |
Definition at line 3749 of file commentscan.l.
3750{
3751 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3752 yyextra->current->commandOverrides.override_inlineSource(false); // OFF
3754}
References FALSE.
◆ handleHideReferencedByRelation()
|
static |
Definition at line 3879 of file commentscan.l.
3880{
3881 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3882 yyextra->current->commandOverrides.override_referencedByRelation(false); // OFF
3884}
References FALSE.
◆ handleHideReferencesRelation()
|
static |
Definition at line 3893 of file commentscan.l.
3894{
3895 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3896 yyextra->current->commandOverrides.override_referencesRelation(false); // OFF
3898}
References FALSE.
◆ handleIdlException()
|
static |
Definition at line 3004 of file commentscan.l.
3005{
3006 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3007 yyextra->currentCmd = cmd;
3008 yyextra->currentMakeEntryType = EntryType::makeExceptionDoc;
3009 BEGIN( ClassDocArg1 );
3011}
References checkStructuralIndicator().
◆ handleIf()
|
static |
Definition at line 3539 of file commentscan.l.
3540{
3541 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3542 yyextra->guardType = Guard_If;
3543 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
3544 if (yyextra->guards->empty())
3545 {
3546 yyextra->guards->emplace(true);
3547 }
3548 else
3549 {
3550 bool enabled = yyextra->guards->top().isEnabled();
3551 yyextra->guards->emplace(enabled);
3552 }
3553 BEGIN(GuardParam);
3555}
◆ handleIFile()
|
static |
Definition at line 3516 of file commentscan.l.
3517{
3518 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3519 addOutput(yyscanner,yytext);
3520 BEGIN(IFile);
3522}
References addOutput(), and FALSE.
◆ handleIfNot()
|
static |
Definition at line 3557 of file commentscan.l.
3558{
3559 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3560 yyextra->guardType = Guard_IfNot;
3561 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
3562 if (yyextra->guards->empty())
3563 {
3564 yyextra->guards->emplace(true);
3565 }
3566 else
3567 {
3568 bool enabled = yyextra->guards->top().isEnabled();
3569 yyextra->guards->emplace(enabled);
3570 }
3571 BEGIN(GuardParam);
3573}
References FALSE, and Guard_IfNot.
◆ handleILine()
|
static |
Definition at line 3508 of file commentscan.l.
3509{
3510 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3511 addOutput(yyscanner,yytext);
3512 BEGIN(ILine);
3514}
References addOutput(), and FALSE.
◆ handleImage()
|
static |
Definition at line 3330 of file commentscan.l.
3331{
3332 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3333 for (const auto &opt : optList)
3334 {
3335 QCString locOpt(opt);
3336 locOpt = locOpt.stripWhiteSpace();
3337 if (locOpt.lower().startsWith("anchor:"))
3338 {
3339 addAnchor(yyscanner,locOpt.mid(7));
3340 break; // real option handling will be done later on
3341 }
3342 }
3343 if (optList.empty())
3344 {
3346 }
3347 else
3348 {
3350 }
3351 BEGIN(Comment);
static void addAnchor(yyscan_t yyscanner, const QCString &anchor, const QCString &title="")
Definition commentscan.l:4547
3353}
References addAnchor(), addOutput(), FALSE, join(), QCString::lower(), QCString::mid(), QCString::startsWith(), and QCString::stripWhiteSpace().
◆ handleIncludedBygraph()
|
static |
Definition at line 3763 of file commentscan.l.
3764{
3765 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3766 yyextra->current->commandOverrides.override_includedByGraph(true); // ON
3768}
References FALSE.
◆ handleIncludegraph()
|
static |
Definition at line 3756 of file commentscan.l.
3757{
3758 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3759 yyextra->current->commandOverrides.override_includeGraph(true); // ON
3761}
References FALSE.
◆ handleIngroup()
|
static |
Definition at line 3671 of file commentscan.l.
3672{
3673 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3674 yyextra->inGroupParamFound=FALSE;
3675 BEGIN( InGroupParam );
3677}
References FALSE.
◆ handleInherit()
|
static |
Definition at line 4048 of file commentscan.l.
4049{
4050 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4051 BEGIN(InheritParam);
4053}
References FALSE.
◆ handleInheritanceGraph()
|
static |
Definition at line 3826 of file commentscan.l.
3827{
3828 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3829 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::YES);
3830 for (const auto &opt_ : optList)
3831 {
3834 {
3835 if (opt == "yes")
3836 {
3837 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::YES);
3838 }
3839 else if (opt == "graph")
3840 {
3841 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::GRAPH);
3842 }
3843 else if (opt == "builtin")
3844 {
3845 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::BUILTIN);
3846 }
3847 else if (opt == "text")
3848 {
3849 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::TEXT);
3850 }
3851 else if (opt == "no")
3852 {
3853 yyextra->current->commandOverrides.override_inheritanceGraph(CLASS_GRAPH_t::NO);
3854 }
3855 else
3856 {
3857 warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\inheritancegraph: '{}'",
3859 }
3860 }
3861 }
3863}
References FALSE, QCString::isEmpty(), QCString::lower(), QCString::stripWhiteSpace(), stripWhiteSpace(), and warn.
◆ handleInterface()
|
static |
Definition at line 2995 of file commentscan.l.
2996{
2997 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2998 yyextra->currentCmd = cmd;
2999 yyextra->currentMakeEntryType = EntryType::makeInterfaceDoc;
3000 BEGIN( ClassDocArg1 );
3002}
References checkStructuralIndicator().
◆ handleInternal()
|
static |
Definition at line 3908 of file commentscan.l.
3909{
3910 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3912 {
3913 // make sure some whitespace before a \internal command
3914 // is not treated as "documentation"
3915 if (yyextra->current->doc.stripWhiteSpace().isEmpty())
3916 {
3917 yyextra->current->doc.clear();
3918 }
3919 yyextra->condCount=0;
3920 BEGIN( SkipInternal );
3921 }
3922 else
3923 {
3924 // re-enabled for bug640828
3926 yyextra->inInternalDocs = TRUE;
3927 }
3929}
References addOutput(), Config_getBool, FALSE, and TRUE.
◆ handleIPrefix()
|
static |
Definition at line 3531 of file commentscan.l.
3532{
3533 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3535 BEGIN(IRaisePrefix);
3537}
References addOutput(), and FALSE.
◆ handleIRaise()
|
static |
Definition at line 3524 of file commentscan.l.
3525{
3526 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3527 BEGIN(IRaise);
3529}
References FALSE.
◆ handleLineInfo()
|
static |
Definition at line 3496 of file commentscan.l.
3497{
3498 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3499 if (!yyextra->spaceBeforeCmd.isEmpty())
3500 {
3501 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3502 yyextra->spaceBeforeCmd.clear();
3503 }
3506}
References addOutput(), and FALSE.
◆ handleMainpage()
|
static |
Definition at line 3021 of file commentscan.l.
3022{
3023 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3025 if (!stop)
3026 {
3027 yyextra->current->name = "mainpage";
3028 }
3030 BEGIN( PageDocArg2 );
3031 return stop;
3032}
References makeStructuralIndicator(), OutputDoc, and setOutput().
◆ handleMemberOf()
|
static |
Definition at line 3242 of file commentscan.l.
3243{
3244 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3245 if (!yyextra->current->relates.isEmpty())
3246 {
3247 warn(yyextra->fileName,yyextra->lineNr,
3248 "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
3249 }
3250 yyextra->current->relatesType = RelatesType::MemberOf;
3251 yyextra->currentCmd = cmd;
3252 BEGIN(RelatesParam1);
3254}
◆ handleModule()
|
static |
Definition at line 2943 of file commentscan.l.
2944{
2945 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2946 yyextra->currentCmd = cmd;
2947 yyextra->currentMakeEntryType = EntryType::makeModuleDoc;
2948 BEGIN( ModuleDocArg1 );
2950}
References checkStructuralIndicator().
◆ handleName()
|
static |
Definition at line 3122 of file commentscan.l.
3123{
3124 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3126 if (!stop)
3127 {
3128 yyextra->docGroup.clearHeader();
3129 BEGIN( NameParam );
3130 if (!yyextra->docGroup.isEmpty()) // end of previous member group
3131 {
3133 }
3134 }
3135 return stop;
3136}
References makeStructuralIndicator(), and TRUE.
◆ handleNamespace()
|
static |
Definition at line 2909 of file commentscan.l.
2910{
2911 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2912 yyextra->currentMakeEntryType = EntryType::makeNamespaceDoc;
2913 BEGIN( NameSpaceDocArg1 );
2915}
References checkStructuralIndicator().
◆ handleNoop()
|
static |
Definition at line 3115 of file commentscan.l.
3116{
3117 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3118 BEGIN( Noop );
3120}
References FALSE.
◆ handleNoSubGrouping()
|
static |
Definition at line 3679 of file commentscan.l.
3680{
3681 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3682 yyextra->current->subGrouping = FALSE;
3684}
References FALSE.
◆ handleOverload()
|
static |
Definition at line 2866 of file commentscan.l.
2867{
2868 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2869 yyextra->functionProto.clear();
2870 BEGIN(OverloadParam);
2872}
References FALSE.
◆ handlePackage()
|
static |
Definition at line 2917 of file commentscan.l.
2918{
2919 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2921 BEGIN( PackageDocArg1 );
2922 return stop;
2923}
References makeStructuralIndicator().
◆ handlePage()
|
static |
Definition at line 3013 of file commentscan.l.
3014{
3015 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3017 BEGIN( PageDocArg1 );
3018 return stop;
3019}
References makeStructuralIndicator().
◆ handleParam()
|
static |
Definition at line 3046 of file commentscan.l.
3047{
3048 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3049 // we need process param and retval arguments to escape leading underscores in case of
3050 // markdown processing, see bug775493
3052 BEGIN( ParamArg1 );
3054}
References addOutput(), and FALSE.
◆ handleParBlock()
|
static |
Definition at line 3182 of file commentscan.l.
3183{
3184 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3185 if (yyextra->insideParBlock)
3186 {
3187 warn(yyextra->fileName,yyextra->lineNr,
3188 "found \\parblock command while already in a parblock!");
3189 }
3190 if (!yyextra->spaceBeforeCmd.isEmpty())
3191 {
3192 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3193 yyextra->spaceBeforeCmd.clear();
3194 }
3196 yyextra->insideParBlock = TRUE;
3198}
References addOutput(), FALSE, TRUE, and warn.
◆ handlePrivate()
|
static |
Definition at line 3945 of file commentscan.l.
3946{
3947 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3948 yyextra->current->protection = Protection::Private;
3950}
◆ handlePrivateSection()
|
static |
Definition at line 3952 of file commentscan.l.
3953{
3954 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3955 yyextra->current->protection = yyextra->protection = Protection::Private;
3957}
◆ handleProtected()
|
static |
Definition at line 3959 of file commentscan.l.
3960{
3961 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3962 yyextra->current->protection = Protection::Protected;
3964}
◆ handleProtectedSection()
|
static |
Definition at line 3966 of file commentscan.l.
3967{
3968 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3969 yyextra->current->protection = yyextra->protection = Protection::Protected ;
3971}
◆ handleProtocol()
|
static |
Definition at line 2959 of file commentscan.l.
2960{ // Obj-C protocol
2961 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2962 yyextra->currentCmd = cmd;
2963 yyextra->currentMakeEntryType = EntryType::makeProtocolDoc;
2964 BEGIN( ClassDocArg1 );
2966}
References checkStructuralIndicator().
◆ handlePublic()
|
static |
Definition at line 3973 of file commentscan.l.
3974{
3975 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3976 yyextra->current->protection = Protection::Public;
3978}
◆ handlePublicSection()
|
static |
Definition at line 3980 of file commentscan.l.
3981{
3982 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3983 yyextra->current->protection = yyextra->protection = Protection::Public;
3985}
◆ handlePure()
|
static |
Definition at line 3938 of file commentscan.l.
3939{
3940 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3941 yyextra->current->virt = Specifier::Pure;
3943}
◆ handleQualifier()
|
static |
Definition at line 3900 of file commentscan.l.
3901{
3902 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3903 yyextra->currentCmd = cmd;
3904 BEGIN(Qualifier);
3906}
References FALSE.
◆ handleRaiseWarning()
|
static |
Definition at line 3107 of file commentscan.l.
3108{
3109 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3110 yyextra->raiseWarning = "";
3111 BEGIN( RaiseWarning );
3113}
References FALSE.
◆ handleReferencedByRelation()
|
static |
Definition at line 3872 of file commentscan.l.
3873{
3874 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3875 yyextra->current->commandOverrides.override_referencedByRelation(true); // ON
3877}
References FALSE.
◆ handleReferencesRelation()
|
static |
Definition at line 3886 of file commentscan.l.
3887{
3888 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3889 yyextra->current->commandOverrides.override_referencesRelation(true); // ON
3891}
References FALSE.
◆ handleRefItem()
|
static |
Definition at line 3256 of file commentscan.l.
3257{
3258 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3260 BEGIN(LineParam);
3262}
References addOutput(), and FALSE.
◆ handleRelated()
|
static |
Definition at line 3214 of file commentscan.l.
3215{
3216 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3217 if (!yyextra->current->relates.isEmpty())
3218 {
3219 warn(yyextra->fileName,yyextra->lineNr,
3220 "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
3221 }
3222 yyextra->current->relatesType = RelatesType::Simple;
3223 yyextra->currentCmd = cmd;
3224 BEGIN(RelatesParam1);
3226}
◆ handleRelatedAlso()
|
static |
Definition at line 3228 of file commentscan.l.
3229{
3230 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3231 if (!yyextra->current->relates.isEmpty())
3232 {
3233 warn(yyextra->fileName,yyextra->lineNr,
3234 "found multiple \\relates, \\relatesalso or \\memberof commands in a comment block, using last definition");
3235 }
3236 yyextra->current->relatesType = RelatesType::Duplicate;
3237 yyextra->currentCmd = cmd;
3238 BEGIN(RelatesParam1);
3240}
◆ handleRetval()
|
static |
Definition at line 3056 of file commentscan.l.
3057{
3058 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3060 BEGIN( ParamArg1 );
3062}
References addOutput(), and FALSE.
◆ handleSection()
|
static |
Definition at line 3264 of file commentscan.l.
3265{
3266 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3268 //printf("handleSection(%s) raiseLevel=%d\n",qPrint(s),yyextra->raiseLevel);
3269 BEGIN(SectionLabel);
3270 // determine natural section level
3277 // raise it if requested
3278 yyextra->sectionLevel = std::min(yyextra->sectionLevel + yyextra->raiseLevel,SectionType::MaxLevel);
3279 // rewrite the update section level to the output
3280 switch (yyextra->sectionLevel)
3281 {
3289 }
3291}
References addOutput(), FALSE, SectionType::MaxLevel, OutputDoc, SectionType::Paragraph, SectionType::Section, setOutput(), SectionType::Subparagraph, SectionType::Subsection, SectionType::Subsubparagraph, and SectionType::Subsubsection.
◆ handleShowEnumValues()
|
static |
Definition at line 3728 of file commentscan.l.
3729{
3730 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3731 yyextra->current->commandOverrides.override_enumValues(true); // ON
3733}
References FALSE.
◆ handleShowInitializer()
|
static |
Definition at line 3686 of file commentscan.l.
3687{
3688 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3689 yyextra->current->initLines = 100000; // ON
3691}
References FALSE.
◆ handleShowInlineSource()
|
static |
Definition at line 3742 of file commentscan.l.
3743{
3744 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3745 yyextra->current->commandOverrides.override_inlineSource(true); // ON
3747}
References FALSE.
◆ handleStatic()
|
static |
◆ handleStruct()
|
static |
Definition at line 2986 of file commentscan.l.
2987{
2988 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2989 yyextra->currentCmd = cmd;
2990 yyextra->currentMakeEntryType = EntryType::makeStructDoc;
2991 BEGIN( ClassDocArg1 );
2993}
References checkStructuralIndicator().
◆ handleSubpage()
|
static |
Definition at line 3293 of file commentscan.l.
3294{
3295 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3296 if (!yyextra->current->section.isEmpty() &&
3297 !yyextra->current->section.isPageDoc() &&
3298 !yyextra->current->section.isMainpageDoc()
3299 )
3300 {
3301 warn(yyextra->fileName,yyextra->lineNr,
3302 "found \\subpage command in a comment block that is not marked as a page!");
3303 }
3304 if (!yyextra->spaceBeforeCmd.isEmpty())
3305 {
3306 addOutput(yyscanner,yyextra->spaceBeforeCmd);
3307 yyextra->spaceBeforeCmd.clear();
3308 }
3310 BEGIN(SubpageLabel);
3312}
References addOutput(), FALSE, and warn.
◆ handleTest()
|
static |
Definition at line 3147 of file commentscan.l.
3148{
3149 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3150 yyextra->newXRefKind = XRef_Test;
3152 yyextra->xrefKind = XRef_Test;
3154}
References FALSE, OutputXRef, setOutput(), and XRef_Test.
◆ handleToc()
|
static |
Definition at line 3987 of file commentscan.l.
3988{
3989 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3990 if (yyextra->current->section.isPageDoc() ||
3991 yyextra->current->section.isMainpageDoc())
3992 {
3993 for (const auto &opt_ : optList)
3994 {
3998 if (i>0) // found ':' but not on position 0 what would mean just a level
3999 {
4000 char dum=0;
4002 {
4003 warn(yyextra->fileName,yyextra->lineNr,"Unknown option:level specified with \\tableofcontents: '{}'",
4005 opt = "";
4006 }
4007 else
4008 {
4011 }
4012 }
4014 {
4015 if (opt == "html")
4016 {
4017 yyextra->current->localToc.enableHtml(level);
4018 }
4019 else if (opt == "latex")
4020 {
4021 yyextra->current->localToc.enableLatex(level);
4022 }
4023 else if (opt == "xml")
4024 {
4025 yyextra->current->localToc.enableXml(level);
4026 }
4027 else if (opt == "docbook")
4028 {
4029 yyextra->current->localToc.enableDocbook(level);
4030 }
4031 else
4032 {
4033 warn(yyextra->fileName,yyextra->lineNr,"Unknown option specified with \\tableofcontents: '{}'",
4035 }
4036 }
4037 }
4038 if (yyextra->current->localToc.nothingEnabled())
4039 {
4040 // for backward compatibility
4041 yyextra->current->localToc.enableHtml(SectionType::MaxLevel);
4042 yyextra->current->localToc.enableXml(SectionType::MaxLevel);
4043 }
4044 }
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
4046}
References QCString::data(), FALSE, QCString::find(), QCString::isEmpty(), QCString::left(), QCString::length(), QCString::lower(), SectionType::MaxLevel, qPrint(), QCString::right(), QCString::stripWhiteSpace(), stripWhiteSpace(), and warn.
◆ handleTodo()
|
static |
Definition at line 3138 of file commentscan.l.
3139{
3140 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
3141 yyextra->newXRefKind = XRef_Todo;
3143 yyextra->xrefKind = XRef_Todo;
3145}
References FALSE, OutputXRef, setOutput(), and XRef_Todo.
◆ handleUnion()
|
static |
Definition at line 2977 of file commentscan.l.
2978{
2979 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2980 yyextra->currentCmd = cmd;
2981 yyextra->currentMakeEntryType = EntryType::makeUnionDoc;
2982 BEGIN( ClassDocArg1 );
2984}
References checkStructuralIndicator().
◆ handleWeakGroup()
|
static |
Definition at line 2900 of file commentscan.l.
2901{
2902 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
2904 yyextra->current->groupDocType = Entry::GROUPDOC_WEAK;
2905 BEGIN( GroupDocArg1 );
2906 return stop;
2907}
References Entry::GROUPDOC_WEAK, and makeStructuralIndicator().
◆ handleXRefItem()
|
static |
◆ initParser()
|
static |
Definition at line 4117 of file commentscan.l.
4118{
4119 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4120 yyextra->sectionLabel.clear();
4121 yyextra->sectionTitle.clear();
4122 yyextra->docGroup.clearHeader();
4123 yyextra->insideParBlock = FALSE;
4124}
References FALSE.
Referenced by CommentScanner::parseCommentBlock(), parseMain(), and parseMain().
◆ lineCount()
|
static |
Definition at line 4161 of file commentscan.l.
4162{
4163 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4164 for( const char* c = yytext ; *c ; ++c )
4165 yyextra->lineNr += (*c == '\n') ;
4166}
◆ makeStructuralIndicator()
|
static |
Definition at line 4135 of file commentscan.l.
4136{
4137 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4138 assert(maker!=nullptr); // detect programming error
4139 //printf("yyextra->current->section=%x\n",yyextra->current->section);
4140 if (yyextra->current->section.isDoc())
4141 {
4142 return true;
4143 }
4144 else if (maker)
4145 {
4146 yyextra->needNewEntry = true;
4147 yyextra->current->section = maker();
4148 yyextra->current->fileName = yyextra->fileName;
4149 yyextra->current->startLine = yyextra->lineNr;
4150 if (yyextra->current->docLine == -1) yyextra->current->docLine = yyextra->lineNr;
4151 return false;
4152 }
4153 else
4154 {
4155 return false;
4156 }
4157}
Referenced by handleAddToGroup(), handleDefGroup(), handleDir(), handleExample(), handleFile(), handleMainpage(), handleName(), handlePackage(), handlePage(), and handleWeakGroup().
◆ sectionLevelToType()
|
static |
Definition at line 4297 of file commentscan.l.
References SectionType::Anchor, and SectionType::MaxLevel.
Referenced by addSection().
◆ setOutput()
|
inlinestatic |
Definition at line 4395 of file commentscan.l.
4396{
4397 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4398 bool xrefAppendToPrev = yyextra->xrefAppendFlag;
4399 // determine append flag for the next item (i.e. the end of this item)
4400 yyextra->xrefAppendFlag = !yyextra->inBody &&
4402 yyextra->newXRefKind==yyextra->xrefKind && // of the same kind
4403 (yyextra->xrefKind!=XRef_Item ||
4404 yyextra->newXRefItemKey==yyextra->xrefItemKey); // with the same key if \xrefitem
4405 //printf("%d && %d && %d && (%d || %d)\n",
4406 // yyextra->inContext==OutputXRef,
4407 // ctx==OutputXRef,
4408 // yyextra->newXRefKind==yyextra->xrefKind,
4409 // yyextra->xrefKind!=XRef_Item,
4410 // yyextra->newXRefItemKey==yyextra->xrefItemKey);
4411 //printf("refKind=%d yyextra->newXRefKind=%d xrefAppendToPrev=%d yyextra->xrefAppendFlag=%d\n",
4412 // yyextra->xrefKind,yyextra->newXRefKind,xrefAppendToPrev,yyextra->xrefAppendFlag);
4413
4414 //printf("setOutput(yyscanner,yyextra->inContext=%d ctx=%d)\n",yyextra->inContext,ctx);
4416 {
4417 // See if we can append this new xref item to the previous one.
4418 // We know this at the start of the next item of the same
4419 // type and need to remember this until the end of that item.
4420 switch(yyextra->xrefKind)
4421 {
4424 theTranslator->trTodo(),
4425 theTranslator->trTodoList(),
4426 xrefAppendToPrev
4427 );
4428 break;
4431 theTranslator->trTest(),
4432 theTranslator->trTestList(),
4433 xrefAppendToPrev
4434 );
4435 break;
4438 theTranslator->trBug(),
4439 theTranslator->trBugList(),
4440 xrefAppendToPrev
4441 );
4442 break;
4445 theTranslator->trDeprecated(),
4446 theTranslator->trDeprecatedList(),
4447 xrefAppendToPrev
4448 );
4449 break;
4451 addXRefItem(yyscanner,yyextra->xrefItemKey,
4452 yyextra->xrefItemTitle,
4453 yyextra->xrefListTitle,
4454 xrefAppendToPrev
4455 );
4456 break;
4458 ASSERT(0);
4459 break;
4460 }
4461 }
4462 yyextra->xrefItemKey = yyextra->newXRefItemKey;
static void addXRefItem(yyscan_t yyscanner, const QCString &listName, const QCString &itemTitle, const QCString &listTitle, bool append)
Definition commentscan.l:4184
4463
4464 int oldContext = yyextra->inContext;
4465 yyextra->inContext = ctx;
4467 switch(yyextra->inContext)
4468 {
4470 if (oldContext!=yyextra->inContext)
4471 {
4472 stripTrailingWhiteSpace(yyextra->current->doc);
4473 if (yyextra->current->doc.isEmpty()) yyextra->current->docLine = yyextra->lineNr;
4474 if (yyextra->current->docFile.isEmpty())
4475 {
4476 yyextra->current->docFile = yyextra->fileName;
4477 yyextra->current->docLine = yyextra->lineNr;
4478 }
4479 }
4480 yyextra->pOutputString = &yyextra->current->doc;
4481 break;
4483 {
4484 if (oldContext!=yyextra->inContext)
4485 {
4486 if (yyextra->current->brief.isEmpty()) yyextra->current->briefLine = yyextra->lineNr;
4487 if (yyextra->current->briefFile.isEmpty())
4488 {
4489 yyextra->current->briefFile = yyextra->fileName;
4490 yyextra->current->briefLine = yyextra->lineNr;
4491 }
4492 }
4493 bool foundMatch = false;
4494 if (yyextra->current->brief.stripWhiteSpace().isEmpty()) // we only want one brief
4495 // description even if multiple
4496 // are given...
4497 {
4498 foundMatch = true;
4499 }
4500 else
4501 {
4502 std::string str = yyextra->current->brief.str();
4505 {
4506 size_t cnt = 0;
4508 {
4509 if (match[2].str()[i] == '\n') cnt++;
4510 }
4511 if (cnt>0)
4512 {
4513 yyextra->current->brief = yyextra->current->brief.left(yyextra->current->brief.length()-cnt);
4514 // set warning line correct
4515 yyextra->current->brief += " \\iline " + QCString().setNum(cnt + static_cast<int>(std::stoul(match[1].str()))) + " \\ilinebr ";
4516 }
4517 foundMatch = true;
4518 }
4519 }
4520 if (foundMatch)
4521 {
4522 yyextra->pOutputString = &yyextra->current->brief;
4523 }
4524 else
4525 {
4526 if (!yyextra->current->doc.isEmpty()) // when appending parts add a new line
4527 {
4528 yyextra->current->doc += "\n";
4529 }
4530 yyextra->pOutputString = &yyextra->current->doc;
4532 }
4533 }
4534 break;
4536 yyextra->pOutputString = &yyextra->outputXRef;
4537 // first item found, so can't append to previous
4538 //yyextra->xrefAppendFlag = FALSE;
4539 break;
4541 yyextra->pOutputString = &yyextra->current->inbodyDocs;
4542 break;
4543 }
static void stripTrailingWhiteSpace(QCString &s)
Definition commentscan.l:4367
4544}
References addXRefItem(), ASSERT, reg::match(), nonBrief_re, OutputBrief, OutputDoc, OutputInbody, OutputXRef, QCString::setNum(), stripTrailingWhiteSpace(), theTranslator, 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(), and CommentScanner::parseCommentBlock().
◆ stateToString()
|
static |
◆ stripQuotes()
|
static |
Definition at line 4170 of file commentscan.l.
4171{
4172 QCString name;
4173 if (s==nullptr || *s==0) return name;
4174 name=s;
4176 {
4178 }
4179 return name;
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:226
4180}
References QCString::at(), QCString::length(), and QCString::mid().
◆ stripTrailingWhiteSpace()
|
static |
Definition at line 4367 of file commentscan.l.
4368{
4370 int i = (int)len-1;
4371 while (i>=0)
4372 {
4374 if (c==' ' || c=='\t' || c=='\r') // normal whitespace
4375 {
4376 i--;
4377 }
4378 else if (c=='r' && i>=7 && qstrncmp("\\ilinebr",s.data()+i-7,8)==0) // special line break marker
4379 {
4380 i-=8;
4381 }
4382 else // non-whitespace
4383 {
4384 break;
4385 }
4386 }
4387 //printf("stripTrailingWhitespace(%s) i=%d len=%d\n",qPrint(s),i,len);
4388 if (i!=(int)len-1)
4389 {
4391 }
4392}
References QCString::at(), QCString::data(), QCString::length(), qstrncmp(), and QCString::resize().
Referenced by setOutput().
◆ yylex()
| int yylex | ( | yyscan_t | yyscanner | ) |
Definition at line 696 of file commentscan.l.
715 {CMD}{CMD}[a-z_A-Z]+{B}* { // escaped command
716 addOutput(yyscanner,yytext);
717 }
718<Comment>{CMD}{CMD}"~"[a-z_A-Z]* { // escaped command
719 addOutput(yyscanner,yytext);
720 }
721<Comment>{MAILADDR} { // mail address
722 addOutput(yyscanner,yytext);
723 }
724<Comment>"\""[^"\n]*"\"" { // quoted text
725 addOutput(yyscanner,yytext);
726 }
727<Comment>("\\"[a-z_A-Z]+)+"\\" { // directory (or chain of commands!)
728 addOutput(yyscanner,yytext);
729 }
730<Comment>"<"{DETAILEDHTML}{ATTR}">" { // HTML command that ends a brief description
731 QCString htmlOpenTag(yytext);
732 int spacePos = htmlOpenTag.find(' '); // check for optional attributes
733 if (spacePos==-1) spacePos=yyleng-1;
735 //printf("found open tag '%s'\n",qPrint(htmlTagName));
736 yyextra->htmlContextStack.emplace_back(htmlTagName,yyextra->inContext);
738 {
740 }
741 // continue with the same input
742 REJECT;
743 }
744<Comment>"</"{DETAILEDHTML}">" { // HTML command that ends a brief description
745 QCString htmlCloseTag(yytext);
747 //printf("found close tag '%s'\n",qPrint(htmlTagName));
748 if (!yyextra->htmlContextStack.empty() &&
749 yyextra->htmlContextStack.back().tagName==htmlTagName)
750 {
752 {
753 //printf("switching back to OutputDoc\n");
755 }
756 yyextra->htmlContextStack.pop_back();
757 }
758 REJECT;
759 }
760<Comment>"<"{DETAILEDHTMLOPT}">" { // HTML <code> command that ends a brief description
761 // without attributes
763 {
764 yyextra->CScode=true;
767 }
768 else
769 {
770 // continue with the same input
771 REJECT;
772 }
773 }
774<Comment>"<"{DETAILEDHTMLOPTEND}">" { // HTML command that ends a brief description
775 if (yyextra->CScode)
776 {
778 yyextra->CScode=false;
779 }
780 else
781 {
782 yyextra->CScode=false;
783 // continue with the same input
784 REJECT;
785 }
786 }
787<Comment>"<"{DETAILEDHTMLOPT}{ATTR}">" { // HTML <code> command that ends a brief description
788 // with attributes, so cannot be CS.
790 {
792 }
793 // continue with the same input
794 REJECT;
795 }
796<Comment>"<"{DETAILS}{ATTR}">" { // start of a HTML style details description
797 yyextra->htmlDetailsStack.push_back(0);
798 yyextra->htmlContextStack.emplace_back("details",yyextra->inContext);
800 {
802 }
803 addOutput(yyscanner,yytext);
804 }
805<Comment>"</"{DETAILS}">" { // end of a HTML style details description
806 if (!yyextra->htmlDetailsStack.empty())
807 {
808 yyextra->htmlDetailsStack.pop_back();
809 }
810 if (!yyextra->htmlContextStack.empty() &&
811 yyextra->htmlContextStack.back().tagName=="details")
812 {
814 {
815 //printf("switching back to OutputDoc\n");
817 }
818 yyextra->htmlContextStack.pop_back();
819 }
820 addOutput(yyscanner,yytext);
821 }
822<Comment>"<"{AHTML} { // potential start of HTML anchor, see issue 9200
823 yyextra->htmlAnchorStr = yytext;
824 yyextra->htmlAnchor = false;
825 BEGIN(HtmlA);
826 }
827<HtmlA>{ANCHTML} { // only labels that can be converted to doxygen anchor
828 yyextra->htmlAnchorStr += yytext;
829 QCString tag(yytext);
830 int s=tag.find("=");
831 char c=tag[s+1];
832 QCString id;
833 if (c=='\'' || c=='"') // valid start
834 {
835 int e=tag.find(c,s+2);
836 if (e!=-1) // found matching end
837 {
838 id=tag.mid(s+2,e-s-2); // extract id
840 }
841 }
842 else
843 {
844 id=tag.mid(s+1);
846 }
847 if (!id.isEmpty() && !yyextra->htmlAnchor)
848 {
849 // only use first analogous to what is in docparser
853 yyextra->htmlAnchor = true;
854 }
855 }
856<HtmlA>("\""[^\n\"]*"\""|"'"[^\n']*"'") {
857 yyextra->htmlAnchorStr += yytext;
858 }
859<HtmlA>">"|"/>" {
860 if (!yyextra->htmlAnchor)
861 {
862 addOutput(yyscanner,yyextra->htmlAnchorStr);
863 addOutput(yyscanner,yytext);
864 }
865 else
866 {
867 if (yyleng == 1) // to keep <a></a> pairs, otherwise single </a> present
868 {
870 }
871 }
872 BEGIN(Comment);
873 }
874<HtmlA>{DOCNL} { // newline
875 yyextra->htmlAnchorStr += yytext;
876 if (*yytext == '\n') yyextra->lineNr++;
877 }
878<HtmlA>. { // catch-all for anything else
879 yyextra->htmlAnchorStr += yytext;
880 }
881<Comment>"<"{SUMMARY}">" { // start of a .NET XML style brief description
882 if (yyextra->htmlDetailsStack.empty())
883 {
885 }
886 else // HTML5 style <summary> as part of <details> section.
887 {
888 addOutput(yyscanner,yytext);
889 }
890 }
891<Comment>"<"{REMARKS}">" { // start of a .NET XML style detailed description
893 addOutput(yyscanner,yytext);
894 }
895<Comment>"</"{SUMMARY}">" { // start of a .NET XML style detailed description
896 if (!yyextra->htmlDetailsStack.empty())
897 {
898 addOutput(yyscanner,yytext);
899 }
900 else
901 {
903 }
904 }
905<Comment>"</"{REMARKS}">" { // end of a brief or detailed description
907 addOutput(yyscanner,yytext);
908 }
909<Comment>"<"{CAPTION}{ATTR}">" {
910 QCString tag(yytext);
911 int s=tag.find("id=");
912 if (s!=-1) // command has id attribute
913 {
914 char c=tag[s+3];
915 if (c=='\'' || c=='"') // valid start
916 {
917 int e=tag.find(c,s+4);
918 if (e!=-1) // found matching end
919 {
922 }
923 }
924 }
925 addOutput(yyscanner,yytext);
926 }
927<Comment>"<"{PRE}{ATTR}">" {
928 yyextra->insidePre=TRUE;
929 addOutput(yyscanner,yytext);
930 }
931<Comment>"</"{PRE}">" {
932 yyextra->insidePre=FALSE;
933 addOutput(yyscanner,yytext);
934 }
935<Comment>{RCSTAG} { // RCS tag which end a brief description
937 REJECT;
938 }
939<Comment>"<!--" {
940 BEGIN(HtmlComment);
941 }
942<Comment>"<!\[CDATA\[" {
943 BEGIN(CdataSection);
944 }
945<Comment>{B}*{CMD}"endinternal"{B}* {
947 if (!yyextra->inInternalDocs)
948 warn(yyextra->fileName,yyextra->lineNr,
949 "found \\endinternal without matching \\internal"
950 );
951 yyextra->inInternalDocs = FALSE;
952 }
953<Comment>{B}*"\\ilinebr "{B}* { // preserve spacing around \\ilinebr
954 addOutput(yyscanner,yytext);
955 }
956<Comment>(\n|"\\ilinebr ")/({B}*(\n|{IFILELINE}?"\\ilinebr "))+ { // at least one blank line (or blank line command)
958 {
959 endBrief(yyscanner);
960 }
961 else
962 {
963 REJECT;
964 }
965 }
966<Comment>{B}*{CMD}[a-z_A-Z]+"{"[^}]*"}"{B}* |
967<Comment>{B}*{CMD}[a-z_A-Z]+{B}* { // potentially interesting command
968 // the {B}* in the front was added for bug620924
971 /* handle `f{` command as special case */
972 if ((idx > 1) && (yytext[idx-1] == 'f') && (yytext[idx-2] == '\\' || yytext[idx-2] =='@')) REJECT;
974 QCString cmdName;
975 StringVector optList;
976 if (idx == -1) // no options
977 {
979 }
980 else // options present
981 {
985 }
987 //printf("lookup command '%s' found=%d\n",qPrint(cmdName),it!=docCmdMap.end());
989 {
990 int i=0;
991 while (yytext[i]==' ' || yytext[i]=='\t') i++;
993 CommandSpacing spacing = it->second.spacing;
996 {
997 yyextra->briefEndsAtDot=FALSE;
999 // this command forces the end of brief description
1001 }
1002 //if (i>0) addOutput(yyscanner,QCString(yytext).left(i)); // removed for bug 689341
1003 if (it->second.handler && it->second.handler(yyscanner, cmdName, optList))
1004 {
1005 // implicit split of the comment block into two
1006 // entries. Restart the next block at the start
1007 // of this command.
1008 yyextra->parseMore=TRUE;
StringVector split(const std::string &s, const std::string &delimiter)
split input string s by string delimiter delimiter.
Definition util.cpp:7042
1009
1010 yyextra->inputPosition=yyextra->prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf);
1011 yyterminate();
1012 }
1013 else if (it->second.handler==nullptr)
1014 {
1015 // command without handler, to be processed
1016 // later by parsedoc.cpp
1017 addOutput(yyscanner,yytext);
1018 }
1019 }
1020 else // command not relevant
1021 {
1022 addOutput(yyscanner,yytext);
1023 }
1024 }
1025<Comment>{B}*({CMD}{CMD})"f"[$\[{] { // escaped formula command
1026 addOutput(yyscanner,yytext);
1027 }
1028<Comment>{B}*{CMD}"~"[a-z_A-Z-]* { // language switch command
1032 { // enable language specific section
1034 {
1035 warn(yyextra->fileName,yyextra->lineNr,
1037 }
1038 BEGIN(SkipLang);
1039 }
1040 }
1041<Comment>{B}*{CMD}"f{"[^}\n]+"}"("{"?) { // start of a formula with custom environment
1043 yyextra->formulaText="";
1044 yyextra->formulaPreText="\\begin";
1045 yyextra->formulaPostText="";
1047 if (yyextra->formulaEnv.at(yyextra->formulaEnv.length()-1)=='{')
1048 {
1049 // remove trailing open brace
1050 yyextra->formulaEnv=yyextra->formulaEnv.left(yyextra->formulaEnv.length()-1);
1051 }
1052 yyextra->formulaPreText+=yyextra->formulaEnv;
1053 yyextra->formulaNewLines=0;
1054 BEGIN(ReadFormulaLong);
1055 }
1056<Comment>{B}*{CMD}"f$" { // start of a inline formula
1057 yyextra->formulaText="";
1058 yyextra->formulaPreText="$";
1059 yyextra->formulaPostText="";
1060 yyextra->formulaNewLines=0;
1061 BEGIN(ReadFormulaShort);
1062 }
1063<Comment>{B}*{CMD}"f(" { // start of a inline formula
1064 yyextra->formulaText="";
1065 yyextra->formulaPreText="";
1066 yyextra->formulaPostText="";
1067 yyextra->formulaNewLines=0;
1068 BEGIN(ReadFormulaRound);
1069 }
1070<Comment>{B}*{CMD}"f[" { // start of a block formula
1072 yyextra->formulaText="";
1073 yyextra->formulaPreText="\\[";
1074 yyextra->formulaPostText="";
1075 yyextra->formulaNewLines=0;
1076 BEGIN(ReadFormulaLong);
1077 }
1078<Comment>{B}*{CMD}"{" { // begin of a group
1079 //yyextra->langParser->handleGroupStartCommand(yyextra->memberGroupHeader);
1080 yyextra->docGroup.open(yyextra->current,yyextra->fileName,yyextra->lineNr);
1081 }
1082<Comment>{B}*{CMD}"}" { // end of a group
1083 //yyextra->langParser->handleGroupEndCommand();
1084 yyextra->docGroup.close(yyextra->current,yyextra->fileName,yyextra->lineNr,TRUE);
1085 yyextra->docGroup.clearHeader();
1086 yyextra->parseMore=TRUE;
1087 yyextra->needNewEntry = TRUE;
1088 yyextra->inputPosition=yyextra->prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) + (int)strlen(yytext);
1089 yyterminate();
1090 }
1091<Comment>{B}*{CMD}[$@\\&~<>#%] { // escaped character
1092 addOutput(yyscanner,yytext);
1093 }
1094<Comment>[a-z_A-Z]+ { // normal word
1095 addOutput(yyscanner,yytext);
1096 }
1097<Comment>^{B}*"."{Bopt}/\n { // explicit end autolist: e.g " ."
1098 addOutput(yyscanner,yytext);
1099 }
1100<Comment>^{B}*[1-9][0-9]*"."{B}+ |
1101<Comment>^{B}*[*+]{B}+ { // start of autolist
1102 if (!yyextra->markdownSupport)
1103 {
1104 REJECT;
1105 }
1106 else
1107 {
1109 {
1110 yyextra->briefEndsAtDot=FALSE;
1112 }
1113 addOutput(yyscanner,yytext);
1114 }
1115 }
1116<Comment>^{B}*"-"{B}+ { // start of autolist
1118 {
1119 yyextra->briefEndsAtDot=FALSE;
1121 }
1122 addOutput(yyscanner,yytext);
1123 }
1124<Comment>^{B}*([\-:|]{B}*)*("--"|"---")({B}*[\-:|])*{Bopt}/\n { // horizontal line (dashed)
1125 addOutput(yyscanner,yytext);
1126 }
1127<Comment>{CMD}"---" { // escaped mdash
1128 addOutput(yyscanner,yytext);
1129 }
1130<Comment>{CMD}"--" { // escaped mdash
1131 addOutput(yyscanner,yytext);
1132 }
1133<Comment>"---" { // mdash
1135 }
1136<Comment>"--" { // ndash
1138 }
1139<Comment>"-#"{B}+ { // numbered item
1141 {
1142 yyextra->briefEndsAtDot=FALSE;
1144 }
1145 addOutput(yyscanner,yytext);
1146 }
1147<Comment>[?!][a-z_A-Z0-9\(\)=<] |
1148<Comment>("."+)[a-z_A-Z0-9\)] { // . at start or in the middle of a word, or ellipsis
1149 // ? or ! in middle of word or followed by equal sign or round bracket.
1150 addOutput(yyscanner,yytext);
1151 }
1152<Comment>{CMD}[\.?!] { // we have to be a bit careful with the special commands
1153 // \. \? and \! as they might otherwise terminate a brief description
1154 addOutput(yyscanner,yytext);
1155 }
1156<Comment>".\\"[ \t] { // . with escaped space.
1157 addOutput(yyscanner,yytext[0]);
1158 addOutput(yyscanner,yytext[2]);
1159 }
1160<Comment>"."[,:;] { // . with some puntuations such as "e.g.," or "e.g.:"
1161 addOutput(yyscanner,yytext);
1162 }
1163<Comment>"...\\"[ \t] { // ellipsis with escaped space.
1165 }
1166<Comment>"..."/[^\.] { // ellipsis
1168 }
1169<Comment>".."[\.]?/[^ \t\n] { // internal ellipsis
1170 addOutput(yyscanner,yytext);
1171 }
1172<Comment>(\n|"\\ilinebr ")({B}*(\n|"\\ilinebr "))+ { // at least one blank line (or blank line command)
1174 {
1175 // see bug 613024, we need to put the newlines after ending the XRef section.
1177 yy_size_t i;
1178 for (i=0;i<(yy_size_t)yyleng;)
1179 {
1182 else i++;
1183 }
1184 }
1186 {
1187 yy_size_t i;
1188 for (i=0;i<(yy_size_t)yyleng;)
1189 {
1192 else i++;
1193 }
1195 }
1196 else // yyextra->inContext==OutputBrief
1197 { // only go to the detailed description if we have
1198 // found some brief description and not just whitespace
1199 endBrief(yyscanner);
1200 }
1201 lineCount(yyscanner);
1202 }
1203<Comment>"."[?!] |
1204<Comment>[\.?!] { // potential end of a JavaDoc style comment
1205 addOutput(yyscanner,yytext);
1206 if (yyextra->briefEndsAtDot)
1207 {
1209 yyextra->briefEndsAtDot=FALSE;
1210 }
1211 }
1212<Comment>{DOCNL} { // newline
1213 addOutput(yyscanner,yytext);
1214 if (*yytext == '\n') yyextra->lineNr++;
1215 }
1216<Comment>. { // catch-all for anything else
1217 addOutput(yyscanner,*yytext);
1218 }
1219
1220
1221 /* -------------- Rules for handling HTML comments ----------- */
1222
1223<HtmlComment>"---"[!]?">"{B}* {
1224 warn(yyextra->fileName,yyextra->lineNr,
1225 "incorrect HTML end comment --->"
1226 );
1227 }
1228<HtmlComment>"--"[!]?">"{B}* { BEGIN( Comment ); }
1229<HtmlComment>{DOCNL} {
1230 if (*yytext=='\n')
1231 {
1232 yyextra->lineNr++;
1234 }
1235 }
1236<HtmlComment>[^\\\n\-]+ { // ignore unimportant characters
1237 }
1238<HtmlComment>. { // ignore every else
1239 }
1240
1241<CdataSection>"\]\]>" {
1242 BEGIN( Comment );
1243 }
1244<CdataSection>{DOCNL} {
1246 if (*yytext=='\n') yyextra->lineNr++;
1247 }
1248<CdataSection>[<>&] { // the special XML characters for iwhich the CDATA section is especially used
1250 addOutput(yyscanner,*yytext);
1251 }
1252<CdataSection>[^\\\n\]<>&]+ {
1253 addOutput(yyscanner,yytext);
1254 }
1255<CdataSection>. {
1256 addOutput(yyscanner,*yytext);
1257 }
1258
1259 /* -------------- Rules for handling formulas ---------------- */
1260
1261<ReadFormulaShort,ReadFormulaShortSection>{CMD}"f$" { // end of inline formula
1262 yyextra->formulaPostText+="$";
1265 if (YY_START == ReadFormulaShort)
1266 {
1267 BEGIN(Comment);
1268 }
1269 else
1270 {
1271 yyextra->sectionTitle+= " "+form;
1272 BEGIN(SectionTitle);
1273 }
1274 }
1275<ReadFormulaRound,ReadFormulaRoundSection>{CMD}"f)" { // end of inline formula
1278 if (YY_START == ReadFormulaRound)
1279 {
1280 BEGIN(Comment);
1281 }
1282 else
1283 {
1284 yyextra->sectionTitle+= " "+form;
1285 BEGIN(SectionTitle);
1286 }
1287 }
1288<ReadFormulaLong>{CMD}"f]" { // end of block formula
1289 yyextra->formulaPostText+="\\]";
1291 BEGIN(Comment);
1292 }
1293<ReadFormulaLong>{CMD}"f}" { // end of custom env formula
1294 yyextra->formulaPostText+="\\end";
1295 yyextra->formulaPostText+=yyextra->formulaEnv;
1297 BEGIN(Comment);
1298 }
1299<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>[^\\@\n]+ { // any non-special character
1300 yyextra->formulaText+=yytext;
1301 }
1302<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>\n { // new line
1303 yyextra->formulaNewLines++;
1304 yyextra->formulaText+=*yytext;
1305 yyextra->lineNr++;
1306 addIline(yyscanner,yyextra->lineNr);
1307 }
1308<ReadFormulaLong,ReadFormulaShort,ReadFormulaShortSection,ReadFormulaRound,ReadFormulaRoundSection>. { // any other character
1309 yyextra->formulaText+=*yytext;
1310 }
1311
1312 /* ------------ handle argument of enum command --------------- */
1313
1314<EnumDocArg1>{SCOPEID} { // handle argument
1315 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1316 yyextra->current->name = yytext;
1317 BEGIN( Comment );
1318 }
1319<EnumDocArg1>{LC} { // line continuation
1320 yyextra->lineNr++;
1322 }
1323<EnumDocArg1>{DOCNL} { // missing argument
1324 warn(yyextra->fileName,yyextra->lineNr,
1325 "missing argument after '\\enum'."
1326 );
1327 unput_string(yytext,yyleng);
1328 BEGIN( Comment );
1329 }
1330<EnumDocArg1>. { // ignore other stuff
1331 }
1332
1333 /* ------------ handle argument of namespace command --------------- */
1334
1335<NameSpaceDocArg1>{SCOPENAME} { // handle argument
1336 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1337 lineCount(yyscanner);
1338 yyextra->current->name = substitute(removeRedundantWhiteSpace(QCString(yytext)),QCString("."),QCString("::"));
1339 BEGIN( Comment );
1340 }
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:477
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:578
1341<NameSpaceDocArg1>{LC} { // line continuation
1342 yyextra->lineNr++;
1344 }
1345<NameSpaceDocArg1>{DOCNL} { // missing argument
1346 warn(yyextra->fileName,yyextra->lineNr,
1347 "missing argument after '\\namespace'."
1348 );
1349 unput_string(yytext,yyleng);
1350 BEGIN( Comment );
1351 }
1352<NameSpaceDocArg1>. { // ignore other stuff
1353 }
1354
1355 /* ------------ handle argument of package command --------------- */
1356
1357<PackageDocArg1>{ID}("."{ID})* { // handle argument
1358 yyextra->current->name = yytext;
1359 BEGIN( Comment );
1360 }
1361<PackageDocArg1>{LC} { // line continuation
1362 yyextra->lineNr++;
1364 }
1365<PackageDocArg1>{DOCNL} { // missing argument
1366 warn(yyextra->fileName,yyextra->lineNr,
1367 "missing argument after \\package."
1368 );
1369 unput_string(yytext,yyleng);
1370 //addOutput(yyscanner,'\n');
1371 //if (*yytext=='\n') yyextra->lineNr++;
1372 BEGIN( Comment );
1373 }
1374<PackageDocArg1>. { // ignore other stuff
1375 }
1376
1377 /* ------------ handle argument of concept command --------------- */
1378
1379<ConceptDocArg1>{SCOPEID} { // handle argument
1380 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1381 yyextra->current->name = yytext;
1382 BEGIN( Comment );
1383 }
1384<ConceptDocArg1>{LC} { // line continuation
1385 yyextra->lineNr++;
1387 }
1388<ConceptDocArg1>{DOCNL} { // missing argument
1389 warn(yyextra->fileName,yyextra->lineNr,
1390 "missing argument after '\\concept'."
1391 );
1392 unput_string(yytext,yyleng);
1393 BEGIN( Comment );
1394 }
1395<ConceptDocArg1>. { // ignore other stuff
1396 }
1397
1398 /* ------------ handle argument of module command --------------- */
1399<ModuleDocArg1>{MODULE_ID} { // handle argument
1400 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1401 yyextra->current->name = yytext;
1402 BEGIN( Comment );
1403 }
1404<ModuleDocArg1>{LC} { // line continuation
1405 yyextra->lineNr++;
1407 }
1408<ModuleDocArg1>{DOCNL} { // missing argument
1409 warn(yyextra->fileName,yyextra->lineNr,
1410 "missing argument after '\\module'."
1411 );
1412 unput_string(yytext,yyleng);
1413 BEGIN( Comment );
1414 }
1415<ModuleDocArg1>. { // ignore other stuff
1416 }
1417
1418 /* ------ handle argument of class/struct/union command --------------- */
1419
1420<ClassDocArg1>{SCOPENAME}{TMPLSPEC} {
1421 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1422 lineCount(yyscanner);
1424 BEGIN( ClassDocArg2 );
1425 }
1426<ClassDocArg1>{SCOPENAME} { // first argument
1427 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1428 lineCount(yyscanner);
1430 if (yyextra->current->section.isProtocolDoc())
1431 {
1432 yyextra->current->name+="-p";
1433 }
1434 // prepend outer scope name
1435 BEGIN( ClassDocArg2 );
1436 }
1437<CategoryDocArg1>{SCOPENAME}{B}*"("[^\)]+")" {
1438 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
1439 lineCount(yyscanner);
1441 BEGIN( ClassDocArg2 );
1442 }
1443<ClassDocArg1,CategoryDocArg1>{LC} { // line continuation
1444 yyextra->lineNr++;
1446 }
1447<ClassDocArg1,CategoryDocArg1>{DOCNL} {
1448 warn(yyextra->fileName,yyextra->lineNr,
1449 "missing argument after '\\{}'.",yyextra->currentCmd
1450 );
1451 unput_string(yytext,yyleng);
1452 BEGIN( Comment );
1453 }
1454<ClassDocArg1,CategoryDocArg1>. { // ignore other stuff
1455 }
1456
1457<ClassDocArg2>{DOCNL} {
1458 unput_string(yytext,yyleng);
1459 BEGIN( Comment );
1460 }
1461<ClassDocArg2>{FILE}|"<>" { // second argument; include file
1462 yyextra->current->includeFile = yytext;
1463 BEGIN( ClassDocArg3 );
1464 }
1465<ClassDocArg2>{LC} { // line continuation
1466 yyextra->lineNr++;
1468 }
1469<ClassDocArg2>. { // ignore other stuff
1470 }
1471
1472<ClassDocArg3>[<"]?{FILE}?[">]? { // third argument; include file name
1473 yyextra->current->includeName = yytext;
1474 BEGIN( Comment );
1475 }
1476<ClassDocArg3>{LC} { // line continuation
1477 yyextra->lineNr++;
1479 }
1480<ClassDocArg3>{DOCNL} {
1481 //if (*yytext=='\n') yyextra->lineNr++;
1482 unput_string(yytext,yyleng);
1483 BEGIN( Comment );
1484 }
1485<ClassDocArg3>. { // ignore other stuff
1486 }
1487
1488 /* --------- handle arguments of {def,add,weak}group commands --------- */
1489
1490<GroupDocArg1>{LABELID}(".html"?) { // group name
1491 yyextra->current->name = yytext;
1492 //lastDefGroup.groupname = yytext;
1493 //lastDefGroup.pri = yyextra->current->groupingPri();
1494 // the .html stuff is for Qt compatibility
1495 if (yyextra->current->name.endsWith(".html"))
1496 {
1497 yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-5);
1498 }
1499 yyextra->current->type.clear();
1500 BEGIN(GroupDocArg2);
1501 }
1502<GroupDocArg1>"\\"{B}*"\n" { // line continuation
1503 yyextra->lineNr++;
1505 }
1506<GroupDocArg1>{DOCNL} { // missing argument!
1507 warn(yyextra->fileName,yyextra->lineNr,
1508 "missing group name after {}",
1509 yyextra->current->groupDocCmd()
1510 );
1511 //addOutput(yyscanner,'\n');
1512 //if (*yytext=='\n') yyextra->lineNr++;
1513 unput_string(yytext,yyleng);
1514 BEGIN( Comment );
1515 }
1516<GroupDocArg1>. { // ignore other stuff
1517 }
1518<GroupDocArg2>"\\"{B}*"\n" { // line continuation
1519 yyextra->lineNr++;
1521 }
1522<GroupDocArg2>[^\n\\]+ { // title (stored in type)
1523 yyextra->current->type += yytext;
1524 yyextra->current->type = yyextra->current->type.stripWhiteSpace();
1525 }
1526<GroupDocArg2>{DOCNL}+ {
1528 yyextra->current->type.isEmpty()
1529 ) // defgroup requires second argument
1530 {
1531 warn(yyextra->fileName,yyextra->lineNr,
1532 "missing title after "
1533 "\\defgroup {}", yyextra->current->name
1534 );
1535 }
1536 unput_string(yytext,yyleng);
1537 int extraLineNr = 0;
1539 {
1540 for (int i = 0; i < yyleng; i++)
1541 {
1542 if (yytext[i]=='\n') extraLineNr++;
1543 }
1544 }
1545 //if (*yytext=='\n') yyextra->lineNr++;
1546 //addOutput(yyscanner,'\n');
1548 {
1550 addOutput(yyscanner,"\" \\iline " + QCString().setNum(yyextra->lineNr + extraLineNr) + " \\ilinebr ");
1551 }
1552 BEGIN( Comment );
1553 }
1554<GroupDocArg2>. { // title (stored in type)
1555 yyextra->current->type += yytext;
1556 yyextra->current->type = yyextra->current->type.stripWhiteSpace();
1557 }
1558
1559 /* --------- handle arguments of page/mainpage command ------------------- */
1560
1561<PageDocArg1>[^\n]*"\\ilinebr @ianchor"\{[^\]\n]*\}{B}{FILE} { // special case where the Markdown processor has rewritten
1562 // "@page label Title" as
1563 // "@page md_label Title\ilinebr @ianchor{Title} label"
1564 QCString text = yytext;
1569 if (istart != -1)
1570 {
1573 yyextra->current->name = yyextra->current->name.mid(0,istart);
1574 }
1576 //printf("name='%s' title='%s'\n",qPrint(yyextra->current->name),qPrint(yyextra->current->args));
1577 BEGIN( PageDocArg2 );
1578 }
1579<PageDocArg1>{FILE} { // first argument; page name
1580 yyextra->current->name = stripQuotes(yytext);
1581 yyextra->current->args = "";
1582 BEGIN( PageDocArg2 );
1583 }
1584<PageDocArg1>{LC} { yyextra->lineNr++;
1586 }
1587<PageDocArg1>{DOCNL} {
1588 warn(yyextra->fileName,yyextra->lineNr,
1589 "missing argument after \\page."
1590 );
1591 unput_string(yytext,yyleng);
1592 //if (*yytext=='\n') yyextra->lineNr++;
1593 //addOutput(yyscanner,'\n');
1594 BEGIN( Comment );
1595 }
1596<PageDocArg1>. { // ignore other stuff
1597 }
1598<PageDocArg2>{DOCNL} { // second argument; page title
1599 unput_string(yytext,yyleng);
1600 //if (*yytext=='\n') yyextra->lineNr++;
1601 //addOutput(yyscanner,'\n');
1604 BEGIN( Comment );
1605 }
1606<PageDocArg2>{CMD}[<>] {
1607 // bug 748927
1608 QCString tmp(yytext);
1611 yyextra->current->args += tmp;
1612 }
1613<PageDocArg2>. {
1614 yyextra->current->args += yytext;
1615 }
1616 /* --------- handle arguments of the param command ------------ */
1617<ParamArg1>{ID}/{B}*"," {
1618 addOutput(yyscanner,yytext);
1619 }
1620<ParamArg1>"," {
1622 }
1623<ParamArg1>{DOCNL} {
1624 if (*yytext=='\n') yyextra->lineNr++;
1626 }
1627<ParamArg1>{ID} {
1628 addOutput(yyscanner,yytext);
1629 BEGIN( Comment );
1630 }
1631<ParamArg1>. {
1632 unput(yytext[0]);
1633 BEGIN( Comment );
1634 }
1635
1636 /* --------- handle arguments of the file/dir/example command ------------ */
1637
1638<FileDocArg1>{DOCNL} { // no file name specified
1639 unput_string(yytext,yyleng);
1640 //if (*yytext=='\n') yyextra->lineNr++;
1641 //addOutput(yyscanner,'\n');
1642 BEGIN( Comment );
1643 }
1644<FileDocArg1>{FILE} { // first argument; name
1645 yyextra->current->name = stripQuotes(yytext);
1646 BEGIN( Comment );
1647 }
1648<FileDocArg1>{LC} { yyextra->lineNr++;
1650 }
1651<FileDocArg1>. { // ignore other stuff
1652 }
1653
1654 /* --------- handle arguments of the xrefitem command ------------ */
1655
1656<XRefItemParam1>{LABELID} { // first argument
1657 yyextra->newXRefItemKey=yytext;
1659 BEGIN(XRefItemParam2);
1660 }
1661<XRefItemParam1>{LC} { // line continuation
1662 yyextra->lineNr++;
1664 }
1665<XRefItemParam1>{DOCNL} { // missing arguments
1666 warn(yyextra->fileName,yyextra->lineNr,
1667 "Missing first argument of \\xrefitem"
1668 );
1669 if (*yytext=='\n') yyextra->lineNr++;
1671 yyextra->inContext = OutputDoc;
1672 BEGIN( Comment );
1673 }
1674<XRefItemParam1>. { // ignore other stuff
1675 }
1676
1677<XRefItemParam2>"\""[^\n\"]*"\"" { // second argument
1678 yyextra->xrefItemTitle = stripQuotes(yytext);
1679 BEGIN(XRefItemParam3);
1680 }
1681<XRefItemParam2>{LC} { // line continuation
1682 yyextra->lineNr++;
1684 }
1685<XRefItemParam2>{DOCNL} { // missing argument
1686 warn(yyextra->fileName,yyextra->lineNr,
1687 "Missing second argument of \\xrefitem"
1688 );
1689 if (*yytext=='\n') yyextra->lineNr++;
1691 yyextra->inContext = OutputDoc;
1692 BEGIN( Comment );
1693 }
1694<XRefItemParam2>. { // ignore other stuff
1695 }
1696
1697<XRefItemParam3>"\""[^\n\"]*"\"" { // third argument
1698 yyextra->xrefListTitle = stripQuotes(yytext);
1699 yyextra->xrefKind = XRef_Item;
1700 BEGIN( Comment );
1701 }
1702<XRefItemParam2,XRefItemParam3>{LC} { // line continuation
1703 yyextra->lineNr++;
1705 }
1706<XRefItemParam3>{DOCNL} { // missing argument
1707 warn(yyextra->fileName,yyextra->lineNr,
1708 "Missing third argument of \\xrefitem"
1709 );
1710 if (*yytext=='\n') yyextra->lineNr++;
1712 yyextra->inContext = OutputDoc;
1713 BEGIN( Comment );
1714 }
1715<XRefItemParam3>. { // ignore other stuff
1716 }
1717
1718
1719 /* ----- handle arguments of the relates(also)/memberof command ------- */
1720
1721<RelatesParam1>({ID}("::"|"."))*{ID} { // argument
1722 yyextra->current->relates = yytext;
1723 //if (yyextra->current->mGrpId!=DOX_NOGROUP)
1724 //{
1725 // memberGroupRelates = yytext;
1726 //}
1727 BEGIN( Comment );
1728 }
1729<RelatesParam1>{LC} { // line continuation
1730 yyextra->lineNr++;
1732 }
1733<RelatesParam1>{DOCNL} { // missing argument
1734 warn(yyextra->fileName,yyextra->lineNr,
1735 "Missing argument of '\\{}' command",yyextra->currentCmd
1736 );
1737 unput_string(yytext,yyleng);
1738 //if (*yytext=='\n') yyextra->lineNr++;
1739 //addOutput(yyscanner,'\n');
1740 BEGIN( Comment );
1741 }
1742<RelatesParam1>. { // ignore other stuff
1743 }
1744
1745
1746 /* ----- handle arguments of the qualifier command ----- */
1747<Qualifier>{LABELID} { // unquoted version, simple label
1748 yyextra->current->qualifiers.emplace_back(yytext);
1749 BEGIN( Comment );
1750 }
1751<Qualifier>"\""[^\"]*"\"" { // quotes version, add without quotes
1752 std::string inp(yytext);
1753 yyextra->current->qualifiers.push_back(inp.substr(1,yyleng-2));
1754 BEGIN( Comment );
1755 }
1756<Qualifier>{DOCNL} { // missing argument
1757 warn(yyextra->fileName,yyextra->lineNr,
1758 "Missing argument of '\\{}' command",yyextra->currentCmd
1759 );
1760 unput_string(yytext,yyleng);
1761 BEGIN( Comment );
1762 }
1763<Qualifier>. {
1764 warn(yyextra->fileName,yyextra->lineNr,
1765 "Argument of '\\{}' command should be quoted",yyextra->currentCmd
1766 );
1767 unput_string(yytext,yyleng);
1768 BEGIN( Comment );
1769 }
1770 /* ----- handle arguments of the iline command ----- */
1771<ILine>{LINENR}/[\\@\n\.] |
1772<ILine>{LINENR}{B} {
1773 bool ok = false;
1775 if (!ok)
1776 {
1778 }
1779 else
1780 {
1781 yyextra->lineNr = nr;
1782 }
1783 addOutput(yyscanner,yytext);
1784 if (YY_START == ILine)
1785 {
1786 BEGIN(Comment);
1787 }
1788 else
1789 {
1790 yyextra->sectionTitle+=yytext;
1791 BEGIN(SectionTitle);
1792 }
1793 }
1794<ILine,ILineSection>. {
1795 addOutput(yyscanner,yytext);
1796 if (YY_START == ILine)
1797 {
1798 BEGIN(Comment);
1799 }
1800 else
1801 {
1802 yyextra->sectionTitle+=yytext;
1803 BEGIN(SectionTitle);
1804 }
1805 }
1806
1807 /* ----- handle arguments of the iraise command ----- */
1808<IRaise>{B}*[0-9]+/[\\@\n\.] |
1809<IRaise>{B}*[0-9]+{B} {
1810 bool ok = false;
1812 if (!ok)
1813 {
1815 }
1816 else
1817 {
1818 yyextra->raiseLevel = nr;
1819 }
1820 BEGIN(Comment);
1821 }
1822<IRaise>. {
1823 unput(yytext[0]);
1824 BEGIN(Comment);
1825 }
1826 /* ----- handle arguments of the iprefix command ----- */
1827
1828<IRaisePrefix>{B}*"\""({LABELID})?"\"" {
1829 QCString text(yytext);
1830 yyextra->raisePrefix = text.stripWhiteSpace().mid(1,text.length()-2);
1831 addOutput(yyscanner,yytext);
1832 BEGIN(Comment);
1833 }
1834<IRaisePrefix>. {
1835 unput(yytext[0]);
1836 BEGIN(Comment);
1837 }
1838
1839
1840 /* ----- handle arguments of the ifile command ----- */
1841
1842<IFile,IFileSection>{FILE} {
1843 addOutput(yyscanner,yytext);
1844 QCString text(yytext);
1845 if (yytext[0] == '\"') yyextra->fileName = text.mid(1,text.length()-2);
1846 else yyextra->fileName = yytext;
1847 if (YY_START == IFile)
1848 {
1849 BEGIN(Comment);
1850 }
1851 else
1852 {
1853 yyextra->sectionTitle+=yytext;
1854 BEGIN(SectionTitle);
1855 }
1856 }
1857
1858<LinkSection>[^\\@\n]* {
1859 yyextra->sectionTitle+=yytext;
1860 }
1861<LinkSection>{CMD}{CMD} {
1862 yyextra->sectionTitle+=yytext;
1863 }
1864<LinkSection>{DOCNL} {
1865 addOutput(yyscanner,yytext);
1866 if (*yytext == '\n') yyextra->lineNr++;
1867 yyextra->sectionTitle+=yytext;
1868 }
1869<LinkSection>{CMD}"endlink" {
1870 yyextra->sectionTitle+=yytext;
1871 BEGIN(SectionTitle);
1872 }
1873<LinkSection>. {
1874 yyextra->sectionTitle+=yytext;
1875 }
1876<LinkSection><<EOF>> {
1877 warn(yyextra->fileName,yyextra->lineNr,
1878 "reached end of comment while inside a '\\link' command, missing '\\endlink' command"
1879 );
1880 yyterminate();
1881 }
1882 /* ----- handle arguments of the relates(also)/addindex commands ----- */
1883
1884<LineParam>{CMD}{CMD} { // escaped command
1885 addOutput(yyscanner,yytext);
1886 }
1887<LineParam>{DOCNL} { // end of argument
1888 //if (*yytext=='\n') yyextra->lineNr++;
1889 //addOutput(yyscanner,'\n');
1890 unput_string(yytext,yyleng);
1891 BEGIN( Comment );
1892 }
1893<LineParam>{LC} { // line continuation
1894 yyextra->lineNr++;
1896 }
1897<LineParam>({CMD}{CMD}){ID} { // escaped command
1898 addOutput(yyscanner,yytext);
1899 }
1900<LineParam>. { // ignore other stuff
1901 addOutput(yyscanner,*yytext);
1902 }
1903
1904 /* ----- handle arguments of the section/subsection/.. commands ------- */
1905
1906<SectionLabel>{LABELID} { // first argument
1907 yyextra->sectionLabel=yyextra->raisePrefix+yytext;
1908 addOutput(yyscanner,yyextra->sectionLabel.data());
1909 yyextra->sectionTitle.clear();
1910 BEGIN(SectionTitle);
1911 }
1912<SectionLabel>{DOCNL} { // missing argument
1913 warn(yyextra->fileName,yyextra->lineNr,
1914 "\\section command has no label"
1915 );
1916 if (*yytext=='\n') yyextra->lineNr++;
1918 BEGIN( Comment );
1919 }
1920<SectionLabel>. { // invalid character for section label
1921 warn(yyextra->fileName,yyextra->lineNr,
1922 "Invalid or missing section label"
1923 );
1924 BEGIN(Comment);
1925 }
1926<SectionTitle>{STAopt}/"\n" { // end of section title
1927 addSection(yyscanner);
1928 addOutput(yyscanner,yytext);
1929 BEGIN( Comment );
1930 }
static void addSection(yyscan_t yyscanner, bool addYYtext=true)
Definition commentscan.l:4303
1931<SectionTitle>{STopt}"\\\\ilinebr" { // escaped end of section title
1932 yyextra->sectionTitle+=yytext;
1933 }
1934<SectionTitle>{STopt}/"\\ilinebr" { // end of section title
1935 addSection(yyscanner);
1936 addOutput(yyscanner,yytext);
1937 BEGIN( Comment );
1938 }
1939<SectionTitle>{B}*{CMD}"f$" {
1940 yyextra->formulaText="";
1941 yyextra->formulaPreText="$";
1942 yyextra->formulaPostText="";
1943 yyextra->formulaNewLines=0;
1944 BEGIN(ReadFormulaShortSection);
1945 }
1946<SectionTitle>{B}*{CMD}"f(" { // start of a inline formula
1947 yyextra->formulaText="";
1948 yyextra->formulaPreText="";
1949 yyextra->formulaPostText="";
1950 yyextra->formulaNewLines=0;
1951 BEGIN(ReadFormulaRoundSection);
1952 }
1953<SectionTitle>{B}*{CMD}"~"[a-z_A-Z-]* | // language switch command
1954<SectionTitle>{B}*{CMD}"f"[\[{] { // block formula
1958 warn(yyextra->fileName,yyextra->lineNr,
1959 "'\\{}' command is not allowed in section title, ending section title.",
1961 );
1962 unput_string(yytext,yyleng);
1963 BEGIN(Comment);
1964 }
1965<SectionTitle>{LC} { // line continuation
1966 yyextra->lineNr++;
1968 }
1969<SectionTitle>[^\n@\\]* { // any character without special meaning
1970 yyextra->sectionTitle+=yytext;
1971 addOutput(yyscanner,yytext);
1972 }
1973<SectionTitle>{B}*{CMD}{CMD} {
1974 yyextra->sectionTitle+=yytext;
1975 addOutput(yyscanner,yytext);
1976 }
1977<SectionTitle>{B}*{CMD}[a-z_A-Z]+"{"[^}]*"}"{B}* |
1978<SectionTitle>{B}*{CMD}[a-z_A-Z]+{B}* { // handling command in section title
1981 /* handle `f{` command as special case */
1982 if ((idx > 1) && (yytext[idx-1] == 'f') && (yytext[idx-2] == '\\' || yytext[idx-2] =='@')) REJECT;
1984 QCString cmdName;
1985 StringVector optList;
1986 if (idx == -1) // no options
1987 {
1989 }
1990 else // options present
1991 {
1995 }
1998 {
1999 switch (it->second.sectionHandling)
2000 {
2002 {
2003 int i=0;
2004 while (yytext[i]==' ' || yytext[i]=='\t') i++;
2005 yyextra->sectionTitle+=fullMatch.left(i);
2006 yyextra->sectionTitle+='@';
2007 yyextra->sectionTitle+=fullMatch.mid(i);
2011 warn(yyextra->fileName,yyextra->lineNr,
2012 "'\\{}' command is not allowed in section title, escaping command.",cmdName
2013 );
2014 }
2015 break;
2017 {
2020 warn(yyextra->fileName,yyextra->lineNr,
2021 "'\\{}' command is not allowed in section title, ending section title.",cmdName
2022 );
2023 unput_string(yytext,yyleng);
2024 BEGIN(Comment);
2025 }
2026 break;
2028 {
2029 if (cmdName == "fileinfo")
2030 {
2031 int i=0;
2032 while (yytext[i]==' ' || yytext[i]=='\t') i++;
2033 yyextra->sectionTitle+=fullMatch.left(i);
2035 handleFileInfoSection(yyscanner,cmdName,optList);
2036 if (idxEnd == -1)
2037 {
2038 yyextra->sectionTitle+=fullMatch.mid(i+9);
2040 }
2041 else
2042 {
2043 yyextra->sectionTitle+=fullMatch.mid(idxEnd+1);
2045 }
2046 }
2047 else if (cmdName == "lineinfo")
2048 {
2049 int i=0;
2050 while (yytext[i]==' ' || yytext[i]=='\t') i++;
2051 yyextra->sectionTitle+=fullMatch.left(i);
2053 yyextra->sectionTitle+=' ';
2054 yyextra->sectionTitle+=fullMatch.mid(i+9);
2059 }
2060 else if (cmdName == "raisewarning")
2061 {
2062 yyextra->raiseWarning = "";
2063 BEGIN(RaiseWarningSection);
2064 }
2065 else if (cmdName == "noop")
2066 {
2068 BEGIN(Noop);
2069 }
2070 else if (cmdName == "cite")
2071 {
2072 yyextra->sectionTitle+=yytext;
2073 addOutput(yyscanner,yytext);
2074 BEGIN(CiteLabelSection);
2075 }
2076 else if (cmdName == "iline")
2077 {
2078 yyextra->sectionTitle+=yytext;
2079 addOutput(yyscanner,yytext);
2080 BEGIN(ILineSection);
2081 }
2082 else if (cmdName == "ifile")
2083 {
2084 yyextra->sectionTitle+=yytext;
2085 addOutput(yyscanner,yytext);
2086 BEGIN(IFileSection);
2087 }
2088 else if ((cmdName == "anchor") || (cmdName == "ianchor"))
2089 {
2091 if (optList.empty())
2092 {
2093 yyextra -> anchorTitle = "";
2094 }
2095 else
2096 {
2099 }
2101 BEGIN(AnchorLabelSection);
2102 }
2103 else if (cmdName == "link")
2104 {
2105 yyextra->sectionTitle+=yytext;
2106 BEGIN(LinkSection);
2107 }
2108 else
2109 {
2110 yyextra->sectionTitle+=yytext;
2111 warn(yyextra->fileName,yyextra->lineNr,
2112 "internal error '\\{}' command is to be replaced in section title.",cmdName
2113 );
2114 }
2115 }
2116 break;
2118 {
2119 yyextra->sectionTitle+=yytext;
2120 addOutput(yyscanner,yytext);
2121 }
2122 break;
2123 }
2124 }
2125 else
2126 {
2127 yyextra->sectionTitle+=yytext;
2128 addOutput(yyscanner,yytext);
2129 }
2130 }
static bool handleFileInfoSection(yyscan_t yyscanner, const QCString &cmdName, const StringVector &optList)
Definition commentscan.l:3403
2131<SectionTitle>. { // anything else
2132 yyextra->sectionTitle+=yytext;
2133 addOutput(yyscanner,*yytext);
2134 }
2135
2136 /* ----- handle arguments of the subpage command ------- */
2137
2138<SubpageLabel>{FILE} { // first argument
2139 addOutput(yyscanner,yytext);
2140 // we add subpage labels as a kind of "inheritance" relation to prevent
2141 // needing to add another list to the Entry class.
2143 BEGIN(SubpageTitle);
2144 }
2145<SubpageLabel>{DOCNL} { // missing argument
2146 warn(yyextra->fileName,yyextra->lineNr,
2147 "\\subpage command has no label"
2148 );
2149 if (*yytext=='\n') yyextra->lineNr++;
2151 BEGIN( Comment );
2152 }
2153<SubpageLabel>. {
2154 unput(yytext[0]);
2155 BEGIN( Comment );
2156 }
2157<SubpageTitle>{DOCNL} { // no title, end command
2158 addOutput(yyscanner,yytext);
2159 BEGIN( Comment );
2160 }
2161<SubpageTitle>[ \t]*"\""[^\"\n]*"\"" { // add title, end of command
2162 addOutput(yyscanner,yytext);
2163 BEGIN( Comment );
2164 }
2165<SubpageTitle>. { // no title, end of command
2166 unput(*yytext);
2167 BEGIN( Comment );
2168 }
2169
2170 /* ----- handle arguments of the anchor command ------- */
2171
2172<AnchorLabel,AnchorLabelSection>{LABELID} { // found argument
2173 QCString lbl = yyextra->raisePrefix+yytext;
2174 addAnchor(yyscanner,lbl, yyextra->anchorTitle);
2176 if (YY_START == AnchorLabel)
2177 {
2178 BEGIN(Comment);
2179 }
2180 else
2181 {
2182 BEGIN(SectionTitle);
2183 }
2184 }
2185<AnchorLabel,AnchorLabelSection>{DOCNL} { // missing argument
2186 warn(yyextra->fileName,yyextra->lineNr,
2187 "\\anchor command has no label"
2188 );
2189 if (*yytext=='\n') yyextra->lineNr++;
2191 if (YY_START == AnchorLabel)
2192 {
2193 BEGIN(Comment);
2194 }
2195 else
2196 {
2197 BEGIN(SectionTitle);
2198 }
2199 }
2200<AnchorLabel,AnchorLabelSection>. { // invalid character for anchor label
2201 warn(yyextra->fileName,yyextra->lineNr,
2202 "Invalid or missing anchor label"
2203 );
2204 addOutput(yyscanner,yytext);
2205 if (YY_START == AnchorLabel)
2206 {
2207 BEGIN(Comment);
2208 }
2209 else
2210 {
2211 BEGIN(SectionTitle);
2212 }
2213 }
2214
2215
2216 /* ----- handle arguments of the preformatted block commands ------- */
2217
2218<FormatBlock>{CMD}("endverbatim"|"endiverbatim"|"endiliteral"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endrtfonly"|"endmanonly"|"enddot"|"endcode"|"endicode"|"endmsc")/{NW} { // possible ends
2219 addOutput(yyscanner,yytext);
2220 if (&yytext[4]==yyextra->blockName) // found end of the block
2221 {
2222 BEGIN(Comment);
2223 }
2224 }
2225<FormatBlock>{CMD}"enduml" {
2226 addOutput(yyscanner,yytext);
2227 if (yyextra->blockName=="startuml") // found end of the block
2228 {
2229 BEGIN(Comment);
2230 }
2231 }
2232<FormatBlock>[^ \@\*\/\\\n]* { // some word
2233 addOutput(yyscanner,yytext);
2234 }
2235<FormatBlock>{DOCNL} { // new line
2236 if (*yytext=='\n') yyextra->lineNr++;
2238 }
2239<FormatBlock>{CCS} { // start of a C-comment
2240 if (!(yyextra->blockName=="code" || yyextra->blockName=="verbatim" ||
2241 yyextra->blockName=="icode" || yyextra->blockName=="iverbatim"||
2242 yyextra->blockName=="iliteral"
2243 )
2244 ) yyextra->commentCount++;
2245 addOutput(yyscanner,yytext);
2246 }
2247<FormatBlock>{CCE} { // end of a C-comment
2248 addOutput(yyscanner,yytext);
2249 if (!(yyextra->blockName=="code" || yyextra->blockName=="verbatim" ||
2250 yyextra->blockName=="icode" || yyextra->blockName=="iverbatim"||
2251 yyextra->blockName=="iliteral"
2252 )
2253 )
2254 {
2255 yyextra->commentCount--;
2256 if (yyextra->commentCount<0)
2257 {
2259 if (yyextra->blockName=="startuml") endTag="enduml";
2260 warn(yyextra->fileName,yyextra->lineNr,
2261 "found */ without matching /* while inside a \\{} block! Perhaps a missing \\{}?",
2262 yyextra->blockName,endTag);
2263 }
2264 }
2265 }
2266<FormatBlock>. {
2267 addOutput(yyscanner,*yytext);
2268 }
2269<FormatBlock><<EOF>> {
2271 if (yyextra->blockName=="startuml") endTag="enduml";
2272 warn(yyextra->fileName,yyextra->lineNr,
2273 "reached end of comment while inside a \\{} block; check for missing \\{} tag!",
2274 yyextra->blockName,endTag
2275 );
2276 yyterminate();
2277 }
2278
2279 /* ----- handle arguments of if/ifnot commands ------- */
2280
2281<GuardParam>{B}*"(" {
2282 yyextra->guardExpr=yytext;
2283 yyextra->roundCount=1;
2284 BEGIN(GuardExpr);
2285 }
2286<GuardExpr>[^()]* {
2287 yyextra->guardExpr+=yytext;
2288 lineCount(yyscanner);
2289 }
2290<GuardExpr>"(" {
2291 yyextra->guardExpr+=yytext;
2292 yyextra->roundCount++;
2293 }
2294<GuardExpr>")" {
2295 yyextra->guardExpr+=yytext;
2296 yyextra->roundCount--;
2297 if (yyextra->roundCount==0)
2298 {
2299 handleGuard(yyscanner,yyextra->guardExpr);
2300 }
2301 }
static void handleGuard(yyscan_t yyscanner, const QCString &expr)
Definition commentscan.l:4824
2302<GuardExpr>\n {
2303 warn(yyextra->fileName,yyextra->lineNr,
2304 "invalid expression '{}' for yyextra->guards",yyextra->guardExpr);
2305 unput(*yytext);
2306 BEGIN(GuardParam);
2307 }
2308<GuardParam>{B}*[a-z_A-Z0-9.\-]+ { // parameter of if/ifnot yyextra->guards
2310 }
2311<GuardParam>{DOCNL} { // end of argument
2312 //next line is commented out due to bug620924
2313 //addOutput(yyscanner,'\n');
2314 addIlineBreak(yyscanner,yyextra->lineNr);
2315 unput_string(yytext,yyleng);
2317 }
2318<GuardParam>{LC} { // line continuation
2319 yyextra->lineNr++;
2321 }
2322<GuardParam>. { // empty condition
2323 unput(*yytext);
2325 }
2326<GuardParamEnd>{B}*{DOCNL} {
2327 lineCount(yyscanner);
2328 yyextra->spaceBeforeIf.clear();
2329 addIlineBreak(yyscanner,yyextra->lineNr);
2330 BEGIN(Comment);
2331 }
2332<GuardParamEnd>{B}* {
2333 if (!yyextra->spaceBeforeIf.isEmpty()) // needed for 665313 in combination with bug620924
2334 {
2335 addOutput(yyscanner,yyextra->spaceBeforeIf);
2336 }
2337 yyextra->spaceBeforeIf.clear();
2338 addIlineBreak(yyscanner,yyextra->lineNr);
2339 BEGIN(Comment);
2340 }
2341<GuardParamEnd>. {
2342 unput(*yytext);
2343 addIlineBreak(yyscanner,yyextra->lineNr);
2344 BEGIN(Comment);
2345 }
2346
2347 /* ----- handle skipping of conditional sections ------- */
2348
2349<SkipGuardedSection>{CMD}"ifnot"/{NW} {
2350 yyextra->guardType = Guard_IfNot;
2351 yyextra->guards->emplace(false);
2352 BEGIN( GuardParam );
2353 }
2354<SkipGuardedSection>{CMD}"if"/{NW} {
2355 yyextra->guardType = Guard_If;
2356 yyextra->guards->emplace(false);
2357 BEGIN( GuardParam );
2358 }
2359<SkipGuardedSection>{CMD}"endif"/{NW} {
2360 if (yyextra->guards->empty())
2361 {
2362 warn(yyextra->fileName,yyextra->lineNr,
2363 "found \\endif without matching start command");
2364 BEGIN( Comment );
2365 }
2366 else
2367 {
2368 yyextra->guards->pop();
2369 if (yyextra->guards->empty())
2370 {
2371 BEGIN( GuardParamEnd );
2372 }
2373 else
2374 {
2375 if (yyextra->guards->top().isEnabled())
2376 {
2377 BEGIN( GuardParamEnd );
2378 }
2379 else
2380 {
2381 BEGIN( SkipGuardedSection );
2382 }
2383 }
2384 }
2385 }
2386<SkipGuardedSection>{CMD}"else"/{NW} {
2387 if (yyextra->guards->empty())
2388 {
2389 warn(yyextra->fileName,yyextra->lineNr,
2390 "found \\else without matching start command");
2391 }
2392 else if (yyextra->guards->top().hasElse())
2393 {
2394 warn(yyextra->fileName,yyextra->lineNr,
2395 "found multiple \\else commands in same \\if construct");
2396 yyextra->guards->top().setEnabled(false);
2397 BEGIN( SkipGuardedSection );
2398 }
2399 else if (!yyextra->guards->top().parentVisible())
2400 {
2401 yyextra->guards->top().setEnabled(false);
2402 BEGIN( SkipGuardedSection );
2403 }
2404 else
2405 {
2406 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
2407 yyextra->guards->top().setElse();
2408 if (!yyextra->guards->top().parentVisible())
2409 {
2410 yyextra->guards->top().setEnabled(false);
2411 BEGIN( SkipGuardedSection );
2412 }
2413 else if (yyextra->guards->top().isEnabledFound())
2414 {
2415 yyextra->guards->top().setEnabled(false);
2416 BEGIN( SkipGuardedSection );
2417 }
2418 else
2419 {
2420 yyextra->guards->top().setEnabled(true);
2421 BEGIN( GuardParamEnd );
2422 }
2423 }
2424 }
2425<SkipGuardedSection>{CMD}"elseif"/{NW} {
2426 if (yyextra->guards->empty())
2427 {
2428 warn(yyextra->fileName,yyextra->lineNr,
2429 "found \\elseif without matching start command");
2430 }
2431 else if (yyextra->guards->top().hasElse())
2432 {
2433 warn(yyextra->fileName,yyextra->lineNr,
2434 "found \\elseif command after \\else command was given in \\if construct");
2435 yyextra->guardType = Guard_ElseIf;
2436 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
2437 yyextra->guards->top().setEnabled(false);
2438 BEGIN( GuardParam );
2439 }
2440 else
2441 {
2442 yyextra->guardType = Guard_ElseIf;
2443 yyextra->spaceBeforeIf = yyextra->spaceBeforeCmd;
2444 yyextra->guards->top().setEnabled(false);
2445 BEGIN( GuardParam );
2446 }
2447 }
2448<SkipGuardedSection>{DOCNL} { // skip line
2449 if (*yytext=='\n') yyextra->lineNr++;
2450 //addOutput(yyscanner,'\n');
2451 }
2452<SkipGuardedSection>[^ \\@\n]+ { // skip non-special characters
2453 }
2454<SkipGuardedSection>{CMD}{CMD} |
2455<SkipGuardedSection>. { // any other character
2456 }
2457
2458
2459 /* ----- handle skipping of internal section ------- */
2460
2461<SkipInternal>{DOCNL} { // skip line
2462 if (*yytext=='\n') yyextra->lineNr++;
2464 }
2465<SkipInternal>[@\\]"if"/[ \t] {
2466 yyextra->condCount++;
2467 }
2468<SkipInternal>[@\\]"ifnot"/[ \t] {
2469 yyextra->condCount++;
2470 }
2471<SkipInternal>[@\\]/"endif" {
2472 yyextra->condCount--;
2473 if (yyextra->condCount<0) // handle conditional section around of \internal, see bug607743
2474 {
2475 unput('\\');
2476 BEGIN(Comment);
2477 }
2478 }
2479<SkipInternal>[@\\]/"section"[ \t] {
2480 if (yyextra->sectionLevel>0)
2481 {
2482 unput('\\');
2483 BEGIN(Comment);
2484 }
2485 }
2486<SkipInternal>[@\\]/"subsection"[ \t] {
2487 if (yyextra->sectionLevel>1)
2488 {
2489 unput('\\');
2490 BEGIN(Comment);
2491 }
2492 }
2493<SkipInternal>[@\\]/"subsubsection"[ \t] {
2494 if (yyextra->sectionLevel>2)
2495 {
2496 unput('\\');
2497 BEGIN(Comment);
2498 }
2499 }
2500<SkipInternal>[@\\]/"paragraph"[ \t] {
2501 if (yyextra->sectionLevel>3)
2502 {
2503 unput('\\');
2504 BEGIN(Comment);
2505 }
2506 }
2507<SkipInternal>[@\\]/"subparagraph"[ \t] {
2508 if (yyextra->sectionLevel>4)
2509 {
2510 unput('\\');
2511 BEGIN(Comment);
2512 }
2513 }
2514<SkipInternal>[@\\]/"subsubparagraph"[ \t] {
2515 if (yyextra->sectionLevel>5)
2516 {
2517 unput('\\');
2518 BEGIN(Comment);
2519 }
2520 }
2521<SkipInternal>[@\\]"endinternal"[ \t]* {
2522 BEGIN(Comment);
2523 }
2524<SkipInternal>[^ \\@\n]+ { // skip non-special characters
2525 }
2526<SkipInternal>. { // any other character
2527 }
2528
2529
2530 /* ----- handle argument of name command ------- */
2531
2532<NameParam>{DOCNL} { // end of argument
2533 //if (*yytext=='\n') yyextra->lineNr++;
2534 //addOutput(yyscanner,'\n');
2535 unput_string(yytext,yyleng);
2536 BEGIN( Comment );
2537 }
2538<NameParam>{LC} { // line continuation
2539 yyextra->lineNr++;
2541 yyextra->docGroup.appendHeader(' ');
2542 }
2543<NameParam>. { // ignore other stuff
2544 yyextra->docGroup.appendHeader(*yytext);
2545 yyextra->current->name+=*yytext;
2546 }
2547
2548 /* ----- handle argument of noop command ------- */
2549<Noop>{DOCNL} { // end of argument
2550 if (*yytext=='\n')
2551 {
2552 yyextra->lineNr++;
2554 }
2555 BEGIN( Comment );
2556 }
2557<Noop>. { // ignore other stuff
2558 }
2559 /* ----- handle argument of raisewarning command ------- */
2560<RaiseWarning,RaiseWarningSection>{DOCNL} { // end of argument
2561 warn_doc_error(yyextra->fileName,yyextra->lineNr,
2562 "{}",yyextra->raiseWarning);
2563 yyextra->raiseWarning = "";
2564 if (*yytext=='\n') yyextra->lineNr++;
2566 if (YY_START == RaiseWarning)
2567 {
2568 BEGIN(Comment);
2569 }
2570 else
2571 {
2572 yyextra->sectionTitle+=yytext;
2573 BEGIN(SectionTitle);
2574 }
2575 }
2576<RaiseWarning,RaiseWarningSection>. { // ignore other stuff
2577 yyextra->raiseWarning += yytext;
2578 }
2579 /* ----- handle argument of ingroup command ------- */
2580
2581<InGroupParam>{LABELID} { // group id
2582 yyextra->current->groups.emplace_back(
2584 );
2585 yyextra->inGroupParamFound=TRUE;
2586 }
2587<InGroupParam>{DOCNL} { // missing argument
2588 if (!yyextra->inGroupParamFound)
2589 {
2590 warn(yyextra->fileName,yyextra->lineNr,
2591 "Missing group name for \\ingroup command"
2592 );
2593 }
2594 //if (*yytext=='\n') yyextra->lineNr++;
2595 //addOutput(yyscanner,'\n');
2596 unput_string(yytext,yyleng);
2597 BEGIN( Comment );
2598 }
2599<InGroupParam>{LC} { // line continuation
2600 yyextra->lineNr++;
2602 }
2603<InGroupParam>. { // ignore other stuff
2604 addOutput(yyscanner,*yytext);
2605 }
2606
2607 /* ----- handle argument of fn command ------- */
2608
2609<FnParam>{DOCNL} { // end of argument
2610 if (yyextra->braceCount==0)
2611 {
2612 if (yyextra->functionProto.stripWhiteSpace().isEmpty())
2613 {
2614 warn(yyextra->fileName,yyextra->lineNr,
2615 "missing argument after '\\{}'.",yyextra->currentCmd
2616 );
2617 }
2618 else
2619 {
2620 makeStructuralIndicator(yyscanner,yyextra->currentMakeEntryType);
2621 yyextra->langParser->parsePrototype(yyextra->functionProto);
2622 }
2623 unput_string(yytext,yyleng);
2624 BEGIN( Comment );
2625 }
2626 }
2627<FnParam>{LC} { // line continuation
2628 yyextra->lineNr++;
2629 yyextra->functionProto+=' ';
2630 }
2631<FnParam>[^@\\\n()]+ { // non-special characters
2632 yyextra->functionProto+=yytext;
2633 }
2634<FnParam>"(" {
2635 yyextra->functionProto+=yytext;
2636 yyextra->braceCount++;
2637 }
2638<FnParam>")" {
2639 yyextra->functionProto+=yytext;
2640 yyextra->braceCount--;
2641 }
2642<FnParam>. { // add other stuff
2643 yyextra->functionProto+=*yytext;
2644 }
2645
2646
2647 /* ----- handle argument of overload command ------- */
2648
2649
2650<OverloadParam>{DOCNL} { // end of argument
2651 if (*yytext=='\n') yyextra->lineNr++;
2652 if (yyextra->functionProto.stripWhiteSpace().isEmpty())
2653 { // plain overload command
2656 }
2657 else // overload declaration
2658 {
2659 makeStructuralIndicator(yyscanner,EntryType::makeOverloadDoc);
2660 yyextra->langParser->parsePrototype(yyextra->functionProto);
2661 }
2662 BEGIN( Comment );
2663 }
2664<OverloadParam>{LC} { // line continuation
2665 yyextra->lineNr++;
2666 yyextra->functionProto+=' ';
2667 }
2668<OverloadParam>. { // add other stuff
2669 yyextra->functionProto+=*yytext;
2670 }
2671
2672 /* ----- handle argument of inherit command ------- */
2673
2674<InheritParam>({ID}("::"|"."))*{ID} { // found argument
2675 yyextra->current->extends.emplace_back(
2677 );
2678 BEGIN( Comment );
2679 }
2680<InheritParam>{DOCNL} { // missing argument
2681 warn(yyextra->fileName,yyextra->lineNr,
2682 "\\inherit command has no argument"
2683 );
2684 if (*yytext=='\n') yyextra->lineNr++;
2686 BEGIN( Comment );
2687 }
2688<InheritParam>. { // invalid character for anchor label
2689 warn(yyextra->fileName,yyextra->lineNr,
2690 "Invalid or missing name for \\inherit command"
2691 );
2692 BEGIN(Comment);
2693 }
2694
2695 /* ----- handle argument of extends and implements commands ------- */
2696
2697<ExtendsParam>({ID}("::"|"."))*{ID} { // found argument
2698 yyextra->current->extends.emplace_back(
2700 );
2701 BEGIN( Comment );
2702 }
2703<ExtendsParam>{DOCNL} { // missing argument
2704 warn(yyextra->fileName,yyextra->lineNr,
2705 "'\\{}' command has no argument",yyextra->currentCmd
2706 );
2707 //if (*yytext=='\n') yyextra->lineNr++;
2708 //addOutput(yyscanner,'\n');
2709 unput_string(yytext,yyleng);
2710 BEGIN( Comment );
2711 }
2712<ExtendsParam>. { // ignore other stuff
2713 }
2714
2715 /* ----- handle language specific sections ------- */
2716
2717<SkipLang>[\\@]"~"[a-zA-Z-]* { /* language switch */
2718 QCString langId(&yytext[2]);
2720 {
2721 warn(yyextra->fileName,yyextra->lineNr,
2723 }
2724 else if (langId.isEmpty() ||
2726 { // enable language specific section
2727 BEGIN(Comment);
2728 }
2729 }
2730<SkipLang>[^*@\\\n]* { /* any character not a *, @, backslash or new line */
2731 }
2732<SkipLang>{DOCNL} { /* new line in verbatim block */
2733 if (*yytext=='\n') yyextra->lineNr++;
2734 }
2735<SkipLang>. { /* any other character */
2736 }
2737
2738 /* ----- handle arguments of the cite command ------- */
2739
2740<CiteLabel,CiteLabelSection>{CITEID} { // found argument
2741 addCite(yyscanner);
2742 addOutput(yyscanner,yytext);
2743 if (YY_START == CiteLabel)
2744 {
2745 BEGIN(Comment);
2746 }
2747 else
2748 {
2749 yyextra->sectionTitle+=yytext;
2750 BEGIN(SectionTitle);
2751 }
2752 }
2753<CiteLabel,CiteLabelSection>{DOCNL} { // missing argument
2754 warn(yyextra->fileName,yyextra->lineNr,
2755 "\\cite command has no label"
2756 );
2757 //if (*yytext=='\n') yyextra->lineNr++;
2758 //addOutput(yyscanner,'\n');
2759 if (YY_START == CiteLabel)
2760 {
2761 unput_string(yytext,yyleng);
2762 BEGIN(Comment);
2763 }
2764 else
2765 {
2766 yyextra->sectionTitle+=yytext;
2767 unput_string(yytext,yyleng);
2768 BEGIN(SectionTitle);
2769 }
2770 }
2771<CiteLabel,CiteLabelSection>. { // invalid character for cite label
2772 warn(yyextra->fileName,yyextra->lineNr,
2773 "Invalid or missing cite label"
2774 );
2775 if (YY_START == CiteLabel)
2776 {
2777 BEGIN(Comment);
2778 }
2779 else
2780 {
2781 yyextra->sectionTitle+=yytext;
2782 BEGIN(SectionTitle);
2783 }
2784 }
2785
2786 /* ----- handle argument of the copydoc command ------- */
2787
2788<CopyDoc><<EOF>> {
2791 addOutput(yyscanner,yyextra->copyDocArg);
2793 BEGIN(Comment);
2794 }
2795<CopyDoc>{DOCNL} {
2796 if (*yytext=='\n') yyextra->lineNr++;
2797 if (yyextra->braceCount==0)
2798 {
2801 addOutput(yyscanner,yyextra->copyDocArg);
2803 BEGIN(Comment);
2804 }
2805 }
2806<CopyDoc>{LC} { // line continuation
2807 yyextra->lineNr++;
2808 }
2809<CopyDoc>[^@\\\n()]+ { // non-special characters
2810 yyextra->copyDocArg+=yytext;
2811 addOutput(yyscanner,yytext);
2812 }
2813<CopyDoc>"(" {
2814 yyextra->copyDocArg+=yytext;
2815 addOutput(yyscanner,yytext);
2816 yyextra->braceCount++;
2817 }
2818<CopyDoc>")" {
2819 yyextra->copyDocArg+=yytext;
2820 addOutput(yyscanner,yytext);
2821 yyextra->braceCount--;
2822 }
2823<CopyDoc>. {
2824 yyextra->copyDocArg+=yytext;
2825 addOutput(yyscanner,yytext);
2826 }
2827
2828 /*
2829<*>. { fprintf(stderr,"Lex scanner %s %sdefault rule for state %s: #%s#\n", __FILE__,!yyextra->fileName.isEmpty() ? ("(" + yyextra->fileName +") ").data(): "",stateToString(YY_START),yytext);}
2830<*>\n { fprintf(stderr,"Lex scanner %s %sdefault rule newline for state %s.\n", __FILE__, !yyextra->fileName.isEmpty() ? ("(" + yyextra->fileName +") ").data(): "",stateToString(YY_START));}
2831 */
2832
2833%%
◆ yyread()
|
static |
Definition at line 4646 of file commentscan.l.
4647{
4648 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
4649 yyextra->prevPosition=yyextra->inputPosition;
4650 int c=0;
4651 while( c < max_size && yyextra->inputString[yyextra->inputPosition] )
4652 {
4653 *buf = yyextra->inputString[yyextra->inputPosition++] ;
4654 //printf("%d (%c)\n",*buf,*buf);
4655 c++; buf++;
4656 }
4657 return c;
4658}
Variable Documentation
◆ docCmdMap
|
static |
Definition at line 208 of file commentscan.l.
209{
210 // command name handler function command spacing section handling
228 { "collaborationgraph", { &handleCollaborationgraph, CommandSpacing::Invisible, SectionHandling::Escape }},
242 { "directorygraph", { &handleDirectoryGraph, CommandSpacing::Invisible, SectionHandling::Escape }},
259 { "hidecallergraph", { &handleHideCallergraph, CommandSpacing::Invisible, SectionHandling::Escape }},
260 { "hidecallgraph", { &handleHideCallgraph, CommandSpacing::Invisible, SectionHandling::Escape }},
261 { "hidecollaborationgraph", { &handleHideCollaborationgraph, CommandSpacing::Invisible, SectionHandling::Escape }},
262 { "hidedirectorygraph", { &handleHideDirectoryGraph, CommandSpacing::Invisible, SectionHandling::Escape }},
263 { "hideenumvalues", { &handleHideEnumValues, CommandSpacing::Invisible, SectionHandling::Escape }},
264 { "hidegroupgraph", { &handleHideGroupgraph, CommandSpacing::Invisible, SectionHandling::Escape }},
265 { "hideincludedbygraph", { &handleHideIncludedBygraph, CommandSpacing::Invisible, SectionHandling::Escape }},
266 { "hideincludegraph", { &handleHideIncludegraph, CommandSpacing::Invisible, SectionHandling::Escape }},
267 { "hideinheritancegraph", { &handleHideInheritanceGraph, CommandSpacing::Invisible, SectionHandling::Escape }},
268 { "hideinitializer", { &handleHideInitializer, CommandSpacing::Invisible, SectionHandling::Escape }},
269 { "hideinlinesource", { &handleHideInlineSource, CommandSpacing::Invisible, SectionHandling::Escape }},
270 { "hiderefby", { &handleHideReferencedByRelation, CommandSpacing::Invisible, SectionHandling::Escape }},
271 { "hiderefs", { &handleHideReferencesRelation, CommandSpacing::Invisible, SectionHandling::Escape }},
281 { "includedbygraph", { &handleIncludedBygraph, CommandSpacing::Invisible, SectionHandling::Escape }},
286 { "inheritancegraph", { &handleInheritanceGraph, CommandSpacing::Invisible, SectionHandling::Escape }},
304 { "nosubgrouping", { &handleNoSubGrouping, CommandSpacing::Invisible, SectionHandling::Escape }},
316 { "privatesection", { &handlePrivateSection, CommandSpacing::Invisible, SectionHandling::Escape }},
319 { "protectedsection", { &handleProtectedSection, CommandSpacing::Invisible, SectionHandling::Escape }},
322 { "publicsection", { &handlePublicSection, CommandSpacing::Invisible, SectionHandling::Escape }},
325 { "raisewarning", { &handleRaiseWarning, CommandSpacing::Invisible, SectionHandling::Replace }},
343 { "showenumvalues", { &handleShowEnumValues, CommandSpacing::Invisible, SectionHandling::Escape }},
344 { "showinitializer", { &handleShowInitializer, CommandSpacing::Invisible, SectionHandling::Escape }},
345 { "showinlinesource", { &handleShowInlineSource, CommandSpacing::Invisible, SectionHandling::Escape }},
346 { "showrefby", { &handleReferencedByRelation, CommandSpacing::Invisible, SectionHandling::Escape }},
347 { "showrefs", { &handleReferencesRelation, CommandSpacing::Invisible, SectionHandling::Escape }},
static bool handlePrivate(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3945
static bool handleHideIncludegraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3770
static bool handleDetails(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3095
static bool handleName(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3122
static bool handleImage(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3330
static bool handleStatic(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3931
static bool handleCopyDetails(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:4081
static bool handleProtectedSection(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3966
static bool handleOverload(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2866
static bool handleXRefItem(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3174
static bool handleProtocol(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2959
static bool handleWeakGroup(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2900
static bool handleInternal(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3908
static bool handleShowInitializer(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3686
static bool handleGroupgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3812
static bool handleQualifier(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3900
static bool handleLineInfo(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3496
static bool handleNoSubGrouping(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3679
static bool handleMainpage(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3021
static bool handleCite(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3355
static bool handleTest(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3147
static bool handleIRaise(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3524
static bool handleHideCallgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3707
static bool handleCallgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3700
static bool handleIngroup(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3671
static bool handleStruct(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2986
static bool handleInterface(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2995
static bool handleShowInlineSource(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3742
static bool handleAddToGroup(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2891
static bool handleDef(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2855
static bool handleConcept(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2934
static bool handleExtends(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:4055
static bool handleBrief(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2837
static bool handleRefItem(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3256
static bool handleIncludedBygraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3763
static bool handleUnion(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2977
static bool handleHideDirectoryGraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3791
static bool handleRelated(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3214
static bool handleBug(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3156
static bool handleReferencesRelation(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3886
static bool handleHideIncludedBygraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3777
static bool handleRaiseWarning(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3107
static bool handleElseIf(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3575
static bool handleMemberOf(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3242
static bool handleToc(yyscan_t yyscanner, const QCString &s, const StringVector &)
Definition commentscan.l:3987
static bool handleParBlock(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3182
static bool handleCategory(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2968
static bool handlePrivateSection(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3952
static bool handleModule(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2943
static bool handleInherit(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:4048
static bool handleEndIf(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3636
static bool handleDirectoryGraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3784
static bool handleTodo(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3138
static bool handleIPrefix(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3531
static bool handleCopyDoc(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:4094
static bool handleReferencedByRelation(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3872
static bool handleEnum(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2874
static bool handleIfNot(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3557
static bool handleFormatBlock(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3368
static bool handleHideInlineSource(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3749
static bool handleNoop(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3115
static bool handleAnchor(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3314
static bool handleHideInitializer(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3693
static bool handleCallergraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3714
static bool handleParam(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3046
static bool handleHideInheritanceGraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3865
static bool handleIf(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3539
static bool handlePage(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3013
static bool handlePackage(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2917
static bool handleHideEnumValues(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3735
static bool handleSection(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3264
static bool handleCollaborationgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3798
static bool handleHideGroupgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3819
static bool handleIFile(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3516
static bool handleFn(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2844
static bool handleDeprecated(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3165
static bool handleIncludegraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3756
static bool handlePure(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3938
static bool handleHideCollaborationgraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3805
static bool handleHideReferencedByRelation(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3879
static bool handlePublic(yyscan_t yyscanner, const QCString &s, const StringVector &)
Definition commentscan.l:3973
static bool handleDir(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3064
static bool handleRelatedAlso(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3228
static bool handleInheritanceGraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3826
static bool handleAddIndex(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3391
static bool handleFileInfo(yyscan_t yyscanner, const QCString &cmdName, const StringVector &optList)
Definition commentscan.l:3399
static bool handleSubpage(yyscan_t yyscanner, const QCString &s, const StringVector &)
Definition commentscan.l:3293
static bool handleProtected(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3959
static bool handleEndParBlock(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3200
static bool handleElse(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3602
static bool handleClass(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2925
static bool handleHeaderFile(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2952
static bool handleCopyBrief(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:4063
static bool handleShowEnumValues(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3728
static bool handleHideReferencesRelation(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3893
static bool handleFile(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3034
static bool handleRetval(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3056
static bool handleIdlException(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3004
static bool handleNamespace(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2909
static bool handleHideCallergraph(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3721
static bool handleDefGroup(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:2882
static bool handleExample(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3073
static bool handleILine(yyscan_t yyscanner, const QCString &, const StringVector &)
Definition commentscan.l:3508
static bool handlePublicSection(yyscan_t yyscanner, const QCString &s, const StringVector &)
Definition commentscan.l:3980
408};
◆ g_citeMutex
|
static |
Definition at line 528 of file commentscan.l.
Referenced by addCite().
◆ g_formulaMutex
|
static |
Definition at line 527 of file commentscan.l.
Referenced by addFormula().
◆ g_sectionMutex
|
static |
Definition at line 526 of file commentscan.l.
Referenced by addAnchor(), addSection(), and addXRefItem().
◆ nonBrief_re
|
static |
Referenced by endBrief(), and setOutput().
