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