commentscan.cpp File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <qarray.h>
#include <qstack.h>
#include <qregexp.h>
#include <qfile.h>
#include "scanner.h"
#include "entry.h"
#include "doxygen.h"
#include "message.h"
#include "config.h"
#include "util.h"
#include "index.h"
#include "defargs.h"
#include "language.h"
#include "outputlist.h"
#include "membergroup.h"
#include "reflist.h"
#include "debug.h"
#include "parserintf.h"
#include "cite.h"
#include "markdown.h"
#include "condparser.h"
#include "formula.h"

Go to the source code of this file.

Classes
struct	yy_buffer_state
struct	yy_trans_info
struct	DocCmdMap
class	DocCmdMapper
	Command mapper. More...
struct	DocCmdMapper::Cmd
class	GuardedSection

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   commentscanYY_create_buffer
#define	yy_delete_buffer   commentscanYY_delete_buffer
#define	yy_flex_debug   commentscanYY_flex_debug
#define	yy_init_buffer   commentscanYY_init_buffer
#define	yy_flush_buffer   commentscanYY_flush_buffer
#define	yy_load_buffer_state   commentscanYY_load_buffer_state
#define	yy_switch_to_buffer   commentscanYY_switch_to_buffer
#define	yyin   commentscanYYin
#define	yyleng   commentscanYYleng
#define	yylex   commentscanYYlex
#define	yylineno   commentscanYYlineno
#define	yyout   commentscanYYout
#define	yyrestart   commentscanYYrestart
#define	yytext   commentscanYYtext
#define	yywrap   commentscanYYwrap
#define	yyalloc   commentscanYYalloc
#define	yyrealloc   commentscanYYrealloc
#define	yyfree   commentscanYYfree
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   35
#define	FLEX_BETA
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE   commentscanYYrestart(commentscanYYin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	YY_LESS_LINENO(n)
#define	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_TYPEDEF_YY_SIZE_T
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	YY_FLUSH_BUFFER   commentscanYY_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   commentscanYY_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	commentscanYYwrap(n)   1
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   commentscanYYtext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   205
#define	YY_END_OF_BUFFER   206
#define	REJECT
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	YY_NEVER_INTERACTIVE   1
#define	YY_INPUT(buf, result, max_size)   result=yyread(buf,max_size);
#define	INITIAL   0
#define	Comment   1
#define	PageDocArg1   2
#define	PageDocArg2   3
#define	RelatesParam1   4
#define	ClassDocArg1   5
#define	ClassDocArg2   6
#define	ClassDocArg3   7
#define	CategoryDocArg1   8
#define	XRefItemParam1   9
#define	XRefItemParam2   10
#define	XRefItemParam3   11
#define	FileDocArg1   12
#define	EnumDocArg1   13
#define	NameSpaceDocArg1   14
#define	PackageDocArg1   15
#define	GroupDocArg1   16
#define	GroupDocArg2   17
#define	SectionLabel   18
#define	SectionTitle   19
#define	SubpageLabel   20
#define	SubpageTitle   21
#define	FormatBlock   22
#define	LineParam   23
#define	GuardParam   24
#define	GuardParamEnd   25
#define	SkipGuardedSection   26
#define	SkipInternal   27
#define	NameParam   28
#define	InGroupParam   29
#define	FnParam   30
#define	OverloadParam   31
#define	InheritParam   32
#define	ExtendsParam   33
#define	ReadFormulaShort   34
#define	ReadFormulaLong   35
#define	AnchorLabel   36
#define	HtmlComment   37
#define	SkipLang   38
#define	CiteLabel   39
#define	CopyDoc   40
#define	GuardExpr   41
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( commentscanYYtext, commentscanYYleng, 1, commentscanYYout )) {} } while (0)
#define	yyterminate()   return YY_NULL
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int commentscanYYlex (void)
#define	YY_USER_ACTION
#define	YY_BREAK   break;
#define	YY_RULE_SETUP
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type
typedef bool(*	DocCmdFunc) (const QCString &name)

Enumerations
enum	XRefKind {   XRef_Item, XRef_Todo, XRef_Test, XRef_Bug,   XRef_Deprecated, XRef_None }
enum	OutputContext { OutputDoc, OutputBrief, OutputXRef, OutputInbody }
enum	GuardType { Guard_If, Guard_IfNot, Guard_Skip }

Functions
void	commentscanYYrestart (FILE *input_file)
void	commentscanYY_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	commentscanYY_create_buffer (FILE *file, int size)
void	commentscanYY_delete_buffer (YY_BUFFER_STATE b)
void	commentscanYY_flush_buffer (YY_BUFFER_STATE b)
void	commentscanYYpush_buffer_state (YY_BUFFER_STATE new_buffer)
void	commentscanYYpop_buffer_state (void)
static void	commentscanYYensure_buffer_stack (void)
static void	commentscanYY_load_buffer_state (void)
static void	commentscanYY_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	commentscanYY_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	commentscanYY_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	commentscanYY_scan_bytes (yyconst char *bytes, int len)
void *	commentscanYYalloc (yy_size_t)
void *	commentscanYYrealloc (void *, yy_size_t)
void	commentscanYYfree (void *)
static yy_state_type	yy_get_previous_state (void)
static yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
static int	yy_get_next_buffer (void)
static void	yy_fatal_error (yyconst char msg[])
static bool	handleBrief (const QCString &)
static bool	handleFn (const QCString &)
static bool	handleDef (const QCString &)
static bool	handleOverload (const QCString &)
static bool	handleEnum (const QCString &)
static bool	handleDefGroup (const QCString &)
static bool	handleAddToGroup (const QCString &)
static bool	handleWeakGroup (const QCString &)
static bool	handleNamespace (const QCString &)
static bool	handlePackage (const QCString &)
static bool	handleClass (const QCString &)
static bool	handleHeaderFile (const QCString &)
static bool	handleProtocol (const QCString &)
static bool	handleCategory (const QCString &)
static bool	handleUnion (const QCString &)
static bool	handleStruct (const QCString &)
static bool	handleInterface (const QCString &)
static bool	handleIdlException (const QCString &)
static bool	handlePage (const QCString &)
static bool	handleMainpage (const QCString &)
static bool	handleFile (const QCString &)
static bool	handleDir (const QCString &)
static bool	handleExample (const QCString &)
static bool	handleDetails (const QCString &)
static bool	handleName (const QCString &)
static bool	handleTodo (const QCString &)
static bool	handleTest (const QCString &)
static bool	handleBug (const QCString &)
static bool	handleSubpage (const QCString &s)
static bool	handleDeprecated (const QCString &)
static bool	handleXRefItem (const QCString &)
static bool	handleRelated (const QCString &)
static bool	handleRelatedAlso (const QCString &)
static bool	handleMemberOf (const QCString &)
static bool	handleRefItem (const QCString &)
static bool	handleSection (const QCString &)
static bool	handleAnchor (const QCString &)
static bool	handleCite (const QCString &)
static bool	handleFormatBlock (const QCString &)
static bool	handleAddIndex (const QCString &)
static bool	handleIf (const QCString &)
static bool	handleIfNot (const QCString &)
static bool	handleElseIf (const QCString &)
static bool	handleElse (const QCString &)
static bool	handleEndIf (const QCString &)
static bool	handleIngroup (const QCString &)
static bool	handleNoSubGrouping (const QCString &)
static bool	handleShowInitializer (const QCString &)
static bool	handleHideInitializer (const QCString &)
static bool	handleCallgraph (const QCString &)
static bool	handleHideCallgraph (const QCString &)
static bool	handleCallergraph (const QCString &)
static bool	handleHideCallergraph (const QCString &)
static bool	handleInternal (const QCString &)
static bool	handleLineBr (const QCString &)
static bool	handleStatic (const QCString &)
static bool	handlePure (const QCString &)
static bool	handlePrivate (const QCString &)
static bool	handlePrivateSection (const QCString &)
static bool	handleProtected (const QCString &)
static bool	handleProtectedSection (const QCString &)
static bool	handlePublic (const QCString &s)
static bool	handlePublicSection (const QCString &s)
static bool	handleToc (const QCString &s)
static bool	handleInherit (const QCString &)
static bool	handleExtends (const QCString &)
static bool	handleCopyDoc (const QCString &)
static bool	handleCopyBrief (const QCString &)
static bool	handleCopyDetails (const QCString &)
static bool	handleParBlock (const QCString &)
static bool	handleEndParBlock (const QCString &)
void	openGroup (Entry *e, const char *file, int line)
void	closeGroup (Entry *e, const char *file, int line, bool foundInline=FALSE)
void	initGroupInfo (Entry *e)
static void	groupAddDocs (Entry *e)
static void	initParser ()
static bool	getDocSectionName (int s)
static bool	makeStructuralIndicator (Entry::Sections s)
static void	lineCount ()
static QCString	stripQuotes (const char *s)
static void	addXRefItem (const char *listName, const char *itemTitle, const char *listTitle, bool append)
static QCString	addFormula ()
static void	checkFormula ()
static SectionInfo::SectionType	sectionLevelToType (int level)
static void	addSection ()
static void	addCite ()
static void	stripTrailingWhiteSpace (QCString &s)
static void	setOutput (OutputContext ctx)
static void	addAnchor (const char *anchor)
static void	addOutput (const char *s)
static void	addOutput (char c)
static void	endBrief (bool addToOutput=TRUE)
static void	handleGuard (const QCString &expr)
static int	yyread (char *buf, int max_size)
static int	yy_init_globals (void)
int	commentscanYYlex_destroy (void)
int	commentscanYYget_debug (void)
void	commentscanYYset_debug (int debug_flag)
YY_EXTRA_TYPE	commentscanYYget_extra (void)
void	commentscanYYset_extra (YY_EXTRA_TYPE user_defined)
FILE *	commentscanYYget_in (void)
void	commentscanYYset_in (FILE *in_str)
FILE *	commentscanYYget_out (void)
void	commentscanYYset_out (FILE *out_str)
int	commentscanYYget_leng (void)
char *	commentscanYYget_text (void)
int	commentscanYYget_lineno (void)
void	commentscanYYset_lineno (int line_number)
static void	yyunput (int c, char *buf_ptr)
int	commentscanYYlex (void)
	if (!(yy_init))
	while (1)
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (yyconst char *msg)
bool	parseCommentBlock (ParserInterface *parser, Entry *curEntry, const QCString &comment, const QCString &fileName, int &lineNr, bool isBrief, bool isAutoBriefOn, bool isInbody, Protection &prot, int &position, bool &newEntryNeeded)
void	groupEnterFile (const char *fileName, int)
void	groupLeaveFile (const char *fileName, int line)
void	groupEnterCompound (const char *fileName, int line, const char *name)
void	groupLeaveCompound (const char *, int, const char *)
static int	findExistingGroup (int &groupId, const MemberGroupInfo *info)

Variables
int	commentscanYYleng
FILE *	commentscanYYin = (FILE *) 0
FILE *	commentscanYYout = (FILE *) 0
static size_t	yy_buffer_stack_top = 0
static size_t	yy_buffer_stack_max = 0
static YY_BUFFER_STATE *	yy_buffer_stack = 0
static char	yy_hold_char
static int	yy_n_chars
static char *	yy_c_buf_p = (char *) 0
static int	yy_init = 0
static int	yy_start = 0
static int	yy_did_buffer_switch_on_eof
int	commentscanYYlineno = 1
char *	commentscanYYtext
static yyconst flex_int16_t	yy_acclist [759]
static yyconst flex_int16_t	yy_accept [1139]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [76]
static yyconst flex_int16_t	yy_base [1371]
static yyconst flex_int16_t	yy_def [1371]
static yyconst flex_int16_t	yy_nxt [9667]
static yyconst flex_int16_t	yy_chk [9667]
int	commentscanYY_flex_debug = 0
static yy_state_type *	yy_state_buf =0
static yy_state_type *	yy_state_ptr =0
static char *	yy_full_match
static int	yy_lp
static DocCmdMap	docCmdMap []
bool	inInternalDocs = FALSE
static ParserInterface *	langParser
static QCString	inputString
static int	inputPosition
static QCString	yyFileName
static int	yyLineNr
static bool	inBody
static OutputContext	inContext
static bool	briefEndsAtDot
static QCString	formulaText
static QCString	formulaEnv
static int	formulaNewLines
static QCString *	pOutputString
static QCString	outputXRef
static QCString	blockName
static XRefKind	xrefKind
static XRefKind	newXRefKind
static GuardType	guardType
static bool	enabledSectionFound
static QCString	functionProto
static QStack< GuardedSection >	guards
static Entry *	current = 0
static bool	needNewEntry
static QCString	g_sectionLabel
static QCString	g_sectionTitle
static int	g_sectionLevel
static QCString	xrefItemKey
static QCString	newXRefItemKey
static QCString	xrefItemTitle
static QCString	xrefListTitle
static Protection	protection
static bool	xrefAppendFlag
static bool	inGroupParamFound
static int	braceCount
static bool	insidePre
static bool	parseMore
static int	g_condCount
static int	g_commentCount
static QCString	g_spaceBeforeCmd
static QCString	g_spaceBeforeIf
static QCString	g_copyDocArg
static QCString	g_guardExpr
static int	g_roundCount
static bool	g_insideParBlock
static QStack< Grouping >	g_autoGroupStack
static int	g_memberGroupId = DOX_NOGROUP
static QCString	g_memberGroupHeader
static QCString	g_memberGroupDocs
static QCString	g_memberGroupRelates
static QCString	g_compoundName
static int	prevPosition =0
	YY_DECL
register char *	yy_cp
register char *	yy_bp
register int	yy_act

Macro Definition Documentation

#define AnchorLabel   36

Definition at line 4097 of file commentscan.cpp.

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 144 of file commentscan.cpp.

#define CategoryDocArg1   8

Definition at line 4069 of file commentscan.cpp.

#define CiteLabel   39

Definition at line 4100 of file commentscan.cpp.

#define ClassDocArg1   5

Definition at line 4066 of file commentscan.cpp.

#define ClassDocArg2   6

Definition at line 4067 of file commentscan.cpp.

#define ClassDocArg3   7

Definition at line 4068 of file commentscan.cpp.

#define Comment   1

Definition at line 4062 of file commentscan.cpp.

#define commentscanYYwrap

(

n

)

1

Definition at line 354 of file commentscan.cpp.

#define CopyDoc   40

Definition at line 4101 of file commentscan.cpp.

#define ECHO   do { if (fwrite( commentscanYYtext, commentscanYYleng, 1, commentscanYYout )) {} } while (0)

Definition at line 4189 of file commentscan.cpp.

#define EnumDocArg1   13

Definition at line 4074 of file commentscan.cpp.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file commentscan.cpp.

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file commentscan.cpp.

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file commentscan.cpp.

#define ExtendsParam   33

Definition at line 4094 of file commentscan.cpp.

#define FileDocArg1   12

Definition at line 4073 of file commentscan.cpp.

#define FLEX_BETA

Definition at line 33 of file commentscan.cpp.

#define FLEX_SCANNER

Definition at line 28 of file commentscan.cpp.

#define FLEXINT_H

Definition at line 49 of file commentscan.cpp.

#define FnParam   30

Definition at line 4091 of file commentscan.cpp.

#define FormatBlock   22

Definition at line 4083 of file commentscan.cpp.

#define GroupDocArg1   16

Definition at line 4077 of file commentscan.cpp.

#define GroupDocArg2   17

Definition at line 4078 of file commentscan.cpp.

#define GuardExpr   41

Definition at line 4102 of file commentscan.cpp.

#define GuardParam   24

Definition at line 4085 of file commentscan.cpp.

#define GuardParamEnd   25

Definition at line 4086 of file commentscan.cpp.

#define HtmlComment   37

Definition at line 4098 of file commentscan.cpp.

#define InGroupParam   29

Definition at line 4090 of file commentscan.cpp.

#define InheritParam   32

Definition at line 4093 of file commentscan.cpp.

#define INITIAL   0

Definition at line 4061 of file commentscan.cpp.

#define INT16_MAX   (32767)

Definition at line 92 of file commentscan.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file commentscan.cpp.

#define INT32_MAX   (2147483647)

Definition at line 95 of file commentscan.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file commentscan.cpp.

#define INT8_MAX   (127)

Definition at line 89 of file commentscan.cpp.

#define INT8_MIN   (-128)

Definition at line 80 of file commentscan.cpp.

#define LineParam   23

Definition at line 4084 of file commentscan.cpp.

#define NameParam   28

Definition at line 4089 of file commentscan.cpp.

#define NameSpaceDocArg1   14

Definition at line 4075 of file commentscan.cpp.

#define OverloadParam   31

Definition at line 4092 of file commentscan.cpp.

#define PackageDocArg1   15

Definition at line 4076 of file commentscan.cpp.

#define PageDocArg1   2

Definition at line 4063 of file commentscan.cpp.

#define PageDocArg2   3

Definition at line 4064 of file commentscan.cpp.

#define ReadFormulaLong   35

Definition at line 4096 of file commentscan.cpp.

#define ReadFormulaShort   34

Definition at line 4095 of file commentscan.cpp.

#define REJECT

Value:

{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */ \
yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
++(yy_lp); \
goto find_rule; \
}

Definition at line 3102 of file commentscan.cpp.

#define RelatesParam1   4

Definition at line 4065 of file commentscan.cpp.

#define SectionLabel   18

Definition at line 4079 of file commentscan.cpp.

#define SectionTitle   19

Definition at line 4080 of file commentscan.cpp.

#define SkipGuardedSection   26

Definition at line 4087 of file commentscan.cpp.

#define SkipInternal   27

Definition at line 4088 of file commentscan.cpp.

#define SkipLang   38

Definition at line 4099 of file commentscan.cpp.

#define SubpageLabel   20

Definition at line 4081 of file commentscan.cpp.

#define SubpageTitle   21

Definition at line 4082 of file commentscan.cpp.

#define UINT16_MAX   (65535U)

Definition at line 101 of file commentscan.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file commentscan.cpp.

#define UINT8_MAX   (255U)

Definition at line 98 of file commentscan.cpp.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 199 of file commentscan.cpp.

#define XRefItemParam1   9

Definition at line 4070 of file commentscan.cpp.

#define XRefItemParam2   10

Definition at line 4071 of file commentscan.cpp.

#define XRefItemParam3   11

Definition at line 4072 of file commentscan.cpp.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 350 of file commentscan.cpp.

#define YY_BREAK   break;

Definition at line 4268 of file commentscan.cpp.

#define YY_BUF_SIZE   16384

Definition at line 163 of file commentscan.cpp.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 266 of file commentscan.cpp.

#define YY_BUFFER_NEW   0

Definition at line 254 of file commentscan.cpp.

#define YY_BUFFER_NORMAL   1

Definition at line 255 of file commentscan.cpp.

#define yy_create_buffer   commentscanYY_create_buffer

Definition at line 9 of file commentscan.cpp.

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 282 of file commentscan.cpp.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 289 of file commentscan.cpp.

#define YY_DECL   int commentscanYYlex (void)

Definition at line 4256 of file commentscan.cpp.

#define YY_DECL_IS_OURS   1

Definition at line 4252 of file commentscan.cpp.

#define yy_delete_buffer   commentscanYY_delete_buffer

Definition at line 10 of file commentscan.cpp.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
	commentscanYYleng = (size_t) (yy_cp - yy_bp); \
        (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
        (yy_c_buf_p) = yy_cp;

Definition at line 378 of file commentscan.cpp.

#define YY_END_OF_BUFFER   206

Definition at line 386 of file commentscan.cpp.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 159 of file commentscan.cpp.

#define YY_EXIT_FAILURE   2

Definition at line 7293 of file commentscan.cpp.

#define YY_EXTRA_TYPE   void *

Definition at line 4113 of file commentscan.cpp.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 4243 of file commentscan.cpp.

#define yy_flex_debug   commentscanYY_flex_debug

Definition at line 11 of file commentscan.cpp.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file commentscan.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file commentscan.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file commentscan.cpp.

#define yy_flush_buffer   commentscanYY_flush_buffer

Definition at line 13 of file commentscan.cpp.

#define YY_FLUSH_BUFFER   commentscanYY_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 318 of file commentscan.cpp.

#define yy_init_buffer   commentscanYY_init_buffer

Definition at line 12 of file commentscan.cpp.

#define YY_INPUT	(		buf,
			result,
			max_size
	)		result=yyread(buf,max_size);

Definition at line 3999 of file commentscan.cpp.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file commentscan.cpp.

#define YY_LESS_LINENO

(

n

)

Definition at line 183 of file commentscan.cpp.

#define yy_load_buffer_state   commentscanYY_load_buffer_state

Definition at line 14 of file commentscan.cpp.

#define YY_MORE_ADJ   0

Definition at line 3111 of file commentscan.cpp.

#define YY_NEVER_INTERACTIVE   1

Definition at line 3446 of file commentscan.cpp.

#define yy_new_buffer   commentscanYY_create_buffer

Definition at line 328 of file commentscan.cpp.

#define YY_NEW_FILE   commentscanYYrestart(commentscanYYin )

Definition at line 157 of file commentscan.cpp.

#define YY_NO_INPUT   1

Definition at line 3163 of file commentscan.cpp.

#define YY_NO_UNISTD_H   1

Definition at line 3164 of file commentscan.cpp.

#define YY_NULL   0

Definition at line 131 of file commentscan.cpp.

#define YY_NUM_RULES   205

Definition at line 385 of file commentscan.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 4181 of file commentscan.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 3112 of file commentscan.cpp.

#define YY_RULE_SETUP

Value:

if ( commentscanYYleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
                                (commentscanYYtext[commentscanYYleng - 1] == '\n'); \
	YY_USER_ACTION

Definition at line 4271 of file commentscan.cpp.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 138 of file commentscan.cpp.

#define yy_set_bol

(

at_bol

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        commentscanYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            commentscanYY_create_buffer(commentscanYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 340 of file commentscan.cpp.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        commentscanYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            commentscanYY_create_buffer(commentscanYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 330 of file commentscan.cpp.

#define YY_SKIP_YYWRAP

Definition at line 355 of file commentscan.cpp.

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 150 of file commentscan.cpp.

#define YY_START_STACK_INCR   25

Definition at line 4238 of file commentscan.cpp.

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 168 of file commentscan.cpp.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 154 of file commentscan.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 207 of file commentscan.cpp.

#define yy_switch_to_buffer   commentscanYY_switch_to_buffer

Definition at line 15 of file commentscan.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 171 of file commentscan.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 202 of file commentscan.cpp.

#define YY_USER_ACTION

Definition at line 4263 of file commentscan.cpp.

#define yyalloc   commentscanYYalloc

Definition at line 24 of file commentscan.cpp.

#define yyconst

Definition at line 127 of file commentscan.cpp.

#define yyfree   commentscanYYfree

Definition at line 26 of file commentscan.cpp.

#define yyin   commentscanYYin

Definition at line 16 of file commentscan.cpp.

#define yyleng   commentscanYYleng

Definition at line 17 of file commentscan.cpp.

#define yyless

(

n

)

Value:

do \
                { \
                /* Undo effects of setting up commentscanYYtext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                *yy_cp = (yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */ \
                } \
	while ( 0 )

Definition at line 7305 of file commentscan.cpp.

#define yyless

(

n

)

Value:

do \
                { \
                /* Undo effects of setting up commentscanYYtext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		commentscanYYtext[commentscanYYleng] = (yy_hold_char); \
                (yy_c_buf_p) = commentscanYYtext + yyless_macro_arg; \
                (yy_hold_char) = *(yy_c_buf_p); \
                *(yy_c_buf_p) = '\0'; \
		commentscanYYleng = yyless_macro_arg; \
                } \
	while ( 0 )

Definition at line 7305 of file commentscan.cpp.

#define yylex   commentscanYYlex

Definition at line 18 of file commentscan.cpp.

#define yylineno   commentscanYYlineno

Definition at line 19 of file commentscan.cpp.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 3110 of file commentscan.cpp.

#define yyout   commentscanYYout

Definition at line 20 of file commentscan.cpp.

#define yyrealloc   commentscanYYrealloc

Definition at line 25 of file commentscan.cpp.

#define yyrestart   commentscanYYrestart

Definition at line 21 of file commentscan.cpp.

#define YYSTATE   YY_START

Definition at line 151 of file commentscan.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 7503 of file commentscan.cpp.

#define yyterminate

(

)

return YY_NULL

Definition at line 4233 of file commentscan.cpp.

#define yytext   commentscanYYtext

Definition at line 22 of file commentscan.cpp.

#define yytext_ptr   commentscanYYtext

Definition at line 368 of file commentscan.cpp.

#define yywrap   commentscanYYwrap

Definition at line 23 of file commentscan.cpp.

Typedef Documentation

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

Definition at line 3239 of file commentscan.cpp.

typedef short int flex_int16_t

Definition at line 71 of file commentscan.cpp.

typedef int flex_int32_t

Definition at line 72 of file commentscan.cpp.

typedef signed char flex_int8_t

Definition at line 70 of file commentscan.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file commentscan.cpp.

typedef unsigned int flex_uint32_t

Definition at line 75 of file commentscan.cpp.

typedef unsigned char flex_uint8_t

Definition at line 73 of file commentscan.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 172 of file commentscan.cpp.

typedef unsigned char YY_CHAR

Definition at line 357 of file commentscan.cpp.

typedef size_t yy_size_t

Definition at line 203 of file commentscan.cpp.

typedef int yy_state_type

Definition at line 361 of file commentscan.cpp.

Enumeration Type Documentation

enum GuardType

Enumerator
Guard_If
Guard_IfNot
Guard_Skip

Definition at line 3466 of file commentscan.cpp.

{
  Guard_If,
  Guard_IfNot,
  Guard_Skip
};

enum OutputContext

Enumerator
OutputDoc
OutputBrief
OutputXRef
OutputInbody

Definition at line 3458 of file commentscan.cpp.

{
  OutputDoc,
  OutputBrief,
  OutputXRef,
  OutputInbody
};

enum XRefKind

Enumerator
XRef_Item
XRef_Todo
XRef_Test
XRef_Bug
XRef_Deprecated
XRef_None

Definition at line 3448 of file commentscan.cpp.

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

Function Documentation

static void addAnchor ( const char *  anchor )

static

Definition at line 3950 of file commentscan.cpp.

{
  SectionInfo *si = Doxygen::sectionDict->find(anchor);
  if (si)
  {
    if (si->lineNr != -1)
    {
      warn(yyFileName,yyLineNr,"multiple use of section label '%s' while adding anchor, (first occurrence: %s, line %d)",anchor,si->fileName.data(),si->lineNr);
    }
    else
    {
      warn(yyFileName,yyLineNr,"multiple use of section label '%s' while adding anchor, (first occurrence: %s)",anchor,si->fileName.data());
    }
  }
  else
  {
    si = new SectionInfo(yyFileName,yyLineNr,anchor,0,SectionInfo::Anchor,0);
    Doxygen::sectionDict->append(anchor,si);
    current->anchors->append(si);
  }
}

static void addCite ( )

static

Definition at line 3810 of file commentscan.cpp.

{
  Doxygen::citeDict->insert(commentscanYYtext);
}

static QCString addFormula ( )

static

Definition at line 3743 of file commentscan.cpp.

{
  QCString formLabel;
  QCString fText=formulaText.simplifyWhiteSpace();
  Formula *f=0;
  if ((f=Doxygen::formulaDict->find(fText))==0)
  {
    f = new Formula(fText);
    Doxygen::formulaList->append(f);
    Doxygen::formulaDict->insert(fText,f);
    formLabel.sprintf("\\form#%d",f->getId());
    Doxygen::formulaNameDict->insert(formLabel,f);
  }
  else
  {
    formLabel.sprintf("\\form#%d",f->getId());
  }
  int i;
  for (i=0;i<formulaNewLines;i++) formLabel+="@_fakenl"; // add fake newlines to
                                                         // keep the warnings 
                                                         // correctly aligned.
  return formLabel;
}

static void addOutput ( const char *  s )

inlinestatic

Definition at line 3973 of file commentscan.cpp.

{
  //printf("addOutput(%s)\n",s);
  *pOutputString+=s;
}

static void addOutput ( char  c )

inlinestatic

Definition at line 3980 of file commentscan.cpp.

{
  *pOutputString+=c;
}

static void addSection ( )

static

Definition at line 3778 of file commentscan.cpp.

{
  SectionInfo *si = Doxygen::sectionDict->find(g_sectionLabel);
  if (si)
  {
    if (si->lineNr != -1)
    {
      warn(yyFileName,yyLineNr,"multiple use of section label '%s' while adding section, (first occurrence: %s, line %d)",g_sectionLabel.data(),si->fileName.data(),si->lineNr);
    }
    else
    {
      warn(yyFileName,yyLineNr,"multiple use of section label '%s' while adding section, (first occurrence: %s)",g_sectionLabel.data(),si->fileName.data());
    }
  }
  else
  {
    // create a new section element
    g_sectionTitle+=commentscanYYtext;
    g_sectionTitle=g_sectionTitle.stripWhiteSpace();
    si = new SectionInfo(yyFileName,yyLineNr,g_sectionLabel,
                          g_sectionTitle,sectionLevelToType(g_sectionLevel),g_sectionLevel);

    // add section to this entry
    current->anchors->append(si);

    // add section to the global dictionary
    Doxygen::sectionDict->append(g_sectionLabel,si);
  }
}

static void addXRefItem ( const char *  listName, const char *  itemTitle, const char *  listTitle, bool  append  )

static

Definition at line 3640 of file commentscan.cpp.

{
  Entry *docEntry = current; // inBody && previous ? previous : current;
  if (listName==0) return;
  //printf("addXRefItem(%s,%s,%s,%d)\n",listName,itemTitle,listTitle,append);

  ListItemInfo *lii=0;
  RefList *refList = Doxygen::xrefLists->find(listName);
  if (refList==0) // new list
  {
    refList = new RefList(listName,listTitle,itemTitle);
    Doxygen::xrefLists->insert(listName,refList);
    //printf("new list!\n");
  }
  if (docEntry->sli)
  {
    QListIterator<ListItemInfo> slii(*docEntry->sli);
    for (slii.toFirst();(lii=slii.current());++slii)
    {
      if (qstrcmp(lii->type,listName)==0) 
      {
        //printf("found %s lii->type=%s\n",listName,lii->type);
        break;
      }
    }
  }
  if (lii && append) // already found item of same type just before this one
  {
    //printf("listName=%s item id = %d existing\n",listName,lii->itemId);
    RefItem *item = refList->getRefItem(lii->itemId);
    ASSERT(item!=0);
    item->text += " <p>";
    if (Doxygen::markdownSupport)
    {
      item->text += processMarkdown(yyFileName,yyLineNr,current,outputXRef);
    }
    else
    {
      item->text += outputXRef;
    }
    //printf("%s: text +=%s\n",listName,item->text.data());
  }
  else // new item
  {
    int itemId  = refList->addRefItem();
    //printf("listName=%s item id = %d new current=%p\n",listName,itemId,current);

    // if we have already an item from the same list type (e.g. a second @todo)
    // in the same Entry (i.e. lii!=0) then we reuse its link anchor.
    char anchorLabel[1024];
    //sprintf(anchorLabel,"_%s%06d",listName,lii ? lii->itemId : itemId);
    sprintf(anchorLabel,"_%s%06d",listName,itemId);
    RefItem *item = refList->getRefItem(itemId);
    ASSERT(item!=0);
    if (Doxygen::markdownSupport)
    {
      item->text = processMarkdown(yyFileName,yyLineNr,current,outputXRef);
    }
    else
    {
      item->text = outputXRef;
    }
    item->listAnchor = anchorLabel;
    docEntry->addSpecialListItem(listName,itemId);
    QCString cmdString;
    cmdString.sprintf("\\xrefitem %s %d.",listName,itemId);
    if (inBody)
    {
      docEntry->inbodyDocs += cmdString;
    }
    else
    {
      docEntry->doc += cmdString;
    }
    SectionInfo *si = Doxygen::sectionDict->find(anchorLabel);
    if (si)
    {
      if (si->lineNr != -1)
      {
        warn(listName,yyLineNr,"multiple use of section label '%s', (first occurrence: %s, line %d)",anchorLabel,si->fileName.data(),si->lineNr);
      }
      else
      {
        warn(listName,yyLineNr,"multiple use of section label '%s', (first occurrence: %s)",anchorLabel,si->fileName.data());
      }
    }
    else
    {
      si=new SectionInfo(listName,yyLineNr,anchorLabel,
                         g_sectionTitle,SectionInfo::Anchor,
                         g_sectionLevel);
      Doxygen::sectionDict->append(anchorLabel,si);
      docEntry->anchors->append(si);
    }
  }
  outputXRef.resize(0);
}

static void checkFormula ( )

static

Definition at line 8139 of file commentscan.cpp.

{
  if (YY_START==ReadFormulaShort || YY_START==ReadFormulaLong)
  {
    warn(yyFileName,yyLineNr,"End of comment block while inside formula.");
  }
}

void closeGroup	(	Entry *	e,
		const char *	file,
		int	line,
		bool	foundInline = FALSE
	)

Definition at line 8382 of file commentscan.cpp.

{
  //printf("==> closeGroup(name=%s,sec=%x,file=%s,line=%d) g_autoGroupStack=%d\n",
  //    e->name.data(),e->section,fileName,line,g_autoGroupStack.count());
  if (g_memberGroupId!=DOX_NOGROUP) // end of member group
  {
    MemberGroupInfo *info=Doxygen::memGrpInfoDict.find(g_memberGroupId);
    if (info) // known group
    {
      info->doc = g_memberGroupDocs;
      info->docFile = fileName;
      info->docLine = line;
    }
    g_memberGroupId=DOX_NOGROUP;
    g_memberGroupRelates.resize(0);
    g_memberGroupDocs.resize(0);
    if (!foundInline) e->mGrpId=DOX_NOGROUP;
    //printf("new group id=%d\n",g_memberGroupId);
  }
  else if (!g_autoGroupStack.isEmpty()) // end of auto group
  {
    Grouping *grp = g_autoGroupStack.pop();
    // see bug577005: we should not remove the last group for e
    if (!foundInline) e->groups->removeLast();
    //printf("Removing %s e=%p\n",grp->groupname.data(),e);
    delete grp;
    if (!foundInline) initGroupInfo(e);
  }
}

YY_BUFFER_STATE commentscanYY_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Definition at line 7010 of file commentscan.cpp.

{
        YY_BUFFER_STATE b;
    
        b = (YY_BUFFER_STATE) commentscanYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in commentscanYY_create_buffer()" );

        b->yy_buf_size = size;

        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
        b->yy_ch_buf = (char *) commentscanYYalloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR( "out of dynamic memory in commentscanYY_create_buffer()" );

        b->yy_is_our_buffer = 1;

        commentscanYY_init_buffer(b,file );

        return b;
}

void commentscanYY_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with commentscanYY_create_buffer()

Definition at line 7038 of file commentscan.cpp.

{
    
        if ( ! b )
                return;

        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

        if ( b->yy_is_our_buffer )
                commentscanYYfree((void *) b->yy_ch_buf  );

        commentscanYYfree((void *) b  );
}

void commentscanYY_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 7085 of file commentscan.cpp.

{
        if ( ! b )
                return;

        b->yy_n_chars = 0;

        /* We always need two end-of-buffer characters.  The first causes
         * a transition to the end-of-buffer state.  The second causes
         * a jam in that state.
         */
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

        b->yy_buf_pos = &b->yy_ch_buf[0];

        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;

        if ( b == YY_CURRENT_BUFFER )
                commentscanYY_load_buffer_state( );
}

static void commentscanYY_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 7057 of file commentscan.cpp.

{
        int oerrno = errno;
    
        commentscanYY_flush_buffer(b );

        b->yy_input_file = file;
        b->yy_fill_buffer = 1;

    /* If b is the current buffer, then commentscanYY_init_buffer was _probably_
     * called from commentscanYYrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = 0;
    
        errno = oerrno;
}

static void commentscanYY_load_buffer_state ( void  )

static

Definition at line 6996 of file commentscan.cpp.

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
        commentscanYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
        (yy_hold_char) = *(yy_c_buf_p);
}

YY_BUFFER_STATE commentscanYY_scan_buffer	(	char *	base,
		yy_size_t	size
	)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters

base	the character buffer
size	the size in bytes of the character buffer

Returns

the newly allocated buffer state object.

Definition at line 7212 of file commentscan.cpp.

{
        YY_BUFFER_STATE b;
    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;

        b = (YY_BUFFER_STATE) commentscanYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in commentscanYY_scan_buffer()" );

        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
        b->yy_buf_pos = b->yy_ch_buf = base;
        b->yy_is_our_buffer = 0;
        b->yy_input_file = 0;
        b->yy_n_chars = b->yy_buf_size;
        b->yy_is_interactive = 0;
        b->yy_at_bol = 1;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;

        commentscanYY_switch_to_buffer(b  );

        return b;
}

YY_BUFFER_STATE commentscanYY_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

Setup the input buffer state to scan the given bytes. The next call to commentscanYYlex() will scan from a copy of bytes.

Parameters

bytes	the byte buffer to scan
len	the number of bytes in the buffer pointed to by bytes.

Returns

the newly allocated buffer state object.

Definition at line 7262 of file commentscan.cpp.

{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
    
        /* Get memory for full buffer, including space for trailing EOB's. */
        n = _yybytes_len + 2;
        buf = (char *) commentscanYYalloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in commentscanYY_scan_bytes()" );

        for ( i = 0; i < _yybytes_len; ++i )
                buf[i] = yybytes[i];

        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

        b = commentscanYY_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in commentscanYY_scan_bytes()" );

        /* It's okay to grow etc. this buffer, and we should throw it
         * away when we're done.
         */
        b->yy_is_our_buffer = 1;

        return b;
}

YY_BUFFER_STATE commentscanYY_scan_string

(

yyconst char *

yystr

)

Setup the input buffer state to scan a string. The next call to commentscanYYlex() will scan from a copy of str.

Parameters

yystr

a NUL-terminated string to scan

Returns

the newly allocated buffer state object.

Note

If you want to scan bytes that may contain NUL values, then use commentscanYY_scan_bytes() instead.

Definition at line 7249 of file commentscan.cpp.

{
    
        return commentscanYY_scan_bytes(yystr,strlen(yystr) );
}

void commentscanYY_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 6965 of file commentscan.cpp.

{
    
        /* TODO. We should be able to replace this entire function body
         * with
         *              commentscanYYpop_buffer_state();
         *              commentscanYYpush_buffer_state(new_buffer);
     */
        commentscanYYensure_buffer_stack ();
        if ( YY_CURRENT_BUFFER == new_buffer )
                return;

        if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
                *(yy_c_buf_p) = (yy_hold_char);
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        YY_CURRENT_BUFFER_LVALUE = new_buffer;
        commentscanYY_load_buffer_state( );

        /* We don't actually know whether we did this switch during
         * EOF (commentscanYYwrap()) processing, but the only time this flag
         * is looked at is after commentscanYYwrap() is called, so it's safe
         * to go ahead and always set it.
         */
        (yy_did_buffer_switch_on_eof) = 1;
}

void * commentscanYYalloc

(

yy_size_t

size

)

Definition at line 7481 of file commentscan.cpp.

{
        return (void *) malloc( size );
}

static void commentscanYYensure_buffer_stack ( void  )

static

Definition at line 7163 of file commentscan.cpp.

{
        int num_to_alloc;
    
        if (!(yy_buffer_stack)) {

                /* First allocation is just for 2 elements, since we don't know if this
                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
                 * immediate realloc on the next call.
         */
                num_to_alloc = 1;
                (yy_buffer_stack) = (struct yy_buffer_state**)commentscanYYalloc
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in commentscanYYensure_buffer_stack()" );
                                                                  
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                                
                (yy_buffer_stack_max) = num_to_alloc;
                (yy_buffer_stack_top) = 0;
                return;
        }

        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

                /* Increase the buffer to prepare for a possible push. */
                int grow_size = 8 /* arbitrary grow size */;

                num_to_alloc = (yy_buffer_stack_max) + grow_size;
                (yy_buffer_stack) = (struct yy_buffer_state**)commentscanYYrealloc
                                                                ((yy_buffer_stack),
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in commentscanYYensure_buffer_stack()" );

                /* zero only the new slots.*/
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
                (yy_buffer_stack_max) = num_to_alloc;
        }
}

void commentscanYYfree

(

void *

ptr

)

Definition at line 7498 of file commentscan.cpp.

{
        free( (char *) ptr );   /* see commentscanYYrealloc() for (char *) cast */
}

int commentscanYYget_debug

(

void

)

Definition at line 7389 of file commentscan.cpp.

{
        return commentscanYY_flex_debug;
}

YY_EXTRA_TYPE commentscanYYget_extra

(

void

)

FILE * commentscanYYget_in

(

void

)

Get the input stream.

Definition at line 7333 of file commentscan.cpp.

{
        return commentscanYYin;
}

int commentscanYYget_leng

(

void

)

Get the length of the current token.

Definition at line 7349 of file commentscan.cpp.

{
        return commentscanYYleng;
}

int commentscanYYget_lineno

(

void

)

Get the current line number.

Definition at line 7324 of file commentscan.cpp.

{
        
    return commentscanYYlineno;
}

FILE * commentscanYYget_out

(

void

)

Get the output stream.

Definition at line 7341 of file commentscan.cpp.

{
        return commentscanYYout;
}

char * commentscanYYget_text

(

void

)

Get the current token.

Definition at line 7358 of file commentscan.cpp.

{
        return commentscanYYtext;
}

int commentscanYYlex

(

void

)

int commentscanYYlex_destroy

(

void

)

Definition at line 7433 of file commentscan.cpp.

{
    
    /* Pop the buffer stack, destroying each element. */
        while(YY_CURRENT_BUFFER){
                commentscanYY_delete_buffer(YY_CURRENT_BUFFER  );
                YY_CURRENT_BUFFER_LVALUE = NULL;
                commentscanYYpop_buffer_state();
        }

        /* Destroy the stack itself. */
        commentscanYYfree((yy_buffer_stack) );
        (yy_buffer_stack) = NULL;

    commentscanYYfree ( (yy_state_buf) );
    (yy_state_buf)  = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * commentscanYYlex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

void commentscanYYpop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 7144 of file commentscan.cpp.

{
        if (!YY_CURRENT_BUFFER)
                return;

        commentscanYY_delete_buffer(YY_CURRENT_BUFFER );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        if ((yy_buffer_stack_top) > 0)
                --(yy_buffer_stack_top);

        if (YY_CURRENT_BUFFER) {
                commentscanYY_load_buffer_state( );
                (yy_did_buffer_switch_on_eof) = 1;
        }
}

void commentscanYYpush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

Definition at line 7114 of file commentscan.cpp.

{
        if (new_buffer == NULL)
                return;

        commentscanYYensure_buffer_stack();

        /* This block is copied from commentscanYY_switch_to_buffer. */
        if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
                *(yy_c_buf_p) = (yy_hold_char);
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        /* Only push if top exists. Otherwise, replace top. */
        if (YY_CURRENT_BUFFER)
                (yy_buffer_stack_top)++;
        YY_CURRENT_BUFFER_LVALUE = new_buffer;

        /* copied from commentscanYY_switch_to_buffer. */
        commentscanYY_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
}

void * commentscanYYrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 7486 of file commentscan.cpp.

{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
         * because both ANSI C and C++ allow castless assignment from
         * any pointer type to void*, and deal with argument conversions
         * as though doing an assignment.
         */
        return (void *) realloc( (char *) ptr, size );
}

void commentscanYYrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 6948 of file commentscan.cpp.

{
    
        if ( ! YY_CURRENT_BUFFER ){
        commentscanYYensure_buffer_stack ();
                YY_CURRENT_BUFFER_LVALUE =
            commentscanYY_create_buffer(commentscanYYin,YY_BUF_SIZE );
        }

        commentscanYY_init_buffer(YY_CURRENT_BUFFER,input_file );
        commentscanYY_load_buffer_state( );
}

void commentscanYYset_debug

(

int

debug_flag

)

Definition at line 7394 of file commentscan.cpp.

{
        commentscanYY_flex_debug = bdebug ;
}

void commentscanYYset_extra

(

YY_EXTRA_TYPE

user_defined

)

void commentscanYYset_in

(

FILE *

in_str

)

Set the input stream. This does not discard the current input buffer.

Parameters

in_str

A readable stream.

See also

commentscanYY_switch_to_buffer

Definition at line 7379 of file commentscan.cpp.

{
        commentscanYYin = in_str ;
}

void commentscanYYset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

Definition at line 7367 of file commentscan.cpp.

{
    
    commentscanYYlineno = line_number;
}

void commentscanYYset_out

(

FILE *

out_str

)

Definition at line 7384 of file commentscan.cpp.

{
        commentscanYYout = out_str ;
}

static void endBrief ( bool  addToOutput = TRUE )

static

Definition at line 3985 of file commentscan.cpp.

{
  if (!current->brief.stripWhiteSpace().isEmpty())
  { // only go to the detailed description if we have
    // found some brief description and not just whitespace
    briefEndsAtDot=FALSE;
    setOutput(OutputDoc);
    if (addToOutput) addOutput(commentscanYYtext);
  }
}

static int findExistingGroup ( int &  groupId, const MemberGroupInfo *  info  )

static

Definition at line 8334 of file commentscan.cpp.

{
  //printf("findExistingGroup %s:%s\n",info->header.data(),info->compoundName.data());
  QIntDictIterator<MemberGroupInfo> di(Doxygen::memGrpInfoDict);
  MemberGroupInfo *mi;
  for (di.toFirst();(mi=di.current());++di)
  {
    if (g_compoundName==mi->compoundName &&  // same file or scope
        !mi->header.isEmpty() &&             // not a nameless group
        qstricmp(mi->header,info->header)==0  // same header name
       )
    {
      //printf("Found it!\n");
      return (int)di.currentKey(); // put the item in this group
    }
  }
  groupId++; // start new group
  return groupId;
}

static bool getDocSectionName ( int  s )

static

Definition at line 3570 of file commentscan.cpp.

{
  switch(s)
  {
    case Entry::CLASSDOC_SEC:
    case Entry::STRUCTDOC_SEC:
    case Entry::UNIONDOC_SEC:
    case Entry::EXCEPTIONDOC_SEC:
    case Entry::NAMESPACEDOC_SEC:
    case Entry::PROTOCOLDOC_SEC:
    case Entry::CATEGORYDOC_SEC:
    case Entry::ENUMDOC_SEC:
    case Entry::PAGEDOC_SEC:
    case Entry::VARIABLEDOC_SEC:
    case Entry::MEMBERDOC_SEC:
    case Entry::OVERLOADDOC_SEC:
    case Entry::FILEDOC_SEC:
    case Entry::DEFINEDOC_SEC:
    case Entry::GROUPDOC_SEC:
    case Entry::MAINPAGEDOC_SEC:
    case Entry::PACKAGEDOC_SEC:
    case Entry::DIRDOC_SEC:
    case Entry::EXAMPLE_SEC:
    case Entry::MEMBERGRP_SEC:
      return TRUE;
    default: 
      return FALSE;
  }
}

static void groupAddDocs ( Entry *  e )

static

Definition at line 8427 of file commentscan.cpp.

{
  if (e->section==Entry::MEMBERGRP_SEC)
  {
    g_memberGroupDocs=e->brief.stripWhiteSpace();
    e->doc = stripLeadingAndTrailingEmptyLines(e->doc,e->docLine);
    if (!g_memberGroupDocs.isEmpty() && !e->doc.isEmpty())
    {
      g_memberGroupDocs+="\n\n";
    }
    g_memberGroupDocs+=e->doc;
    MemberGroupInfo *info=Doxygen::memGrpInfoDict.find(g_memberGroupId);
    if (info) 
    {
      info->doc = g_memberGroupDocs;
      info->docFile = e->docFile;
      info->docLine = e->docLine;
      info->setRefItems(e->sli);
    }
    e->doc.resize(0);
    e->brief.resize(0);
  }
}

void groupEnterCompound	(	const char *	fileName,
		int	line,
		const char *	name
	)

Definition at line 8299 of file commentscan.cpp.

{
  if (g_memberGroupId!=DOX_NOGROUP)
  {
    warn(fileName,line,"try to put compound %s inside a member group\n",name);
  }
  g_memberGroupId=DOX_NOGROUP;
  g_memberGroupRelates.resize(0);
  g_memberGroupDocs.resize(0);
  g_compoundName = name;
  int i = g_compoundName.find('(');
  if (i!=-1) 
  {
    g_compoundName=g_compoundName.left(i); // strip category (Obj-C)
  }
  if (g_compoundName.isEmpty())
  {
    g_compoundName=fileName;
  }
  //printf("groupEnterCompound(%s)\n",name);
}

void groupEnterFile	(	const char *	fileName,
		int
	)

Definition at line 8274 of file commentscan.cpp.

{
  g_autoGroupStack.setAutoDelete(TRUE);
  g_autoGroupStack.clear();
  g_memberGroupId = DOX_NOGROUP;
  g_memberGroupDocs.resize(0);
  g_memberGroupRelates.resize(0);
  g_compoundName=fileName;
}

void groupLeaveCompound	(	const char *	,
		int	,
		const char *
	)

Definition at line 8321 of file commentscan.cpp.

{
  //printf("groupLeaveCompound(%s)\n",name);
  //if (g_memberGroupId!=DOX_NOGROUP)
  //{
  //  warn(fileName,line,"end of compound %s while inside a member group\n",name);
  //}
  g_memberGroupId=DOX_NOGROUP;
  g_memberGroupRelates.resize(0);
  g_memberGroupDocs.resize(0);
  g_compoundName.resize(0);
}

void groupLeaveFile	(	const char *	fileName,
		int	line
	)

Definition at line 8284 of file commentscan.cpp.

{
  //if (g_memberGroupId!=DOX_NOGROUP)
  //{
  //  warn(fileName,line,"end of file while inside a member group\n");
  //}
  g_memberGroupId=DOX_NOGROUP;
  g_memberGroupRelates.resize(0);
  g_memberGroupDocs.resize(0);
  if (!g_autoGroupStack.isEmpty())
  {
    warn(fileName,line,"end of file while inside a group\n");
  }
}

static bool handleAddIndex ( const QCString &  )

static

Definition at line 7870 of file commentscan.cpp.

{
  addOutput("@addindex ");
  BEGIN(LineParam);
  return FALSE;
}

static bool handleAddToGroup ( const QCString &  )

static

Definition at line 7557 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::GROUPDOC_SEC);
  current->groupDocType = Entry::GROUPDOC_ADD;
  BEGIN( GroupDocArg1 );
  return stop;
}

static bool handleAnchor ( const QCString &  s )

static

Definition at line 7841 of file commentscan.cpp.

{
  addOutput("@"+s+" ");
  BEGIN(AnchorLabel);
  return FALSE;
}

static bool handleBrief ( const QCString &  )

static

Definition at line 7511 of file commentscan.cpp.

{
  //printf("handleBrief\n");
  setOutput(OutputBrief);
  return FALSE;
}

static bool handleBug ( const QCString &  )

static

Definition at line 7729 of file commentscan.cpp.

{
  newXRefKind = XRef_Bug;
  setOutput(OutputXRef);
  xrefKind = XRef_Bug;
  return FALSE;
}

static bool handleCallergraph ( const QCString &  )

static

Definition at line 7982 of file commentscan.cpp.

{
  current->callerGraph = TRUE; // ON
  return FALSE;
}

static bool handleCallgraph ( const QCString &  )

static

Definition at line 7970 of file commentscan.cpp.

{
  current->callGraph = TRUE; // ON
  return FALSE;
}

static bool handleCategory ( const QCString &  )

static

Definition at line 7607 of file commentscan.cpp.

{ // Obj-C category
  bool stop=makeStructuralIndicator(Entry::CATEGORYDOC_SEC);
  BEGIN( CategoryDocArg1 ); 
  return stop;
}

static bool handleCite ( const QCString &  s )

static

Definition at line 7848 of file commentscan.cpp.

{
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("@"+s+" ");
  BEGIN(CiteLabel);
  return FALSE;
}

static bool handleClass ( const QCString &  )

static

Definition at line 7587 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::CLASSDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handleCopyBrief ( const QCString &  )

static

Definition at line 8094 of file commentscan.cpp.

{
  if (current->brief.isEmpty() && current->doc.isEmpty())
  { // if we don't have a brief or detailed description yet,
    // then the @copybrief should end up in the brief description.
    // otherwise it will be copied inline (see bug691315 & bug700788)
    setOutput(OutputBrief);
  }
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("\\copybrief ");
  return FALSE;
}

static bool handleCopyDetails ( const QCString &  )

static

Definition at line 8111 of file commentscan.cpp.

{
  setOutput(OutputDoc);
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("\\copydetails ");
  return FALSE;
}

static bool handleCopyDoc ( const QCString &  )

static

Definition at line 8123 of file commentscan.cpp.

{
  setOutput(OutputBrief);
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("\\copybrief ");
  g_copyDocArg.resize(0);
  BEGIN(CopyDoc);
  return FALSE;
}

static bool handleDef ( const QCString &  )

static

Definition at line 7527 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::DEFINEDOC_SEC);
  functionProto.resize(0);
  BEGIN(FnParam);
  return stop;
}

static bool handleDefGroup ( const QCString &  )

static

Definition at line 7549 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::GROUPDOC_SEC);
  current->groupDocType = Entry::GROUPDOC_NORMAL;
  BEGIN( GroupDocArg1 );
  return stop;
}

static bool handleDeprecated ( const QCString &  )

static

Definition at line 7737 of file commentscan.cpp.

{
  newXRefKind = XRef_Deprecated;
  setOutput(OutputXRef);
  xrefKind = XRef_Deprecated;
  return FALSE;
}

static bool handleDetails ( const QCString &  )

static

Definition at line 7687 of file commentscan.cpp.

{
  if (inContext!=OutputBrief)
  {
    addOutput("\n\n"); // treat @details outside brief description
                       // as a new paragraph
  }
  setOutput(OutputDoc);
  return FALSE;
}

static bool handleDir ( const QCString &  )

static

Definition at line 7671 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::DIRDOC_SEC);
  if (!stop) current->name = yyFileName;
  BEGIN( FileDocArg1 );
  return stop;
}

static bool handleElse ( const QCString &  )

static

Definition at line 7910 of file commentscan.cpp.

{
  if (guards.isEmpty())
  {
    warn(yyFileName,yyLineNr,
        "found \\else without matching start command");
  }
  else
  {
    BEGIN( SkipGuardedSection );
  }
  return FALSE;
}

static bool handleElseIf ( const QCString &  )

static

Definition at line 7895 of file commentscan.cpp.

{
  if (guards.isEmpty())
  {
    warn(yyFileName,yyLineNr,
        "found \\else without matching start command");
  }
  else
  {
    guardType = enabledSectionFound ? Guard_Skip : Guard_If;
    BEGIN(GuardParam);
  }
  return FALSE;
}

static bool handleEndIf ( const QCString &  )

static

Definition at line 7924 of file commentscan.cpp.

{
  if (guards.isEmpty())
  {
    warn(yyFileName,yyLineNr,
        "found \\endif without matching start command");
  }
  else
  {
    delete guards.pop();
  }
  enabledSectionFound=FALSE;
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  BEGIN( GuardParamEnd );
  return FALSE;
}

static bool handleEndParBlock ( const QCString &  )

static

Definition at line 7769 of file commentscan.cpp.

{
  if (!g_insideParBlock)
  {
    warn(yyFileName,yyLineNr,
        "found \\endparblock command without matching \\parblock!");
  }
  addOutput("@endparblock");
  setOutput(OutputDoc); // to end a parblock inside a xrefitem like context
  g_insideParBlock = FALSE;
  return FALSE;
}

static bool handleEnum ( const QCString &  )

static

Definition at line 7542 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::ENUMDOC_SEC);
  BEGIN(EnumDocArg1);
  return stop;
}

static bool handleExample ( const QCString &  )

static

Definition at line 7679 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::EXAMPLE_SEC);
  if (!stop) current->name = yyFileName;
  BEGIN( FileDocArg1 );
  return stop;
}

static bool handleExtends ( const QCString &  )

static

Definition at line 8088 of file commentscan.cpp.

{
  BEGIN(ExtendsParam);
  return FALSE;
}

static bool handleFile ( const QCString &  )

static

Definition at line 7660 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::FILEDOC_SEC);
  if (!stop) 
  {
    current->name = yyFileName;
  }
  BEGIN( FileDocArg1 );
  return stop;
}

static bool handleFn ( const QCString &  )

static

Definition at line 7518 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::MEMBERDOC_SEC);
  functionProto.resize(0);
  braceCount=0;
  BEGIN(FnParam);
  return stop;
}

static bool handleFormatBlock ( const QCString &  s )

static

Definition at line 7860 of file commentscan.cpp.

{
  addOutput("@"+s+" ");
  //printf("handleFormatBlock(%s)\n",s.data());
  blockName=s;
  g_commentCount=0;
  BEGIN(FormatBlock);
  return FALSE;
}

static void handleGuard ( const QCString &  expr )

static

Definition at line 8451 of file commentscan.cpp.

{
  CondParser prs;
  bool sectionEnabled=prs.parse(yyFileName,yyLineNr,expr.stripWhiteSpace());
  bool parentEnabled = TRUE;
  if (!guards.isEmpty()) parentEnabled = guards.top()->isEnabled();
  if (parentEnabled)
  {
    if (
        (sectionEnabled && guardType==Guard_If) ||  
        (!sectionEnabled && guardType==Guard_IfNot)
       ) // section is visible
    {
      guards.push(new GuardedSection(TRUE,TRUE));
      enabledSectionFound=TRUE;
      BEGIN( GuardParamEnd );
    }
    else // section is invisible
    {
      if (guardType!=Guard_Skip)
      {
        guards.push(new GuardedSection(FALSE,TRUE));
      }
      BEGIN( SkipGuardedSection );
    }
  }
  else // invisible because of parent
  {
    guards.push(new GuardedSection(FALSE,FALSE));
    BEGIN( SkipGuardedSection );
  }
}

static bool handleHeaderFile ( const QCString &  )

static

Definition at line 7594 of file commentscan.cpp.

{
  BEGIN( ClassDocArg2 );
  return FALSE;
}

static bool handleHideCallergraph ( const QCString &  )

static

Definition at line 7988 of file commentscan.cpp.

{
  current->callerGraph = FALSE; // OFF
  return FALSE;
}

static bool handleHideCallgraph ( const QCString &  )

static

Definition at line 7976 of file commentscan.cpp.

{
  current->callGraph = FALSE; // OFF
  return FALSE;
}

static bool handleHideInitializer ( const QCString &  )

static

Definition at line 7964 of file commentscan.cpp.

{
  current->initLines = 0; // OFF
  return FALSE;
}

static bool handleIdlException ( const QCString &  )

static

Definition at line 7635 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::EXCEPTIONDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handleIf ( const QCString &  )

static

Definition at line 7877 of file commentscan.cpp.

{
  enabledSectionFound=FALSE;
  guardType = Guard_If;
  g_spaceBeforeIf = g_spaceBeforeCmd;
  BEGIN(GuardParam);
  return FALSE;
}

static bool handleIfNot ( const QCString &  )

static

Definition at line 7886 of file commentscan.cpp.

{
  enabledSectionFound=FALSE;
  guardType = Guard_IfNot;
  g_spaceBeforeIf = g_spaceBeforeCmd;
  BEGIN(GuardParam);
  return FALSE;
}

static bool handleIngroup ( const QCString &  )

static

Definition at line 7945 of file commentscan.cpp.

{
  inGroupParamFound=FALSE;
  BEGIN( InGroupParam );
  return FALSE;
}

static bool handleInherit ( const QCString &  )

static

Definition at line 8082 of file commentscan.cpp.

{
  BEGIN(InheritParam);
  return FALSE;
}

static bool handleInterface ( const QCString &  )

static

Definition at line 7628 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::INTERFACEDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handleInternal ( const QCString &  )

static

Definition at line 7994 of file commentscan.cpp.

{
  if (!Config_getBool("INTERNAL_DOCS"))
  {
    // make sure some whitespace before a \internal command
    // is not treated as "documentation"
    if (current->doc.stripWhiteSpace().isEmpty())
    { 
      current->doc.resize(0);
    }
    g_condCount=0;
    BEGIN( SkipInternal );
  }
  else
  {
    // re-enabled for bug640828
    addOutput("\\internal "); 
    inInternalDocs = TRUE;
  }
  return FALSE;
}

static bool handleLineBr ( const QCString &  )

static

Definition at line 8016 of file commentscan.cpp.

{
  addOutput('\n');
  return FALSE;
}

static bool handleMainpage ( const QCString &  )

static

Definition at line 7649 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::MAINPAGEDOC_SEC);
  if (!stop) 
  {
    current->name = "mainpage";
  }
  BEGIN( PageDocArg2 );
  return stop;
}

static bool handleMemberOf ( const QCString &  )

static

Definition at line 7795 of file commentscan.cpp.

{
  current->relatesType = MemberOf;
  BEGIN(RelatesParam1);
  return FALSE;
}

static bool handleName ( const QCString &  )

static

Definition at line 7698 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::MEMBERGRP_SEC);
  if (!stop)
  {
    g_memberGroupHeader.resize(0);
    BEGIN( NameParam );
    if (g_memberGroupId!=DOX_NOGROUP) // end of previous member group
    {
      closeGroup(current,yyFileName,yyLineNr,TRUE);
    }
  }
  return stop;
}

static bool handleNamespace ( const QCString &  )

static

Definition at line 7573 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::NAMESPACEDOC_SEC);
  BEGIN( NameSpaceDocArg1 );
  return stop;
}

static bool handleNoSubGrouping ( const QCString &  )

static

Definition at line 7952 of file commentscan.cpp.

{
  current->subGrouping = FALSE; 
  return FALSE;
}

static bool handleOverload ( const QCString &  )

static

Definition at line 7535 of file commentscan.cpp.

{
  functionProto.resize(0);
  BEGIN(OverloadParam);
  return FALSE;
}

static bool handlePackage ( const QCString &  )

static

Definition at line 7580 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::PACKAGEDOC_SEC);
  BEGIN( PackageDocArg1 );
  return stop;
}

static bool handlePage ( const QCString &  )

static

Definition at line 7642 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::PAGEDOC_SEC);
  BEGIN( PageDocArg1 );
  return stop;
}

static bool handleParBlock ( const QCString &  )

static

Definition at line 7752 of file commentscan.cpp.

{
  if (g_insideParBlock)
  {
    warn(yyFileName,yyLineNr,
        "found \\parblock command while already in a parblock!");
  }
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("@parblock ");
  g_insideParBlock = TRUE;
  return FALSE;
}

static bool handlePrivate ( const QCString &  )

static

Definition at line 8036 of file commentscan.cpp.

{
  current->protection = Private;
  return FALSE;
}

static bool handlePrivateSection ( const QCString &  )

static

Definition at line 8042 of file commentscan.cpp.

{
  current->protection = protection = Private;
  return FALSE;
}

static bool handleProtected ( const QCString &  )

static

Definition at line 8048 of file commentscan.cpp.

{
  current->protection = Protected;
  return FALSE;
}

static bool handleProtectedSection ( const QCString &  )

static

Definition at line 8054 of file commentscan.cpp.

{
  current->protection = protection = Protected ;
  return FALSE;
}

static bool handleProtocol ( const QCString &  )

static

Definition at line 7600 of file commentscan.cpp.

{ // Obj-C protocol
  bool stop=makeStructuralIndicator(Entry::PROTOCOLDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handlePublic ( const QCString &  s )

static

Definition at line 8060 of file commentscan.cpp.

{
  current->protection = Public;
  return FALSE;
}

static bool handlePublicSection ( const QCString &  s )

static

Definition at line 8066 of file commentscan.cpp.

{
  current->protection = protection = Public;
  return FALSE;
}

static bool handlePure ( const QCString &  )

static

Definition at line 8029 of file commentscan.cpp.

{
  endBrief();
  current->virt = Pure; 
  return FALSE;
}

static bool handleRefItem ( const QCString &  )

static

Definition at line 7802 of file commentscan.cpp.

{
  addOutput("@refitem ");
  BEGIN(LineParam);
  return FALSE;
}

static bool handleRelated ( const QCString &  )

static

Definition at line 7782 of file commentscan.cpp.

{
  BEGIN(RelatesParam1);
  return FALSE;
}

static bool handleRelatedAlso ( const QCString &  )

static

Definition at line 7788 of file commentscan.cpp.

{
  current->relatesType = Duplicate;
  BEGIN(RelatesParam1);
  return FALSE;
}

static bool handleSection ( const QCString &  s )

static

Definition at line 7809 of file commentscan.cpp.

{
  setOutput(OutputDoc);
  addOutput("@"+s+" ");
  BEGIN(SectionLabel);
  if      (s=="section")       g_sectionLevel=1;
  else if (s=="subsection")    g_sectionLevel=2;
  else if (s=="subsubsection") g_sectionLevel=3;
  else if (s=="paragraph")     g_sectionLevel=4;
  return FALSE;
}

static bool handleShowInitializer ( const QCString &  )

static

Definition at line 7958 of file commentscan.cpp.

{
  current->initLines = 100000; // ON
  return FALSE;
}

static bool handleStatic ( const QCString &  )

static

Definition at line 8022 of file commentscan.cpp.

{
  endBrief();
  current->stat = TRUE; 
  return FALSE;
}

static bool handleStruct ( const QCString &  )

static

Definition at line 7621 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::STRUCTDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handleSubpage ( const QCString &  s )

static

Definition at line 7821 of file commentscan.cpp.

{
  if (current->section!=Entry::EMPTY_SEC && 
      current->section!=Entry::PAGEDOC_SEC &&
      current->section!=Entry::MAINPAGEDOC_SEC
     )
  {
    warn(yyFileName,yyLineNr,
        "found \\subpage command in a comment block that is not marked as a page!");
  }
  if (!g_spaceBeforeCmd.isEmpty()) 
  {
    addOutput(g_spaceBeforeCmd);
    g_spaceBeforeCmd.resize(0);
  }
  addOutput("@"+s+" ");
  BEGIN(SubpageLabel);
  return FALSE;
}

static bool handleTest ( const QCString &  )

static

Definition at line 7721 of file commentscan.cpp.

{
  newXRefKind = XRef_Test;
  setOutput(OutputXRef);
  xrefKind = XRef_Test;
  return FALSE;
}

static bool handleToc ( const QCString &  s )

static

Definition at line 8072 of file commentscan.cpp.

{
  if (current->section==Entry::PAGEDOC_SEC || 
      current->section==Entry::MAINPAGEDOC_SEC)
  {
    current->stat=TRUE;  // we 'abuse' stat to pass whether or the TOC is enabled
  }
  return FALSE;
}

static bool handleTodo ( const QCString &  )

static

Definition at line 7713 of file commentscan.cpp.

{
  newXRefKind = XRef_Todo;
  setOutput(OutputXRef);
  xrefKind = XRef_Todo;
  return FALSE;
}

static bool handleUnion ( const QCString &  )

static

Definition at line 7614 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::UNIONDOC_SEC);
  BEGIN( ClassDocArg1 ); 
  return stop;
}

static bool handleWeakGroup ( const QCString &  )

static

Definition at line 7565 of file commentscan.cpp.

{
  bool stop=makeStructuralIndicator(Entry::GROUPDOC_SEC);
  current->groupDocType = Entry::GROUPDOC_WEAK;
  BEGIN( GroupDocArg1 );
  return stop;
}

static bool handleXRefItem ( const QCString &  )

static

Definition at line 7745 of file commentscan.cpp.

{
  newXRefKind = XRef_Item;
  BEGIN(XRefItemParam1);
  return FALSE;
}

if

(

!

yy_init

)

Definition at line 4307 of file commentscan.cpp.

                {
                (yy_init) = 1;

#ifdef YY_USER_INIT
                YY_USER_INIT;
#endif

        /* Create the reject buffer large enough to save one state per allowed character. */
        if ( ! (yy_state_buf) )
            (yy_state_buf) = (yy_state_type *)commentscanYYalloc(YY_STATE_BUF_SIZE  );
            if ( ! (yy_state_buf) )
                YY_FATAL_ERROR( "out of dynamic memory in commentscanYYlex()" );

                if ( ! (yy_start) )
                        (yy_start) = 1; /* first start state */

                if ( ! commentscanYYin )
                        commentscanYYin = stdin;

                if ( ! commentscanYYout )
                        commentscanYYout = stdout;

                if ( ! YY_CURRENT_BUFFER ) {
                        commentscanYYensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
                                commentscanYY_create_buffer(commentscanYYin,YY_BUF_SIZE );
                }

                commentscanYY_load_buffer_state( );
                }

void initGroupInfo

(

Entry *

e

)

Definition at line 8412 of file commentscan.cpp.

{
  //printf("==> initGroup(id=%d,related=%s,e=%p)\n",g_memberGroupId,
  //       g_memberGroupRelates.data(),e);
  e->mGrpId     = g_memberGroupId;
  e->relates    = g_memberGroupRelates;
  if (!g_autoGroupStack.isEmpty())
  {
    //printf("Appending group %s to %s: count=%d entry=%p\n",
    //  g_autoGroupStack.top()->groupname.data(),
    //  e->name.data(),e->groups->count(),e);
    e->groups->append(new Grouping(*g_autoGroupStack.top()));
  }
}

static void initParser ( )

static

Definition at line 3560 of file commentscan.cpp.

{
  g_sectionLabel.resize(0);
  g_sectionTitle.resize(0);
  g_memberGroupHeader.resize(0);
  g_insideParBlock = FALSE;
}

static void lineCount ( )

static

Definition at line 3619 of file commentscan.cpp.

{
  for( const char* c = commentscanYYtext ; *c ; ++c )
    yyLineNr += (*c == '\n') ;
}

static bool makeStructuralIndicator ( Entry::Sections  s )

static

Definition at line 3602 of file commentscan.cpp.

{
  //printf("current->section=%x\n",current->section);
  if (getDocSectionName(current->section))
  {
    return TRUE;
  }
  else
  {
    needNewEntry = TRUE;
    current->section = s;
    current->fileName = yyFileName;
    current->startLine = yyLineNr;
    return FALSE;
  }
}

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

Definition at line 8354 of file commentscan.cpp.

{
  //printf("==> openGroup(name=%s,sec=%x) g_autoGroupStack=%d\n",
  //    e->name.data(),e->section,g_autoGroupStack.count());
  if (e->section==Entry::GROUPDOC_SEC) // auto group
  {
    g_autoGroupStack.push(new Grouping(e->name,e->groupingPri()));
  }
  else // start of a member group
  {
    //printf("    membergroup id=%d %s\n",g_memberGroupId,g_memberGroupHeader.data());
    if (g_memberGroupId==DOX_NOGROUP) // no group started yet
    {
      static int curGroupId=0;

      MemberGroupInfo *info = new MemberGroupInfo;
      info->header = g_memberGroupHeader.stripWhiteSpace();
      info->compoundName = g_compoundName;
      g_memberGroupId = findExistingGroup(curGroupId,info);
      //printf("    use membergroup %d\n",g_memberGroupId);
      Doxygen::memGrpInfoDict.insert(g_memberGroupId,info);

      g_memberGroupRelates = e->relates;
      e->mGrpId = g_memberGroupId;
    }
  }
}

bool parseCommentBlock	(	ParserInterface *	parser,
		Entry *	curEntry,
		const QCString &	comment,
		const QCString &	fileName,
		int &	lineNr,
		bool	isBrief,
		bool	isJavaDocStyle,
		bool	isInbody,
		Protection &	prot,
		int &	position,
		bool &	newEntryNeeded
	)

Invokes the comment block parser with the request to parse a single comment block.

Parameters

[in]	parser	The language parse that invoked this function. The comment block parse may invoke ParserInterface::parsePrototype() in order to parse the argument of a @fn command.
[in]	curEntry	The Entry to which the comment block belongs. Any information (like documentation) that is found in the comment block will be stored in this entry.
[in]	comment	A string representing the actual comment block. Note that leading *'s are already stripped from the comment block.
[in]	fileName	The name of the file in which the comment is found. Mainly used for producing warnings.
[in,out]	lineNr	The line number at which the comment block was found. When the function returns it will be set to the last line parsed.
[in]	isBrief	TRUE iff this comment block represents a brief description.
[in]	isJavaDocStyle	TRUE iff this comment block is in "JavaDoc" style. This means that it starts as a brief description until the end of the sentences is found and then proceeds as a detailed description.
[in]	isInbody	TRUE iff this comment block is located in the body of a function.
[in,out]	prot	The protection level in which this comment block was found. Commands in the comment block may override this.
[in,out]	position	The character position within comment where the comment block starts. Typically used in case the comment block contains multiple structural commands.
[out]	newEntryNeeded	Boolean that is TRUE if the comment block parser finds that a the comment block finishes the entry and a new one needs to be started.

Returns

TRUE if the comment requires further processing. The parameter newEntryNeeded will typically be true in this case and position will indicate the offset inside the comment string where to proceed parsing. FALSE indicates no further processing is needed.

Definition at line 8149 of file commentscan.cpp.

{
  //printf("parseCommentBlock() isBrief=%d isAutoBriefOn=%d lineNr=%d\n",
  //    isBrief,isAutoBriefOn,lineNr);

  initParser();
  guards.setAutoDelete(TRUE);
  guards.clear();
  langParser     = parser;
  current        = curEntry;
  if (comment.isEmpty()) return FALSE; // avoid empty strings
  inputString    = comment;
  inputString.append(" ");
  inputPosition  = position;
  yyLineNr       = lineNr;
  yyFileName     = fileName;
  protection     = prot;
  needNewEntry   = FALSE;
  xrefKind       = XRef_None;
  xrefAppendFlag = FALSE;
  insidePre      = FALSE;
  parseMore      = FALSE;
  inBody         = isInbody;
  outputXRef.resize(0);
  setOutput( isBrief || isAutoBriefOn ? OutputBrief : OutputDoc );
  briefEndsAtDot = isAutoBriefOn;
  g_condCount    = 0;
  g_sectionLevel = 0;
  g_spaceBeforeCmd.resize(0);
  g_spaceBeforeIf.resize(0);

  printlex(commentscanYY_flex_debug, TRUE, __FILE__, fileName ? fileName.data(): NULL);
  if (!current->inbodyDocs.isEmpty() && isInbody) // separate in body fragments
  {
    current->inbodyDocs+="\n\n";
  }

  Debug::print(Debug::CommentScan,0,"-----------\nCommentScanner: %s:%d\n"
               "input=[\n%s]\n",qPrint(fileName),lineNr,qPrint(comment)
              );
  
  commentscanYYrestart( commentscanYYin );
  BEGIN( Comment );
  commentscanYYlex();
  setOutput( OutputDoc );

  if (YY_START==OverloadParam) // comment ended with \overload
  {
    addOutput(getOverloadDocs());
  }

  if (!guards.isEmpty())
  {
    warn(yyFileName,yyLineNr,"Documentation block ended in the middle of a conditional section!");
  }

  if (g_insideParBlock)
  {
    warn(yyFileName,yyLineNr,
        "Documentation block ended while inside a \\parblock. Missing \\endparblock");
  }

  current->doc=stripLeadingAndTrailingEmptyLines(current->doc,current->docLine);

  if (current->section==Entry::FILEDOC_SEC && current->doc.isEmpty())
  {
    // to allow a comment block with just a @file command.
    current->doc="\n\n";
  }

  if (current->section==Entry::MEMBERGRP_SEC &&
      g_memberGroupId==DOX_NOGROUP) // @name section but no group started yet
  {
    openGroup(current,yyFileName,yyLineNr);
  }

  if (Doxygen::markdownSupport)
  {
    current->brief      = processMarkdown(fileName,lineNr,current,current->brief);
    current->doc        = processMarkdown(fileName,lineNr,current,current->doc);
    current->inbodyDocs = processMarkdown(fileName,lineNr,current,current->inbodyDocs);
  }

  Debug::print(Debug::CommentScan,0,
               "brief=[line=%d\n%s]\ndocs=[line=%d\n%s]\ninbody=[line=%d\n%s]\n===========\n",
               current->briefLine,qPrint(current->brief),
               current->docLine,qPrint(current->doc),
               current->inbodyLine,qPrint(current->inbodyDocs)
              );
  
  checkFormula();
  prot = protection;
  
  groupAddDocs(curEntry);

  newEntryNeeded = needNewEntry;

  // if we did not proceed during this call, it does not make
  // sense to continue, since we get stuck. See bug 567346 for situations
  // were this happens
  if (parseMore && position==inputPosition) parseMore=FALSE;

  if (parseMore) position=inputPosition; else position=0;

  lineNr = yyLineNr;
  //printf("position=%d parseMore=%d newEntryNeeded=%d\n",
  //  position,parseMore,newEntryNeeded);

  printlex(commentscanYY_flex_debug, FALSE, __FILE__, fileName ? fileName.data(): NULL);
  return parseMore;
}

static SectionInfo::SectionType sectionLevelToType ( int  level )

static

Definition at line 3772 of file commentscan.cpp.

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

static void setOutput ( OutputContext  ctx )

inlinestatic

Definition at line 3831 of file commentscan.cpp.

{
  bool xrefAppendToPrev = xrefAppendFlag;
  // determine append flag for the next item (i.e. the end of this item)
  xrefAppendFlag = !inBody &&
                   inContext==OutputXRef && ctx==OutputXRef && // two consecutive xref items
                   newXRefKind==xrefKind &&                    // of the same kind
                   (xrefKind!=XRef_Item || 
                    newXRefItemKey==xrefItemKey);              // with the same key if \xrefitem
  //printf("%d && %d && %d && (%d || %d)\n",
  //                 inContext==OutputXRef,
  //                 ctx==OutputXRef,
  //                 newXRefKind==xrefKind,
  //                 xrefKind!=XRef_Item,
  //                 newXRefItemKey==xrefItemKey);
      
  //printf("refKind=%d newXRefKind=%d xrefAppendToPrev=%d xrefAppendFlag=%d\n",
  //      xrefKind,newXRefKind,xrefAppendToPrev,xrefAppendFlag);

  //printf("setOutput(inContext=%d ctx=%d)\n",inContext,ctx);
  if (inContext==OutputXRef) // end of XRef section => add the item 
  {
    // See if we can append this new xref item to the previous one.
    // We know this at the start of the next item of the same
    // type and need to remember this until the end of that item.
    switch(xrefKind)
    {
      case XRef_Todo:
        addXRefItem("todo",
                    theTranslator->trTodo(),
                    theTranslator->trTodoList(),
                    xrefAppendToPrev
                   );
        break;
      case XRef_Test:
        addXRefItem("test",
                    theTranslator->trTest(),
                    theTranslator->trTestList(),
                    xrefAppendToPrev
                   );
        break;
      case XRef_Bug:
        addXRefItem("bug",
                    theTranslator->trBug(),
                    theTranslator->trBugList(),
                    xrefAppendToPrev
                   );
        break;
      case XRef_Deprecated:
        addXRefItem("deprecated",
                    theTranslator->trDeprecated(),
                    theTranslator->trDeprecatedList(),
                    xrefAppendToPrev
                   );
        break;
      case XRef_Item:  // user defined list
        addXRefItem(xrefItemKey,
                    xrefItemTitle,
                    xrefListTitle,
                    xrefAppendToPrev
                   );
        break;
      case XRef_None:
        ASSERT(0);
        break;
    }
  }
  xrefItemKey = newXRefItemKey;

  int oldContext = inContext;
  inContext = ctx;
  if (inContext!=OutputXRef && inBody) inContext=OutputInbody;
  switch(inContext)
  {
    case OutputDoc:
      if (oldContext!=inContext)
      {
        stripTrailingWhiteSpace(current->doc);
        if (current->docFile.isEmpty())
        {
          current->docFile = yyFileName;
          current->docLine = yyLineNr;
        }
      }
      pOutputString = &current->doc;
      break;
    case OutputBrief:
      if (oldContext!=inContext)
      {
        if (current->briefFile.isEmpty())
        {
          current->briefFile = yyFileName;
          current->briefLine = yyLineNr;
        }
      }
      if (current->brief.stripWhiteSpace().isEmpty()) // we only want one brief
                                                      // description even if multiple
                                                      // are given...
      {
        pOutputString = &current->brief;
      }
      else
      {
        pOutputString = &current->doc;
        inContext = OutputDoc; // need to switch to detailed docs, see bug 631380
      }
      break;
    case OutputXRef:
      pOutputString = &outputXRef;
      // first item found, so can't append to previous
      //xrefAppendFlag = FALSE;
      break;
    case OutputInbody:
      pOutputString = &current->inbodyDocs;
      break;
  }
}

static QCString stripQuotes ( const char *  s )

static

Definition at line 3626 of file commentscan.cpp.

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

static void stripTrailingWhiteSpace ( QCString &  s )

static

Definition at line 3818 of file commentscan.cpp.

{
  uint len = s.length();
  int i = (int)len-1;
  char c;
  while (i>=0 && ((c = s.at(i))==' ' || c=='\t' || c=='\r')) i--;
  if (i!=(int)len-1) 
  {
    s.resize(i+2); // string up to and including char at pos i and \0 terminator
  }
}

while

(

1

)

Definition at line 4339 of file commentscan.cpp.

                {
                yy_cp = (yy_c_buf_p);

                /* Support of commentscanYYtext. */
                *yy_cp = (yy_hold_char);

                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;

                yy_current_state = (yy_start);
                yy_current_state += YY_AT_BOL();

                (yy_state_ptr) = (yy_state_buf);
                *(yy_state_ptr)++ = yy_current_state;

yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
                                if ( yy_current_state >= 1138 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        *(yy_state_ptr)++ = yy_current_state;
                        ++yy_cp;
                        }
                while ( yy_current_state != 1137 );

yy_find_action:
                yy_current_state = *--(yy_state_ptr);
                (yy_lp) = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backing up */
                for ( ; ; ) /* until we find what rule we matched */
                        {
                        if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
                                {
                                yy_act = yy_acclist[(yy_lp)];
                                        {
                                        (yy_full_match) = yy_cp;
                                        break;
                                        }
                                }
                        --yy_cp;
                        yy_current_state = *--(yy_state_ptr);
                        (yy_lp) = yy_accept[yy_current_state];
                        }

                YY_DO_BEFORE_ACTION;

do_action:      /* This label is used only to access EOF actions. */

                switch ( yy_act )
        { /* beginning of action switch */
case 1:
YY_RULE_SETUP
#line 1020 "commentscan.l"
{ // escaped command
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 2:
YY_RULE_SETUP
#line 1023 "commentscan.l"
{ // escaped command
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 3:
YY_RULE_SETUP
#line 1026 "commentscan.l"
{ // mail address
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 4:
YY_RULE_SETUP
#line 1029 "commentscan.l"
{ // quoted text
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 5:
YY_RULE_SETUP
#line 1032 "commentscan.l"
{ // directory (or chain of commands!)
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 6:
YY_RULE_SETUP
#line 1035 "commentscan.l"
{ // HTML command that ends a brief description
                                          setOutput(OutputDoc);
                                          // continue with the same input
                                          REJECT;
                                        }
        YY_BREAK
case 7:
YY_RULE_SETUP
#line 1040 "commentscan.l"
{ // HTML command that ends a brief description
                                          if (current->lang==SrcLangExt_CSharp)
                                          {
                                            setOutput(OutputDoc);
                                          }
                                          // continue with the same input
                                          REJECT;
                                        }
        YY_BREAK
case 8:
YY_RULE_SETUP
#line 1048 "commentscan.l"
{ // start of a .NET XML style brief description
                                          setOutput(OutputBrief);
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 9:
YY_RULE_SETUP
#line 1052 "commentscan.l"
{ // start of a .NET XML style detailed description
                                          setOutput(OutputDoc);
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 10:
YY_RULE_SETUP
#line 1056 "commentscan.l"
{ // start of a .NET XML style detailed description
                                          addOutput(commentscanYYtext);
                                          setOutput(OutputDoc);
                                        }
        YY_BREAK
case 11:
YY_RULE_SETUP
#line 1060 "commentscan.l"
{ // end of a brief or detailed description
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 12:
YY_RULE_SETUP
#line 1063 "commentscan.l"
{
                                          QCString tag=commentscanYYtext;
                                          int s=tag.find("id=");
                                          if (s!=-1) // command has id attribute
                                          {
                                            char c=tag[s+3];
                                            if (c=='\'' || c=='"') // valid start
                                            {
                                              int e=tag.find(c,s+4);
                                              if (e!=-1) // found matching end
                                              {
                                                QCString id=tag.mid(s+4,e-s-4); // extract id
                                                addAnchor(id);
                                              }
                                            }
                                          }
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 13:
YY_RULE_SETUP
#line 1081 "commentscan.l"
{
                                          insidePre=TRUE;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 14:
YY_RULE_SETUP
#line 1085 "commentscan.l"
{
                                          insidePre=FALSE;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 15:
YY_RULE_SETUP
#line 1089 "commentscan.l"
{ // RCS tag which end a brief description
                                          setOutput(OutputDoc);
                                          REJECT;
                                        }
        YY_BREAK
case 16:
YY_RULE_SETUP
#line 1093 "commentscan.l"
{ 
                                          BEGIN(HtmlComment);
                                        }
        YY_BREAK
case 17:
YY_RULE_SETUP
#line 1096 "commentscan.l"
{
                                          addOutput("\\endinternal "); 
                                          if (!inInternalDocs)
                                            warn(yyFileName,yyLineNr,
                                               "found \\endinternal without matching \\internal"
                                              );
                                          inInternalDocs = FALSE;
                                        }
        YY_BREAK
case 18:
YY_RULE_SETUP
#line 1104 "commentscan.l"
{ // potentially interesting command
                                          // the {B}* in the front was added for bug620924
                                          QCString cmdName = QCString(commentscanYYtext).stripWhiteSpace().data()+1;
                                          DocCmdMapper::Cmd *cmdPtr = DocCmdMapper::map(cmdName);
                                          if (cmdPtr) // special action is required
                                          {
                                            int i=0;
                                            while (commentscanYYtext[i]==' ' || commentscanYYtext[i]=='\t') i++;
                                            g_spaceBeforeCmd = QCString(commentscanYYtext).left(i);
                                            if (cmdPtr->endsBrief && !(inContext==OutputXRef && cmdName=="parblock"))
                                            {
                                              briefEndsAtDot=FALSE;
                                              // this command forces the end of brief description
                                              setOutput(OutputDoc);
                                            }
                                            //if (i>0) addOutput(QCString(commentscanYYtext).left(i)); // removed for bug 689341
                                            if (cmdPtr->func && cmdPtr->func(cmdName))
                                            {
                                              // implicit split of the comment block into two
                                              // entries. Restart the next block at the start
                                              // of this command.
                                              parseMore=TRUE;

                                              // yuk, this is probably not very portable across lex implementations, 
                                              // but we need to know the position in the input buffer where this 
                                              // rule matched.
                                              // for flex 2.5.33+ we should use YY_CURRENT_BUFFER_LVALUE
#if YY_FLEX_MAJOR_VERSION>=2 && (YY_FLEX_MINOR_VERSION>5 || (YY_FLEX_MINOR_VERSION==5 && YY_FLEX_SUBMINOR_VERSION>=33))
                                              inputPosition=prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf);
#else
                                              inputPosition=prevPosition + (int)(yy_bp - yy_current_buffer->yy_ch_buf);
#endif
                                              yyterminate();
                                            }
                                            else if (cmdPtr->func==0)
                                            {
                                              // command without handler, to be processed
                                              // later by parsedoc.cpp
                                              addOutput(commentscanYYtext);
                                            }
                                          }
                                          else // command not relevant
                                          {
                                            addOutput(commentscanYYtext);
                                          }
                                        }
        YY_BREAK
case 19:
YY_RULE_SETUP
#line 1150 "commentscan.l"
{ // escaped formula command
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 20:
YY_RULE_SETUP
#line 1153 "commentscan.l"
{ // language switch command
                                          QCString langId = QString(commentscanYYtext).stripWhiteSpace().data()+2;
                                          if (!langId.isEmpty() &&
                                              qstricmp(Config_getEnum("OUTPUT_LANGUAGE"),langId)!=0)
                                          { // enable language specific section
                                            BEGIN(SkipLang);
                                          }
                                        }
        YY_BREAK
case 21:
YY_RULE_SETUP
#line 1161 "commentscan.l"
{ // start of a formula with custom environment
                                          formulaText="\\begin";
                                          formulaEnv=QString(commentscanYYtext).stripWhiteSpace().data()+2;
                                          if (formulaEnv.at(formulaEnv.length()-1)=='{')
                                          {
                                            // remove trailing open brace
                                            formulaEnv=formulaEnv.left(formulaEnv.length()-1);
                                          }
                                          formulaText+=formulaEnv;
                                          formulaNewLines=0;
                                          BEGIN(ReadFormulaLong);
                                        }
        YY_BREAK
case 22:
YY_RULE_SETUP
#line 1173 "commentscan.l"
{ // start of a inline formula
                                          formulaText="$";
                                          formulaNewLines=0;
                                          BEGIN(ReadFormulaShort);
                                        }
        YY_BREAK
case 23:
YY_RULE_SETUP
#line 1178 "commentscan.l"
{ // start of a block formula
                                          formulaText="\\[";
                                          formulaNewLines=0;
                                          BEGIN(ReadFormulaLong);
                                        }
        YY_BREAK
case 24:
YY_RULE_SETUP
#line 1183 "commentscan.l"
{ // begin of a group
                                          //langParser->handleGroupStartCommand(g_memberGroupHeader);
                                          openGroup(current,yyFileName,yyLineNr);
                                        }
        YY_BREAK
case 25:
YY_RULE_SETUP
#line 1187 "commentscan.l"
{ // end of a group
                                          //langParser->handleGroupEndCommand();
                                          closeGroup(current,yyFileName,yyLineNr,TRUE);
                                          g_memberGroupHeader.resize(0);
                                          parseMore=TRUE;
                                          needNewEntry = TRUE;
#if YY_FLEX_MAJOR_VERSION>=2 && (YY_FLEX_MINOR_VERSION>5 || (YY_FLEX_MINOR_VERSION==5 && YY_FLEX_SUBMINOR_VERSION>=33))
                                          inputPosition=prevPosition + (int)(yy_bp - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) + strlen(commentscanYYtext);
#else
                                          inputPosition=prevPosition + (int)(yy_bp - yy_current_buffer->yy_ch_buf) + strlen(commentscanYYtext);
#endif
                                          yyterminate();
                                        }
        YY_BREAK
case 26:
YY_RULE_SETUP
#line 1200 "commentscan.l"
{ // escaped character
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 27:
YY_RULE_SETUP
#line 1203 "commentscan.l"
{ // normal word
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 28:
/* rule 28 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1206 "commentscan.l"
{ // explicit end autolist: e.g "  ."
                                          addOutput(commentscanYYtext); 
                                        }
        YY_BREAK
case 29:
#line 1210 "commentscan.l"
case 30:
YY_RULE_SETUP
#line 1210 "commentscan.l"
{ // start of autolist
                                          if (!Doxygen::markdownSupport)
                                          {
                                            REJECT;
                                          }
                                          else
                                          {
                                            if (inContext!=OutputXRef) 
                                            {
                                              briefEndsAtDot=FALSE;
                                              setOutput(OutputDoc);
                                            }
                                            addOutput(commentscanYYtext); 
                                          }
                                        }
        YY_BREAK
case 31:
YY_RULE_SETUP
#line 1225 "commentscan.l"
{ // start of autolist
                                          if (inContext!=OutputXRef) 
                                          {
                                            briefEndsAtDot=FALSE;
                                            setOutput(OutputDoc);
                                          }
                                          addOutput(commentscanYYtext); 
                                        }
        YY_BREAK
case 32:
/* rule 32 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1233 "commentscan.l"
{ // horizontal line (dashed)
                                          addOutput(commentscanYYtext); 
                                        }
        YY_BREAK
case 33:
YY_RULE_SETUP
#line 1236 "commentscan.l"
{ // escaped mdash
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 34:
YY_RULE_SETUP
#line 1239 "commentscan.l"
{ // escaped mdash
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 35:
YY_RULE_SETUP
#line 1242 "commentscan.l"
{ // mdash
                                          addOutput(insidePre || Doxygen::markdownSupport ? commentscanYYtext : "&mdash;");
                                        }
        YY_BREAK
case 36:
YY_RULE_SETUP
#line 1245 "commentscan.l"
{ // ndash
                                          addOutput(insidePre || Doxygen::markdownSupport ? commentscanYYtext : "&ndash;");
                                        }
        YY_BREAK
case 37:
YY_RULE_SETUP
#line 1248 "commentscan.l"
{ // numbered item
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 38:
YY_RULE_SETUP
#line 1251 "commentscan.l"
{ // . at start or in the middle of a word, or ellipsis
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 39:
YY_RULE_SETUP
#line 1254 "commentscan.l"
{ // . with escaped space.
                                          addOutput(commentscanYYtext[0]);
                                          addOutput(commentscanYYtext[2]);
                                        }
        YY_BREAK
case 40:
YY_RULE_SETUP
#line 1258 "commentscan.l"
{ // . with comma such as "e.g.," 
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 41:
YY_RULE_SETUP
#line 1261 "commentscan.l"
{ // ellipsis with escaped space.
                                          addOutput("... ");
                                        }
        YY_BREAK
case 42:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1264 "commentscan.l"
{ // internal ellipsis 
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 43:
/* rule 43 can match eol */
YY_RULE_SETUP
#line 1267 "commentscan.l"
{ // at least one blank line (or blank line command)
                                          if (inContext==OutputXRef)
                                          {
                                            // see bug 613024, we need to put the newlines after ending the XRef section.
                                            if (!g_insideParBlock) setOutput(OutputDoc);
                                            int i;
                                            for (i=0;i<commentscanYYleng;)
                                            {
                                              if (commentscanYYtext[i]=='\n') addOutput('\n'),i++;
                                              else if (strcmp(commentscanYYtext+i,"\\_linebr")==0) addOutput('\n'),i+=8;
                                              else i++;
                                            }
                                          }
                                          else if (inContext!=OutputBrief)
                                          {
                                            int i;
                                            for (i=0;i<commentscanYYleng;)
                                            {
                                              if (commentscanYYtext[i]=='\n') addOutput('\n'),i++;
                                              else if (strcmp(commentscanYYtext+i,"\\_linebr")==0) addOutput('\n'),i+=8;
                                              else i++;
                                            }
                                            setOutput(OutputDoc);
                                          }
                                          else // inContext==OutputBrief
                                          { // only go to the detailed description if we have
                                            // found some brief description and not just whitespace
                                            endBrief(FALSE);
                                          }
                                          lineCount();
                                        }
        YY_BREAK
case 44:
YY_RULE_SETUP
#line 1298 "commentscan.l"
{ // potential end of a JavaDoc style comment
                                          addOutput(*commentscanYYtext);
                                          if (briefEndsAtDot)
                                          {
                                            setOutput(OutputDoc);
                                            briefEndsAtDot=FALSE;
                                          }
                                        }
        YY_BREAK
case 45:
/* rule 45 can match eol */
YY_RULE_SETUP
#line 1306 "commentscan.l"
{ // newline
                                          addOutput(*commentscanYYtext);
                                          yyLineNr++;
                                        }
        YY_BREAK
case 46:
YY_RULE_SETUP
#line 1310 "commentscan.l"
{ // catch-all for anything else
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
/* --------------   Rules for handling HTML comments ----------- */
case 47:
YY_RULE_SETUP
#line 1317 "commentscan.l"
{ BEGIN( Comment ); }
        YY_BREAK
case 48:
/* rule 48 can match eol */
YY_RULE_SETUP
#line 1318 "commentscan.l"
{ 
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                        }
        YY_BREAK
case 49:
YY_RULE_SETUP
#line 1321 "commentscan.l"
{ // ignore unimportant characters
                                        }
        YY_BREAK
case 50:
YY_RULE_SETUP
#line 1323 "commentscan.l"
{ // ignore every else
                                        }
        YY_BREAK
/* --------------   Rules for handling formulas ---------------- */
case 51:
YY_RULE_SETUP
#line 1328 "commentscan.l"
{ // end of inline formula
                                          formulaText+="$";
                                          addOutput(" "+addFormula());
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 52:
YY_RULE_SETUP
#line 1333 "commentscan.l"
{ // end of block formula
                                          formulaText+="\\]";
                                          addOutput(" "+addFormula());
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 53:
YY_RULE_SETUP
#line 1338 "commentscan.l"
{ // end of custom env formula
                                          formulaText+="\\end";
                                          formulaText+=formulaEnv;
                                          addOutput(" "+addFormula());
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 54:
YY_RULE_SETUP
#line 1344 "commentscan.l"
{ // any non-special character
                                          formulaText+=commentscanYYtext; 
                                        } 
        YY_BREAK
case 55:
/* rule 55 can match eol */
YY_RULE_SETUP
#line 1347 "commentscan.l"
{ // new line
                                          formulaNewLines++;
                                          formulaText+=*commentscanYYtext; 
                                          yyLineNr++; 
                                        }
        YY_BREAK
case 56:
YY_RULE_SETUP
#line 1352 "commentscan.l"
{ // any othe character
                                          formulaText+=*commentscanYYtext; 
                                        }
        YY_BREAK
/* ------------ handle argument of enum command --------------- */
case 57:
/* rule 57 can match eol */
YY_RULE_SETUP
#line 1358 "commentscan.l"
{ // handle argument
                                          current->name = commentscanYYtext;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 58:
/* rule 58 can match eol */
YY_RULE_SETUP
#line 1362 "commentscan.l"
{ // line continuation
                                          yyLineNr++;
                                          addOutput('\n');
                                        }
        YY_BREAK
case 59:
/* rule 59 can match eol */
YY_RULE_SETUP
#line 1366 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                               "missing argument after \\enum."
                                              );
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 60:
YY_RULE_SETUP
#line 1374 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ------------ handle argument of namespace command --------------- */
case 61:
/* rule 61 can match eol */
YY_RULE_SETUP
#line 1379 "commentscan.l"
{ // handle argument
                                          current->name = substitute(commentscanYYtext,".","::");
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 62:
/* rule 62 can match eol */
YY_RULE_SETUP
#line 1383 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 63:
/* rule 63 can match eol */
YY_RULE_SETUP
#line 1387 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                               "missing argument after "
                                               "\\namespace."
                                              );
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 64:
YY_RULE_SETUP
#line 1396 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ------------ handle argument of package command --------------- */
case 65:
YY_RULE_SETUP
#line 1401 "commentscan.l"
{ // handle argument
                                          current->name = commentscanYYtext;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 66:
/* rule 66 can match eol */
YY_RULE_SETUP
#line 1405 "commentscan.l"
{ // line continuation 
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 67:
/* rule 67 can match eol */
YY_RULE_SETUP
#line 1409 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                               "missing argument after "
                                               "\\package."
                                              );
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 68:
YY_RULE_SETUP
#line 1418 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ------ handle argument of class/struct/union command --------------- */
case 69:
/* rule 69 can match eol */
YY_RULE_SETUP
#line 1423 "commentscan.l"
{ 
                                          current->name = substitute(removeRedundantWhiteSpace(commentscanYYtext),".","::");
                                          BEGIN( ClassDocArg2 );
                                        }
        YY_BREAK
case 70:
/* rule 70 can match eol */
YY_RULE_SETUP
#line 1427 "commentscan.l"
{ // first argument
                                          current->name = substitute(commentscanYYtext,".","::");
                                          if (current->section==Entry::PROTOCOLDOC_SEC)
                                          {
                                            current->name+="-p";
                                          }
                                          // prepend outer scope name 
                                          BEGIN( ClassDocArg2 );
                                        }
        YY_BREAK
case 71:
/* rule 71 can match eol */
YY_RULE_SETUP
#line 1436 "commentscan.l"
{
                                          current->name = substitute(commentscanYYtext,".","::");
                                          BEGIN( ClassDocArg2 );
                                        }
        YY_BREAK
case 72:
/* rule 72 can match eol */
YY_RULE_SETUP
#line 1440 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 73:
/* rule 73 can match eol */
YY_RULE_SETUP
#line 1444 "commentscan.l"
{
                                          warn(yyFileName,yyLineNr,
                                               "missing argument after "
                                               "\\%s.",YY_START==ClassDocArg1?"class":"category"
                                              );
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 74:
YY_RULE_SETUP
#line 1453 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
case 75:
YY_RULE_SETUP
#line 1456 "commentscan.l"
{ // second argument; include file
                                          current->includeFile = commentscanYYtext;
                                          BEGIN( ClassDocArg3 );
                                        }
        YY_BREAK
case 76:
/* rule 76 can match eol */
YY_RULE_SETUP
#line 1460 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 77:
/* rule 77 can match eol */
YY_RULE_SETUP
#line 1464 "commentscan.l"
{ 
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 78:
YY_RULE_SETUP
#line 1469 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
case 79:
YY_RULE_SETUP
#line 1472 "commentscan.l"
{ // third argument; include file name
                                          current->includeName = commentscanYYtext;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 80:
/* rule 80 can match eol */
YY_RULE_SETUP
#line 1476 "commentscan.l"
{ // line continuation
                                          yyLineNr++;
                                          addOutput('\n');
                                        }
        YY_BREAK
case 81:
/* rule 81 can match eol */
YY_RULE_SETUP
#line 1480 "commentscan.l"
{ 
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 82:
YY_RULE_SETUP
#line 1484 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* --------- handle arguments of {def,add,weak}group commands --------- */
case 83:
YY_RULE_SETUP
#line 1489 "commentscan.l"
{ // group name
                                          current->name = commentscanYYtext;
                                          //lastDefGroup.groupname = commentscanYYtext;
                                          //lastDefGroup.pri = current->groupingPri();
                                          // the .html stuff is for Qt compatibility
                                          if (current->name.right(5)==".html") 
                                          {
                                            current->name=current->name.left(current->name.length()-5);
                                          }
                                          current->type.resize(0);
                                          BEGIN(GroupDocArg2);
                                        }
        YY_BREAK
case 84:
/* rule 84 can match eol */
YY_RULE_SETUP
#line 1501 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 85:
/* rule 85 can match eol */
YY_RULE_SETUP
#line 1505 "commentscan.l"
{ // missing argument!
                                          warn(yyFileName,yyLineNr,
                                               "missing group name after %s",
                                               current->groupDocCmd()
                                              );
                                          addOutput('\n');
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 86:
/* rule 86 can match eol */
YY_RULE_SETUP
#line 1514 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 87:
YY_RULE_SETUP
#line 1518 "commentscan.l"
{ // title (stored in type)
                                          current->type += commentscanYYtext;
                                          current->type = current->type.stripWhiteSpace();
                                        }
        YY_BREAK
case 88:
/* rule 88 can match eol */
YY_RULE_SETUP
#line 1522 "commentscan.l"
{
                                          if ( current->groupDocType==Entry::GROUPDOC_NORMAL &&
                                               current->type.isEmpty() 
                                             ) // defgroup requires second argument
                                          {
                                            warn(yyFileName,yyLineNr,
                                                 "missing title after "
                                                 "\\defgroup %s", current->name.data()
                                                );
                                          }
                                          if (*commentscanYYtext=='\n') yyLineNr++; 
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
/* --------- handle arguments of page/mainpage command ------------------- */
case 89:
YY_RULE_SETUP
#line 1539 "commentscan.l"
{ // first argument; page name
                                          current->name = stripQuotes(commentscanYYtext);
                                          BEGIN( PageDocArg2 ); 
                                        }
        YY_BREAK
case 90:
/* rule 90 can match eol */
YY_RULE_SETUP
#line 1543 "commentscan.l"
{ yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 91:
/* rule 91 can match eol */
YY_RULE_SETUP
#line 1546 "commentscan.l"
{
                                          warn(yyFileName,yyLineNr,
                                               "missing argument after "
                                               "\\page."
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 92:
YY_RULE_SETUP
#line 1555 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
case 93:
/* rule 93 can match eol */
YY_RULE_SETUP
#line 1557 "commentscan.l"
{ // second argument; page title
                                          yyLineNr++;
                                          current->args = commentscanYYtext;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
/* --------- handle arguments of the file/dir/example command ------------ */
case 94:
/* rule 94 can match eol */
YY_RULE_SETUP
#line 1566 "commentscan.l"
{ // no file name specfied
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 95:
YY_RULE_SETUP
#line 1571 "commentscan.l"
{ // first argument; name
                                          current->name = stripQuotes(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 96:
/* rule 96 can match eol */
YY_RULE_SETUP
#line 1575 "commentscan.l"
{ yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 97:
YY_RULE_SETUP
#line 1578 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* --------- handle arguments of the xrefitem command ------------ */
case 98:
YY_RULE_SETUP
#line 1583 "commentscan.l"
{ // first argument
                                          newXRefItemKey=commentscanYYtext;
                                          setOutput(OutputXRef);
                                          BEGIN(XRefItemParam2);
                                        }
        YY_BREAK
case 99:
/* rule 99 can match eol */
YY_RULE_SETUP
#line 1588 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 100:
/* rule 100 can match eol */
YY_RULE_SETUP
#line 1592 "commentscan.l"
{ // missing arguments
                                          warn(yyFileName,yyLineNr,
                                               "Missing first argument of \\xrefitem"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 101:
YY_RULE_SETUP
#line 1601 "commentscan.l"
{ // ignore other stuff 
                                        }
        YY_BREAK
case 102:
YY_RULE_SETUP
#line 1604 "commentscan.l"
{ // second argument
                                          xrefItemTitle = stripQuotes(commentscanYYtext);
                                          BEGIN(XRefItemParam3);
                                        }
        YY_BREAK
case 103:
/* rule 103 can match eol */
YY_RULE_SETUP
#line 1608 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 104:
/* rule 104 can match eol */
YY_RULE_SETUP
#line 1612 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "Missing second argument of \\xrefitem"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 105:
YY_RULE_SETUP
#line 1621 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
case 106:
YY_RULE_SETUP
#line 1624 "commentscan.l"
{ // third argument
                                          xrefListTitle = stripQuotes(commentscanYYtext);
                                          xrefKind = XRef_Item;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 107:
/* rule 107 can match eol */
YY_RULE_SETUP
#line 1629 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 108:
/* rule 108 can match eol */
YY_RULE_SETUP
#line 1633 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "Missing third argument of \\xrefitem"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          inContext = OutputDoc;
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 109:
YY_RULE_SETUP
#line 1642 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ----- handle arguments of the relates(also)/memberof command ------- */
case 110:
YY_RULE_SETUP
#line 1648 "commentscan.l"
{ // argument
                                          current->relates = commentscanYYtext;
                                          //if (current->mGrpId!=DOX_NOGROUP) 
                                          //{
                                          //  memberGroupRelates = commentscanYYtext;
                                          //}
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 111:
/* rule 111 can match eol */
YY_RULE_SETUP
#line 1656 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 112:
/* rule 112 can match eol */
YY_RULE_SETUP
#line 1660 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "Missing argument of \\relates or \\memberof command"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 113:
YY_RULE_SETUP
#line 1668 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ----- handle arguments of the relates(also)/addindex commands ----- */
case 114:
/* rule 114 can match eol */
YY_RULE_SETUP
#line 1674 "commentscan.l"
{ // end of argument
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 115:
/* rule 115 can match eol */
YY_RULE_SETUP
#line 1679 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 116:
YY_RULE_SETUP
#line 1683 "commentscan.l"
{ // ignore other stuff
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
/* ----- handle arguments of the section/subsection/.. commands ------- */
case 117:
YY_RULE_SETUP
#line 1689 "commentscan.l"
{ // first argyment
                                          g_sectionLabel=commentscanYYtext;
                                          addOutput(commentscanYYtext);
                                          g_sectionTitle.resize(0);
                                          BEGIN(SectionTitle);
                                        }
        YY_BREAK
case 118:
/* rule 118 can match eol */
YY_RULE_SETUP
#line 1695 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\section command has no label"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 119:
YY_RULE_SETUP
#line 1703 "commentscan.l"
{ // invalid character for section label
                                          warn(yyFileName,yyLineNr,
                                              "Invalid or missing section label"
                                              );
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 120:
/* rule 120 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1709 "commentscan.l"
{ // end of section title
                                          addSection();
                                          addOutput(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 121:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 8;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1714 "commentscan.l"
{ // end of section title
                                          addSection();
                                          addOutput(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 122:
/* rule 122 can match eol */
YY_RULE_SETUP
#line 1719 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 123:
YY_RULE_SETUP
#line 1723 "commentscan.l"
{ // any character without special meaning
                                          g_sectionTitle+=commentscanYYtext;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 124:
YY_RULE_SETUP
#line 1727 "commentscan.l"
{ // unescape escaped command
                                          g_sectionTitle+=&commentscanYYtext[1];
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 125:
YY_RULE_SETUP
#line 1731 "commentscan.l"
{ // unescape escaped character
                                          g_sectionTitle+=commentscanYYtext[1];
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 126:
YY_RULE_SETUP
#line 1735 "commentscan.l"
{ // anything else
                                          g_sectionTitle+=commentscanYYtext;
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
/* ----- handle arguments of the subpage command ------- */
case 127:
YY_RULE_SETUP
#line 1742 "commentscan.l"
{ // first argument
                                          addOutput(commentscanYYtext);
                                          // we add subpage labels as a kind of "inheritance" relation to prevent
                                          // needing to add another list to the Entry class.
                                          current->extends->append(new BaseInfo(commentscanYYtext,Public,Normal));
                                          BEGIN(SubpageTitle);
                                        }
        YY_BREAK
case 128:
/* rule 128 can match eol */
YY_RULE_SETUP
#line 1749 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\subpage command has no label"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 129:
/* rule 129 can match eol */
YY_RULE_SETUP
#line 1757 "commentscan.l"
{ // no title, end command
                                          addOutput(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 130:
YY_RULE_SETUP
#line 1761 "commentscan.l"
{ // add title, end of command
                                          addOutput(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 131:
YY_RULE_SETUP
#line 1765 "commentscan.l"
{ // no title, end of command
                                          unput(*commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
/* ----- handle arguments of the anchor command ------- */
case 132:
YY_RULE_SETUP
#line 1772 "commentscan.l"
{ // found argument
                                          addAnchor(commentscanYYtext);
                                          addOutput(commentscanYYtext);
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 133:
/* rule 133 can match eol */
YY_RULE_SETUP
#line 1777 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\anchor command has no label"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 134:
YY_RULE_SETUP
#line 1785 "commentscan.l"
{ // invalid character for anchor label
                                          warn(yyFileName,yyLineNr,
                                              "Invalid or missing anchor label"
                                              );
                                          BEGIN(Comment);
                                        }
        YY_BREAK
/* ----- handle arguments of the preformatted block commands ------- */
case 135:
/* rule 135 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1795 "commentscan.l"
{ // possible ends
                                          addOutput(commentscanYYtext);
                                          if (&commentscanYYtext[4]==blockName) // found end of the block
                                          {
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 136:
YY_RULE_SETUP
#line 1802 "commentscan.l"
{
                                          addOutput(commentscanYYtext);
                                          if (blockName=="startuml") // found end of the block
                                          {
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 137:
YY_RULE_SETUP
#line 1809 "commentscan.l"
{ // some word
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 138:
/* rule 138 can match eol */
YY_RULE_SETUP
#line 1812 "commentscan.l"
{ // new line
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                        }
        YY_BREAK
case 139:
YY_RULE_SETUP
#line 1816 "commentscan.l"
{ // start of a C-comment
                                          g_commentCount++;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 140:
YY_RULE_SETUP
#line 1820 "commentscan.l"
{ // end of a C-comment
                                          addOutput(commentscanYYtext);
                                          g_commentCount--;
                                          if (g_commentCount<0 && blockName!="verbatim")
                                          {
                                            warn(yyFileName,yyLineNr,
                                                 "found */ without matching /* while inside a \\%s block! Perhaps a missing \\end%s?\n",blockName.data(),blockName.data());
                                          }
                                        }
        YY_BREAK
case 141:
YY_RULE_SETUP
#line 1829 "commentscan.l"
{
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
case YY_STATE_EOF(FormatBlock):
#line 1832 "commentscan.l"
{
                                          QCString endTag = "@end"+blockName;
                                          if (blockName=="startuml") endTag="enduml";
                                          warn(yyFileName,yyLineNr,
                                            "reached end of comment while inside a @%s block; check for missing @%s tag!",
                                            blockName.data(),endTag.data()
                                          );                            
                                          yyterminate();
                                        }
        YY_BREAK
/* ----- handle arguments of if/ifnot commands ------- */
case 142:
YY_RULE_SETUP
#line 1844 "commentscan.l"
{
                                          g_guardExpr=commentscanYYtext;
                                          g_roundCount=1;
                                          BEGIN(GuardExpr);
                                        }
        YY_BREAK
case 143:
/* rule 143 can match eol */
YY_RULE_SETUP
#line 1849 "commentscan.l"
{
                                          g_guardExpr+=commentscanYYtext;
                                        }
        YY_BREAK
case 144:
YY_RULE_SETUP
#line 1852 "commentscan.l"
{
                                          g_guardExpr+=commentscanYYtext;
                                          g_roundCount++;
                                        }
        YY_BREAK
case 145:
YY_RULE_SETUP
#line 1856 "commentscan.l"
{
                                          g_guardExpr+=commentscanYYtext;
                                          g_roundCount--;
                                          if (g_roundCount==0)
                                          {
                                            handleGuard(g_guardExpr);
                                          }
                                        }
        YY_BREAK
case 146:
/* rule 146 can match eol */
YY_RULE_SETUP
#line 1864 "commentscan.l"
{
                                          warn(yyFileName,yyLineNr,
                                                "invalid expression '%s' for guard",g_guardExpr.data());
                                          unput(*commentscanYYtext);
                                          BEGIN(GuardParam);
                                        }
        YY_BREAK
case 147:
YY_RULE_SETUP
#line 1870 "commentscan.l"
{ // parameter of if/ifnot guard
                                          handleGuard(commentscanYYtext);
                                        }
        YY_BREAK
case 148:
/* rule 148 can match eol */
YY_RULE_SETUP
#line 1873 "commentscan.l"
{ // end of argument
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          //next line is commented out due to bug620924
                                          //addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 149:
/* rule 149 can match eol */
YY_RULE_SETUP
#line 1879 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 150:
YY_RULE_SETUP
#line 1883 "commentscan.l"
{ // ignore other stuff
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
case 151:
/* rule 151 can match eol */
YY_RULE_SETUP
#line 1886 "commentscan.l"
{
                                          g_spaceBeforeIf.resize(0);
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 152:
YY_RULE_SETUP
#line 1890 "commentscan.l"
{
                                          if (!g_spaceBeforeIf.isEmpty()) // needed for 665313 in combation with bug620924
                                          {
                                            addOutput(g_spaceBeforeIf);
                                          }
                                          g_spaceBeforeIf.resize(0);
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 153:
YY_RULE_SETUP
#line 1898 "commentscan.l"
{
                                          unput(*commentscanYYtext);
                                          BEGIN(Comment);
                                        }
        YY_BREAK
/* ----- handle skipping of conditional sections ------- */
case 154:
/* rule 154 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1905 "commentscan.l"
{
                                          guardType = Guard_IfNot;
                                          BEGIN( GuardParam );
                                        }
        YY_BREAK
case 155:
/* rule 155 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1909 "commentscan.l"
{
                                          guardType = Guard_If;
                                          BEGIN( GuardParam );
                                        }
        YY_BREAK
case 156:
/* rule 156 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1913 "commentscan.l"
{
                                          if (guards.isEmpty())
                                          {
                                            warn(yyFileName,yyLineNr,
                                                "found @endif without matching start command");
                                          }
                                          else
                                          {
                                            GuardedSection *s = guards.pop();
                                            bool parentVisible = s->parentVisible();
                                            delete s;
                                            if (parentVisible)
                                            {
                                              enabledSectionFound=TRUE;
                                              BEGIN( GuardParamEnd );
                                            }
                                          }
                                        }
        YY_BREAK
case 157:
/* rule 157 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1931 "commentscan.l"
{
                                          if (guards.isEmpty())
                                          {
                                            warn(yyFileName,yyLineNr,
                                                "found @else without matching start command");
                                          }
                                          else
                                          {
                                            if (!enabledSectionFound && guards.top()->parentVisible())
                                            {
                                              delete guards.pop();
                                              guards.push(new GuardedSection(TRUE,TRUE));
                                              enabledSectionFound=TRUE;
                                              BEGIN( GuardParamEnd );
                                            }
                                          }
                                        }
        YY_BREAK
case 158:
/* rule 158 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1948 "commentscan.l"
{
                                          if (guards.isEmpty())
                                          {
                                            warn(yyFileName,yyLineNr,
                                                "found @elseif without matching start command");
                                          }
                                          else
                                          {
                                            if (!enabledSectionFound && guards.top()->parentVisible())
                                            {
                                              guardType=Guard_If;
                                              delete guards.pop();
                                              BEGIN( GuardParam );
                                            }
                                          }
                                        }
        YY_BREAK
case 159:
/* rule 159 can match eol */
YY_RULE_SETUP
#line 1964 "commentscan.l"
{ // skip line
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          //addOutput('\n');
                                        }
        YY_BREAK
case 160:
YY_RULE_SETUP
#line 1968 "commentscan.l"
{ // skip non-special characters
                                        }
        YY_BREAK
case 161:
YY_RULE_SETUP
#line 1970 "commentscan.l"
{ // any other character
                                        }
        YY_BREAK
/* ----- handle skipping of internal section ------- */
case 162:
/* rule 162 can match eol */
YY_RULE_SETUP
#line 1976 "commentscan.l"
{ // skip line
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                        }
        YY_BREAK
case 163:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 3;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1980 "commentscan.l"
{
                                          g_condCount++;
                                        }
        YY_BREAK
case 164:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 6;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1983 "commentscan.l"
{
                                          g_condCount++;
                                        }
        YY_BREAK
case 165:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1986 "commentscan.l"
{
                                          g_condCount--;
                                          if (g_condCount<0) // handle conditional section around of \internal, see bug607743  
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 166:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 1994 "commentscan.l"
{
                                          if (g_sectionLevel>0)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 167:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 2001 "commentscan.l"
{
                                          if (g_sectionLevel>1)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 168:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 2008 "commentscan.l"
{
                                          if (g_sectionLevel>2)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 169:
*yy_cp = (yy_hold_char); /* undo effects of setting up commentscanYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up commentscanYYtext again */
YY_RULE_SETUP
#line 2015 "commentscan.l"
{
                                          if (g_sectionLevel>3)
                                          {
                                            unput('\\');
                                            BEGIN(Comment);
                                          }
                                        }
        YY_BREAK
case 170:
YY_RULE_SETUP
#line 2022 "commentscan.l"
{
                                          addOutput("\\endinternal "); 
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 171:
YY_RULE_SETUP
#line 2026 "commentscan.l"
{ // skip non-special characters
                                        }
        YY_BREAK
case 172:
YY_RULE_SETUP
#line 2028 "commentscan.l"
{ // any other character
                                        }
        YY_BREAK
/* ----- handle argument of name command ------- */
case 173:
/* rule 173 can match eol */
YY_RULE_SETUP
#line 2034 "commentscan.l"
{ // end of argument
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 174:
/* rule 174 can match eol */
YY_RULE_SETUP
#line 2039 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                          g_memberGroupHeader+=' ';
                                        }
        YY_BREAK
case 175:
YY_RULE_SETUP
#line 2044 "commentscan.l"
{ // ignore other stuff
                                          g_memberGroupHeader+=*commentscanYYtext;
                                          current->name+=*commentscanYYtext;
                                        }
        YY_BREAK
/* ----- handle argument of ingroup command ------- */
case 176:
YY_RULE_SETUP
#line 2051 "commentscan.l"
{ // group id
                                          current->groups->append(
                                            new Grouping(commentscanYYtext, Grouping::GROUPING_INGROUP)
                                          );
                                          inGroupParamFound=TRUE;
                                        }
        YY_BREAK
case 177:
/* rule 177 can match eol */
YY_RULE_SETUP
#line 2057 "commentscan.l"
{ // missing argument
                                          if (!inGroupParamFound)
                                          {
                                            warn(yyFileName,yyLineNr,
                                                "Missing group name for \\ingroup command"
                                                );
                                          }
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 178:
/* rule 178 can match eol */
YY_RULE_SETUP
#line 2068 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          addOutput('\n');
                                        }
        YY_BREAK
case 179:
YY_RULE_SETUP
#line 2072 "commentscan.l"
{ // ignore other stuff
                                          addOutput(*commentscanYYtext);
                                        }
        YY_BREAK
/* ----- handle argument of fn command ------- */
case 180:
/* rule 180 can match eol */
YY_RULE_SETUP
#line 2078 "commentscan.l"
{ // end of argument
                                          if (braceCount==0)
                                          {
                                            if (*commentscanYYtext=='\n') yyLineNr++;
                                            addOutput('\n');
                                            langParser->parsePrototype(functionProto);
                                            BEGIN( Comment );
                                          }
                                        }
        YY_BREAK
case 181:
/* rule 181 can match eol */
YY_RULE_SETUP
#line 2087 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          functionProto+=' ';
                                        }
        YY_BREAK
case 182:
YY_RULE_SETUP
#line 2091 "commentscan.l"
{ // non-special characters
                                          functionProto+=commentscanYYtext;
                                        }
        YY_BREAK
case 183:
YY_RULE_SETUP
#line 2094 "commentscan.l"
{
                                          functionProto+=commentscanYYtext;
                                          braceCount++;
                                        }
        YY_BREAK
case 184:
YY_RULE_SETUP
#line 2098 "commentscan.l"
{
                                          functionProto+=commentscanYYtext;
                                          braceCount--;
                                        }
        YY_BREAK
case 185:
YY_RULE_SETUP
#line 2102 "commentscan.l"
{ // add other stuff
                                          functionProto+=*commentscanYYtext;
                                        }
        YY_BREAK
/* ----- handle argument of overload command ------- */
case 186:
/* rule 186 can match eol */
YY_RULE_SETUP
#line 2110 "commentscan.l"
{ // end of argument
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          if (functionProto.stripWhiteSpace().isEmpty())
                                          { // plain overload command
                                            addOutput(getOverloadDocs());
                                            addOutput('\n');
                                          }
                                          else // overload declaration
                                          {
                                            makeStructuralIndicator(Entry::OVERLOADDOC_SEC);
                                            langParser->parsePrototype(functionProto);
                                          }
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 187:
/* rule 187 can match eol */
YY_RULE_SETUP
#line 2124 "commentscan.l"
{ // line continuation
                                          yyLineNr++; 
                                          functionProto+=' ';
                                        }
        YY_BREAK
case 188:
YY_RULE_SETUP
#line 2128 "commentscan.l"
{ // add other stuff
                                          functionProto+=*commentscanYYtext;
                                        }
        YY_BREAK
/* ----- handle argument of inherit command ------- */
case 189:
YY_RULE_SETUP
#line 2134 "commentscan.l"
{ // found argument
                                          current->extends->append(
                                            new BaseInfo(removeRedundantWhiteSpace(commentscanYYtext),Public,Normal)
                                          );
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 190:
/* rule 190 can match eol */
YY_RULE_SETUP
#line 2140 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\inherit command has no argument"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 191:
YY_RULE_SETUP
#line 2148 "commentscan.l"
{ // invalid character for anchor label
                                          warn(yyFileName,yyLineNr,
                                              "Invalid or missing name for \\inherit command"
                                              );
                                          BEGIN(Comment);
                                        }
        YY_BREAK
/* ----- handle argument of extends and implements commands ------- */
case 192:
YY_RULE_SETUP
#line 2157 "commentscan.l"
{ // found argument
                                          current->extends->append(
                                            new BaseInfo(removeRedundantWhiteSpace(commentscanYYtext),Public,Normal)
                                          );
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 193:
/* rule 193 can match eol */
YY_RULE_SETUP
#line 2163 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\extends or \\implements command has no argument"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 194:
YY_RULE_SETUP
#line 2171 "commentscan.l"
{ // ignore other stuff
                                        }
        YY_BREAK
/* ----- handle language specific sections ------- */
case 195:
YY_RULE_SETUP
#line 2176 "commentscan.l"
{ /* language switch */
                                     QCString langId = &commentscanYYtext[2];
                                     if (langId.isEmpty() ||
                                         qstricmp(Config_getEnum("OUTPUT_LANGUAGE"),langId)==0)
                                     { // enable language specific section
                                       BEGIN(Comment);
                                     }
                                   }
        YY_BREAK
case 196:
YY_RULE_SETUP
#line 2184 "commentscan.l"
{ /* any character not a *, @, backslash or new line */
                                   }
        YY_BREAK
case 197:
/* rule 197 can match eol */
YY_RULE_SETUP
#line 2186 "commentscan.l"
{ /* new line in verbatim block */
                                     if (*commentscanYYtext=='\n') yyLineNr++;
                                   }
        YY_BREAK
case 198:
YY_RULE_SETUP
#line 2189 "commentscan.l"
{ /* any other character */
                                   }
        YY_BREAK
/* ----- handle arguments of the cite command ------- */
case 199:
YY_RULE_SETUP
#line 2194 "commentscan.l"
{ // found argyment
                                          addCite();
                                          addOutput(commentscanYYtext);
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 200:
/* rule 200 can match eol */
YY_RULE_SETUP
#line 2199 "commentscan.l"
{ // missing argument
                                          warn(yyFileName,yyLineNr,
                                              "\\cite command has no label"
                                              );
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          BEGIN( Comment );
                                        }
        YY_BREAK
case 201:
YY_RULE_SETUP
#line 2207 "commentscan.l"
{ // invalid character for cite label
                                          warn(yyFileName,yyLineNr,
                                              "Invalid or missing cite label"
                                              );
                                          BEGIN(Comment);
                                        }
        YY_BREAK
/* ----- handle argument of the copydoc command ------- */
case YY_STATE_EOF(CopyDoc):
#line 2216 "commentscan.l"
case 202:
/* rule 202 can match eol */
YY_RULE_SETUP
#line 2217 "commentscan.l"
{
                                          if (*commentscanYYtext=='\n') yyLineNr++;
                                          addOutput('\n');
                                          setOutput(OutputDoc);
                                          addOutput("\\copydetails ");
                                          addOutput(g_copyDocArg);
                                          addOutput("\n");
                                          BEGIN(Comment);
                                        }
        YY_BREAK
case 203:
YY_RULE_SETUP
#line 2226 "commentscan.l"
{
                                          g_copyDocArg+=commentscanYYtext;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 204:
YY_RULE_SETUP
#line 2230 "commentscan.l"
{
                                          g_copyDocArg+=commentscanYYtext;
                                          addOutput(commentscanYYtext);
                                        }
        YY_BREAK
case 205:
YY_RULE_SETUP
#line 2236 "commentscan.l"
ECHO;
        YY_BREAK
#line 6496 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/commentscan.cpp"
                        case YY_STATE_EOF(INITIAL):
                        case YY_STATE_EOF(Comment):
                        case YY_STATE_EOF(PageDocArg1):
                        case YY_STATE_EOF(PageDocArg2):
                        case YY_STATE_EOF(RelatesParam1):
                        case YY_STATE_EOF(ClassDocArg1):
                        case YY_STATE_EOF(ClassDocArg2):
                        case YY_STATE_EOF(ClassDocArg3):
                        case YY_STATE_EOF(CategoryDocArg1):
                        case YY_STATE_EOF(XRefItemParam1):
                        case YY_STATE_EOF(XRefItemParam2):
                        case YY_STATE_EOF(XRefItemParam3):
                        case YY_STATE_EOF(FileDocArg1):
                        case YY_STATE_EOF(EnumDocArg1):
                        case YY_STATE_EOF(NameSpaceDocArg1):
                        case YY_STATE_EOF(PackageDocArg1):
                        case YY_STATE_EOF(GroupDocArg1):
                        case YY_STATE_EOF(GroupDocArg2):
                        case YY_STATE_EOF(SectionLabel):
                        case YY_STATE_EOF(SectionTitle):
                        case YY_STATE_EOF(SubpageLabel):
                        case YY_STATE_EOF(SubpageTitle):
                        case YY_STATE_EOF(LineParam):
                        case YY_STATE_EOF(GuardParam):
                        case YY_STATE_EOF(GuardParamEnd):
                        case YY_STATE_EOF(SkipGuardedSection):
                        case YY_STATE_EOF(SkipInternal):
                        case YY_STATE_EOF(NameParam):
                        case YY_STATE_EOF(InGroupParam):
                        case YY_STATE_EOF(FnParam):
                        case YY_STATE_EOF(OverloadParam):
                        case YY_STATE_EOF(InheritParam):
                        case YY_STATE_EOF(ExtendsParam):
                        case YY_STATE_EOF(ReadFormulaShort):
                        case YY_STATE_EOF(ReadFormulaLong):
                        case YY_STATE_EOF(AnchorLabel):
                        case YY_STATE_EOF(HtmlComment):
                        case YY_STATE_EOF(SkipLang):
                        case YY_STATE_EOF(CiteLabel):
                        case YY_STATE_EOF(GuardExpr):
                                yyterminate();

        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

                /* Undo the effects of YY_DO_BEFORE_ACTION. */
                *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET

                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
                         * just pointed commentscanYYin at a new source and called
                         * commentscanYYlex().  If so, then we have to assure
                         * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = commentscanYYin;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }

                /* Note that here we test for yy_c_buf_p "<=" to the position
                 * of the first EOB in the buffer, since yy_c_buf_p will
                 * already have been incremented past the NUL character
                 * (since all states make transitions on EOB to the
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;

                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state(  );

                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
                         * yy_get_previous_state() go ahead and do it
                         * for us because it doesn't know how to deal
                         * with the possibility of jamming (and we don't
                         * want to build jamming into it because then it
                         * will run more slowly).
                         */

                        yy_next_state = yy_try_NUL_trans( yy_current_state );

                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;

                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
                                yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }

                        else
                                {
                                yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }

                else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
                                (yy_did_buffer_switch_on_eof) = 0;

                                if ( commentscanYYwrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
                                         * commentscanYYtext, we can now set up
                                         * yy_c_buf_p so that if some total
                                         * hoser (like flex itself) wants to
                                         * call the scanner after we return the
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
                                        }

                                else
                                        {
                                        if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }

                        case EOB_ACT_CONTINUE_SCAN:
                                (yy_c_buf_p) =
                                        (yytext_ptr) + yy_amount_of_matched_text;

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;

                        case EOB_ACT_LAST_MATCH:
                                (yy_c_buf_p) =
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
                }

        default:
                YY_FATAL_ERROR(
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */

static void yy_fatal_error ( yyconst char  msg[] )

static

static void yy_fatal_error ( yyconst char *  msg )

static

Definition at line 7296 of file commentscan.cpp.

{
        (void) fprintf( stderr, "%s\n", msg );
        exit( YY_EXIT_FAILURE );
}

static int yy_get_next_buffer ( void  )

static

Definition at line 6674 of file commentscan.cpp.

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
        register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;

        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );

        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
                         */
                        return EOB_ACT_END_OF_FILE;
                        }

                else
                        {
                        /* We matched some text prior to the EOB, first
                         * process it.
                         */
                        return EOB_ACT_LAST_MATCH;
                        }
                }

        /* Try to read more data. */

        /* First move last chars to start of buffer. */
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;

        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);

        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;

        else
                {
                        int num_to_read =
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */

                        YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );

                        }

                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;

                /* Read in more data. */
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
                        (yy_n_chars), (size_t) num_to_read );

                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
                        commentscanYYrestart(commentscanYYin  );
                        }

                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }

        else
                ret_val = EOB_ACT_CONTINUE_SCAN;

        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
                /* Extend the array by 50%, plus the number we really need. */
                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) commentscanYYrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
        }

        (yy_n_chars) += number_to_move;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

        return ret_val;
}

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 6779 of file commentscan.cpp.

{
        register yy_state_type yy_current_state;
        register char *yy_cp;
    
        yy_current_state = (yy_start);
        yy_current_state += YY_AT_BOL();

        (yy_state_ptr) = (yy_state_buf);
        *(yy_state_ptr)++ = yy_current_state;

        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
                        if ( yy_current_state >= 1138 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                *(yy_state_ptr)++ = yy_current_state;
                }

        return yy_current_state;
}

static int yy_init_globals ( void  )

static

Definition at line 7399 of file commentscan.cpp.

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from commentscanYYlex_destroy(), so don't allocate here.
     */

    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

    (yy_state_buf) = 0;
    (yy_state_ptr) = 0;
    (yy_full_match) = 0;
    (yy_lp) = 0;

/* Defined in main.c */
#ifdef YY_STDINIT
    commentscanYYin = stdin;
    commentscanYYout = stdout;
#else
    commentscanYYin = (FILE *) 0;
    commentscanYYout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * commentscanYYlex_init()
     */
    return 0;
}

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 6811 of file commentscan.cpp.

{
        register int yy_is_jam;
    
        register YY_CHAR yy_c = 1;
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 1138 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        yy_is_jam = (yy_current_state == 1137);
        if ( ! yy_is_jam )
                *(yy_state_ptr)++ = yy_current_state;

        return yy_is_jam ? 0 : yy_current_state;
}

static int yyread ( char *  buf, int  max_size  )

static

Definition at line 4003 of file commentscan.cpp.

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

static void yyunput ( int  c, char *  buf_ptr  )

static

static void yyunput ( int  c, register char *  yy_bp  )

static

Definition at line 6830 of file commentscan.cpp.

{
        register char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

        /* undo effects of setting up commentscanYYtext */
        *yy_cp = (yy_hold_char);

        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                { /* need to shift things up to make room */
                /* +2 for EOB chars. */
                register int number_to_move = (yy_n_chars) + 2;
                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
                register char *source =
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        *--dest = *--source;

                yy_cp += (int) (dest - source);
                yy_bp += (int) (dest - source);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
                }

        *--yy_cp = (char) c;

        (yytext_ptr) = yy_bp;
        (yy_hold_char) = *yy_cp;
        (yy_c_buf_p) = yy_cp;
}

Variable Documentation

QCString blockName

static

Definition at line 3509 of file commentscan.cpp.

int braceCount

static

Definition at line 3534 of file commentscan.cpp.

bool briefEndsAtDot

static

Definition at line 3503 of file commentscan.cpp.

int commentscanYY_flex_debug = 0

Definition at line 3097 of file commentscan.cpp.

FILE * commentscanYYin = (FILE *) 0

Definition at line 359 of file commentscan.cpp.

int commentscanYYleng

Definition at line 294 of file commentscan.cpp.

int commentscanYYlineno = 1

Definition at line 365 of file commentscan.cpp.

FILE * commentscanYYout = (FILE *) 0

Definition at line 359 of file commentscan.cpp.

char * commentscanYYtext

Definition at line 3113 of file commentscan.cpp.

Entry* current = 0

static

Definition at line 3516 of file commentscan.cpp.

DocCmdMap docCmdMap[]

static

Definition at line 3249 of file commentscan.cpp.

bool enabledSectionFound

static

Definition at line 3513 of file commentscan.cpp.

QCString formulaEnv

static

Definition at line 3505 of file commentscan.cpp.

int formulaNewLines

static

Definition at line 3506 of file commentscan.cpp.

QCString formulaText

static

Definition at line 3504 of file commentscan.cpp.

QCString functionProto

static

Definition at line 3514 of file commentscan.cpp.

QStack<Grouping> g_autoGroupStack

static

Definition at line 3551 of file commentscan.cpp.

int g_commentCount

static

Definition at line 3539 of file commentscan.cpp.

QCString g_compoundName

static

Definition at line 3556 of file commentscan.cpp.

int g_condCount

static

Definition at line 3537 of file commentscan.cpp.

QCString g_copyDocArg

static

Definition at line 3542 of file commentscan.cpp.

QCString g_guardExpr

static

Definition at line 3544 of file commentscan.cpp.

bool g_insideParBlock

static

Definition at line 3547 of file commentscan.cpp.

QCString g_memberGroupDocs

static

Definition at line 3554 of file commentscan.cpp.

QCString g_memberGroupHeader

static

Definition at line 3553 of file commentscan.cpp.

int g_memberGroupId = DOX_NOGROUP

static

Definition at line 3552 of file commentscan.cpp.

QCString g_memberGroupRelates

static

Definition at line 3555 of file commentscan.cpp.

int g_roundCount

static

Definition at line 3545 of file commentscan.cpp.

QCString g_sectionLabel

static

Definition at line 3523 of file commentscan.cpp.

int g_sectionLevel

static

Definition at line 3525 of file commentscan.cpp.

QCString g_sectionTitle

static

Definition at line 3524 of file commentscan.cpp.

QCString g_spaceBeforeCmd

static

Definition at line 3540 of file commentscan.cpp.

QCString g_spaceBeforeIf

static

Definition at line 3541 of file commentscan.cpp.

QStack<GuardedSection> guards

static

Definition at line 3515 of file commentscan.cpp.

GuardType guardType

static

Definition at line 3512 of file commentscan.cpp.

bool inBody

static

Definition at line 3501 of file commentscan.cpp.

OutputContext inContext

static

Definition at line 3502 of file commentscan.cpp.

bool inGroupParamFound

static

Definition at line 3533 of file commentscan.cpp.

bool inInternalDocs = FALSE

Definition at line 3444 of file commentscan.cpp.

int inputPosition

static

Definition at line 3498 of file commentscan.cpp.

QCString inputString

static

Definition at line 3497 of file commentscan.cpp.

bool insidePre

static

Definition at line 3535 of file commentscan.cpp.

ParserInterface* langParser

static

Definition at line 3496 of file commentscan.cpp.

bool needNewEntry

static

Definition at line 3521 of file commentscan.cpp.

QCString newXRefItemKey

static

Definition at line 3527 of file commentscan.cpp.

XRefKind newXRefKind

static

Definition at line 3511 of file commentscan.cpp.

QCString outputXRef

static

Definition at line 3508 of file commentscan.cpp.

bool parseMore

static

Definition at line 3536 of file commentscan.cpp.

QCString* pOutputString

static

Definition at line 3507 of file commentscan.cpp.

int prevPosition =0

static

Definition at line 4001 of file commentscan.cpp.

Protection protection

static

Definition at line 3530 of file commentscan.cpp.

bool xrefAppendFlag

static

Definition at line 3532 of file commentscan.cpp.

QCString xrefItemKey

static

Definition at line 3526 of file commentscan.cpp.

QCString xrefItemTitle

static

Definition at line 3528 of file commentscan.cpp.

XRefKind xrefKind

static

Definition at line 3510 of file commentscan.cpp.

QCString xrefListTitle

static

Definition at line 3529 of file commentscan.cpp.

yyconst flex_int16_t yy_accept[1139]

static

Definition at line 481 of file commentscan.cpp.

yyconst flex_int16_t yy_acclist[759]

static

Definition at line 394 of file commentscan.cpp.

register int yy_act

Definition at line 4283 of file commentscan.cpp.

yyconst flex_int16_t yy_base[1371]

static

Definition at line 654 of file commentscan.cpp.

register char * yy_bp

Definition at line 4282 of file commentscan.cpp.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 274 of file commentscan.cpp.

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 273 of file commentscan.cpp.

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 272 of file commentscan.cpp.

char* yy_c_buf_p = (char *) 0

static

Definition at line 297 of file commentscan.cpp.

yyconst flex_int16_t yy_chk[9667]

static

Definition at line 2029 of file commentscan.cpp.

register char* yy_cp

Definition at line 4282 of file commentscan.cpp.

YY_DECL

Initial value:

{
        register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 4280 of file commentscan.cpp.

yyconst flex_int16_t yy_def[1371]

static

Definition at line 808 of file commentscan.cpp.

int yy_did_buffer_switch_on_eof

static

Definition at line 304 of file commentscan.cpp.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 610 of file commentscan.cpp.

char* yy_full_match

static

Definition at line 3100 of file commentscan.cpp.

char yy_hold_char

static

Definition at line 292 of file commentscan.cpp.

int yy_init = 0

static

Definition at line 298 of file commentscan.cpp.

int yy_lp

static

Definition at line 3101 of file commentscan.cpp.

yyconst flex_int32_t yy_meta[76]

static

Initial value:

=
    {   0,
        1,    2,    3,    4,    5,    1,    6,    7,    8,    9,
        7,   10,   11,   12,   13,   14,   15,   16,   17,   18,
       18,   18,   19,   20,   21,   22,   23,   23,   23,   23,
       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
       23,   23,   23,    1,   24,    1,   25,   23,   23,   23,
       23,   23,   23,   23,   23,   26,   23,   23,   23,   27,
       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
       28,   29,   30,   31,   32
    }

Definition at line 642 of file commentscan.cpp.

int yy_n_chars

static

Definition at line 293 of file commentscan.cpp.

yyconst flex_int16_t yy_nxt[9667]

static

Definition at line 962 of file commentscan.cpp.

int yy_start = 0

static

Definition at line 299 of file commentscan.cpp.

yy_state_type* yy_state_buf =0

static

Definition at line 3099 of file commentscan.cpp.

yy_state_type * yy_state_ptr =0

static

Definition at line 3099 of file commentscan.cpp.

QCString yyFileName

static

Definition at line 3499 of file commentscan.cpp.

int yyLineNr

static

Definition at line 3500 of file commentscan.cpp.