NeL: cf_lexical.cpp File Reference

01845         {
+01846         register yy_state_type yy_current_state;
+01847         register char *yy_cp, *yy_bp;
+01848         register int yy_act;
+01849 
+01850 #line 89 "cf_lexical.lxx"
+01851 
+01852 
+01853 #line 1854 "cf_lexical.cpp"
+01854 
+01855         if ( yy_init )
+01856                 {
+01857                 yy_init = 0;
+01858 
+01859 #ifdef YY_USER_INIT
+01860                 YY_USER_INIT;
+01861 #endif
+01862 
+01863                 if ( ! yy_start )
+01864                         yy_start = 1;   /* first start state */
+01865 
+01866                 if ( ! yyin )
+01867                         yyin = stdin;
+01868 
+01869                 if ( ! yyout )
+01870                         yyout = stdout;
+01871 
+01872                 if ( ! yy_current_buffer )
+01873                         yy_current_buffer =
+01874                                 yy_create_buffer( yyin, YY_BUF_SIZE );
+01875 
+01876                 yy_load_buffer_state();
+01877                 }
+01878 
+01879         while ( 1 )             /* loops until end-of-file is reached */
+01880                 {
+01881                 yy_cp = yy_c_buf_p;
+01882 
+01883                 /* Support of yytext. */
+01884                 *yy_cp = yy_hold_char;
+01885 
+01886                 /* yy_bp points to the position in yy_ch_buf of the start of
+01887                  * the current run.
+01888                  */
+01889                 yy_bp = yy_cp;
+01890 
+01891                 yy_current_state = yy_start;
+01892 yy_match:
+01893                 while ( (yy_current_state = yy_nxt[yy_current_state][YY_SC_TO_UI(*yy_cp)]) > 0 )
+01894                         {
+01895                         if ( yy_accept[yy_current_state] )
+01896                                 {
+01897                                 yy_last_accepting_state = yy_current_state;
+01898                                 yy_last_accepting_cpos = yy_cp;
+01899                                 }
+01900 
+01901                         ++yy_cp;
+01902                         }
+01903 
+01904                 yy_current_state = -yy_current_state;
+01905 
+01906 yy_find_action:
+01907                 yy_act = yy_accept[yy_current_state];
+01908 
+01909                 YY_DO_BEFORE_ACTION;
+01910 
+01911 
+01912 do_action:      /* This label is used only to access EOF actions. */
+01913 
+01914 
+01915                 switch ( yy_act )
+01916         { /* beginning of action switch */
+01917                         case 0: /* must back up */
+01918                         /* undo the effects of YY_DO_BEFORE_ACTION */
+01919                         *yy_cp = yy_hold_char;
+01920                         yy_cp = yy_last_accepting_cpos + 1;
+01921                         yy_current_state = yy_last_accepting_state;
+01922                         goto yy_find_action;
+01923 
+01924 case 1:
+01925 YY_RULE_SETUP
+01926 #line 91 "cf_lexical.lxx"
+01927 { if (!cf_Ignore) return PLUS; }
+01928         YY_BREAK
+01929 case 2:
+01930 YY_RULE_SETUP
+01931 #line 92 "cf_lexical.lxx"
+01932 { if (!cf_Ignore) return MINUS; }
+01933         YY_BREAK
+01934 case 3:
+01935 YY_RULE_SETUP
+01936 #line 93 "cf_lexical.lxx"
+01937 { if (!cf_Ignore) return MULT; }
+01938         YY_BREAK
+01939 case 4:
+01940 YY_RULE_SETUP
+01941 #line 94 "cf_lexical.lxx"
+01942 { if (!cf_Ignore) return DIVIDE; }
+01943         YY_BREAK
+01944 case 5:
+01945 YY_RULE_SETUP
+01946 #line 95 "cf_lexical.lxx"
+01947 { if (!cf_Ignore) return RPAREN; }
+01948         YY_BREAK
+01949 case 6:
+01950 YY_RULE_SETUP
+01951 #line 96 "cf_lexical.lxx"
+01952 { if (!cf_Ignore) return LPAREN; }
+01953         YY_BREAK
+01954 case 7:
+01955 YY_RULE_SETUP
+01956 #line 97 "cf_lexical.lxx"
+01957 { if (!cf_Ignore) return ASSIGN; }
+01958         YY_BREAK
+01959 case 8:
+01960 YY_RULE_SETUP
+01961 #line 98 "cf_lexical.lxx"
+01962 { if (!cf_Ignore) return ADD_ASSIGN; }
+01963         YY_BREAK
+01964 case 9:
+01965 YY_RULE_SETUP
+01966 #line 99 "cf_lexical.lxx"
+01967 { if (!cf_Ignore) return SEMICOLON; }
+01968         YY_BREAK
+01969 case 10:
+01970 YY_RULE_SETUP
+01971 #line 100 "cf_lexical.lxx"
+01972 { if (!cf_Ignore) return RBRACE; }
+01973         YY_BREAK
+01974 case 11:
+01975 YY_RULE_SETUP
+01976 #line 101 "cf_lexical.lxx"
+01977 { if (!cf_Ignore) return LBRACE; }
+01978         YY_BREAK
+01979 case 12:
+01980 YY_RULE_SETUP
+01981 #line 102 "cf_lexical.lxx"
+01982 { if (!cf_Ignore) return COMMA; }
+01983         YY_BREAK
+01984 case 13:
+01985 YY_RULE_SETUP
+01986 #line 104 "cf_lexical.lxx"
+01987 { /* ignore tabulation and spaces */; }
+01988         YY_BREAK
+01989 case 14:
+01990 YY_RULE_SETUP
+01991 #line 106 "cf_lexical.lxx"
+01992 {
+01993                                 /* ignore new line but count them */
+01994                                 cf_CurrentLine++;
+01995                                 DEBUG_PRINTF("*****line++ %d\n", cf_CurrentLine);
+01996                         }
+01997         YY_BREAK
+01998 case 15:
+01999 YY_RULE_SETUP
+02000 #line 112 "cf_lexical.lxx"
+02001 { comment(); }
+02002         YY_BREAK
+02003 case 16:
+02004 YY_RULE_SETUP
+02005 #line 114 "cf_lexical.lxx"
+02006 { /* Start of a comment */ cf_Ignore = true; }
+02007         YY_BREAK
+02008 case 17:
+02009 YY_RULE_SETUP
+02010 #line 116 "cf_lexical.lxx"
+02011 { /* End of a comment */ cf_Ignore = false; }
+02012         YY_BREAK
+02013 case 18:
+02014 YY_RULE_SETUP
+02015 #line 118 "cf_lexical.lxx"
+02016 { /* A string */
+02017                                 if (!cf_Ignore)
+02018                                 {
+02019                                         cflval.Val.Type = T_STRING;
+02020                                         strcpy (cflval.Val.String, yytext+1);
+02021                                         cflval.Val.String[strlen(cflval.Val.String)-1] = '\0';
+02022                                         DEBUG_PRINTF("lex: string '%s' '%s'\n", yytext, cflval.Val.String);
+02023                                         return STRING;
+02024                                 }
+02025                         }
+02026         YY_BREAK
+02027 case 19:
+02028 YY_RULE_SETUP
+02029 #line 129 "cf_lexical.lxx"
+02030 { /* A variable */
+02031                                 if (!cf_Ignore)
+02032                                 {
+02033                                         cflval.Val.Type = T_STRING;
+02034                                         strcpy (cflval.Val.String, yytext);
+02035                                         DEBUG_PRINTF("lex: variable '%s' '%s'\n", yytext, cflval.Val.String);
+02036                                         return VARIABLE;
+02037                                 }
+02038                         }
+02039         YY_BREAK
+02040 case 20:
+02041 YY_RULE_SETUP
+02042 #line 139 "cf_lexical.lxx"
+02043 { /* A real */
+02044                                 if (!cf_Ignore)
+02045                                 {
+02046                                         cflval.Val.Type = T_REAL;
+02047                                         cflval.Val.Real = atof (yytext);
+02048                                         DEBUG_PRINTF("lex: real '%s' '%f\n", yytext, cflval.Val.Real);
+02049                                         return REAL;
+02050                                 }
+02051                         }
+02052         YY_BREAK
+02053 case 21:
+02054 YY_RULE_SETUP
+02055 #line 149 "cf_lexical.lxx"
+02056 { /* An int */
+02057                                 if (!cf_Ignore)
+02058                                 {
+02059                                         cflval.Val.Type = T_INT;
+02060                                         cflval.Val.Int = atoi (yytext);
+02061                                         DEBUG_PRINTF("lex: int '%s' '%d'\n", yytext, cflval.Val.Int);
+02062                                         return INT;
+02063                                 }
+02064                         }
+02065         YY_BREAK
+02066 case 22:
+02067 YY_RULE_SETUP
+02068 #line 159 "cf_lexical.lxx"
+02069 { /* An hex int */
+02070                                 if (!cf_Ignore)
+02071                                 {
+02072                                         cflval.Val.Type = T_INT;
+02073                                         sscanf (yytext, "%x", &(cflval.Val.Int));
+02074                                         DEBUG_PRINTF("lex: hexa '%s' '0x%x' '%d'\n", yytext, cflval.Val.Int, cflval.Val.Int);
+02075                                         return INT;
+02076                                 }
+02077                         }
+02078         YY_BREAK
+02079 case 23:
+02080 YY_RULE_SETUP
+02081 #line 169 "cf_lexical.lxx"
+02082 ECHO;
+02083         YY_BREAK
+02084 #line 2085 "cf_lexical.cpp"
+02085 case YY_STATE_EOF(INITIAL):
+02086         yyterminate();
+02087 
+02088         case YY_END_OF_BUFFER:
+02089                 {
+02090                 /* Amount of text matched not including the EOB char. */
+02091                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+02092 
+02093                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
+02094                 *yy_cp = yy_hold_char;
+02095                 YY_RESTORE_YY_MORE_OFFSET
+02096 
+02097                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+02098                         {
+02099                         /* We're scanning a new file or input source.  It's
+02100                          * possible that this happened because the user
+02101                          * just pointed yyin at a new source and called
+02102                          * yylex().  If so, then we have to assure
+02103                          * consistency between yy_current_buffer and our
+02104                          * globals.  Here is the right place to do so, because
+02105                          * this is the first action (other than possibly a
+02106                          * back-up) that will match for the new input source.
+02107                          */
+02108                         yy_n_chars = yy_current_buffer->yy_n_chars;
+02109                         yy_current_buffer->yy_input_file = yyin;
+02110                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+02111                         }
+02112 
+02113                 /* Note that here we test for yy_c_buf_p "<=" to the position
+02114                  * of the first EOB in the buffer, since yy_c_buf_p will
+02115                  * already have been incremented past the NUL character
+02116                  * (since all states make transitions on EOB to the
+02117                  * end-of-buffer state).  Contrast this with the test
+02118                  * in input().
+02119                  */
+02120                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+02121                         { /* This was really a NUL. */
+02122                         yy_state_type yy_next_state;
+02123 
+02124                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+02125 
+02126                         yy_current_state = yy_get_previous_state();
+02127 
+02128                         /* Okay, we're now positioned to make the NUL
+02129                          * transition.  We couldn't have
+02130                          * yy_get_previous_state() go ahead and do it
+02131                          * for us because it doesn't know how to deal
+02132                          * with the possibility of jamming (and we don't
+02133                          * want to build jamming into it because then it
+02134                          * will run more slowly).
+02135                          */
+02136 
+02137                         yy_next_state = yy_try_NUL_trans( yy_current_state );
+02138 
+02139                         yy_bp = yytext_ptr + YY_MORE_ADJ;
+02140 
+02141                         if ( yy_next_state )
+02142                                 {
+02143                                 /* Consume the NUL. */
+02144                                 yy_cp = ++yy_c_buf_p;
+02145                                 yy_current_state = yy_next_state;
+02146                                 goto yy_match;
+02147                                 }
+02148 
+02149                         else
+02150                                 {
+02151                                 yy_cp = yy_c_buf_p;
+02152                                 goto yy_find_action;
+02153                                 }
+02154                         }
+02155 
+02156                 else switch ( yy_get_next_buffer() )
+02157                         {
+02158                         case EOB_ACT_END_OF_FILE:
+02159                                 {
+02160                                 yy_did_buffer_switch_on_eof = 0;
+02161 
+02162                                 if ( yywrap() )
+02163                                         {
+02164                                         /* Note: because we've taken care in
+02165                                          * yy_get_next_buffer() to have set up
+02166                                          * yytext, we can now set up
+02167                                          * yy_c_buf_p so that if some total
+02168                                          * hoser (like flex itself) wants to
+02169                                          * call the scanner after we return the
+02170                                          * YY_NULL, it'll still work - another
+02171                                          * YY_NULL will get returned.
+02172                                          */
+02173                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+02174 
+02175                                         yy_act = YY_STATE_EOF(YY_START);
+02176                                         goto do_action;
+02177                                         }
+02178 
+02179                                 else
+02180                                         {
+02181                                         if ( ! yy_did_buffer_switch_on_eof )
+02182                                                 YY_NEW_FILE;
+02183                                         }
+02184                                 break;
+02185                                 }
+02186 
+02187                         case EOB_ACT_CONTINUE_SCAN:
+02188                                 yy_c_buf_p =
+02189                                         yytext_ptr + yy_amount_of_matched_text;
+02190 
+02191                                 yy_current_state = yy_get_previous_state();
+02192 
+02193                                 yy_cp = yy_c_buf_p;
+02194                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
+02195                                 goto yy_match;
+02196 
+02197                         case EOB_ACT_LAST_MATCH:
+02198                                 yy_c_buf_p =
+02199                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
+02200 
+02201                                 yy_current_state = yy_get_previous_state();
+02202 
+02203                                 yy_cp = yy_c_buf_p;
+02204                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
+02205                                 goto yy_find_action;
+02206                         }
+02207                 break;
+02208                 }
+02209 
+02210         default:
+02211                 YY_FATAL_ERROR(
+02212                         "fatal flex scanner internal error--no action found" );
+02213         } /* end of action switch */
+02214                 } /* end of scanning one token */
+02215         } /* end of yylex */
+


Data Structures
struct	cf_value
struct	yy_buffer_state
Defines
#define	BEGIN yy_start = 1 + 2 *
#define	DEBUG_PRINTF
#define	ECHO (void) fwrite( yytext, yyleng, 1, yyout )
#define	EOB_ACT_CONTINUE_SCAN 0
#define	EOB_ACT_END_OF_FILE 1
#define	EOB_ACT_LAST_MATCH 2
#define	FLEX_SCANNER
#define	INITIAL 0
#define	REJECT reject_used_but_not_detected
#define	unput(c) yyunput( c, yytext_ptr )
#define	YY_AT_BOL() (yy_current_buffer->yy_at_bol)
#define	YY_BREAK break;
#define	YY_BUF_SIZE 16384
#define	YY_BUFFER_EOF_PENDING 2
#define	YY_BUFFER_NEW 0
#define	YY_BUFFER_NORMAL 1
#define	yy_create_buffer cf_create_buffer
#define	YY_CURRENT_BUFFER yy_current_buffer
#define	YY_DECL int yylex YY_PROTO(( void ))
#define	yy_delete_buffer cf_delete_buffer
#define	YY_DO_BEFORE_ACTION
#define	YY_END_OF_BUFFER 24
#define	YY_END_OF_BUFFER_CHAR 0
#define	YY_EXIT_FAILURE 2
#define	YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#define	yy_flex_debug cf_flex_debug
#define	YY_FLEX_MAJOR_VERSION 2
#define	YY_FLEX_MINOR_VERSION 5
#define	YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
#define	yy_flush_buffer cf_flush_buffer
#define	yy_init_buffer cf_init_buffer
#define	YY_INPUT(buf, result, max_size)
#define	yy_load_buffer_state cf_load_buffer_state
#define	YY_MORE_ADJ 0
#define	YY_NEVER_INTERACTIVE 1
#define	yy_new_buffer yy_create_buffer
#define	YY_NEW_FILE yyrestart( yyin )
#define	YY_NO_POP_STATE 1
#define	YY_NO_PUSH_STATE 1
#define	YY_NO_TOP_STATE 1
#define	YY_NO_UNPUT 1
#define	YY_NULL 0
#define	YY_NUM_RULES 23
#define	YY_PROTO(proto) ()
#define	YY_READ_BUF_SIZE 8192
#define	YY_RESTORE_YY_MORE_OFFSET
#define	YY_RULE_SETUP YY_USER_ACTION
#define	YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
#define	yy_scan_buffer cf_scan_buffer
#define	yy_scan_bytes cf_scan_bytes
#define	yy_scan_string cf_scan_string
#define	yy_set_bol(at_bol)
#define	yy_set_interactive(is_interactive)
#define	YY_START ((yy_start - 1) / 2)
#define	YY_START_STACK_INCR 25
#define	YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
#define	yy_switch_to_buffer cf_switch_to_buffer
#define	yyconst
#define	yyin cfin
#define	yyleng cfleng
#define	yyless(n)
#define	yyless(n)
#define	yylex cflex
#define	yymore() yymore_used_but_not_detected
#define	yyout cfout
#define	yyrestart cfrestart
#define	YYSTATE YY_START
#define	yyterminate() return YY_NULL
#define	yytext cftext
#define	yytext_ptr yytext
#define	yywrap cfwrap
Typedefs
typedef yy_buffer_state *	YY_BUFFER_STATE
typedef unsigned char	YY_CHAR
typedef unsigned int	yy_size_t
typedef int	yy_state_type
Enumerations
enum	cf_type { T_UNKNOWN, +T_INT, +T_STRING, +T_REAL + }
Functions
YY_BUFFER_STATE	cf_create_buffer ()
void	cf_delete_buffer ()
void	cf_flush_buffer ()
void	cf_init_buffer ()
void	cf_load_buffer_state ()
YY_BUFFER_STATE	cf_scan_buffer ()
YY_BUFFER_STATE	cf_scan_bytes ()
YY_BUFFER_STATE	cf_scan_string ()
void	cf_switch_to_buffer ()
int	cflex ()
void	cfrestart ()
int	cfwrap ()
void	comment ()
int	input ()
void	yy_fatal_error ()
void *	yy_flex_alloc ()
void	yy_flex_free ()
void *	yy_flex_realloc ()
int	yy_get_next_buffer ()
yy_state_type	yy_get_previous_state ()
yy_state_type	yy_try_NUL_trans (yy_current_state) yy_state_type yy_current_state
yy_state_type	yy_try_NUL_trans ()
Variables
int	cf_CurrentLine
CIFile	cf_ifile
bool	cf_Ignore
FILE *	cfin = (FILE ) 0 cfout = (FILE *) 0
int	cfleng
FILE *	cfout
char *	cftext
FILE *	file
int	len
int	size
short int	yy_accept [41]
char *	yy_c_buf_p = (char *) 0
YY_BUFFER_STATE	yy_current_buffer = 0
int	yy_did_buffer_switch_on_eof
char	yy_hold_char
int	yy_init = 1
char *	yy_last_accepting_cpos
yy_state_type	yy_last_accepting_state
int	yy_n_chars
yy_state_type	yy_NUL_trans [41]
short	yy_nxt [][256]
int	yy_start = 0

cf_lexical.cpp File Reference

Data Structures

Defines

Typedefs

Enumerations

Functions

Variables

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation