NeL: cf_gramatical.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
union	YYSTYPE
Defines
#define	ADD_ASSIGN 257
#define	ASSIGN 258
#define	COMMA 270
#define	const
#define	DEBUG_PRINT(a)
#define	DEBUG_PRINTF
#define	DIVIDE 265
#define	INT 271
#define	LBRACE 269
#define	LPAREN 267
#define	MINUS 263
#define	MULT 264
#define	PLUS 262
#define	RBRACE 268
#define	REAL 272
#define	RPAREN 266
#define	SEMICOLON 261
#define	STRING 260
#define	VARIABLE 259
#define	YYABORT goto yyabortlab
#define	YYACCEPT goto yyacceptlab
#define	YYBACKUP(token, value)
#define	YYBISON 1 /* Identify Bison output. */
#define	yychar cfchar
#define	yyclearin (yychar = YYEMPTY)
#define	yydebug cfdebug
#define	YYEMPTY -2
#define	YYEOF 0
#define	YYERRCODE 256
#define	yyerrok (yyerrstatus = 0)
#define	YYERROR goto yyerrlab1
#define	yyerror cferror
#define	YYFAIL goto yyerrlab
#define	YYFINAL 45
#define	YYFLAG -32768
#define	YYINITDEPTH 200
#define	YYLAST 67
#define	YYLEX yylex()
#define	yylex cflex
#define	yylval cflval
#define	YYMAXDEPTH 10000
#define	yynerrs cfnerrs
#define	YYNTBASE 19
#define	yyparse cfparse
#define	YYPARSE_PARAM pvararray
#define	YYPARSE_PARAM_ARG YYPARSE_PARAM
#define	YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#define	YYPOPSTACK (yyvsp--, yyssp--)
#define	YYRECOVERING() (!!yyerrstatus)
#define	YYSTACK_ALLOC malloc
#define	YYTERROR 1
#define	YYTRANSLATE(x) ((unsigned)(x) <= 272 ? yytranslate[x] : 29)
Enumerations
enum	cf_operation { OP_PLUS, OP_MINUS, OP_MULT, OP_DIVIDE, OP_NEG }
Functions
void	__yy_memcpy (to, from, count) char *to
cf_value	cf_op (cf_value a, cf_value b, cf_operation op)
void	cf_print (cf_value Val)
void	cf_setVar (NLMISC::CConfigFile::CVar &Var, cf_value Val)
int	cferror (const char *)
int	cflex (void)
Variables
int	cf_CurrentLine
NLMISC::CConfigFile::CVar	cf_CurrentVar
bool	cf_Ignore
bool	cf_OverwriteExistingVariable
int	cfchar
YYSTYPE	cflval
int	cfnerrs
unsigned int	count
char *	from
bool	LoadRoot
short	yycheck []
short	yydefact []
short	yydefgoto []
FILE *	yyin
short	yypact []
short	yypgoto []
short	yyr1 []
short	yyr2 []
short	yytable []
char	yytranslate []

cf_gramatical.cpp File Reference

Data Structures

Defines

Enumerations

Functions

Variables

Define Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation