Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02392.html | 3129 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3129 insertions(+) create mode 100644 docs/doxygen/nel/a02392.html (limited to 'docs/doxygen/nel/a02392.html') diff --git a/docs/doxygen/nel/a02392.html b/docs/doxygen/nel/a02392.html new file mode 100644 index 00000000..7ab73466 --- /dev/null +++ b/docs/doxygen/nel/a02392.html @@ -0,0 +1,3129 @@ + + +NeL: NLAISCRIPT::yyFlexLexer class Reference + + + +

NLAISCRIPT::yyFlexLexer Class Reference

#include <lex.h> +

Inheritance diagram for NLAISCRIPT::yyFlexLexer: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +


Public Member Functions
int	debug () const
int	lineno () const
void	set_debug (int flag)
virtual void	switch_streams (istream new_in, ostream new_out)
yy_buffer_state *	yy_create_buffer (istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
	yyFlexLexer (istream arg_yyin=0, ostream arg_yyout=0)
int	YYLeng ()
int	yylex (istream new_in, ostream new_out=0)
virtual int	yylex ()
void	yyrestart (istream *s)
const char *	YYText ()
virtual	~yyFlexLexer ()
Protected Member Functions
virtual void	LexerError (const char *msg)
virtual int	LexerInput (char *buf, int max_size)
virtual void	LexerOutput (const char *buf, int size)
virtual void	setNewLine ()=0
	Tell the _lastBlock about a newLine (for Debug).
void	yy_flush_buffer (struct yy_buffer_state *b)
int	yy_get_next_buffer ()
yy_state_type	yy_get_previous_state ()
void	yy_init_buffer (struct yy_buffer_state b, istream s)
void	yy_load_buffer_state ()
void	yy_pop_state ()
void	yy_push_state (int new_state)
int	yy_top_state ()
yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
int	yyinput ()
void	yyunput (int c, char *buf_ptr)
virtual int	yywrap ()=0
Protected Attributes
double	LastyyNum
char	LastyyText [2][1024 *4]
char *	yy_c_buf_p
yy_buffer_state *	yy_current_buffer
int	yy_did_buffer_switch_on_eof
int	yy_flex_debug
int	yy_full_lp
char *	yy_full_match
int *	yy_full_state
char	yy_hold_char
int	yy_init
char *	yy_last_accepting_cpos
yy_state_type	yy_last_accepting_state
int	yy_looking_for_trail_begin
int	yy_lp
int	yy_more_flag
int	yy_more_len
int	yy_n_chars
int	yy_start
int *	yy_start_stack
int	yy_start_stack_depth
int	yy_start_stack_ptr
yy_state_type *	yy_state_buf
yy_state_type *	yy_state_ptr
int	yyColone
istream *	yyin
int	yyleng
int	yyLine
int	yylineno
ostream *	yyout
char *	yytext

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
yyFlexLexer::yyFlexLexer ( istream * arg_yyin = 0,
ostream * arg_yyout = 0
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 2762 of file lexlang.cpp. +
+References YY_BUF_SIZE, yy_c_buf_p, yy_current_buffer, yy_did_buffer_switch_on_eof, NLAISCRIPT::FlexLexer::yy_flex_debug, yy_init, yy_looking_for_trail_begin, yy_more_flag, yy_more_len, yy_start, yy_state_buf, yy_state_type, yyin, and yyout. +
+
02763 { +02764 yyin = arg_yyin; +02765 yyout = arg_yyout; +02766 yy_c_buf_p = 0; +02767 yy_init = 1; +02768 yy_start = 0; +02769 yy_flex_debug = 0; +02770 yylineno = 1; // this will only get updated if %option yylineno +02771 +02772 yy_did_buffer_switch_on_eof = 0; +02773 +02774 yy_looking_for_trail_begin = 0; +02775 yy_more_flag = 0; +02776 yy_more_len = 0; +02777 +02778 yy_start_stack_ptr = yy_start_stack_depth = 0; +02779 yy_start_stack = 0; +02780 +02781 yy_current_buffer = 0; +02782 +02783 #ifdef YY_USES_REJECT +02784 yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2]; +02785 #else +02786 yy_state_buf = 0; +02787 #endif +02788 } +

+

+ + + + +
+ + + + + + + + + +
yyFlexLexer::~yyFlexLexer ( ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2790 of file lexlang.cpp. +
+References yy_current_buffer, yy_delete_buffer(), and yy_state_buf. +
+
02791 { +02792 delete yy_state_buf; +02793 yy_delete_buffer( yy_current_buffer ); +02794 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::debug ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 71 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yy_flex_debug. +
+
00071 { return yy_flex_debug; } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLAISCRIPT::yyFlexLexer::LexerError ( const char * msg ) [protected, virtual]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
int yyFlexLexer::LexerInput ( char * buf,
int max_size
) [protected, virtual]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2811 of file lexlang.cpp. +
+References yyin. +
+
02813 { +02814 if ( yyin->eof() || yyin->fail() ) +02815 return 0; +02816 +02817 #ifdef YY_INTERACTIVE +02818 yyin->get( buf[0] ); +02819 +02820 if ( yyin->eof() ) +02821 return 0; +02822 +02823 if ( yyin->bad() ) +02824 return -1; +02825 +02826 return 1; +02827 +02828 #else +02829 (void) yyin->read( buf, max_size ); +02830 +02831 if ( yyin->bad() ) +02832 return -1; +02833 else +02834 return yyin->gcount(); +02835 #endif +02836 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void yyFlexLexer::LexerOutput ( const char * buf,
int size
) [protected, virtual]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2838 of file lexlang.cpp. +
+References size, and yyout. +
+
02839 { +02840 (void) yyout->write( buf, size ); +02841 } +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::lineno ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 69 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yylineno. +
+
00069 { return yylineno; } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::FlexLexer::set_debug ( int flag ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 72 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yy_flex_debug. +
+
00072 { yy_flex_debug = flag; } +

+

+ + + + +
+ + + + + + + + + +
virtual void NLAISCRIPT::yyFlexLexer::setNewLine ( ) [protected, pure virtual]
+
+ + + + + +
+ + + +
+Tell the _lastBlock about a newLine (for Debug). +
+ +
+Implemented in NLAISCRIPT::CCompilateur.
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void yyFlexLexer::switch_streams ( istream * new_in,
ostream * new_out
) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 2796 of file lexlang.cpp. +
+References YY_BUF_SIZE, yy_create_buffer(), yy_current_buffer, yy_delete_buffer(), yy_switch_to_buffer(), and yyout. +
+
02797 { +02798 if ( new_in ) +02799 { +02800 yy_delete_buffer( yy_current_buffer ); +02801 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) ); +02802 } +02803 +02804 if ( new_out ) +02805 yyout = new_out; +02806 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer ( istream * s,
int size
) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 3180 of file lexlang.cpp. +
+References file, size, yy_buffer_state::yy_buf_size, YY_BUFFER_STATE, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yy_flex_alloc(), yy_init_buffer(), and yy_buffer_state::yy_is_our_buffer. +
+Referenced by switch_streams(), and yyrestart(). +
+
03181 { +03182 YY_BUFFER_STATE b; +03183 +03184 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); +03185 if ( ! b ) +03186 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); +03187 +03188 b->yy_buf_size = size; +03189 +03190 /* yy_ch_buf has to be 2 characters longer than the size given because +03191 * we need to put in 2 end-of-buffer characters. +03192 */ +03193 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); +03194 if ( ! b->yy_ch_buf ) +03195 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); +03196 +03197 b->yy_is_our_buffer = 1; +03198 +03199 yy_init_buffer( b, file ); +03200 +03201 return b; +03202 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state * b ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Referenced by switch_streams(), and ~yyFlexLexer().
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state * b ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yy_get_next_buffer ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2851 of file lexlang.cpp. +
+References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, YY_BUFFER_STATE, yy_buffer_state::yy_buffer_status, yy_c_buf_p, yy_buffer_state::yy_ch_buf, yy_current_buffer, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_fill_buffer, yy_flex_realloc(), YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, YY_READ_BUF_SIZE, yyin, yyrestart(), and yytext_ptr. +
+Referenced by yyinput(). +
+
02852 { +02853 register char *dest = yy_current_buffer->yy_ch_buf; +02854 register char *source = yytext_ptr; +02855 register int number_to_move, i; +02856 int ret_val; +02857 +02858 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) +02859 YY_FATAL_ERROR( +02860 "fatal flex scanner internal error--end of buffer missed" ); +02861 +02862 if ( yy_current_buffer->yy_fill_buffer == 0 ) +02863 { /* Don't try to fill the buffer, so this is an EOF. */ +02864 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) +02865 { +02866 /* We matched a singled characater, the EOB, so +02867 * treat this as a final EOF. +02868 */ +02869 return EOB_ACT_END_OF_FILE; +02870 } +02871 +02872 else +02873 { +02874 /* We matched some text prior to the EOB, first +02875 * process it. +02876 */ +02877 return EOB_ACT_LAST_MATCH; +02878 } +02879 } +02880 +02881 /* Try to read more data. */ +02882 +02883 /* First move last chars to start of buffer. */ +02884 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; +02885 +02886 for ( i = 0; i < number_to_move; ++i ) +02887 *(dest++) = *(source++); +02888 +02889 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) +02890 /* don't do the read, it's not guaranteed to return an EOF, +02891 * just force an EOF +02892 */ +02893 yy_n_chars = 0; +02894 +02895 else +02896 { +02897 int num_to_read = +02898 yy_current_buffer->yy_buf_size - number_to_move - 1; +02899 +02900 while ( num_to_read <= 0 ) +02901 { /* Not enough room in the buffer - grow it. */ +02902 #ifdef YY_USES_REJECT +02903 YY_FATAL_ERROR( +02904 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +02905 #else +02906 +02907 /* just a shorter name for the current buffer */ +02908 YY_BUFFER_STATE b = yy_current_buffer; +02909 +02910 int yy_c_buf_p_offset = +02911 (int) (yy_c_buf_p - b->yy_ch_buf); +02912 +02913 if ( b->yy_is_our_buffer ) +02914 { +02915 int new_size = b->yy_buf_size * 2; +02916 +02917 if ( new_size <= 0 ) +02918 b->yy_buf_size += b->yy_buf_size / 8; +02919 else +02920 b->yy_buf_size *= 2; +02921 +02922 b->yy_ch_buf = (char *) +02923 /* Include room in for 2 EOB chars. */ +02924 yy_flex_realloc( (void *) b->yy_ch_buf, +02925 b->yy_buf_size + 2 ); +02926 } +02927 else +02928 /* Can't grow it, we don't own it. */ +02929 b->yy_ch_buf = 0; +02930 +02931 if ( ! b->yy_ch_buf ) +02932 YY_FATAL_ERROR( +02933 "fatal error - scanner input buffer overflow" ); +02934 +02935 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; +02936 +02937 num_to_read = yy_current_buffer->yy_buf_size - +02938 number_to_move - 1; +02939 #endif +02940 } +02941 +02942 if ( num_to_read > YY_READ_BUF_SIZE ) +02943 num_to_read = YY_READ_BUF_SIZE; +02944 +02945 /* Read in more data. */ +02946 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), +02947 yy_n_chars, num_to_read ); +02948 } +02949 +02950 if ( yy_n_chars == 0 ) +02951 { +02952 if ( number_to_move == YY_MORE_ADJ ) +02953 { +02954 ret_val = EOB_ACT_END_OF_FILE; +02955 yyrestart( yyin ); +02956 } +02957 +02958 else +02959 { +02960 ret_val = EOB_ACT_LAST_MATCH; +02961 yy_current_buffer->yy_buffer_status = +02962 YY_BUFFER_EOF_PENDING; +02963 } +02964 } +02965 +02966 else +02967 ret_val = EOB_ACT_CONTINUE_SCAN; +02968 +02969 yy_n_chars += number_to_move; +02970 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; +02971 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; +02972 +02973 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; +02974 +02975 return ret_val; +02976 } +

+

+ + + + +
+ + + + + + + + + +
yy_state_type yyFlexLexer::yy_get_previous_state ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2981 of file lexlang.cpp. +
+References yy_accept, yy_c_buf_p, yy_last_accepting_cpos, yy_last_accepting_state, YY_MORE_ADJ, yy_NUL_trans, yy_nxt, YY_SC_TO_UI, yy_start, yy_state_type, and yytext_ptr. +
+
02982 { +02983 register yy_state_type yy_current_state; +02984 register char *yy_cp; +02985 +02986 yy_current_state = yy_start; +02987 +02988 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) +02989 { +02990 if ( *yy_cp ) +02991 { +02992 yy_current_state = yy_nxt[yy_current_state][YY_SC_TO_UI(*yy_cp)]; +02993 } +02994 else +02995 yy_current_state = yy_NUL_trans[yy_current_state]; +02996 if ( yy_accept[yy_current_state] ) +02997 { +02998 yy_last_accepting_state = yy_current_state; +02999 yy_last_accepting_cpos = yy_cp; +03000 } +03001 } +03002 +03003 return yy_current_state; +03004 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_init_buffer ( struct yy_buffer_state * b,
istream * s
) [protected]
+
+ + + + + +
+ + + +
+ +
+Referenced by yy_create_buffer(), and yyrestart().
+

+ + + + +
+ + + + + + + + + +
void yyFlexLexer::yy_load_buffer_state ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3171 of file lexlang.cpp. +
+References yy_buffer_state::yy_buf_pos, yy_c_buf_p, yy_current_buffer, yy_hold_char, yy_buffer_state::yy_input_file, yy_buffer_state::yy_n_chars, yyin, and yytext_ptr. +
+Referenced by yyrestart(). +
+
03172 { +03173 yy_n_chars = yy_current_buffer->yy_n_chars; +03174 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; +03175 yyin = yy_current_buffer->yy_input_file; +03176 yy_hold_char = *yy_c_buf_p; +03177 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_pop_state ( ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_push_state ( int new_state ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state * new_buffer ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Referenced by switch_streams().
+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::yyFlexLexer::yy_top_state ( ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type current_state ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3013 of file lexlang.cpp. +
+References yy_accept, yy_c_buf_p, yy_last_accepting_cpos, yy_last_accepting_state, yy_NUL_trans, and yy_state_type. +
+
03014 { +03015 register int yy_is_jam; +03016 register char *yy_cp = yy_c_buf_p; +03017 +03018 yy_current_state = yy_NUL_trans[yy_current_state]; +03019 yy_is_jam = (yy_current_state == 0); +03020 +03021 if ( ! yy_is_jam ) +03022 { +03023 if ( yy_accept[yy_current_state] ) +03024 { +03025 yy_last_accepting_state = yy_current_state; +03026 yy_last_accepting_cpos = yy_cp; +03027 } +03028 } +03029 +03030 return yy_is_jam ? 0 : yy_current_state; +03031 } +

+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yyinput ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3070 of file lexlang.cpp. +
+References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, input(), yy_c_buf_p, yy_buffer_state::yy_ch_buf, yy_current_buffer, yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_get_next_buffer(), yy_hold_char, YY_MORE_ADJ, YY_NEW_FILE, yytext_ptr, and yywrap(). +
+
03071 { +03072 int c; +03073 +03074 *yy_c_buf_p = yy_hold_char; +03075 +03076 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) +03077 { +03078 /* yy_c_buf_p now points to the character we want to return. +03079 * If this occurs *before* the EOB characters, then it's a +03080 * valid NUL; if not, then we've hit the end of the buffer. +03081 */ +03082 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) +03083 /* This was really a NUL. */ +03084 *yy_c_buf_p = '\0'; +03085 +03086 else +03087 { /* need more input */ +03088 yytext_ptr = yy_c_buf_p; +03089 ++yy_c_buf_p; +03090 +03091 switch ( yy_get_next_buffer() ) +03092 { +03093 case EOB_ACT_END_OF_FILE: +03094 { +03095 if ( yywrap() ) +03096 { +03097 yy_c_buf_p = +03098 yytext_ptr + YY_MORE_ADJ; +03099 return EOF; +03100 } +03101 +03102 if ( ! yy_did_buffer_switch_on_eof ) +03103 YY_NEW_FILE; +03104 #ifdef __cplusplus +03105 return yyinput(); +03106 #else +03107 return input(); +03108 #endif +03109 } +03110 +03111 case EOB_ACT_CONTINUE_SCAN: +03112 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; +03113 break; +03114 +03115 case EOB_ACT_LAST_MATCH: +03116 #ifdef __cplusplus +03117 YY_FATAL_ERROR( +03118 "unexpected last match in yyinput()" ); +03119 #else +03120 YY_FATAL_ERROR( +03121 "unexpected last match in input()" ); +03122 #endif +03123 } +03124 } +03125 } +03126 +03127 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ +03128 *yy_c_buf_p = '\0'; /* preserve yytext */ +03129 yy_hold_char = *++yy_c_buf_p; +03130 +03131 +03132 return c; +03133 } +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::YYLeng ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 46 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yyleng. +
+
00046 { return yyleng; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
int NLAISCRIPT::FlexLexer::yylex ( istream * new_in,
ostream * new_out = 0
) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 58 of file lex.h. +
+References NLAISCRIPT::FlexLexer::switch_streams(), and NLAISCRIPT::FlexLexer::yylex(). +
+
00059 { +00060 switch_streams( new_in, new_out ); +00061 return yylex(); +00062 } +

+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yylex ( ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 1985 of file lexlang.cpp. +
+References ACCOL_D, ACCOL_G, AND_BIN, AND_LOG, CHAINE, CROCHER_D, CROCHER_G, DIFF, DIV, ECHO, EG_LOG, EG_MATH, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, FOIS, NLAISCRIPT::GetIdentType(), NLAISCRIPT::GetNombre(), INF, INF_EG, INITIAL, INTERROGATION, LEPOINT, MOINS, NOMBRE, NON_BIN, OR_BIN, OR_LOG, PAR_D, PAR_G, PLUS, POINT_DEUX, POINT_VI, POWER, SCOP, SUP, SUP_EG, unput, VIRGULE, yy_accept, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_create_buffer, YY_DECL, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state, YY_MORE_ADJ, YY_NEW_FILE, yy_nxt, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, YY_STATE_EOF, yy_state_type, yy_try_NUL_trans(), yyin, yyout, yyterminate, yytext, yytext_ptr, and yywrap. +
+Referenced by NLAISCRIPT::CCompilateur::Compile(). +
+
01986 { +01987 register yy_state_type yy_current_state; +01988 register char *yy_cp, *yy_bp; +01989 register int yy_act; +01990 +01991 #line 25 "lexicon.lex" +01992 +01993 #line 1994 "lexyy.cc" +01994 +01995 if ( yy_init ) +01996 { +01997 yy_init = 0; +01998 +01999 #ifdef YY_USER_INIT +02000 YY_USER_INIT; +02001 #endif +02002 +02003 if ( ! yy_start ) +02004 yy_start = 1; /* first start state */ +02005 +02006 if ( ! yyin ) +02007 yyin = &cin; +02008 +02009 if ( ! yyout ) +02010 yyout = &cout; +02011 +02012 if ( ! yy_current_buffer ) +02013 yy_current_buffer = +02014 yy_create_buffer( yyin, YY_BUF_SIZE ); +02015 +02016 yy_load_buffer_state(); +02017 } +02018 +02019 while ( 1 ) /* loops until end-of-file is reached */ +02020 { +02021 yy_cp = yy_c_buf_p; +02022 +02023 /* Support of yytext. */ +02024 *yy_cp = yy_hold_char; +02025 +02026 /* yy_bp points to the position in yy_ch_buf of the start of +02027 * the current run. +02028 */ +02029 yy_bp = yy_cp; +02030 +02031 yy_current_state = yy_start; +02032 yy_match: +02033 while ( (yy_current_state = yy_nxt[yy_current_state][YY_SC_TO_UI(*yy_cp)]) > 0 ) +02034 { +02035 if ( yy_accept[yy_current_state] ) +02036 { +02037 yy_last_accepting_state = yy_current_state; +02038 yy_last_accepting_cpos = yy_cp; +02039 } +02040 +02041 ++yy_cp; +02042 } +02043 +02044 yy_current_state = -yy_current_state; +02045 +02046 yy_find_action: +02047 yy_act = yy_accept[yy_current_state]; +02048 +02049 YY_DO_BEFORE_ACTION; +02050 +02051 +02052 do_action: /* This label is used only to access EOF actions. */ +02053 +02054 +02055 switch ( yy_act ) +02056 { /* beginning of action switch */ +02057 case 0: /* must back up */ +02058 /* undo the effects of YY_DO_BEFORE_ACTION */ +02059 *yy_cp = yy_hold_char; +02060 yy_cp = yy_last_accepting_cpos + 1; +02061 yy_current_state = yy_last_accepting_state; +02062 goto yy_find_action; +02063 +02064 case 1: +02065 YY_RULE_SETUP +02066 #line 26 "lexicon.lex" +02067 { +02068 /*On ignore les espasement*/ +02069 yyColone += 5; +02070 } +02071 YY_BREAK +02072 case 2: +02073 YY_RULE_SETUP +02074 #line 30 "lexicon.lex" +02075 { +02076 /*On ignore les espasement*/ +02077 yyColone ++; +02078 } +02079 YY_BREAK +02080 case 3: +02081 YY_RULE_SETUP +02082 #line 35 "lexicon.lex" +02083 { +02084 /*On ignore les espasement*/ +02085 yyLine ++; +02086 yyColone = 0; +02087 setNewLine(); +02088 } +02089 YY_BREAK +02090 case 4: +02091 YY_RULE_SETUP +02092 #line 42 "lexicon.lex" +02093 { +02094 strcpy(LastyyText[0], LastyyText[1]); +02095 strcpy(LastyyText[1], yytext); +02096 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],2); +02097 yyColone += strlen(yytext); +02098 return NOMBRE; +02099 } +02100 YY_BREAK +02101 case 5: +02102 YY_RULE_SETUP +02103 #line 50 "lexicon.lex" +02104 { +02105 strcpy(LastyyText[0], LastyyText[1]); +02106 strcpy(LastyyText[1], yytext); +02107 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],10); +02108 yyColone += strlen(yytext); +02109 return NOMBRE; +02110 } +02111 YY_BREAK +02112 case 6: +02113 YY_RULE_SETUP +02114 #line 57 "lexicon.lex" +02115 { +02116 strcpy(LastyyText[0], LastyyText[1]); +02117 strcpy(LastyyText[1], yytext); +02118 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],16); +02119 yyColone += strlen(yytext); +02120 return NOMBRE; +02121 } +02122 YY_BREAK +02123 case 7: +02124 YY_RULE_SETUP +02125 #line 65 "lexicon.lex" +02126 { +02127 strcpy(LastyyText[0], LastyyText[1]); +02128 strcpy(LastyyText[1], yytext); +02129 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02130 yyColone += strlen(yytext); +02131 return NOMBRE; +02132 } +02133 YY_BREAK +02134 case 8: +02135 YY_RULE_SETUP +02136 #line 73 "lexicon.lex" +02137 { +02138 strcpy(LastyyText[0], LastyyText[1]); +02139 strcpy(LastyyText[1], yytext); +02140 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02141 yyColone += strlen(yytext); +02142 return NOMBRE; +02143 } +02144 YY_BREAK +02145 case 9: +02146 YY_RULE_SETUP +02147 #line 81 "lexicon.lex" +02148 { +02149 strcpy(LastyyText[0], LastyyText[1]); +02150 strcpy(LastyyText[1], yytext); +02151 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02152 yyColone += strlen(yytext); +02153 return NOMBRE; +02154 } +02155 YY_BREAK +02156 case 10: +02157 YY_RULE_SETUP +02158 #line 89 "lexicon.lex" +02159 { +02160 strcpy(LastyyText[0], LastyyText[1]); +02161 strcpy(LastyyText[1], yytext); +02162 yyColone += strlen(yytext); +02163 int i = NLAISCRIPT::GetIdentType(yytext); +02164 return i; +02165 +02166 } +02167 YY_BREAK +02168 case 11: +02169 YY_RULE_SETUP +02170 #line 98 "lexicon.lex" +02171 { +02172 yyColone ++; +02173 return LEPOINT; +02174 } +02175 YY_BREAK +02176 case 12: +02177 YY_RULE_SETUP +02178 #line 103 "lexicon.lex" +02179 { +02180 yyColone ++; +02181 return PAR_G; +02182 } +02183 YY_BREAK +02184 case 13: +02185 YY_RULE_SETUP +02186 #line 108 "lexicon.lex" +02187 { +02188 yyColone ++; +02189 return PAR_D; +02190 } +02191 YY_BREAK +02192 case 14: +02193 YY_RULE_SETUP +02194 #line 113 "lexicon.lex" +02195 { +02196 yyColone ++; +02197 int C = yyinput(); +02198 if(C == '=') +02199 { +02200 yyColone ++; +02201 return EG_LOG; +02202 } +02203 else +02204 { +02205 unput(C); +02206 yytext[1] = 0; +02207 } +02208 return EG_MATH; +02209 } +02210 YY_BREAK +02211 case 15: +02212 YY_RULE_SETUP +02213 #line 129 "lexicon.lex" +02214 { +02215 yyColone ++; +02216 int C = yyinput(); +02217 if(C == '=') +02218 { +02219 yyColone ++; +02220 return SUP_EG; +02221 } +02222 else +02223 { +02224 unput(C); +02225 yytext[1] = 0; +02226 } +02227 return SUP; +02228 } +02229 YY_BREAK +02230 case 16: +02231 YY_RULE_SETUP +02232 #line 145 "lexicon.lex" +02233 { +02234 yyColone ++; +02235 int C = yyinput(); +02236 if(C == '=') +02237 { +02238 yyColone ++; +02239 return INF_EG; +02240 } +02241 else +02242 { +02243 unput(C); +02244 yytext[1] = 0; +02245 } +02246 return INF; +02247 } +02248 YY_BREAK +02249 case 17: +02250 YY_RULE_SETUP +02251 #line 162 "lexicon.lex" +02252 { +02253 yyColone ++; +02254 int C = yyinput(); +02255 if(C == '=') +02256 { +02257 yyColone ++; +02258 return DIFF; +02259 } +02260 else +02261 { +02262 unput(C); +02263 yytext[1] = 0; +02264 } +02265 return NON_BIN; +02266 } +02267 YY_BREAK +02268 case 18: +02269 YY_RULE_SETUP +02270 #line 178 "lexicon.lex" +02271 { +02272 yyColone ++; +02273 int C = yyinput(); +02274 if(C == '|') +02275 { +02276 yyColone ++; +02277 return OR_LOG; +02278 } +02279 else +02280 { +02281 unput(C); +02282 yytext[1] = 0; +02283 } +02284 return OR_BIN; +02285 } +02286 YY_BREAK +02287 case 19: +02288 YY_RULE_SETUP +02289 #line 194 "lexicon.lex" +02290 { +02291 yyColone ++; +02292 int C = yyinput(); +02293 if(C == '&') +02294 { +02295 yyColone ++; +02296 return AND_LOG; +02297 } +02298 else +02299 { +02300 unput(C); +02301 yytext[1] = 0; +02302 } +02303 return AND_BIN; +02304 } +02305 YY_BREAK +02306 case 20: +02307 YY_RULE_SETUP +02308 #line 211 "lexicon.lex" +02309 { +02310 yyColone ++; +02311 return PLUS; +02312 } +02313 YY_BREAK +02314 case 21: +02315 YY_RULE_SETUP +02316 #line 216 "lexicon.lex" +02317 { +02318 yyColone ++; +02319 return MOINS; +02320 } +02321 YY_BREAK +02322 case 22: +02323 YY_RULE_SETUP +02324 #line 221 "lexicon.lex" +02325 { +02326 yyColone ++; +02327 return FOIS; +02328 } +02329 YY_BREAK +02330 case 23: +02331 YY_RULE_SETUP +02332 #line 226 "lexicon.lex" +02333 { +02334 yyColone ++; +02335 +02336 int C = yyinput(); +02337 if(C == '*') +02338 { +02339 yyColone ++; +02340 int NbrCom = 1; +02341 int BeginDebut = 0; +02342 int BeginFin = 0; +02343 #ifdef _DEBUG +02344 char DebugStr[2]; +02345 DebugStr[1] = 0; +02346 #endif +02347 while(1) +02348 { +02349 C = yyinput(); +02350 #ifdef _DEBUG +02351 DebugStr[0] = C; +02352 #endif +02353 yyColone ++; +02354 if(C == '\n') +02355 { +02356 yyLine ++; +02357 yyColone = 0; +02358 setNewLine(); +02359 continue; +02360 } +02361 if(C == '*' ) +02362 { +02363 yyColone ++; +02364 C = yyinput(); +02365 #ifdef _DEBUG +02366 DebugStr[0] = C; +02367 #endif +02368 if(C == '/') +02369 { +02370 yyColone ++; +02371 yytext[1] = 0; +02372 NbrCom --; +02373 if(!NbrCom) break; +02374 } +02375 else +02376 { +02377 unput(C); +02378 } +02379 } +02380 else +02381 if(C == '/') +02382 { +02383 yyColone ++; +02384 C = yyinput(); +02385 #ifdef _DEBUG +02386 DebugStr[0] = C; +02387 #endif +02388 if(C == '*') +02389 { +02390 yyColone ++; +02391 NbrCom ++; +02392 } +02393 else +02394 { +02395 unput(C); +02396 +02397 } +02398 } +02399 +02400 } +02401 } +02402 else +02403 if(C == '/') +02404 { +02405 yyColone ++; +02406 #ifdef _DEBUG +02407 char DebugStr[2]; +02408 DebugStr[1] = 0; +02409 #endif +02410 while(1) +02411 { +02412 C = yyinput(); +02413 #ifdef _DEBUG +02414 DebugStr[0] = C; +02415 #endif +02416 yyColone ++; +02417 if(C == '\n') +02418 { +02419 yyLine ++; +02420 yyColone = 0; +02421 setNewLine(); +02422 yytext[1] = 0; +02423 break; +02424 } +02425 } +02426 } +02427 else +02428 { +02429 unput(C); +02430 yytext[1] = 0; +02431 return DIV; +02432 } +02433 +02434 } +02435 YY_BREAK +02436 case 24: +02437 YY_RULE_SETUP +02438 #line 329 "lexicon.lex" +02439 { +02440 yyColone ++; +02441 return VIRGULE; +02442 } +02443 YY_BREAK +02444 case 25: +02445 YY_RULE_SETUP +02446 #line 334 "lexicon.lex" +02447 { +02448 yyColone ++; +02449 return POWER; +02450 } +02451 YY_BREAK +02452 case 26: +02453 YY_RULE_SETUP +02454 #line 339 "lexicon.lex" +02455 { +02456 yyColone ++; +02457 return POINT_VI; +02458 } +02459 YY_BREAK +02460 case 27: +02461 YY_RULE_SETUP +02462 #line 344 "lexicon.lex" +02463 { +02464 yyColone ++; +02465 int C = yyinput(); +02466 if(C == ':') +02467 { +02468 yyColone ++; +02469 return SCOP; +02470 } +02471 else +02472 { +02473 unput(C); +02474 yytext[1] = 0; +02475 } +02476 return POINT_DEUX; +02477 } +02478 YY_BREAK +02479 case 28: +02480 YY_RULE_SETUP +02481 #line 360 "lexicon.lex" +02482 { +02483 yyColone ++; +02484 return ACCOL_G; +02485 } +02486 YY_BREAK +02487 case 29: +02488 YY_RULE_SETUP +02489 #line 364 "lexicon.lex" +02490 { +02491 yyColone ++; +02492 return ACCOL_D; +02493 } +02494 YY_BREAK +02495 case 30: +02496 YY_RULE_SETUP +02497 #line 368 "lexicon.lex" +02498 { +02499 yyColone ++; +02500 return INTERROGATION; +02501 } +02502 YY_BREAK +02503 case 31: +02504 YY_RULE_SETUP +02505 #line 372 "lexicon.lex" +02506 { +02507 yyColone ++; +02508 char c = 0; +02509 int i = 0; +02510 strcpy(LastyyText[0], LastyyText[1]); +02511 while(c != 34) +02512 { +02513 c = yyinput(); +02514 yyColone ++; +02515 switch(c) +02516 { +02517 +02518 case 34: +02519 c = yyinput(); +02520 if(c == 34) +02521 { +02522 LastyyText[1][i] = c; +02523 i++; +02524 c = 0; +02525 } +02526 else +02527 { +02528 LastyyText[1][i] = 0; +02529 unput(c); +02530 c = 34; +02531 } +02532 break; +02533 +02534 case '\n': +02535 case '\r': +02536 yyLine ++; +02537 yyColone = 0; +02538 break; +02539 +02540 case '\t': +02541 yyColone +=5; +02542 break; +02543 case EOF: +02544 return 0; +02545 +02546 default: +02547 LastyyText[1][i] = c; +02548 i ++; +02549 break; +02550 } +02551 +02552 } +02553 return CHAINE; +02554 } +02555 YY_BREAK +02556 case 32: +02557 YY_RULE_SETUP +02558 #line 422 "lexicon.lex" +02559 { +02560 yyColone ++; +02561 char c = 0; +02562 int i = 0; +02563 strcpy(LastyyText[0], LastyyText[1]); +02564 while(c != 39) +02565 { +02566 c = yyinput(); +02567 yyColone ++; +02568 switch(c) +02569 { +02570 +02571 case 39: +02572 c = yyinput(); +02573 if(c == 39) +02574 { +02575 LastyyText[1][i] = c; +02576 i++; +02577 c = 0; +02578 } +02579 else +02580 { +02581 LastyyText[1][i] = 0; +02582 unput(c); +02583 c = 39; +02584 } +02585 break; +02586 +02587 case '\n': +02588 case '\r': +02589 yyLine ++; +02590 yyColone = 0; +02591 break; +02592 +02593 case '\t': +02594 yyColone +=5; +02595 break; +02596 case EOF: +02597 return 0; +02598 +02599 default: +02600 LastyyText[1][i] = c; +02601 i ++; +02602 break; +02603 } +02604 +02605 } +02606 return CHAINE; +02607 } +02608 YY_BREAK +02609 case 33: +02610 YY_RULE_SETUP +02611 #line 471 "lexicon.lex" +02612 { +02613 yyColone ++; +02614 return CROCHER_D; +02615 } +02616 YY_BREAK +02617 case 34: +02618 YY_RULE_SETUP +02619 #line 475 "lexicon.lex" +02620 { +02621 yyColone ++; +02622 return CROCHER_G; +02623 } +02624 YY_BREAK +02625 case 35: +02626 YY_RULE_SETUP +02627 #line 480 "lexicon.lex" +02628 ECHO; +02629 YY_BREAK +02630 #line 2631 "lexyy.cc" +02631 case YY_STATE_EOF(INITIAL): +02632 yyterminate(); +02633 +02634 case YY_END_OF_BUFFER: +02635 { +02636 /* Amount of text matched not including the EOB char. */ +02637 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; +02638 +02639 /* Undo the effects of YY_DO_BEFORE_ACTION. */ +02640 *yy_cp = yy_hold_char; +02641 +02642 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) +02643 { +02644 /* We're scanning a new file or input source. It's +02645 * possible that this happened because the user +02646 * just pointed yyin at a new source and called +02647 * yylex(). If so, then we have to assure +02648 * consistency between yy_current_buffer and our +02649 * globals. Here is the right place to do so, because +02650 * this is the first action (other than possibly a +02651 * back-up) that will match for the new input source. +02652 */ +02653 yy_n_chars = yy_current_buffer->yy_n_chars; +02654 yy_current_buffer->yy_input_file = yyin; +02655 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; +02656 } +02657 +02658 /* Note that here we test for yy_c_buf_p "<=" to the position +02659 * of the first EOB in the buffer, since yy_c_buf_p will +02660 * already have been incremented past the NUL character +02661 * (since all states make transitions on EOB to the +02662 * end-of-buffer state). Contrast this with the test +02663 * in input(). +02664 */ +02665 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) +02666 { /* This was really a NUL. */ +02667 yy_state_type yy_next_state; +02668 +02669 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; +02670 +02671 yy_current_state = yy_get_previous_state(); +02672 +02673 /* Okay, we're now positioned to make the NUL +02674 * transition. We couldn't have +02675 * yy_get_previous_state() go ahead and do it +02676 * for us because it doesn't know how to deal +02677 * with the possibility of jamming (and we don't +02678 * want to build jamming into it because then it +02679 * will run more slowly). +02680 */ +02681 +02682 yy_next_state = yy_try_NUL_trans( yy_current_state ); +02683 +02684 yy_bp = yytext_ptr + YY_MORE_ADJ; +02685 +02686 if ( yy_next_state ) +02687 { +02688 /* Consume the NUL. */ +02689 yy_cp = ++yy_c_buf_p; +02690 yy_current_state = yy_next_state; +02691 goto yy_match; +02692 } +02693 +02694 else +02695 { +02696 yy_cp = yy_c_buf_p; +02697 goto yy_find_action; +02698 } +02699 } +02700 +02701 else switch ( yy_get_next_buffer() ) +02702 { +02703 case EOB_ACT_END_OF_FILE: +02704 { +02705 yy_did_buffer_switch_on_eof = 0; +02706 +02707 if ( yywrap() ) +02708 { +02709 /* Note: because we've taken care in +02710 * yy_get_next_buffer() to have set up +02711 * yytext, we can now set up +02712 * yy_c_buf_p so that if some total +02713 * hoser (like flex itself) wants to +02714 * call the scanner after we return the +02715 * YY_NULL, it'll still work - another +02716 * YY_NULL will get returned. +02717 */ +02718 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; +02719 +02720 yy_act = YY_STATE_EOF(YY_START); +02721 goto do_action; +02722 } +02723 +02724 else +02725 { +02726 if ( ! yy_did_buffer_switch_on_eof ) +02727 YY_NEW_FILE; +02728 } +02729 break; +02730 } +02731 +02732 case EOB_ACT_CONTINUE_SCAN: +02733 yy_c_buf_p = +02734 yytext_ptr + yy_amount_of_matched_text; +02735 +02736 yy_current_state = yy_get_previous_state(); +02737 +02738 yy_cp = yy_c_buf_p; +02739 yy_bp = yytext_ptr + YY_MORE_ADJ; +02740 goto yy_match; +02741 +02742 case EOB_ACT_LAST_MATCH: +02743 yy_c_buf_p = +02744 &yy_current_buffer->yy_ch_buf[yy_n_chars]; +02745 +02746 yy_current_state = yy_get_previous_state(); +02747 +02748 yy_cp = yy_c_buf_p; +02749 yy_bp = yytext_ptr + YY_MORE_ADJ; +02750 goto yy_find_action; +02751 } +02752 break; +02753 } +02754 +02755 default: +02756 YY_FATAL_ERROR( +02757 "fatal flex scanner internal error--no action found" ); +02758 } /* end of action switch */ +02759 } /* end of scanning one token */ +02760 } /* end of yylex */ +

+

+ + + + +
+ + + + + + + + + + +
void yyFlexLexer::yyrestart ( istream * s ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 3136 of file lexlang.cpp. +
+References YY_BUF_SIZE, yy_create_buffer(), yy_current_buffer, yy_init_buffer(), yy_load_buffer_state(), and yyin. +
+Referenced by yy_get_next_buffer(). +
+
03137 { +03138 if ( ! yy_current_buffer ) +03139 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); +03140 +03141 yy_init_buffer( yy_current_buffer, input_file ); +03142 yy_load_buffer_state(); +03143 } +

+

+ + + + +
+ + + + + + + + + +
const char* NLAISCRIPT::FlexLexer::YYText ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 45 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yytext. +
+
00045 { return yytext; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yyunput ( int c,
char * buf_ptr
) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
virtual int NLAISCRIPT::yyFlexLexer::yywrap ( ) [protected, pure virtual]
+
+ + + + + +
+ + + +
+ +
+Implemented in NLAISCRIPT::CCompilateur. +
+Referenced by yyinput().
+

Field Documentation

+ + + + +
+ + +
double NLAISCRIPT::yyFlexLexer::LastyyNum [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 169 of file lex.h.
+

+ + + + +
+ + +
char NLAISCRIPT::yyFlexLexer::LastyyText[2][1024*4] [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 168 of file lex.h.
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_c_buf_p [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 138 of file lex.h. +
+Referenced by yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state(), yy_try_NUL_trans(), yyFlexLexer(), and yyinput().
+

+ + + + +
+ + +
struct yy_buffer_state* NLAISCRIPT::yyFlexLexer::yy_current_buffer [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 129 of file lex.h. +
+Referenced by switch_streams(), yy_get_next_buffer(), yy_load_buffer_state(), yyFlexLexer(), yyinput(), yyrestart(), and ~yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_did_buffer_switch_on_eof [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 145 of file lex.h. +
+Referenced by yyFlexLexer(), and yyinput().
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yy_flex_debug [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 78 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::debug(), NLAISCRIPT::FlexLexer::set_debug(), and yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_full_lp [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 158 of file lex.h.
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_full_match [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 156 of file lex.h.
+

+ + + + +
+ + +
int* NLAISCRIPT::yyFlexLexer::yy_full_state [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 157 of file lex.h.
+

+ + + + +
+ + +
char NLAISCRIPT::yyFlexLexer::yy_hold_char [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 132 of file lex.h. +
+Referenced by yy_load_buffer_state(), and yyinput().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_init [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 140 of file lex.h. +
+Referenced by yyFlexLexer().
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_last_accepting_cpos [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 151 of file lex.h. +
+Referenced by yy_get_previous_state(), and yy_try_NUL_trans().
+

+ + + + +
+ + +
yy_state_type NLAISCRIPT::yyFlexLexer::yy_last_accepting_state [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 150 of file lex.h. +
+Referenced by yy_get_previous_state(), and yy_try_NUL_trans().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_looking_for_trail_begin [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 161 of file lex.h. +
+Referenced by yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_lp [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 160 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_more_flag [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 163 of file lex.h. +
+Referenced by yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_more_len [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 164 of file lex.h. +
+Referenced by yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_n_chars [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 135 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 141 of file lex.h. +
+Referenced by yy_get_previous_state(), and yyFlexLexer().
+

+ + + + +
+ + +
int* NLAISCRIPT::yyFlexLexer::yy_start_stack [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 116 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start_stack_depth [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 115 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start_stack_ptr [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 114 of file lex.h.
+

+ + + + +
+ + +
yy_state_type* NLAISCRIPT::yyFlexLexer::yy_state_buf [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 153 of file lex.h. +
+Referenced by yyFlexLexer(), and ~yyFlexLexer().
+

+ + + + +
+ + +
yy_state_type* NLAISCRIPT::yyFlexLexer::yy_state_ptr [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 154 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yyColone [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 170 of file lex.h.
+

+ + + + +
+ + +
istream* NLAISCRIPT::yyFlexLexer::yyin [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 126 of file lex.h. +
+Referenced by yy_get_next_buffer(), yy_load_buffer_state(), yyFlexLexer(), yyrestart(), and NLAISCRIPT::CCompilateur::yywrap().
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yyleng [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 76 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::YYLeng().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yyLine [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 170 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yylineno [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 77 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::lineno().
+

+ + + + +
+ + +
ostream* NLAISCRIPT::yyFlexLexer::yyout [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 127 of file lex.h. +
+Referenced by LexerOutput(), switch_streams(), and yyFlexLexer().
+

+ + + + +
+ + +
char* NLAISCRIPT::FlexLexer::yytext [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 75 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::YYText().
+

The documentation for this class was generated from the following files:

lex.h
lexlang.cpp

Generated on Tue Mar 16 12:39:36 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1

NLAISCRIPT::yyFlexLexer Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation