tclscanner.cpp File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qlist.h>
#include <qmap.h>
#include <qarray.h>
#include <qstack.h>
#include <qregexp.h>
#include <qfile.h>
#include <qdict.h>
#include "entry.h"
#include "message.h"
#include "config.h"
#include "doxygen.h"
#include "util.h"
#include "defargs.h"
#include "language.h"
#include "commentscan.h"
#include "pre.h"
#include "tclscanner.h"
#include "outputlist.h"
#include "membername.h"
#include "searchindex.h"
#include "commentcnv.h"
#include "bufstr.h"
#include "portable.h"
#include "arguments.h"
#include "namespacedef.h"
#include "filedef.h"

Go to the source code of this file.

Classes
struct	yy_buffer_state
struct	yy_trans_info
struct	tcl_scan
	Structure containing information about current scan context. More...

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   tclscannerYY_create_buffer
#define	yy_delete_buffer   tclscannerYY_delete_buffer
#define	yy_flex_debug   tclscannerYY_flex_debug
#define	yy_init_buffer   tclscannerYY_init_buffer
#define	yy_flush_buffer   tclscannerYY_flush_buffer
#define	yy_load_buffer_state   tclscannerYY_load_buffer_state
#define	yy_switch_to_buffer   tclscannerYY_switch_to_buffer
#define	yyin   tclscannerYYin
#define	yyleng   tclscannerYYleng
#define	yylex   tclscannerYYlex
#define	yylineno   tclscannerYYlineno
#define	yyout   tclscannerYYout
#define	yyrestart   tclscannerYYrestart
#define	yytext   tclscannerYYtext
#define	yywrap   tclscannerYYwrap
#define	yyalloc   tclscannerYYalloc
#define	yyrealloc   tclscannerYYrealloc
#define	yyfree   tclscannerYYfree
#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   tclscannerYYrestart(tclscannerYYin )
#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   tclscannerYY_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   tclscannerYY_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	tclscannerYYwrap(n)   1
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   tclscannerYYtext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   55
#define	YY_END_OF_BUFFER   56
#define	REJECT   reject_used_but_not_detected
#define	yymore()   ((yy_more_flag) = 1)
#define	YY_MORE_ADJ   (yy_more_len)
#define	YY_RESTORE_YY_MORE_OFFSET
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	MAX_INCLUDE_DEPTH   10
#define	tcl_err
	Application error. More...
#define	tcl_war
	Application warning. More...
#define	tcl_inf   if (0) printf("--- %.4d %d@%d: ",__LINE__,tclscannerYYlineno,yy_start_stack_ptr) && printf
	Application message. More...
#define	D   if (0) printf("--- %.4d %d@%d: %s\n",__LINE__,tclscannerYYlineno,yy_start_stack_ptr,tclscannerYYtext);
	Debug message. More...
#define	CONST   const
#define	UCHAR   (unsigned char)
#define	TCL_ERROR   1
#define	TCL_OK   0
#define	ckalloc   malloc
#define	ckfree   free
#define	TclCopyAndCollapse(size, src, dest)   memcpy(dest,src,size); *(dest+size)=0
#define	YY_INPUT(buf, result, max_size)   result=yyread(buf,max_size);
#define	INITIAL   0
#define	ERROR   1
#define	TOP   2
#define	COMMAND   3
#define	WORD   4
#define	COMMENT   5
#define	COMMENT_NL   6
#define	COMMENT_CODE   7
#define	COMMENT_VERB   8
#define	COMMENTLINE   9
#define	COMMENTLINE_NL   10
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( tclscannerYYtext, tclscannerYYleng, 1, tclscannerYYout )) {} } 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 tclscannerYYlex (void)
#define	YY_USER_ACTION
#define	YY_BREAK   break;
#define	YY_RULE_SETUP   YY_USER_ACTION
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type

Functions
void	tclscannerYYrestart (FILE *input_file)
void	tclscannerYY_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	tclscannerYY_create_buffer (FILE *file, int size)
void	tclscannerYY_delete_buffer (YY_BUFFER_STATE b)
void	tclscannerYY_flush_buffer (YY_BUFFER_STATE b)
void	tclscannerYYpush_buffer_state (YY_BUFFER_STATE new_buffer)
void	tclscannerYYpop_buffer_state (void)
static void	tclscannerYYensure_buffer_stack (void)
static void	tclscannerYY_load_buffer_state (void)
static void	tclscannerYY_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	tclscannerYY_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	tclscannerYY_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	tclscannerYY_scan_bytes (yyconst char *bytes, int len)
void *	tclscannerYYalloc (yy_size_t)
void *	tclscannerYYrealloc (void *, yy_size_t)
void	tclscannerYYfree (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[])
int	TclFindElement (CONST char *list, int listLength, CONST char **elementPtr, CONST char **nextPtr, int *sizePtr, int *bracePtr)
int	Tcl_SplitList (CONST char *list, int *argcPtr, CONST char ***argvPtr)
void	tcl_split_list (QString &str, QStringList &list)
static int	yyread (char *buf, int max_size)
static tcl_scan *	tcl_scan_start (char type, QString content, QCString ns, Entry *entry_cl, Entry *entry_fn)
	Start new scan context for given 'content'. More...
static void	tcl_scan_end ()
	Close current scan context. More...
static void	tcl_comment (int what, const char *text)
	Handling of comment parsing. More...
static void	tcl_word (int what, const char *text)
	Handling of word parsing. More...
static void	tcl_command (int what, const char *text)
Entry *	tcl_entry_new ()
	Create new entry. More...
void	tcl_protection (Entry *entry)
	Set protection level. More...
static void	tcl_name (const QCString &ns0, const QCString &name0, QCString &ns, QCString &name)
	Check name. More...
static void	tcl_name_SnippetAware (const QCString &ns0, const QCString &name0, QCString &ns, QCString &name)
	Check name. Strip namespace qualifiers from name0 if inside inlined code segment. More...
Entry *	tcl_entry_namespace (const QCString ns)
Entry *	tcl_entry_class (const QCString cl)
static int	tcl_keyword (QCString str)
	Check for keywords. More...
static void	tcl_font_end ()
	End codifying with special font class. More...
static void	tcl_codify (const char *s, const char *str)
	Codify 'str' with special font class 's'. More...
static void	tcl_codify_cmd (const char *s, int i)
static tcl_scan *	tcl_codify_token (tcl_scan *myScan, const QCString type, const QCString string)
	codify a string token More...
static int	yy_init_globals (void)
int	tclscannerYYlex_destroy (void)
int	tclscannerYYget_debug (void)
void	tclscannerYYset_debug (int debug_flag)
YY_EXTRA_TYPE	tclscannerYYget_extra (void)
void	tclscannerYYset_extra (YY_EXTRA_TYPE user_defined)
FILE *	tclscannerYYget_in (void)
void	tclscannerYYset_in (FILE *in_str)
FILE *	tclscannerYYget_out (void)
void	tclscannerYYset_out (FILE *out_str)
int	tclscannerYYget_leng (void)
char *	tclscannerYYget_text (void)
int	tclscannerYYget_lineno (void)
void	tclscannerYYset_lineno (int line_number)
static void	yyunput (int c, char *buf_ptr)
static void	yy_push_state (int new_state)
static void	yy_pop_state (void)
static int	yy_top_state (void)
int	tclscannerYYlex (void)
	if (!(yy_init))
	while (1)
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (yyconst char *msg)
static void	tcl_command_ARGLIST (QString &arglist)
	Parse given arglist . More...
static void	tcl_codify_link (QCString name)
	Create link. More...
static tcl_scan *	tcl_command_ARG (tcl_scan *myScan, unsigned int i, bool ignoreOutermostBraces)
	scan general argument for brackets More...
static void	tcl_command_EVAL ()
	Handle internal tcl commands. More...
static void	tcl_command_SWITCH ()
	Handle internal tcl commands. More...
static void	tcl_command_CATCH ()
	Handle internal tcl commands. More...
static void	tcl_command_IF (QStringList type)
	Handle internal tcl commands. More...
static void	tcl_command_FOR ()
	Handle internal tcl commands. More...
static void	tcl_command_FOREACH ()
	! Handle internal tcl commands. More...
static void	tcl_command_WHILE ()
	! Handle internal tcl commands. More...
static void	tcl_command_OTHER ()
	Handle all other commands. More...
static void	tcl_command_PROC ()
	Handle proc statements. More...
static void	tcl_command_METHOD ()
	Handle itcl::body statements and oo::define method and method inside itcl::class statements. More...
static void	tcl_command_CONSTRUCTOR ()
	Handle constructor statements inside class definitions. More...
static void	tcl_command_DESTRUCTOR ()
	Handle destructor statements inside class definitions. More...
static void	tcl_command_NAMESPACE ()
	Handle namespace statements. More...
static void	tcl_command_ITCL_CLASS ()
	Handle itcl::class statements. More...
static void	tcl_command_OO_CLASS ()
	Handle oo::class statements. More...
static void	tcl_command_OO_DEFINE ()
	Handle oo::define statements. More...
static void	tcl_command_VARIABLE (int inclass)
	Handle variable statements. More...
static void	tcl_init ()
	Common initializations. More...
static void	tcl_parse (const QCString ns, const QCString cls)
	Start parsing. More...
void	tclDummy ()

Variables
int	tclscannerYYleng
FILE *	tclscannerYYin = (FILE *) 0
FILE *	tclscannerYYout = (FILE *) 0
static size_t	yy_buffer_stack_top = 0
static size_t	yy_buffer_stack_max = 0
static YY_BUFFER_STATE *	yy_buffer_stack = 0
static char	yy_hold_char
static int	yy_n_chars
static char *	yy_c_buf_p = (char *) 0
static int	yy_init = 0
static int	yy_start = 0
static int	yy_did_buffer_switch_on_eof
int	tclscannerYYlineno = 1
char *	tclscannerYYtext
static yyconst flex_int16_t	yy_accept [179]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [41]
static yyconst flex_int16_t	yy_base [204]
static yyconst flex_int16_t	yy_def [204]
static yyconst flex_int16_t	yy_nxt [656]
static yyconst flex_int16_t	yy_chk [656]
static yyconst flex_int32_t	yy_rule_can_match_eol [56]
static yy_state_type	yy_last_accepting_state
static char *	yy_last_accepting_cpos
int	tclscannerYY_flex_debug = 0
static int	yy_more_flag = 0
static int	yy_more_len = 0
struct {
CodeOutputInterface *   code
int   code_line
int   code_linenumbers
const char *   code_font
bool   config_autobrief
QMap< QString, QString >   config_subst
QCString   input_string
int   input_position
QCString   file_name
ParserInterface *   this_parser
int   command
int   comment
int   brace_level
int   bracket_level
int   bracket_quote
char   word_is
int   line_comment
int   line_commentline
int   line_command
int   line_body0
int   line_body1
QCString   string_command
QCString   string_commentline
QCString   string_commentcodify
QCString   string_comment
QCString   string_last
QCString   string
Entry *   entry_main
Entry *   entry_file
Entry *   entry_current
Entry *   entry_inside
QStringList   list_commandwords
QList< tcl_scan >   scan
QAsciiDict< Entry >   ns
QAsciiDict< Entry >   cl
QAsciiDict< Entry >   fn
QList< Entry >   entry
Protection   protection
MemberDef *   memberdef
bool   collectXRefs
}	tcl
static int	yy_start_stack_ptr = 0
static int	yy_start_stack_depth = 0
static int *	yy_start_stack = NULL
	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 tclscanner.cpp.

#define ckalloc   malloc

Definition at line 786 of file tclscanner.cpp.

#define ckfree   free

Definition at line 787 of file tclscanner.cpp.

#define COMMAND   3

Definition at line 1494 of file tclscanner.cpp.

#define COMMENT   5

Definition at line 1496 of file tclscanner.cpp.

#define COMMENT_CODE   7

Definition at line 1498 of file tclscanner.cpp.

#define COMMENT_NL   6

Definition at line 1497 of file tclscanner.cpp.

#define COMMENT_VERB   8

Definition at line 1499 of file tclscanner.cpp.

#define COMMENTLINE   9

Definition at line 1500 of file tclscanner.cpp.

#define COMMENTLINE_NL   10

Definition at line 1501 of file tclscanner.cpp.

#define CONST   const

Definition at line 782 of file tclscanner.cpp.

#define D   if (0) printf("--- %.4d %d@%d: %s\n",__LINE__,tclscannerYYlineno,yy_start_stack_ptr,tclscannerYYtext);

Debug message.

Definition at line 775 of file tclscanner.cpp.

#define ECHO   do { if (fwrite( tclscannerYYtext, tclscannerYYleng, 1, tclscannerYYout )) {} } while (0)

Definition at line 1598 of file tclscanner.cpp.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file tclscanner.cpp.

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file tclscanner.cpp.

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file tclscanner.cpp.

#define ERROR   1

Definition at line 1492 of file tclscanner.cpp.

#define FLEX_BETA

Definition at line 33 of file tclscanner.cpp.

#define FLEX_SCANNER

Definition at line 28 of file tclscanner.cpp.

#define FLEXINT_H

Definition at line 49 of file tclscanner.cpp.

#define INITIAL   0

Definition at line 1491 of file tclscanner.cpp.

#define INT16_MAX   (32767)

Definition at line 92 of file tclscanner.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file tclscanner.cpp.

#define INT32_MAX   (2147483647)

Definition at line 95 of file tclscanner.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file tclscanner.cpp.

#define INT8_MAX   (127)

Definition at line 89 of file tclscanner.cpp.

#define INT8_MIN   (-128)

Definition at line 80 of file tclscanner.cpp.

#define MAX_INCLUDE_DEPTH   10

Definition at line 756 of file tclscanner.cpp.

#define REJECT   reject_used_but_not_detected

Definition at line 693 of file tclscanner.cpp.

#define tcl_err

Value:

printf("Error %d %s() at line %d! ",__LINE__,tcl.file_name.data(),tclscannerYYlineno); \
  yy_push_state(ERROR); \
  yyless(0); \
  printf

Application error.

Definition at line 759 of file tclscanner.cpp.

#define TCL_ERROR   1

Definition at line 784 of file tclscanner.cpp.

#define tcl_inf   if (0) printf("--- %.4d %d@%d: ",__LINE__,tclscannerYYlineno,yy_start_stack_ptr) && printf

Application message.

Definition at line 771 of file tclscanner.cpp.

#define TCL_OK   0

Definition at line 785 of file tclscanner.cpp.

#define tcl_war

Value:

printf("Warning %d %s() at line %d: ",__LINE__,tcl.file_name.data(),tclscannerYYlineno); \
  printf

Application warning.

Definition at line 766 of file tclscanner.cpp.

#define TclCopyAndCollapse	(		size,
			src,
			dest
	)		memcpy(dest,src,size); *(dest+size)=0

Definition at line 788 of file tclscanner.cpp.

#define tclscannerYYwrap

(

n

)

1

Definition at line 367 of file tclscanner.cpp.

#define TOP   2

Definition at line 1493 of file tclscanner.cpp.

#define UCHAR   (unsigned char)

Definition at line 783 of file tclscanner.cpp.

#define UINT16_MAX   (65535U)

Definition at line 101 of file tclscanner.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file tclscanner.cpp.

#define UINT8_MAX   (255U)

Definition at line 98 of file tclscanner.cpp.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 212 of file tclscanner.cpp.

#define WORD   4

Definition at line 1495 of file tclscanner.cpp.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 363 of file tclscanner.cpp.

#define YY_BREAK   break;

Definition at line 1677 of file tclscanner.cpp.

#define YY_BUF_SIZE   16384

Definition at line 163 of file tclscanner.cpp.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 279 of file tclscanner.cpp.

#define YY_BUFFER_NEW   0

Definition at line 267 of file tclscanner.cpp.

#define YY_BUFFER_NORMAL   1

Definition at line 268 of file tclscanner.cpp.

#define yy_create_buffer   tclscannerYY_create_buffer

Definition at line 9 of file tclscanner.cpp.

#define YY_CURRENT_BUFFER

Value:

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

Definition at line 295 of file tclscanner.cpp.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 302 of file tclscanner.cpp.

#define YY_DECL   int tclscannerYYlex (void)

Definition at line 1665 of file tclscanner.cpp.

#define YY_DECL_IS_OURS   1

Definition at line 1661 of file tclscanner.cpp.

#define yy_delete_buffer   tclscannerYY_delete_buffer

Definition at line 10 of file tclscanner.cpp.

#define YY_DO_BEFORE_ACTION

Value:

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

Definition at line 391 of file tclscanner.cpp.

#define YY_END_OF_BUFFER   56

Definition at line 400 of file tclscanner.cpp.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 159 of file tclscanner.cpp.

#define YY_EXIT_FAILURE   2

Definition at line 3200 of file tclscanner.cpp.

#define YY_EXTRA_TYPE   void *

Definition at line 1512 of file tclscanner.cpp.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 1652 of file tclscanner.cpp.

#define yy_flex_debug   tclscannerYY_flex_debug

Definition at line 11 of file tclscanner.cpp.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file tclscanner.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file tclscanner.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file tclscanner.cpp.

#define yy_flush_buffer   tclscannerYY_flush_buffer

Definition at line 13 of file tclscanner.cpp.

#define YY_FLUSH_BUFFER   tclscannerYY_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 331 of file tclscanner.cpp.

#define yy_init_buffer   tclscannerYY_init_buffer

Definition at line 12 of file tclscanner.cpp.

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

Definition at line 1477 of file tclscanner.cpp.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file tclscanner.cpp.

#define YY_LESS_LINENO

(

n

)

Value:

do { \
                int yyl;\
                for ( yyl = n; yyl < tclscannerYYleng; ++yyl )\
                    if ( tclscannerYYtext[yyl] == '\n' )\
                        --tclscannerYYlineno;\
            }while(0)

Definition at line 190 of file tclscanner.cpp.

#define yy_load_buffer_state   tclscannerYY_load_buffer_state

Definition at line 14 of file tclscanner.cpp.

#define YY_MORE_ADJ   (yy_more_len)

Definition at line 697 of file tclscanner.cpp.

#define yy_new_buffer   tclscannerYY_create_buffer

Definition at line 341 of file tclscanner.cpp.

#define YY_NEW_FILE   tclscannerYYrestart(tclscannerYYin )

Definition at line 157 of file tclscanner.cpp.

#define YY_NO_INPUT   1

Definition at line 753 of file tclscanner.cpp.

#define YY_NO_UNISTD_H   1

Definition at line 754 of file tclscanner.cpp.

#define YY_NULL   0

Definition at line 131 of file tclscanner.cpp.

#define YY_NUM_RULES   55

Definition at line 399 of file tclscanner.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 1590 of file tclscanner.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 698 of file tclscanner.cpp.

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 1680 of file tclscanner.cpp.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 138 of file tclscanner.cpp.

#define yy_set_bol

(

at_bol

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        tclscannerYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            tclscannerYY_create_buffer(tclscannerYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 353 of file tclscanner.cpp.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        tclscannerYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            tclscannerYY_create_buffer(tclscannerYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 343 of file tclscanner.cpp.

#define YY_SKIP_YYWRAP

Definition at line 368 of file tclscanner.cpp.

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

Definition at line 150 of file tclscanner.cpp.

#define YY_START_STACK_INCR   25

Definition at line 1647 of file tclscanner.cpp.

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

Definition at line 168 of file tclscanner.cpp.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 154 of file tclscanner.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 220 of file tclscanner.cpp.

#define yy_switch_to_buffer   tclscannerYY_switch_to_buffer

Definition at line 15 of file tclscanner.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 171 of file tclscanner.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 215 of file tclscanner.cpp.

#define YY_USER_ACTION

Definition at line 1672 of file tclscanner.cpp.

#define yyalloc   tclscannerYYalloc

Definition at line 24 of file tclscanner.cpp.

#define yyconst

Definition at line 127 of file tclscanner.cpp.

#define yyfree   tclscannerYYfree

Definition at line 26 of file tclscanner.cpp.

#define yyin   tclscannerYYin

Definition at line 16 of file tclscanner.cpp.

#define yyleng   tclscannerYYleng

Definition at line 17 of file tclscanner.cpp.

#define yyless

(

n

)

Value:

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

Definition at line 3212 of file tclscanner.cpp.

#define yyless

(

n

)

Value:

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

Definition at line 3212 of file tclscanner.cpp.

#define yylex   tclscannerYYlex

Definition at line 18 of file tclscanner.cpp.

#define yylineno   tclscannerYYlineno

Definition at line 19 of file tclscanner.cpp.

#define yymore

(

)

((yy_more_flag) = 1)

Definition at line 696 of file tclscanner.cpp.

#define yyout   tclscannerYYout

Definition at line 20 of file tclscanner.cpp.

#define yyrealloc   tclscannerYYrealloc

Definition at line 25 of file tclscanner.cpp.

#define yyrestart   tclscannerYYrestart

Definition at line 21 of file tclscanner.cpp.

#define YYSTATE   YY_START

Definition at line 151 of file tclscanner.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 3413 of file tclscanner.cpp.

#define yyterminate

(

)

return YY_NULL

Definition at line 1642 of file tclscanner.cpp.

#define yytext   tclscannerYYtext

Definition at line 22 of file tclscanner.cpp.

#define yytext_ptr   tclscannerYYtext

Definition at line 381 of file tclscanner.cpp.

#define yywrap   tclscannerYYwrap

Definition at line 23 of file tclscanner.cpp.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 71 of file tclscanner.cpp.

typedef int flex_int32_t

Definition at line 72 of file tclscanner.cpp.

typedef signed char flex_int8_t

Definition at line 70 of file tclscanner.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file tclscanner.cpp.

typedef unsigned int flex_uint32_t

Definition at line 75 of file tclscanner.cpp.

typedef unsigned char flex_uint8_t

Definition at line 73 of file tclscanner.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 172 of file tclscanner.cpp.

typedef unsigned char YY_CHAR

Definition at line 370 of file tclscanner.cpp.

typedef size_t yy_size_t

Definition at line 216 of file tclscanner.cpp.

typedef int yy_state_type

Definition at line 374 of file tclscanner.cpp.

Function Documentation

if

(

!

yy_init

)

Definition at line 1695 of file tclscanner.cpp.

                {
                (yy_init) = 1;

#ifdef YY_USER_INIT
                YY_USER_INIT;
#endif

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

                if ( ! tclscannerYYin )
                        tclscannerYYin = stdin;

                if ( ! tclscannerYYout )
                        tclscannerYYout = stdout;

                if ( ! YY_CURRENT_BUFFER ) {
                        tclscannerYYensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
                                tclscannerYY_create_buffer(tclscannerYYin,YY_BUF_SIZE );
                }

                tclscannerYY_load_buffer_state( );
                }

static void tcl_codify ( const char *  s, const char *  str  )

static

Codify 'str' with special font class 's'.

Definition at line 1359 of file tclscanner.cpp.

{
  if (!tcl.code || !str) return;
  if (s && qstrcmp(s,"NULL")!=0)
  {
    tcl_font_end();
    tcl.code->startFontClass(s);
    tcl.code_font=s;
  }
  char *tmp = (char *) malloc(strlen(str)+1);
  strcpy(tmp, str);
  char *p=tmp,*sp=p;
  char c;
  bool done=FALSE;
  while (!done)
  {
    sp=p;
    while ((c=*p++) && c!='\n') {}
    if (c=='\n')
    {
      tcl.code_line++;
      *(p-1)='\0'; // Dimitri: is this really needed?
                   // wtschueller: As far as I can see: yes.
                   // Deletes that \n that would produce ugly source listings otherwise.
                   // However, there may exist more sophisticated solutions.
      tcl.code->codify(sp);
      if (tcl.code_font)
      {
        tcl.code->endFontClass();
      }
      tcl.code->endCodeLine();
      tcl.code->startCodeLine(tcl.code_linenumbers);
      if (tcl.code_linenumbers)
      {
        tcl.code->writeLineNumber(0,0,0,tcl.code_line);
      }
      if (tcl.code_font)
      {
        tcl.code->startFontClass(tcl.code_font);
      }
    }
    else
    {
      tcl.code->codify(sp);
      done=TRUE;
    }
  }
  free(tmp);
  tcl_font_end();
}

static void tcl_codify_cmd ( const char *  s, int  i  )

static

Definition at line 1436 of file tclscanner.cpp.

{
  tcl_codify(s,(*tcl.list_commandwords.at(i)).utf8());
}

static void tcl_codify_link ( QCString  name )

static

Create link.

Definition at line 3939 of file tclscanner.cpp.

{
  if (tcl.code == NULL || name.isEmpty()) return;
  static int init=0;
  static QAsciiDict<MemberDef> fn;
  if (init==0) 
  {
    init=1;
    MemberNameSDict::Iterator mni(*Doxygen::memberNameSDict);
    MemberNameSDict::Iterator fni(*Doxygen::functionNameSDict);
    MemberName *mn=0;
    MemberDef *md;
    for (mni.toFirst();(mn=mni.current());++mni) 
    {
      MemberNameIterator mi(*mn);
      for (mi.toFirst();(md=mi.current());++mi) 
      {
        fn.insert(md->qualifiedName(),md);
      }
    }
    for (fni.toFirst();(mn=fni.current());++fni) 
    {
      MemberNameIterator fi(*mn);
      for (fi.toFirst();(md=fi.current());++fi) 
      {
        fn.insert(md->qualifiedName(),md);
      }
    }
  }
  MemberDef *myDef;
  QCString myName=name; 
  if (name.mid(0,2)=="::") // fully qualified global command
  {
    myName = myName.mid(2);
    myDef = fn.find(myName);
  }
  else // not qualified name
  {
    QCString myName1=myName; 
    myDef = NULL;
    myName1 = tcl.scan.at(0)->ns;
    if (myName1 == " " || myName1 == "")
    {
      myName1 = myName;
    }
    else
    {
      myName1 = myName1 + "::" + myName;
    }
    myDef = fn.find(myName1); // search namespace command
    if (myDef == NULL)
    {
      myDef = fn.find(myName); // search global command
    }
  }
  if (myDef != NULL) // documented command
  {
    tcl.code->writeCodeLink(myDef->getReference().data(),
                myDef->getOutputFileBase().data(),
                myDef->anchor().data(),
                name,
                myDef->qualifiedName().data());
    if (tcl.memberdef)
    {
        myDef->addSourceReferencedBy(tcl.memberdef);
        tcl.memberdef->addSourceReferences(myDef);
    } else {
      Entry* callerEntry;
      unsigned int i;
      // walk the stack of scan contexts and find the enclosing method or proc
      for (i=0;i<tcl.scan.count();i++)
      {
        callerEntry=tcl.scan.at(i)->entry_scan;
        if (callerEntry->mtype==Method && !callerEntry->name.isEmpty())
        {
          break;
        }
      }
      if (i<tcl.scan.count())
      {
        // enclosing method found
        QCString callerName = callerEntry->name;
        if (callerName.mid(0,2)=="::") // fully qualified global command
        {
          callerName = callerName.mid(2);
        }
        else
        {
          if (!(tcl.scan.at(0)->ns.stripWhiteSpace().isEmpty()))
          {
            callerName = tcl.scan.at(0)->ns + "::" + callerEntry->name;
          }
        }
        MemberDef *callerDef=NULL;
        callerDef = fn.find(callerName);
        if (callerDef!=NULL && myDef!= NULL && tcl.collectXRefs)
        {
          addDocCrossReference(callerDef,myDef);
        }
      }
    }
  }
  else if (tcl_keyword(myName)) // check keyword
  {
    tcl_codify("keyword",name);
  }
  else
  {
    tcl_codify(NULL,name); // something else
  }
  
}

static tcl_scan* tcl_codify_token ( tcl_scan *  myScan, const QCString  type, const QCString  string  )

static

codify a string token

Definition at line 1446 of file tclscanner.cpp.

{
    if (myScan != NULL)
    {
      if (type != NULL)
      {
        myScan->after << type << string;
      }
      else
      {
        myScan->after << "NULL" << string;
      }
    }
    else
    {
      if (qstrcmp(type, "script") == 0)
      {
        myScan = tcl.scan.at(0);
        myScan = tcl_scan_start('?', string,
                myScan->ns, myScan->entry_cl, myScan->entry_fn);
      }
      else
      {
        tcl_codify((const char*)type, string);
      }
    }
    return myScan;
}

static void tcl_command ( int  what, const char *  text  )

static

Handling of command parsing. what=0 -> ... what=1 -> ... what=-1 -> ...

Definition at line 4779 of file tclscanner.cpp.

{
  int myLine=0;
  if (what==0)
  {
    tcl.scan.at(0)->line1=tclscannerYYlineno;// current line in scan context
    tcl.line_body0=tclscannerYYlineno;// start line of command
tcl_inf("<- %s\n",text);
    yy_push_state(COMMAND);
    tcl.list_commandwords.clear();
    tcl.string_command="";
    tcl.string_last="";
    tcl.command=1;
    return;
  }
  else if (what==1)
  {
    if (tcl.string_last.length())
    {
      tcl.list_commandwords.append(tcl.string_last);
      tcl.string_last="";
    }
    if (text) 
    {
      tcl.list_commandwords.append(text);
    }
    return;
  }
  else if (what!=-1)
  {// should not happen
    tcl_err("what %d\n",what);
    return;
  }
  QCString myText = text;
tcl_inf("->\n");
  if (tcl.command==0)
  {
    return; //TODO check on inside comment
  }
  if (tcl.string_last != "")
  {// get last word
    tcl.list_commandwords.append(tcl.string_last);
    tcl.string_last="";
  }
  yy_pop_state();

  // check command
  QCString myStr = (*tcl.list_commandwords.at(0)).utf8();
  tcl_scan *myScanBackup=tcl.scan.at(0);
  int myLevel = 0;
  Protection myProt = tcl.protection;

  if (tcl.list_commandwords.count() < 3)
  {
    tcl_command_OTHER();
    goto command_end;
  }
  // remove leading "::" and apply TCL_SUBST
  if (myStr.left(2)=="::") myStr = myStr.mid(2);
  if (tcl.config_subst.contains(myStr))
  {
    myStr=tcl.config_subst[myStr].utf8();
  }
  if (myStr=="private")
  {
    tcl.protection = Private;
    myLevel = 1;
  }
  else if (myStr=="protected")
  {
    tcl.protection = Protected;
    myLevel = 1;
  }
  else if (myStr=="public")
  {
    tcl.protection = Public;
    myLevel = 1;
  }
  if (myLevel)
  {
    tcl_codify_cmd("keyword",0);
    tcl_codify_cmd(NULL,1);
    tcl.list_commandwords.remove(tcl.list_commandwords.at(1));
    tcl.list_commandwords.remove(tcl.list_commandwords.at(0));
    if (tcl.list_commandwords.count()==1)
    {
      tcl_scan *myScan = tcl.scan.at(0);
      myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(0),
        myScan->ns,myScan->entry_cl,myScan->entry_fn);
      myProt = tcl.protection;
      goto command_end;
    }
    myStr       = (*tcl.list_commandwords.at(0)).utf8();
    // remove leading "::" and apply TCL_SUBST
    if (myStr.left(2)=="::") myStr = myStr.mid(2);
    if (tcl.config_subst.contains(myStr))
    {
      myStr=tcl.config_subst[myStr].utf8();
    }
  }
  if (myStr=="proc")
  {
    if (tcl.list_commandwords.count() == 5)
    {// itcl::proc
      tcl.list_commandwords.append("");
      tcl.list_commandwords.append("");
    }
    if (tcl.list_commandwords.count() != 7) {myLine=__LINE__;goto command_warn;}
    tcl_command_PROC();
    goto command_end;
  }
  if (myStr=="method")
  {
    if (tcl.list_commandwords.count() == 5)
    {// itcl::method
      tcl.list_commandwords.append("");
      tcl.list_commandwords.append("");
    }
    if (tcl.list_commandwords.count() != 7) {myLine=__LINE__;goto command_warn;}
    tcl_command_METHOD();
    goto command_end;
  }
  if (myStr=="constructor")
  {
    if (tcl.list_commandwords.count() != 5) {myLine=__LINE__;goto command_warn;}
    tcl_command_CONSTRUCTOR();
    goto command_end;
  }
  if (myStr=="destructor")
  {
    if (tcl.list_commandwords.count() != 3) {myLine=__LINE__;goto command_warn;}
    tcl_command_DESTRUCTOR();
    goto command_end;
  }
  if (myStr=="namespace")
  {
    if ((*tcl.list_commandwords.at(2)).utf8()=="eval")
    {
      if (tcl.list_commandwords.count() < 7) {myLine=__LINE__;goto command_warn;}
      tcl_command_NAMESPACE();
      goto command_end;
    }
    tcl_command_OTHER();
    goto command_end;
  }
  if (myStr=="itcl::class")
  {
    if (tcl.list_commandwords.count() != 5) {myLine=__LINE__;goto command_warn;}
    tcl_command_ITCL_CLASS();
    goto command_end;
  }
  if (myStr=="itcl::body")
  {
    if (tcl.list_commandwords.count() != 7) {myLine=__LINE__;goto command_warn;}
    tcl_command_METHOD();
    goto command_end;
  }
  if (myStr=="oo::class")
  {
    if ((*tcl.list_commandwords.at(2)).utf8()=="create")
    {
      if (tcl.list_commandwords.count() != 7) {myLine=__LINE__;goto command_warn;}
      tcl_command_OO_CLASS();
      goto command_end;
    }
    tcl_command_OTHER();
    goto command_end;
  }
  if (myStr=="oo::define")
  {
    if (tcl.list_commandwords.count() < 5) {myLine=__LINE__;goto command_warn;}
    tcl_command_OO_DEFINE();
    goto command_end;
  }
  if (myStr=="variable")
  {
    if (tcl.list_commandwords.count() < 3) {myLine=__LINE__;goto command_warn;}
    if (tcl.scan.at(0)->entry_fn == NULL)
    {// only parsed outside functions
      tcl_command_VARIABLE(tcl.scan.at(0)->entry_cl && tcl.scan.at(0)->entry_cl->name!="");
      goto command_end;
    }
  }
  if (myStr=="common")
  {
    if (tcl.list_commandwords.count() < 3) {myLine=__LINE__;goto command_warn;}
    if (tcl.scan.at(0)->entry_fn == NULL)
    {// only parsed outside functions
      tcl_command_VARIABLE(0);
      goto command_end;
    }
  }
  if (myStr=="inherit" || myStr=="superclass")
  {
    if (tcl.list_commandwords.count() < 3) {myLine=__LINE__;goto command_warn;}
    if (tcl.scan.at(0)->entry_cl && tcl.scan.at(0)->entry_cl->name!="")
    {
      for (unsigned int i = 2; i < tcl.list_commandwords.count(); i = i + 2)
      {
        tcl.scan.at(0)->entry_cl->extends->append(new BaseInfo((*tcl.list_commandwords.at(i)).utf8(),Public,Normal));
      }
    }
    goto command_end;
  }
  /*
   * Start of internal tcl keywords
   * Ready: switch, eval, catch, if, for, foreach, while
   */
  if (myStr=="switch")
  {
    if (tcl.list_commandwords.count() < 5) {myLine=__LINE__;goto command_warn;}
    tcl_command_SWITCH();
    goto command_end;
  }
  if (myStr=="eval")
  {
    if (tcl.list_commandwords.count() < 3) {myLine=__LINE__;goto command_warn;}
    tcl_command_EVAL();
    goto command_end;
  }
  if (myStr=="catch")
  {
    if (tcl.list_commandwords.count() < 3) {myLine=__LINE__;goto command_warn;}
    tcl_command_CATCH();
    goto command_end;
  }
  if (myStr=="for")
  {
    if (tcl.list_commandwords.count() != 9) {myLine=__LINE__;goto command_warn;}
    tcl_command_FOR();
    goto command_end;
  }
  if (myStr=="foreach")
  {
    if (tcl.list_commandwords.count() < 7 || tcl.list_commandwords.count()%2==0) {myLine=__LINE__;goto command_warn;}
    tcl_command_FOREACH();
    goto command_end;
  }
  /*
if expr1 ?then? body1 elseif expr2 ?then? body2 elseif ... ?else?  ?bodyN?
  */
  if (myStr=="if" && tcl.list_commandwords.count() > 4)
  {
    QStringList myType;
    myType << "keyword" << "NULL" << "expr" << "NULL";
    char myState='x';// last word: e'x'pr 't'hen 'b'ody 'e'lse else'i'f..
    for (unsigned int i = 4; i < tcl.list_commandwords.count(); i = i + 2)
    {
      QCString myStr=(*tcl.list_commandwords.at(i)).utf8();
      if (myState=='x')
      {
        if (myStr=="then") 
        {
          myState='t';
          myType << "keyword" << "NULL";
        }
        else
        {
          myState='b';
          myType << "script" << "NULL";
        }
      }
      else if (myState=='t')
      {
        myState='b';
        myType << "script" << "NULL";
      }
      else if (myState=='b')
      {
        if (myStr=="elseif") {
          myState='i';
          myType << "keyword" << "NULL";
        }
        else if (myStr=="else" && i==tcl.list_commandwords.count()-3)
        {
          myState = 'b';
          myType << "keyword" << "NULL" << "script";
          i = tcl.list_commandwords.count();
        }
        else if (i==tcl.list_commandwords.count()-1)
        {
          myState = 'b';
          myType << "script";
          i = tcl.list_commandwords.count();
        }
        else
        {
          myLine=__LINE__;goto command_warn;
        }
      }
      else if (myState=='i')
      {
        myState='x';
        myType << "expr" << "NULL";
      }
    }
    if (myState != 'b') {myLine=__LINE__;goto command_warn;}
    tcl_command_IF(myType);
    goto command_end;
  }
  if (myStr=="while")
  {
    if (tcl.list_commandwords.count() != 5) {myLine=__LINE__;goto command_warn;}
    tcl_command_WHILE();
    goto command_end;
  }
  tcl_command_OTHER();
  goto command_end;
  command_warn:// print warning message because of wrong used syntax
    tcl_war("%d count=%d: %s\n",myLine,tcl.list_commandwords.count(),tcl.list_commandwords.join(" ").ascii());
    tcl_command_OTHER();
  command_end:// add remaining text to current context
    if (!myText.isEmpty())
    {
      if(myScanBackup==tcl.scan.at(0))
      {
        tcl_codify("comment",myText);  
      }
      else
      {
        tcl.scan.at(0)->after << "comment" << myText;
      }
    }
    tcl.list_commandwords.clear();
    tcl.command = 0;
    tcl.protection = myProt;
}

static tcl_scan* tcl_command_ARG ( tcl_scan *  myScan, unsigned int  i, bool  ignoreOutermostBraces  )

static

scan general argument for brackets

Definition at line 4058 of file tclscanner.cpp.

{
  QCString myName;
  bool insideQuotes=false;
  unsigned int insideBrackets=0;
  unsigned int insideBraces=0;
  myName = (*tcl.list_commandwords.at(i)).utf8();
  if (i%2 != 0)
  {
    // handle white space
    myScan = tcl_codify_token(myScan, "NULL", myName);
  }
  else
  {
    QCString myStr = "";
    unsigned int j;
    for (j=0;j<myName.length();j++)
    {
      QChar c = myName[j];
      bool backslashed = false;
      if (j>0)
      {
        backslashed = myName[j-1]=='\\';
      }
      // this is a state machine
      // input is c
      // internal state is myScan and insideXXX
      // these are the transitions:
      if (c=='[' && !backslashed && insideBraces==0)
      {
        insideBrackets++;
      }
      if (c==']' && !backslashed && insideBraces==0 && insideBrackets>0)
      {
        insideBrackets--;
      }
      if (c=='{' && !backslashed && !insideQuotes && !(ignoreOutermostBraces && j==0))
      {
        insideBraces++;
      }
      if (c=='}' && !backslashed && !insideQuotes && insideBraces>0)
      {
        insideBraces--;
      }
      if (c=='"' && !backslashed && insideBraces==0)
      {
        insideQuotes=!insideQuotes;
      }
      // all output, depending on state and input
      if (c=='[' && !backslashed && insideBrackets==1 && insideBraces==0)
      {
        // the first opening bracket, output what we have so far
        myStr+=c;
        myScan = tcl_codify_token(myScan, "NULL", myStr);
        myStr="";
      }
      else if (c==']' && !backslashed && insideBrackets==0 && insideBraces==0)
      {
        // the last closing bracket, start recursion, switch to deferred
        myScan = tcl_codify_token(myScan, "script", myStr);
        myStr="";
        myStr+=c;
      }
      else
      {
         myStr+=c;
      }
    }
    if (i == 0 && myScan == NULL)
    {
      tcl_codify_link(myStr);
    }
    else
    {
      myScan = tcl_codify_token(myScan, "NULL", myStr);
    }
  }
  return (myScan);
}

static void tcl_command_ARGLIST ( QString &  arglist )

static

Parse given arglist .

Definition at line 3899 of file tclscanner.cpp.

{
D
  Argument *myArg;
  QStringList myArgs;
  QString myArglist="";

  if (!tcl.entry_current->argList)
  {
    tcl.entry_current->argList=new ArgumentList;
  }
  tcl_split_list(arglist,myArgs);
  for (uint i=0;i<myArgs.count();i++)
  {
    QStringList myArgs1;
    myArg=new Argument;

    tcl_split_list(*myArgs.at(i),myArgs1);
    if (myArgs1.count()==2)
    {
      myArg->name= (*myArgs1.at(0)).utf8();
      myArg->defval= (*myArgs1.at(1)).utf8();
      if (myArg->defval.isEmpty())
      {
        myArg->defval = " ";
      }
      myArglist += "?" + QCString(myArg->name) + "? ";
    }
    else
    {
      myArg->name= (*myArgs.at(i)).utf8();
      myArglist += QString(myArg->name) + " ";
    }
    tcl.entry_current->argList->append(myArg);
  }
  arglist = myArglist;
  tcl.entry_current->args = arglist.utf8();
}

static void tcl_command_CATCH ( )

static

Handle internal tcl commands.

Definition at line 4282 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword", 0);
  tcl_codify_cmd(NULL, 1);
  tcl_scan *myScan = tcl.scan.at(0);
  myScan = tcl_scan_start('?', *tcl.list_commandwords.at(2),
        myScan->ns, myScan->entry_cl, myScan->entry_fn);
  for (unsigned int i = 3; i < tcl.list_commandwords.count(); i++)
  {
    myScan = tcl_command_ARG(myScan, i, false);
  }
}

static void tcl_command_CONSTRUCTOR ( )

static

Handle constructor statements inside class definitions.

Definition at line 4485 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntryCl, *myEntry;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd(NULL,2);
  tcl_codify_cmd(NULL,3);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(0)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myEntryCl = tcl_entry_class(myNs);
  }
  else
  {
    myNs = myScan->ns;
    myEntryCl = myScan->entry_cl;
  }
  tcl.entry_current->section = Entry::FUNCTION_SEC;
  tcl.entry_current->mtype = Method;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl_protection(tcl.entry_current);
  tcl_command_ARGLIST(*tcl.list_commandwords.at(2));
  if (myEntryCl) myEntryCl->addSubEntry(tcl.entry_current);
  myEntry = tcl.entry_current;
  tcl.fn.insert(myName,myEntry);
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(4),
        myNs, myEntryCl, myEntry);
}

static void tcl_command_DESTRUCTOR ( )

static

Handle destructor statements inside class definitions.

Definition at line 4522 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntryCl, *myEntry;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(0)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myEntryCl = tcl_entry_class(myNs);
  }
  else
  {
    myNs = myScan->ns;
    myEntryCl = myScan->entry_cl;
  }
  tcl.entry_current->section = Entry::FUNCTION_SEC;
  tcl.entry_current->mtype = Method;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl_protection(tcl.entry_current);
  myEntryCl->addSubEntry(tcl.entry_current);
  myEntry = tcl.entry_current;
  tcl.fn.insert(myName,myEntry);
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(2),
        myNs, myEntryCl, myEntry);
}

static void tcl_command_EVAL ( )

static

Handle internal tcl commands.

Definition at line 4140 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword", 0);
  tcl_scan *myScan = tcl.scan.at(0);
  QCString myString = "";
  // we simply rescan the line without the eval
  // we include leading whitespace because tcl_scan_start will examine
  // the first char. If it finds a bracket it will assume one expression in brackets.
  // Example: eval [list set] [list NotInvoked] [Invoked NotInvoked]
  for (unsigned int i = 1; i < tcl.list_commandwords.count(); i++)
  {
    myString += (*tcl.list_commandwords.at(i)).utf8();
  }
  myScan = tcl_scan_start('?', myString,
        myScan->ns, myScan->entry_cl, myScan->entry_fn);
}

static void tcl_command_FOR ( )

static

Handle internal tcl commands.

Definition at line 4328 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_scan *myScan=tcl.scan.at(0);
  myScan = tcl_scan_start('?',*tcl.list_commandwords.at(2),
        myScan->ns,myScan->entry_cl,myScan->entry_fn);
  myScan->after << "NULL" << tcl.list_commandwords[3];
  myScan = tcl_command_ARG(myScan, 4, true);
  myScan->after << "NULL" << tcl.list_commandwords[5];
  myScan->after << "script" << tcl.list_commandwords[6];
  myScan->after << "NULL" << tcl.list_commandwords[7];
  myScan->after << "script" << tcl.list_commandwords[8];
}

static void tcl_command_FOREACH ( )

static

! Handle internal tcl commands.

Definition at line 4347 of file tclscanner.cpp.

{
D
  unsigned int i;
  tcl_scan *myScan=NULL;
  tcl_codify_cmd("keyword",0);
  for (i = 1;i<tcl.list_commandwords.count()-1;i++)
  {
    myScan = tcl_command_ARG(myScan, i, false);
  }
  if (myScan!=0)
  {
    myScan->after << "script" << tcl.list_commandwords[tcl.list_commandwords.count()-1];
  }
  else
  {
    myScan=tcl.scan.at(0);
    myScan = tcl_scan_start('?',*tcl.list_commandwords.at(tcl.list_commandwords.count()-1),
          myScan->ns,myScan->entry_cl,myScan->entry_fn);
  }
}

static void tcl_command_IF ( QStringList  type )

static

Handle internal tcl commands.

Definition at line 4298 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_scan *myScan = NULL;
  myScan = tcl_command_ARG(myScan, 2, true);
  for (unsigned int i = 3;i<tcl.list_commandwords.count();i++)
  {
    if (type[i] == "expr")
    {
      myScan = tcl_command_ARG(myScan, i, true);
    }
    else
    {
      if (myScan!=0)
      {
        myScan->after << type[i] << tcl.list_commandwords[i];
      }
      else
      {
        myScan=tcl.scan.at(0);
        myScan = tcl_scan_start('?',*tcl.list_commandwords.at(i),
              myScan->ns,myScan->entry_cl,myScan->entry_fn);
      }
    }
  }
}

static void tcl_command_ITCL_CLASS ( )

static

Handle itcl::class statements.

Definition at line 4595 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntryCl;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd("NULL",2);
  tcl_codify_cmd("NULL",3);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(2)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myName = myNs+"::"+myName;
  }
  tcl.entry_current->section = Entry::CLASS_SEC;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl.entry_main->addSubEntry(tcl.entry_current);
  tcl.cl.insert(myName,tcl.entry_current);
  myEntryCl = tcl.entry_current;
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(4),
        myName, myEntryCl, NULL);
}

static void tcl_command_METHOD ( )

static

Handle itcl::body statements and oo::define method and method inside itcl::class statements.

Definition at line 4443 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntryCl, *myEntry;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd(NULL,2);
  tcl_codify_cmd(NULL,3);
  tcl_codify_cmd(NULL,4);
  tcl_codify_cmd(NULL,5);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(2)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myEntryCl = tcl_entry_class(myNs);
  }
  else
  {
    myNs = myScan->ns;
    myEntryCl = myScan->entry_cl;
  }
  // needed in case of more then one definition p.e. itcl::method and itcl::body
  // see also bug #
  tcl.fn.remove(myName);
  tcl.entry_current->section = Entry::FUNCTION_SEC;
  tcl.entry_current->mtype = Method;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl_protection(tcl.entry_current);
  tcl_command_ARGLIST(*tcl.list_commandwords.at(4));
  myEntryCl->addSubEntry(tcl.entry_current);
  tcl.fn.insert(myName,tcl.entry_current);
  myEntry = tcl.entry_current;
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(6),
        myNs, myEntryCl, myEntry);
}

static void tcl_command_NAMESPACE ( )

static

Handle namespace statements.

Definition at line 4556 of file tclscanner.cpp.

{
D
  QCString myNs, myName, myStr;
  //Entry *myEntryNs=NULL;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd("keyword",2);
  tcl_codify_cmd(NULL,3);
  tcl_codify_cmd(NULL,4);
  tcl_codify_cmd(NULL,5);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(4)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myName = myNs+"::"+myName;
  }
  tcl.entry_current->section = Entry::NAMESPACE_SEC;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl.entry_main->addSubEntry(tcl.entry_current);
  tcl.ns.insert(myName,tcl.entry_current);
  //myEntryNs = tcl.entry_current;
  myStr = (*tcl.list_commandwords.at(6)).utf8();
  if (tcl.list_commandwords.count() > 7)
  {
    for (uint i=7;i<tcl.list_commandwords.count();i++)
    {
      myStr.append((*tcl.list_commandwords.at(i)).utf8());
    }
    tcl.word_is=' ';
  }
  myScan = tcl_scan_start(tcl.word_is,myStr, myName, NULL, NULL);
}

static void tcl_command_OO_CLASS ( )

static

Handle oo::class statements.

Definition at line 4624 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  //Entry *myEntryNs;
  Entry *myEntryCl;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd("NULL",2);
  tcl_codify_cmd("NULL",3);
  tcl_codify_cmd("NULL",4);
  tcl_codify_cmd("NULL",5);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(4)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myName = myNs+"::"+myName;
  }
  tcl.entry_current->section = Entry::CLASS_SEC;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl.entry_main->addSubEntry(tcl.entry_current);
  //myEntryNs = tcl_entry_namespace(myName);
  tcl.cl.insert(myName,tcl.entry_current);
  myEntryCl = tcl.entry_current;
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(6),
        myName, myEntryCl, NULL);
}

static void tcl_command_OO_DEFINE ( )

static

Handle oo::define statements.

Definition at line 4657 of file tclscanner.cpp.

{
D
  QCString myNs, myName, myStr;
  Entry *myEntryCl;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd("NULL",2);
  tcl_codify_cmd("NULL",3);
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(2)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myName = myNs+"::"+myName;
  }
  myEntryCl = tcl_entry_class(myName);
  myStr = (*tcl.list_commandwords.at(4)).utf8();
  //
  // special cases first
  // oo::define classname method methodname args script
  // oo::define classname constructor argList bodyScript
  // oo::define classname destructor bodyScript
  unsigned int n =tcl.list_commandwords.count();
  if ((myStr == "method"      && n == 11) ||
      (myStr == "constructor" && n == 9) ||
      (myStr == "destructor"  && n == 7))
  {
    for (unsigned int i = 4; i < n-1; i++)
    {
      tcl_codify_cmd("NULL",i);
    }
    Entry *myEntry;
    QCString myMethod;
    tcl_name(myScan->ns,(*tcl.list_commandwords.at(n==11?6:4)).utf8(),myNs,myMethod);
    // code snippet taken from tcl_command_METHOD()/tcl_command_CONSTRUCTOR
    tcl.fn.remove(myMethod);
    tcl.entry_current->section = Entry::FUNCTION_SEC;
    tcl.entry_current->mtype = Method;
    tcl.entry_current->name = myMethod;
    tcl.entry_current->startLine = tcl.line_command;
    tcl.entry_current->bodyLine = tcl.line_body0;
    tcl.entry_current->endBodyLine = tcl.line_body1;
    tcl_protection(tcl.entry_current);
    if (n==11)
    {
      tcl_command_ARGLIST(*tcl.list_commandwords.at(8));
    }
    else if (n==9)
    {
      tcl_command_ARGLIST(*tcl.list_commandwords.at(6));
    }
    if (myEntryCl) myEntryCl->addSubEntry(tcl.entry_current);
    tcl.fn.insert(myMethod,tcl.entry_current);
    myEntry = tcl.entry_current;
    myScan = tcl_scan_start('?',*tcl.list_commandwords.at(n-1),
          myNs, myEntryCl, myEntry);
  }
  else
  {
    // The general case
    // Simply concat all arguments into a script.
    // Note: all documentation collected just before the
    // oo::define command is lost
    if (tcl.list_commandwords.count() > 5)
    {
      for (uint i=5;i<tcl.list_commandwords.count();i++)
      {
        myStr.append((*tcl.list_commandwords.at(i)).utf8());
      }
      tcl.word_is=' ';
    }
    myScan = tcl_scan_start(tcl.word_is,myStr,myName,myEntryCl,NULL);
  }
}

static void tcl_command_OTHER ( )

static

Handle all other commands.

Definition at line 4393 of file tclscanner.cpp.

{
  tcl_scan *myScan=NULL;
  for (unsigned int i=0; i< tcl.list_commandwords.count(); i++)
  {
    myScan = tcl_command_ARG(myScan, i, false);
  }
}

static void tcl_command_PROC ( )

static

Handle proc statements.

Definition at line 4403 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntryNs;
  Entry *myEntry;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_codify_cmd(NULL,2);
  tcl_codify_cmd(NULL,3);
  tcl_codify_cmd(NULL,4);
  tcl_codify_cmd(NULL,5);
  tcl_name_SnippetAware(myScan->ns,(*tcl.list_commandwords.at(2)).utf8(),myNs,myName);
  if (myNs.length())
  {
    myEntryNs = tcl_entry_namespace(myNs);
  }
  else
  {
    myEntryNs = tcl_entry_namespace(myScan->ns);
  }
  //why not needed here? tcl.fn.remove(myName);
  tcl.entry_current->section = Entry::FUNCTION_SEC;
  tcl.entry_current->mtype = Method;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl_protection(tcl.entry_current);
  tcl_command_ARGLIST(*tcl.list_commandwords.at(4));
  myEntryNs->addSubEntry(tcl.entry_current);
  myEntry = tcl.entry_current;
  tcl.fn.insert(myName,myEntry);
  myScan = tcl_scan_start(tcl.word_is,*tcl.list_commandwords.at(6),
        myEntryNs->name,NULL,myEntry);
}

static void tcl_command_SWITCH ( )

static

Handle internal tcl commands.

Definition at line 4161 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_scan *myScan=NULL;
  unsigned int i;
  QCString token;
  // first: find the last option token
  unsigned int lastOptionIndex = 0;
  for (i = 2; i<tcl.list_commandwords.count(); i += 2)
  {
    token = (*tcl.list_commandwords.at(i)).utf8();
    if (token == "--")
    {
      lastOptionIndex = i;
      break;
    }
    if (token[0] == '-' && i - lastOptionIndex == 2)
    {
      // options start with dash and should form a continuous chain
      lastOptionIndex = i;
    }
  }
  // second: eat up options
  for (i = 2; i <= lastOptionIndex; i++)
  {
    myScan = tcl_command_ARG(myScan, i, false);
  }
  // third: how many tokens are left?
  if (tcl.list_commandwords.count() - lastOptionIndex == 5)
  {
    //printf("syntax: switch ?options? string {pattern body ?pattern body ...?}\n");
    myScan = tcl_command_ARG(myScan, lastOptionIndex + 1, false);
    myScan = tcl_command_ARG(myScan, lastOptionIndex + 2, false);
    myScan = tcl_command_ARG(myScan, lastOptionIndex + 3, false);
    // walk trough the list step by step
    // this way we can preserve whitespace
    bool inBraces = false;
    bool nextIsPattern = true;
    int size;
    const char *elem;
    const char *next;
    token = (*tcl.list_commandwords.at(lastOptionIndex + 4)).utf8();
    if (token[0] == '{')
    {
      inBraces = true;
      token = token.mid(1, token.length() - 2);
      myScan = tcl_codify_token(myScan, "NULL", QCString("{"));
    }
    // ToDo: check if multibyte chars are handled correctly
    while (token.length() > 0)
    {
      TclFindElement((const char*)token, token.length(), &elem, &next, &size, NULL);
      //printf("%s\nstart=%d, elem=%d, next=%d, size=%d, brace=%d\n",
      //        (const char*) token, (const char*) token, elem, next, size, brace);
      //
      // handle leading whitespace/opening brace/double quotes
      if (elem - token > 0)
      {
        myScan = tcl_codify_token(myScan, "NULL", token.left(elem - token));
      }
      // handle actual element without braces/double quotes
      if (nextIsPattern)
      {
        myScan = tcl_codify_token(myScan, "NULL", token.mid(elem - token,size));
        //printf("pattern=%s\n",(const char*) token.mid(elem - token, size));
      }
      else {
        myScan = tcl_codify_token(myScan, "script", token.mid(elem - token, size));
        //printf("script =%s\n", (const char*) token.mid(elem - token, size));
      }
      // handle trailing whitespace/closing brace/double quotes
      if (next - elem - size > 0)
      {
        myScan = tcl_codify_token(myScan, "NULL", token.mid(elem - token + size, next - elem - size));
      }
      nextIsPattern = !nextIsPattern;
      token = token.mid(next - token);
    }
    if (inBraces)
    {
      myScan = tcl_codify_token(myScan, "NULL", QCString("}"));
    }
    if (!nextIsPattern)
    {
      tcl_war("Invalid switch syntax: last token is not a list of even elements.\n");
      //tcl_war("%s\n", tcl.list_commandwords.join(" ").ascii());
    }
  }
  else if ((tcl.list_commandwords.count() - lastOptionIndex > 6) &&
           ((tcl.list_commandwords.count() - lastOptionIndex-3) % 4 == 0))
  {
    //printf("detected: switch ?options? string pattern body ?pattern body ...?\n");
    myScan = tcl_command_ARG(myScan, lastOptionIndex + 1, false);
    myScan = tcl_command_ARG(myScan, lastOptionIndex + 2, false);
    //printf("value=%s\n",(const char*) (*tcl.list_commandwords.at(lastOptionIndex + 2)).utf8());
    for (i = lastOptionIndex + 3; i < tcl.list_commandwords.count(); i += 4)
    {
      myScan = tcl_command_ARG(myScan, i + 0, false); // whitespace
      myScan = tcl_command_ARG(myScan, i + 1, false); // pattern
      myScan = tcl_command_ARG(myScan, i + 2, false); // whitespace
      myScan = tcl_codify_token(myScan, "script", (*tcl.list_commandwords.at(i+3)).utf8());  // script
      //printf("pattern=%s\n",(const char*) (*tcl.list_commandwords.at(i+1)).utf8());
      //printf("script=%s\n",(const char*) (*tcl.list_commandwords.at(i+3)).utf8());
    }
  }
  else
  {
    // not properly detected syntax
    tcl_war("Invalid switch syntax: %d options followed by %d tokens.\n",
            lastOptionIndex / 2, (tcl.list_commandwords.count() - 1) / 2 - lastOptionIndex / 2);
    for (i = lastOptionIndex + 1; i <= tcl.list_commandwords.count(); i++)
    {
      myScan = tcl_command_ARG(myScan, i, false);
    }
  }
}

static void tcl_command_VARIABLE ( int  inclass )

static

Handle variable statements.

Definition at line 4734 of file tclscanner.cpp.

{
D
  QCString myNs, myName;
  Entry *myEntry;
  tcl_scan *myScan = tcl.scan.at(0);

  tcl_codify_cmd("keyword",0);
  for (unsigned int i=1; i< tcl.list_commandwords.count(); i++)
  {
    tcl_codify_cmd(NULL,i);
  }
  tcl_name(myScan->ns,(*tcl.list_commandwords.at(2)).utf8(),myNs,myName);
  if (myNs.length())
  {// qualified variables go into namespace
    myEntry = tcl_entry_namespace(myNs);
    tcl.entry_current->stat = true;
  }
  else
  {
    if (inclass)
    {
      myEntry = myScan->entry_cl;
      tcl.entry_current->stat = false;
    }
    else
    {
      myEntry = tcl_entry_namespace(myScan->ns);
      tcl.entry_current->stat = true;
    }
  }
  tcl.entry_current->section = Entry::VARIABLE_SEC;
  tcl.entry_current->name = myName;
  tcl.entry_current->startLine = tcl.line_command;
  tcl.entry_current->bodyLine = tcl.line_body0;
  tcl.entry_current->endBodyLine = tcl.line_body1;
  tcl_protection(tcl.entry_current);
  myEntry->addSubEntry(tcl.entry_current);
  tcl.entry_current = tcl_entry_new();
}

static void tcl_command_WHILE ( )

static

! Handle internal tcl commands.

Definition at line 4371 of file tclscanner.cpp.

{
D
  tcl_codify_cmd("keyword",0);
  tcl_codify_cmd(NULL,1);
  tcl_scan *myScan = NULL;
  myScan = tcl_command_ARG(myScan, 2, true);
  myScan = tcl_command_ARG(myScan, 3, false);
  if (myScan!=0)
  {
    myScan->after << "script" << tcl.list_commandwords[4];
  }
  else
  {
  myScan=tcl.scan.at(0);
  myScan = tcl_scan_start('?',*tcl.list_commandwords.at(4),
        myScan->ns,myScan->entry_cl,myScan->entry_fn);
  }
}

static void tcl_comment ( int  what, const char *  text  )

static

Handling of comment parsing.

Definition at line 3729 of file tclscanner.cpp.

{
  if (what==0)
  { // begin of comment
    if (tcl.comment)
    {
      tcl_err("comment in comment\n");
      return;
    }
    yy_push_state(COMMENT);
tcl_inf("<- %s\n",text);
    tcl.string_comment="";
    tcl.comment=0;
  }
  else if (what==1)
  { // start new comment
    if (tcl.comment)
    {
      tcl_comment(99,""); // inbody
    }
    tcl.string_comment=text;
    tcl.comment=1;
  }
  else if (what==2)
  { // add to comment
    if (tcl.comment)
    {
      tcl.string_comment+=text;
    }
  }
  else if (what==-1 || what == -2)
  { // end of comment without/with command
    if (tcl.comment)
    {
      tcl.string_last=tcl.string_comment;
      tcl_comment(100+what,"");
    }
    else
    {
      tcl.string_last = "";
tcl_inf("-> %s\n",(const char *)tcl.string_comment);
    }
    yy_pop_state();
    tcl.string_comment="";
    tcl.comment=0;
  }
  else if (what==98 || what==99)
  { // 98=new 99=inbody
    if (tcl.this_parser && tcl.string_comment.length())
    {
tcl_inf("-> %s\n",(const char *)tcl.string_comment);
      int myPos=0;
      bool myNew=0;
      int myLine=tcl.line_comment;
      BufStr myI(1024);
      BufStr myO(1024);
      Protection myProt=tcl.protection;

      // resolve ALIASES
      myI.addArray("/*!",3);
      myI.addArray(tcl.string_comment.data(),tcl.string_comment.length());
      myI.addArray("*/",2);
      convertCppComments(&myI,&myO,tcl.file_name);
      myO.dropFromStart(3);
      myO.shrink(myO.curPos()-2);
      myO.addChar('\0');
      QCString myDoc = myO.data();
      if (what==99)
      { // inbody comment file or namespace or class or proc/method
        int myPos0;
        int myLine0;
        Entry myEntry0; // used to test parsing
        Entry *myEntry;

        Entry *myEntry1=NULL;
        if (tcl.scan.at(0)->entry_fn)
        {
          myEntry1=tcl.scan.at(0)->entry_fn;
        }
        else if (tcl.scan.at(0)->entry_cl)
        {
          myEntry1=tcl.scan.at(0)->entry_cl;
        }

        myPos0=myPos;
        myLine0=myLine;
        while (parseCommentBlock(tcl.this_parser, &myEntry0, myDoc, tcl.file_name,
          myLine, FALSE, tcl.config_autobrief, FALSE, myProt, myPos, myNew))
        {
          if (myNew)
          { // we need a new entry in this case
            myNew=0;
            myEntry = tcl_entry_new();
            parseCommentBlock(tcl.this_parser, myEntry, myDoc, tcl.file_name,
              myLine0, FALSE, tcl.config_autobrief, FALSE, myProt, myPos0, myNew);
            tcl.entry_inside->addSubEntry(myEntry);
          }
          else
          { // we can add to current entry in this case
            if (!myEntry1)
            {
              myEntry1=tcl_entry_namespace(tcl.scan.at(0)->ns);
            }
            parseCommentBlock(tcl.this_parser, myEntry1, myDoc, tcl.file_name,
              myLine0, FALSE, tcl.config_autobrief, FALSE, myProt, myPos0, myNew);
          }
          myPos0=myPos;
          myLine0=myLine;
        }
        if (myNew)
        { // we need a new entry
          myNew=0;
          myEntry = tcl_entry_new();
          parseCommentBlock(tcl.this_parser, myEntry, myDoc, tcl.file_name,
            myLine0, FALSE, tcl.config_autobrief, FALSE, myProt, myPos0, myNew);
          tcl.entry_inside->addSubEntry(myEntry);
        }
        else
        { // we can add to current entry
          if (!myEntry1)
          {
            myEntry1=tcl_entry_namespace(tcl.scan.at(0)->ns);
          }
          parseCommentBlock(tcl.this_parser, myEntry1, myDoc, tcl.file_name,
            myLine0, FALSE, tcl.config_autobrief, FALSE, myProt, myPos0, myNew);
        }
      }
      else
      { // new entry
        tcl.entry_current = tcl_entry_new();
        while (parseCommentBlock(tcl.this_parser, tcl.entry_current, myDoc,
          tcl.file_name, myLine, FALSE, tcl.config_autobrief, FALSE,
          myProt, myPos, myNew))
        {
          if (myNew)
          {
            tcl.entry_inside->addSubEntry(tcl.entry_current);
            tcl.entry_current = tcl_entry_new();
          }
          else
          {
            tcl.entry_current->section = tcl.entry_inside->section;
            tcl.entry_current->name = tcl.entry_inside->name;
          }
        }
        if (myNew)
        {
          tcl.entry_inside->addSubEntry(tcl.entry_current);
          tcl.entry_current = tcl_entry_new();
        }
        else
        {
          tcl.entry_current->section = tcl.entry_inside->section;
          tcl.entry_current->name = tcl.entry_inside->name;
        }
      }
      if (tcl.protection != myProt)
      {
        tcl.scan.at(0)->protection = tcl.protection = myProt;
      }
    }
  }
  else
  {
    tcl_err("what %d\n",what);
    return;
  }
}

Entry* tcl_entry_class

(

const QCString

cl

)

Definition at line 1280 of file tclscanner.cpp.

{
  Entry *myEntry;
  if (!cl.length()) return(NULL);

  myEntry = tcl.cl.find(cl);
  if (myEntry == NULL)
  {
    myEntry = tcl_entry_new();
    myEntry->section    = Entry::CLASS_SEC;
    myEntry->name       = cl;
    tcl.entry_main->addSubEntry(myEntry);
    tcl.cl.insert(cl,myEntry);
  }
  return myEntry;
}

Entry* tcl_entry_namespace

(

const QCString

ns

)

Definition at line 1256 of file tclscanner.cpp.

{
  Entry *myEntry;
  if (ns.length())
  {
    myEntry = tcl.ns.find(ns);
  }
  else
  {
    myEntry = tcl.ns.find("::");
  }
  if (myEntry == NULL)
  {
    myEntry = tcl_entry_new();
    myEntry->section    = Entry::NAMESPACE_SEC;
    myEntry->name       = ns;
    tcl.entry_main->addSubEntry(myEntry);
    tcl.ns.insert(ns,myEntry);
  }
  return myEntry;
}

Entry* tcl_entry_new

(

)

Create new entry.

Definition at line 1168 of file tclscanner.cpp.

{
  Entry *myEntry = new Entry;
  myEntry->section    = Entry::EMPTY_SEC;
  myEntry->name       = "";
//  myEntry->type       = "";
  myEntry->brief      = "";
//  myEntry->doc        = "";
  myEntry->protection = Public;
//  myEntry->mtype      = Method;
//  myEntry->virt       = Normal;
//  myEntry->stat       = FALSE;
  myEntry->fileName   = tcl.file_name;
  myEntry->lang       = SrcLangExt_Tcl;
  initGroupInfo(myEntry);
  // collect entries
  if (!tcl.code)
  {
    tcl.entry.insert(0,myEntry);
  }
  return myEntry;
}

static void tcl_font_end ( )

static

End codifying with special font class.

Definition at line 1348 of file tclscanner.cpp.

{
  if (!tcl.code) return;
  if (tcl.code_font)
  {
    tcl.code->endFontClass();
    tcl.code_font=NULL;
  }
}

static void tcl_init ( )

static

Common initializations.

Definition at line 5109 of file tclscanner.cpp.

{
  // Get values from option TCL_SUBST
  tcl.config_subst.clear();
  if (Config::instance()->get("TCL_SUBST")) 
  {
    QStrList myStrList = Config_getList("TCL_SUBST");
    const char *s=myStrList.first();
    while (s) 
    {
      QCString myStr=s;
      int i=myStr.find('=');
      if (i>0)
      {
        QCString myName=myStr.left(i).stripWhiteSpace();
        QCString myValue=myStr.right(myStr.length()-i-1).stripWhiteSpace();
        if (!myName.isEmpty() && !myValue.isEmpty())
tcl_inf("TCL_SUBST: use '%s'\n",s);
        tcl.config_subst[myName] = myValue;
      }
      s = myStrList.next();
    }
  }

  if (tcl.input_string.at(tcl.input_string.length()-1) == 0x1A)
  {
  }
  else if (tcl.input_string.at(tcl.input_string.length()-1) == '\n')
  {
    tcl.input_string[tcl.input_string.length()-1] = 0x1A;
  }
  else
  {
    tcl.input_string += 0x1A;
  }

  tcl.code = NULL;
  tcl.code_font=NULL;
  tcl.code_line=1;
  tcl.code_linenumbers=1;
  tcl.config_autobrief = Config_getBool("JAVADOC_AUTOBRIEF");
  tcl.input_position = 0;
  tcl.file_name = NULL;
  tcl.this_parser = NULL;
  tcl.command=0;
  tcl.comment=0;
  tcl.brace_level=0;
  tcl.bracket_level=0;
  tcl.bracket_quote=0;
  tcl.word_is=' ';
  tcl.string_command="";
  tcl.string_commentline="";
  tcl.string_commentcodify="";
  tcl.string_comment    = "";
  tcl.string_last       = "";
  tcl.entry_main        = NULL;
  tcl.entry_file        = NULL;
  tcl.entry_current     = NULL;
  tcl.entry_inside      = NULL;
  tcl.list_commandwords.clear();
  tcl.scan.clear();
  tcl.ns.clear();
  tcl.cl.clear();
  tcl.fn.clear();
  tclscannerYYlineno              = 1;
  tcl.protection        = Public;
  tcl.memberdef         = NULL;
}

static int tcl_keyword ( QCString  str )

static

Check for keywords.

Definition at line 1299 of file tclscanner.cpp.

{
  static QStringList myList;
  static int myInit=1;
  if (myInit)
  {
    // tcl keywords
    myList <<"append"<<"apply"<<"array"<<"auto_execok"<<"auto_import"<<"auto_load"<<"auto_mkindex"<<"auto_qualify"<<"auto_reset";
    myList <<"binary";
    myList <<"catch"<<"cd"<<"close"<<"clock"<<"concat";
    myList <<"eof"<<"eval"<<"exec"<<"exit"<<"expr";
    myList <<"fblocked"<<"fconfigure"<<"file"<<"fileevent"<<"flush"<<"for"<<"foreach"<<"format";
    myList <<"gets"<<"global";
    myList <<"http";
    myList <<"if"<<"incr"<<"info"<<"interp";
    myList <<"join";
    myList <<"lappend"<<"lassign"<<"lindex"<<"linsert"<<"llength"<<"load"<<"lrange"<<"lrepeat"<<"lreplace"<<"lreverse"<<"lset";
    myList <<"namespace";
    myList <<"package"<<"parray"<<"pid"<<"pkg_mkIndex"<<"proc"<<"puts"<<"pwd";
    myList <<"registry"<<"rename"<<"return";
    myList <<"scan"<<"set"<<"split"<<"string"<<"switch";
    myList <<"tclLog"<<"tcl_endOfWord"<<"tcl_findLibrary"<<"tcl_startOfNextWord"<<"tcl_startOfPreviousWord"<<"tcl_wordBreakAfter"<<"tcl_wordBreakBefore"<<"tell"<<"time";
    myList <<"unknown"<<"upvar";
    myList <<"variable"<<"vwait";
// tk keywords
    myList <<"bell"<<"bind"<<"bindtags";
    myList <<"clipboard"<<"console"<<"consoleinterp";
    myList <<"destroy";
    myList <<"event";
    myList <<"focus";
    myList <<"grid";
    myList <<"lower";
    myList <<"option";
    myList <<"pack"<<"place";
    myList <<"raise";
    myList <<"send";
    myList <<"tkerror"<<"tkwait"<<"tk_bisque"<<"tk_focusNext"<<"tk_focusPrev"<<"tk_focusFollowsMouse"<<"tk_popup"<<"tk_setPalette"<<"tk_textCut"<<"tk_TextCopy"<<"tk_textPaste"<<"chooseColor"<<"tk_chooseColor"<<"tk_chooseDirectory"<<"tk_dialog"<<"tk_getOpenFile"<<"tkDialog"<<"tk_getSaveFile"<<"tk_messageBox";
    myList <<"winfo"<<"wm";
    myList <<"button"<<"canvas"<<"checkbutton"<<"entry"<<"frame"<<"image"<<"label"<<"labelframe"<<"listbox"<<"menu"<<"menubutton"<<"message"<<"panedwindow"<<"radiobutton"<<"scale"<<"scrollbar"<<"spinbox"<<"toplevel";
    myList.sort();
    myInit=0;
  }
  str=str.stripWhiteSpace();
  if (str.left(2)=="::") {str=str.mid(2);}
  if (myList.findIndex(str) != -1) return(1);
  return 0;
}

static void tcl_name ( const QCString &  ns0, const QCString &  name0, QCString &  ns, QCString &  name  )

static

Check name.

Definition at line 1206 of file tclscanner.cpp.

{
  QCString myNm;
  int myStart;

  if (qstrncmp(name0.data(),"::",2)==0)
  {
    myNm = name0.mid(2);
  }
  else if (ns0.length() && ns0 != " ")
  {
    myNm = ns0 + "::" + name0;
  }
  else
  {
    myNm = name0;
  }
  myStart = myNm.findRev("::");
  if (myStart == -1)
  {
    ns = "";
    name = myNm;
  }
  else
  {
    ns = myNm.mid(0,myStart);
    name = myNm.mid(myStart+2);
  }
}

static void tcl_name_SnippetAware ( const QCString &  ns0, const QCString &  name0, QCString &  ns, QCString &  name  )

static

Check name. Strip namespace qualifiers from name0 if inside inlined code segment.

Definition at line 1238 of file tclscanner.cpp.

{
  // If we are inside an inlined code snippet then ns0
  // already containes the complete namespace path.
  // Any namespace qualifiers in name0 are redundant.
  int i = name0.findRev("::");
  if (i>=0 && tcl.memberdef)
  {
    tcl_name(ns0, name0.mid(i+2), ns, name);
  }
  else
  {
    tcl_name(ns0, name0, ns, name);
  }
}

static void tcl_parse ( const QCString  ns, const QCString  cls  )

static

Start parsing.

Definition at line 5179 of file tclscanner.cpp.

{
  tcl_scan *myScan;

  tcl.entry_file          = tcl_entry_new();
  tcl.entry_file->name    = tcl.file_name;
  tcl.entry_file->section = Entry::SOURCE_SEC;
  tcl.entry_file->protection = Public;
  tcl.entry_main->addSubEntry(tcl.entry_file);
  Entry *myEntry=tcl_entry_new();
  myEntry->name="";
  tcl.entry_main->addSubEntry(myEntry);
  tcl.ns.insert("::",myEntry);
  tcl.entry_current = tcl_entry_new();

  tclscannerYYrestart( tclscannerYYin );
  BEGIN( TOP );
  tclscannerYYlineno=1;
  myScan = new tcl_scan;
  myScan->type[0]=' ';myScan->type[1]='\n';
  myScan->after.clear();
  myScan->line0=tclscannerYYlineno;
  myScan->line1=tclscannerYYlineno;
  myScan->buffer_state=YY_CURRENT_BUFFER;
  myScan->ns=ns;
  myScan->entry_cl=tcl_entry_class(cls);
  myScan->entry_fn=NULL;
  tcl.entry_inside = tcl.entry_file;
  myScan->entry_scan = tcl.entry_inside;
  tcl.scan.insert(0,myScan);
  tclscannerYYlex();
  tcl.scan.clear();
  tcl.ns.clear();
  tcl.cl.clear();
  tcl.fn.clear();
  tcl.entry.clear();
}

void tcl_protection

(

Entry *

entry

)

Set protection level.

Definition at line 1192 of file tclscanner.cpp.

{
  if (entry->protection!=Public&&entry->protection!=Protected&&entry->protection!=Private)
  {
    entry->protection = tcl.protection;
  }
  if (entry->protection!=Protected&&entry->protection!=Private)
  {
    entry->protection = Public;
  }
}

static void tcl_scan_end ( )

static

Close current scan context.

Definition at line 3468 of file tclscanner.cpp.

{
  tcl_scan *myScan=tcl.scan.at(0);
  tcl_scan *myScan1=tcl.scan.at(1);
tcl_inf("line=%d\n",myScan->line1);

  if (myScan->type[0]=='{') myScan->type[0]='}';
  if (myScan->type[0]=='[') myScan->type[0]=']';
  if (myScan->type[0]!=' ') tcl_codify(NULL,&myScan->type[0]);
  int myStart=-1;
  for (unsigned int i=0;i<myScan->after.count();i=i+2)
  {
    if (myScan->after[i]=="script") {
      myStart=i;
      break;
    }
    tcl_codify(myScan->after[i].utf8(),myScan->after[i+1].utf8());
  }
  tclscannerYY_delete_buffer(myScan->buffer_state);
  yy_pop_state();
  tcl.entry_inside = myScan1->entry_scan;
  tclscannerYY_switch_to_buffer(myScan1->buffer_state);
  tclscannerYYlineno=myScan1->line1;
  tcl.protection = myScan1->protection;
  if (myStart>=0)
  {
    myScan1 = tcl_scan_start('?', myScan->after[myStart+1], myScan->ns, myScan->entry_cl, myScan->entry_fn);
    for (unsigned int i=myStart+2;i<myScan->after.count();i++)
    {
      myScan1->after.append(myScan->after[i]);
    }
    tcl.scan.remove(1);
  }
  else
  {
    tcl.scan.removeFirst();
  }
}

static tcl_scan * tcl_scan_start ( char  type, QString  content, QCString  ns, Entry *  entry_cls, Entry *  entry_fn  )

static

Start new scan context for given 'content'.

Definition at line 3421 of file tclscanner.cpp.

{
  tcl_scan *myScan=tcl.scan.at(0);
tcl_inf("line=%d type=%d '%s'\n",tcl.line_body0,type,content.ascii());

  myScan->line1=tclscannerYYlineno;
  yy_push_state(TOP);

  myScan=new tcl_scan;
  myScan->type[0] =' ';
  myScan->type[1] = '\0'; 
  switch (type) {
    case '"':
    case '{':
    case '[':
      myScan->type[0] = type;
      break;
    case '?':
      if (content[0]=='"' && content[content.length()-1]=='"') myScan->type[0]='"';
      if (content[0]=='{' && content[content.length()-1]=='}') myScan->type[0]='{';
      if (content[0]=='[' && content[content.length()-1]==']') myScan->type[0]='[';
  }
  if (myScan->type[0]!=' ')
  {
    tcl_codify(NULL,&myScan->type[0]);
    content = content.mid(1,content.length()-2);
  }
  content += (char)0x1A;// for detection end of scan context
  myScan->ns = ns;
  myScan->entry_cl = entry_cl;
  myScan->entry_fn = entry_fn;
  myScan->entry_scan = tcl.entry_current;
  myScan->buffer_state=tclscannerYY_scan_string(content.ascii());
  myScan->line0=tcl.line_body0;
  myScan->line1=tcl.line_body1;
  myScan->after.clear();
  tclscannerYYlineno=myScan->line0;
  myScan->protection = tcl.protection;

  tcl.entry_inside = myScan->entry_scan;
  tcl.entry_current = tcl_entry_new();
  tcl.scan.insert(0,myScan);
  tclscannerYY_switch_to_buffer(myScan->buffer_state);
  return (myScan);
}

void tcl_split_list	(	QString &	str,
		QStringList &	list
	)

Definition at line 1068 of file tclscanner.cpp.

{
  int argc;
  const char **argv;

  list.clear();
  if (str.left(1)=="{" && str.right(1)=="}")
  {
    str=str.mid(1,str.length()-2);
  }
  else if (str.left(1)=="\"" && str.right(1)=="\"")
  {
    str=str.mid(1,str.length()-2);
  }
  if (Tcl_SplitList(str.ascii(),&argc,&argv) != TCL_OK)
  {
    list.append(str);
  }
  else
  {
    for (int i = 0; i < argc; i++)
    {
      list.append(argv[i]);
    }
    ckfree((char *) argv);
  }
}

int Tcl_SplitList	(	CONST char *	list,
		int *	argcPtr,
		CONST char ***	argvPtr
	)

Definition at line 976 of file tclscanner.cpp.

{
  CONST char **argv, *l, *element;
  char *p;
  int length, size, i, result, elSize, brace;

  /*
   * Figure out how much space to allocate. There must be enough space for
   * both the array of pointers and also for a copy of the list. To estimate
   * the number of pointers needed, count the number of space characters in
   * the list.
   */

  for (size = 2, l = list; *l != 0; l++) 
  {
    if (isspace(UCHAR(*l))) 
    {                   /* INTL: ISO space. */
      size++;

      /*
       * Consecutive space can only count as a single list delimiter.
       */

      while (1) 
      {
        char next = *(l + 1);

        if (next == '\0') 
        {
          break;
        }
        ++l;
        if (isspace(UCHAR(next))) 
        {               /* INTL: ISO space. */
          continue;
        }
        break;
      }
    }
  }
  length = (int)(l - list);
  argv = (CONST char **) ckalloc((unsigned)
      ((size * sizeof(char *)) + length + 1));
  for (i = 0, p = ((char *) argv) + size*sizeof(char *);
      *list != 0;  i++) 
  {
    CONST char *prevList = list;

    result = TclFindElement(list, length, &element, &list,
        &elSize, &brace);
    length -= (int)(list - prevList);
    if (result != TCL_OK) 
    {
      ckfree((char *) argv);
      return result;
    }
    if (*element == 0) 
    {
      break;
    }
    if (i >= size) 
    {
      ckfree((char *) argv);
      return TCL_ERROR;
    }
    argv[i] = p;
    if (brace) 
    {
      memcpy(p, element, (size_t) elSize);
      p += elSize;
      *p = 0;
      p++;
    } 
    else 
    {
      TclCopyAndCollapse(elSize, element, p);
      p += elSize+1;
    }
  }

  argv[i] = NULL;
  *argvPtr = argv;
  *argcPtr = i;
  return TCL_OK;
}

static void tcl_word ( int  what, const char *  text  )

static

Handling of word parsing.

Definition at line 3508 of file tclscanner.cpp.

{
  static char myList[1024]="";// nesting level list
  static int myLevel=0;// number of current nesting level
  static int myWhite=0;// set true when next char should be whitespace
  static char myWord;// internal state

  switch (what)
  {
  case 0:// start
    yy_push_state(WORD);
    switch (text[0])
    {
      case '{':
      case '[':
      case '"': myWord = text[0]; break;
      default: myWord = '.';
    }
    myList[0]=myWord;
    myLevel=1;
    myWhite=0;
  break;
  case 1:// all other chars
    if (myWhite)
    {// {x}y "x"y
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    if (myLevel==0)
    {
      myWord='.';
      myList[0]=myWord;
      myLevel=1;
    }
  break;
  case 2:// \\\n
    if (myLevel==0)
    {
      myWord=' ';
      yy_pop_state();
      yyless(0);
tcl_inf("(\\\n) ?%s?\n",tcl.string_last.data());
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      case '[':
      case '"':
      break;
      case '.':
        if (myLevel==1)
        {
          myWord=' ';
          yy_pop_state();
          yyless(0);
tcl_inf("(\\\n) ?%s?\n",tcl.string_last.data());
          return;
        }
      break;
    }
    myWhite=0;
  break;
  case 3:// {
    if (myWhite)
    {// {x}{ "x"{
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      case '[':
        myList[myLevel++]='{';
      break;
      case '"':
      case '.':
      break;
    }
    myWhite=0;
  break;
  case 4:// }
    if (myWhite)
    {// {x}{ "x"{
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':// {{x}}
        myLevel--;
        if (myLevel==0 && !tcl.code) 
        {
          myWhite=1;
        }
      break;
      case '[':
      case '"':
      case '.':
      break;
    }
  break;
  case 5:// [
    if (myWhite)
    {// {x}[
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      break;
      case '[':
      case '"':
      case '.':
        myList[myLevel++]='[';
      break;
    }
    myWhite=0;
  break;
  case 6:// ]
    if (myWhite)
    {// {x}]
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      break;
      case '[':
        myLevel--;
      break;
      case '"':
      case '.':
      break;
    }
    myWhite=0;
  break;
  case 7:// "
    if (myWhite)
    {// {x}"
      tcl_err("expected word separator: %s\n",text);
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      break;
      case '[':
        myList[myLevel++]='"';
      break;
      case '"':
        myLevel--;
      case '.':
      break;
    }
  break;
  case 8:// ' '
  case 9:// \t
  case 10:// ;
  case 11:// \n
    if (myLevel==0)
    {
      myWord=' ';
      yy_pop_state();
      yyless(0);
tcl_inf("(%d) ?%s?\n",what,tcl.string_last.data());
      return;
    }
    switch (myList[myLevel-1])
    {
      case '{':
      case '[':
      case '"':
      break;
      case '.':
        if (myLevel==1)
        {
          myWord=' ';
          yy_pop_state();
          yyless(0);
tcl_inf("(.%d) ?%s?\n",what,tcl.string_last.data());
          return;
        }
        else
        {
          myLevel--;
        }
      break;
    }
    myWhite=0;
  break;
  case 12:// \x1A
    if (myLevel==0)
    {
      myWord=' ';
      yy_pop_state();
      yyless(0);
tcl_inf("(%d) ?%s?\n",what,tcl.string_last.data());
      return;
    }
    if (myLevel!=1 || myList[0] != '.')
    {
      tcl_war("level=%d expected=%c\n",myLevel,myList[myLevel-1]);
    }
    myWord=' ';
    yy_pop_state();
    yyless(0);
tcl_inf("(.%d) ?%s?\n",what,tcl.string_last.data());
    return;
    myWhite=0;
  break;
  default:
    tcl_err("wrong state: %d\n",what);
    return;
  }
  tcl.string_last += text;
}

void tclDummy

(

)

Definition at line 5385 of file tclscanner.cpp.

{
  yy_top_state();
}

int TclFindElement	(	CONST char *	list,
		int	listLength,
		CONST char **	elementPtr,
		CONST char **	nextPtr,
		int *	sizePtr,
		int *	bracePtr
	)

Definition at line 789 of file tclscanner.cpp.

{
  CONST char *p = list;
  CONST char *elemStart;        /* Points to first byte of first element. */
  CONST char *limit;            /* Points just after list's last byte. */
  int openBraces = 0;           /* Brace nesting level during parse. */
  int inQuotes = 0;
  int size = 0;         /* lint. */
  //RZ    int numChars;

  /*
   * Skim off leading white space and check for an opening brace or quote.
   * We treat embedded NULLs in the list as bytes belonging to a list
   * element.
   */

  limit = (list + listLength);
  while ((p < limit) && (isspace(UCHAR(*p)))) 
  { /* INTL: ISO space. */
    p++;
  }
  if (p == limit) 
  {             /* no element found */
    elemStart = limit;
    goto done;
  }

  if (*p == '{')   /* } to keep vi happy */
  {
    openBraces = 1;
    p++;
  } 
  else if (*p == '"') 
  {
    inQuotes = 1;
    p++;
  }
  elemStart = p;
  if (bracePtr != 0) 
  {
    *bracePtr = openBraces;
  }

  /*
   * Find element's end (a space, close brace, or the end of the string).
   */

  while (p < limit) 
  {
    switch (*p) 
    {
      /*
       * Open brace: don't treat specially unless the element is in
       * braces. In this case, keep a nesting count.
       */

      case '{':
        if (openBraces != 0) 
        {
          openBraces++;
        }
        break;

        /*
         * Close brace: if element is in braces, keep nesting count and
         * quit when the last close brace is seen.
         */

      case '}':
        if (openBraces > 1) 
        {
          openBraces--;
        } 
        else if (openBraces == 1) 
        {
          size = (int)(p - elemStart);
          p++;
          if ((p >= limit) || isspace(UCHAR(*p))) 
          {     /* INTL: ISO space. */
            goto done;
          }

          /*
           * Garbage after the closing brace; return an error.
           */

          return TCL_ERROR;
        }
        break;

        /*
         * Backslash: skip over everything up to the end of the backslash
         * sequence.
         */

      case '\\':
        //RZ        Tcl_UtfBackslash(p, &numChars, NULL);
        //RZ        p += (numChars - 1);
        p++; //RZ
        break;

        /*
         * Space: ignore if element is in braces or quotes; otherwise
         * terminate element.
         */

      case ' ':
      case '\f':
      case '\n':
      case '\r':
      case '\t':
      case '\v':
        if ((openBraces == 0) && !inQuotes) 
        {
          size = (int)(p - elemStart);
          goto done;
        }
        break;

        /*
         * Double-quote: if element is in quotes then terminate it.
         */

      case '"':
        if (inQuotes) 
        {
          size = (int)(p - elemStart);
          p++;
          if ((p >= limit) || isspace(UCHAR(*p))) 
          {     /* INTL: ISO space */
            goto done;
          }

          /*
           * Garbage after the closing quote; return an error.
           */
          return TCL_ERROR;
        }
        break;
    }
    p++;
  }

  /*
   * End of list: terminate element.
   */

  if (p == limit) 
  {
    if (openBraces != 0) 
    {
      return TCL_ERROR;
    } 
    else if (inQuotes) 
    {
      return TCL_ERROR;
    }
    size = (int)(p - elemStart);
  }

done:
  while ((p < limit) && (isspace(UCHAR(*p)))) 
  { /* INTL: ISO space. */
    p++;
  }
  *elementPtr = elemStart;
  *nextPtr = p;
  if (sizePtr != 0) 
  {
    *sizePtr = size;
  }
  return TCL_OK;
}

YY_BUFFER_STATE tclscannerYY_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

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

Returns

the allocated buffer state.

Definition at line 2880 of file tclscanner.cpp.

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

        b->yy_buf_size = size;

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

        b->yy_is_our_buffer = 1;

        tclscannerYY_init_buffer(b,file );

        return b;
}

void tclscannerYY_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with tclscannerYY_create_buffer()

Definition at line 2908 of file tclscanner.cpp.

{
    
        if ( ! b )
                return;

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

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

        tclscannerYYfree((void *) b  );
}

void tclscannerYY_flush_buffer

(

YY_BUFFER_STATE

b

)

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

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 2955 of file tclscanner.cpp.

{
        if ( ! b )
                return;

        b->yy_n_chars = 0;

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

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

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

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

static void tclscannerYY_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 2927 of file tclscanner.cpp.

{
        int oerrno = errno;
    
        tclscannerYY_flush_buffer(b );

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

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

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

static void tclscannerYY_load_buffer_state ( void  )

static

Definition at line 2866 of file tclscanner.cpp.

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

YY_BUFFER_STATE tclscannerYY_scan_buffer	(	char *	base,
		yy_size_t	size
	)

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

Parameters

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

Returns

the newly allocated buffer state object.

Definition at line 3082 of file tclscanner.cpp.

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

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

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

        tclscannerYY_switch_to_buffer(b  );

        return b;
}

YY_BUFFER_STATE tclscannerYY_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

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

Parameters

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

Returns

the newly allocated buffer state object.

Definition at line 3132 of file tclscanner.cpp.

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

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

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

        b = tclscannerYY_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in tclscannerYY_scan_bytes()" );

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

        return b;
}

YY_BUFFER_STATE tclscannerYY_scan_string

(

yyconst char *

yystr

)

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

Parameters

yystr

a NUL-terminated string to scan

Returns

the newly allocated buffer state object.

Note

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

Definition at line 3119 of file tclscanner.cpp.

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

void tclscannerYY_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 2835 of file tclscanner.cpp.

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

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

        YY_CURRENT_BUFFER_LVALUE = new_buffer;
        tclscannerYY_load_buffer_state( );

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

void * tclscannerYYalloc

(

yy_size_t

size

)

Definition at line 3391 of file tclscanner.cpp.

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

static void tclscannerYYensure_buffer_stack ( void  )

static

Definition at line 3033 of file tclscanner.cpp.

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

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

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

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

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

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

void tclscannerYYfree

(

void *

ptr

)

Definition at line 3408 of file tclscanner.cpp.

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

int tclscannerYYget_debug

(

void

)

Definition at line 3296 of file tclscanner.cpp.

{
        return tclscannerYY_flex_debug;
}

YY_EXTRA_TYPE tclscannerYYget_extra

(

void

)

FILE * tclscannerYYget_in

(

void

)

Get the input stream.

Definition at line 3240 of file tclscanner.cpp.

{
        return tclscannerYYin;
}

int tclscannerYYget_leng

(

void

)

Get the length of the current token.

Definition at line 3256 of file tclscanner.cpp.

{
        return tclscannerYYleng;
}

int tclscannerYYget_lineno

(

void

)

Get the current line number.

Definition at line 3231 of file tclscanner.cpp.

{
        
    return tclscannerYYlineno;
}

FILE * tclscannerYYget_out

(

void

)

Get the output stream.

Definition at line 3248 of file tclscanner.cpp.

{
        return tclscannerYYout;
}

char * tclscannerYYget_text

(

void

)

Get the current token.

Definition at line 3265 of file tclscanner.cpp.

{
        return tclscannerYYtext;
}

int tclscannerYYlex

(

void

)

int tclscannerYYlex_destroy

(

void

)

Definition at line 3342 of file tclscanner.cpp.

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

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

    /* Destroy the start condition stack. */
        tclscannerYYfree((yy_start_stack)  );
        (yy_start_stack) = NULL;

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

    return 0;
}

void tclscannerYYpop_buffer_state

(

void

)

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

Definition at line 3014 of file tclscanner.cpp.

{
        if (!YY_CURRENT_BUFFER)
                return;

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

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

void tclscannerYYpush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

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

Parameters

new_buffer

The new state.

Definition at line 2984 of file tclscanner.cpp.

{
        if (new_buffer == NULL)
                return;

        tclscannerYYensure_buffer_stack();

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

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

        /* copied from tclscannerYY_switch_to_buffer. */
        tclscannerYY_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
}

void * tclscannerYYrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 3396 of file tclscanner.cpp.

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

void tclscannerYYrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 2818 of file tclscanner.cpp.

{
    
        if ( ! YY_CURRENT_BUFFER ){
        tclscannerYYensure_buffer_stack ();
                YY_CURRENT_BUFFER_LVALUE =
            tclscannerYY_create_buffer(tclscannerYYin,YY_BUF_SIZE );
        }

        tclscannerYY_init_buffer(YY_CURRENT_BUFFER,input_file );
        tclscannerYY_load_buffer_state( );
}

void tclscannerYYset_debug

(

int

debug_flag

)

Definition at line 3301 of file tclscanner.cpp.

{
        tclscannerYY_flex_debug = bdebug ;
}

void tclscannerYYset_extra

(

YY_EXTRA_TYPE

user_defined

)

void tclscannerYYset_in

(

FILE *

in_str

)

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

Parameters

in_str

A readable stream.

See also

tclscannerYY_switch_to_buffer

Definition at line 3286 of file tclscanner.cpp.

{
        tclscannerYYin = in_str ;
}

void tclscannerYYset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

Definition at line 3274 of file tclscanner.cpp.

{
    
    tclscannerYYlineno = line_number;
}

void tclscannerYYset_out

(

FILE *

out_str

)

Definition at line 3291 of file tclscanner.cpp.

{
        tclscannerYYout = out_str ;
}

while

(

1

)

Definition at line 1721 of file tclscanner.cpp.

                {
                (yy_more_len) = 0;
                if ( (yy_more_flag) )
                        {
                        (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);
                        (yy_more_flag) = 0;
                        }
                yy_cp = (yy_c_buf_p);

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

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

                yy_current_state = (yy_start);
yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
                                (yy_last_accepting_state) = yy_current_state;
                                (yy_last_accepting_cpos) = yy_cp;
                                }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
                                if ( yy_current_state >= 179 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        ++yy_cp;
                        }
                while ( yy_current_state != 178 );
                yy_cp = (yy_last_accepting_cpos);
                yy_current_state = (yy_last_accepting_state);

yy_find_action:
                yy_act = yy_accept[yy_current_state];

                YY_DO_BEFORE_ACTION;

                if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
                        {
                        int yyl;
                        for ( yyl = (yy_more_len); yyl < tclscannerYYleng; ++yyl )
                                if ( tclscannerYYtext[yyl] == '\n' )
                                           
    tclscannerYYlineno++;
;
                        }

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

                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
                        *yy_cp = (yy_hold_char);
                        yy_cp = (yy_last_accepting_cpos);
                        yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 798 "tclscanner.l"
{
D
  yyterminate();
}
        YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(ERROR):
case YY_STATE_EOF(TOP):
case YY_STATE_EOF(COMMAND):
case YY_STATE_EOF(WORD):
case YY_STATE_EOF(COMMENT):
case YY_STATE_EOF(COMMENT_NL):
case YY_STATE_EOF(COMMENT_CODE):
case YY_STATE_EOF(COMMENT_VERB):
case YY_STATE_EOF(COMMENTLINE):
case YY_STATE_EOF(COMMENTLINE_NL):
#line 802 "tclscanner.l"
{
D
  if (tcl.scan.count()<1)
  {// error
D
    tcl_err("Tcl parser stack empty! Parser error in file '%s'.\n",tcl.file_name.data());
    yyterminate();
  }
  else if (tcl.scan.count()==1)
  {// exit, check on input?
D
    yyterminate();
  }
  else
  {// continue
D
    tcl_command(-1,"");
    tcl_scan_end();
  }
}
        YY_BREAK
case 2:
YY_RULE_SETUP
#line 822 "tclscanner.l"
{
D
  yyless(0);
  tcl.line_comment=tclscannerYYlineno;
  tcl_comment(0,"");
}
        YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
#line 828 "tclscanner.l"
{
D
  tcl_codify(NULL,tclscannerYYtext);
}
        YY_BREAK
case 4:
YY_RULE_SETUP
#line 832 "tclscanner.l"
{
D
  yyless(0);
  tcl.line_command=tclscannerYYlineno;
  tcl_command(0,"");
}
        YY_BREAK
case 5:
YY_RULE_SETUP
#line 839 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
}
        YY_BREAK
case 6:
/* rule 6 can match eol */
YY_RULE_SETUP
#line 843 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  tcl_comment(2,tclscannerYYtext+1);
}
        YY_BREAK
case 7:
/* rule 7 can match eol */
YY_RULE_SETUP
#line 848 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  QCString t=tclscannerYYtext;
  t = t.mid(2,t.length()-3);
  t.append("\n");
  tcl_comment(1,t.data());
  yy_push_state(COMMENT_NL);
}
        YY_BREAK
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
#line 857 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  tcl_comment(1,tclscannerYYtext+2);
}
        YY_BREAK
case 9:
/* rule 9 can match eol */
YY_RULE_SETUP
#line 862 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  tcl_codify("comment",t.left(7));
  tcl_comment(2,"\n@code\n");
  yyless(7);
  yy_push_state(COMMENT_CODE);
}
        YY_BREAK
case 10:
/* rule 10 can match eol */
YY_RULE_SETUP
#line 870 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  tcl_codify("comment",t.left(11));
  tcl_comment(2,"\n@verbatim\n");
  yyless(11);
  yy_push_state(COMMENT_VERB);
}
        YY_BREAK
case 11:
/* rule 11 can match eol */
YY_RULE_SETUP
#line 878 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  QCString t=tclscannerYYtext;
  t = t.mid(1,t.length()-3);
  t.append("\n");
  tcl_comment(2,t.data());
  yy_push_state(COMMENT_NL);
}
        YY_BREAK
case 12:
/* rule 12 can match eol */
YY_RULE_SETUP
#line 887 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  tcl_comment(2,tclscannerYYtext+1);
}
        YY_BREAK
case 13:
YY_RULE_SETUP
#line 892 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  t = t.mid(0,t.length()-1);
  tcl_codify("comment",t.data());
  t = t.mid(1,t.length());
  tcl_comment(-2,t.data());
  unput(0x1A);
}
        YY_BREAK
case 14:
YY_RULE_SETUP
#line 901 "tclscanner.l"
{
D
  tcl_comment(-2,"");
  unput(0x1A);
}
        YY_BREAK
case 15:
/* rule 15 can match eol */
YY_RULE_SETUP
#line 906 "tclscanner.l"
{
D
  tcl_comment(-2,tclscannerYYtext);
  yyless(0);
}
        YY_BREAK
case 16:
/* rule 16 can match eol */
YY_RULE_SETUP
#line 912 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  t = t.left(t.length()-10);
  tcl_comment(2,t.data());
  tcl_comment(2,"\n@endcode\n");
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 17:
/* rule 17 can match eol */
YY_RULE_SETUP
#line 921 "tclscanner.l"
{
D
  yymore();
}
        YY_BREAK
case 18:
YY_RULE_SETUP
#line 925 "tclscanner.l"
{
D
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 19:
/* rule 19 can match eol */
YY_RULE_SETUP
#line 931 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  t = t.left(t.length()-14);
  tcl_comment(2,t.data());
  tcl_comment(2,"\n@endverbatim\n");
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 20:
/* rule 20 can match eol */
YY_RULE_SETUP
#line 940 "tclscanner.l"
{
D
  yymore();
}
        YY_BREAK
case 21:
YY_RULE_SETUP
#line 944 "tclscanner.l"
{
D
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 22:
/* rule 22 can match eol */
YY_RULE_SETUP
#line 950 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  tcl_comment(2,tclscannerYYtext);
}
        YY_BREAK
case 23:
/* rule 23 can match eol */
YY_RULE_SETUP
#line 955 "tclscanner.l"
{
D
  tcl_codify("comment",tclscannerYYtext);
  tcl_comment(2,tclscannerYYtext);
  yy_pop_state();
}
        YY_BREAK
case 24:
YY_RULE_SETUP
#line 961 "tclscanner.l"
{
D
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 25:
YY_RULE_SETUP
#line 967 "tclscanner.l"
{
D
  yy_pop_state();
  yyless(0);
}
        YY_BREAK
case 26:
YY_RULE_SETUP
#line 972 "tclscanner.l"
{
D
  tcl.string_commentcodify += tclscannerYYtext;
}
        YY_BREAK
case 27:
/* rule 27 can match eol */
YY_RULE_SETUP
#line 976 "tclscanner.l"
{
D
  tcl.string_commentcodify += tclscannerYYtext;
  QCString t=tclscannerYYtext;
  t = t.mid(2,t.length()-4);
  t.append("\n");
  tcl.string_commentline += t;
  yy_push_state(COMMENTLINE_NL);
}
        YY_BREAK
case 28:
/* rule 28 can match eol */
YY_RULE_SETUP
#line 985 "tclscanner.l"
{
D
  tcl.string_commentcodify += tclscannerYYtext;
  tcl.string_commentline += (tclscannerYYtext+2);
}
        YY_BREAK
case 29:
/* rule 29 can match eol */
YY_RULE_SETUP
#line 990 "tclscanner.l"
{
D
  yy_pop_state();
  if (tcl.string_commentline.length())
  {
    tcl.entry_current->brief = tcl.string_commentline;
    tcl.entry_current->briefLine = tcl.line_commentline;
    tcl.entry_current->briefFile = tcl.file_name;
  }
  yyless(0);
  tcl_command(-1,tcl.string_commentcodify.data());
  tcl.string_commentline="";
  tcl.string_commentcodify="";
}
        YY_BREAK
case 30:
/* rule 30 can match eol */
YY_RULE_SETUP
#line 1005 "tclscanner.l"
{
D
  tcl.string_commentcodify += tclscannerYYtext;
  QCString t=tclscannerYYtext;
  t = t.left(t.length()-3);
  t.append("\n");
  tcl.string_commentline += t;
}
        YY_BREAK
case 31:
/* rule 31 can match eol */
YY_RULE_SETUP
#line 1013 "tclscanner.l"
{
D
  tcl.string_commentcodify += tclscannerYYtext;
  tcl.string_commentline += tclscannerYYtext;
  yy_pop_state();
}
        YY_BREAK
case 32:
YY_RULE_SETUP
#line 1019 "tclscanner.l"
{
D
  QCString t=tclscannerYYtext;
  t = t.left(t.length()-1);
  tcl.string_commentcodify += t;
  tcl.string_commentline += t;
  yy_pop_state();
  unput(0x1A);
}
        YY_BREAK
case 33:
/* rule 33 can match eol */
YY_RULE_SETUP
#line 1029 "tclscanner.l"
{
D
  tcl.string_commentcodify = tclscannerYYtext;
  tcl.string_commentcodify = tcl.string_commentcodify.left(tcl.string_commentcodify.length()-2);
  tcl.string_commentline = "";
  tcl.line_commentline = tclscannerYYlineno;
  tcl.line_body1=tclscannerYYlineno;
  unput('<');
  unput('#');
  yy_push_state(COMMENTLINE);
}
        YY_BREAK
case 34:
/* rule 34 can match eol */
YY_RULE_SETUP
#line 1040 "tclscanner.l"
{
D
  tcl.string_commentcodify = "";
  tcl.string_commentline = "";
  tcl.line_body1=tclscannerYYlineno;
  tcl_command(-1,"");
}
        YY_BREAK
case 35:
/* rule 35 can match eol */
YY_RULE_SETUP
#line 1047 "tclscanner.l"
{
D
  tcl.string_commentcodify = "";
  tcl.string_commentline = "";
  tcl.line_body1=tclscannerYYlineno;
  tcl_command(-1,tclscannerYYtext);
}
        YY_BREAK
case 36:
/* rule 36 can match eol */
YY_RULE_SETUP
#line 1054 "tclscanner.l"
{
D
  tcl.string_commentcodify = "";
  tcl.string_commentline = "";
  tcl.line_body1=tclscannerYYlineno-1;
  tcl_command(-1,tclscannerYYtext);
}
        YY_BREAK
case 37:
/* rule 37 can match eol */
YY_RULE_SETUP
#line 1061 "tclscanner.l"
{
D
  tcl_command(1,tclscannerYYtext);
}
        YY_BREAK
case 38:
YY_RULE_SETUP
#line 1065 "tclscanner.l"
{
D
  tcl.word_is = ' ';
  tcl.string_last = "{*}";
  tcl_word(0,&tclscannerYYtext[3]);
}
        YY_BREAK
case 39:
YY_RULE_SETUP
#line 1071 "tclscanner.l"
{
D
  tcl.word_is=' ';
  tcl.string_last = "";
  tcl_word(0,tclscannerYYtext);
}
        YY_BREAK
case 40:
YY_RULE_SETUP
#line 1077 "tclscanner.l"
{
D
  tcl.word_is=' ';
  if (tclscannerYYtext[0]=='{'||tclscannerYYtext[0]=='['||tclscannerYYtext[0]=='"') tcl.word_is = tclscannerYYtext[0];
  tcl.string_last = "";
  tcl_word(0,tclscannerYYtext);
}
        YY_BREAK
case 41:
#line 1086 "tclscanner.l"
case 42:
YY_RULE_SETUP
#line 1086 "tclscanner.l"
{
  tcl_word(1,tclscannerYYtext);
}
        YY_BREAK
case 43:
/* rule 43 can match eol */
YY_RULE_SETUP
#line 1089 "tclscanner.l"
{
  tcl_word(2,tclscannerYYtext);
}
        YY_BREAK
case 44:
YY_RULE_SETUP
#line 1092 "tclscanner.l"
{
  tcl_word(3,tclscannerYYtext);
}
        YY_BREAK
case 45:
YY_RULE_SETUP
#line 1095 "tclscanner.l"
{
  tcl_word(4,tclscannerYYtext);
}
        YY_BREAK
case 46:
YY_RULE_SETUP
#line 1098 "tclscanner.l"
{
  tcl_word(5,tclscannerYYtext);
}
        YY_BREAK
case 47:
YY_RULE_SETUP
#line 1101 "tclscanner.l"
{
  tcl_word(6,tclscannerYYtext);
}
        YY_BREAK
case 48:
YY_RULE_SETUP
#line 1104 "tclscanner.l"
{
  tcl_word(7,tclscannerYYtext);
}
        YY_BREAK
case 49:
YY_RULE_SETUP
#line 1107 "tclscanner.l"
{
  tcl_word(8,tclscannerYYtext);
}
        YY_BREAK
case 50:
YY_RULE_SETUP
#line 1110 "tclscanner.l"
{
  tcl_word(9,tclscannerYYtext);
}
        YY_BREAK
case 51:
YY_RULE_SETUP
#line 1113 "tclscanner.l"
{
  tcl_word(10,tclscannerYYtext);
}
        YY_BREAK
case 52:
/* rule 52 can match eol */
YY_RULE_SETUP
#line 1116 "tclscanner.l"
{
  tcl_word(11,tclscannerYYtext);
}
        YY_BREAK
case 53:
YY_RULE_SETUP
#line 1119 "tclscanner.l"
{
  tcl_word(12,tclscannerYYtext);
}
        YY_BREAK
case 54:
YY_RULE_SETUP
#line 1122 "tclscanner.l"
{
  tcl_word(1,tclscannerYYtext);
}
        YY_BREAK
case 55:
YY_RULE_SETUP
#line 1125 "tclscanner.l"
ECHO;
        YY_BREAK
#line 2366 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/tclscanner.cpp"

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

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

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

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

                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state(  );

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

                        yy_next_state = yy_try_NUL_trans( yy_current_state );

                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;

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

                        else
                                {
                                yy_cp = (yy_last_accepting_cpos);
                                yy_current_state = (yy_last_accepting_state);
                                goto yy_find_action;
                                }
                        }

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

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

                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
                                        }

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

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

                                yy_current_state = yy_get_previous_state(  );

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

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

                                yy_current_state = yy_get_previous_state(  );

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

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

static void yy_fatal_error ( yyconst char  msg[] )

static

static void yy_fatal_error ( yyconst char *  msg )

static

Definition at line 3203 of file tclscanner.cpp.

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

static int yy_get_next_buffer ( void  )

static

Definition at line 2504 of file tclscanner.cpp.

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

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

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

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

        /* Try to read more data. */

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

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

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

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

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

                        /* just a shorter name for the current buffer */
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;

                        int yy_c_buf_p_offset =
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);

                        if ( b->yy_is_our_buffer )
                                {
                                int new_size = b->yy_buf_size * 2;

                                if ( new_size <= 0 )
                                        b->yy_buf_size += b->yy_buf_size / 8;
                                else
                                        b->yy_buf_size *= 2;

                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
                                        tclscannerYYrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
                                b->yy_ch_buf = 0;

                        if ( ! b->yy_ch_buf )
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );

                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;

                        }

                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;

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

                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
                        tclscannerYYrestart(tclscannerYYin  );
                        }

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

        else
                ret_val = EOB_ACT_CONTINUE_SCAN;

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

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

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

        return ret_val;
}

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 2638 of file tclscanner.cpp.

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

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

        return yy_current_state;
}

static int yy_init_globals ( void  )

static

Definition at line 3306 of file tclscanner.cpp.

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

    /* We do not touch tclscannerYYlineno unless the option is enabled. */
    tclscannerYYlineno =  1;
    
    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

    (yy_start_stack_ptr) = 0;
    (yy_start_stack_depth) = 0;
    (yy_start_stack) =  NULL;

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

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

static void yy_pop_state ( void  )

static

Definition at line 3186 of file tclscanner.cpp.

{
        if ( --(yy_start_stack_ptr) < 0 )
                YY_FATAL_ERROR( "start-condition stack underflow" );

        BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}

static void yy_push_state ( int  new_state )

static

Definition at line 3162 of file tclscanner.cpp.

{
        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
                {
                yy_size_t new_size;

                (yy_start_stack_depth) += YY_START_STACK_INCR;
                new_size = (yy_start_stack_depth) * sizeof( int );

                if ( ! (yy_start_stack) )
                        (yy_start_stack) = (int *) tclscannerYYalloc(new_size  );

                else
                        (yy_start_stack) = (int *) tclscannerYYrealloc((void *) (yy_start_stack),new_size  );

                if ( ! (yy_start_stack) )
                        YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
                }

        (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

        BEGIN(new_state);
}

static int yy_top_state ( void  )

static

Definition at line 3194 of file tclscanner.cpp.

{
        return (yy_start_stack)[(yy_start_stack_ptr) - 1];
}

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 2670 of file tclscanner.cpp.

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

        register YY_CHAR yy_c = 1;
        if ( yy_accept[yy_current_state] )
                {
                (yy_last_accepting_state) = yy_current_state;
                (yy_last_accepting_cpos) = yy_cp;
                }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 179 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        yy_is_jam = (yy_current_state == 178);

        return yy_is_jam ? 0 : yy_current_state;
}

static int yyread ( char *  buf, int  max_size  )

static

Definition at line 5368 of file tclscanner.cpp.

{
  int c=0;

  *buf = '\0';
  while ( c < max_size && tcl.input_string.at(tcl.input_position) )
  {
    *buf = tcl.input_string.at(tcl.input_position++) ;
    c++; buf++;
  }
  //printf("Read from=%d size=%d max=%d c=%d\n",tcl.input_position,strlen(&tcl.input_string[tcl.input_position]),max_size,c);
  return c;
}

static void yyunput ( int  c, char *  buf_ptr  )

static

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

static

Definition at line 2693 of file tclscanner.cpp.

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

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

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

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

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

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

        *--yy_cp = (char) c;

    if ( c == '\n' ){
        --tclscannerYYlineno;
    }

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

Variable Documentation

int brace_level

Definition at line 1126 of file tclscanner.cpp.

int bracket_level

Definition at line 1127 of file tclscanner.cpp.

int bracket_quote

Definition at line 1128 of file tclscanner.cpp.

QAsciiDict<Entry> cl

Definition at line 1148 of file tclscanner.cpp.

CodeOutputInterface* code

Definition at line 1114 of file tclscanner.cpp.

const char* code_font

Definition at line 1117 of file tclscanner.cpp.

int code_line

Definition at line 1115 of file tclscanner.cpp.

int code_linenumbers

Definition at line 1116 of file tclscanner.cpp.

bool collectXRefs

Definition at line 1153 of file tclscanner.cpp.

int command

Definition at line 1124 of file tclscanner.cpp.

int comment

Definition at line 1125 of file tclscanner.cpp.

bool config_autobrief

Definition at line 1118 of file tclscanner.cpp.

QMap<QString,QString> config_subst

Definition at line 1119 of file tclscanner.cpp.

QList<Entry> entry

Definition at line 1150 of file tclscanner.cpp.

Entry* entry_current

Definition at line 1143 of file tclscanner.cpp.

Entry* entry_file

Definition at line 1142 of file tclscanner.cpp.

Entry* entry_inside

Definition at line 1144 of file tclscanner.cpp.

Entry* entry_main

Definition at line 1141 of file tclscanner.cpp.

QCString file_name

Definition at line 1122 of file tclscanner.cpp.

QAsciiDict<Entry> fn

Definition at line 1149 of file tclscanner.cpp.

int input_position

Definition at line 1121 of file tclscanner.cpp.

QCString input_string

Definition at line 1120 of file tclscanner.cpp.

int line_body0

Definition at line 1133 of file tclscanner.cpp.

int line_body1

Definition at line 1134 of file tclscanner.cpp.

int line_command

Definition at line 1132 of file tclscanner.cpp.

int line_comment

Definition at line 1130 of file tclscanner.cpp.

int line_commentline

Definition at line 1131 of file tclscanner.cpp.

QStringList list_commandwords

Definition at line 1145 of file tclscanner.cpp.

MemberDef* memberdef

Definition at line 1152 of file tclscanner.cpp.

QAsciiDict<Entry> ns

Definition at line 1147 of file tclscanner.cpp.

Protection protection

Definition at line 1151 of file tclscanner.cpp.

QList<tcl_scan> scan

Definition at line 1146 of file tclscanner.cpp.

QCString string

Definition at line 1140 of file tclscanner.cpp.

QCString string_command

Definition at line 1135 of file tclscanner.cpp.

QCString string_comment

Definition at line 1138 of file tclscanner.cpp.

QCString string_commentcodify

Definition at line 1137 of file tclscanner.cpp.

QCString string_commentline

Definition at line 1136 of file tclscanner.cpp.

QCString string_last

Definition at line 1139 of file tclscanner.cpp.

struct { ... } tcl

int tclscannerYY_flex_debug = 0

Definition at line 688 of file tclscanner.cpp.

FILE * tclscannerYYin = (FILE *) 0

Definition at line 372 of file tclscanner.cpp.

int tclscannerYYleng

Definition at line 307 of file tclscanner.cpp.

int tclscannerYYlineno = 1

Definition at line 378 of file tclscanner.cpp.

FILE * tclscannerYYout = (FILE *) 0

Definition at line 372 of file tclscanner.cpp.

char * tclscannerYYtext

Definition at line 699 of file tclscanner.cpp.

ParserInterface* this_parser

Definition at line 1123 of file tclscanner.cpp.

char word_is

Definition at line 1129 of file tclscanner.cpp.

yyconst flex_int16_t yy_accept[179]

static

Initial value:

=
    {   0,
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
        5,    5,    0,    0,    0,    0,    0,    0,   26,   26,
        0,    0,   56,   55,    1,    4,    3,    3,    2,    4,
       40,   37,   36,   34,   35,   40,   40,   54,   50,   52,
       53,   49,   48,   51,   46,   54,   47,   44,   45,   15,
        5,   14,   15,   55,   23,   24,   55,   55,   17,   18,
       55,   55,   20,   21,   55,   29,   26,   29,   25,   29,
       55,   31,   32,   55,    3,    0,   37,   36,   34,   35,
        0,    0,    0,    0,   39,    0,   42,   43,   41,    5,
        0,   12,   13,    0,    0,    0,    0,   23,   24,    0,

       22,    0,   17,   18,    0,    0,   20,   21,    0,    0,
       25,   26,    0,    0,   31,   32,    0,   30,   33,    0,
        0,    0,    8,   13,    0,    0,    0,    0,   11,    0,
        0,    0,   28,   25,    0,   38,    0,    6,   13,    0,
        7,    0,    0,    0,    0,   27,    6,    0,    0,    0,
        0,    0,    0,    0,    0,   12,    0,    0,    0,    9,
        9,    0,    0,    0,    0,    0,    0,    0,   16,    0,
       12,    0,   10,   10,    0,    0,   19,    0
    }

Definition at line 408 of file tclscanner.cpp.

register int yy_act

Definition at line 1689 of file tclscanner.cpp.

yyconst flex_int16_t yy_base[204]

static

Initial value:

=
    {   0,
        0,    0,  126,  112,    0,    8,   32,   70,  108,  147,
       14,   22,   19,   27,   35,   42,   44,   51,   57,   63,
       73,   77,  107,  615,  615,  615,   80,   91,  615,  100,
      615,  116,  615,  615,   99,   96,   89,  615,  615,  615,
      615,  615,  615,  615,  615,    3,  615,  615,  615,  615,
       38,  615,  119,   83,  615,  132,  134,   87,  615,  124,
      151,  136,  615,  139,  157,   88,  161,  615,   84,    4,
      142,  615,  166,  171,  175,   81,    0,  615,  615,  183,
       75,  187,   59,   60,  615,   16,  615,  615,  615,   48,
      194,  615,  198,  200,  223,  259,  206,  615,  210,  213,

      615,  202,  615,  217,  225,  229,  615,  236,  239,    8,
        0,  245,  241,  250,  615,  254,  256,  615,  615,    0,
      261,  264,  615,  268,  273,  287,  291,  297,  615,  299,
      301,  304,  615,  306,  311,  615,  320,  615,  334,  336,
      615,  338,  344,  340,  347,  615,  615,  363,  368,  370,
      353,  379,  383,  386,  397,  213,  394,  399,  414,  615,
      278,  408,  420,  434,  423,  439,  441,  451,  615,  455,
      294,  457,  615,  325,  460,  462,  615,  615,  493,  498,
      503,  508,  513,  518,  523,  528,  533,  538,  543,  547,
      549,  554,  559,  564,  569,  574,  579,  584,  589,  594,

      599,  604,  609
    }

Definition at line 471 of file tclscanner.cpp.

register char * yy_bp

Definition at line 1688 of file tclscanner.cpp.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 287 of file tclscanner.cpp.

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 286 of file tclscanner.cpp.

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 285 of file tclscanner.cpp.

char* yy_c_buf_p = (char *) 0

static

Definition at line 310 of file tclscanner.cpp.

yyconst flex_int16_t yy_chk[656]

static

Definition at line 601 of file tclscanner.cpp.

register char* yy_cp

Definition at line 1688 of file tclscanner.cpp.

YY_DECL

Initial value:

{
        register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 1686 of file tclscanner.cpp.

yyconst flex_int16_t yy_def[204]

static

Initial value:

=
    {   0,
      179,  179,  180,  180,  181,  181,  182,  182,  183,  183,
      184,  184,  185,  185,  186,  186,  187,  187,  188,  188,
      189,  189,  178,  178,  178,  178,  178,  178,  178,  178,
      178,  178,  178,  178,  178,  190,  178,  178,  178,  178,
      178,  178,  178,  178,  178,  191,  178,  178,  178,  178,
      178,  178,  192,  193,  178,  193,  193,  194,  178,  194,
      194,  195,  178,  195,  195,  196,  196,  178,  196,  196,
      197,  178,  197,  197,  178,  178,   32,  178,  178,  178,
      178,  178,  178,  178,  178,  178,  178,  178,  178,  178,
      192,  178,  192,  198,  192,  192,  193,  178,  193,  193,

      178,  194,  178,  194,  194,  195,  178,  195,  195,  196,
      196,  196,  199,  197,  178,  197,  197,  178,  178,  200,
      192,  198,  178,  198,  201,  198,  192,  192,  178,  194,
      195,  199,  178,  199,  199,  178,  201,  178,  201,  201,
      178,  192,  192,  194,  195,  178,  178,  192,  192,  194,
      195,  192,  192,  194,  195,  202,  192,  194,  195,  178,
      202,  192,  194,  195,  192,  194,  195,  192,  178,  195,
      203,  195,  178,  203,  195,  195,  178,    0,  178,  178,
      178,  178,  178,  178,  178,  178,  178,  178,  178,  178,
      178,  178,  178,  178,  178,  178,  178,  178,  178,  178,

      178,  178,  178
    }

Definition at line 498 of file tclscanner.cpp.

int yy_did_buffer_switch_on_eof

static

Definition at line 317 of file tclscanner.cpp.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 431 of file tclscanner.cpp.

char yy_hold_char

static

Definition at line 305 of file tclscanner.cpp.

int yy_init = 0

static

Definition at line 311 of file tclscanner.cpp.

char* yy_last_accepting_cpos

static

Definition at line 685 of file tclscanner.cpp.

yy_state_type yy_last_accepting_state

static

Definition at line 684 of file tclscanner.cpp.

yyconst flex_int32_t yy_meta[41]

static

Initial value:

=
    {   0,
        1,    2,    3,    1,    2,    2,    4,    1,    2,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    2,    5,    2,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    2
    }

Definition at line 463 of file tclscanner.cpp.

int yy_more_flag = 0

static

Definition at line 694 of file tclscanner.cpp.

int yy_more_len = 0

static

Definition at line 695 of file tclscanner.cpp.

int yy_n_chars

static

Definition at line 306 of file tclscanner.cpp.

yyconst flex_int16_t yy_nxt[656]

static

Definition at line 525 of file tclscanner.cpp.

yyconst flex_int32_t yy_rule_can_match_eol[56]

static

Initial value:

=
    {   0,
0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 
    1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,     }

Definition at line 678 of file tclscanner.cpp.

int yy_start = 0

static

Definition at line 312 of file tclscanner.cpp.

int* yy_start_stack = NULL

static

Definition at line 1580 of file tclscanner.cpp.

int yy_start_stack_depth = 0

static

Definition at line 1579 of file tclscanner.cpp.

int yy_start_stack_ptr = 0

static

Definition at line 1578 of file tclscanner.cpp.