code.cpp File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <qregexp.h>
#include <qdir.h>
#include "entry.h"
#include "doxygen.h"
#include "message.h"
#include "outputlist.h"
#include "util.h"
#include "membername.h"
#include "searchindex.h"
#include "arguments.h"
#include "config.h"
#include "groupdef.h"
#include "classlist.h"
#include "filedef.h"
#include "filename.h"
#include "namespacedef.h"
#include "tooltip.h"

Go to the source code of this file.

Classes
struct	yy_buffer_state
struct	yy_trans_info
struct	ObjCCallCtx
class	VariableContext
class	VariableContext::Scope
class	CallContext
struct	CallContext::Ctx

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   codeYY_create_buffer
#define	yy_delete_buffer   codeYY_delete_buffer
#define	yy_flex_debug   codeYY_flex_debug
#define	yy_init_buffer   codeYY_init_buffer
#define	yy_flush_buffer   codeYY_flush_buffer
#define	yy_load_buffer_state   codeYY_load_buffer_state
#define	yy_switch_to_buffer   codeYY_switch_to_buffer
#define	yyin   codeYYin
#define	yyleng   codeYYleng
#define	yylex   codeYYlex
#define	yylineno   codeYYlineno
#define	yyout   codeYYout
#define	yyrestart   codeYYrestart
#define	yytext   codeYYtext
#define	yywrap   codeYYwrap
#define	yyalloc   codeYYalloc
#define	yyrealloc   codeYYrealloc
#define	yyfree   codeYYfree
#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   codeYYrestart(codeYYin )
#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   codeYY_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   codeYY_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	codeYYwrap(n)   1
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   codeYYtext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   214
#define	YY_END_OF_BUFFER   215
#define	YY_TRAILING_MASK   0x2000
#define	YY_TRAILING_HEAD_MASK   0x4000
#define	REJECT
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	DBG_CTX(x)   do { } while(0)
#define	YY_NO_UNISTD_H   1
#define	CLASSBLOCK   (int *)4
#define	SCOPEBLOCK   (int *)8
#define	INNERBLOCK   (int *)12
#define	YY_INPUT(buf, result, max_size)   result=yyread(buf,max_size);
#define	INITIAL   0
#define	SkipString   1
#define	SkipStringS   2
#define	SkipVerbString   3
#define	SkipCPP   4
#define	SkipComment   5
#define	SkipCxxComment   6
#define	RemoveSpecialCComment   7
#define	StripSpecialCComment   8
#define	Body   9
#define	FuncCall   10
#define	MemberCall   11
#define	MemberCall2   12
#define	SkipInits   13
#define	ClassName   14
#define	AlignAs   15
#define	AlignAsEnd   16
#define	PackageName   17
#define	ClassVar   18
#define	CppCliTypeModifierFollowup   19
#define	Bases   20
#define	SkipSharp   21
#define	ReadInclude   22
#define	TemplDecl   23
#define	TemplCast   24
#define	CallEnd   25
#define	ObjCMethod   26
#define	ObjCParams   27
#define	ObjCParamType   28
#define	ObjCCall   29
#define	ObjCMName   30
#define	ObjCSkipStr   31
#define	OldStyleArgs   32
#define	UsingName   33
#define	RawString   34
#define	InlineInit   35
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( codeYYtext, codeYYleng, 1, codeYYout )) {} } 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 codeYYlex (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

Functions
void	codeYYrestart (FILE *input_file)
void	codeYY_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	codeYY_create_buffer (FILE *file, int size)
void	codeYY_delete_buffer (YY_BUFFER_STATE b)
void	codeYY_flush_buffer (YY_BUFFER_STATE b)
void	codeYYpush_buffer_state (YY_BUFFER_STATE new_buffer)
void	codeYYpop_buffer_state (void)
static void	codeYYensure_buffer_stack (void)
static void	codeYY_load_buffer_state (void)
static void	codeYY_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	codeYY_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	codeYY_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	codeYY_scan_bytes (yyconst char *bytes, int len)
void *	codeYYalloc (yy_size_t)
void *	codeYYrealloc (void *, yy_size_t)
void	codeYYfree (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 void	saveObjCContext ()
static void	restoreObjCContext ()
static void	pushScope (const char *s)
static void	popScope ()
static void	setCurrentDoc (const QCString &anchor)
static void	addToSearchIndex (const char *text)
static void	setClassScope (const QCString &name)
static void	startCodeLine ()
static void	endFontClass ()
static void	startFontClass (const char *s)
static void	endCodeLine ()
static void	nextCodeLine ()
static void	codifyLines (const char *text)
static void	writeMultiLineCodeLink (CodeOutputInterface &ol, Definition *d, const char *text)
static void	addType ()
static void	addParmType ()
static void	addUsingDirective (const char *name)
static void	setParameterList (MemberDef *md)
static ClassDef *	stripClassName (const char *s, Definition *d=g_currentDefinition)
static MemberDef *	setCallContextForVar (const QCString &name)
static void	updateCallContextForSmartPointer ()
static bool	getLinkInScope (const QCString &c, const QCString &m, const char *memberText, CodeOutputInterface &ol, const char *text, bool varOnly=FALSE)
static bool	getLink (const char *className, const char *memberName, CodeOutputInterface &ol, const char *text=0, bool varOnly=FALSE)
static void	generateClassOrGlobalLink (CodeOutputInterface &ol, const char *clName, bool typeOnly=FALSE, bool varOnly=FALSE)
static bool	generateClassMemberLink (CodeOutputInterface &ol, MemberDef *xmd, const char *memName)
static bool	generateClassMemberLink (CodeOutputInterface &ol, Definition *def, const char *memName)
static void	generateMemberLink (CodeOutputInterface &ol, const QCString &varName, char *memName)
static void	generatePHPVariableLink (CodeOutputInterface &ol, const char *varName)
static void	generateFunctionLink (CodeOutputInterface &ol, const char *funcName)
static int	countLines ()
static void	writeObjCMethodCall (ObjCCallCtx *ctx)
static QCString	escapeName (const char *s)
static QCString	escapeObject (const char *s)
static QCString	escapeWord (const char *s)
static int	yyread (char *buf, int max_size)
static int	yy_init_globals (void)
int	codeYYlex_destroy (void)
int	codeYYget_debug (void)
void	codeYYset_debug (int debug_flag)
YY_EXTRA_TYPE	codeYYget_extra (void)
void	codeYYset_extra (YY_EXTRA_TYPE user_defined)
FILE *	codeYYget_in (void)
void	codeYYset_in (FILE *in_str)
FILE *	codeYYget_out (void)
void	codeYYset_out (FILE *out_str)
int	codeYYget_leng (void)
char *	codeYYget_text (void)
int	codeYYget_lineno (void)
void	codeYYset_lineno (int line_number)
static void	yyunput (int c, char *buf_ptr)
static int	input (void)
int	codeYYlex (void)
	if (!(yy_init))
	while (1)
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (yyconst char *msg)
void	resetCCodeParserState ()
void	parseCCode (CodeOutputInterface &od, const char *className, const QCString &s, SrcLangExt lang, bool exBlock, const char *exName, FileDef *fd, int startLine, int endLine, bool inlineFragment, MemberDef *memberDef, bool showLineNumbers, Definition *searchCtx, bool collectXRefs)
void	codeFreeScanner ()

Variables
int	codeYYleng
FILE *	codeYYin = (FILE *) 0
FILE *	codeYYout = (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	codeYYlineno = 1
char *	codeYYtext
static yyconst flex_int16_t	yy_acclist [6690]
static yyconst flex_int16_t	yy_accept [3538]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [85]
static yyconst flex_int32_t	yy_base [4112]
static yyconst flex_int16_t	yy_def [4112]
static yyconst flex_int16_t	yy_nxt [36458]
static yyconst flex_int16_t	yy_chk [36458]
int	codeYY_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 int	yy_looking_for_trail_begin = 0
static int	yy_full_lp
static int *	yy_full_state
static CodeOutputInterface *	g_code
static ClassSDict *	g_codeClassSDict = 0
static QCString	g_curClassName
static QStrList	g_curClassBases
static QCString	g_parmType
static QCString	g_parmName
static const char *	g_inputString
	the code fragment as text More...
static int	g_inputPosition
	read offset during parsing More...
static int	g_inputLines
	number of line in the code fragment More...
static int	g_yyLineNr
	current line number More...
static int	g_yyColNr
	current column number More...
static bool	g_needsTermination
static bool	g_exampleBlock
static QCString	g_exampleName
static QCString	g_exampleFile
static bool	g_insideTemplate = FALSE
static QCString	g_type
static QCString	g_name
static QCString	g_args
static QCString	g_classScope
static QCString	g_realScope
static QStack< int >	g_scopeStack
	1 if bracket starts a scope, More...
static int	g_anchorCount
static FileDef *	g_sourceFileDef
static bool	g_lineNumbers
static Definition *	g_currentDefinition
static MemberDef *	g_currentMemberDef
static bool	g_includeCodeFragment
static const char *	g_currentFontClass
static bool	g_searchingForBody
static bool	g_insideBody
static int	g_bodyCurlyCount
static QCString	g_saveName
static QCString	g_saveType
static QCString	g_delimiter
static int	g_bracketCount = 0
static int	g_curlyCount = 0
static int	g_sharpCount = 0
static bool	g_inFunctionTryBlock = FALSE
static bool	g_inForEachExpression = FALSE
static int	g_lastTemplCastContext
static int	g_lastSpecialCContext
static int	g_lastStringContext
static int	g_lastSkipCppContext
static int	g_lastVerbStringContext
static int	g_memCallContext
static int	g_lastCContext
static int	g_skipInlineInitContext
static bool	g_insideObjC
static bool	g_insideJava
static bool	g_insideCS
static bool	g_insidePHP
static bool	g_insideProtocolList
static bool	g_lexInit = FALSE
static QStack< int >	g_classScopeLengthStack
static Definition *	g_searchCtx
static bool	g_collectXRefs
static ObjCCallCtx *	g_currentCtx =0
static int	g_currentCtxId =0
static int	g_currentNameId =0
static int	g_currentObjId =0
static int	g_currentWordId =0
static QStack< ObjCCallCtx >	g_contextStack
static QIntDict< ObjCCallCtx >	g_contextDict
static QIntDict< QCString >	g_nameDict
static QIntDict< QCString >	g_objectDict
static QIntDict< QCString >	g_wordDict
static int	g_braceCount =0
static QCString	g_forceTagReference
static VariableContext	g_theVarContext
static CallContext	g_theCallContext
	YY_DECL
register char *	yy_cp
register char *	yy_bp
register int	yy_act

Macro Definition Documentation

#define AlignAs   15

Definition at line 12363 of file code.cpp.

#define AlignAsEnd   16

Definition at line 12364 of file code.cpp.

#define Bases   20

Definition at line 12368 of file code.cpp.

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 144 of file code.cpp.

#define Body   9

Definition at line 12357 of file code.cpp.

#define CallEnd   25

Definition at line 12373 of file code.cpp.

#define CLASSBLOCK   (int *)4

Definition at line 10589 of file code.cpp.

#define ClassName   14

Definition at line 12362 of file code.cpp.

#define ClassVar   18

Definition at line 12366 of file code.cpp.

#define codeYYwrap

(

n

)

1

Definition at line 354 of file code.cpp.

#define CppCliTypeModifierFollowup   19

Definition at line 12367 of file code.cpp.

#define DBG_CTX

(

x

)

do { } while(0)

Definition at line 10585 of file code.cpp.

#define ECHO   do { if (fwrite( codeYYtext, codeYYleng, 1, codeYYout )) {} } while (0)

Definition at line 12470 of file code.cpp.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file code.cpp.

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file code.cpp.

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file code.cpp.

#define FLEX_BETA

Definition at line 33 of file code.cpp.

#define FLEX_SCANNER

Definition at line 28 of file code.cpp.

#define FLEXINT_H

Definition at line 49 of file code.cpp.

#define FuncCall   10

Definition at line 12358 of file code.cpp.

#define INITIAL   0

Definition at line 12348 of file code.cpp.

#define InlineInit   35

Definition at line 12383 of file code.cpp.

#define INNERBLOCK   (int *)12

Definition at line 10591 of file code.cpp.

#define INT16_MAX   (32767)

Definition at line 92 of file code.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file code.cpp.

#define INT32_MAX   (2147483647)

Definition at line 95 of file code.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file code.cpp.

#define INT8_MAX   (127)

Definition at line 89 of file code.cpp.

#define INT8_MIN   (-128)

Definition at line 80 of file code.cpp.

#define MemberCall   11

Definition at line 12359 of file code.cpp.

#define MemberCall2   12

Definition at line 12360 of file code.cpp.

#define ObjCCall   29

Definition at line 12377 of file code.cpp.

#define ObjCMethod   26

Definition at line 12374 of file code.cpp.

#define ObjCMName   30

Definition at line 12378 of file code.cpp.

#define ObjCParams   27

Definition at line 12375 of file code.cpp.

#define ObjCParamType   28

Definition at line 12376 of file code.cpp.

#define ObjCSkipStr   31

Definition at line 12379 of file code.cpp.

#define OldStyleArgs   32

Definition at line 12380 of file code.cpp.

#define PackageName   17

Definition at line 12365 of file code.cpp.

#define RawString   34

Definition at line 12382 of file code.cpp.

#define ReadInclude   22

Definition at line 12370 of file code.cpp.

#define REJECT

Value:

{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */ \
yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
(yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
(yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
++(yy_lp); \
goto find_rule; \
}

Definition at line 10524 of file code.cpp.

#define RemoveSpecialCComment   7

Definition at line 12355 of file code.cpp.

#define SCOPEBLOCK   (int *)8

Definition at line 10590 of file code.cpp.

#define SkipComment   5

Definition at line 12353 of file code.cpp.

#define SkipCPP   4

Definition at line 12352 of file code.cpp.

#define SkipCxxComment   6

Definition at line 12354 of file code.cpp.

#define SkipInits   13

Definition at line 12361 of file code.cpp.

#define SkipSharp   21

Definition at line 12369 of file code.cpp.

#define SkipString   1

Definition at line 12349 of file code.cpp.

#define SkipStringS   2

Definition at line 12350 of file code.cpp.

#define SkipVerbString   3

Definition at line 12351 of file code.cpp.

#define StripSpecialCComment   8

Definition at line 12356 of file code.cpp.

#define TemplCast   24

Definition at line 12372 of file code.cpp.

#define TemplDecl   23

Definition at line 12371 of file code.cpp.

#define UINT16_MAX   (65535U)

Definition at line 101 of file code.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file code.cpp.

#define UINT8_MAX   (255U)

Definition at line 98 of file code.cpp.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 199 of file code.cpp.

#define UsingName   33

Definition at line 12381 of file code.cpp.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 350 of file code.cpp.

#define YY_BREAK   break;

Definition at line 12549 of file code.cpp.

#define YY_BUF_SIZE   16384

Definition at line 163 of file code.cpp.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 266 of file code.cpp.

#define YY_BUFFER_NEW   0

Definition at line 254 of file code.cpp.

#define YY_BUFFER_NORMAL   1

Definition at line 255 of file code.cpp.

#define yy_create_buffer   codeYY_create_buffer

Definition at line 9 of file code.cpp.

#define YY_CURRENT_BUFFER

Value:

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

Definition at line 282 of file code.cpp.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 289 of file code.cpp.

#define YY_DECL   int codeYYlex (void)

Definition at line 12537 of file code.cpp.

#define YY_DECL_IS_OURS   1

Definition at line 12533 of file code.cpp.

#define yy_delete_buffer   codeYY_delete_buffer

Definition at line 10 of file code.cpp.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
	codeYYleng = (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 code.cpp.

#define YY_END_OF_BUFFER   215

Definition at line 386 of file code.cpp.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 159 of file code.cpp.

#define YY_EXIT_FAILURE   2

Definition at line 16117 of file code.cpp.

#define YY_EXTRA_TYPE   void *

Definition at line 12394 of file code.cpp.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 12524 of file code.cpp.

#define yy_flex_debug   codeYY_flex_debug

Definition at line 11 of file code.cpp.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file code.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file code.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file code.cpp.

#define yy_flush_buffer   codeYY_flush_buffer

Definition at line 13 of file code.cpp.

#define YY_FLUSH_BUFFER   codeYY_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 318 of file code.cpp.

#define yy_init_buffer   codeYY_init_buffer

Definition at line 12 of file code.cpp.

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

Definition at line 12298 of file code.cpp.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file code.cpp.

#define YY_LESS_LINENO

(

n

)

Definition at line 183 of file code.cpp.

#define yy_load_buffer_state   codeYY_load_buffer_state

Definition at line 14 of file code.cpp.

#define YY_MORE_ADJ   0

Definition at line 10536 of file code.cpp.

#define yy_new_buffer   codeYY_create_buffer

Definition at line 328 of file code.cpp.

#define YY_NEW_FILE   codeYYrestart(codeYYin )

Definition at line 157 of file code.cpp.

#define YY_NO_UNISTD_H   1

Definition at line 10587 of file code.cpp.

#define YY_NULL   0

Definition at line 131 of file code.cpp.

#define YY_NUM_RULES   214

Definition at line 385 of file code.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 12462 of file code.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 10537 of file code.cpp.

#define YY_RULE_SETUP

Value:

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

Definition at line 12552 of file code.cpp.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 138 of file code.cpp.

#define yy_set_bol

(

at_bol

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        codeYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            codeYY_create_buffer(codeYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 340 of file code.cpp.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        codeYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            codeYY_create_buffer(codeYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 330 of file code.cpp.

#define YY_SKIP_YYWRAP

Definition at line 355 of file code.cpp.

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

Definition at line 150 of file code.cpp.

#define YY_START_STACK_INCR   25

Definition at line 12519 of file code.cpp.

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

Definition at line 168 of file code.cpp.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 154 of file code.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 207 of file code.cpp.

#define yy_switch_to_buffer   codeYY_switch_to_buffer

Definition at line 15 of file code.cpp.

#define YY_TRAILING_HEAD_MASK   0x4000

Definition at line 10523 of file code.cpp.

#define YY_TRAILING_MASK   0x2000

Definition at line 10522 of file code.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 171 of file code.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 202 of file code.cpp.

#define YY_USER_ACTION

Definition at line 12544 of file code.cpp.

#define yyalloc   codeYYalloc

Definition at line 24 of file code.cpp.

#define yyconst

Definition at line 127 of file code.cpp.

#define yyfree   codeYYfree

Definition at line 26 of file code.cpp.

#define yyin   codeYYin

Definition at line 16 of file code.cpp.

#define yyleng   codeYYleng

Definition at line 17 of file code.cpp.

#define yyless

(

n

)

Value:

do \
                { \
                /* Undo effects of setting up codeYYtext. */ \
        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 codeYYtext again */ \
                } \
	while ( 0 )

Definition at line 16129 of file code.cpp.

#define yyless

(

n

)

Value:

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

Definition at line 16129 of file code.cpp.

#define yylex   codeYYlex

Definition at line 18 of file code.cpp.

#define yylineno   codeYYlineno

Definition at line 19 of file code.cpp.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 10535 of file code.cpp.

#define yyout   codeYYout

Definition at line 20 of file code.cpp.

#define yyrealloc   codeYYrealloc

Definition at line 25 of file code.cpp.

#define yyrestart   codeYYrestart

Definition at line 21 of file code.cpp.

#define YYSTATE   YY_START

Definition at line 151 of file code.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 16327 of file code.cpp.

#define yyterminate

(

)

return YY_NULL

Definition at line 12514 of file code.cpp.

#define yytext   codeYYtext

Definition at line 22 of file code.cpp.

#define yytext_ptr   codeYYtext

Definition at line 368 of file code.cpp.

#define yywrap   codeYYwrap

Definition at line 23 of file code.cpp.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 71 of file code.cpp.

typedef int flex_int32_t

Definition at line 72 of file code.cpp.

typedef signed char flex_int8_t

Definition at line 70 of file code.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file code.cpp.

typedef unsigned int flex_uint32_t

Definition at line 75 of file code.cpp.

typedef unsigned char flex_uint8_t

Definition at line 73 of file code.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 172 of file code.cpp.

typedef unsigned char YY_CHAR

Definition at line 357 of file code.cpp.

typedef size_t yy_size_t

Definition at line 203 of file code.cpp.

typedef int yy_state_type

Definition at line 361 of file code.cpp.

Function Documentation

static void addParmType ( )

static

Definition at line 11186 of file code.cpp.

{
  if (g_parmName=="const") { g_parmName.resize(0); return; }
  if (!g_parmType.isEmpty()) g_parmType += ' ' ;
  g_parmType += g_parmName ;
  g_parmName.resize(0) ;
}

static void addToSearchIndex ( const char *  text )

static

Definition at line 10981 of file code.cpp.

{
  if (Doxygen::searchIndex)
  {
    g_code->addWord(text,FALSE);
  }
}

static void addType ( )

static

Definition at line 11175 of file code.cpp.

{
  if (g_name=="const") { g_name.resize(0); return; }
  if (!g_type.isEmpty()) g_type += ' ' ;
  g_type += g_name ;
  g_name.resize(0) ;
  if (!g_type.isEmpty()) g_type += ' ' ;
  g_type += g_args ;
  g_args.resize(0) ;
}

static void addUsingDirective ( const char *  name )

static

Definition at line 11194 of file code.cpp.

{
  if (g_sourceFileDef && name)
  {
    NamespaceDef *nd = Doxygen::namespaceSDict->find(name);
    if (nd)
    {
      g_sourceFileDef->addUsingDirective(nd);
    }
  }
}

void codeFreeScanner

(

)

Definition at line 16505 of file code.cpp.

{
#if defined(YY_FLEX_SUBMINOR_VERSION) 
  if (g_lexInit)
  {
    codeYYlex_destroy();
  }
#endif
}

YY_BUFFER_STATE codeYY_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 15834 of file code.cpp.

{
        YY_BUFFER_STATE b;
    
        b = (YY_BUFFER_STATE) codeYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in codeYY_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 *) codeYYalloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR( "out of dynamic memory in codeYY_create_buffer()" );

        b->yy_is_our_buffer = 1;

        codeYY_init_buffer(b,file );

        return b;
}

void codeYY_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with codeYY_create_buffer()

Definition at line 15862 of file code.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 )
                codeYYfree((void *) b->yy_ch_buf  );

        codeYYfree((void *) b  );
}

void codeYY_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 15909 of file code.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 )
                codeYY_load_buffer_state( );
}

static void codeYY_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 15881 of file code.cpp.

{
        int oerrno = errno;
    
        codeYY_flush_buffer(b );

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

    /* If b is the current buffer, then codeYY_init_buffer was _probably_
     * called from codeYYrestart() 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 codeYY_load_buffer_state ( void  )

static

Definition at line 15820 of file code.cpp.

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

YY_BUFFER_STATE codeYY_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 16036 of file code.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) codeYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in codeYY_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;

        codeYY_switch_to_buffer(b  );

        return b;
}

YY_BUFFER_STATE codeYY_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

Setup the input buffer state to scan the given bytes. The next call to codeYYlex() 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 16086 of file code.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 *) codeYYalloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in codeYY_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 = codeYY_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in codeYY_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 codeYY_scan_string

(

yyconst char *

yystr

)

Setup the input buffer state to scan a string. The next call to codeYYlex() 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 codeYY_scan_bytes() instead.

Definition at line 16073 of file code.cpp.

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

void codeYY_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 15789 of file code.cpp.

{
    
        /* TODO. We should be able to replace this entire function body
         * with
         *              codeYYpop_buffer_state();
         *              codeYYpush_buffer_state(new_buffer);
     */
        codeYYensure_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;
        codeYY_load_buffer_state( );

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

void * codeYYalloc

(

yy_size_t

size

)

Definition at line 16305 of file code.cpp.

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

static void codeYYensure_buffer_stack ( void  )

static

Definition at line 15987 of file code.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**)codeYYalloc
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in codeYYensure_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**)codeYYrealloc
                                                                ((yy_buffer_stack),
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in codeYYensure_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 codeYYfree

(

void *

ptr

)

Definition at line 16322 of file code.cpp.

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

int codeYYget_debug

(

void

)

Definition at line 16213 of file code.cpp.

{
        return codeYY_flex_debug;
}

YY_EXTRA_TYPE codeYYget_extra

(

void

)

FILE * codeYYget_in

(

void

)

Get the input stream.

Definition at line 16157 of file code.cpp.

{
        return codeYYin;
}

int codeYYget_leng

(

void

)

Get the length of the current token.

Definition at line 16173 of file code.cpp.

{
        return codeYYleng;
}

int codeYYget_lineno

(

void

)

Get the current line number.

Definition at line 16148 of file code.cpp.

{
        
    return codeYYlineno;
}

FILE * codeYYget_out

(

void

)

Get the output stream.

Definition at line 16165 of file code.cpp.

{
        return codeYYout;
}

char * codeYYget_text

(

void

)

Get the current token.

Definition at line 16182 of file code.cpp.

{
        return codeYYtext;
}

int codeYYlex

(

void

)

int codeYYlex_destroy

(

void

)

Definition at line 16257 of file code.cpp.

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

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

    codeYYfree ( (yy_state_buf) );
    (yy_state_buf)  = NULL;

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

    return 0;
}

void codeYYpop_buffer_state

(

void

)

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

Definition at line 15968 of file code.cpp.

{
        if (!YY_CURRENT_BUFFER)
                return;

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

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

void codeYYpush_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 15938 of file code.cpp.

{
        if (new_buffer == NULL)
                return;

        codeYYensure_buffer_stack();

        /* This block is copied from codeYY_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 codeYY_switch_to_buffer. */
        codeYY_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
}

void * codeYYrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 16310 of file code.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 codeYYrestart

(

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 15772 of file code.cpp.

{
    
        if ( ! YY_CURRENT_BUFFER ){
        codeYYensure_buffer_stack ();
                YY_CURRENT_BUFFER_LVALUE =
            codeYY_create_buffer(codeYYin,YY_BUF_SIZE );
        }

        codeYY_init_buffer(YY_CURRENT_BUFFER,input_file );
        codeYY_load_buffer_state( );
}

void codeYYset_debug

(

int

debug_flag

)

Definition at line 16218 of file code.cpp.

{
        codeYY_flex_debug = bdebug ;
}

void codeYYset_extra

(

YY_EXTRA_TYPE

user_defined

)

void codeYYset_in

(

FILE *

in_str

)

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

Parameters

in_str

A readable stream.

See also

codeYY_switch_to_buffer

Definition at line 16203 of file code.cpp.

{
        codeYYin = in_str ;
}

void codeYYset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

Definition at line 16191 of file code.cpp.

{
    
    codeYYlineno = line_number;
}

void codeYYset_out

(

FILE *

out_str

)

Definition at line 16208 of file code.cpp.

{
        codeYYout = out_str ;
}

static void codifyLines ( const char *  text )

static

write a code fragment `text' that may span multiple lines, inserting line numbers for each line.

Definition at line 11102 of file code.cpp.

{
  //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text);
  const char *p=text,*sp=p;
  char c;
  bool done=FALSE;
  while (!done)
  {
    sp=p;
    while ((c=*p++) && c!='\n') { g_yyColNr++; }
    if (c=='\n')
    {
      g_yyLineNr++;
      g_yyColNr=1;
      //*(p-1)='\0';
      int l = (int)(p-sp-1);
      char *tmp = (char*)malloc(l+1);
      memcpy(tmp,sp,l);
      tmp[l]='\0';
      g_code->codify(tmp);
      free(tmp);
      nextCodeLine();
    }
    else
    {
      g_code->codify(sp);
      done=TRUE;
    }
  }
}

static int countLines ( )

static

counts the number of lines in the input

Definition at line 11943 of file code.cpp.

{
  const char *p=g_inputString;
  char c;
  int count=1;
  while ((c=*p)) 
  { 
    p++ ; 
    if (c=='\n') count++;  
  }
  if (p>g_inputString && *(p-1)!='\n') 
  { // last line does not end with a \n, so we add an extra
    // line and explicitly terminate the line after parsing.
    count++, 
    g_needsTermination=TRUE; 
  } 
  return count;
}

static void endCodeLine ( )

static

Definition at line 11081 of file code.cpp.

{
  DBG_CTX((stderr,"endCodeLine(%d)\n",g_yyLineNr));
  endFontClass();
  g_code->endCodeLine();
}

static void endFontClass ( )

static

Definition at line 11962 of file code.cpp.

{
  if (g_currentFontClass)
  {
    g_code->endFontClass();
    g_currentFontClass=0;
  }
}

static QCString escapeName ( const char *  s )

static

Definition at line 12268 of file code.cpp.

{
  QCString result;
  result.sprintf("$n%d",g_currentNameId);
  g_nameDict.insert(g_currentNameId,new QCString(s));
  g_currentNameId++;
  return result;
}

static QCString escapeObject ( const char *  s )

static

Definition at line 12277 of file code.cpp.

{
  QCString result;
  result.sprintf("$o%d",g_currentObjId);
  g_objectDict.insert(g_currentObjId,new QCString(s));
  g_currentObjId++;
  return result;
}

static QCString escapeWord ( const char *  s )

static

Definition at line 12286 of file code.cpp.

{
  QCString result;
  result.sprintf("$w%d",g_currentWordId);
  g_wordDict.insert(g_currentWordId,new QCString(s));
  g_currentWordId++;
  return result;
}

static bool generateClassMemberLink ( CodeOutputInterface &  ol, MemberDef *  xmd, const char *  memName  )

static

Definition at line 11638 of file code.cpp.

{
  // extract class definition of the return type in order to resolve
  // a->b()->c() like call chains

  //printf("type=`%s' args=`%s' class=%s\n",
  //  xmd->typeString(),xmd->argsString(),
  //  xmd->getClassDef()->name().data());

  if (g_exampleBlock)
  {
    QCString anchor;
    anchor.sprintf("a%d",g_anchorCount);
    //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),
    //                                  g_exampleFile.data());
    if (xmd->addExample(anchor,g_exampleName,g_exampleFile))
    {
      ol.writeCodeAnchor(anchor);
      g_anchorCount++;
    }
  }

  ClassDef *typeClass = stripClassName(removeAnonymousScopes(xmd->typeString()),xmd->getOuterScope());
  DBG_CTX((stderr,"%s -> typeName=%p\n",xmd->typeString(),typeClass));
  g_theCallContext.setScope(typeClass);

  Definition *xd = xmd->getOuterScope()==Doxygen::globalScope ?
                   xmd->getFileDef() : xmd->getOuterScope();
  if (xmd->getGroupDef()) xd = xmd->getGroupDef();
  if (xd && xd->isLinkable())
  {

    //printf("g_currentDefiniton=%p g_currentMemberDef=%p xmd=%p g_insideBody=%d\n",g_currentDefinition,g_currentMemberDef,xmd,g_insideBody);

    if (xmd->templateMaster()) xmd = xmd->templateMaster();

    if (xmd->isLinkable())
    {
      // add usage reference
      if (g_currentDefinition && g_currentMemberDef &&
          /*xmd!=g_currentMemberDef &&*/ g_insideBody && g_collectXRefs)
      {
        addDocCrossReference(g_currentMemberDef,xmd);
      }

      // write the actual link
      writeMultiLineCodeLink(ol,xmd,memName);
      addToSearchIndex(memName);
      return TRUE;
    }
  }

  return FALSE;
}

static bool generateClassMemberLink ( CodeOutputInterface &  ol, Definition *  def, const char *  memName  )

static

Definition at line 11693 of file code.cpp.

{
  if (def && def->definitionType()==Definition::TypeClass)
  {
    ClassDef *cd = (ClassDef*)def;
    MemberDef *xmd = cd->getMemberByName(memName);
    //printf("generateClassMemberLink(class=%s,member=%s)=%p\n",def->name().data(),memName,xmd);
    if (xmd)
    {
      return generateClassMemberLink(ol,xmd,memName);
    }
    else
    {
      Definition *innerDef = cd->findInnerCompound(memName);
      if (innerDef)
      {
        g_theCallContext.setScope(innerDef);
        addToSearchIndex(memName);
        writeMultiLineCodeLink(*g_code,innerDef,memName);
        return TRUE;
      }
    }
  }
  else if (def && def->definitionType()==Definition::TypeNamespace)
  {
    NamespaceDef *nd = (NamespaceDef*)def;
    //printf("Looking for %s inside namespace %s\n",memName,nd->name().data());
    Definition *innerDef = nd->findInnerCompound(memName);
    if (innerDef)
    {
      g_theCallContext.setScope(innerDef);
      addToSearchIndex(memName);
      writeMultiLineCodeLink(*g_code,innerDef,memName);
      return TRUE;
    }
  }
  return FALSE;
}

static void generateClassOrGlobalLink ( CodeOutputInterface &  ol, const char *  clName, bool  typeOnly = FALSE, bool  varOnly = FALSE  )

static

Definition at line 11461 of file code.cpp.

{
  int i=0;
  if (*clName=='~') // correct for matching negated values i.s.o. destructors.
  {
    g_code->codify("~");
    clName++;
  }
  QCString className=clName;
  if (className.isEmpty()) return;
  if (g_insideProtocolList) // for Obj-C
  {
    className+="-p";
  }
  if (g_insidePHP)
  {
    className = substitute(className,"\\","::"); // for PHP namespaces
  }
  else if (g_insideCS || g_insideJava)
  {
    className = substitute(className,".","::"); // for PHP namespaces
  }
  ClassDef *cd=0,*lcd=0;
  MemberDef *md=0;
  bool isLocal=FALSE;

  //printf("generateClassOrGlobalLink(className=%s)\n",className.data());
  if ((lcd=g_theVarContext.findVariable(className))==0) // not a local variable
  {
    Definition *d = g_currentDefinition;
    //printf("d=%s g_sourceFileDef=%s\n",d?d->name().data():"<none>",g_sourceFileDef?g_sourceFileDef->name().data():"<none>");
    cd = getResolvedClass(d,g_sourceFileDef,className,&md);
    DBG_CTX((stderr,"non-local variable name=%s context=%d cd=%s md=%s!\n",
    className.data(),g_theVarContext.count(),cd?cd->name().data():"<none>",
        md?md->name().data():"<none>"));
    if (cd==0 && md==0 && (i=className.find('<'))!=-1)
    {
      QCString bareName = className.left(i); //stripTemplateSpecifiersFromScope(className);
      DBG_CTX((stderr,"bareName=%s\n",bareName.data()));
      if (bareName!=className)
      {
        cd=getResolvedClass(d,g_sourceFileDef,bareName,&md); // try unspecialized version
      }
    }
    NamespaceDef *nd = getResolvedNamespace(className);
    if (nd)
    {
      g_theCallContext.setScope(nd);
      addToSearchIndex(className);
      writeMultiLineCodeLink(*g_code,nd,clName);
      return;
    }
    //printf("md=%s\n",md?md->name().data():"<none>");
    DBG_CTX((stderr,"is found as a type cd=%s nd=%s\n",
          cd?cd->name().data():"<null>",
          nd?nd->name().data():"<null>"));
    if (cd==0 && md==0) // also see if it is variable or enum or enum value
    {
      if (getLink(g_classScope,clName,ol,clName,varOnly))
      {
        return;
      }
    }
  }
  else
  {
    //printf("local variable!\n");
    if (lcd!=VariableContext::dummyContext) 
    {
      //printf("non-dummy context lcd=%s!\n",lcd->name().data());
      g_theCallContext.setScope(lcd);

      // to following is needed for links to a global variable, but is
      // no good for a link to a local variable that is also a global symbol.
       
      //if (getLink(g_classScope,clName,ol,clName))
      //{
        //return;
      //}
    }
    isLocal=TRUE;
    DBG_CTX((stderr,"is a local variable cd=%p!\n",cd));
  }
  if (cd && cd->isLinkable()) // is it a linkable class
  {
    DBG_CTX((stderr,"is linkable class %s\n",clName));
    if (g_exampleBlock)
    {
      QCString anchor;
      anchor.sprintf("_a%d",g_anchorCount);
      //printf("addExampleClass(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),
      //                                   g_exampleFile.data());
      if (cd->addExample(anchor,g_exampleName,g_exampleFile))
      {
        ol.writeCodeAnchor(anchor);
        g_anchorCount++;
      }
    }
    writeMultiLineCodeLink(ol,cd,clName);
    addToSearchIndex(className);
    g_theCallContext.setScope(cd);
    if (md)
    {
      Definition *d = md->getOuterScope()==Doxygen::globalScope ?
                      md->getFileDef() : md->getOuterScope();
      if (md->getGroupDef()) d = md->getGroupDef();
      if (d && d->isLinkable() && md->isLinkable() && 
          g_currentMemberDef && g_collectXRefs)
      {
        addDocCrossReference(g_currentMemberDef,md);
      }
    }
  }
  else // not a class, maybe a global member
  {
    DBG_CTX((stderr,"class %s not linkable! cd=%p md=%p typeOnly=%d\n",clName,cd,md,typeOnly));
    if (!isLocal && (md!=0 || (cd==0 && !typeOnly))) // not a class, see if it is a global enum/variable/typedef.
    {
      if (md==0) // not found as a typedef
      {
        md = setCallContextForVar(clName);
        //printf("setCallContextForVar(%s) md=%p g_currentDefinition=%p\n",clName,md,g_currentDefinition);
        if (md && g_currentDefinition)
        {
          DBG_CTX((stderr,"%s accessible from %s? %d md->getOuterScope=%s\n",
              md->name().data(),g_currentDefinition->name().data(),
              isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md),
              md->getOuterScope()->name().data()));
        }
             
        if (md && g_currentDefinition && 
            isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md)==-1)
        {
          md=0; // variable not accessible
        }
      }
      if (md && (!varOnly || md->isVariable()))
      {
        DBG_CTX((stderr,"is a global md=%p g_currentDefinition=%s linkable=%d\n",md,g_currentDefinition?g_currentDefinition->name().data():"<none>",md->isLinkable()));
        if (md->isLinkable())
        {
          QCString text;
          if (!g_forceTagReference.isEmpty()) // explicit reference to symbol in tag file
          {
            text=g_forceTagReference;
            if (text.right(4)==".tag") // strip .tag if present
            {
              text=text.left(text.length()-4);
            }
            text+=getLanguageSpecificSeparator(md->getLanguage());
            text+=clName;
            md->setName(text);
            md->setLocalName(text);
          }
          else // normal reference
          {
            text=clName;
          }
          writeMultiLineCodeLink(ol,md,text);
          addToSearchIndex(clName);
          if (g_currentMemberDef && g_collectXRefs)
          {
            addDocCrossReference(g_currentMemberDef,md);
          }
          return;
        }
      }
    }
    
    // nothing found, just write out the word
    DBG_CTX((stderr,"not found!\n"));
    codifyLines(clName);
    addToSearchIndex(clName);
  }
}

static void generateFunctionLink ( CodeOutputInterface &  ol, const char *  funcName  )

static

Definition at line 11841 of file code.cpp.

{
  //CodeClassDef *ccd=0;
  ClassDef *ccd=0;
  QCString locScope=g_classScope;
  QCString locFunc=removeRedundantWhiteSpace(funcName);
  QCString funcScope;
  QCString funcWithScope=locFunc;
  QCString funcWithFullScope=locFunc;
  QCString fullScope=locScope;
  DBG_CTX((stdout,"*** locScope=%s locFunc=%s\n",locScope.data(),locFunc.data()));
  int len=2;
  int i=locFunc.findRev("::");
  if (g_currentMemberDef && g_currentMemberDef->getClassDef() &&
      funcName==g_currentMemberDef->localName() && 
      g_currentMemberDef->getDefLine()==g_yyLineNr &&
      generateClassMemberLink(ol,g_currentMemberDef,funcName)
     )
  {
    // special case where funcName is the name of a method that is also
    // defined on this line. In this case we can directly link to 
    // g_currentMemberDef, which is not only faster, but
    // in case of overloaded methods, this will make sure that we link to
    // the correct method, and thereby get the correct reimplemented relations.
    // See also bug 549022.
    goto exit;
  }
  if (i==-1) i=locFunc.findRev("."),len=1;
  if (i==-1) i=locFunc.findRev("\\"),len=1; // for PHP
  if (i>0)
  {
    funcScope=locFunc.left(i);
    locFunc=locFunc.right(locFunc.length()-i-len).stripWhiteSpace();
    int ts=locScope.find('<'); // start of template
    int te=locScope.findRev('>'); // end of template
    //printf("ts=%d te=%d\n",ts,te);
    if (ts!=-1 && te!=-1 && te>ts)
    {
      // remove template from scope
      locScope=locScope.left(ts)+locScope.right(locScope.length()-te-1);
    }
    ts=funcScope.find('<'); // start of template
    te=funcScope.findRev('>'); // end of template
    //printf("ts=%d te=%d\n",ts,te);
    if (ts!=-1 && te!=-1 && te>ts)
    {
      // remove template from scope
      funcScope=funcScope.left(ts)+funcScope.right(funcScope.length()-te-1);
    }
    if (!funcScope.isEmpty())
    {
      funcWithScope = funcScope+"::"+locFunc;
      if (!locScope.isEmpty())
      {
        fullScope=locScope+"::"+funcScope;
      }
    }
    if (!locScope.isEmpty())
    {
      funcWithFullScope = locScope+"::"+funcWithScope;
    }
  }
  if (!fullScope.isEmpty() && (ccd=g_codeClassSDict->find(fullScope)))
  {
    //printf("using classScope %s\n",g_classScope.data());
    if (ccd->baseClasses())
    {
      BaseClassListIterator bcli(*ccd->baseClasses());
      for ( ; bcli.current() ; ++bcli)
      {
        if (getLink(bcli.current()->classDef->name(),locFunc,ol,funcName)) 
        {
          goto exit;
        }
      }
    }
  }
  if (!locScope.isEmpty() && fullScope!=locScope && (ccd=g_codeClassSDict->find(locScope)))
  {
    //printf("using classScope %s\n",g_classScope.data());
    if (ccd->baseClasses())
    {
      BaseClassListIterator bcli(*ccd->baseClasses());
      for ( ; bcli.current() ; ++bcli)
      {
        if (getLink(bcli.current()->classDef->name(),funcWithScope,ol,funcName)) 
        {
          goto exit;
        }
      }
    }
  }
  if (!getLink(locScope,funcWithScope,ol,funcName))
  {
    generateClassOrGlobalLink(ol,funcName);
  }
exit:  
  g_forceTagReference.resize(0);
  return;
}

static void generateMemberLink ( CodeOutputInterface &  ol, const QCString &  varName, char *  memName  )

static

Definition at line 11732 of file code.cpp.

{
  //printf("generateMemberLink(object=%s,mem=%s) classScope=%s\n",
  //    varName.data(),memName,g_classScope.data());

  if (varName.isEmpty()) return;

  // look for the variable in the current context
  ClassDef *vcd = g_theVarContext.findVariable(varName);
  if (vcd) 
  {
    if (vcd!=VariableContext::dummyContext)
    {
      //printf("Class found!\n");
      if (getLink(vcd->name(),memName,ol)) 
      {
        //printf("Found result!\n");
        return;
      }
      if (vcd->baseClasses())
      {
        BaseClassListIterator bcli(*vcd->baseClasses());
        for ( ; bcli.current() ; ++bcli)
        {
          if (getLink(bcli.current()->classDef->name(),memName,ol)) 
          {
            //printf("Found result!\n");
            return;
          }
        }
      }
    }
  }
  else // variable not in current context, maybe it is in a parent context
  {
    vcd = getResolvedClass(g_currentDefinition,g_sourceFileDef,g_classScope);
    if (vcd && vcd->isLinkable())
    {
      //printf("Found class %s for variable `%s'\n",g_classScope.data(),varName.data());
      MemberName *vmn=Doxygen::memberNameSDict->find(varName);
      if (vmn==0)
      {
        int vi;
        QCString vn=varName;
        if ((vi=vn.findRev("::"))!=-1 || (vi=vn.findRev('.'))!=-1)  // explicit scope A::b(), probably static member
        {
          ClassDef *jcd = getClass(vn.left(vi));
          vn=vn.right(vn.length()-vi-2);
          vmn=Doxygen::memberNameSDict->find(vn);
          //printf("Trying name `%s' scope=%s\n",vn.data(),scope.data());
          if (vmn)
          {
            MemberNameIterator vmni(*vmn);
            MemberDef *vmd;
            for (;(vmd=vmni.current());++vmni)
            {
              if (/*(vmd->isVariable() || vmd->isFunction()) && */
                  vmd->getClassDef()==jcd)
              {
                //printf("Found variable type=%s\n",vmd->typeString());
                ClassDef *mcd=stripClassName(vmd->typeString(),vmd->getOuterScope());
                if (mcd && mcd->isLinkable())
                {
                  if (generateClassMemberLink(ol,mcd,memName)) return;
                }
              }
            }
          }
        }
      }
      if (vmn)
      {
        //printf("There is a variable with name `%s'\n",varName);
        MemberNameIterator vmni(*vmn);
        MemberDef *vmd;
        for (;(vmd=vmni.current());++vmni)
        {
          if (/*(vmd->isVariable() || vmd->isFunction()) && */
              vmd->getClassDef()==vcd)
          {
            //printf("Found variable type=%s\n",vmd->typeString());
            ClassDef *mcd=stripClassName(vmd->typeString(),vmd->getOuterScope());
            if (mcd && mcd->isLinkable())
            {
              if (generateClassMemberLink(ol,mcd,memName)) return;
            }
          }
        }
      }
    }
  }
  // nothing found -> write result as is
  codifyLines(memName);
  addToSearchIndex(memName);
  return;
}

static void generatePHPVariableLink ( CodeOutputInterface &  ol, const char *  varName  )

static

Definition at line 11830 of file code.cpp.

{
  QCString name = varName+7; // strip $this->
  name.prepend("$");
  //printf("generatePHPVariableLink(%s) name=%s scope=%s\n",varName,name.data(),g_classScope.data());
  if (!getLink(g_classScope,name,ol,varName))
  {
    codifyLines(varName);
  }
}

static bool getLink ( const char *  className, const char *  memberName, CodeOutputInterface &  ol, const char *  text = 0, bool  varOnly = FALSE  )

static

Definition at line 11439 of file code.cpp.

{
  //printf("getLink(%s,%s) g_curClassName=%s\n",className,memberName,g_curClassName.data());
  QCString m=removeRedundantWhiteSpace(memberName);
  QCString c=className;
  if (!getLinkInScope(c,m,memberName,ol,text,varOnly))
  {
    if (!g_curClassName.isEmpty())
    {
      if (!c.isEmpty()) c.prepend("::");
      c.prepend(g_curClassName);
      return getLinkInScope(c,m,memberName,ol,text,varOnly);
    }
    return FALSE;
  }
  return TRUE;
}

static bool getLinkInScope ( const QCString &  c, const QCString &  m, const char *  memberText, CodeOutputInterface &  ol, const char *  text, bool  varOnly = FALSE  )

static

Definition at line 11384 of file code.cpp.

{
  MemberDef    *md;
  ClassDef     *cd;
  FileDef      *fd;
  NamespaceDef *nd;
  GroupDef     *gd;
  DBG_CTX((stderr,"getLinkInScope: trying `%s'::`%s' varOnly=%d\n",c.data(),m.data(),varOnly));
  if (getDefs(c,m,"()",md,cd,fd,nd,gd,FALSE,g_sourceFileDef,FALSE,g_forceTagReference) && 
      md->isLinkable() && (!varOnly || md->isVariable()))
  {
    //printf("found it %s!\n",md->qualifiedName().data());
    if (g_exampleBlock)
    {
      QCString anchor;
      anchor.sprintf("a%d",g_anchorCount);
      //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),g_exampleName.data(),
      //                                  g_exampleFile.data());
      if (md->addExample(anchor,g_exampleName,g_exampleFile))
      {
        ol.writeCodeAnchor(anchor);
        g_anchorCount++;
      }
    }

    Definition *d = md->getOuterScope()==Doxygen::globalScope ?
                    md->getFileDef() : md->getOuterScope();
    if (md->getGroupDef()) d = md->getGroupDef();
    if (d && d->isLinkable())
    {
      g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
      //printf("g_currentDefinition=%p g_currentMemberDef=%p g_insideBody=%d\n",
      //        g_currentDefinition,g_currentMemberDef,g_insideBody);

      if (g_currentDefinition && g_currentMemberDef &&
          md!=g_currentMemberDef && g_insideBody && g_collectXRefs)
      {
        addDocCrossReference(g_currentMemberDef,md);
      }
      //printf("d->getReference()=`%s' d->getOutputBase()=`%s' name=`%s' member name=`%s'\n",d->getReference().data(),d->getOutputFileBase().data(),d->name().data(),md->name().data());
     
      writeMultiLineCodeLink(ol,md, text ? text : memberText);
      addToSearchIndex(text ? text : memberText);
      return TRUE;
    } 
  }
  return FALSE;
}

if

(

!

yy_init

)

Definition at line 12571 of file code.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 *)codeYYalloc(YY_STATE_BUF_SIZE  );
            if ( ! (yy_state_buf) )
                YY_FATAL_ERROR( "out of dynamic memory in codeYYlex()" );

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

                if ( ! codeYYin )
                        codeYYin = stdin;

                if ( ! codeYYout )
                        codeYYout = stdout;

                if ( ! YY_CURRENT_BUFFER ) {
                        codeYYensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
                                codeYY_create_buffer(codeYYin,YY_BUF_SIZE );
                }

                codeYY_load_buffer_state( );
                }

static int input ( void  )

static

Definition at line 15695 of file code.cpp.

{
        int c;
    
        *(yy_c_buf_p) = (yy_hold_char);

        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
                {
                /* yy_c_buf_p now points to the character we want to return.
                 * If this occurs *before* the EOB characters, then it's a
                 * valid NUL; if not, then we've hit the end of the buffer.
                 */
                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        /* This was really a NUL. */
                        *(yy_c_buf_p) = '\0';

                else
                        { /* need more input */
                        int offset = (yy_c_buf_p) - (yytext_ptr);
                        ++(yy_c_buf_p);

                        switch ( yy_get_next_buffer(  ) )
                                {
                                case EOB_ACT_LAST_MATCH:
                                        /* This happens because yy_g_n_b()
                                         * sees that we've accumulated a
                                         * token and flags that we need to
                                         * try matching the token before
                                         * proceeding.  But for input(),
                                         * there's no matching to consider.
                                         * So convert the EOB_ACT_LAST_MATCH
                                         * to EOB_ACT_END_OF_FILE.
                                         */

                                        /* Reset buffer status. */
                                        codeYYrestart(codeYYin );

                                        /*FALLTHROUGH*/

                                case EOB_ACT_END_OF_FILE:
                                        {
                                        if ( codeYYwrap( ) )
                                                return EOF;

                                        if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
#ifdef __cplusplus
                                        return yyinput();
#else
                                        return input();
#endif
                                        }

                                case EOB_ACT_CONTINUE_SCAN:
                                        (yy_c_buf_p) = (yytext_ptr) + offset;
                                        break;
                                }
                        }
                }

        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
        *(yy_c_buf_p) = '\0';   /* preserve codeYYtext */
        (yy_hold_char) = *++(yy_c_buf_p);

        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');

        return c;
}

static void nextCodeLine ( )

static

Definition at line 11088 of file code.cpp.

{
  const char * fc = g_currentFontClass;
  endCodeLine();
  if (g_yyLineNr<g_inputLines) 
  {
    g_currentFontClass = fc;
    startCodeLine();
  }
}

void parseCCode	(	CodeOutputInterface &	od,
		const char *	className,
		const QCString &	s,
		SrcLangExt	lang,
		bool	exBlock,
		const char *	exName,
		FileDef *	fd,
		int	startLine,
		int	endLine,
		bool	inlineFragment,
		MemberDef *	memberDef,
		bool	showLineNumbers,
		Definition *	searchCtx,
		bool	collectXRefs
	)

Definition at line 16397 of file code.cpp.

{
  //printf("***parseCode() exBlock=%d exName=%s fd=%p className=%s searchCtx=%s\n",
  //      exBlock,exName,fd,className,searchCtx?searchCtx->name().data():"<none>");

  if (s.isEmpty()) return;

  printlex(codeYY_flex_debug, TRUE, __FILE__, fd ? fd->fileName().data(): NULL);

  TooltipManager::instance()->clearTooltips();
  if (g_codeClassSDict==0)
  {
    resetCCodeParserState();
  }
  g_code = &od;
  g_inputString   = s;
  g_inputPosition = 0;
  g_currentFontClass = 0;
  g_needsTermination = FALSE;
  g_searchCtx = searchCtx;
  g_collectXRefs = collectXRefs;
  g_inFunctionTryBlock = FALSE;
  if (endLine!=-1)
    g_inputLines  = endLine+1;
  else
    g_inputLines  = countLines();

  if (startLine!=-1)
    g_yyLineNr    = startLine;
  else
    g_yyLineNr    = 1;

  g_curlyCount    = 0;
  g_bodyCurlyCount    = 0;
  g_bracketCount  = 0;
  g_sharpCount    = 0;
  g_insideTemplate = FALSE;
  g_theCallContext.clear();
  g_scopeStack.clear();
  g_classScope    = className;
  //printf("parseCCode %s\n",className);
  g_exampleBlock  = exBlock; 
  g_exampleName   = exName;
  g_sourceFileDef = fd;
  g_lineNumbers   = fd!=0 && showLineNumbers;
  bool cleanupSourceDef = FALSE;
  if (fd==0)
  {
    // create a dummy filedef for the example
    g_sourceFileDef = new FileDef("",(exName?exName:"generated"));
    cleanupSourceDef = TRUE;
  }
  g_insideObjC = lang==SrcLangExt_ObjC;
  g_insideJava = lang==SrcLangExt_Java;
  g_insideCS   = lang==SrcLangExt_CSharp;
  g_insidePHP  = lang==SrcLangExt_PHP;
  if (g_sourceFileDef) 
  {
    setCurrentDoc("l00001");
  }
  g_currentDefinition = 0;
  g_currentMemberDef = 0;
  g_searchingForBody = exBlock;
  g_insideBody = FALSE;
  g_bracketCount = 0;
  if (!g_exampleName.isEmpty())
  {
    g_exampleFile = convertNameToFile(g_exampleName+"-example",FALSE,TRUE);
    //printf("g_exampleFile=%s\n",g_exampleFile.data());
  }
  g_includeCodeFragment = inlineFragment;
  //printf("** exBlock=%d exName=%s include=%d\n",exBlock,exName,inlineFragment);
  startCodeLine();
  g_type.resize(0);
  g_name.resize(0);
  g_args.resize(0);
  g_parmName.resize(0);
  g_parmType.resize(0);
  if (memberDef) setParameterList(memberDef);
  codeYYrestart( codeYYin );
  BEGIN( Body );
  codeYYlex();
  g_lexInit=TRUE;
  if (g_needsTermination)
  {
    endFontClass();
    DBG_CTX((stderr,"endCodeLine(%d)\n",g_yyLineNr));
    g_code->endCodeLine();
  }
  if (fd)
  {
    TooltipManager::instance()->writeTooltips(*g_code);
  }
  if (cleanupSourceDef)
  {
    // delete the temporary file definition used for this example
    delete g_sourceFileDef;
    g_sourceFileDef=0;
  }

  printlex(codeYY_flex_debug, FALSE, __FILE__, fd ? fd->fileName().data(): NULL);
  return;
}

static void popScope ( )

static

remove the top class/namespace name from the scope

Definition at line 10951 of file code.cpp.

{
  if (!g_classScopeLengthStack.isEmpty())
  {
    int *pLength = g_classScopeLengthStack.pop();
    g_classScope.truncate(*pLength);
    delete pLength;
  }
  else
  {
    //err("Too many end of scopes found!\n");
  }
  //printf("popScope() result: `%s'\n",g_classScope.data());
}

static void pushScope ( const char *  s )

static

add class/namespace name s to the scope

Definition at line 10935 of file code.cpp.

{
  g_classScopeLengthStack.push(new int(g_classScope.length()));
  if (g_classScope.isEmpty() || leftScopeMatch(s,g_classScope))
  {
    g_classScope = s;
  }
  else
  {
    g_classScope += "::";
    g_classScope += s;
  }
  //printf("pushScope(%s) result: `%s'\n",s,g_classScope.data());
}

void resetCCodeParserState

(

)

Definition at line 16382 of file code.cpp.

{
  //printf("***initParseCodeContext()\n");
  g_forceTagReference.resize(0);
  g_theVarContext.clear();
  g_classScopeLengthStack.setAutoDelete(TRUE);
  g_classScopeLengthStack.clear();
  delete g_codeClassSDict;
  g_codeClassSDict = new ClassSDict(17);
  g_codeClassSDict->setAutoDelete(TRUE);
  g_codeClassSDict->clear();
  g_curClassBases.clear();
  g_anchorCount = 0;
}

static void restoreObjCContext ( )

static

Definition at line 16366 of file code.cpp.

{
  //printf("restore state=%d->%d\n",YY_START,g_currentCtx->lexState);
  BEGIN(g_currentCtx->lexState);
  g_braceCount = g_currentCtx->braceCount;
  if (!g_contextStack.isEmpty())
  {
    g_currentCtx = g_contextStack.pop();
  }
  else
  {
    g_currentCtx = 0;
    //printf("Trying to pop context while g_contextStack is empty!\n");
  }
}

static void saveObjCContext ( )

static

Definition at line 16336 of file code.cpp.

{
  if (g_currentCtx)
  {
    g_currentCtx->format+=QCString().sprintf("$c%d",g_currentCtxId);
    if (g_braceCount==0 && YY_START==ObjCCall)
    {
      g_currentCtx->objectTypeOrName=g_currentCtx->format.mid(1);
      //printf("new type=%s\n",g_currentCtx->objectTypeOrName.data());
    }
    g_contextStack.push(g_currentCtx);
  }
  else
  {
    //printf("Trying to save NULL context!\n");
  }
  ObjCCallCtx *newCtx = new ObjCCallCtx;
  newCtx->id = g_currentCtxId;
  newCtx->lexState = YY_START;
  newCtx->braceCount = g_braceCount;
  newCtx->objectType = 0;
  newCtx->objectVar = 0;
  newCtx->method = 0;
  //printf("save state=%d\n",YY_START);
  g_contextDict.insert(g_currentCtxId,newCtx);
  g_currentCtx = newCtx;
  g_braceCount = 0;
  g_currentCtxId++;
}

static MemberDef* setCallContextForVar ( const QCString &  name )

static

Definition at line 11255 of file code.cpp.

{
  if (name.isEmpty()) return 0;
  DBG_CTX((stderr,"setCallContextForVar(%s) g_classScope=%s\n",name.data(),g_classScope.data()));

  int scopeEnd = name.findRev("::");
  if (scopeEnd!=-1) // name with explicit scope
  {
    QCString scope   = name.left(scopeEnd);
    QCString locName = name.right(name.length()-scopeEnd-2);
    //printf("explicit scope: name=%s scope=%s\n",locName.data(),scope.data());
    ClassDef *mcd = getClass(scope); 
    if (mcd && !locName.isEmpty())
    {
      MemberDef *md=mcd->getMemberByName(locName);
      if (md)
      {
        //printf("name=%s scope=%s\n",locName.data(),scope.data());
        g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
        return md;
      }
    }
    else // check namespace as well
    {
      NamespaceDef *mnd = getResolvedNamespace(scope);
      if (mnd && !locName.isEmpty())
      {
        MemberDef *md=mnd->getMemberByName(locName);
        if (md)
        {
          //printf("name=%s scope=%s\n",locName.data(),scope.data());
          g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
          return md;
        }
      }
    }
  }
  
  MemberName *mn;
  ClassDef *mcd = g_theVarContext.findVariable(name);
  if (mcd) // local variable
  {
    DBG_CTX((stderr,"local variable?\n"));
    if (mcd!=VariableContext::dummyContext)
    {
      DBG_CTX((stderr,"local var `%s' mcd=%s\n",name.data(),mcd->name().data()));
      g_theCallContext.setScope(mcd);
    }
  }
  else
  {
    DBG_CTX((stderr,"class member? scope=%s\n",g_classScope.data()));
    // look for a class member 
    mcd = getClass(g_classScope);
    if (mcd)
    {
      DBG_CTX((stderr,"Inside class %s\n",mcd->name().data()));
      MemberDef *md=mcd->getMemberByName(name);
      if (md) 
      {
        DBG_CTX((stderr,"Found member %s\n",md->name().data()));
        if (g_scopeStack.top()!=CLASSBLOCK)
        {
          DBG_CTX((stderr,"class member `%s' mcd=%s\n",name.data(),mcd->name().data()));
          g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
        }
        return md;
      }
    }
  }

  // look for a global member
  if ((mn=Doxygen::functionNameSDict->find(name)))
  {
    //printf("global var `%s'\n",name.data());
    if (mn->count()==1) // global defined only once
    {
      MemberDef *md=mn->getFirst();
      if (!md->isStatic() || md->getBodyDef()==g_sourceFileDef)
      {
        g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
        return md;
      }
      return 0;
    }
    else if (mn->count()>1) // global defined more than once
    {
      MemberNameIterator it(*mn);
      MemberDef *md;
      for (;(md=it.current());++it)
      {
        //printf("mn=%p md=%p md->getBodyDef()=%p g_sourceFileDef=%p\n",
        //    mn,md,
        //    md->getBodyDef(),g_sourceFileDef);

        // in case there are multiple members we could link to, we 
        // only link to members if defined in the same file or 
        // defined as external.
        if ((!md->isStatic() || md->getBodyDef()==g_sourceFileDef) &&
            (g_forceTagReference.isEmpty() || g_forceTagReference==md->getReference())
           )
        {
          g_theCallContext.setScope(stripClassName(md->typeString(),md->getOuterScope()));
          //printf("returning member %s in source file %s\n",md->name().data(),g_sourceFileDef->name().data());
          return md;
        }
      }
      return 0;
    }
  }
  return 0;
}

static void setClassScope ( const QCString &  name )

static

Definition at line 10989 of file code.cpp.

{
  //printf("setClassScope(%s)\n",name.data());
  QCString n=name;
  n=n.simplifyWhiteSpace();
  int ts=n.find('<'); // start of template
  int te=n.findRev('>'); // end of template
  //printf("ts=%d te=%d\n",ts,te);
  if (ts!=-1 && te!=-1 && te>ts)
  {
    // remove template from scope
    n=n.left(ts)+n.right(n.length()-te-1);
  }
  while (!g_classScopeLengthStack.isEmpty())
  {
    popScope();
  }
  g_classScope.resize(0);
  int i;
  while ((i=n.find("::"))!=-1)
  {
    pushScope(n.left(i));
    n = n.mid(i+2);
  }
  pushScope(n);
  //printf("--->New class scope `%s'\n",g_classScope.data());
}

static void setCurrentDoc ( const QCString &  anchor )

static

Definition at line 10966 of file code.cpp.

{
  if (Doxygen::searchIndex)
  {
    if (g_searchCtx)
    {
      g_code->setCurrentDoc(g_searchCtx,g_searchCtx->anchor(),FALSE);
    }
    else
    {
      g_code->setCurrentDoc(g_sourceFileDef,anchor,TRUE);
    }
  }
}

static void setParameterList ( MemberDef *  md )

static

Definition at line 11206 of file code.cpp.

{
  g_classScope = md->getClassDef() ? md->getClassDef()->name().data() : "";
  ArgumentList *al = md->argumentList();
  if (al==0) return;
  ArgumentListIterator it(*al);
  Argument *a;
  for (;(a=it.current());++it)
  {
    g_parmName = a->name.copy();
    g_parmType = a->type.copy();
    int i = g_parmType.find('*');
    if (i!=-1) g_parmType = g_parmType.left(i);
    i = g_parmType.find('&');
    if (i!=-1) g_parmType = g_parmType.left(i);
    g_parmType.stripPrefix("const ");
    g_parmType=g_parmType.stripWhiteSpace();
    g_theVarContext.addVariable(g_parmType,g_parmName);
  }
}

static void startCodeLine ( )

static

start a new line of code, inserting a line number if g_sourceFileDef is TRUE. If a definition starts at the current line, then the line number is linked to the documentation of that definition.

Definition at line 11021 of file code.cpp.

{
  //if (g_currentFontClass) { g_code->endFontClass(); }
  if (g_sourceFileDef && g_lineNumbers)
  {
    //QCString lineNumber,lineAnchor;
    //lineNumber.sprintf("%05d",g_yyLineNr);
    //lineAnchor.sprintf("l%05d",g_yyLineNr);
   
    Definition *d   = g_sourceFileDef->getSourceDefinition(g_yyLineNr);
    //printf("%s:startCodeLine(%d)=%p\n",g_sourceFileDef->name().data(),g_yyLineNr,d);
    if (!g_includeCodeFragment && d)
    {
      g_currentDefinition = d;
      g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr);
      g_insideBody = FALSE;
      g_searchingForBody = TRUE;
      g_realScope = d->name();
      //g_classScope = "";
      g_type.resize(0);
      g_name.resize(0);
      g_args.resize(0);
      g_parmType.resize(0);
      g_parmName.resize(0);
      //printf("Real scope: `%s'\n",g_realScope.data());
      g_bodyCurlyCount = 0;
      QCString lineAnchor;
      lineAnchor.sprintf("l%05d",g_yyLineNr);
      if (g_currentMemberDef)
      {
        g_code->writeLineNumber(g_currentMemberDef->getReference(),
                                g_currentMemberDef->getOutputFileBase(),
                                g_currentMemberDef->anchor(),g_yyLineNr);
        setCurrentDoc(lineAnchor);
      }
      else if (d->isLinkableInProject())
      {
        g_code->writeLineNumber(d->getReference(),
                                d->getOutputFileBase(),
                                0,g_yyLineNr);
        setCurrentDoc(lineAnchor);
      }
    }
    else
    {
      g_code->writeLineNumber(0,0,0,g_yyLineNr);
    }
  }
  DBG_CTX((stderr,"startCodeLine(%d)\n",g_yyLineNr));
  g_code->startCodeLine(g_sourceFileDef && g_lineNumbers); 
  if (g_currentFontClass)
  {
    g_code->startFontClass(g_currentFontClass);
  }
}

static void startFontClass ( const char *  s )

static

Definition at line 11971 of file code.cpp.

{
  endFontClass();
  g_code->startFontClass(s);
  g_currentFontClass=s;
}

static ClassDef* stripClassName ( const char *  s, Definition *  d = g_currentDefinition  )

static

Definition at line 11227 of file code.cpp.

{
  int pos=0;
  QCString type = s;
  QCString className;
  QCString templSpec;
  while (extractClassNameFromType(type,pos,className,templSpec)!=-1)
  {
    QCString clName=className+templSpec;
    ClassDef *cd=0;
    if (!g_classScope.isEmpty())
    {
      cd=getResolvedClass(d,g_sourceFileDef,g_classScope+"::"+clName);
    }
    if (cd==0)
    {
      cd=getResolvedClass(d,g_sourceFileDef,clName);
    }
    //printf("stripClass trying `%s' = %p\n",clName.data(),cd);
    if (cd)
    {
      return cd;
    }
  }

  return 0;
}

static void updateCallContextForSmartPointer ( )

static

Definition at line 11368 of file code.cpp.

{
  Definition *d = g_theCallContext.getScope();
  //printf("updateCallContextForSmartPointer() cd=%s\n",cd ? d->name().data() : "<none>");
  MemberDef *md;
  if (d && d->definitionType()==Definition::TypeClass && (md=((ClassDef*)d)->isSmartPointer()))
  {
    ClassDef *ncd = stripClassName(md->typeString(),md->getOuterScope());
    if (ncd)
    {
      g_theCallContext.setScope(ncd);
      //printf("Found smart pointer call %s->%s!\n",cd->name().data(),ncd->name().data());
    }
  }
}

while

(

1

)

Definition at line 12603 of file code.cpp.

                {
                yy_cp = (yy_c_buf_p);

                /* Support of codeYYtext. */
                *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 >= 3537 )
                                        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 != 3536 );

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)];
                                if ( yy_act & YY_TRAILING_HEAD_MASK ||
                                     (yy_looking_for_trail_begin) )
                                        {
                                        if ( yy_act == (yy_looking_for_trail_begin) )
                                                {
                                                (yy_looking_for_trail_begin) = 0;
                                                yy_act &= ~YY_TRAILING_HEAD_MASK;
                                                break;
                                                }
                                        }
                                else if ( yy_act & YY_TRAILING_MASK )
                                        {
                                        (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
                                        (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
                                        (yy_full_match) = yy_cp;
                                        (yy_full_state) = (yy_state_ptr);
                                        (yy_full_lp) = (yy_lp);
                                        }
                                else
                                        {
                                        (yy_full_match) = yy_cp;
                                        (yy_full_state) = (yy_state_ptr);
                                        (yy_full_lp) = (yy_lp);
                                        break;
                                        }
                                ++(yy_lp);
                                goto find_rule;
                                }
                        --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 1837 "code.l"

        YY_BREAK
case 2:
YY_RULE_SETUP
#line 1838 "code.l"
{
                                          startFontClass("preprocessor");
                                          g_code->codify(codeYYtext);
                                          BEGIN( ReadInclude ); 
                                        }
        YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
#line 1843 "code.l"
{ 
                                          g_insideObjC=TRUE;
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          if (!g_insideTemplate) 
                                            BEGIN( ClassName ); 
                                        }
        YY_BREAK
case 4:
YY_RULE_SETUP
#line 1851 "code.l"
{
                                          if (g_insideTemplate) REJECT;
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          BEGIN( ClassName ); 
                                        }
        YY_BREAK
case 5:
/* rule 5 can match eol */
YY_RULE_SETUP
#line 1858 "code.l"
{ 
                                          if (g_insideTemplate) REJECT;
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 6:
YY_RULE_SETUP
#line 1864 "code.l"
{ 
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          if (!g_insideTemplate) 
                                            BEGIN( ClassName ); 
                                        }
        YY_BREAK
case 7:
/* rule 7 can match eol */
YY_RULE_SETUP
#line 1871 "code.l"
{ 
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          BEGIN( PackageName ); 
                                        }
        YY_BREAK
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
#line 1877 "code.l"
{
                                          if (!g_insideObjC) REJECT;
                                          codifyLines(codeYYtext);
                                          BEGIN(Body);
                                        }
        YY_BREAK
case 9:
YY_RULE_SETUP
#line 1882 "code.l"
{
                                          if (!g_insideObjC || g_insideBody)
                                          { 
                                            g_code->codify(codeYYtext);
                                          }
                                          else // Start of Objective-C method
                                          {
                                            //printf("Method!\n");
                                            g_code->codify(codeYYtext);
                                            BEGIN(ObjCMethod);
                                          }
                                        }
        YY_BREAK
case 10:
YY_RULE_SETUP
#line 1894 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          BEGIN(ObjCParams);
                                        }
        YY_BREAK
case 11:
YY_RULE_SETUP
#line 1898 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          BEGIN(ObjCParamType);
                                        }
        YY_BREAK
case 12:
YY_RULE_SETUP
#line 1902 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          if (*codeYYtext=='{')
                                          {
                                            g_curlyCount++;
                                            if (g_searchingForBody)
                                            {
                                              g_searchingForBody=FALSE;
                                              g_insideBody=TRUE;
                                            }
                                            if (g_insideBody) g_bodyCurlyCount++;
                                            if (!g_curClassName.isEmpty()) // valid class name
                                            {
                                              pushScope(g_curClassName);
                                              DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n"));
                                              g_scopeStack.push(SCOPEBLOCK);
                                            }
                                          }
                                          g_type.resize(0);
                                          g_name.resize(0);
                                          BEGIN(Body);
                                        }
        YY_BREAK
case 13:
YY_RULE_SETUP
#line 1924 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 14:
YY_RULE_SETUP
#line 1927 "code.l"
{
                                          startFontClass("keywordtype");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          g_parmType=codeYYtext;
                                        }
        YY_BREAK
case 15:
YY_RULE_SETUP
#line 1933 "code.l"
{
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          g_parmType=codeYYtext;
                                        }
        YY_BREAK
case 16:
YY_RULE_SETUP
#line 1937 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          BEGIN(ObjCParams);
                                        }
        YY_BREAK
case 17:
YY_RULE_SETUP
#line 1941 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_parmName=codeYYtext;
                                          g_theVarContext.addVariable(g_parmType,g_parmName);
                                          g_parmType.resize(0);g_parmName.resize(0);
                                        }
        YY_BREAK
case 18:
YY_RULE_SETUP
#line 1947 "code.l"
{
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 19:
YY_RULE_SETUP
#line 1950 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 20:
/* rule 20 can match eol */
YY_RULE_SETUP
#line 1953 "code.l"
{
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 21:
YY_RULE_SETUP
#line 1956 "code.l"
{
                                          //FileInfo *f;
                                          bool ambig;
                                          bool found=FALSE;
                                          //QCString absPath = codeYYtext;
                                          //if (g_sourceFileDef && QDir::isRelativePath(absPath))
                                          //{
                                          //  absPath = QDir::cleanDirPath(g_sourceFileDef->getPath()+"/"+absPath);
                                          //}

                                          FileDef *fd=findFileDef(Doxygen::inputNameDict,codeYYtext,ambig);
                                          //printf("looking for include %s -> %s fd=%p\n",codeYYtext,absPath.data(),fd);
                                          if (fd && fd->isLinkable())
                                          {
                                            if (ambig) // multiple input files match the name
                                            {
                                              //printf("===== yes %s is ambiguous\n",codeYYtext);
                                              QCString name = QDir::cleanDirPath(codeYYtext).utf8();
                                              if (!name.isEmpty() && g_sourceFileDef)
                                              {
                                                FileName *fn = Doxygen::inputNameDict->find(name);
                                                if (fn)
                                                {
                                                  FileNameIterator fni(*fn);
                                                  // for each include name
                                                  for (fni.toFirst();!found && (fd=fni.current());++fni)
                                                  {
                                                    // see if this source file actually includes the file
                                                    found = g_sourceFileDef->isIncluded(fd->absFilePath());
                                                    //printf("      include file %s found=%d\n",fd->absFilePath().data(),found);
                                                  }
                                                }
                                              }
                                            }
                                            else // not ambiguous
                                            {
                                              found = TRUE;
                                            }
                                          }
                                          //printf("      include file %s found=%d\n",fd ? fd->absFilePath().data() : "<none>",found);
                                          if (found)
                                          {
                                            writeMultiLineCodeLink(*g_code,fd,codeYYtext);
                                          }
                                          else
                                          {
                                            g_code->codify(codeYYtext);
                                          }
                                          char c=yyinput();
                                          QCString text;
                                          text+=c;
                                          g_code->codify(text);
                                          endFontClass();
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 22:
YY_RULE_SETUP
#line 2011 "code.l"
{ 
                                          startFontClass("preprocessor");
                                          g_lastSkipCppContext = YY_START;
                                          g_code->codify(codeYYtext);
                                          BEGIN( SkipCPP ) ; 
                                        }
        YY_BREAK
case 23:
YY_RULE_SETUP
#line 2017 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 24:
YY_RULE_SETUP
#line 2020 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 25:
/* rule 25 can match eol */
YY_RULE_SETUP
#line 2023 "code.l"
{ 
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 26:
YY_RULE_SETUP
#line 2026 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 27:
YY_RULE_SETUP
#line 2029 "code.l"
{ 
                                          g_theVarContext.popScope();
                                          g_yyColNr++;
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 28:
YY_RULE_SETUP
#line 2034 "code.l"
{ 
                                          g_theVarContext.pushScope();

                                          DBG_CTX((stderr,"** scope stack push INNERBLOCK\n"));
                                          g_scopeStack.push(INNERBLOCK);

                                          if (g_searchingForBody)
                                          {
                                            g_searchingForBody=FALSE;
                                            g_insideBody=TRUE;
                                          }
                                          g_code->codify(codeYYtext);
                                          g_curlyCount++;
                                          if (g_insideBody) 
                                          {
                                            g_bodyCurlyCount++;
                                          }
                                          g_type.resize(0); 
                                          g_name.resize(0);
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 29:
YY_RULE_SETUP
#line 2055 "code.l"
{ 
                                          g_theVarContext.popScope();
                                          g_type.resize(0); 
                                          g_name.resize(0);

                                          int *scope = g_scopeStack.pop();
                                          DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK));
                                          if (scope==SCOPEBLOCK || scope==CLASSBLOCK) 
                                          {
                                            popScope();
                                          }

                                          g_code->codify(codeYYtext);

                                          DBG_CTX((stderr,"g_bodyCurlyCount=%d\n",g_bodyCurlyCount));
                                          if (--g_bodyCurlyCount<=0)
                                          {
                                            g_insideBody=FALSE;
                                            g_currentMemberDef=0;
                                            if (g_currentDefinition) 
                                              g_currentDefinition=g_currentDefinition->getOuterScope();
                                          }
                                          BEGIN(Body);
                                        }
        YY_BREAK
case 30:
YY_RULE_SETUP
#line 2079 "code.l"
{ 
                                          //printf("End of objc scope fd=%s\n",g_sourceFileDef->name().data());
                                          if (g_sourceFileDef)
                                          {
                                            FileDef *fd=g_sourceFileDef;
                                            g_insideObjC = fd->name().lower().right(2)==".m" || 
                                                           fd->name().lower().right(3)==".mm"; 
                                            //printf("insideObjC=%d\n",g_insideObjC);
                                          }
                                          else
                                          {
                                            g_insideObjC = FALSE;
                                          }
                                          if (g_insideBody)
                                          {
                                            g_theVarContext.popScope();

                                            int *scope = g_scopeStack.pop();
                                            DBG_CTX((stderr,"** scope stack pop SCOPEBLOCK=%d\n",scope==SCOPEBLOCK));
                                            if (scope==SCOPEBLOCK || scope==CLASSBLOCK) 
                                            {
                                              popScope();
                                            }
                                            g_insideBody=FALSE;
                                          }

                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();

                                          g_currentMemberDef=0;
                                          if (g_currentDefinition) 
                                            g_currentDefinition=g_currentDefinition->getOuterScope();
                                          BEGIN(Body);
                                        }
        YY_BREAK
case 31:
YY_RULE_SETUP
#line 2114 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          g_searchingForBody=FALSE; 
                                          BEGIN( Body ); 
                                        }
        YY_BREAK
case 32:
YY_RULE_SETUP
#line 2119 "code.l"
{
                                          g_type=g_curClassName.copy();
                                          g_name.resize(0);
                                          g_code->codify(codeYYtext);
                                          BEGIN( Body ); // variable of type struct *
                                        }
        YY_BREAK
case 33:
YY_RULE_SETUP
#line 2125 "code.l"
{
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 34:
YY_RULE_SETUP
#line 2130 "code.l"
{
                                          g_curClassName=codeYYtext;
                                          addType();
                                          if (g_curClassName=="alignas")
                                          {
                                            startFontClass("keyword");
                                            g_code->codify(codeYYtext);
                                            endFontClass();
                                            BEGIN( AlignAs );
                                          }
                                          else
                                          {
                                            generateClassOrGlobalLink(*g_code,codeYYtext);
                                            BEGIN( ClassVar );
                                          }
                                        }
        YY_BREAK
case 35:
YY_RULE_SETUP
#line 2146 "code.l"
{ 
                                          g_bracketCount=1;
                                          g_code->codify(codeYYtext);
                                          BEGIN( AlignAsEnd );
                                        }
        YY_BREAK
case 36:
/* rule 36 can match eol */
YY_RULE_SETUP
#line 2151 "code.l"
{ g_yyLineNr++; 
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 37:
YY_RULE_SETUP
#line 2154 "code.l"
{ g_code->codify(codeYYtext); }
        YY_BREAK
case 38:
YY_RULE_SETUP
#line 2155 "code.l"
{ g_code->codify(codeYYtext);
                                          g_bracketCount++; 
                                        }
        YY_BREAK
case 39:
YY_RULE_SETUP
#line 2158 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          if (--g_bracketCount<=0)
                                          {
                                            BEGIN(ClassName);
                                          }
                                        }
        YY_BREAK
case 40:
/* rule 40 can match eol */
YY_RULE_SETUP
#line 2165 "code.l"
{ g_yyLineNr++; 
                                          codifyLines(codeYYtext); 
                                        }
        YY_BREAK
case 41:
YY_RULE_SETUP
#line 2168 "code.l"
{ g_code->codify(codeYYtext); }
        YY_BREAK
case 42:
YY_RULE_SETUP
#line 2169 "code.l"
{ // PHP namespace
                                          g_curClassName=substitute(codeYYtext,"\\","::");
                                          g_scopeStack.push(CLASSBLOCK);
                                          pushScope(g_curClassName);
                                          addType();
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          BEGIN( ClassVar );
                                        }
        YY_BREAK
case 43:
YY_RULE_SETUP
#line 2177 "code.l"
{ // Obj-C category
                                          g_curClassName=removeRedundantWhiteSpace(codeYYtext);
                                          g_scopeStack.push(CLASSBLOCK);
                                          pushScope(g_curClassName);
                                          addType();
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          BEGIN( ClassVar );
                                        }
        YY_BREAK
case 44:
YY_RULE_SETUP
#line 2185 "code.l"
{
                                          g_curClassName=substitute(codeYYtext,".","::");
                                          //printf("found package: %s\n",g_curClassName.data());
                                          addType();
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 45:
YY_RULE_SETUP
#line 2191 "code.l"
{
                                          unput(*codeYYtext);
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 46:
YY_RULE_SETUP
#line 2195 "code.l"
{ // Java
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          g_curClassBases.clear();
                                          BEGIN( Bases ); 
                                        }
        YY_BREAK
case 47:
/* rule 47 can match eol */
YY_RULE_SETUP
#line 2202 "code.l"
{
                                          DBG_CTX((stderr,"***** C++/CLI modifier %s on g_curClassName=%s\n",codeYYtext,g_curClassName.data()));
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          BEGIN( CppCliTypeModifierFollowup ); 
                                        }
        YY_BREAK
case 48:
YY_RULE_SETUP
#line 2209 "code.l"
{
                                          g_type = g_curClassName.copy();
                                          g_name = codeYYtext;
                                          if (g_insideBody)
                                          {
                                            g_theVarContext.addVariable(g_type,g_name);
                                          }
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 49:
YY_RULE_SETUP
#line 2218 "code.l"
{
                                          codifyLines(codeYYtext);
                                          g_curClassBases.clear();
                                          BEGIN( Bases ); 
                                        }
        YY_BREAK
case 50:
#line 2224 "code.l"
case 51:
#line 2225 "code.l"
case 52:
YY_RULE_SETUP
#line 2225 "code.l"
{
                                          g_theVarContext.pushScope();
                                          g_code->codify(codeYYtext);
                                          g_curlyCount++;
                                          if (YY_START==ClassVar && g_curClassName.isEmpty())
                                          {
                                            g_curClassName = g_name.copy();
                                          }
                                          if (g_searchingForBody)
                                          {
                                            g_searchingForBody=FALSE;
                                            g_insideBody=TRUE;
                                          }
                                          if (g_insideBody) g_bodyCurlyCount++;
                                          if (!g_curClassName.isEmpty()) // valid class name
                                          {
                                            DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n"));
                                            g_scopeStack.push(CLASSBLOCK);
                                            pushScope(g_curClassName);
                                            DBG_CTX((stderr,"***** g_curClassName=%s\n",g_curClassName.data()));
                                            if (getResolvedClass(g_currentDefinition,g_sourceFileDef,g_curClassName)==0)
                                            {
                                              DBG_CTX((stderr,"Adding new class %s\n",g_curClassName.data()));
                                              ClassDef *ncd=new ClassDef("<code>",1,1,
                                                  g_curClassName,ClassDef::Class,0,0,FALSE);
                                              g_codeClassSDict->append(g_curClassName,ncd);
                                              // insert base classes.
                                              char *s=g_curClassBases.first();
                                              while (s)
                                              {
                                                ClassDef *bcd;
                                                bcd=g_codeClassSDict->find(s);
                                                if (bcd==0) bcd=getResolvedClass(g_currentDefinition,g_sourceFileDef,s);
                                                if (bcd && bcd!=ncd)
                                                {
                                                  ncd->insertBaseClass(bcd,s,Public,Normal);
                                                }
                                                s=g_curClassBases.next();
                                              }
                                            }
                                            //printf("g_codeClassList.count()=%d\n",g_codeClassList.count());
                                          }
                                          else // not a class name -> assume inner block
                                          {
                                            DBG_CTX((stderr,"** scope stack push INNERBLOCK\n"));
                                            g_scopeStack.push(INNERBLOCK);
                                          }
                                          g_curClassName.resize(0);
                                          g_curClassBases.clear();
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 53:
YY_RULE_SETUP
#line 2276 "code.l"
{ 
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 54:
YY_RULE_SETUP
#line 2281 "code.l"
{ 
                                          DBG_CTX((stderr,"%s:addBase(%s)\n",g_curClassName.data(),codeYYtext));
                                          g_curClassBases.inSort(codeYYtext); 
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 55:
YY_RULE_SETUP
#line 2286 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          if (!g_insideObjC)
                                          {
                                            g_sharpCount=1;
                                            BEGIN ( SkipSharp );
                                          }
                                          else
                                          {
                                            g_insideProtocolList=TRUE;
                                          }
                                        }
        YY_BREAK
case 56:
YY_RULE_SETUP
#line 2298 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_insideProtocolList=FALSE;
                                        }
        YY_BREAK
case 57:
YY_RULE_SETUP
#line 2302 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          ++g_sharpCount; 
                                        }
        YY_BREAK
case 58:
YY_RULE_SETUP
#line 2306 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          if (--g_sharpCount<=0)
                                          BEGIN ( Bases );
                                        }
        YY_BREAK
case 59:
YY_RULE_SETUP
#line 2311 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_sharpCount=1;
                                          BEGIN ( SkipSharp );
                                        }
        YY_BREAK
case 60:
YY_RULE_SETUP
#line 2316 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          ++g_sharpCount;
                                        }
        YY_BREAK
case 61:
YY_RULE_SETUP
#line 2320 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          if (--g_sharpCount<=0)
                                            BEGIN ( Bases );
                                        }
        YY_BREAK
case 62:
YY_RULE_SETUP
#line 2327 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 63:
/* rule 63 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2332 "code.l"
{
                                          addType();
                                          generateFunctionLink(*g_code,codeYYtext);
                                          g_bracketCount=0;
                                          g_args.resize(0);
                                          g_name+=codeYYtext; 
                                          BEGIN( FuncCall );
                                        }
        YY_BREAK
case 64:
/* rule 64 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2340 "code.l"
{
                                          addType();
                                          generateFunctionLink(*g_code,codeYYtext);
                                          g_bracketCount=0;
                                          g_args.resize(0);
                                          g_name+=codeYYtext; 
                                          BEGIN( FuncCall );
                                        }
        YY_BREAK
case 65:
/* rule 65 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2348 "code.l"
{
                                          addType();
                                          generateFunctionLink(*g_code,codeYYtext);
                                          g_bracketCount=0;
                                          g_args.resize(0);
                                          g_name+=codeYYtext; 
                                          BEGIN( FuncCall );
                                        }
        YY_BREAK
case 66:
/* rule 66 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2356 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          g_insideTemplate=TRUE;
                                          g_sharpCount=0;
                                        }
        YY_BREAK
case 67:
/* rule 67 can match eol */
YY_RULE_SETUP
#line 2363 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          BEGIN(UsingName);
                                        }
        YY_BREAK
case 68:
YY_RULE_SETUP
#line 2369 "code.l"
{ addUsingDirective(codeYYtext);
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          DBG_CTX((stderr,"** scope stack push CLASSBLOCK\n"));
                                          g_scopeStack.push(CLASSBLOCK);
                                          pushScope(codeYYtext);
                                          BEGIN(Body);
                                        }
        YY_BREAK
case 69:
/* rule 69 can match eol */
YY_RULE_SETUP
#line 2376 "code.l"
{ codifyLines(codeYYtext); BEGIN(Body); }
        YY_BREAK
case 70:
YY_RULE_SETUP
#line 2377 "code.l"
{ codifyLines(codeYYtext); BEGIN(Body); }
        YY_BREAK
case 71:
YY_RULE_SETUP
#line 2378 "code.l"
{ g_code->codify(codeYYtext); // this-> for C++, this. for C#
                                        }
        YY_BREAK
case 72:
/* rule 72 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2380 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          if (QCString(codeYYtext)=="typedef")
                                          {
                                            addType();
                                            g_name+=codeYYtext; 
                                          }
                                          endFontClass();
                                        }
        YY_BREAK
case 73:
YY_RULE_SETUP
#line 2390 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 74:
/* rule 74 can match eol */
YY_RULE_SETUP
#line 2395 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          g_name.resize(0);g_type.resize(0);
                                        }
        YY_BREAK
case 75:
/* rule 75 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2401 "code.l"
{
                                          if (!g_inForEachExpression) REJECT;
                                          startFontClass("keywordflow");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          // insert the variable in the parent scope, see bug 546158
                                          g_theVarContext.popScope();
                                          g_theVarContext.addVariable(g_parmType,g_parmName);
                                          g_theVarContext.pushScope();
                                          g_name.resize(0);g_type.resize(0);
                                        }
        YY_BREAK
case 76:
/* rule 76 can match eol */
YY_RULE_SETUP
#line 2412 "code.l"
{
                                          startFontClass("keywordflow");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          g_name.resize(0);g_type.resize(0);
                                          g_inForEachExpression = (qstrcmp(codeYYtext,"for each")==0 || qstrcmp(codeYYtext, "foreach")==0);
                                          BEGIN(FuncCall);
                                        }
        YY_BREAK
case 77:
/* rule 77 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2420 "code.l"
{
                                          startFontClass("keywordflow");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          if (g_inFunctionTryBlock && (qstrcmp(codeYYtext,"catch")==0 || qstrcmp(codeYYtext,"finally")==0))
                                          {
                                            g_inFunctionTryBlock=FALSE;
                                          }
                                        }
        YY_BREAK
case 78:
YY_RULE_SETUP
#line 2429 "code.l"
{
                                          startFontClass("keywordflow");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 79:
YY_RULE_SETUP
#line 2434 "code.l"
{ // end of cast?
                                          g_code->codify(codeYYtext);
                                          g_theCallContext.popScope();
                                          g_bracketCount--;
                                          g_parmType = g_name;
                                          BEGIN(FuncCall);
                                        }
        YY_BREAK
case 80:
YY_RULE_SETUP
#line 2441 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_name.resize(0);g_type.resize(0);
                                          if (*codeYYtext==')')
                                          {
                                            g_theCallContext.popScope();
                                            g_bracketCount--;
                                            BEGIN(FuncCall);
                                          }
                                        }
        YY_BREAK
case 81:
YY_RULE_SETUP
#line 2451 "code.l"
{
                                          startFontClass("keywordtype");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          addType();
                                          g_name+=codeYYtext; 
                                        }
        YY_BREAK
case 82:
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 7;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2458 "code.l"
{
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          g_sharpCount=0;
                                          BEGIN(TemplDecl);
                                        }
        YY_BREAK
case 83:
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 8;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2465 "code.l"
{ // template<...>
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          g_sharpCount=0;
                                          BEGIN(TemplDecl);
                                        }
        YY_BREAK
case 84:
YY_RULE_SETUP
#line 2472 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 85:
YY_RULE_SETUP
#line 2477 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_sharpCount++;
                                        }
        YY_BREAK
case 86:
YY_RULE_SETUP
#line 2481 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_sharpCount--;
                                          if (g_sharpCount<=0)
                                          {
                                            BEGIN(Body);
                                          }
                                        }
        YY_BREAK
case 87:
YY_RULE_SETUP
#line 2489 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          BEGIN( g_lastTemplCastContext );
                                        }
        YY_BREAK
case 88:
YY_RULE_SETUP
#line 2495 "code.l"
{
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 89:
YY_RULE_SETUP
#line 2498 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 90:
YY_RULE_SETUP
#line 2503 "code.l"
{
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 91:
YY_RULE_SETUP
#line 2506 "code.l"
{ // static_cast<T>(
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                          g_lastTemplCastContext = YY_START;
                                          BEGIN(TemplCast);
                                        }
        YY_BREAK
case 92:
/* rule 92 can match eol */
YY_RULE_SETUP
#line 2513 "code.l"
{ // PHP member variable
                                          addType();
                                          generatePHPVariableLink(*g_code,codeYYtext);
                                          g_name+=codeYYtext+7; 
                                        }
        YY_BREAK
case 93:
/* rule 93 can match eol */
YY_RULE_SETUP
#line 2518 "code.l"
{ // A<T> *pt;
                                          int i=QCString(codeYYtext).find('<');
                                          QCString kw = QCString(codeYYtext).left(i).stripWhiteSpace();
                                          if (kw.right(5)=="_cast" && YY_START==Body)
                                          {
                                            REJECT;
                                          }
                                          addType();
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          g_name+=codeYYtext; 
                                        }
        YY_BREAK
case 94:
/* rule 94 can match eol */
YY_RULE_SETUP
#line 2529 "code.l"
{ // "int var;" or "var, var2" or "debug(f) macro" 
                                          addType();
                                          // changed this to generateFunctionLink, see bug 624514
                                          //generateClassOrGlobalLink(*g_code,codeYYtext,FALSE,TRUE);
                                          generateFunctionLink(*g_code,codeYYtext);
                                          g_name+=codeYYtext; 
                                        }
        YY_BREAK
case 95:
/* rule 95 can match eol */
YY_RULE_SETUP
#line 2536 "code.l"
{ // p->func()
                                          addType();
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          g_name+=codeYYtext; 
                                        }
        YY_BREAK
case 96:
/* rule 96 can match eol */
YY_RULE_SETUP
#line 2541 "code.l"
{  // (*p)->func() but not "if (p) ..."
                                          g_code->codify(codeYYtext);
                                          int s=0;while (s<(int)codeYYleng && !isId(codeYYtext[s])) s++;
                                          int e=(int)codeYYleng-1;while (e>=0 && !isId(codeYYtext[e])) e--;
                                          QCString varname = ((QCString)codeYYtext).mid(s,e-s+1); 
                                          addType();
                                          g_name=varname; 
                                        }
        YY_BREAK
case 97:
/* rule 97 can match eol */
YY_RULE_SETUP
#line 2549 "code.l"
{ // a() or c::a() or t<A,B>::a() or A\B\foo()
                                          addType();
                                          generateFunctionLink(*g_code,codeYYtext);
                                          g_bracketCount=0;
                                          g_args.resize(0);
                                          g_name+=codeYYtext; 
                                          BEGIN( FuncCall );
                                        }
        YY_BREAK
case 98:
/* rule 98 can match eol */
YY_RULE_SETUP
#line 2557 "code.l"
{
                                          QCString text=codeYYtext;
                                          int i=text.find('R');
                                          g_code->codify(text.left(i+1));
                                          startFontClass("stringliteral");
                                          g_code->codify(codeYYtext+i+1);
                                          g_lastStringContext=YY_START;
                                          g_inForEachExpression = FALSE;
                                          g_delimiter = codeYYtext+i+2;
                                          g_delimiter=g_delimiter.left(g_delimiter.length()-1);
                                          BEGIN( RawString );
                                        }
        YY_BREAK
case 99:
YY_RULE_SETUP
#line 2569 "code.l"
{
                                          startFontClass("stringliteral");
                                          g_code->codify(codeYYtext);
                                          g_lastStringContext=YY_START;
                                          g_inForEachExpression = FALSE;
                                          BEGIN( SkipString );
                                        }
        YY_BREAK
case 100:
YY_RULE_SETUP
#line 2576 "code.l"
{
                                          startFontClass("stringliteral");
                                          g_code->codify(codeYYtext);
                                          g_lastStringContext=YY_START;
                                          g_inForEachExpression = FALSE;
                                          BEGIN( SkipStringS );
                                        }
        YY_BREAK
case 101:
YY_RULE_SETUP
#line 2583 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 102:
YY_RULE_SETUP
#line 2586 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 103:
YY_RULE_SETUP
#line 2589 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 104:
YY_RULE_SETUP
#line 2592 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          BEGIN( g_lastStringContext );
                                        }
        YY_BREAK
case 105:
YY_RULE_SETUP
#line 2597 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          BEGIN( g_lastStringContext );
                                        }
        YY_BREAK
case 106:
YY_RULE_SETUP
#line 2602 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 107:
/* rule 107 can match eol */
YY_RULE_SETUP
#line 2605 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          QCString delimiter = codeYYtext+1;
                                          delimiter=delimiter.left(delimiter.length()-1);
                                          if (delimiter==g_delimiter)
                                          {
                                            BEGIN( g_lastStringContext );
                                          }
                                        }
        YY_BREAK
case 108:
YY_RULE_SETUP
#line 2614 "code.l"
{ g_code->codify(codeYYtext); }
        YY_BREAK
case 109:
YY_RULE_SETUP
#line 2615 "code.l"
{ g_code->codify(codeYYtext); }
        YY_BREAK
case 110:
/* rule 110 can match eol */
YY_RULE_SETUP
#line 2616 "code.l"
{ codifyLines(codeYYtext); }
        YY_BREAK
case 111:
YY_RULE_SETUP
#line 2617 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 112:
YY_RULE_SETUP
#line 2620 "code.l"
{ // escaped quote
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 113:
YY_RULE_SETUP
#line 2623 "code.l"
{ // end of string
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          BEGIN( g_lastVerbStringContext );
                                        }
        YY_BREAK
case 114:
YY_RULE_SETUP
#line 2628 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 115:
/* rule 115 can match eol */
YY_RULE_SETUP
#line 2631 "code.l"
{
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 116:
YY_RULE_SETUP
#line 2634 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_name.resize(0);g_type.resize(0);
                                        }
        YY_BREAK
case 117:
YY_RULE_SETUP
#line 2638 "code.l"
{
                                          if (g_insideTemplate)
                                          {
                                            g_sharpCount++;
                                          }
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 118:
YY_RULE_SETUP
#line 2645 "code.l"
{
                                          if (g_insideTemplate)
                                          {
                                            if (--g_sharpCount<=0)
                                            {
                                              g_insideTemplate=FALSE;
                                            }
                                          }
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 119:
YY_RULE_SETUP
#line 2655 "code.l"
{
                                          startFontClass("charliteral"); 
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 120:
YY_RULE_SETUP
#line 2660 "code.l"
{ 
                                          if (codeYYtext[0]=='-') // -> could be overloaded
                                          {
                                            updateCallContextForSmartPointer();
                                          }
                                          g_code->codify(codeYYtext);
                                          g_memCallContext = YY_START;
                                          BEGIN( MemberCall ); 
                                        }
        YY_BREAK
case 121:
/* rule 121 can match eol */
YY_RULE_SETUP
#line 2669 "code.l"
{
                                          if (g_theCallContext.getScope())
                                          {
                                            if (!generateClassMemberLink(*g_code,g_theCallContext.getScope(),codeYYtext))
                                            {
                                              g_code->codify(codeYYtext);
                                              addToSearchIndex(codeYYtext);
                                            }
                                            g_name.resize(0);
                                          }
                                          else
                                          {
                                            g_code->codify(codeYYtext);
                                            addToSearchIndex(codeYYtext);
                                            g_name.resize(0);
                                          }
                                          g_type.resize(0);
                                          g_bracketCount=0;
                                          if (g_memCallContext==Body)
                                          {
                                            BEGIN(FuncCall);
                                          }
                                          else
                                          {
                                            BEGIN(g_memCallContext);
                                          }
                                        }
        YY_BREAK
case 122:
/* rule 122 can match eol */
YY_RULE_SETUP
#line 2696 "code.l"
{
                                          if (g_theCallContext.getScope())
                                          {
                                            DBG_CTX((stderr,"g_theCallContext.getClass()=%p\n",g_theCallContext.getScope()));
                                            if (!generateClassMemberLink(*g_code,g_theCallContext.getScope(),codeYYtext))
                                            {
                                              g_code->codify(codeYYtext);
                                              addToSearchIndex(codeYYtext);
                                            }
                                            g_name.resize(0);
                                          }
                                          else
                                          {
                                            DBG_CTX((stderr,"no class context!\n"));
                                            g_code->codify(codeYYtext);
                                            addToSearchIndex(codeYYtext);
                                            g_name.resize(0);
                                          }
                                          g_type.resize(0);
                                          BEGIN(g_memCallContext);
                                        }
        YY_BREAK
case 123:
YY_RULE_SETUP
#line 2717 "code.l"
{
                                          if (g_insideObjC && *codeYYtext=='[')
                                          {
                                            //printf("Found start of ObjC call!\n");
                                            // start of a method call
                                            g_contextDict.setAutoDelete(TRUE);
                                            g_nameDict.setAutoDelete(TRUE);
                                            g_objectDict.setAutoDelete(TRUE);
                                            g_wordDict.setAutoDelete(TRUE);
                                            g_contextDict.clear();
                                            g_nameDict.clear();
                                            g_objectDict.clear();
                                            g_wordDict.clear();
                                            g_currentCtxId  = 0;
                                            g_currentNameId  = 0;
                                            g_currentObjId  = 0;
                                            g_currentCtx = 0;
                                            g_braceCount = 0;
                                            unput('[');
                                            BEGIN(ObjCCall);
                                          }
                                          else
                                          {
                                            g_code->codify(codeYYtext);
                                            g_saveName = g_name.copy();
                                            g_saveType = g_type.copy();
                                            if (*codeYYtext!='[' && !g_type.isEmpty()) 
                                            {
                                              //printf("g_scopeStack.bottom()=%p\n",g_scopeStack.bottom());
                                              //if (g_scopeStack.top()!=CLASSBLOCK) // commented out for bug731363
                                              {
                                                //printf("AddVariable: '%s' '%s' context=%d\n",
                                                //    g_type.data(),g_name.data(),g_theVarContext.count());
                                                g_theVarContext.addVariable(g_type,g_name);
                                              }
                                              g_name.resize(0);
                                            }
                                            if (*codeYYtext==';' || *codeYYtext=='=') 
                                            {
                                              g_type.resize(0);
                                              g_name.resize(0);
                                            }
                                            else if (*codeYYtext=='[')
                                            {
                                              g_theCallContext.pushScope();
                                            }
                                            g_args.resize(0);
                                            g_parmType.resize(0);
                                            g_parmName.resize(0);
                                          }
                                        }
        YY_BREAK
/*
<ObjCMemberCall>{ID}                    {
                                          if (qstrcmp(codeYYtext,"self")==0 || qstrcmp(codeYYtext,"super")==0)
                                          {
                                            // TODO: get proper base class for "super"
                                            g_theCallContext.setClass(getClass(g_curClassName));
                                            startFontClass("keyword");
                                            g_code->codify(codeYYtext); 
                                            endFontClass();
                                          }
                                          else
                                          {
                                            generateClassOrGlobalLink(*g_code,codeYYtext);
                                          }
                                          g_name.resize(0);
                                          BEGIN(ObjCMemberCall2);
                                        }
<ObjCMemberCall>"["                     {
                                            g_code->codify(codeYYtext);
                                            g_theCallContext.pushScope();
                                        }
<ObjCMemberCall2>{ID}":"?               {
                                          g_name+=codeYYtext;
                                          if (g_theCallContext.getClass())
                                          {
                                            //printf("Calling method %s\n",g_name.data());
                                            if (!generateClassMemberLink(*g_code,g_theCallContext.getClass(),g_name))
                                            {
                                              g_code->codify(codeYYtext);
                                              addToSearchIndex(g_name);
                                            }
                                          }
                                          else
                                          {
                                            g_code->codify(codeYYtext);
                                            addToSearchIndex(g_name);
                                          }
                                          g_name.resize(0);
                                          BEGIN(ObjCMemberCall3);
                                        }
<ObjCMemberCall2,ObjCMemberCall3>"]"    {
                                          g_theCallContext.popScope();
                                          g_code->codify(codeYYtext);
                                          BEGIN(Body);
                                        }
  */
case 124:
YY_RULE_SETUP
#line 2814 "code.l"
{ 
                                   saveObjCContext();
                                   g_currentCtx->format+=*codeYYtext;
                                   BEGIN(ObjCCall);
                                   //printf("open\n");
                                 }
        YY_BREAK
case 125:
YY_RULE_SETUP
#line 2820 "code.l"
{ 
                                    g_currentCtx->format+=*codeYYtext;
                                    restoreObjCContext();
                                    BEGIN(ObjCMName);
                                    if (g_currentCtx==0)
                                    {
                                      // end of call
                                      writeObjCMethodCall(g_contextDict.find(0));
                                      BEGIN(Body);
                                    }
                                    //printf("close\n");
                                  }
        YY_BREAK
case 126:
YY_RULE_SETUP
#line 2832 "code.l"
{
                                    g_currentCtx->format+=escapeObject(codeYYtext);
                                    if (g_braceCount==0)
                                    {
                                      g_currentCtx->objectTypeOrName=codeYYtext;
                                      //printf("new type=%s\n",g_currentCtx->objectTypeOrName.data());
                                      BEGIN(ObjCMName);
                                    }
                                  }
        YY_BREAK
case 127:
/* rule 127 can match eol */
YY_RULE_SETUP
#line 2841 "code.l"
{ 
                                    if (g_braceCount==0 && 
                                        g_currentCtx->methodName.isEmpty())
                                    {
                                      g_currentCtx->methodName=codeYYtext; 
                                      g_currentCtx->format+=escapeName(codeYYtext);
                                    }
                                    else
                                    {
                                      g_currentCtx->format+=escapeWord(codeYYtext);
                                    }
                                  }
        YY_BREAK
case 128:
/* rule 128 can match eol */
YY_RULE_SETUP
#line 2853 "code.l"
{ 
                                     if (g_braceCount==0)
                                     {
                                       g_currentCtx->methodName+=codeYYtext;
                                       g_currentCtx->methodName+=":";
                                     }
                                     g_currentCtx->format+=escapeName(codeYYtext);
                                   }
        YY_BREAK
case 129:
YY_RULE_SETUP
#line 2861 "code.l"
{ g_currentCtx->format+=codeYYtext; }
        YY_BREAK
case 130:
YY_RULE_SETUP
#line 2862 "code.l"
{ g_currentCtx->format+=codeYYtext; }
        YY_BREAK
case 131:
YY_RULE_SETUP
#line 2863 "code.l"
{ g_currentCtx->format+=codeYYtext; 
                                      BEGIN(g_lastStringContext); 
                                   }
        YY_BREAK
case 132:
YY_RULE_SETUP
#line 2866 "code.l"
{ g_currentCtx->format+=codeYYtext; }
        YY_BREAK
case 133:
YY_RULE_SETUP
#line 2867 "code.l"
{ g_currentCtx->format+=codeYYtext; 
                                      g_lastStringContext=YY_START;
                                      BEGIN(ObjCSkipStr); 
                                   }
        YY_BREAK
case 134:
YY_RULE_SETUP
#line 2871 "code.l"
{ g_currentCtx->format+="$$"; }
        YY_BREAK
case 135:
YY_RULE_SETUP
#line 2872 "code.l"
{ g_currentCtx->format+=*codeYYtext; g_braceCount++; }
        YY_BREAK
case 136:
YY_RULE_SETUP
#line 2873 "code.l"
{ g_currentCtx->format+=*codeYYtext; g_braceCount--; }
        YY_BREAK
case 137:
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2874 "code.l"
{ // needed to prevent matching the global rule (for C#)
                                     g_currentCtx->format+=codeYYtext;
                                   }
        YY_BREAK
case 138:
YY_RULE_SETUP
#line 2877 "code.l"
{ g_currentCtx->format+=escapeWord(codeYYtext); }
        YY_BREAK
case 139:
YY_RULE_SETUP
#line 2878 "code.l"
{ g_currentCtx->format+=*codeYYtext; }
        YY_BREAK
case 140:
/* rule 140 can match eol */
YY_RULE_SETUP
#line 2879 "code.l"
{ g_currentCtx->format+=*codeYYtext; }
        YY_BREAK
case 141:
YY_RULE_SETUP
#line 2881 "code.l"
{
                                          g_theCallContext.popScope();
                                          g_code->codify(codeYYtext);
                                          // TODO: nested arrays like: a[b[0]->func()]->func()
                                          g_name = g_saveName.copy();
                                          g_type = g_saveType.copy();
                                        }
        YY_BREAK
case 142:
YY_RULE_SETUP
#line 2888 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 143:
YY_RULE_SETUP
#line 2891 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 144:
/* rule 144 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2894 "code.l"
{
                                          //addParmType();
                                          //g_parmName=codeYYtext; 
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 145:
/* rule 145 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2901 "code.l"
{
                                          addParmType();
                                          g_parmName=codeYYtext; 
                                          startFontClass("keywordtype");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 146:
/* rule 146 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 2908 "code.l"
{
                                          addParmType();
                                          g_parmName=codeYYtext; 
                                          startFontClass("keywordflow");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 147:
YY_RULE_SETUP
#line 2915 "code.l"
{
                                          addParmType();
                                          g_parmName=codeYYtext; 
                                          generateClassOrGlobalLink(*g_code,codeYYtext,!g_insideBody);
                                        }
        YY_BREAK
case 148:
YY_RULE_SETUP
#line 2920 "code.l"
{ // probably a cast, not a function call
                                          g_code->codify(codeYYtext);
                                          g_inForEachExpression = FALSE;
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 149:
YY_RULE_SETUP
#line 2925 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_theVarContext.addVariable(g_parmType,g_parmName);
                                          g_parmType.resize(0);g_parmName.resize(0);
                                        }
        YY_BREAK
case 150:
YY_RULE_SETUP
#line 2930 "code.l"
{
                                          if (g_bracketCount>0)
                                          {
                                            g_code->codify(codeYYtext);
                                            g_skipInlineInitContext=YY_START;
                                            g_curlyCount=0;
                                            BEGIN(InlineInit);
                                          }
                                          else
                                          {
                                            REJECT;
                                          }
                                        }
        YY_BREAK
case 151:
YY_RULE_SETUP
#line 2943 "code.l"
{ g_curlyCount++;
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 152:
YY_RULE_SETUP
#line 2946 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          if (--g_curlyCount<=0)
                                          {
                                            BEGIN(g_skipInlineInitContext);
                                          }
                                        }
        YY_BREAK
case 153:
/* rule 153 can match eol */
YY_RULE_SETUP
#line 2953 "code.l"
{
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 154:
YY_RULE_SETUP
#line 2956 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 155:
YY_RULE_SETUP
#line 2959 "code.l"
{
                                          g_parmType.resize(0);g_parmName.resize(0);
                                          g_code->codify(codeYYtext);
                                          g_bracketCount++; 
                                          g_theCallContext.pushScope();
                                          if (YY_START==FuncCall && !g_insideBody)
                                          {
                                            g_theVarContext.pushScope();
                                          }
                                        }
        YY_BREAK
case 156:
YY_RULE_SETUP
#line 2969 "code.l"
{ // operator
                                          if (qstrcmp(codeYYtext,"*") && 
                                              qstrcmp(codeYYtext,"&") &&
                                              qstrcmp(codeYYtext,"^") &&
                                              qstrcmp(codeYYtext,"%")) // typically a pointer or reference
                                          {
                                            // not a * or &, or C++/CLI's ^ or %
                                            g_parmType.resize(0);g_parmName.resize(0);
                                          }
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 157:
YY_RULE_SETUP
#line 2980 "code.l"
{ 
                                          if (codeYYtext[0]==')') // no a pointer cast
                                          {
                                            //printf("addVariable(%s,%s)\n",g_parmType.data(),g_parmName.data());
                                            g_theVarContext.addVariable(g_parmType,g_parmName);
                                          }
                                          else
                                          {
                                            g_parmType.resize(0);
                                            g_parmName.resize(0);
                                          }
                                          g_theCallContext.popScope();
                                          g_inForEachExpression = FALSE;
                                          //g_theCallContext.setClass(0); // commented out, otherwise a()->b() does not work for b().
                                          g_code->codify(codeYYtext);
                                          if (--g_bracketCount<=0) 
                                          {
                                            if (g_name.isEmpty())
                                            {
                                              BEGIN( Body );
                                            }
                                            else
                                            {
                                              BEGIN( CallEnd ); 
                                            }
                                          }
                                        }
        YY_BREAK
case 158:
/* rule 158 can match eol */
YY_RULE_SETUP
#line 3007 "code.l"
{ codifyLines(codeYYtext); }
        YY_BREAK
/*
<MemberCall2,FuncCall>")"[ \t\n]*[;:]   {
  */
case 159:
YY_RULE_SETUP
#line 3011 "code.l"
{
                                          codifyLines(codeYYtext);
                                          g_bracketCount=0;
                                          if (*codeYYtext==';') g_searchingForBody=FALSE; 
                                          if (!g_type.isEmpty())
                                          {
                                            DBG_CTX((stderr,"add variable g_type=%s g_name=%s)\n",g_type.data(),g_name.data()));
                                            g_theVarContext.addVariable(g_type,g_name);
                                          }
                                          g_parmType.resize(0);g_parmName.resize(0);
                                          g_theCallContext.setScope(0);
                                          if (*codeYYtext==';' || g_insideBody)
                                          {
                                            if (!g_insideBody)
                                            {
                                              g_theVarContext.popScope();
                                            }
                                            g_name.resize(0);g_type.resize(0);
                                            BEGIN( Body );
                                          }
                                          else
                                          {
                                            g_bracketCount=0;
                                            BEGIN( SkipInits );
                                          }
                                        }
        YY_BREAK
case 160:
/* rule 160 can match eol */
YY_RULE_SETUP
#line 3037 "code.l"
{
                                          startFontClass("keyword");
                                          codifyLines(codeYYtext);
                                          endFontClass();
                                        }
        YY_BREAK
case 161:
/* rule 161 can match eol */
YY_RULE_SETUP
#line 3042 "code.l"
{
                                          if (g_insideBody)
                                          {
                                            g_theVarContext.pushScope();
                                          }
                                          g_theVarContext.addVariable(g_parmType,g_parmName);
                                          //g_theCallContext.popScope();
                                          g_parmType.resize(0);g_parmName.resize(0);
                                          int index = g_name.findRev("::");
                                          DBG_CTX((stderr,"g_name=%s\n",g_name.data()));
                                          if (index!=-1) 
                                          {
                                            QCString scope = g_name.left(index);
                                            if (!g_classScope.isEmpty()) scope.prepend(g_classScope+"::");
                                            ClassDef *cd=getResolvedClass(Doxygen::globalScope,g_sourceFileDef,scope);
                                            if (cd)
                                            {
                                              setClassScope(cd->name());
                                              g_scopeStack.push(SCOPEBLOCK);
                                              DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n"));
                                            }
                                            else 
                                            {
                                              //setClassScope(g_realScope);
                                              g_scopeStack.push(INNERBLOCK);
                                              DBG_CTX((stderr,"** scope stack push INNERBLOCK\n"));
                                            }
                                          }
                                          else
                                          {
                                            DBG_CTX((stderr,"** scope stack push INNERBLOCK\n"));
                                            g_scopeStack.push(INNERBLOCK);
                                          }
                                          codeYYtext[codeYYleng-1]='\0';
                                          QCString cv(codeYYtext);
                                          if (!cv.stripWhiteSpace().isEmpty())
                                          {
                                            startFontClass("keyword");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                          else // just whitespace
                                          {
                                            codifyLines(codeYYtext);
                                          }
                                          g_code->codify("{");
                                          if (g_searchingForBody)
                                          {
                                            g_searchingForBody=FALSE;
                                            g_insideBody=TRUE;
                                          }
                                          if (g_insideBody) g_bodyCurlyCount++;
                                          g_curlyCount++;
                                          g_type.resize(0); g_name.resize(0);
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 162:
YY_RULE_SETUP
#line 3098 "code.l"
{ // function-try-block
                                          startFontClass("keyword");
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          g_inFunctionTryBlock=TRUE;
                                        }
        YY_BREAK
case 163:
YY_RULE_SETUP
#line 3104 "code.l"
{
                                          if (g_insideBody || !g_parmType.isEmpty()) 
                                          {
                                            REJECT;
                                          }
                                          // could be K&R style definition
                                          addParmType();
                                          g_parmName=codeYYtext; 
                                          generateClassOrGlobalLink(*g_code,codeYYtext,!g_insideBody);
                                          BEGIN(OldStyleArgs);
                                        }
        YY_BREAK
case 164:
YY_RULE_SETUP
#line 3115 "code.l"
{
                                          addParmType();
                                          g_parmName=codeYYtext; 
                                          generateClassOrGlobalLink(*g_code,codeYYtext,!g_insideBody);
                                        }
        YY_BREAK
case 165:
YY_RULE_SETUP
#line 3120 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_theVarContext.addVariable(g_parmType,g_parmName);
                                          if (*codeYYtext==';') g_parmType.resize(0);
                                          g_parmName.resize(0);
                                        }
        YY_BREAK
case 166:
YY_RULE_SETUP
#line 3126 "code.l"
{
                                          startFontClass("preprocessor");
                                          g_lastSkipCppContext = Body;
                                          g_code->codify(codeYYtext);
                                          BEGIN( SkipCPP );
                                        }
        YY_BREAK
case 167:
YY_RULE_SETUP
#line 3132 "code.l"
{
                                          unput(*codeYYtext);
                                          if (!g_insideBody) 
                                          {
                                            g_theVarContext.popScope();
                                          }
                                          g_name.resize(0);g_args.resize(0);
                                          g_parmType.resize(0);g_parmName.resize(0);
                                          BEGIN( Body ); 
                                        }
        YY_BREAK
case 168:
YY_RULE_SETUP
#line 3142 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_type.resize(0); g_name.resize(0);
                                          BEGIN( Body );
                                        }
        YY_BREAK
case 169:
YY_RULE_SETUP
#line 3147 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          g_curlyCount++; 
                                          if (g_searchingForBody)
                                          {
                                            g_searchingForBody=FALSE;
                                            g_insideBody=TRUE;
                                          }
                                          if (g_insideBody) g_bodyCurlyCount++;
                                          if (g_name.find("::")!=-1) 
                                          {
                                            DBG_CTX((stderr,"** scope stack push SCOPEBLOCK\n"));
                                            g_scopeStack.push(SCOPEBLOCK);
                                            setClassScope(g_realScope);
                                          }
                                          else
                                          {
                                            DBG_CTX((stderr,"** scope stack push INNERBLOCK\n"));
                                            g_scopeStack.push(INNERBLOCK);
                                          }
                                          g_type.resize(0); g_name.resize(0);
                                          BEGIN( Body ); 
                                        }
        YY_BREAK
case 170:
YY_RULE_SETUP
#line 3170 "code.l"
{
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 171:
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3173 "code.l"
{
                                          generateFunctionLink(*g_code,codeYYtext);
                                        }
        YY_BREAK
case 172:
YY_RULE_SETUP
#line 3176 "code.l"
{ 
                                          g_name=codeYYtext; 
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          BEGIN( MemberCall2 ); 
                                        }
        YY_BREAK
case 173:
YY_RULE_SETUP
#line 3181 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          int s=0;while (!isId(codeYYtext[s])) s++;
                                          int e=(int)codeYYleng-1;while (!isId(codeYYtext[e])) e--;
                                          g_name=((QCString)codeYYtext).mid(s,e-s+1); 
                                          BEGIN( MemberCall2 ); 
                                        }
        YY_BREAK
case 174:
/* rule 174 can match eol */
YY_RULE_SETUP
#line 3188 "code.l"
{ 
                                          if (!g_args.isEmpty())
                                            generateMemberLink(*g_code,g_args,codeYYtext);
                                          else
                                            generateClassOrGlobalLink(*g_code,codeYYtext);
                                          g_args.resize(0);
                                          BEGIN( FuncCall );
                                        }
        YY_BREAK
case 175:
/* rule 175 can match eol */
YY_RULE_SETUP
#line 3196 "code.l"
{
                                          //g_code->codify(codeYYtext);
                                          g_name=codeYYtext; 
                                          generateClassOrGlobalLink(*g_code,codeYYtext);
                                          BEGIN( MemberCall2 ); 
                                        }
        YY_BREAK
case 176:
YY_RULE_SETUP
#line 3202 "code.l"
{
                                          if (codeYYtext[0]=='-') // -> could be overloaded
                                          {
                                            updateCallContextForSmartPointer();
                                          }
                                          g_code->codify(codeYYtext);
                                          g_memCallContext = YY_START;
                                          BEGIN( MemberCall ); 
                                        }
        YY_BREAK
case 177:
YY_RULE_SETUP
#line 3211 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          BEGIN( g_lastCContext ) ; 
                                        }
        YY_BREAK
case 178:
YY_RULE_SETUP
#line 3216 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 179:
YY_RULE_SETUP
#line 3219 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 180:
YY_RULE_SETUP
#line 3222 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          endFontClass();
                                          if (g_lastCContext==SkipCPP)
                                          {
                                            startFontClass("preprocessor");
                                          }
                                          BEGIN( g_lastCContext ) ; 
                                        }
        YY_BREAK
case 181:
/* rule 181 can match eol */
YY_RULE_SETUP
#line 3231 "code.l"
{ // line continuation
                                          codifyLines(codeYYtext);
                                        }
        YY_BREAK
case 182:
YY_RULE_SETUP
#line 3234 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 183:
YY_RULE_SETUP
#line 3237 "code.l"

        YY_BREAK
case 184:
/* rule 184 can match eol */
YY_RULE_SETUP
#line 3238 "code.l"
{
                                          unput('\n');
                                          endFontClass();
                                          BEGIN( g_lastCContext ) ;
                                        }
        YY_BREAK
case 185:
YY_RULE_SETUP
#line 3243 "code.l"
{
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
case 186:
/* rule 186 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3246 "code.l"
{
                                          g_yyLineNr+=QCString(codeYYtext).contains('\n');
                                        }
        YY_BREAK
case 187:
/* rule 187 can match eol */
YY_RULE_SETUP
#line 3249 "code.l"
{
                                          g_yyLineNr+=QCString(codeYYtext).contains('\n');
                                          nextCodeLine();
                                          if (g_lastSpecialCContext==SkipCxxComment)
                                          { // force end of C++ comment here
                                            endFontClass();
                                            BEGIN( g_lastCContext ) ;
                                          }
                                          else
                                          {
                                            BEGIN(g_lastSpecialCContext);
                                          }
                                        }
        YY_BREAK
case 188:
YY_RULE_SETUP
#line 3262 "code.l"
{
                                          BEGIN(g_lastSpecialCContext);
                                        }
        YY_BREAK
case 189:
YY_RULE_SETUP
#line 3265 "code.l"

        YY_BREAK
case 190:
YY_RULE_SETUP
#line 3266 "code.l"

        YY_BREAK
case 191:
/* rule 191 can match eol */
YY_RULE_SETUP
#line 3267 "code.l"
{ g_yyLineNr++; }
        YY_BREAK
case 192:
YY_RULE_SETUP
#line 3268 "code.l"

        YY_BREAK
case 193:
YY_RULE_SETUP
#line 3269 "code.l"
{ 
                                          g_code->codify(codeYYtext);
                                          g_type.resize(0);
                                          g_name.resize(0);
                                          BEGIN(g_memCallContext); 
                                        }
        YY_BREAK
case 194:
/* rule 194 can match eol */
YY_RULE_SETUP
#line 3275 "code.l"
{ // remove special one-line comment
                                          if (YY_START==SkipCPP) REJECT;
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_yyLineNr+=((QCString)codeYYtext).contains('\n');
                                            nextCodeLine();
                                          }
                                          else
                                          {
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                          if (YY_START==SkipCxxComment)
                                          {
                                            endFontClass();
                                            BEGIN( g_lastCContext ) ;
                                          }
                                        }
        YY_BREAK
case 195:
/* rule 195 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3294 "code.l"
{ 
                                          endFontClass();
                                          codifyLines(codeYYtext);
                                          BEGIN( g_lastSkipCppContext ) ;
                                        }
        YY_BREAK
case 196:
/* rule 196 can match eol */
YY_RULE_SETUP
#line 3299 "code.l"
{ // remove one-line group marker
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_yyLineNr+=2;
                                            nextCodeLine();
                                          }
                                          else
                                          {
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                          if (YY_START==SkipCxxComment)
                                          {
                                            endFontClass();
                                            BEGIN( g_lastCContext ) ;
                                          }
                                        }
        YY_BREAK
case 197:
/* rule 197 can match eol */
YY_RULE_SETUP
#line 3317 "code.l"
{ // remove one-line group marker
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_lastSpecialCContext = YY_START;
                                            g_yyLineNr++;
                                            BEGIN(RemoveSpecialCComment);
                                          }
                                          else
                                          {
                                            // check is to prevent getting stuck in skipping C++ comments
                                            if (YY_START != SkipCxxComment)
                                            {
                                              g_lastCContext = YY_START ;
                                            }
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            BEGIN(SkipComment);
                                          }
                                        }
        YY_BREAK
case 198:
/* rule 198 can match eol */
YY_RULE_SETUP
#line 3336 "code.l"
{ // remove one-line group marker
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_yyLineNr++;
                                            nextCodeLine();
                                          }
                                          else
                                          {
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                        }
        YY_BREAK
case 199:
YY_RULE_SETUP
#line 3349 "code.l"
{ // remove multi-line group marker
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_lastSpecialCContext = YY_START;
                                            BEGIN(RemoveSpecialCComment);
                                          }
                                          else
                                          {
                                            // check is to prevent getting stuck in skipping C++ comments
                                            if (YY_START != SkipCxxComment)
                                            {
                                              g_lastCContext = YY_START ;
                                            }
                                            startFontClass("comment");
                                            g_code->codify(codeYYtext);
                                            BEGIN(SkipComment);
                                          }
                                        }
        YY_BREAK
case 200:
/* rule 200 can match eol */
YY_RULE_SETUP
#line 3367 "code.l"
{ // remove special one-line comment
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_yyLineNr++;
                                            //nextCodeLine();
                                          }
                                          else
                                          {
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                        }
        YY_BREAK
case 201:
/* rule 201 can match eol */
YY_RULE_SETUP
#line 3380 "code.l"
{ // strip special one-line comment
                                          if (YY_START==SkipComment || YY_START==SkipString) REJECT;
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            char c[2]; c[0]='\n'; c[1]=0;
                                            codifyLines(c);
                                          }
                                          else
                                          {
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            endFontClass();
                                          }
                                        }
        YY_BREAK
case 202:
YY_RULE_SETUP
#line 3394 "code.l"
{ // special pattern /*[tag:filename]*/ to force linking to a tag file
                                          g_forceTagReference=codeYYtext;
                                          int s=g_forceTagReference.find(':');
                                          int e=g_forceTagReference.findRev(']');
                                          g_forceTagReference = g_forceTagReference.mid(s+1,e-s-1);
                                        }
        YY_BREAK
case 203:
/* rule 203 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3400 "code.l"
{
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_lastSpecialCContext = YY_START;
                                            g_yyLineNr++;
                                            BEGIN(RemoveSpecialCComment);
                                          }
                                          else
                                          {
                                            // check is to prevent getting stuck in skipping C++ comments
                                            if (YY_START != SkipCxxComment)
                                            {
                                              g_lastCContext = YY_START ;
                                            }
                                            startFontClass("comment");
                                            codifyLines(codeYYtext);
                                            BEGIN(SkipComment);
                                          }
                                        }
        YY_BREAK
case 204:
/* rule 204 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3419 "code.l"
{ // special C comment block at a new line
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_lastSpecialCContext = YY_START;
                                            BEGIN(RemoveSpecialCComment);
                                          }
                                          else
                                          {
                                            // check is to prevent getting stuck in skipping C++ comments
                                            if (YY_START != SkipCxxComment)
                                            {
                                              g_lastCContext = YY_START ;
                                            }
                                            startFontClass("comment");
                                            g_code->codify(codeYYtext);
                                            BEGIN(SkipComment);
                                          }
                                        }
        YY_BREAK
case 205:
/* rule 205 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up codeYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 3;
YY_DO_BEFORE_ACTION; /* set up codeYYtext again */
YY_RULE_SETUP
#line 3437 "code.l"
{ // special C comment block half way a line
                                          if (YY_START==SkipString) REJECT;
                                          if (Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            g_lastSpecialCContext = YY_START;
                                            BEGIN(RemoveSpecialCComment);
                                          }
                                          else
                                          {
                                            // check is to prevent getting stuck in skipping C++ comments
                                            if (YY_START != SkipCxxComment)
                                            {
                                              g_lastCContext = YY_START ;
                                            }
                                            startFontClass("comment");
                                            g_code->codify(codeYYtext);
                                            BEGIN(SkipComment);
                                          }
                                        }
        YY_BREAK
case 206:
YY_RULE_SETUP
#line 3456 "code.l"
{ 
                                          if (YY_START==SkipString) REJECT;
                                          if (!Config_getBool("STRIP_CODE_COMMENTS"))
                                          {
                                            startFontClass("comment");
                                            g_code->codify(codeYYtext);
                                            endFontClass();
                                          }
                                        }
        YY_BREAK
case 207:
YY_RULE_SETUP
#line 3465 "code.l"
{ 
                                          startFontClass("comment");
                                          g_code->codify(codeYYtext);
                                          // check is to prevent getting stuck in skipping C++ comments
                                          if (YY_START != SkipCxxComment)
                                          {
                                            g_lastCContext = YY_START ;
                                          }
                                          BEGIN( SkipComment ) ;
                                        }
        YY_BREAK
case 208:
YY_RULE_SETUP
#line 3475 "code.l"
{ // C# verbatim string
                                          startFontClass("stringliteral");
                                          g_code->codify(codeYYtext);
                                          g_lastVerbStringContext=YY_START;
                                          BEGIN(SkipVerbString);
                                        }
        YY_BREAK
case 209:
YY_RULE_SETUP
#line 3481 "code.l"
{ 
                                          startFontClass("comment");
                                          g_code->codify(codeYYtext);
                                          g_lastCContext = YY_START ;
                                          BEGIN( SkipCxxComment ) ;
                                        }
        YY_BREAK
case 210:
YY_RULE_SETUP
#line 3487 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_theCallContext.pushScope();
                                        }
        YY_BREAK
case 211:
YY_RULE_SETUP
#line 3491 "code.l"
{
                                          g_code->codify(codeYYtext);
                                          g_theCallContext.popScope();
                                        }
        YY_BREAK
case 212:
/* rule 212 can match eol */
YY_RULE_SETUP
#line 3495 "code.l"
{
                                          g_yyColNr++;
                                          codifyLines(codeYYtext); 
                                        }
        YY_BREAK
case 213:
YY_RULE_SETUP
#line 3499 "code.l"
{
                                          g_yyColNr++;
                                          g_code->codify(codeYYtext);
                                        }
        YY_BREAK
/*
<*>([ \t\n]*"\n"){2,}                   { // combine multiple blank lines
                                          //QCString sepLine=codeYYtext;
                                          //g_code->codify("\n\n");
                                          //g_yyLineNr+=sepLine.contains('\n'); 
                                          //char sepLine[3]="\n\n";
                                          codifyLines(codeYYtext);
                                        }
  */
case 214:
YY_RULE_SETUP
#line 3513 "code.l"
ECHO;
        YY_BREAK
#line 15324 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/code.cpp"
                        case YY_STATE_EOF(INITIAL):
                        case YY_STATE_EOF(SkipString):
                        case YY_STATE_EOF(SkipStringS):
                        case YY_STATE_EOF(SkipVerbString):
                        case YY_STATE_EOF(SkipCPP):
                        case YY_STATE_EOF(SkipComment):
                        case YY_STATE_EOF(SkipCxxComment):
                        case YY_STATE_EOF(RemoveSpecialCComment):
                        case YY_STATE_EOF(StripSpecialCComment):
                        case YY_STATE_EOF(Body):
                        case YY_STATE_EOF(FuncCall):
                        case YY_STATE_EOF(MemberCall):
                        case YY_STATE_EOF(MemberCall2):
                        case YY_STATE_EOF(SkipInits):
                        case YY_STATE_EOF(ClassName):
                        case YY_STATE_EOF(AlignAs):
                        case YY_STATE_EOF(AlignAsEnd):
                        case YY_STATE_EOF(PackageName):
                        case YY_STATE_EOF(ClassVar):
                        case YY_STATE_EOF(CppCliTypeModifierFollowup):
                        case YY_STATE_EOF(Bases):
                        case YY_STATE_EOF(SkipSharp):
                        case YY_STATE_EOF(ReadInclude):
                        case YY_STATE_EOF(TemplDecl):
                        case YY_STATE_EOF(TemplCast):
                        case YY_STATE_EOF(CallEnd):
                        case YY_STATE_EOF(ObjCMethod):
                        case YY_STATE_EOF(ObjCParams):
                        case YY_STATE_EOF(ObjCParamType):
                        case YY_STATE_EOF(ObjCCall):
                        case YY_STATE_EOF(ObjCMName):
                        case YY_STATE_EOF(ObjCSkipStr):
                        case YY_STATE_EOF(OldStyleArgs):
                        case YY_STATE_EOF(UsingName):
                        case YY_STATE_EOF(RawString):
                        case YY_STATE_EOF(InlineInit):
                                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 codeYYin at a new source and called
                         * codeYYlex().  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 = codeYYin;
                        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 ( codeYYwrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
                                         * codeYYtext, 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 writeMultiLineCodeLink ( CodeOutputInterface &  ol, Definition *  d, const char *  text  )

static

writes a link to a fragment text that may span multiple lines, inserting line numbers for each line. If text contains newlines, the link will be split into multiple links with the same destination, one for each line.

Definition at line 11137 of file code.cpp.

{
  static bool sourceTooltips = Config_getBool("SOURCE_TOOLTIPS");
  TooltipManager::instance()->addTooltip(d);
  QCString ref  = d->getReference();
  QCString file = d->getOutputFileBase();
  QCString anchor = d->anchor();
  QCString tooltip; 
  if (!sourceTooltips) // fall back to simple "title" tooltips
  {
    tooltip = d->briefDescriptionAsTooltip();
  }
  bool done=FALSE;
  char *p=(char *)text;
  while (!done)
  {
    char *sp=p;
    char c;
    while ((c=*p++) && c!='\n') { }
    if (c=='\n')
    {
      g_yyLineNr++;
      *(p-1)='\0';
      //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);
      ol.writeCodeLink(ref,file,anchor,sp,tooltip);
      nextCodeLine();
    }
    else
    {
      //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);
      ol.writeCodeLink(ref,file,anchor,sp,tooltip);
      done=TRUE;
    }
  }
}

static void writeObjCMethodCall ( ObjCCallCtx *  ctx )

static

Definition at line 11981 of file code.cpp.

{
  if (ctx==0) return;
  char c;
  const char *p = ctx->format.data();
  if (!ctx->methodName.isEmpty())
  {
    //printf("writeObjCMethodCall(%s) obj=%s method=%s\n",
    //    ctx->format.data(),ctx->objectTypeOrName.data(),ctx->methodName.data());
    if (!ctx->objectTypeOrName.isEmpty() && ctx->objectTypeOrName.at(0)!='$')
    {
      //printf("Looking for object=%s method=%s\n",ctx->objectTypeOrName.data(),
      //        ctx->methodName.data());
      ClassDef *cd = g_theVarContext.findVariable(ctx->objectTypeOrName);
      if (cd==0) // not a local variable
      {
        if (ctx->objectTypeOrName=="self")
        {
          if (g_currentDefinition && 
              g_currentDefinition->definitionType()==Definition::TypeClass)
          {
            ctx->objectType = (ClassDef *)g_currentDefinition;
          }
        }
        else
        {
          ctx->objectType = getResolvedClass(
              g_currentDefinition,
              g_sourceFileDef,
              ctx->objectTypeOrName,
              &ctx->method);
        }
        //printf("  object is class? %p\n",ctx->objectType);
        if (ctx->objectType) // found class
        {
          ctx->method = ctx->objectType->getMemberByName(ctx->methodName);
          //printf("    yes->method=%s\n",ctx->method?ctx->method->name().data():"<none>");
        }
        else if (ctx->method==0) // search for class variable with the same name
        {
          //printf("    no\n");
          //printf("g_currentDefinition=%p\n",g_currentDefinition);
          if (g_currentDefinition && 
              g_currentDefinition->definitionType()==Definition::TypeClass)
          {
            ctx->objectVar = ((ClassDef *)g_currentDefinition)->getMemberByName(ctx->objectTypeOrName);
            //printf("      ctx->objectVar=%p\n",ctx->objectVar);
            if (ctx->objectVar)
            {
              ctx->objectType = stripClassName(ctx->objectVar->typeString());
              //printf("        ctx->objectType=%p\n",ctx->objectType);
              if (ctx->objectType)
              {
                ctx->method = ctx->objectType->getMemberByName(ctx->methodName);
                //printf("          ctx->method=%p\n",ctx->method);
              }
            }
          }
        }
      }
      else // local variable
      {
        //printf("  object is local variable\n");
        if (cd!=VariableContext::dummyContext)
        {
          ctx->method = cd->getMemberByName(ctx->methodName);
          //printf("   class=%p method=%p\n",cd,ctx->method);
        }
      }
    }
  }

  //printf("[");
  while ((c=*p++)) // for each character in ctx->format
  {
    if (c=='$')
    {
      char nc=*p++;
      if (nc=='$') // escaped $
      {
        g_code->codify("$");
      }
      else // name fragment or reference to a nested call 
      {
        if (nc=='n') // name fragment
        {
          nc=*p++;
          QCString refIdStr;
          while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; }
          p--;
          int refId=refIdStr.toInt();
          QCString *pName = g_nameDict.find(refId);
          if (pName)
          {
            if (ctx->method && ctx->method->isLinkable())
            {
              writeMultiLineCodeLink(*g_code,ctx->method,pName->data());
              if (g_currentMemberDef && g_collectXRefs)
              {
                addDocCrossReference(g_currentMemberDef,ctx->method);
              }
            }
            else
            {
              codifyLines(pName->data());
            }
          }
          else
          {
            //printf("Invalid name: id=%d\n",refId);
          }
        }
        else if (nc=='o') // reference to potential object name
        {
          nc=*p++;
          QCString refIdStr;
          while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; }
          p--;
          int refId=refIdStr.toInt();
          QCString *pObject = g_objectDict.find(refId);
          if (pObject)
          {
            if (*pObject=="self")
            {
              if (g_currentDefinition && 
                  g_currentDefinition->definitionType()==Definition::TypeClass)
              {
                ctx->objectType = (ClassDef *)g_currentDefinition;
                if (ctx->objectType->categoryOf()) 
                {
                  ctx->objectType = ctx->objectType->categoryOf();
                }
                if (ctx->objectType)
                {
                  ctx->method = ctx->objectType->getMemberByName(ctx->methodName);
                }
              }
              startFontClass("keyword");
              codifyLines(pObject->data());
              endFontClass();
            }
            else if (*pObject=="super")
            {
              if (g_currentDefinition &&
                  g_currentDefinition->definitionType()==Definition::TypeClass)
              {
                ClassDef *cd = (ClassDef *)g_currentDefinition;
                if (cd->categoryOf()) 
                {
                  cd = cd->categoryOf();
                }
                BaseClassList *bcd = cd->baseClasses();
                if (bcd) // get direct base class (there should be only one)
                {
                  BaseClassListIterator bli(*bcd);
                  BaseClassDef *bclass;
                  for (bli.toFirst();(bclass=bli.current());++bli)
                  {
                    if (bclass->classDef->compoundType()!=ClassDef::Protocol)
                    {
                      ctx->objectType = bclass->classDef;
                      if (ctx->objectType)
                      {
                        ctx->method = ctx->objectType->getMemberByName(ctx->methodName);
                      }
                    }
                  }
                }
              }
              startFontClass("keyword");
              codifyLines(pObject->data());
              endFontClass();
            }
            else if (ctx->objectVar && ctx->objectVar->isLinkable()) // object is class variable
            {
              writeMultiLineCodeLink(*g_code,ctx->objectVar,pObject->data());
              if (g_currentMemberDef && g_collectXRefs)
              {
                addDocCrossReference(g_currentMemberDef,ctx->objectVar);
              }
            }
            else if (ctx->objectType && 
                     ctx->objectType!=VariableContext::dummyContext && 
                     ctx->objectType->isLinkable()
                    ) // object is class name
            {
              ClassDef *cd = ctx->objectType;
              writeMultiLineCodeLink(*g_code,cd,pObject->data());
            }
            else // object still needs to be resolved
            {
              ClassDef *cd = getResolvedClass(g_currentDefinition, 
                  g_sourceFileDef, *pObject);
              if (cd && cd->isLinkable())
              {
                if (ctx->objectType==0) ctx->objectType=cd;
                writeMultiLineCodeLink(*g_code,cd,pObject->data());
              }
              else
              {
                codifyLines(pObject->data());
              }
            }
          }
          else
          {
            //printf("Invalid object: id=%d\n",refId);
          }
        }
        else if (nc=='c') // reference to nested call
        {
          nc=*p++;
          QCString refIdStr;
          while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; }
          p--;
          int refId=refIdStr.toInt();
          ObjCCallCtx *ictx = g_contextDict.find(refId);
          if (ictx) // recurse into nested call
          {
            writeObjCMethodCall(ictx);
            if (ictx->method) // link to nested call successfully
            {
              // get the ClassDef representing the method's return type
              if (QCString(ictx->method->typeString())=="id")
              {
                // see if the method name is unique, if so we link to it
                MemberName *mn=Doxygen::memberNameSDict->find(ctx->methodName);
                //printf("mn->count=%d ictx->method=%s ctx->methodName=%s\n",
                //    mn==0?-1:(int)mn->count(),
                //    ictx->method->name().data(),
                //    ctx->methodName.data());
                if (mn && mn->count()==1) // member name unique
                {
                  ctx->method = mn->getFirst();
                }
              } 
              else
              {
                ctx->objectType = stripClassName(ictx->method->typeString());
                if (ctx->objectType)
                {
                  ctx->method = ctx->objectType->getMemberByName(ctx->methodName);
                }
              }
              //printf("  ***** method=%s -> object=%p\n",ictx->method->name().data(),ctx->objectType);
            }
          }
          else
          {
            //printf("Invalid context: id=%d\n",refId);
          }
        }
        else if (nc=='w') // some word
        {
          nc=*p++;
          QCString refIdStr;
          while (nc!=0 && isdigit(nc)) { refIdStr+=nc; nc=*p++; }
          p--;
          int refId=refIdStr.toInt();
          QCString *pWord = g_wordDict.find(refId);
          if (pWord)
          {
            codifyLines(pWord->data());
          }
        }
        else // illegal marker
        {
          ASSERT(!"invalid escape sequence");
        }
      }
    }
    else // normal non-marker character
    {
      char s[2];
      s[0]=c;s[1]=0;
      codifyLines(s);
    }
  }  
  //printf("%s %s]\n",ctx->objectTypeOrName.data(),ctx->methodName.data());
  //printf("}=(type='%s',name='%s')",
  //    ctx->objectTypeOrName.data(),
  //    ctx->methodName.data());
}

