#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 |
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
|
Definition at line 71 of file lex.h. References NLAISCRIPT::FlexLexer::yy_flex_debug.
00071 { return yy_flex_debug; }
|
|
|
|
|
||||||||||||
|
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 }
|
|
||||||||||||
|
Definition at line 2838 of file lexlang.cpp.
02839 {
02840 (void) yyout->write( buf, size );
02841 }
|
|
|
Definition at line 69 of file lex.h. References NLAISCRIPT::FlexLexer::yylineno.
00069 { return yylineno; }
|
|
|
Definition at line 72 of file lex.h. References NLAISCRIPT::FlexLexer::yy_flex_debug.
00072 { yy_flex_debug = flag; }
|
|
|
Tell the _lastBlock about a newLine (for Debug).
Implemented in NLAISCRIPT::CCompilateur. |
|
||||||||||||
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
Implements NLAISCRIPT::FlexLexer. Referenced by switch_streams(), and ~yyFlexLexer(). |
|
|
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
Referenced by yy_create_buffer(), and yyrestart(). |
|
|
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 }
|
|
|
|
|
|
|
|
|
Implements NLAISCRIPT::FlexLexer. Referenced by switch_streams(). |
|
|
|
|
|
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 }
|
|
|
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 }
|
|
|
Definition at line 46 of file lex.h. References NLAISCRIPT::FlexLexer::yyleng.
00046 { return yyleng; }
|
|
||||||||||||
|
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 }
|
|
|
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 */
|
|
|
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 }
|
|
|
Definition at line 45 of file lex.h. References NLAISCRIPT::FlexLexer::yytext.
00045 { return yytext; }
|
|
||||||||||||
|
|
|
|
Implemented in NLAISCRIPT::CCompilateur. Referenced by yyinput(). |
|
|
|
|
|
|
|
|
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(). |
|
|
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(). |
|
|
Definition at line 145 of file lex.h. Referenced by yyFlexLexer(), and yyinput(). |
|
|
Definition at line 78 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::debug(), NLAISCRIPT::FlexLexer::set_debug(), and yyFlexLexer(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 132 of file lex.h. Referenced by yy_load_buffer_state(), and yyinput(). |
|
|
Definition at line 140 of file lex.h. Referenced by yyFlexLexer(). |
|
|
Definition at line 151 of file lex.h. Referenced by yy_get_previous_state(), and yy_try_NUL_trans(). |
|
|
Definition at line 150 of file lex.h. Referenced by yy_get_previous_state(), and yy_try_NUL_trans(). |
|
|
Definition at line 161 of file lex.h. Referenced by yyFlexLexer(). |
|
|
|
|
|
Definition at line 163 of file lex.h. Referenced by yyFlexLexer(). |
|
|
Definition at line 164 of file lex.h. Referenced by yyFlexLexer(). |
|
|
|
|
|
Definition at line 141 of file lex.h. Referenced by yy_get_previous_state(), and yyFlexLexer(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 153 of file lex.h. Referenced by yyFlexLexer(), and ~yyFlexLexer(). |
|
|
|
|
|
|
|
|
Definition at line 126 of file lex.h. Referenced by yy_get_next_buffer(), yy_load_buffer_state(), yyFlexLexer(), yyrestart(), and NLAISCRIPT::CCompilateur::yywrap(). |
|
|
Definition at line 76 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::YYLeng(). |
|
|
|
|
|
Definition at line 77 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::lineno(). |
|
|
Definition at line 127 of file lex.h. Referenced by LexerOutput(), switch_streams(), and yyFlexLexer(). |
|
|
Definition at line 75 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::YYText(). |
1.3.6