Classes | Macros | Typedefs | Functions | Variables
doctokenizer.cpp File Reference
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <ctype.h>
#include <qfile.h>
#include <qstring.h>
#include <qstack.h>
#include <qdict.h>
#include <qregexp.h>
#include "doctokenizer.h"
#include "cmdmapper.h"
#include "config.h"
#include "message.h"
#include "section.h"
#include "membergroup.h"
#include "definition.h"
#include "doxygen.h"
#include "portable.h"

Go to the source code of this file.

Classes

struct  yy_buffer_state
 
struct  yy_trans_info
 
struct  DocLexerContext
 

Macros

#define YY_INT_ALIGNED   short int
 
#define yy_create_buffer   doctokenizerYY_create_buffer
 
#define yy_delete_buffer   doctokenizerYY_delete_buffer
 
#define yy_flex_debug   doctokenizerYY_flex_debug
 
#define yy_init_buffer   doctokenizerYY_init_buffer
 
#define yy_flush_buffer   doctokenizerYY_flush_buffer
 
#define yy_load_buffer_state   doctokenizerYY_load_buffer_state
 
#define yy_switch_to_buffer   doctokenizerYY_switch_to_buffer
 
#define yyin   doctokenizerYYin
 
#define yyleng   doctokenizerYYleng
 
#define yylex   doctokenizerYYlex
 
#define yylineno   doctokenizerYYlineno
 
#define yyout   doctokenizerYYout
 
#define yyrestart   doctokenizerYYrestart
 
#define yytext   doctokenizerYYtext
 
#define yywrap   doctokenizerYYwrap
 
#define yyalloc   doctokenizerYYalloc
 
#define yyrealloc   doctokenizerYYrealloc
 
#define yyfree   doctokenizerYYfree
 
#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   doctokenizerYYrestart(doctokenizerYYin )
 
#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   doctokenizerYY_flush_buffer(YY_CURRENT_BUFFER )
 
#define yy_new_buffer   doctokenizerYY_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 doctokenizerYYwrap(n)   1
 
#define YY_SKIP_YYWRAP
 
#define yytext_ptr   doctokenizerYYtext
 
#define YY_DO_BEFORE_ACTION
 
#define YY_NUM_RULES   206
 
#define YY_END_OF_BUFFER   207
 
#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 YY_NO_INPUT   1
 
#define YY_NO_UNISTD_H   1
 
#define YY_INPUT(buf, result, max_size)   result=yyread(buf,max_size);
 
#define INITIAL   0
 
#define St_Para   1
 
#define St_Comment   2
 
#define St_Title   3
 
#define St_TitleN   4
 
#define St_TitleQ   5
 
#define St_TitleA   6
 
#define St_TitleV   7
 
#define St_Code   8
 
#define St_CodeOpt   9
 
#define St_XmlCode   10
 
#define St_HtmlOnly   11
 
#define St_HtmlOnlyOption   12
 
#define St_ManOnly   13
 
#define St_LatexOnly   14
 
#define St_RtfOnly   15
 
#define St_XmlOnly   16
 
#define St_DbOnly   17
 
#define St_Verbatim   18
 
#define St_Dot   19
 
#define St_Msc   20
 
#define St_PlantUMLOpt   21
 
#define St_PlantUML   22
 
#define St_Param   23
 
#define St_XRefItem   24
 
#define St_XRefItem2   25
 
#define St_File   26
 
#define St_Pattern   27
 
#define St_Link   28
 
#define St_Cite   29
 
#define St_Ref   30
 
#define St_Ref2   31
 
#define St_IntRef   32
 
#define St_Text   33
 
#define St_SkipTitle   34
 
#define St_Anchor   35
 
#define St_Snippet   36
 
#define St_SetScope   37
 
#define St_SetScopeEnd   38
 
#define St_Sections   39
 
#define St_SecLabel1   40
 
#define St_SecLabel2   41
 
#define St_SecTitle   42
 
#define St_SecSkip   43
 
#define YY_EXTRA_TYPE   void *
 
#define YY_READ_BUF_SIZE   8192
 
#define ECHO   do { if (fwrite( doctokenizerYYtext, doctokenizerYYleng, 1, doctokenizerYYout )) {} } 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 doctokenizerYYlex (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_stateYY_BUFFER_STATE
 
typedef size_t yy_size_t
 
typedef unsigned char YY_CHAR
 
typedef int yy_state_type
 

Functions

void doctokenizerYYrestart (FILE *input_file)
 
void doctokenizerYY_switch_to_buffer (YY_BUFFER_STATE new_buffer)
 
YY_BUFFER_STATE doctokenizerYY_create_buffer (FILE *file, int size)
 
void doctokenizerYY_delete_buffer (YY_BUFFER_STATE b)
 
void doctokenizerYY_flush_buffer (YY_BUFFER_STATE b)
 
void doctokenizerYYpush_buffer_state (YY_BUFFER_STATE new_buffer)
 
void doctokenizerYYpop_buffer_state (void)
 
static void doctokenizerYYensure_buffer_stack (void)
 
static void doctokenizerYY_load_buffer_state (void)
 
static void doctokenizerYY_init_buffer (YY_BUFFER_STATE b, FILE *file)
 
YY_BUFFER_STATE doctokenizerYY_scan_buffer (char *base, yy_size_t size)
 
YY_BUFFER_STATE doctokenizerYY_scan_string (yyconst char *yy_str)
 
YY_BUFFER_STATE doctokenizerYY_scan_bytes (yyconst char *bytes, int len)
 
void * doctokenizerYYalloc (yy_size_t)
 
void * doctokenizerYYrealloc (void *, yy_size_t)
 
void doctokenizerYYfree (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[])
 
void doctokenizerYYpushContext ()
 
bool doctokenizerYYpopContext ()
 
const char * tokToString (int token)
 
static int computeIndent (const char *str, int length)
 
static void processSection ()
 
static void handleHtmlTag ()
 
static QCString stripEmptyLines (const QCString &s)
 
static int yyread (char *buf, int max_size)
 
static int yy_init_globals (void)
 
int doctokenizerYYlex_destroy (void)
 
int doctokenizerYYget_debug (void)
 
void doctokenizerYYset_debug (int debug_flag)
 
YY_EXTRA_TYPE doctokenizerYYget_extra (void)
 
void doctokenizerYYset_extra (YY_EXTRA_TYPE user_defined)
 
FILE * doctokenizerYYget_in (void)
 
void doctokenizerYYset_in (FILE *in_str)
 
FILE * doctokenizerYYget_out (void)
 
void doctokenizerYYset_out (FILE *out_str)
 
int doctokenizerYYget_leng (void)
 
char * doctokenizerYYget_text (void)
 
int doctokenizerYYget_lineno (void)
 
void doctokenizerYYset_lineno (int line_number)
 
static void yyunput (int c, char *buf_ptr)
 
int doctokenizerYYlex (void)
 
 if (!(yy_init))
 
 while (1)
 
static void yyunput (int c, register char *yy_bp)
 
static void yy_fatal_error (yyconst char *msg)
 
void doctokenizerYYFindSections (const char *input, Definition *d, MemberGroup *mg, const char *fileName)
 
void doctokenizerYYinit (const char *input, const char *fileName)
 
void doctokenizerYYsetStatePara ()
 
void doctokenizerYYsetStateTitle ()
 
void doctokenizerYYsetStateTitleAttrValue ()
 
void doctokenizerYYsetStateCode ()
 
void doctokenizerYYsetStateXmlCode ()
 
void doctokenizerYYsetStateHtmlOnly ()
 
void doctokenizerYYsetStateManOnly ()
 
void doctokenizerYYsetStateRtfOnly ()
 
void doctokenizerYYsetStateXmlOnly ()
 
void doctokenizerYYsetStateDbOnly ()
 
void doctokenizerYYsetStateLatexOnly ()
 
void doctokenizerYYsetStateVerbatim ()
 
void doctokenizerYYsetStateDot ()
 
void doctokenizerYYsetStateMsc ()
 
void doctokenizerYYsetStatePlantUMLOpt ()
 
void doctokenizerYYsetStatePlantUML ()
 
void doctokenizerYYsetStateParam ()
 
void doctokenizerYYsetStateXRefItem ()
 
void doctokenizerYYsetStateFile ()
 
void doctokenizerYYsetStatePattern ()
 
void doctokenizerYYsetStateLink ()
 
void doctokenizerYYsetStateCite ()
 
void doctokenizerYYsetStateRef ()
 
void doctokenizerYYsetStateInternalRef ()
 
void doctokenizerYYsetStateText ()
 
void doctokenizerYYsetStateSkipTitle ()
 
void doctokenizerYYsetStateAnchor ()
 
void doctokenizerYYsetStateSnippet ()
 
void doctokenizerYYsetStateSetScope ()
 
void doctokenizerYYcleanup ()
 
void doctokenizerYYsetInsidePre (bool b)
 
void doctokenizerYYpushBackHtmlTag (const char *tag)
 
void doctokenizerYYstartAutoList ()
 
void doctokenizerYYendAutoList ()
 

Variables

int doctokenizerYYleng
 
FILE * doctokenizerYYin = (FILE *) 0
 
FILE * doctokenizerYYout = (FILE *) 0
 
static size_t yy_buffer_stack_top = 0
 
static size_t yy_buffer_stack_max = 0
 
static YY_BUFFER_STATEyy_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 doctokenizerYYlineno = 1
 
char * doctokenizerYYtext
 
static yyconst flex_int16_t yy_acclist [5516]
 
static yyconst flex_int16_t yy_accept [10009]
 
static yyconst flex_int32_t yy_ec [256]
 
static yyconst flex_int32_t yy_meta [84]
 
static yyconst flex_int32_t yy_base [13538]
 
static yyconst flex_int16_t yy_def [13538]
 
static yyconst flex_int16_t yy_nxt [335945]
 
static yyconst flex_int16_t yy_chk [335945]
 
static yyconst flex_int32_t yy_rule_can_match_eol [207]
 
int doctokenizerYY_flex_debug = 0
 
static yy_state_typeyy_state_buf =0
 
static yy_state_typeyy_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 int g_commentState
 
TokenInfog_token = 0
 
static int g_inputPos = 0
 
static const char * g_inputString
 
static QCString g_fileName
 
static bool g_insidePre
 
static int g_sharpCount =0
 
static Definitiong_definition
 
static MemberGroupg_memberGroup
 
static QCString g_secLabel
 
static QCString g_secTitle
 
static SectionInfo::SectionType g_secType
 
static QCString g_endMarker
 
static int g_autoListLevel
 
static QStack< DocLexerContextg_lexerStack
 
 YY_DECL
 
register char * yy_cp
 
register char * yy_bp
 
register int yy_act
 

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 144 of file doctokenizer.cpp.

#define doctokenizerYYwrap (   n)    1

Definition at line 367 of file doctokenizer.cpp.

#define ECHO   do { if (fwrite( doctokenizerYYtext, doctokenizerYYleng, 1, doctokenizerYYout )) {} } while (0)

Definition at line 79611 of file doctokenizer.cpp.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file doctokenizer.cpp.

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file doctokenizer.cpp.

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file doctokenizer.cpp.

#define FLEX_BETA

Definition at line 33 of file doctokenizer.cpp.

#define FLEX_SCANNER

Definition at line 28 of file doctokenizer.cpp.

#define FLEXINT_H

Definition at line 49 of file doctokenizer.cpp.

#define INITIAL   0

Definition at line 79481 of file doctokenizer.cpp.

#define INT16_MAX   (32767)

Definition at line 92 of file doctokenizer.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file doctokenizer.cpp.

#define INT32_MAX   (2147483647)

Definition at line 95 of file doctokenizer.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file doctokenizer.cpp.

#define INT8_MAX   (127)

Definition at line 89 of file doctokenizer.cpp.

#define INT8_MIN   (-128)

Definition at line 80 of file doctokenizer.cpp.

#define REJECT
Value:
{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */ \
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; \
}
static char * yy_full_match
static yy_state_type * yy_state_ptr
static char yy_hold_char
static int yy_full_lp
register char * yy_cp
static int * yy_full_state
static int yy_lp

Definition at line 79096 of file doctokenizer.cpp.

#define St_Anchor   35

Definition at line 79516 of file doctokenizer.cpp.

#define St_Cite   29

Definition at line 79510 of file doctokenizer.cpp.

#define St_Code   8

Definition at line 79489 of file doctokenizer.cpp.

#define St_CodeOpt   9

Definition at line 79490 of file doctokenizer.cpp.

#define St_Comment   2

Definition at line 79483 of file doctokenizer.cpp.

#define St_DbOnly   17

Definition at line 79498 of file doctokenizer.cpp.

#define St_Dot   19

Definition at line 79500 of file doctokenizer.cpp.

#define St_File   26

Definition at line 79507 of file doctokenizer.cpp.

#define St_HtmlOnly   11

Definition at line 79492 of file doctokenizer.cpp.

#define St_HtmlOnlyOption   12

Definition at line 79493 of file doctokenizer.cpp.

#define St_IntRef   32

Definition at line 79513 of file doctokenizer.cpp.

#define St_LatexOnly   14

Definition at line 79495 of file doctokenizer.cpp.

#define St_Link   28

Definition at line 79509 of file doctokenizer.cpp.

#define St_ManOnly   13

Definition at line 79494 of file doctokenizer.cpp.

#define St_Msc   20

Definition at line 79501 of file doctokenizer.cpp.

#define St_Para   1

Definition at line 79482 of file doctokenizer.cpp.

#define St_Param   23

Definition at line 79504 of file doctokenizer.cpp.

#define St_Pattern   27

Definition at line 79508 of file doctokenizer.cpp.

#define St_PlantUML   22

Definition at line 79503 of file doctokenizer.cpp.

#define St_PlantUMLOpt   21

Definition at line 79502 of file doctokenizer.cpp.

#define St_Ref   30

Definition at line 79511 of file doctokenizer.cpp.

#define St_Ref2   31

Definition at line 79512 of file doctokenizer.cpp.

#define St_RtfOnly   15

Definition at line 79496 of file doctokenizer.cpp.

#define St_SecLabel1   40

Definition at line 79521 of file doctokenizer.cpp.

#define St_SecLabel2   41

Definition at line 79522 of file doctokenizer.cpp.

#define St_SecSkip   43

Definition at line 79524 of file doctokenizer.cpp.

#define St_Sections   39

Definition at line 79520 of file doctokenizer.cpp.

#define St_SecTitle   42

Definition at line 79523 of file doctokenizer.cpp.

#define St_SetScope   37

Definition at line 79518 of file doctokenizer.cpp.

#define St_SetScopeEnd   38

Definition at line 79519 of file doctokenizer.cpp.

#define St_SkipTitle   34

Definition at line 79515 of file doctokenizer.cpp.

#define St_Snippet   36

Definition at line 79517 of file doctokenizer.cpp.

#define St_Text   33

Definition at line 79514 of file doctokenizer.cpp.

#define St_Title   3

Definition at line 79484 of file doctokenizer.cpp.

#define St_TitleA   6

Definition at line 79487 of file doctokenizer.cpp.

#define St_TitleN   4

Definition at line 79485 of file doctokenizer.cpp.

#define St_TitleQ   5

Definition at line 79486 of file doctokenizer.cpp.

#define St_TitleV   7

Definition at line 79488 of file doctokenizer.cpp.

#define St_Verbatim   18

Definition at line 79499 of file doctokenizer.cpp.

#define St_XmlCode   10

Definition at line 79491 of file doctokenizer.cpp.

#define St_XmlOnly   16

Definition at line 79497 of file doctokenizer.cpp.

#define St_XRefItem   24

Definition at line 79505 of file doctokenizer.cpp.

#define St_XRefItem2   25

Definition at line 79506 of file doctokenizer.cpp.

#define UINT16_MAX   (65535U)

Definition at line 101 of file doctokenizer.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file doctokenizer.cpp.

#define UINT8_MAX   (255U)

Definition at line 98 of file doctokenizer.cpp.

#define unput (   c)    yyunput( c, (yytext_ptr) )

Definition at line 212 of file doctokenizer.cpp.

#define YY_AT_BOL ( )    (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 363 of file doctokenizer.cpp.

#define YY_BREAK   break;

Definition at line 79690 of file doctokenizer.cpp.

#define YY_BUF_SIZE   16384

Definition at line 163 of file doctokenizer.cpp.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 279 of file doctokenizer.cpp.

#define YY_BUFFER_NEW   0

Definition at line 267 of file doctokenizer.cpp.

#define YY_BUFFER_NORMAL   1

Definition at line 268 of file doctokenizer.cpp.

#define yy_create_buffer   doctokenizerYY_create_buffer

Definition at line 9 of file doctokenizer.cpp.

#define YY_CURRENT_BUFFER
Value:
: NULL)
static YY_BUFFER_STATE * yy_buffer_stack
static size_t yy_buffer_stack_top

Definition at line 295 of file doctokenizer.cpp.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 302 of file doctokenizer.cpp.

#define YY_DECL   int doctokenizerYYlex (void)

Definition at line 79678 of file doctokenizer.cpp.

#define YY_DECL_IS_OURS   1

Definition at line 79674 of file doctokenizer.cpp.

#define yy_delete_buffer   doctokenizerYY_delete_buffer

Definition at line 10 of file doctokenizer.cpp.

#define YY_DO_BEFORE_ACTION
Value:
doctokenizerYYleng = (size_t) (yy_cp - yy_bp); \
*yy_cp = '\0'; \
#define yytext_ptr
static char yy_hold_char
register char * yy_cp
int doctokenizerYYleng
register char * yy_bp
static char * yy_c_buf_p

Definition at line 391 of file doctokenizer.cpp.

#define YY_END_OF_BUFFER   207

Definition at line 399 of file doctokenizer.cpp.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 159 of file doctokenizer.cpp.

#define YY_EXIT_FAILURE   2

Definition at line 82319 of file doctokenizer.cpp.

#define YY_EXTRA_TYPE   void *

Definition at line 79535 of file doctokenizer.cpp.

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 79665 of file doctokenizer.cpp.

#define yy_flex_debug   doctokenizerYY_flex_debug

Definition at line 11 of file doctokenizer.cpp.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file doctokenizer.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file doctokenizer.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file doctokenizer.cpp.

#define yy_flush_buffer   doctokenizerYY_flush_buffer

Definition at line 13 of file doctokenizer.cpp.

#define YY_FLUSH_BUFFER   doctokenizerYY_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 331 of file doctokenizer.cpp.

#define yy_init_buffer   doctokenizerYY_init_buffer

Definition at line 12 of file doctokenizer.cpp.

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

Definition at line 79420 of file doctokenizer.cpp.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file doctokenizer.cpp.

#define YY_LESS_LINENO (   n)
Value:
do { \
int yyl;\
for ( yyl = n; yyl < doctokenizerYYleng; ++yyl )\
if ( doctokenizerYYtext[yyl] == '\n' )\
}while(0)
int doctokenizerYYlineno
std::void_t< T > n
int doctokenizerYYleng
char * doctokenizerYYtext

Definition at line 190 of file doctokenizer.cpp.

#define yy_load_buffer_state   doctokenizerYY_load_buffer_state

Definition at line 14 of file doctokenizer.cpp.

#define YY_MORE_ADJ   0

Definition at line 79108 of file doctokenizer.cpp.

#define yy_new_buffer   doctokenizerYY_create_buffer

Definition at line 341 of file doctokenizer.cpp.

#define YY_NEW_FILE   doctokenizerYYrestart(doctokenizerYYin )

Definition at line 157 of file doctokenizer.cpp.

#define YY_NO_INPUT   1

Definition at line 79149 of file doctokenizer.cpp.

#define YY_NO_UNISTD_H   1

Definition at line 79150 of file doctokenizer.cpp.

#define YY_NULL   0

Definition at line 131 of file doctokenizer.cpp.

#define YY_NUM_RULES   206

Definition at line 398 of file doctokenizer.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 79603 of file doctokenizer.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 79109 of file doctokenizer.cpp.

#define YY_RULE_SETUP
Value:
#define YY_CURRENT_BUFFER_LVALUE
int doctokenizerYYleng
#define YY_USER_ACTION
char * doctokenizerYYtext

Definition at line 79693 of file doctokenizer.cpp.

#define YY_SC_TO_UI (   c)    ((unsigned int) (unsigned char) c)

Definition at line 138 of file doctokenizer.cpp.

#define yy_set_bol (   at_bol)
Value:
{ \
doctokenizerYYensure_buffer_stack (); \
doctokenizerYY_create_buffer(doctokenizerYYin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE
FILE * doctokenizerYYin
if(!(yy_init))
#define YY_BUF_SIZE

Definition at line 353 of file doctokenizer.cpp.

#define yy_set_interactive (   is_interactive)
Value:
{ \
doctokenizerYYensure_buffer_stack (); \
doctokenizerYY_create_buffer(doctokenizerYYin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE
FILE * doctokenizerYYin
if(!(yy_init))
#define YY_BUF_SIZE

Definition at line 343 of file doctokenizer.cpp.

#define YY_SKIP_YYWRAP

Definition at line 368 of file doctokenizer.cpp.

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

Definition at line 150 of file doctokenizer.cpp.

#define YY_START_STACK_INCR   25

Definition at line 79660 of file doctokenizer.cpp.

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

Definition at line 168 of file doctokenizer.cpp.

#define YY_STATE_EOF (   state)    (YY_END_OF_BUFFER + state + 1)

Definition at line 154 of file doctokenizer.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 220 of file doctokenizer.cpp.

#define yy_switch_to_buffer   doctokenizerYY_switch_to_buffer

Definition at line 15 of file doctokenizer.cpp.

#define YY_TRAILING_HEAD_MASK   0x4000

Definition at line 79095 of file doctokenizer.cpp.

#define YY_TRAILING_MASK   0x2000

Definition at line 79094 of file doctokenizer.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 171 of file doctokenizer.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 215 of file doctokenizer.cpp.

#define YY_USER_ACTION

Definition at line 79685 of file doctokenizer.cpp.

Definition at line 24 of file doctokenizer.cpp.

#define yyconst

Definition at line 127 of file doctokenizer.cpp.

#define yyfree   doctokenizerYYfree

Definition at line 26 of file doctokenizer.cpp.

#define yyin   doctokenizerYYin

Definition at line 16 of file doctokenizer.cpp.

#define yyleng   doctokenizerYYleng

Definition at line 17 of file doctokenizer.cpp.

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up doctokenizerYYtext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */ \
} \
while ( 0 )
#define YY_RESTORE_YY_MORE_OFFSET
static char yy_hold_char
std::void_t< T > n
register char * yy_cp
#define YY_DO_BEFORE_ACTION
register char * yy_bp
while(1)
#define YY_MORE_ADJ
static char * yy_c_buf_p

Definition at line 82331 of file doctokenizer.cpp.

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up doctokenizerYYtext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
(yy_c_buf_p) = doctokenizerYYtext + yyless_macro_arg; \
*(yy_c_buf_p) = '\0'; \
doctokenizerYYleng = yyless_macro_arg; \
} \
while ( 0 )
static char yy_hold_char
std::void_t< T > n
int doctokenizerYYleng
while(1)
static char * yy_c_buf_p
char * doctokenizerYYtext

Definition at line 82331 of file doctokenizer.cpp.

#define yylex   doctokenizerYYlex

Definition at line 18 of file doctokenizer.cpp.

#define yylineno   doctokenizerYYlineno

Definition at line 19 of file doctokenizer.cpp.

#define yymore ( )    yymore_used_but_not_detected

Definition at line 79107 of file doctokenizer.cpp.

#define yyout   doctokenizerYYout

Definition at line 20 of file doctokenizer.cpp.

#define yyrealloc   doctokenizerYYrealloc

Definition at line 25 of file doctokenizer.cpp.

#define yyrestart   doctokenizerYYrestart

Definition at line 21 of file doctokenizer.cpp.

#define YYSTATE   YY_START

Definition at line 151 of file doctokenizer.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 82532 of file doctokenizer.cpp.

#define yyterminate ( )    return YY_NULL

Definition at line 79655 of file doctokenizer.cpp.

#define yytext   doctokenizerYYtext

Definition at line 22 of file doctokenizer.cpp.

#define yytext_ptr   doctokenizerYYtext

Definition at line 381 of file doctokenizer.cpp.

#define yywrap   doctokenizerYYwrap

Definition at line 23 of file doctokenizer.cpp.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 71 of file doctokenizer.cpp.

typedef int flex_int32_t

Definition at line 72 of file doctokenizer.cpp.

typedef signed char flex_int8_t

Definition at line 70 of file doctokenizer.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file doctokenizer.cpp.

typedef unsigned int flex_uint32_t

Definition at line 75 of file doctokenizer.cpp.

typedef unsigned char flex_uint8_t

Definition at line 73 of file doctokenizer.cpp.

Definition at line 172 of file doctokenizer.cpp.

typedef unsigned char YY_CHAR

Definition at line 370 of file doctokenizer.cpp.

typedef size_t yy_size_t

Definition at line 216 of file doctokenizer.cpp.

typedef int yy_state_type

Definition at line 374 of file doctokenizer.cpp.

Function Documentation

static int computeIndent ( const char *  str,
int  length 
)
static

Definition at line 79236 of file doctokenizer.cpp.

79237 {
79238  int i;
79239  int indent=0;
79240  static int tabSize=Config_getInt("TAB_SIZE");
79241  for (i=0;i<length;i++)
79242  {
79243  if (str[i]=='\t')
79244  {
79245  indent+=tabSize - (indent%tabSize);
79246  }
79247  else if (str[i]=='\n')
79248  {
79249  indent=0;
79250  }
79251  else
79252  {
79253  indent++;
79254  }
79255  }
79256  return indent;
79257 }
#define Config_getInt(val)
Definition: config.cpp:661
static QCString str
YY_BUFFER_STATE doctokenizerYY_create_buffer ( FILE *  file,
int  size 
)

Allocate and initialize an input buffer state.

Parameters
fileA readable stream.
sizeThe character buffer size in bytes. When in doubt, use YY_BUF_SIZE.
Returns
the allocated buffer state.

Definition at line 82036 of file doctokenizer.cpp.

82037 {
82039 
82040  b = (YY_BUFFER_STATE) doctokenizerYYalloc(sizeof( struct yy_buffer_state ) );
82041  if ( ! b )
82042  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYY_create_buffer()" );
82043 
82044  b->yy_buf_size = size;
82045 
82046  /* yy_ch_buf has to be 2 characters longer than the size given because
82047  * we need to put in 2 end-of-buffer characters.
82048  */
82049  b->yy_ch_buf = (char *) doctokenizerYYalloc(b->yy_buf_size + 2 );
82050  if ( ! b->yy_ch_buf )
82051  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYY_create_buffer()" );
82052 
82053  b->yy_is_our_buffer = 1;
82054 
82056 
82057  return b;
82058 }
#define YY_FATAL_ERROR(msg)
yy_size_t yy_buf_size
Definition: code.cpp:218
void * doctokenizerYYalloc(yy_size_t)
decltype(auto) constexpr size(T &&obj)
ADL-aware version of std::size.
Definition: StdUtils.h:92
char * yy_ch_buf
Definition: code.cpp:212
struct yy_buffer_state * YY_BUFFER_STATE
int yy_is_our_buffer
Definition: code.cpp:229
static void doctokenizerYY_init_buffer(YY_BUFFER_STATE b, FILE *file)
static bool * b
Definition: config.cpp:1043
void doctokenizerYY_delete_buffer ( YY_BUFFER_STATE  b)

Destroy the buffer.

Parameters
ba buffer created with doctokenizerYY_create_buffer()

Definition at line 82064 of file doctokenizer.cpp.

82065 {
82066 
82067  if ( ! b )
82068  return;
82069 
82070  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
82072 
82073  if ( b->yy_is_our_buffer )
82074  doctokenizerYYfree((void *) b->yy_ch_buf );
82075 
82076  doctokenizerYYfree((void *) b );
82077 }
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE
char * yy_ch_buf
Definition: code.cpp:212
struct yy_buffer_state * YY_BUFFER_STATE
int yy_is_our_buffer
Definition: code.cpp:229
void doctokenizerYYfree(void *)
void doctokenizerYY_flush_buffer ( YY_BUFFER_STATE  b)

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

Parameters
bthe buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 82111 of file doctokenizer.cpp.

82112 {
82113  if ( ! b )
82114  return;
82115 
82116  b->yy_n_chars = 0;
82117 
82118  /* We always need two end-of-buffer characters. The first causes
82119  * a transition to the end-of-buffer state. The second causes
82120  * a jam in that state.
82121  */
82124 
82125  b->yy_buf_pos = &b->yy_ch_buf[0];
82126 
82127  b->yy_at_bol = 1;
82129 
82130  if ( b == YY_CURRENT_BUFFER )
82132 }
char * yy_buf_pos
Definition: code.cpp:213
#define YY_CURRENT_BUFFER
int yy_n_chars
Definition: code.cpp:223
char * yy_ch_buf
Definition: code.cpp:212
#define YY_BUFFER_NEW
#define YY_END_OF_BUFFER_CHAR
static void doctokenizerYY_load_buffer_state(void)
int yy_buffer_status
Definition: code.cpp:252
static void doctokenizerYY_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)
static

Definition at line 82083 of file doctokenizer.cpp.

82085 {
82086  int oerrno = errno;
82087 
82089 
82090  b->yy_input_file = file;
82091  b->yy_fill_buffer = 1;
82092 
82093  /* If b is the current buffer, then doctokenizerYY_init_buffer was _probably_
82094  * called from doctokenizerYYrestart() or through yy_get_next_buffer.
82095  * In that case, we don't want to reset the lineno or column.
82096  */
82097  if (b != YY_CURRENT_BUFFER){
82098  b->yy_bs_lineno = 1;
82099  b->yy_bs_column = 0;
82100  }
82101 
82102  b->yy_is_interactive = 0;
82103 
82104  errno = oerrno;
82105 }
FILE * yy_input_file
Definition: code.cpp:210
#define YY_CURRENT_BUFFER
void doctokenizerYY_flush_buffer(YY_BUFFER_STATE b)
int yy_fill_buffer
Definition: code.cpp:250
int yy_bs_lineno
Definition: code.cpp:244
int errno
Contains the last error code.
Definition: structcmd.h:53
int yy_bs_column
Definition: code.cpp:245
int yy_is_interactive
Definition: code.cpp:236
static void doctokenizerYY_load_buffer_state ( void  )
static

Definition at line 82022 of file doctokenizer.cpp.

82023 {
82024  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
82025  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
82026  doctokenizerYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
82027  (yy_hold_char) = *(yy_c_buf_p);
82028 }
#define yytext_ptr
#define YY_CURRENT_BUFFER_LVALUE
FILE * doctokenizerYYin
static int yy_n_chars
static char yy_hold_char
static char * yy_c_buf_p
YY_BUFFER_STATE doctokenizerYY_scan_buffer ( char *  base,
yy_size_t  size 
)

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

Parameters
basethe character buffer
sizethe size in bytes of the character buffer
Returns
the newly allocated buffer state object.

Definition at line 82238 of file doctokenizer.cpp.

82239 {
82241 
82242  if ( size < 2 ||
82245  /* They forgot to leave room for the EOB's. */
82246  return 0;
82247 
82248  b = (YY_BUFFER_STATE) doctokenizerYYalloc(sizeof( struct yy_buffer_state ) );
82249  if ( ! b )
82250  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYY_scan_buffer()" );
82251 
82252  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
82253  b->yy_buf_pos = b->yy_ch_buf = base;
82254  b->yy_is_our_buffer = 0;
82255  b->yy_input_file = 0;
82256  b->yy_n_chars = b->yy_buf_size;
82257  b->yy_is_interactive = 0;
82258  b->yy_at_bol = 1;
82259  b->yy_fill_buffer = 0;
82261 
82263 
82264  return b;
82265 }
char * yy_buf_pos
Definition: code.cpp:213
FILE * yy_input_file
Definition: code.cpp:210
int yy_n_chars
Definition: code.cpp:223
int yy_fill_buffer
Definition: code.cpp:250
#define YY_FATAL_ERROR(msg)
yy_size_t yy_buf_size
Definition: code.cpp:218
void * doctokenizerYYalloc(yy_size_t)
decltype(auto) constexpr size(T &&obj)
ADL-aware version of std::size.
Definition: StdUtils.h:92
char * yy_ch_buf
Definition: code.cpp:212
struct yy_buffer_state * YY_BUFFER_STATE
int yy_is_our_buffer
Definition: code.cpp:229
#define YY_BUFFER_NEW
#define YY_END_OF_BUFFER_CHAR
void doctokenizerYY_switch_to_buffer(YY_BUFFER_STATE new_buffer)
static bool * b
Definition: config.cpp:1043
int yy_is_interactive
Definition: code.cpp:236
int yy_buffer_status
Definition: code.cpp:252
YY_BUFFER_STATE doctokenizerYY_scan_bytes ( yyconst char *  yybytes,
int  _yybytes_len 
)

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

Parameters
bytesthe byte buffer to scan
lenthe number of bytes in the buffer pointed to by bytes.
Returns
the newly allocated buffer state object.

Definition at line 82288 of file doctokenizer.cpp.

82289 {
82291  char *buf;
82292  yy_size_t n;
82293  int i;
82294 
82295  /* Get memory for full buffer, including space for trailing EOB's. */
82296  n = _yybytes_len + 2;
82297  buf = (char *) doctokenizerYYalloc(n );
82298  if ( ! buf )
82299  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYY_scan_bytes()" );
82300 
82301  for ( i = 0; i < _yybytes_len; ++i )
82302  buf[i] = yybytes[i];
82303 
82304  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
82305 
82306  b = doctokenizerYY_scan_buffer(buf,n );
82307  if ( ! b )
82308  YY_FATAL_ERROR( "bad buffer in doctokenizerYY_scan_bytes()" );
82309 
82310  /* It's okay to grow etc. this buffer, and we should throw it
82311  * away when we're done.
82312  */
82313  b->yy_is_our_buffer = 1;
82314 
82315  return b;
82316 }
#define YY_FATAL_ERROR(msg)
void * doctokenizerYYalloc(yy_size_t)
std::void_t< T > n
YY_BUFFER_STATE doctokenizerYY_scan_buffer(char *base, yy_size_t size)
int yy_is_our_buffer
Definition: code.cpp:229
#define YY_END_OF_BUFFER_CHAR
static bool * b
Definition: config.cpp:1043
size_t yy_size_t
Definition: code.cpp:203
YY_BUFFER_STATE doctokenizerYY_scan_string ( yyconst char *  yystr)

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

Parameters
yystra 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 doctokenizerYY_scan_bytes() instead.

Definition at line 82275 of file doctokenizer.cpp.

82276 {
82277 
82278  return doctokenizerYY_scan_bytes(yystr,strlen(yystr) );
82279 }
YY_BUFFER_STATE doctokenizerYY_scan_bytes(yyconst char *bytes, int len)
void doctokenizerYY_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Switch to a different input buffer.

Parameters
new_bufferThe new input buffer.

Definition at line 81991 of file doctokenizer.cpp.

81992 {
81993 
81994  /* TODO. We should be able to replace this entire function body
81995  * with
81996  * doctokenizerYYpop_buffer_state();
81997  * doctokenizerYYpush_buffer_state(new_buffer);
81998  */
82000  if ( YY_CURRENT_BUFFER == new_buffer )
82001  return;
82002 
82003  if ( YY_CURRENT_BUFFER )
82004  {
82005  /* Flush out information for old buffer. */
82006  *(yy_c_buf_p) = (yy_hold_char);
82007  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
82008  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
82009  }
82010 
82011  YY_CURRENT_BUFFER_LVALUE = new_buffer;
82013 
82014  /* We don't actually know whether we did this switch during
82015  * EOF (doctokenizerYYwrap()) processing, but the only time this flag
82016  * is looked at is after doctokenizerYYwrap() is called, so it's safe
82017  * to go ahead and always set it.
82018  */
82020 }
#define YY_CURRENT_BUFFER
static int yy_did_buffer_switch_on_eof
#define YY_CURRENT_BUFFER_LVALUE
static void doctokenizerYYensure_buffer_stack(void)
static int yy_n_chars
static char yy_hold_char
static void doctokenizerYY_load_buffer_state(void)
static char * yy_c_buf_p
void * doctokenizerYYalloc ( yy_size_t  size)

Definition at line 82510 of file doctokenizer.cpp.

82511 {
82512  return (void *) malloc( size );
82513 }
decltype(auto) constexpr size(T &&obj)
ADL-aware version of std::size.
Definition: StdUtils.h:92
void doctokenizerYYcleanup ( )

Definition at line 82729 of file doctokenizer.cpp.

82730 {
82732 }
#define YY_CURRENT_BUFFER
void doctokenizerYY_delete_buffer(YY_BUFFER_STATE b)
void doctokenizerYYendAutoList ( )

Definition at line 82756 of file doctokenizer.cpp.

82757 {
82758  g_autoListLevel--;
82759 }
static int g_autoListLevel
static void doctokenizerYYensure_buffer_stack ( void  )
static

Definition at line 82189 of file doctokenizer.cpp.

82190 {
82191  int num_to_alloc;
82192 
82193  if (!(yy_buffer_stack)) {
82194 
82195  /* First allocation is just for 2 elements, since we don't know if this
82196  * scanner will even need a stack. We use 2 instead of 1 to avoid an
82197  * immediate realloc on the next call.
82198  */
82199  num_to_alloc = 1;
82201  (num_to_alloc * sizeof(struct yy_buffer_state*)
82202  );
82203  if ( ! (yy_buffer_stack) )
82204  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYYensure_buffer_stack()" );
82205 
82206  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
82207 
82208  (yy_buffer_stack_max) = num_to_alloc;
82209  (yy_buffer_stack_top) = 0;
82210  return;
82211  }
82212 
82213  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
82214 
82215  /* Increase the buffer to prepare for a possible push. */
82216  int grow_size = 8 /* arbitrary grow size */;
82217 
82218  num_to_alloc = (yy_buffer_stack_max) + grow_size;
82220  ((yy_buffer_stack),
82221  num_to_alloc * sizeof(struct yy_buffer_state*)
82222  );
82223  if ( ! (yy_buffer_stack) )
82224  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYYensure_buffer_stack()" );
82225 
82226  /* zero only the new slots.*/
82227  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
82228  (yy_buffer_stack_max) = num_to_alloc;
82229  }
82230 }
#define YY_FATAL_ERROR(msg)
void * doctokenizerYYrealloc(void *, yy_size_t)
void * doctokenizerYYalloc(yy_size_t)
static YY_BUFFER_STATE * yy_buffer_stack
static size_t yy_buffer_stack_top
static size_t yy_buffer_stack_max
void doctokenizerYYFindSections ( const char *  input,
Definition d,
MemberGroup mg,
const char *  fileName 
)

Definition at line 82540 of file doctokenizer.cpp.

82542 {
82543  if (input==0) return;
82545  g_inputString = input;
82546  //printf("parsing --->`%s'<---\n",input);
82547  g_inputPos = 0;
82548  g_definition = d;
82549  g_memberGroup = mg;
82550  g_fileName = fileName;
82551  BEGIN(St_Sections);
82555 }
int doctokenizerYY_flex_debug
static MemberGroup * g_memberGroup
void printlex(int dbg, bool enter, const char *lexName, const char *fileName)
Definition: message.cpp:242
int doctokenizerYYlineno
const bool FALSE
Definition: qglobal.h:370
static const char * g_inputString
static int g_inputPos
static constexpr double mg
Definition: Units.h:145
#define St_Sections
int doctokenizerYYlex(void)
static QCString g_fileName
static int input(void)
Definition: code.cpp:15695
fileName
Definition: dumpTree.py:9
static Definition * g_definition
#define BEGIN
const bool TRUE
Definition: qglobal.h:371
void doctokenizerYYfree ( void *  ptr)

Definition at line 82527 of file doctokenizer.cpp.

82528 {
82529  free( (char *) ptr ); /* see doctokenizerYYrealloc() for (char *) cast */
82530 }
int doctokenizerYYget_debug ( void  )

Definition at line 82415 of file doctokenizer.cpp.

82416 {
82418 }
int doctokenizerYY_flex_debug
YY_EXTRA_TYPE doctokenizerYYget_extra ( void  )
FILE * doctokenizerYYget_in ( void  )

Get the input stream.

Definition at line 82359 of file doctokenizer.cpp.

82360 {
82361  return doctokenizerYYin;
82362 }
FILE * doctokenizerYYin
int doctokenizerYYget_leng ( void  )

Get the length of the current token.

Definition at line 82375 of file doctokenizer.cpp.

82376 {
82377  return doctokenizerYYleng;
82378 }
int doctokenizerYYleng
int doctokenizerYYget_lineno ( void  )

Get the current line number.

Definition at line 82350 of file doctokenizer.cpp.

82351 {
82352 
82353  return doctokenizerYYlineno;
82354 }
int doctokenizerYYlineno
FILE * doctokenizerYYget_out ( void  )

Get the output stream.

Definition at line 82367 of file doctokenizer.cpp.

82368 {
82369  return doctokenizerYYout;
82370 }
FILE * doctokenizerYYout
char * doctokenizerYYget_text ( void  )

Get the current token.

Definition at line 82384 of file doctokenizer.cpp.

82385 {
82386  return doctokenizerYYtext;
82387 }
char * doctokenizerYYtext
void doctokenizerYYinit ( const char *  input,
const char *  fileName 
)

Definition at line 82557 of file doctokenizer.cpp.

82558 {
82559  g_autoListLevel = 0;
82560  g_inputString = input;
82561  g_inputPos = 0;
82562  g_fileName = fileName;
82563  g_insidePre = FALSE;
82564  BEGIN(St_Para);
82565 }
#define St_Para
const bool FALSE
Definition: qglobal.h:370
static const char * g_inputString
static int g_inputPos
static QCString g_fileName
static int input(void)
Definition: code.cpp:15695
fileName
Definition: dumpTree.py:9
static bool g_insidePre
#define BEGIN
static int g_autoListLevel
int doctokenizerYYlex ( void  )
int doctokenizerYYlex_destroy ( void  )

Definition at line 82462 of file doctokenizer.cpp.

82463 {
82464 
82465  /* Pop the buffer stack, destroying each element. */
82466  while(YY_CURRENT_BUFFER){
82468  YY_CURRENT_BUFFER_LVALUE = NULL;
82470  }
82471 
82472  /* Destroy the stack itself. */
82474  (yy_buffer_stack) = NULL;
82475 
82477  (yy_state_buf) = NULL;
82478 
82479  /* Reset the globals. This is important in a non-reentrant scanner so the next time
82480  * doctokenizerYYlex() is called, initialization will occur. */
82481  yy_init_globals( );
82482 
82483  return 0;
82484 }
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE
void doctokenizerYYpop_buffer_state(void)
void doctokenizerYY_delete_buffer(YY_BUFFER_STATE b)
static YY_BUFFER_STATE * yy_buffer_stack
void doctokenizerYYfree(void *)
static yy_state_type * yy_state_buf
static int yy_init_globals(void)
void doctokenizerYYpop_buffer_state ( void  )

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

Definition at line 82170 of file doctokenizer.cpp.

82171 {
82172  if (!YY_CURRENT_BUFFER)
82173  return;
82174 
82176  YY_CURRENT_BUFFER_LVALUE = NULL;
82177  if ((yy_buffer_stack_top) > 0)
82178  --(yy_buffer_stack_top);
82179 
82180  if (YY_CURRENT_BUFFER) {
82183  }
82184 }
#define YY_CURRENT_BUFFER
static int yy_did_buffer_switch_on_eof
#define YY_CURRENT_BUFFER_LVALUE
void doctokenizerYY_delete_buffer(YY_BUFFER_STATE b)
static size_t yy_buffer_stack_top
static void doctokenizerYY_load_buffer_state(void)
bool doctokenizerYYpopContext ( )

Definition at line 79199 of file doctokenizer.cpp.

79200 {
79201  if (g_lexerStack.isEmpty()) return FALSE;
79202  DocLexerContext *ctx = g_lexerStack.pop();
79204  g_inputPos = ctx->inputPos;
79205  g_inputString = ctx->inputString;
79208  BEGIN(ctx->rule);
79209  delete ctx;
79210  return TRUE;
79211 }
#define YY_CURRENT_BUFFER
static QStack< DocLexerContext > g_lexerStack
const char * inputString
const bool FALSE
Definition: qglobal.h:370
static const char * g_inputString
static int g_inputPos
void doctokenizerYY_delete_buffer(YY_BUFFER_STATE b)
YY_BUFFER_STATE state
#define BEGIN
void doctokenizerYY_switch_to_buffer(YY_BUFFER_STATE new_buffer)
static int g_autoListLevel
const bool TRUE
Definition: qglobal.h:371
void doctokenizerYYpush_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_bufferThe new state.

Definition at line 82140 of file doctokenizer.cpp.

82141 {
82142  if (new_buffer == NULL)
82143  return;
82144 
82146 
82147  /* This block is copied from doctokenizerYY_switch_to_buffer. */
82148  if ( YY_CURRENT_BUFFER )
82149  {
82150  /* Flush out information for old buffer. */
82151  *(yy_c_buf_p) = (yy_hold_char);
82152  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
82153  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
82154  }
82155 
82156  /* Only push if top exists. Otherwise, replace top. */
82157  if (YY_CURRENT_BUFFER)
82158  (yy_buffer_stack_top)++;
82159  YY_CURRENT_BUFFER_LVALUE = new_buffer;
82160 
82161  /* copied from doctokenizerYY_switch_to_buffer. */
82164 }
#define YY_CURRENT_BUFFER
static int yy_did_buffer_switch_on_eof
#define YY_CURRENT_BUFFER_LVALUE
static void doctokenizerYYensure_buffer_stack(void)
static int yy_n_chars
static char yy_hold_char
static size_t yy_buffer_stack_top
static void doctokenizerYY_load_buffer_state(void)
static char * yy_c_buf_p
void doctokenizerYYpushBackHtmlTag ( const char *  tag)

Definition at line 82739 of file doctokenizer.cpp.

82740 {
82741  QCString tagName = tag;
82742  int i,l = tagName.length();
82743  unput('>');
82744  for (i=l-1;i>=0;i--)
82745  {
82746  unput(tag[i]);
82747  }
82748  unput('<');
82749 }
uint length() const
Definition: qcstring.h:195
#define unput(c)
static QStrList * l
Definition: config.cpp:1044
void doctokenizerYYpushContext ( )

Definition at line 79186 of file doctokenizer.cpp.

79187 {
79188  DocLexerContext *ctx = new DocLexerContext;
79189  ctx->rule = YY_START;
79191  ctx->token = g_token;
79192  ctx->inputPos = g_inputPos;
79193  ctx->inputString = g_inputString;
79194  ctx->state = YY_CURRENT_BUFFER;
79195  g_lexerStack.push(ctx);
79197 }
#define YY_CURRENT_BUFFER
static QStack< DocLexerContext > g_lexerStack
YY_BUFFER_STATE doctokenizerYY_create_buffer(FILE *file, int size)
const char * inputString
static const char * g_inputString
static int g_inputPos
FILE * doctokenizerYYin
TokenInfo * g_token
#define YY_BUF_SIZE
YY_BUFFER_STATE state
void doctokenizerYY_switch_to_buffer(YY_BUFFER_STATE new_buffer)
static int g_autoListLevel
#define YY_START
void * doctokenizerYYrealloc ( void *  ptr,
yy_size_t  size 
)

Definition at line 82515 of file doctokenizer.cpp.

82516 {
82517  /* The cast to (char *) in the following accommodates both
82518  * implementations that use char* generic pointers, and those
82519  * that use void* generic pointers. It works with the latter
82520  * because both ANSI C and C++ allow castless assignment from
82521  * any pointer type to void*, and deal with argument conversions
82522  * as though doing an assignment.
82523  */
82524  return (void *) realloc( (char *) ptr, size );
82525 }
decltype(auto) constexpr size(T &&obj)
ADL-aware version of std::size.
Definition: StdUtils.h:92
void doctokenizerYYrestart ( FILE *  input_file)

Immediately switch to a different input stream.

Parameters
input_fileA readable stream.
Note
This function does not reset the start condition to INITIAL .

Definition at line 81974 of file doctokenizer.cpp.

81975 {
81976 
81977  if ( ! YY_CURRENT_BUFFER ){
81981  }
81982 
81985 }
#define YY_CURRENT_BUFFER
YY_BUFFER_STATE doctokenizerYY_create_buffer(FILE *file, int size)
#define YY_CURRENT_BUFFER_LVALUE
FILE * doctokenizerYYin
static void doctokenizerYYensure_buffer_stack(void)
#define YY_BUF_SIZE
static void doctokenizerYY_init_buffer(YY_BUFFER_STATE b, FILE *file)
static void doctokenizerYY_load_buffer_state(void)
void doctokenizerYYset_debug ( int  debug_flag)

Definition at line 82420 of file doctokenizer.cpp.

82421 {
82422  doctokenizerYY_flex_debug = bdebug ;
82423 }
int doctokenizerYY_flex_debug
void doctokenizerYYset_extra ( YY_EXTRA_TYPE  user_defined)
void doctokenizerYYset_in ( FILE *  in_str)

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

Parameters
in_strA readable stream.
See also
doctokenizerYY_switch_to_buffer

Definition at line 82405 of file doctokenizer.cpp.

82406 {
82407  doctokenizerYYin = in_str ;
82408 }
FILE * doctokenizerYYin
void doctokenizerYYset_lineno ( int  line_number)

Set the current line number.

Parameters
line_number

Definition at line 82393 of file doctokenizer.cpp.

82394 {
82395 
82396  doctokenizerYYlineno = line_number;
82397 }
int doctokenizerYYlineno
void doctokenizerYYset_out ( FILE *  out_str)

Definition at line 82410 of file doctokenizer.cpp.

82411 {
82412  doctokenizerYYout = out_str ;
82413 }
FILE * doctokenizerYYout
void doctokenizerYYsetInsidePre ( bool  b)

Definition at line 82734 of file doctokenizer.cpp.

82735 {
82736  g_insidePre = b;
82737 }
static bool g_insidePre
static bool * b
Definition: config.cpp:1043
void doctokenizerYYsetStateAnchor ( )

Definition at line 82714 of file doctokenizer.cpp.

82715 {
82716  BEGIN(St_Anchor);
82717 }
#define St_Anchor
#define BEGIN
void doctokenizerYYsetStateCite ( )

Definition at line 82689 of file doctokenizer.cpp.

82690 {
82691  BEGIN(St_Cite);
82692 }
#define BEGIN
#define St_Cite
void doctokenizerYYsetStateCode ( )

Definition at line 82582 of file doctokenizer.cpp.

82583 {
82584  g_token->verb="";
82585  g_token->name="";
82586  BEGIN(St_CodeOpt);
82587 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
QCString name
Definition: doctokenizer.h:77
#define St_CodeOpt
void doctokenizerYYsetStateDbOnly ( )

Definition at line 82621 of file doctokenizer.cpp.

82622 {
82623  g_token->verb="";
82624  BEGIN(St_DbOnly);
82625 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
#define St_DbOnly
void doctokenizerYYsetStateDot ( )

Definition at line 82639 of file doctokenizer.cpp.

82640 {
82641  g_token->verb="";
82642  BEGIN(St_Dot);
82643 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
#define St_Dot
void doctokenizerYYsetStateFile ( )

Definition at line 82674 of file doctokenizer.cpp.

82675 {
82676  BEGIN(St_File);
82677 }
#define St_File
#define BEGIN
void doctokenizerYYsetStateHtmlOnly ( )

Definition at line 82596 of file doctokenizer.cpp.

82597 {
82598  g_token->verb="";
82599  g_token->name="";
82601 }
#define St_HtmlOnlyOption
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
QCString name
Definition: doctokenizer.h:77
void doctokenizerYYsetStateInternalRef ( )

Definition at line 82699 of file doctokenizer.cpp.

82700 {
82701  BEGIN(St_IntRef);
82702 }
#define St_IntRef
#define BEGIN
void doctokenizerYYsetStateLatexOnly ( )

Definition at line 82627 of file doctokenizer.cpp.

82628 {
82629  g_token->verb="";
82631 }
TokenInfo * g_token
#define St_LatexOnly
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
void doctokenizerYYsetStateLink ( )

Definition at line 82684 of file doctokenizer.cpp.

82685 {
82686  BEGIN(St_Link);
82687 }
#define BEGIN
#define St_Link
void doctokenizerYYsetStateManOnly ( )

Definition at line 82603 of file doctokenizer.cpp.

82604 {
82605  g_token->verb="";
82606  BEGIN(St_ManOnly);
82607 }
#define St_ManOnly
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
void doctokenizerYYsetStateMsc ( )

Definition at line 82645 of file doctokenizer.cpp.

82646 {
82647  g_token->verb="";
82648  BEGIN(St_Msc);
82649 }
TokenInfo * g_token
#define St_Msc
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
void doctokenizerYYsetStatePara ( )

Definition at line 82567 of file doctokenizer.cpp.

82568 {
82569  BEGIN(St_Para);
82570 }
#define St_Para
#define BEGIN
void doctokenizerYYsetStateParam ( )

Definition at line 82664 of file doctokenizer.cpp.

82665 {
82666  BEGIN(St_Param);
82667 }
#define BEGIN
#define St_Param
void doctokenizerYYsetStatePattern ( )

Definition at line 82679 of file doctokenizer.cpp.

82680 {
82681  BEGIN(St_Pattern);
82682 }
#define St_Pattern
#define BEGIN
void doctokenizerYYsetStatePlantUML ( )

Definition at line 82658 of file doctokenizer.cpp.

82659 {
82660  g_token->verb="";
82661  BEGIN(St_PlantUML);
82662 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
#define St_PlantUML
void doctokenizerYYsetStatePlantUMLOpt ( )

Definition at line 82651 of file doctokenizer.cpp.

82652 {
82653  g_token->verb="";
82654  g_token->sectionId="";
82656 }
QCString sectionId
Definition: doctokenizer.h:89
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
#define St_PlantUMLOpt
void doctokenizerYYsetStateRef ( )

Definition at line 82694 of file doctokenizer.cpp.

82695 {
82696  BEGIN(St_Ref);
82697 }
#define St_Ref
#define BEGIN
void doctokenizerYYsetStateRtfOnly ( )

Definition at line 82609 of file doctokenizer.cpp.

82610 {
82611  g_token->verb="";
82612  BEGIN(St_RtfOnly);
82613 }
TokenInfo * g_token
#define St_RtfOnly
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
void doctokenizerYYsetStateSetScope ( )

Definition at line 82724 of file doctokenizer.cpp.

82725 {
82726  BEGIN(St_SetScope);
82727 }
#define St_SetScope
#define BEGIN
void doctokenizerYYsetStateSkipTitle ( )

Definition at line 82709 of file doctokenizer.cpp.

82710 {
82712 }
#define St_SkipTitle
#define BEGIN
void doctokenizerYYsetStateSnippet ( )

Definition at line 82719 of file doctokenizer.cpp.

82720 {
82721  BEGIN(St_Snippet);
82722 }
#define St_Snippet
#define BEGIN
void doctokenizerYYsetStateText ( )

Definition at line 82704 of file doctokenizer.cpp.

82705 {
82706  BEGIN(St_Text);
82707 }
#define St_Text
#define BEGIN
void doctokenizerYYsetStateTitle ( )

Definition at line 82572 of file doctokenizer.cpp.

82573 {
82574  BEGIN(St_Title);
82575 }
#define BEGIN
#define St_Title
void doctokenizerYYsetStateTitleAttrValue ( )

Definition at line 82577 of file doctokenizer.cpp.

82578 {
82579  BEGIN(St_TitleV);
82580 }
#define BEGIN
#define St_TitleV
void doctokenizerYYsetStateVerbatim ( )

Definition at line 82633 of file doctokenizer.cpp.

82634 {
82635  g_token->verb="";
82636  BEGIN(St_Verbatim);
82637 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
#define St_Verbatim
void doctokenizerYYsetStateXmlCode ( )

Definition at line 82589 of file doctokenizer.cpp.

82590 {
82591  g_token->verb="";
82592  g_token->name="";
82593  BEGIN(St_XmlCode);
82594 }
TokenInfo * g_token
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
QCString name
Definition: doctokenizer.h:77
#define St_XmlCode
void doctokenizerYYsetStateXmlOnly ( )

Definition at line 82615 of file doctokenizer.cpp.

82616 {
82617  g_token->verb="";
82618  BEGIN(St_XmlOnly);
82619 }
TokenInfo * g_token
#define St_XmlOnly
#define BEGIN
QCString verb
Definition: doctokenizer.h:96
void doctokenizerYYsetStateXRefItem ( )

Definition at line 82669 of file doctokenizer.cpp.

82670 {
82671  BEGIN(St_XRefItem);
82672 }
#define St_XRefItem
#define BEGIN
void doctokenizerYYstartAutoList ( )

Definition at line 82751 of file doctokenizer.cpp.

82752 {
82753  g_autoListLevel++;
82754 }
static int g_autoListLevel
static void handleHtmlTag ( )
static

Definition at line 79285 of file doctokenizer.cpp.

79286 {
79287  QCString tagText=doctokenizerYYtext;
79288  g_token->attribs.clear();
79289  g_token->endTag = FALSE;
79290  g_token->emptyTag = FALSE;
79291 
79292  // Check for end tag
79293  int startNamePos=1;
79294  if (tagText.at(1)=='/')
79295  {
79296  g_token->endTag = TRUE;
79297  startNamePos++;
79298  }
79299 
79300  // Parse the name portion
79301  int i = startNamePos;
79302  for (i=startNamePos; i < (int)doctokenizerYYleng; i++)
79303  {
79304  // Check for valid HTML/XML name chars (including namespaces)
79305  char c = tagText.at(i);
79306  if (!(isalnum(c) || c=='-' || c=='_' || c==':')) break;
79307  }
79308  g_token->name = tagText.mid(startNamePos,i-startNamePos);
79309 
79310  // Parse the attributes. Each attribute is a name, value pair
79311  // The result is stored in g_token->attribs.
79312  int startName,endName,startAttrib,endAttrib;
79313  while (i<(int)doctokenizerYYleng)
79314  {
79315  char c=tagText.at(i);
79316  // skip spaces
79317  while (i<(int)doctokenizerYYleng && isspace(c)) { c=tagText.at(++i); }
79318  // check for end of the tag
79319  if (c == '>') break;
79320  // Check for XML style "empty" tag.
79321  if (c == '/')
79322  {
79323  g_token->emptyTag = TRUE;
79324  break;
79325  }
79326  startName=i;
79327  // search for end of name
79328  while (i<(int)doctokenizerYYleng && !isspace(c) && c!='=') { c=tagText.at(++i); }
79329  endName=i;
79330  HtmlAttrib opt;
79331  opt.name = tagText.mid(startName,endName-startName).lower();
79332  // skip spaces
79333  while (i<(int)doctokenizerYYleng && isspace(c)) { c=tagText.at(++i); }
79334  if (tagText.at(i)=='=') // option has value
79335  {
79336  c=tagText.at(++i);
79337  // skip spaces
79338  while (i<(int)doctokenizerYYleng && isspace(c)) { c=tagText.at(++i); }
79339  if (tagText.at(i)=='\'') // option '...'
79340  {
79341  c=tagText.at(++i);
79342  startAttrib=i;
79343 
79344  // search for matching quote
79345  while (i<(int)doctokenizerYYleng && c!='\'') { c=tagText.at(++i); }
79346  endAttrib=i;
79347  if (i<(int)doctokenizerYYleng) c=tagText.at(++i);
79348  }
79349  else if (tagText.at(i)=='"') // option "..."
79350  {
79351  c=tagText.at(++i);
79352  startAttrib=i;
79353  // search for matching quote
79354  while (i<(int)doctokenizerYYleng && c!='"') { c=tagText.at(++i); }
79355  endAttrib=i;
79356  if (i<(int)doctokenizerYYleng) c=tagText.at(++i);
79357  }
79358  else // value without any quotes
79359  {
79360  startAttrib=i;
79361  // search for separator or end symbol
79362  while (i<(int)doctokenizerYYleng && !isspace(c) && c!='>') { c=tagText.at(++i); }
79363  endAttrib=i;
79364  if (i<(int)doctokenizerYYleng) c=tagText.at(++i);
79365  }
79366  opt.value = tagText.mid(startAttrib,endAttrib-startAttrib);
79367  }
79368  else // start next option
79369  {
79370  }
79371  //printf("=====> Adding option name=<%s> value=<%s>\n",
79372  // opt.name.data(),opt.value.data());
79373  g_token->attribs.append(&opt);
79374  }
79375 }
void append(const type *d)
Definition: qlist.h:73
char & at(uint i) const
Definition: qcstring.h:326
opt
Definition: train.py:196
const bool FALSE
Definition: qglobal.h:370
bool emptyTag
Definition: doctokenizer.h:104
TokenInfo * g_token
QCString value
Definition: htmlattrib.h:25
void clear()
Definition: qlist.h:82
HtmlAttribList attribs
Definition: doctokenizer.h:102
QCString mid(uint index, uint len=0xffffffff) const
Definition: qcstring.cpp:246
int doctokenizerYYleng
QCString name
Definition: doctokenizer.h:77
QCString name
Definition: htmlattrib.h:24
QCString lower() const
Definition: qcstring.cpp:263
const bool TRUE
Definition: qglobal.h:371
char * doctokenizerYYtext
if ( yy_init)

Definition at line 79711 of file doctokenizer.cpp.

79712  {
79713  (yy_init) = 1;
79714 
79715 #ifdef YY_USER_INIT
79716  YY_USER_INIT;
79717 #endif
79718 
79719  /* Create the reject buffer large enough to save one state per allowed character. */
79720  if ( ! (yy_state_buf) )
79722  if ( ! (yy_state_buf) )
79723  YY_FATAL_ERROR( "out of dynamic memory in doctokenizerYYlex()" );
79724 
79725  if ( ! (yy_start) )
79726  (yy_start) = 1; /* first start state */
79727 
79728  if ( ! doctokenizerYYin )
79729  doctokenizerYYin = stdin;
79730 
79731  if ( ! doctokenizerYYout )
79733 
79734  if ( ! YY_CURRENT_BUFFER ) {
79738  }
79739 
79741  }
#define YY_CURRENT_BUFFER
FILE * doctokenizerYYout
#define YY_FATAL_ERROR(msg)
YY_BUFFER_STATE doctokenizerYY_create_buffer(FILE *file, int size)
#define YY_CURRENT_BUFFER_LVALUE
FILE * doctokenizerYYin
void * doctokenizerYYalloc(yy_size_t)
int yy_state_type
Definition: code.cpp:361
static void doctokenizerYYensure_buffer_stack(void)
#define YY_BUF_SIZE
#define YY_STATE_BUF_SIZE
static int yy_init
static int yy_start
static yy_state_type * yy_state_buf
static void doctokenizerYY_load_buffer_state(void)
static void processSection ( )
static

Definition at line 79261 of file doctokenizer.cpp.

79262 {
79263  //printf("%s: found section/anchor with name `%s'\n",g_fileName.data(),g_secLabel.data());
79264  QCString file;
79265  if (g_memberGroup)
79266  {
79267  file = g_memberGroup->parent()->getOutputFileBase();
79268  }
79269  else if (g_definition)
79270  {
79271  file = g_definition->getOutputFileBase();
79272  }
79273  else
79274  {
79275  warn(g_fileName,doctokenizerYYlineno,"Found section/anchor %s without context\n",g_secLabel.data());
79276  }
79277  SectionInfo *si=0;
79278  if ((si=Doxygen::sectionDict->find(g_secLabel)))
79279  {
79280  si->fileName = file;
79281  si->type = g_secType;
79282  }
79283 }
static MemberGroup * g_memberGroup
int doctokenizerYYlineno
static QCString g_secLabel
virtual QCString getOutputFileBase() const =0
static QCString g_fileName
static SectionInfo::SectionType g_secType
static Definition * g_definition
Definition * parent() const
Definition: membergroup.h:89
QCString fileName
Definition: section.h:61
static SectionDict * sectionDict
Definition: doxygen.h:117
const char * data() const
Definition: qcstring.h:207
void warn(const char *file, int line, const char *fmt,...)
Definition: message.cpp:183
static QCString stripEmptyLines ( const QCString s)
static

Definition at line 79377 of file doctokenizer.cpp.

79378 {
79379  if (s.isEmpty()) return QCString();
79380  int end=s.length();
79381  int start=0,p=0;
79382  // skip leading empty lines
79383  for (;;)
79384  {
79385  int c;
79386  while ((c=s[p]) && (c==' ' || c=='\t')) p++;
79387  if (s[p]=='\n')
79388  {
79389  start=++p;
79390  }
79391  else
79392  {
79393  break;
79394  }
79395  }
79396  // skip trailing empty lines
79397  p=end-1;
79398  if (p>=start && s.at(p)=='\n') p--;
79399  while (p>=start)
79400  {
79401  int c;
79402  while ((c=s[p]) && (c==' ' || c=='\t')) p--;
79403  if (s[p]=='\n')
79404  {
79405  end=p;
79406  }
79407  else
79408  {
79409  break;
79410  }
79411  p--;
79412  }
79413  //printf("stripEmptyLines(%d-%d)\n",start,end);
79414  return s.mid(start,end-start);
79415 }
end
while True: pbar.update(maxval-len(onlies[E][S])) #print iS, "/", len(onlies[E][S]) found = False for...
bool isEmpty() const
Definition: qcstring.h:189
uint length() const
Definition: qcstring.h:195
char & at(uint i) const
Definition: qcstring.h:326
p
Definition: test.py:223
QCString mid(uint index, uint len=0xffffffff) const
Definition: qcstring.cpp:246
const char* tokToString ( int  token)

Definition at line 79216 of file doctokenizer.cpp.

79217 {
79218  switch (token)
79219  {
79220  case 0: return "TK_EOF";
79221  case TK_WORD: return "TK_WORD";
79222  case TK_LNKWORD: return "TK_LNKWORD";
79223  case TK_WHITESPACE: return "TK_WHITESPACE";
79224  case TK_LISTITEM: return "TK_LISTITEM";
79225  case TK_ENDLIST: return "TK_ENDLIST";
79226  case TK_COMMAND: return "TK_COMMAND";
79227  case TK_HTMLTAG: return "TK_HTMLTAG";
79228  case TK_SYMBOL: return "TK_SYMBOL";
79229  case TK_NEWPARA: return "TK_NEWPARA";
79230  case TK_RCSTAG: return "TK_RCSTAG";
79231  case TK_URL: return "TK_URL";
79232  }
79233  return "ERROR";
79234 }
while ( )

Definition at line 79743 of file doctokenizer.cpp.

79744  {
79745  yy_cp = (yy_c_buf_p);
79746 
79747  /* Support of doctokenizerYYtext. */
79748  *yy_cp = (yy_hold_char);
79749 
79750  /* yy_bp points to the position in yy_ch_buf of the start of
79751  * the current run.
79752  */
79753  yy_bp = yy_cp;
79754 
79755  yy_current_state = (yy_start);
79756  yy_current_state += YY_AT_BOL();
79757 
79758  (yy_state_ptr) = (yy_state_buf);
79759  *(yy_state_ptr)++ = yy_current_state;
79760 
79761 yy_match:
79762  do
79763  {
79764  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
79765  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
79766  {
79767  yy_current_state = (int) yy_def[yy_current_state];
79768  if ( yy_current_state >= 10008 )
79769  yy_c = yy_meta[(unsigned int) yy_c];
79770  }
79771  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
79772  *(yy_state_ptr)++ = yy_current_state;
79773  ++yy_cp;
79774  }
79775  while ( yy_current_state != 10007 );
79776 
79777 yy_find_action:
79778  yy_current_state = *--(yy_state_ptr);
79779  (yy_lp) = yy_accept[yy_current_state];
79780 find_rule: /* we branch to this label when backing up */
79781  for ( ; ; ) /* until we find what rule we matched */
79782  {
79783  if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
79784  {
79785  yy_act = yy_acclist[(yy_lp)];
79786  if ( yy_act & YY_TRAILING_HEAD_MASK ||
79788  {
79790  {
79793  break;
79794  }
79795  }
79796  else if ( yy_act & YY_TRAILING_MASK )
79797  {
79798  (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
79800  (yy_full_match) = yy_cp;
79802  (yy_full_lp) = (yy_lp);
79803  }
79804  else
79805  {
79806  (yy_full_match) = yy_cp;
79808  (yy_full_lp) = (yy_lp);
79809  break;
79810  }
79811  ++(yy_lp);
79812  goto find_rule;
79813  }
79814  --yy_cp;
79815  yy_current_state = *--(yy_state_ptr);
79816  (yy_lp) = yy_accept[yy_current_state];
79817  }
79818 
79820 
79822  {
79823  int yyl;
79824  for ( yyl = 0; yyl < doctokenizerYYleng; ++yyl )
79825  if ( doctokenizerYYtext[yyl] == '\n' )
79826 
79828 ;
79829  }
79830 
79831 do_action: /* This label is used only to access EOF actions. */
79832 
79833  switch ( yy_act )
79834  { /* beginning of action switch */
79835 case 1:
79837 #line 450 "doctokenizer.l"
79838 /* skip carriage return */
79839  YY_BREAK
79840 case 2:
79841 /* rule 2 can match eol */
79843 #line 451 "doctokenizer.l"
79844 { /* list item */
79846  int dashPos = text.findRev('-');
79847  g_token->isEnumList = text.at(dashPos+1)=='#';
79848  g_token->id = -1;
79850  return TK_LISTITEM;
79851  }
79852  YY_BREAK
79853 case 3:
79854 /* rule 3 can match eol */
79856 #line 459 "doctokenizer.l"
79857 { /* list item */
79859  {
79860  REJECT;
79861  }
79862  else
79863  {
79865  static QRegExp re("[*+]");
79866  int listPos = text.findRev(re);
79868  g_token->id = -1;
79870  return TK_LISTITEM;
79871  }
79872  }
79873  YY_BREAK
79874 case 4:
79876 #line 475 "doctokenizer.l"
79877 { /* numbered list item */
79879  {
79880  REJECT;
79881  }
79882  else
79883  {
79885  static QRegExp re("[1-9]");
79886  int digitPos = text.find(re);
79887  int dotPos = text.find('.',digitPos);
79888  g_token->isEnumList = TRUE;
79889  g_token->id = atoi(QCString(doctokenizerYYtext).mid(digitPos,dotPos-digitPos));
79891  return TK_LISTITEM;
79892  }
79893  }
79894  YY_BREAK
79895 case 5:
79896 /* rule 5 can match eol */
79898 #line 492 "doctokenizer.l"
79899 { /* list item on next line */
79901  text=text.right(text.length()-text.find('\n')-1);
79902  int dashPos = text.findRev('-');
79903  g_token->isEnumList = text.at(dashPos+1)=='#';
79904  g_token->id = -1;
79905  g_token->indent = computeIndent(text,dashPos);
79906  return TK_LISTITEM;
79907  }
79908  YY_BREAK
79909 case 6:
79910 /* rule 6 can match eol */
79912 #line 501 "doctokenizer.l"
79913 { /* list item on next line */
79915  {
79916  REJECT;
79917  }
79918  else
79919  {
79921  static QRegExp re("[*+]");
79922  text=text.right(text.length()-text.find('\n')-1);
79923  int markPos = text.findRev(re);
79925  g_token->id = -1;
79926  g_token->indent = computeIndent(text,markPos);
79927  return TK_LISTITEM;
79928  }
79929  }
79930  YY_BREAK
79931 case 7:
79932 /* rule 7 can match eol */
79934 #line 518 "doctokenizer.l"
79935 { /* list item on next line */
79937  {
79938  REJECT;
79939  }
79940  else
79941  {
79943  int nl=text.findRev('\n');
79944  int len=text.length();
79945  text=text.right(len-nl-1);
79946  static QRegExp re("[1-9]");
79947  int digitPos = text.find(re);
79948  int dotPos = text.find('.',digitPos);
79949  g_token->isEnumList = TRUE;
79950  g_token->id = atoi(QCString(text).mid(digitPos,dotPos-digitPos));
79951  g_token->indent = computeIndent(text,digitPos);
79952  return TK_LISTITEM;
79953  }
79954  }
79955  YY_BREAK
79956 case 8:
79957 /* rule 8 can match eol */
79959 #line 538 "doctokenizer.l"
79960 { /* end list */
79961  int dotPos = QCString(doctokenizerYYtext).findRev('.');
79963  return TK_ENDLIST;
79964  }
79965  YY_BREAK
79966 case 9:
79967 /* rule 9 can match eol */
79969 #line 543 "doctokenizer.l"
79970 { /* end list on next line */
79972  text=text.right(text.length()-text.find('\n')-1);
79973  int dotPos = text.findRev('.');
79974  g_token->indent = computeIndent(text,dotPos);
79975  return TK_ENDLIST;
79976  }
79977  YY_BREAK
79978 case 10:
79980 #line 550 "doctokenizer.l"
79981 {
79982  g_token->name = "javalink";
79983  return TK_COMMAND;
79984  }
79985  YY_BREAK
79986 case 11:
79988 #line 554 "doctokenizer.l"
79989 {
79990  g_token->name = "inheritdoc";
79991  return TK_COMMAND;
79992  }
79993  YY_BREAK
79994 case 12:
79996 #line 558 "doctokenizer.l"
79997 { // artificial new line
79999  }
80000  YY_BREAK
80001 case 13:
80003 #line 561 "doctokenizer.l"
80004 {
80005  g_token->name = "form";
80006  bool ok;
80007  g_token->id = QCString(doctokenizerYYtext).right((int)doctokenizerYYleng-6).toInt(&ok);
80008  ASSERT(ok);
80009  return TK_COMMAND;
80010  }
80011  YY_BREAK
80012 case 14:
80013 /* rule 14 can match eol */
80015 #line 568 "doctokenizer.l"
80016 { /* \n followed by real newline */
80021  return TK_COMMAND;
80022  }
80023  YY_BREAK
80024 case 15:
80025 #line 576 "doctokenizer.l"
80026 case 16:
80027 #line 577 "doctokenizer.l"
80028 case 17:
80030 #line 577 "doctokenizer.l"
80031 { /* special command */
80035  return TK_COMMAND;
80036  }
80037  YY_BREAK
80038 case 18:
80040 #line 583 "doctokenizer.l"
80041 { /* param [in,out] command */
80042  g_token->name = "param";
80044  bool isIn = s.find("in")!=-1;
80045  bool isOut = s.find("out")!=-1;
80046  if (isIn)
80047  {
80048  if (isOut)
80049  {
80051  }
80052  else
80053  {
80055  }
80056  }
80057  else if (isOut)
80058  {
80060  }
80061  else
80062  {
80064  }
80065  return TK_COMMAND;
80066  }
80067  YY_BREAK
80068 case 19:
80069 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
80070 (yy_c_buf_p) = yy_cp -= 1;
80071 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
80073 #line 609 "doctokenizer.l"
80074 { // URL.
80077  return TK_URL;
80078  }
80079  YY_BREAK
80080 case 20:
80082 #line 614 "doctokenizer.l"
80083 { // URL
80086  return TK_URL;
80087  }
80088  YY_BREAK
80089 case 21:
80091 #line 619 "doctokenizer.l"
80092 { // URL
80094  g_token->name = g_token->name.mid(1,g_token->name.length()-2);
80096  return TK_URL;
80097  }
80098  YY_BREAK
80099 case 22:
80101 #line 625 "doctokenizer.l"
80102 { // Mail address
80104  g_token->name.stripPrefix("mailto:");
80106  return TK_URL;
80107  }
80108  YY_BREAK
80109 case 23:
80111 #line 631 "doctokenizer.l"
80112 { // Mail address
80114  g_token->name = g_token->name.mid(1,g_token->name.length()-2);
80115  g_token->name.stripPrefix("mailto:");
80117  return TK_URL;
80118  }
80119  YY_BREAK
80120 case 24:
80122 #line 638 "doctokenizer.l"
80123 { /* RCS tag */
80124  QCString tagName(doctokenizerYYtext+1);
80125  int index=tagName.find(':');
80126  g_token->name = tagName.left(index);
80127  int text_begin = index+2;
80128  int text_end = tagName.length()-1;
80129  if (tagName[text_begin-1]==':') /* check for Subversion fixed-length keyword */
80130  {
80131  ++text_begin;
80132  if (tagName[text_end-1]=='#')
80133  --text_end;
80134  }
80135  g_token->text = tagName.mid(text_begin,text_end-text_begin);
80136  return TK_RCSTAG;
80137  }
80138  YY_BREAK
80139 case 25:
80141 #line 653 "doctokenizer.l"
80142 { /* environment variable */
80144  name = name.left(name.length()-1);
80145  QCString value = portable_getenv(name);
80146  for (int i=value.length()-1;i>=0;i--) unput(value.at(i));
80147  }
80148  YY_BREAK
80149 case 26:
80150 /* rule 26 can match eol */
80152 #line 659 "doctokenizer.l"
80153 { /* html tag */
80154  handleHtmlTag();
80155  return TK_HTMLTAG;
80156  }
80157  YY_BREAK
80158 case 27:
80160 #line 663 "doctokenizer.l"
80161 { /* special symbol */
80163  return TK_SYMBOL;
80164  }
80165  YY_BREAK
80166 /********* patterns for linkable words ******************/
80167 case 28:
80169 #line 670 "doctokenizer.l"
80170 { /* this rule is to prevent opening html
80171  * tag to be recognized as a templated classes
80172  */
80174  return TK_LNKWORD;
80175  }
80176  YY_BREAK
80177 case 29:
80178 /* rule 29 can match eol */
80179 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
80180 (yy_c_buf_p) = yy_cp -= 4;
80181 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
80182 #line 677 "doctokenizer.l"
80183 case 30:
80184 /* rule 30 can match eol */
80185 #line 678 "doctokenizer.l"
80186 case 31:
80187 /* rule 31 can match eol */
80188 #line 679 "doctokenizer.l"
80189 case 32:
80190 /* rule 32 can match eol */
80191 #line 680 "doctokenizer.l"
80192 case 33:
80193 /* rule 33 can match eol */
80195 #line 680 "doctokenizer.l"
80196 {
80198  return TK_LNKWORD;
80199  }
80200  YY_BREAK
80201 case 34:
80202 /* rule 34 can match eol */
80204 #line 684 "doctokenizer.l"
80205 {
80208  unput(doctokenizerYYtext[(int)doctokenizerYYleng-1]);
80209  return TK_LNKWORD;
80210  }
80211  YY_BREAK
80212 /********* patterns for normal words ******************/
80213 case 35:
80214 /* rule 35 can match eol */
80215 #line 693 "doctokenizer.l"
80216 case 36:
80217 /* rule 36 can match eol */
80219 #line 693 "doctokenizer.l"
80220 { /* function call */
80221  if (doctokenizerYYtext[0]=='%') // strip % if present
80223  else
80225  return TK_WORD;
80226 
80227  /* the following is dummy code to please the
80228  * compiler, removing this results in a warning
80229  * on my machine
80230  */
80231  goto find_rule;
80232  }
80233  YY_BREAK
80234 case 37:
80236 #line 706 "doctokenizer.l"
80237 {
80239  return TK_WORD;
80240  }
80241  YY_BREAK
80242 case 38:
80243 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
80244 (yy_c_buf_p) = yy_cp = yy_bp + 8;
80245 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
80247 #line 710 "doctokenizer.l"
80248 { // Special case: word "operator" followed by a HTML command
80249  // avoid interpretation as "operator <"
80251  return TK_WORD;
80252  }
80253  YY_BREAK
80254 /*******************************************************/
80255 case 39:
80256 #line 719 "doctokenizer.l"
80257 case 40:
80258 /* rule 40 can match eol */
80260 #line 719 "doctokenizer.l"
80261 { /* white space */
80263  return TK_WHITESPACE;
80264  }
80265  YY_BREAK
80266 case 41:
80268 #line 723 "doctokenizer.l"
80269 {
80271  return TK_COMMAND;
80272  }
80273  YY_BREAK
80274 case 42:
80275 /* rule 42 can match eol */
80277 #line 727 "doctokenizer.l"
80278 { /* skip trailing paragraph followed by new list item */
80279  if (g_insidePre || g_autoListLevel==0)
80280  {
80281  REJECT;
80282  }
80283  }
80284  YY_BREAK
80285 case 43:
80286 /* rule 43 can match eol */
80288 #line 733 "doctokenizer.l"
80289 { /* skip trailing paragraph followed by new list item */
80291  {
80292  REJECT;
80293  }
80294  }
80295  YY_BREAK
80296 case 44:
80297 /* rule 44 can match eol */
80299 #line 739 "doctokenizer.l"
80300 { /* skip trailing paragraph followed by new list item */
80302  {
80303  REJECT;
80304  }
80305  }
80306  YY_BREAK
80307 case 45:
80308 /* rule 45 can match eol */
80310 #line 745 "doctokenizer.l"
80311 {
80312  g_token->indent=computeIndent(doctokenizerYYtext,(int)doctokenizerYYleng);
80313  int i;
80314  // put back the indentation (needed for list items)
80315  for (i=0;i<g_token->indent;i++)
80316  {
80317  unput(' ');
80318  }
80319  // tell flex that after putting the last indent
80320  // back we are at the beginning of the line
80321  YY_CURRENT_BUFFER->yy_at_bol=1;
80322  // start of a new paragraph
80323  return TK_NEWPARA;
80324  }
80325  YY_BREAK
80326 case 46:
80328 #line 759 "doctokenizer.l"
80329 {
80331  int i=g_token->name.find('{'); /* } to keep vi happy */
80332  g_token->name = g_token->name.mid(i+1,g_token->name.length()-i-2);
80333  BEGIN(St_Code);
80334  }
80335  YY_BREAK
80336 case 47:
80337 /* rule 47 can match eol */
80338 #line 766 "doctokenizer.l"
80339 case 48:
80340 /* rule 48 can match eol */
80342 #line 766 "doctokenizer.l"
80343 {
80345  BEGIN(St_Code);
80346  }
80347  YY_BREAK
80348 case 49:
80349 /* rule 49 can match eol */
80351 #line 770 "doctokenizer.l"
80352 {
80353  return RetVal_OK;
80354  }
80355  YY_BREAK
80356 case 50:
80357 /* rule 50 can match eol */
80359 #line 773 "doctokenizer.l"
80360 {
80361  return RetVal_OK;
80362  }
80363  YY_BREAK
80364 case 51:
80365 #line 777 "doctokenizer.l"
80366 case 52:
80367 /* rule 52 can match eol */
80368 #line 778 "doctokenizer.l"
80369 case 53:
80370 /* rule 53 can match eol */
80372 #line 778 "doctokenizer.l"
80373 {
80375  }
80376  YY_BREAK
80377 case 54:
80379 #line 781 "doctokenizer.l"
80380 { // the space is added in commentscan.l
80381  g_token->name="block";
80382  BEGIN(St_HtmlOnly);
80383  }
80384  YY_BREAK
80385 case 55:
80386 /* rule 55 can match eol */
80388 #line 785 "doctokenizer.l"
80389 {
80391  BEGIN(St_HtmlOnly);
80392  }
80393  YY_BREAK
80394 case 56:
80396 #line 789 "doctokenizer.l"
80397 {
80398  return RetVal_OK;
80399  }
80400  YY_BREAK
80401 case 57:
80402 #line 793 "doctokenizer.l"
80403 case 58:
80404 /* rule 58 can match eol */
80405 #line 794 "doctokenizer.l"
80406 case 59:
80407 /* rule 59 can match eol */
80409 #line 794 "doctokenizer.l"
80410 {
80412  }
80413  YY_BREAK
80414 case 60:
80416 #line 797 "doctokenizer.l"
80417 {
80418  return RetVal_OK;
80419  }
80420  YY_BREAK
80421 case 61:
80422 #line 801 "doctokenizer.l"
80423 case 62:
80424 /* rule 62 can match eol */
80425 #line 802 "doctokenizer.l"
80426 case 63:
80427 /* rule 63 can match eol */
80429 #line 802 "doctokenizer.l"
80430 {
80432  }
80433  YY_BREAK
80434 case 64:
80436 #line 805 "doctokenizer.l"
80437 {
80438  return RetVal_OK;
80439  }
80440  YY_BREAK
80441 case 65:
80442 #line 809 "doctokenizer.l"
80443 case 66:
80444 /* rule 66 can match eol */
80445 #line 810 "doctokenizer.l"
80446 case 67:
80447 /* rule 67 can match eol */
80449 #line 810 "doctokenizer.l"
80450 {
80452  }
80453  YY_BREAK
80454 case 68:
80456 #line 813 "doctokenizer.l"
80457 {
80458  return RetVal_OK;
80459  }
80460  YY_BREAK
80461 case 69:
80462 #line 817 "doctokenizer.l"
80463 case 70:
80464 /* rule 70 can match eol */
80465 #line 818 "doctokenizer.l"
80466 case 71:
80467 /* rule 71 can match eol */
80469 #line 818 "doctokenizer.l"
80470 {
80472  }
80473  YY_BREAK
80474 case 72:
80476 #line 821 "doctokenizer.l"
80477 {
80478  return RetVal_OK;
80479  }
80480  YY_BREAK
80481 case 73:
80482 #line 825 "doctokenizer.l"
80483 case 74:
80484 /* rule 74 can match eol */
80485 #line 826 "doctokenizer.l"
80486 case 75:
80487 /* rule 75 can match eol */
80489 #line 826 "doctokenizer.l"
80490 {
80492  }
80493  YY_BREAK
80494 case 76:
80496 #line 829 "doctokenizer.l"
80497 {
80498  return RetVal_OK;
80499  }
80500  YY_BREAK
80501 case 77:
80502 #line 833 "doctokenizer.l"
80503 case 78:
80504 /* rule 78 can match eol */
80505 #line 834 "doctokenizer.l"
80506 case 79:
80507 /* rule 79 can match eol */
80509 #line 834 "doctokenizer.l"
80510 {
80512  }
80513  YY_BREAK
80514 case 80:
80516 #line 837 "doctokenizer.l"
80517 {
80519  return RetVal_OK;
80520  }
80521  YY_BREAK
80522 case 81:
80523 #line 842 "doctokenizer.l"
80524 case 82:
80525 /* rule 82 can match eol */
80526 #line 843 "doctokenizer.l"
80527 case 83:
80528 /* rule 83 can match eol */
80530 #line 843 "doctokenizer.l"
80531 { /* Verbatim text */
80533  }
80534  YY_BREAK
80535 case 84:
80537 #line 846 "doctokenizer.l"
80538 {
80539  return RetVal_OK;
80540  }
80541  YY_BREAK
80542 case 85:
80543 #line 850 "doctokenizer.l"
80544 case 86:
80545 /* rule 86 can match eol */
80546 #line 851 "doctokenizer.l"
80547 case 87:
80548 /* rule 87 can match eol */
80550 #line 851 "doctokenizer.l"
80551 { /* dot text */
80553  }
80554  YY_BREAK
80555 case 88:
80557 #line 854 "doctokenizer.l"
80558 {
80559  return RetVal_OK;
80560  }
80561  YY_BREAK
80562 case 89:
80563 #line 858 "doctokenizer.l"
80564 case 90:
80565 /* rule 90 can match eol */
80566 #line 859 "doctokenizer.l"
80567 case 91:
80568 /* rule 91 can match eol */
80570 #line 859 "doctokenizer.l"
80571 { /* msc text */
80573  }
80574  YY_BREAK
80575 case 92:
80576 /* rule 92 can match eol */
80578 #line 862 "doctokenizer.l"
80579 { // case 1: file name is specified as {filename}
80581  // skip curly brackets around the optional image name
80582  g_token->sectionId = g_token->sectionId.mid(1,g_token->sectionId.length()-2).stripWhiteSpace();
80583  return RetVal_OK;
80584  }
80585  YY_BREAK
80586 case 93:
80588 #line 868 "doctokenizer.l"
80589 { // case 2: plain file name specified followed by an attribute
80591  return RetVal_OK;
80592  }
80593  YY_BREAK
80594 case 94:
80595 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
80596 (yy_c_buf_p) = yy_cp -= 1;
80597 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
80599 #line 872 "doctokenizer.l"
80600 { // case 3: plain file name specified followed by a quoted title
80602  return RetVal_OK;
80603  }
80604  YY_BREAK
80605 case 95:
80606 /* rule 95 can match eol */
80607 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
80608 (yy_c_buf_p) = yy_cp -= 1;
80609 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
80611 #line 876 "doctokenizer.l"
80612 { // case 4: plain file name specified without title or attributes
80614  return RetVal_OK;
80615  }
80616  YY_BREAK
80617 case 96:
80619 #line 880 "doctokenizer.l"
80620 {
80621  g_token->sectionId = "";
80623  return RetVal_OK;
80624  }
80625  YY_BREAK
80626 case 97:
80628 #line 885 "doctokenizer.l"
80629 {
80630  return RetVal_OK;
80631  }
80632  YY_BREAK
80633 case 98:
80634 #line 889 "doctokenizer.l"
80635 case 99:
80636 /* rule 99 can match eol */
80637 #line 890 "doctokenizer.l"
80638 case 100:
80639 /* rule 100 can match eol */
80641 #line 890 "doctokenizer.l"
80642 { /* plantuml text */
80644  }
80645  YY_BREAK
80646 case 101:
80648 #line 893 "doctokenizer.l"
80649 { // quoted title
80650  BEGIN(St_TitleQ);
80651  }
80652  YY_BREAK
80653 case 102:
80655 #line 896 "doctokenizer.l"
80656 {
80658  return TK_WHITESPACE;
80659  }
80660  YY_BREAK
80661 case 103:
80663 #line 900 "doctokenizer.l"
80664 { // non-quoted title
80666  BEGIN(St_TitleN);
80667  }
80668  YY_BREAK
80669 case 104:
80670 /* rule 104 can match eol */
80672 #line 904 "doctokenizer.l"
80673 {
80675  return 0;
80676  }
80677  YY_BREAK
80678 case 105:
80680 #line 908 "doctokenizer.l"
80681 { /* symbol */
80683  return TK_SYMBOL;
80684  }
80685  YY_BREAK
80686 case 106:
80687 /* rule 106 can match eol */
80689 #line 912 "doctokenizer.l"
80690 {
80691  }
80692  YY_BREAK
80693 case 107:
80694 #line 915 "doctokenizer.l"
80695 case 108:
80697 #line 915 "doctokenizer.l"
80698 { /* special command */
80701  return TK_COMMAND;
80702  }
80703  YY_BREAK
80704 case 109:
80706 #line 920 "doctokenizer.l"
80707 { /* attribute */
80708  if (doctokenizerYYtext[0]=='%') // strip % if present
80710  else
80712  return TK_WORD;
80713  }
80714  YY_BREAK
80715 case 110:
80716 /* rule 110 can match eol */
80717 #line 928 "doctokenizer.l"
80718 case 111:
80719 /* rule 111 can match eol */
80721 #line 928 "doctokenizer.l"
80722 { /* word */
80723  if (doctokenizerYYtext[0]=='%') // strip % if present
80725  else
80727  return TK_WORD;
80728  }
80729  YY_BREAK
80730 case 112:
80732 #line 935 "doctokenizer.l"
80733 {
80735  return TK_WHITESPACE;
80736  }
80737  YY_BREAK
80738 case 113:
80739 /* rule 113 can match eol */
80741 #line 939 "doctokenizer.l"
80742 { /* new line => end of title */
80744  return 0;
80745  }
80746  YY_BREAK
80747 case 114:
80749 #line 943 "doctokenizer.l"
80750 { /* symbol */
80752  return TK_SYMBOL;
80753  }
80754  YY_BREAK
80755 case 115:
80756 #line 948 "doctokenizer.l"
80757 case 116:
80759 #line 948 "doctokenizer.l"
80760 { /* special command */
80763  return TK_COMMAND;
80764  }
80765  YY_BREAK
80766 case 117:
80767 #line 954 "doctokenizer.l"
80768 case 118:
80770 #line 954 "doctokenizer.l"
80771 { /* word */
80773  return TK_WORD;
80774  }
80775  YY_BREAK
80776 case 119:
80778 #line 958 "doctokenizer.l"
80779 {
80781  return TK_WHITESPACE;
80782  }
80783  YY_BREAK
80784 case 120:
80786 #line 962 "doctokenizer.l"
80787 { /* closing quote => end of title */
80788  BEGIN(St_TitleA);
80789  return 0;
80790  }
80791  YY_BREAK
80792 case 121:
80793 /* rule 121 can match eol */
80795 #line 966 "doctokenizer.l"
80796 { /* new line => end of title */
80798  return 0;
80799  }
80800  YY_BREAK
80801 case 122:
80803 #line 970 "doctokenizer.l"
80804 { // title attribute
80806  g_token->name = g_token->name.left(g_token->name.find('=')).stripWhiteSpace();
80807  BEGIN(St_TitleV);
80808  }
80809  YY_BREAK
80810 case 123:
80812 #line 975 "doctokenizer.l"
80813 { // attribute value
80815  BEGIN(St_TitleN);
80816  return TK_WORD;
80817  }
80818  YY_BREAK
80819 case 124:
80821 #line 980 "doctokenizer.l"
80822 {
80824  return 0;
80825  }
80826  YY_BREAK
80827 case 125:
80828 /* rule 125 can match eol */
80830 #line 984 "doctokenizer.l"
80831 {
80832  return 0;
80833  }
80834  YY_BREAK
80835 case 126:
80836 /* rule 126 can match eol */
80838 #line 988 "doctokenizer.l"
80839 { // anchor
80841  return TK_WORD;
80842  }
80843  YY_BREAK
80844 case 127:
80846 #line 992 "doctokenizer.l"
80847 {
80849  return 0;
80850  }
80851  YY_BREAK
80852 case 128:
80854 #line 996 "doctokenizer.l"
80855 { // label to cite
80857  return TK_WORD;
80858  }
80859  YY_BREAK
80860 case 129:
80862 #line 1000 "doctokenizer.l"
80863 { // white space
80864  unput(' ');
80865  return 0;
80866  }
80867  YY_BREAK
80868 case 130:
80869 /* rule 130 can match eol */
80871 #line 1004 "doctokenizer.l"
80872 { // new line
80874  return 0;
80875  }
80876  YY_BREAK
80877 case 131:
80879 #line 1008 "doctokenizer.l"
80880 { // any other character
80882  return 0;
80883  }
80884  YY_BREAK
80885 case 132:
80886 /* rule 132 can match eol */
80888 #line 1012 "doctokenizer.l"
80889 { // label to refer to
80891  return TK_WORD;
80892  }
80893  YY_BREAK
80894 case 133:
80896 #line 1016 "doctokenizer.l"
80897 { // white space
80898  unput(' ');
80899  return 0;
80900  }
80901  YY_BREAK
80902 case 134:
80903 /* rule 134 can match eol */
80905 #line 1020 "doctokenizer.l"
80906 { // white space following by quoted string
80907  BEGIN(St_Ref2);
80908  }
80909  YY_BREAK
80910 case 135:
80911 /* rule 135 can match eol */
80913 #line 1023 "doctokenizer.l"
80914 { // new line
80916  return 0;
80917  }
80918  YY_BREAK
80919 case 136:
80921 #line 1027 "doctokenizer.l"
80922 { // any other character
80924  return 0;
80925  }
80926  YY_BREAK
80927 case 137:
80929 #line 1031 "doctokenizer.l"
80930 {
80932  return TK_WORD;
80933  }
80934  YY_BREAK
80935 case 138:
80937 #line 1035 "doctokenizer.l"
80938 {
80939  BEGIN(St_Ref2);
80940  }
80941  YY_BREAK
80942 case 139:
80943 /* rule 139 can match eol */
80945 #line 1038 "doctokenizer.l"
80946 {
80949  return TK_WORD;
80950  }
80951  YY_BREAK
80952 case 140:
80953 /* rule 140 can match eol */
80955 #line 1043 "doctokenizer.l"
80956 {
80959  g_sharpCount=1;
80961  }
80962  YY_BREAK
80963 case 141:
80965 #line 1049 "doctokenizer.l"
80966 {
80967  }
80968  YY_BREAK
80969 case 142:
80971 #line 1051 "doctokenizer.l"
80972 {
80974  g_sharpCount++;
80975  }
80976  YY_BREAK
80977 case 143:
80979 #line 1055 "doctokenizer.l"
80980 {
80982  g_sharpCount--;
80983  if (g_sharpCount<=0)
80984  {
80985  return TK_WORD;
80986  }
80987  }
80988  YY_BREAK
80989 case 144:
80991 #line 1063 "doctokenizer.l"
80992 {
80994  }
80995  YY_BREAK
80996 case 145:
80998 #line 1066 "doctokenizer.l"
80999 { /* symbol */
81001  return TK_SYMBOL;
81002  }
81003  YY_BREAK
81004 case 146:
81005 #line 1071 "doctokenizer.l"
81006 case 147:
81008 #line 1071 "doctokenizer.l"
81009 { /* special command */
81012  return TK_COMMAND;
81013  }
81014  YY_BREAK
81015 case 148:
81016 #line 1077 "doctokenizer.l"
81017 case 149:
81019 #line 1077 "doctokenizer.l"
81020 {
81021  /* word */
81023  return TK_WORD;
81024  }
81025  YY_BREAK
81026 case 150:
81028 #line 1082 "doctokenizer.l"
81029 {
81031  return TK_WHITESPACE;
81032  }
81033  YY_BREAK
81034 case 151:
81035 /* rule 151 can match eol */
81037 #line 1086 "doctokenizer.l"
81038 { /* " or \n => end of title */
81039  return 0;
81040  }
81041  YY_BREAK
81042 case 152:
81044 #line 1089 "doctokenizer.l"
81045 {
81047  }
81048  YY_BREAK
81049 case 153:
81051 #line 1092 "doctokenizer.l"
81052 {
81054  }
81055  YY_BREAK
81056 case 154:
81058 #line 1095 "doctokenizer.l"
81059 {
81061  numStr=numStr.left((int)doctokenizerYYleng-1);
81062  g_token->id=numStr.toInt();
81063  return RetVal_OK;
81064  }
81065  YY_BREAK
81066 case 155:
81068 #line 1101 "doctokenizer.l"
81069 { /* html style comment block */
81071  BEGIN(St_Comment);
81072  }
81073  YY_BREAK
81074 case 156:
81076 #line 1105 "doctokenizer.l"
81077 {
81079  g_token->name = g_token->name.left((int)doctokenizerYYleng-2);
81080  return TK_WORD;
81081  }
81082  YY_BREAK
81083 case 157:
81084 /* rule 157 can match eol */
81086 #line 1110 "doctokenizer.l"
81087 {
81089  int j = params.find('&');
81090  int i = params.find('$');
81091  if (j<i && j!=-1) i=j;
81092  QCString types = params.left(i).stripWhiteSpace();
81093  g_token->name = types+"#"+params.mid(i);
81094  return TK_WORD;
81095  }
81096  YY_BREAK
81097 case 158:
81099 #line 1119 "doctokenizer.l"
81100 {
81102  if (g_token->name.at(doctokenizerYYleng-1)==':')
81103  {
81104  g_token->name=g_token->name.left(doctokenizerYYleng-1);
81105  }
81106  return TK_WORD;
81107  }
81108  YY_BREAK
81109 case 159:
81110 /* rule 159 can match eol */
81112 #line 1127 "doctokenizer.l"
81113 /* param separator */
81114  YY_BREAK
81115 case 160:
81116 /* rule 160 can match eol */
81118 #line 1128 "doctokenizer.l"
81119 {
81121  return TK_WHITESPACE;
81122  }
81123  YY_BREAK
81124 case 161:
81126 #line 1132 "doctokenizer.l"
81127 {
81129  return TK_WORD;
81130  }
81131  YY_BREAK
81132 case 162:
81134 #line 1136 "doctokenizer.l"
81135 {
81137  g_token->name = text.mid(1,text.length()-2);
81138  return TK_WORD;
81139  }
81140  YY_BREAK
81141 case 163:
81143 #line 1141 "doctokenizer.l"
81144 {
81147  return TK_WORD;
81148  }
81149  YY_BREAK
81150 case 164:
81151 /* rule 164 can match eol */
81153 #line 1146 "doctokenizer.l"
81154 {
81156  return TK_WORD;
81157  }
81158  YY_BREAK
81159 case 165:
81161 #line 1150 "doctokenizer.l"
81162 { /* end of html comment */
81164  }
81165  YY_BREAK
81166 case 166:
81167 /* rule 166 can match eol */
81169 #line 1153 "doctokenizer.l"
81170 /* inside html comment */
81171  YY_BREAK
81172 case 167:
81174 #line 1154 "doctokenizer.l"
81175 /* inside html comment */
81176  YY_BREAK
81177 /* State for skipping title (all chars until the end of the line) */
81178 case 168:
81180 #line 1158 "doctokenizer.l"
81181 
81182  YY_BREAK
81183 case 169:
81184 /* rule 169 can match eol */
81186 #line 1159 "doctokenizer.l"
81187 { return 0; }
81188  YY_BREAK
81189 /* State for the pass used to find the anchors and sections */
81190 case 170:
81192 #line 1163 "doctokenizer.l"
81193 
81194  YY_BREAK
81195 case 171:
81197 #line 1164 "doctokenizer.l"
81198 
81199  YY_BREAK
81200 case 172:
81201 /* rule 172 can match eol */
81203 #line 1165 "doctokenizer.l"
81204 {
81206  int s=tag.find("id=");
81207  if (s!=-1) // command has id attribute
81208  {
81209  char c=tag[s+3];
81210  if (c=='\'' || c=='"') // valid start
81211  {
81212  int e=tag.find(c,s+4);
81213  if (e!=-1) // found matching end
81214  {
81216  g_secLabel=tag.mid(s+4,e-s-4); // extract id
81217  processSection();
81218  }
81219  }
81220  }
81221  }
81222  YY_BREAK
81223 case 173:
81225 #line 1183 "doctokenizer.l"
81226 {
81228  BEGIN(St_SecLabel1);
81229  }
81230  YY_BREAK
81231 case 174:
81233 #line 1187 "doctokenizer.l"
81234 {
81236  BEGIN(St_SecLabel2);
81237  }
81238  YY_BREAK
81239 case 175:
81241 #line 1191 "doctokenizer.l"
81242 {
81244  BEGIN(St_SecLabel2);
81245  }
81246  YY_BREAK
81247 case 176:
81249 #line 1195 "doctokenizer.l"
81250 {
81252  BEGIN(St_SecLabel2);
81253  }
81254  YY_BREAK
81255 case 177:
81257 #line 1199 "doctokenizer.l"
81258 {
81260  BEGIN(St_SecLabel2);
81261  }
81262  YY_BREAK
81263 case 178:
81264 /* rule 178 can match eol */
81265 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81266 (yy_c_buf_p) = yy_cp -= 1;
81267 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81269 #line 1203 "doctokenizer.l"
81270 {
81271  g_endMarker="endverbatim";
81272  BEGIN(St_SecSkip);
81273  }
81274  YY_BREAK
81275 case 179:
81276 /* rule 179 can match eol */
81277 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81278 (yy_c_buf_p) = yy_cp -= 1;
81279 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81281 #line 1207 "doctokenizer.l"
81282 {
81283  g_endMarker="enddot";
81284  BEGIN(St_SecSkip);
81285  }
81286  YY_BREAK
81287 case 180:
81288 /* rule 180 can match eol */
81289 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81290 (yy_c_buf_p) = yy_cp -= 1;
81291 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81293 #line 1211 "doctokenizer.l"
81294 {
81295  g_endMarker="endmsc";
81296  BEGIN(St_SecSkip);
81297  }
81298  YY_BREAK
81299 case 181:
81300 /* rule 181 can match eol */
81301 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81302 (yy_c_buf_p) = yy_cp -= 1;
81303 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81305 #line 1215 "doctokenizer.l"
81306 {
81307  g_endMarker="enduml";
81308  BEGIN(St_SecSkip);
81309  }
81310  YY_BREAK
81311 case 182:
81312 /* rule 182 can match eol */
81313 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81314 (yy_c_buf_p) = yy_cp -= 1;
81315 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81317 #line 1219 "doctokenizer.l"
81318 {
81319  g_endMarker="endhtmlonly";
81320  BEGIN(St_SecSkip);
81321  }
81322  YY_BREAK
81323 case 183:
81324 /* rule 183 can match eol */
81325 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81326 (yy_c_buf_p) = yy_cp -= 1;
81327 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81329 #line 1223 "doctokenizer.l"
81330 {
81331  g_endMarker="endlatexonly";
81332  BEGIN(St_SecSkip);
81333  }
81334  YY_BREAK
81335 case 184:
81336 /* rule 184 can match eol */
81337 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81338 (yy_c_buf_p) = yy_cp -= 1;
81339 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81341 #line 1227 "doctokenizer.l"
81342 {
81343  g_endMarker="endxmlonly";
81344  BEGIN(St_SecSkip);
81345  }
81346  YY_BREAK
81347 case 185:
81348 /* rule 185 can match eol */
81349 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81350 (yy_c_buf_p) = yy_cp -= 1;
81351 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81353 #line 1231 "doctokenizer.l"
81354 {
81355  g_endMarker="enddocbookonly";
81356  BEGIN(St_SecSkip);
81357  }
81358  YY_BREAK
81359 case 186:
81360 /* rule 186 can match eol */
81361 *yy_cp = (yy_hold_char); /* undo effects of setting up doctokenizerYYtext */
81362 (yy_c_buf_p) = yy_cp -= 1;
81363 YY_DO_BEFORE_ACTION; /* set up doctokenizerYYtext again */
81365 #line 1235 "doctokenizer.l"
81366 {
81367  g_endMarker="endcode";
81368  BEGIN(St_SecSkip);
81369  }
81370  YY_BREAK
81371 case 187:
81373 #line 1239 "doctokenizer.l"
81374 {
81375  g_endMarker="-->";
81376  BEGIN(St_SecSkip);
81377  }
81378  YY_BREAK
81379 case 188:
81381 #line 1243 "doctokenizer.l"
81382 {
81384  {
81385  BEGIN(St_Sections);
81386  }
81387  }
81388  YY_BREAK
81389 case 189:
81391 #line 1249 "doctokenizer.l"
81392 {
81394  {
81395  BEGIN(St_Sections);
81396  }
81397  }
81398  YY_BREAK
81399 case 190:
81400 /* rule 190 can match eol */
81402 #line 1255 "doctokenizer.l"
81403 
81404  YY_BREAK
81405 case 191:
81407 #line 1256 "doctokenizer.l"
81408 
81409  YY_BREAK
81410 case 192:
81411 /* rule 192 can match eol */
81413 #line 1257 "doctokenizer.l"
81414 
81415  YY_BREAK
81416 case 193:
81418 #line 1258 "doctokenizer.l"
81419 
81420  YY_BREAK
81421 case 194:
81422 /* rule 194 can match eol */
81424 #line 1259 "doctokenizer.l"
81425 
81426  YY_BREAK
81427 case 195:
81429 #line 1260 "doctokenizer.l"
81430 {
81432  processSection();
81433  BEGIN(St_Sections);
81434  }
81435  YY_BREAK
81436 case 196:
81437 #line 1266 "doctokenizer.l"
81438 case 197:
81440 #line 1266 "doctokenizer.l"
81441 {
81444  BEGIN(St_SecTitle);
81445  }
81446  YY_BREAK
81447 case 198:
81448 #line 1272 "doctokenizer.l"
81449 case 199:
81450 /* rule 199 can match eol */
81452 #line 1272 "doctokenizer.l"
81453 {
81456  processSection();
81457  BEGIN(St_Sections);
81458  }
81459  YY_BREAK
81460 case 200:
81462 #line 1278 "doctokenizer.l"
81463 {
81464  warn(g_fileName,doctokenizerYYlineno,"Unexpected character `%s' while looking for section label or title",doctokenizerYYtext);
81465  }
81466  YY_BREAK
81467 case 201:
81468 #line 1283 "doctokenizer.l"
81469 case 202:
81470 /* rule 202 can match eol */
81472 #line 1283 "doctokenizer.l"
81473 {
81476  return TK_WORD;
81477  }
81478  YY_BREAK
81479 /* Generic rules that work for all states */
81480 case 203:
81481 /* rule 203 can match eol */
81483 #line 1290 "doctokenizer.l"
81484 {
81485  warn(g_fileName,doctokenizerYYlineno,"Unexpected new line character");
81486  }
81487  YY_BREAK
81488 case 204:
81490 #line 1293 "doctokenizer.l"
81491 { /* unescaped special character */
81492  //warn(g_fileName,doctokenizerYYlineno,"Unexpected character `%s', assuming command \\%s was meant.",doctokenizerYYtext,doctokenizerYYtext);
81494  return TK_COMMAND;
81495  }
81496  YY_BREAK
81497 case 205:
81499 #line 1298 "doctokenizer.l"
81500 {
81501  warn(g_fileName,doctokenizerYYlineno,"Unexpected character `%s'",doctokenizerYYtext);
81502  }
81503  YY_BREAK
81504 case 206:
81506 #line 1301 "doctokenizer.l"
81507 ECHO;
81508  YY_BREAK
81509 #line 81510 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/doctokenizer.cpp"
81510  case YY_STATE_EOF(INITIAL):
81511  case YY_STATE_EOF(St_Para):
81512  case YY_STATE_EOF(St_Comment):
81513  case YY_STATE_EOF(St_Title):
81514  case YY_STATE_EOF(St_TitleN):
81515  case YY_STATE_EOF(St_TitleQ):
81516  case YY_STATE_EOF(St_TitleA):
81517  case YY_STATE_EOF(St_TitleV):
81518  case YY_STATE_EOF(St_Code):
81519  case YY_STATE_EOF(St_CodeOpt):
81520  case YY_STATE_EOF(St_XmlCode):
81521  case YY_STATE_EOF(St_HtmlOnly):
81522  case YY_STATE_EOF(St_HtmlOnlyOption):
81523  case YY_STATE_EOF(St_ManOnly):
81524  case YY_STATE_EOF(St_LatexOnly):
81525  case YY_STATE_EOF(St_RtfOnly):
81526  case YY_STATE_EOF(St_XmlOnly):
81527  case YY_STATE_EOF(St_DbOnly):
81528  case YY_STATE_EOF(St_Verbatim):
81529  case YY_STATE_EOF(St_Dot):
81530  case YY_STATE_EOF(St_Msc):
81531  case YY_STATE_EOF(St_PlantUMLOpt):
81532  case YY_STATE_EOF(St_PlantUML):
81533  case YY_STATE_EOF(St_Param):
81534  case YY_STATE_EOF(St_XRefItem):
81535  case YY_STATE_EOF(St_XRefItem2):
81536  case YY_STATE_EOF(St_File):
81537  case YY_STATE_EOF(St_Pattern):
81538  case YY_STATE_EOF(St_Link):
81539  case YY_STATE_EOF(St_Cite):
81540  case YY_STATE_EOF(St_Ref):
81541  case YY_STATE_EOF(St_Ref2):
81542  case YY_STATE_EOF(St_IntRef):
81543  case YY_STATE_EOF(St_Text):
81544  case YY_STATE_EOF(St_SkipTitle):
81545  case YY_STATE_EOF(St_Anchor):
81546  case YY_STATE_EOF(St_Snippet):
81547  case YY_STATE_EOF(St_SetScope):
81548  case YY_STATE_EOF(St_SetScopeEnd):
81549  case YY_STATE_EOF(St_Sections):
81550  case YY_STATE_EOF(St_SecLabel1):
81551  case YY_STATE_EOF(St_SecLabel2):
81552  case YY_STATE_EOF(St_SecTitle):
81553  case YY_STATE_EOF(St_SecSkip):
81554  yyterminate();
81555 
81556  case YY_END_OF_BUFFER:
81557  {
81558  /* Amount of text matched not including the EOB char. */
81559  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
81560 
81561  /* Undo the effects of YY_DO_BEFORE_ACTION. */
81562  *yy_cp = (yy_hold_char);
81564 
81565  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
81566  {
81567  /* We're scanning a new file or input source. It's
81568  * possible that this happened because the user
81569  * just pointed doctokenizerYYin at a new source and called
81570  * doctokenizerYYlex(). If so, then we have to assure
81571  * consistency between YY_CURRENT_BUFFER and our
81572  * globals. Here is the right place to do so, because
81573  * this is the first action (other than possibly a
81574  * back-up) that will match for the new input source.
81575  */
81576  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
81577  YY_CURRENT_BUFFER_LVALUE->yy_input_file = doctokenizerYYin;
81578  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
81579  }
81580 
81581  /* Note that here we test for yy_c_buf_p "<=" to the position
81582  * of the first EOB in the buffer, since yy_c_buf_p will
81583  * already have been incremented past the NUL character
81584  * (since all states make transitions on EOB to the
81585  * end-of-buffer state). Contrast this with the test
81586  * in input().
81587  */
81588  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
81589  { /* This was really a NUL. */
81590  yy_state_type yy_next_state;
81591 
81592  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
81593 
81594  yy_current_state = yy_get_previous_state( );
81595 
81596  /* Okay, we're now positioned to make the NUL
81597  * transition. We couldn't have
81598  * yy_get_previous_state() go ahead and do it
81599  * for us because it doesn't know how to deal
81600  * with the possibility of jamming (and we don't
81601  * want to build jamming into it because then it
81602  * will run more slowly).
81603  */
81604 
81605  yy_next_state = yy_try_NUL_trans( yy_current_state );
81606 
81608 
81609  if ( yy_next_state )
81610  {
81611  /* Consume the NUL. */
81612  yy_cp = ++(yy_c_buf_p);
81613  yy_current_state = yy_next_state;
81614  goto yy_match;
81615  }
81616 
81617  else
81618  {
81619  yy_cp = (yy_c_buf_p);
81620  goto yy_find_action;
81621  }
81622  }
81623 
81624  else switch ( yy_get_next_buffer( ) )
81625  {
81626  case EOB_ACT_END_OF_FILE:
81627  {
81629 
81630  if ( doctokenizerYYwrap( ) )
81631  {
81632  /* Note: because we've taken care in
81633  * yy_get_next_buffer() to have set up
81634  * doctokenizerYYtext, we can now set up
81635  * yy_c_buf_p so that if some total
81636  * hoser (like flex itself) wants to
81637  * call the scanner after we return the
81638  * YY_NULL, it'll still work - another
81639  * YY_NULL will get returned.
81640  */
81642 
81643  yy_act = YY_STATE_EOF(YY_START);
81644  goto do_action;
81645  }
81646 
81647  else
81648  {
81649  if ( ! (yy_did_buffer_switch_on_eof) )
81650  YY_NEW_FILE;
81651  }
81652  break;
81653  }
81654 
81655  case EOB_ACT_CONTINUE_SCAN:
81656  (yy_c_buf_p) =
81657  (yytext_ptr) + yy_amount_of_matched_text;
81658 
81659  yy_current_state = yy_get_previous_state( );
81660 
81661  yy_cp = (yy_c_buf_p);
81663  goto yy_match;
81664 
81665  case EOB_ACT_LAST_MATCH:
81666  (yy_c_buf_p) =
81667  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
81668 
81669  yy_current_state = yy_get_previous_state( );
81670 
81671  yy_cp = (yy_c_buf_p);
81673  goto yy_find_action;
81674  }
81675  break;
81676  }
81677 
81678  default:
81680  "fatal flex scanner internal error--no action found" );
81681  } /* end of action switch */
81682  } /* end of scanning one token */
static QCString name
Definition: declinfo.cpp:673
static bool markdownSupport
Definition: doxygen.h:153
#define yytext_ptr
#define YY_CURRENT_BUFFER
#define St_Comment
#define yyterminate()
#define St_Pattern
QCString stripWhiteSpace() const
Definition: qcstring.cpp:295
#define St_Para
#define YY_AT_BOL()
The QRegExp class provides pattern matching using regular expressions or wildcards.
Definition: qregexp.h:46
#define St_HtmlOnlyOption
static char * yy_full_match
#define YY_RULE_SETUP
uint length() const
Definition: qcstring.h:195
const char * portable_getenv(const char *variable)
Definition: portable.cpp:317
#define YY_FATAL_ERROR(msg)
static QCString g_secTitle
#define St_ManOnly
#define unput(c)
char & at(uint i) const
Definition: qcstring.h:326
#define YY_SC_TO_UI(c)
#define St_IntRef
#define EOB_ACT_LAST_MATCH
static int yy_did_buffer_switch_on_eof
static yyconst flex_int16_t yy_def[13538]
#define YY_RESTORE_YY_MORE_OFFSET
#define St_HtmlOnly
int doctokenizerYYlineno
#define YY_CURRENT_BUFFER_LVALUE
const bool FALSE
Definition: qglobal.h:370
ParamDir paramDir
Definition: doctokenizer.h:114
QCString sectionId
Definition: doctokenizer.h:89
QCString left(uint len) const
Definition: qcstring.cpp:213
bool stripPrefix(const char *prefix)
Definition: qcstring.cpp:201
static int yy_looking_for_trail_begin
int find(char c, int index=0, bool cs=TRUE) const
Definition: qcstring.cpp:41
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
static QCString g_secLabel
FILE * doctokenizerYYin
#define St_SetScope
static void processSection()
int yy_state_type
Definition: code.cpp:361
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition: qcstring.cpp:95
#define St_Sections
TokenInfo * g_token
static yyconst flex_int16_t yy_accept[10009]
#define St_Text
static QCString g_fileName
#define doctokenizerYYwrap(n)
#define St_SkipTitle
static int yy_n_chars
static QCString stripEmptyLines(const QCString &s)
const double e
#define INITIAL
static SectionInfo::SectionType g_secType
static yy_state_type * yy_state_ptr
register int yy_act
#define St_XRefItem
QCString chars
Definition: doctokenizer.h:107
#define YY_NEW_FILE
#define St_Ref
#define YY_END_OF_BUFFER
static int g_commentState
static bool g_insidePre
static yyconst flex_int16_t yy_acclist[5516]
#define St_File
#define YY_TRAILING_MASK
static char yy_hold_char
#define St_Anchor
#define St_SecSkip
static int g_sharpCount
QCString right(uint len) const
Definition: qcstring.cpp:231
#define St_TitleQ
#define YY_TRAILING_HEAD_MASK
int toInt(bool *ok=0) const
Definition: qcstring.cpp:439
static int yy_full_lp
#define YY_BREAK
register char * yy_cp
#define St_XmlOnly
static yyconst flex_int16_t yy_chk[335945]
#define St_Ref2
#define St_LatexOnly
QCString text
Definition: doctokenizer.h:80
#define St_XRefItem2
#define St_Snippet
#define St_SetScopeEnd
unsigned char YY_CHAR
Definition: code.cpp:357
void warn(const char *file, int line, const char *fmt,...)
Definition: message.cpp:183
static yyconst flex_int32_t yy_meta[84]
static int computeIndent(const char *str, int length)
#define YY_STATE_EOF(state)
#define REJECT
static int * yy_full_state
#define St_SecTitle
QCString mid(uint index, uint len=0xffffffff) const
Definition: qcstring.cpp:246
#define St_Msc
#define St_RtfOnly
static yyconst flex_int32_t yy_rule_can_match_eol[207]
#define St_TitleN
#define BEGIN
static int yy_lp
#define YY_BUFFER_NORMAL
QCString verb
Definition: doctokenizer.h:96
int doctokenizerYYleng
QCString name
Definition: doctokenizer.h:77
#define YY_BUFFER_NEW
#define St_PlantUMLOpt
#define St_TitleA
static const char types[][NUM_HTML_LIST_TYPES]
#define St_Title
#define St_PlantUML
static QCString g_endMarker
static yyconst flex_int32_t yy_ec[256]
#define St_TitleV
#define St_SecLabel2
static int g_autoListLevel
#define EOB_ACT_END_OF_FILE
#define St_Link
#define St_XmlCode
bool isEnumList
Definition: doctokenizer.h:85
#define YY_DO_BEFORE_ACTION
static yyconst flex_int16_t yy_nxt[335945]
#define St_SecLabel1
#define St_Cite
static int yy_get_next_buffer(void)
#define St_DbOnly
bool isEMailAddr
Definition: doctokenizer.h:110
static int yy_start
#define YY_START
#define ECHO
register char * yy_bp
static yyconst flex_int32_t yy_base[13538]
static yy_state_type * yy_state_buf
Q_EXPORT int qstrcmp(const char *str1, const char *str2)
Definition: qcstring.h:95
#define EOB_ACT_CONTINUE_SCAN
#define St_Param
static yy_state_type yy_get_previous_state(void)
std::string nl(std::size_t i=1)
static QCString * s
Definition: config.cpp:1042
#define St_CodeOpt
const bool TRUE
Definition: qglobal.h:371
#define YY_MORE_ADJ
static char * yy_c_buf_p
char * doctokenizerYYtext
#define St_Code
#define St_Verbatim
#define St_Dot
#define ASSERT(x)
Definition: qglobal.h:590
static void handleHtmlTag()
static void yy_fatal_error ( yyconst char  msg[])
static
static void yy_fatal_error ( yyconst char *  msg)
static

Definition at line 82322 of file doctokenizer.cpp.

82323 {
82324  (void) fprintf( stderr, "%s\n", msg );
82325  exit( YY_EXIT_FAILURE );
82326 }
void msg(const char *fmt,...)
Definition: message.cpp:107
#define YY_EXIT_FAILURE
static int yy_get_next_buffer ( void  )
static

Definition at line 81692 of file doctokenizer.cpp.

81693 {
81694  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
81695  register char *source = (yytext_ptr);
81696  register int number_to_move, i;
81697  int ret_val;
81698 
81699  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
81701  "fatal flex scanner internal error--end of buffer missed" );
81702 
81703  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
81704  { /* Don't try to fill the buffer, so this is an EOF. */
81705  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
81706  {
81707  /* We matched a single character, the EOB, so
81708  * treat this as a final EOF.
81709  */
81710  return EOB_ACT_END_OF_FILE;
81711  }
81712 
81713  else
81714  {
81715  /* We matched some text prior to the EOB, first
81716  * process it.
81717  */
81718  return EOB_ACT_LAST_MATCH;
81719  }
81720  }
81721 
81722  /* Try to read more data. */
81723 
81724  /* First move last chars to start of buffer. */
81725  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
81726 
81727  for ( i = 0; i < number_to_move; ++i )
81728  *(dest++) = *(source++);
81729 
81730  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
81731  /* don't do the read, it's not guaranteed to return an EOF,
81732  * just force an EOF
81733  */
81734  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
81735 
81736  else
81737  {
81738  int num_to_read =
81739  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
81740 
81741  while ( num_to_read <= 0 )
81742  { /* Not enough room in the buffer - grow it. */
81743 
81745 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
81746 
81747  }
81748 
81749  if ( num_to_read > YY_READ_BUF_SIZE )
81750  num_to_read = YY_READ_BUF_SIZE;
81751 
81752  /* Read in more data. */
81753  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
81754  (yy_n_chars), (size_t) num_to_read );
81755 
81756  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
81757  }
81758 
81759  if ( (yy_n_chars) == 0 )
81760  {
81761  if ( number_to_move == YY_MORE_ADJ )
81762  {
81763  ret_val = EOB_ACT_END_OF_FILE;
81765  }
81766 
81767  else
81768  {
81769  ret_val = EOB_ACT_LAST_MATCH;
81770  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
81772  }
81773  }
81774 
81775  else
81776  ret_val = EOB_ACT_CONTINUE_SCAN;
81777 
81778  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
81779  /* Extend the array by 50%, plus the number we really need. */
81780  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
81781  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) doctokenizerYYrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
81782  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
81783  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
81784  }
81785 
81786  (yy_n_chars) += number_to_move;
81789 
81790  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
81791 
81792  return ret_val;
81793 }
#define yytext_ptr
#define YY_FATAL_ERROR(msg)
#define YY_BUFFER_EOF_PENDING
#define EOB_ACT_LAST_MATCH
#define YY_CURRENT_BUFFER_LVALUE
void * doctokenizerYYrealloc(void *, yy_size_t)
FILE * doctokenizerYYin
#define YY_INPUT(buf, result, max_size)
static int yy_n_chars
#define YY_END_OF_BUFFER_CHAR
void doctokenizerYYrestart(FILE *input_file)
#define EOB_ACT_END_OF_FILE
#define YY_READ_BUF_SIZE
#define EOB_ACT_CONTINUE_SCAN
size_t yy_size_t
Definition: code.cpp:203
#define YY_MORE_ADJ
static char * yy_c_buf_p
static yy_state_type yy_get_previous_state ( void  )
static

Definition at line 81797 of file doctokenizer.cpp.

81798 {
81799  register yy_state_type yy_current_state;
81800  register char *yy_cp;
81801 
81802  yy_current_state = (yy_start);
81803  yy_current_state += YY_AT_BOL();
81804 
81805  (yy_state_ptr) = (yy_state_buf);
81806  *(yy_state_ptr)++ = yy_current_state;
81807 
81808  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
81809  {
81810  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
81811  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
81812  {
81813  yy_current_state = (int) yy_def[yy_current_state];
81814  if ( yy_current_state >= 10008 )
81815  yy_c = yy_meta[(unsigned int) yy_c];
81816  }
81817  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
81818  *(yy_state_ptr)++ = yy_current_state;
81819  }
81820 
81821  return yy_current_state;
81822 }
#define yytext_ptr
#define YY_AT_BOL()
#define YY_SC_TO_UI(c)
static yyconst flex_int16_t yy_def[13538]
int yy_state_type
Definition: code.cpp:361
static yy_state_type * yy_state_ptr
register char * yy_cp
static yyconst flex_int16_t yy_chk[335945]
unsigned char YY_CHAR
Definition: code.cpp:357
static yyconst flex_int32_t yy_meta[84]
static yyconst flex_int32_t yy_ec[256]
static yyconst flex_int16_t yy_nxt[335945]
static int yy_start
static yyconst flex_int32_t yy_base[13538]
static yy_state_type * yy_state_buf
#define YY_MORE_ADJ
static char * yy_c_buf_p
static int yy_init_globals ( void  )
static

Definition at line 82425 of file doctokenizer.cpp.

82426 {
82427  /* Initialization is the same as for the non-reentrant scanner.
82428  * This function is called from doctokenizerYYlex_destroy(), so don't allocate here.
82429  */
82430 
82431  /* We do not touch doctokenizerYYlineno unless the option is enabled. */
82433 
82434  (yy_buffer_stack) = 0;
82435  (yy_buffer_stack_top) = 0;
82436  (yy_buffer_stack_max) = 0;
82437  (yy_c_buf_p) = (char *) 0;
82438  (yy_init) = 0;
82439  (yy_start) = 0;
82440 
82441  (yy_state_buf) = 0;
82442  (yy_state_ptr) = 0;
82443  (yy_full_match) = 0;
82444  (yy_lp) = 0;
82445 
82446 /* Defined in main.c */
82447 #ifdef YY_STDINIT
82448  doctokenizerYYin = stdin;
82450 #else
82451  doctokenizerYYin = (FILE *) 0;
82452  doctokenizerYYout = (FILE *) 0;
82453 #endif
82454 
82455  /* For future reference: Set errno on error, since we are called by
82456  * doctokenizerYYlex_init()
82457  */
82458  return 0;
82459 }
FILE * doctokenizerYYout
static char * yy_full_match
int doctokenizerYYlineno
FILE * doctokenizerYYin
static yy_state_type * yy_state_ptr
static YY_BUFFER_STATE * yy_buffer_stack
static size_t yy_buffer_stack_top
static int yy_lp
static int yy_init
static int yy_start
static yy_state_type * yy_state_buf
static size_t yy_buffer_stack_max
static char * yy_c_buf_p
static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state)
static

Definition at line 81829 of file doctokenizer.cpp.

81830 {
81831  register int yy_is_jam;
81832 
81833  register YY_CHAR yy_c = 1;
81834  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
81835  {
81836  yy_current_state = (int) yy_def[yy_current_state];
81837  if ( yy_current_state >= 10008 )
81838  yy_c = yy_meta[(unsigned int) yy_c];
81839  }
81840  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
81841  yy_is_jam = (yy_current_state == 10007);
81842  if ( ! yy_is_jam )
81843  *(yy_state_ptr)++ = yy_current_state;
81844 
81845  return yy_is_jam ? 0 : yy_current_state;
81846 }
static yyconst flex_int16_t yy_def[13538]
static yy_state_type * yy_state_ptr
static yyconst flex_int16_t yy_chk[335945]
unsigned char YY_CHAR
Definition: code.cpp:357
static yyconst flex_int32_t yy_meta[84]
static yyconst flex_int16_t yy_nxt[335945]
static yyconst flex_int32_t yy_base[13538]
static int yyread ( char *  buf,
int  max_size 
)
static

Definition at line 79422 of file doctokenizer.cpp.

79423 {
79424  int c=0;
79425  const char *src=g_inputString+g_inputPos;
79426  while ( c < max_size && *src ) *buf++ = *src++, c++;
79427  g_inputPos+=c;
79428  return c;
79429 }
static const char * g_inputString
static int g_inputPos
static void yyunput ( int  c,
char *  buf_ptr 
)
static
static void yyunput ( int  c,
register char *  yy_bp 
)
static

Definition at line 81848 of file doctokenizer.cpp.

81849 {
81850  register char *yy_cp;
81851 
81852  yy_cp = (yy_c_buf_p);
81853 
81854  /* undo effects of setting up doctokenizerYYtext */
81855  *yy_cp = (yy_hold_char);
81856 
81857  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
81858  { /* need to shift things up to make room */
81859  /* +2 for EOB chars. */
81860  register int number_to_move = (yy_n_chars) + 2;
81861  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
81862  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
81863  register char *source =
81864  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
81865 
81866  while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
81867  *--dest = *--source;
81868 
81869  yy_cp += (int) (dest - source);
81870  yy_bp += (int) (dest - source);
81871  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
81872  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
81873 
81874  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
81875  YY_FATAL_ERROR( "flex scanner push-back overflow" );
81876  }
81877 
81878  *--yy_cp = (char) c;
81879 
81880  if ( c == '\n' ){
81882  }
81883 
81884  (yytext_ptr) = yy_bp;
81885  (yy_hold_char) = *yy_cp;
81886  (yy_c_buf_p) = yy_cp;
81887 }
#define yytext_ptr
#define YY_FATAL_ERROR(msg)
int doctokenizerYYlineno
#define YY_CURRENT_BUFFER_LVALUE
if(!(yy_init))
static int yy_n_chars
static char yy_hold_char
register char * yy_cp
register char * yy_bp
static char * yy_c_buf_p

Variable Documentation

int doctokenizerYY_flex_debug = 0

Definition at line 79086 of file doctokenizer.cpp.

FILE * doctokenizerYYin = (FILE *) 0

Definition at line 372 of file doctokenizer.cpp.

int doctokenizerYYleng

Definition at line 307 of file doctokenizer.cpp.

int doctokenizerYYlineno = 1

Definition at line 378 of file doctokenizer.cpp.

FILE * doctokenizerYYout = (FILE *) 0

Definition at line 372 of file doctokenizer.cpp.

char * doctokenizerYYtext

Definition at line 79110 of file doctokenizer.cpp.

int g_autoListLevel
static

Definition at line 79170 of file doctokenizer.cpp.

int g_commentState
static

Definition at line 79155 of file doctokenizer.cpp.

Definition* g_definition
static

Definition at line 79164 of file doctokenizer.cpp.

QCString g_endMarker
static

Definition at line 79169 of file doctokenizer.cpp.

QCString g_fileName
static

Definition at line 79159 of file doctokenizer.cpp.

int g_inputPos = 0
static

Definition at line 79157 of file doctokenizer.cpp.

const char* g_inputString
static

Definition at line 79158 of file doctokenizer.cpp.

bool g_insidePre
static

Definition at line 79160 of file doctokenizer.cpp.

QStack<DocLexerContext> g_lexerStack
static

Definition at line 79182 of file doctokenizer.cpp.

MemberGroup* g_memberGroup
static

Definition at line 79165 of file doctokenizer.cpp.

QCString g_secLabel
static

Definition at line 79166 of file doctokenizer.cpp.

QCString g_secTitle
static

Definition at line 79167 of file doctokenizer.cpp.

SectionInfo::SectionType g_secType
static

Definition at line 79168 of file doctokenizer.cpp.

int g_sharpCount =0
static

Definition at line 79161 of file doctokenizer.cpp.

TokenInfo* g_token = 0

Definition at line 79156 of file doctokenizer.cpp.

yyconst flex_int16_t yy_accept[10009]
static

Definition at line 1018 of file doctokenizer.cpp.

yyconst flex_int16_t yy_acclist[5516]
static

Definition at line 407 of file doctokenizer.cpp.

register int yy_act

Definition at line 79705 of file doctokenizer.cpp.

yyconst flex_int32_t yy_base[13538]
static

Definition at line 2168 of file doctokenizer.cpp.

register char * yy_bp

Definition at line 79704 of file doctokenizer.cpp.

YY_BUFFER_STATE* yy_buffer_stack = 0
static

Stack as an array.

Definition at line 287 of file doctokenizer.cpp.

size_t yy_buffer_stack_max = 0
static

capacity of stack.

Definition at line 286 of file doctokenizer.cpp.

size_t yy_buffer_stack_top = 0
static

index of top of stack.

Definition at line 285 of file doctokenizer.cpp.

char* yy_c_buf_p = (char *) 0
static

Definition at line 310 of file doctokenizer.cpp.

yyconst flex_int16_t yy_chk[335945]
static

Definition at line 42112 of file doctokenizer.cpp.

register char* yy_cp

Definition at line 79704 of file doctokenizer.cpp.

YY_DECL
Initial value:
{
register yy_state_type yy_current_state
int yy_state_type
Definition: code.cpp:361

The main scanner function which does all the work.

Definition at line 79702 of file doctokenizer.cpp.

yyconst flex_int16_t yy_def[13538]
static

Definition at line 3661 of file doctokenizer.cpp.

int yy_did_buffer_switch_on_eof
static

Definition at line 317 of file doctokenizer.cpp.

yyconst flex_int32_t yy_ec[256]
static

Definition at line 2123 of file doctokenizer.cpp.

int yy_full_lp
static

Definition at line 79092 of file doctokenizer.cpp.

char* yy_full_match
static

Definition at line 79089 of file doctokenizer.cpp.

int* yy_full_state
static

Definition at line 79093 of file doctokenizer.cpp.

char yy_hold_char
static

Definition at line 305 of file doctokenizer.cpp.

int yy_init = 0
static

Definition at line 311 of file doctokenizer.cpp.

int yy_looking_for_trail_begin = 0
static

Definition at line 79091 of file doctokenizer.cpp.

int yy_lp
static

Definition at line 79090 of file doctokenizer.cpp.

yyconst flex_int32_t yy_meta[84]
static
Initial value:
=
{ 0,
1, 2, 3, 4, 2, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 20, 21, 22, 23, 24, 25, 26, 27, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
29, 30, 29, 31, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 32, 33,
34, 35, 36
}

Definition at line 2155 of file doctokenizer.cpp.

int yy_n_chars
static

Definition at line 306 of file doctokenizer.cpp.

yyconst flex_int16_t yy_nxt[335945]
static

Definition at line 5154 of file doctokenizer.cpp.

yyconst flex_int32_t yy_rule_can_match_eol[207]
static
Initial value:
=
{ 0,
0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1,
1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1,
0, 0, 1, 1, 0, 0, 0, }

Definition at line 79071 of file doctokenizer.cpp.

int yy_start = 0
static

Definition at line 312 of file doctokenizer.cpp.

yy_state_type* yy_state_buf =0
static

Definition at line 79088 of file doctokenizer.cpp.

yy_state_type * yy_state_ptr =0
static

Definition at line 79088 of file doctokenizer.cpp.