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