static void yy_fatal_error ( yyconst char  msg[] )

static

static void yy_fatal_error ( yyconst char *  msg )

static

Definition at line 16120 of file code.cpp.

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

static int yy_get_next_buffer ( void  )

static

Definition at line 15498 of file code.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;
                        codeYYrestart(codeYYin  );
                        }

                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 *) codeYYrealloc((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 15603 of file code.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 >= 3537 )
                                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 16223 of file code.cpp.

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from codeYYlex_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
    codeYYin = stdin;
    codeYYout = stdout;
#else
    codeYYin = (FILE *) 0;
    codeYYout = (FILE *) 0;
#endif

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

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 15635 of file code.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 >= 3537 )
                        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 == 3536);
        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 12300 of file code.cpp.

{
    int c=0;
    while( c < max_size && g_inputString[g_inputPosition] )
    {
        *buf = g_inputString[g_inputPosition++] ;
        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 15654 of file code.cpp.

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

        /* undo effects of setting up codeYYtext */
        *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

int codeYY_flex_debug = 0

Definition at line 10514 of file code.cpp.

FILE * codeYYin = (FILE *) 0

Definition at line 359 of file code.cpp.

int codeYYleng

Definition at line 294 of file code.cpp.

int codeYYlineno = 1

Definition at line 365 of file code.cpp.

FILE * codeYYout = (FILE *) 0

Definition at line 359 of file code.cpp.

char * codeYYtext

Definition at line 10538 of file code.cpp.

int g_anchorCount

static

Definition at line 10625 of file code.cpp.

QCString g_args

static

Definition at line 10620 of file code.cpp.

int g_bodyCurlyCount

static

Definition at line 10634 of file code.cpp.

int g_braceCount =0

static

Definition at line 10692 of file code.cpp.

int g_bracketCount = 0

static

Definition at line 10639 of file code.cpp.

QCString g_classScope

static

Definition at line 10621 of file code.cpp.

QStack<int> g_classScopeLengthStack

static

Definition at line 10662 of file code.cpp.

CodeOutputInterface* g_code

static

Definition at line 10597 of file code.cpp.

ClassSDict* g_codeClassSDict = 0

static

Definition at line 10599 of file code.cpp.

bool g_collectXRefs

static

Definition at line 10665 of file code.cpp.

QIntDict<ObjCCallCtx> g_contextDict

static

Definition at line 10688 of file code.cpp.

QStack<ObjCCallCtx> g_contextStack

static

Definition at line 10687 of file code.cpp.

QStrList g_curClassBases

static

Definition at line 10601 of file code.cpp.

QCString g_curClassName

static

Definition at line 10600 of file code.cpp.

int g_curlyCount = 0

static

Definition at line 10640 of file code.cpp.

ObjCCallCtx* g_currentCtx =0

static

Definition at line 10682 of file code.cpp.

int g_currentCtxId =0

static

Definition at line 10683 of file code.cpp.

Definition* g_currentDefinition

static

Definition at line 10628 of file code.cpp.

const char* g_currentFontClass

static

Definition at line 10631 of file code.cpp.

MemberDef* g_currentMemberDef

static

Definition at line 10629 of file code.cpp.

int g_currentNameId =0

static

Definition at line 10684 of file code.cpp.

int g_currentObjId =0

static

Definition at line 10685 of file code.cpp.

int g_currentWordId =0

static

Definition at line 10686 of file code.cpp.

QCString g_delimiter

static

Definition at line 10637 of file code.cpp.

bool g_exampleBlock

static

Definition at line 10613 of file code.cpp.

QCString g_exampleFile

static

Definition at line 10615 of file code.cpp.

QCString g_exampleName

static

Definition at line 10614 of file code.cpp.

QCString g_forceTagReference

static

Definition at line 10697 of file code.cpp.

bool g_includeCodeFragment

static

Definition at line 10630 of file code.cpp.

bool g_inForEachExpression = FALSE

static

Definition at line 10643 of file code.cpp.

bool g_inFunctionTryBlock = FALSE

static

Definition at line 10642 of file code.cpp.

int g_inputLines

static

number of line in the code fragment

Definition at line 10608 of file code.cpp.

int g_inputPosition

static

read offset during parsing

Definition at line 10607 of file code.cpp.

const char* g_inputString

static

the code fragment as text

Definition at line 10606 of file code.cpp.

bool g_insideBody

static

Definition at line 10633 of file code.cpp.

bool g_insideCS

static

Definition at line 10656 of file code.cpp.

bool g_insideJava

static

Definition at line 10655 of file code.cpp.

bool g_insideObjC

static

Definition at line 10654 of file code.cpp.

bool g_insidePHP

static

Definition at line 10657 of file code.cpp.

bool g_insideProtocolList

static

Definition at line 10658 of file code.cpp.

bool g_insideTemplate = FALSE

static

Definition at line 10617 of file code.cpp.

int g_lastCContext

static

Definition at line 10651 of file code.cpp.

int g_lastSkipCppContext

static

Definition at line 10648 of file code.cpp.

int g_lastSpecialCContext

static

Definition at line 10646 of file code.cpp.

int g_lastStringContext

static

Definition at line 10647 of file code.cpp.

int g_lastTemplCastContext

static

Definition at line 10645 of file code.cpp.

int g_lastVerbStringContext

static

Definition at line 10649 of file code.cpp.

bool g_lexInit = FALSE

static

Definition at line 10660 of file code.cpp.

bool g_lineNumbers

static

Definition at line 10627 of file code.cpp.

int g_memCallContext

static

Definition at line 10650 of file code.cpp.

QCString g_name

static

Definition at line 10619 of file code.cpp.

QIntDict<QCString> g_nameDict

static

Definition at line 10689 of file code.cpp.

bool g_needsTermination

static

Definition at line 10611 of file code.cpp.

QIntDict<QCString> g_objectDict

static

Definition at line 10690 of file code.cpp.

QCString g_parmName

static

Definition at line 10604 of file code.cpp.

QCString g_parmType

static

Definition at line 10603 of file code.cpp.

QCString g_realScope

static

Definition at line 10622 of file code.cpp.

QCString g_saveName

static

Definition at line 10635 of file code.cpp.

QCString g_saveType

static

Definition at line 10636 of file code.cpp.

QStack<int> g_scopeStack

static

1 if bracket starts a scope,

Definition at line 10623 of file code.cpp.

Definition* g_searchCtx

static

Definition at line 10664 of file code.cpp.

bool g_searchingForBody

static

Definition at line 10632 of file code.cpp.

int g_sharpCount = 0

static

Definition at line 10641 of file code.cpp.

int g_skipInlineInitContext

static

Definition at line 10652 of file code.cpp.

FileDef* g_sourceFileDef

static

Definition at line 10626 of file code.cpp.

CallContext g_theCallContext

static

Definition at line 10930 of file code.cpp.

VariableContext g_theVarContext

static

Definition at line 10860 of file code.cpp.

QCString g_type

static

Definition at line 10618 of file code.cpp.

QIntDict<QCString> g_wordDict

static

Definition at line 10691 of file code.cpp.

int g_yyColNr

static

current column number

Definition at line 10610 of file code.cpp.

int g_yyLineNr

static

current line number

Definition at line 10609 of file code.cpp.

yyconst flex_int16_t yy_accept[3538]

static

Definition at line 1133 of file code.cpp.

yyconst flex_int16_t yy_acclist[6690]

static

Definition at line 394 of file code.cpp.

register int yy_act

Definition at line 12564 of file code.cpp.

yyconst flex_int32_t yy_base[4112]

static

Definition at line 1571 of file code.cpp.

register char * yy_bp

Definition at line 12563 of file code.cpp.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 274 of file code.cpp.

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 273 of file code.cpp.

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 272 of file code.cpp.

char* yy_c_buf_p = (char *) 0

static

Definition at line 297 of file code.cpp.

yyconst flex_int16_t yy_chk[36458]

static

Definition at line 6499 of file code.cpp.

register char* yy_cp

Definition at line 12563 of file code.cpp.

YY_DECL

Initial value:

{
        register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 12561 of file code.cpp.

yyconst flex_int16_t yy_def[4112]

static

Definition at line 2028 of file code.cpp.

int yy_did_buffer_switch_on_eof

static

Definition at line 304 of file code.cpp.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 1526 of file code.cpp.

int yy_full_lp

static

Definition at line 10520 of file code.cpp.

char* yy_full_match

static

Definition at line 10517 of file code.cpp.

int* yy_full_state

static

Definition at line 10521 of file code.cpp.

char yy_hold_char

static

Definition at line 292 of file code.cpp.

int yy_init = 0

static

Definition at line 298 of file code.cpp.

int yy_looking_for_trail_begin = 0

static

Definition at line 10519 of file code.cpp.

int yy_lp

static

Definition at line 10518 of file code.cpp.

yyconst flex_int32_t yy_meta[85]

static

Initial value:

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

Definition at line 1558 of file code.cpp.

int yy_n_chars

static

Definition at line 293 of file code.cpp.

yyconst flex_int16_t yy_nxt[36458]

static

Definition at line 2485 of file code.cpp.

int yy_start = 0

static

Definition at line 299 of file code.cpp.

yy_state_type* yy_state_buf =0

static

Definition at line 10516 of file code.cpp.

yy_state_type * yy_state_ptr =0

static

Definition at line 10516 of file code.cpp.