pegasus/src/Pegasus/Compiler/cimmof_lex.cpp - annotate

Return to cimmof_lex.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Compiler

1 mike 1.3 #define yy_create_buffer cimmof__create_buffer 2 #define yy_delete_buffer cimmof__delete_buffer 3 #define yy_scan_buffer cimmof__scan_buffer 4 #define yy_scan_string cimmof__scan_string 5 #define yy_scan_bytes cimmof__scan_bytes 6 #define yy_flex_debug cimmof__flex_debug 7 #define yy_init_buffer cimmof__init_buffer 8 #define yy_flush_buffer cimmof__flush_buffer 9 #define yy_load_buffer_state cimmof__load_buffer_state 10 #define yy_switch_to_buffer cimmof__switch_to_buffer 11 #define yyin cimmof_in 12 #define yyleng cimmof_leng 13 #define yylex cimmof_lex 14 #define yyout cimmof_out 15 #define yyrestart cimmof_restart 16 #define yytext cimmof_text 17 #define yywrap cimmof_wrap 18 19 #line 20 "cimmof_lex.cpp" 20 /* A lexical scanner generated by flex / 21 22 mike 1.3 / Scanner skeleton version:
23 bob 1.4 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
24 mike 1.3 / 25 26 #define FLEX_SCANNER 27 #define YY_FLEX_MAJOR_VERSION 2 28 #define YY_FLEX_MINOR_VERSION 5 29 30 #include <stdio.h> 31 32 33 / cfront 1.2 defines "c_plusplus" instead of "__cplusplus" / 34 #ifdef c_plusplus 35 #ifndef __cplusplus 36 #define __cplusplus 37 #endif 38 #endif 39 40 41 #ifdef __cplusplus 42 43 #include <stdlib.h> 44 #include <unistd.h> 45 mike 1.3 46 / Use prototypes in function declarations. / 47 #define YY_USE_PROTOS 48 49 / The "const" storage-class-modifier is valid. / 50 #define YY_USE_CONST 51 52 #else / ! __cplusplus / 53 54 #if __STDC__ 55 56 #define YY_USE_PROTOS 57 #define YY_USE_CONST 58 59 #endif / __STDC__ / 60 #endif / ! __cplusplus / 61 62 #ifdef __TURBOC__ 63 #pragma warn -rch 64 #pragma warn -use 65 #include <io.h> 66 mike 1.3 #include <stdlib.h> 67 #define YY_USE_CONST 68 #define YY_USE_PROTOS 69 #endif 70 71 #ifdef YY_USE_CONST 72 #define yyconst const 73 #else 74 #define yyconst 75 #endif 76 77 78 #ifdef YY_USE_PROTOS 79 #define YY_PROTO(proto) proto 80 #else 81 #define YY_PROTO(proto) () 82 #endif 83 84 / Returned upon end-of-file. / 85 #define YY_NULL 0 86 87 mike 1.3 / Promotes a possibly negative, possibly signed char to an unsigned 88 * integer for use as an array index. If the signed char is negative, 89 * we want to instead treat it as an 8-bit unsigned char, hence the 90 * double cast. 91 / 92 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 93 94 / Enter a start condition. This macro really ought to take a parameter, 95 * but we do it the disgusting crufty way forced on us by the ()-less 96 * definition of BEGIN. 97 / 98 #define BEGIN yy_start = 1 + 2 99 100 /* Translate the current start state into a value that can be later handed 101 * to BEGIN to return to the state. The YYSTATE alias is for lex 102 * compatibility. 103 / 104 #define YY_START ((yy_start - 1) / 2) 105 #define YYSTATE YY_START 106 107 / Action number for EOF rule of a given start state. / 108 mike 1.3 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 109 110 / Special action meaning "start processing a new file". / 111 #define YY_NEW_FILE yyrestart( yyin ) 112 113 #define YY_END_OF_BUFFER_CHAR 0 114 115 / Size of default input buffer. / 116 #define YY_BUF_SIZE 16384 117 118 typedef struct yy_buffer_state YY_BUFFER_STATE; 119 120 extern int yyleng; 121 extern FILE yyin, yyout; 122 123 #define EOB_ACT_CONTINUE_SCAN 0 124 #define EOB_ACT_END_OF_FILE 1 125 #define EOB_ACT_LAST_MATCH 2 126 127 /* The funky do-while in the following #define is used to turn the definition 128 * int a single C statement (which needs a semi-colon terminator). This 129 mike 1.3 * avoids problems with code like: 130 * 131 * if ( condition_holds ) 132 * yyless( 5 ); 133 * else 134 * do_something_else(); 135 * 136 * Prior to using the do-while the compiler would get upset at the 137 * "else" because it interpreted the "if" statement as being all 138 * done when it reached the ';' after the yyless() call. 139 / 140 141 / Return all but the first 'n' matched characters back to the input stream. / 142 143 #define yyless(n) \ 144 do \ 145 { \ 146 / Undo effects of setting up yytext. / \ 147 yy_cp = yy_hold_char; \ 148 YY_RESTORE_YY_MORE_OFFSET \ 149 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 150 mike 1.3 YY_DO_BEFORE_ACTION; /* set up yytext again / \ 151 } \ 152 while ( 0 ) 153 154 #define unput(c) yyunput( c, yytext_ptr ) 155 156 / The following is because we cannot portably get our hands on size_t 157 * (without autoconf's help, which isn't available because we want 158 * flex-generated scanners to compile on their own). 159 / 160 typedef unsigned int yy_size_t; 161 162 163 struct yy_buffer_state 164 { 165 FILE yy_input_file; 166 167 char yy_ch_buf; / input buffer / 168 char yy_buf_pos; /* current position in input buffer / 169 170 / Size of input buffer in bytes, not including room for EOB 171 mike 1.3 * characters. 172 / 173 yy_size_t yy_buf_size; 174 175 / Number of characters read into yy_ch_buf, not including EOB 176 * characters. 177 / 178 int yy_n_chars; 179 180 / Whether we "own" the buffer - i.e., we know we created it, 181 * and can realloc() it to grow it, and should free() it to 182 * delete it. 183 / 184 int yy_is_our_buffer; 185 186 / Whether this is an "interactive" input source; if so, and 187 * if we're using stdio for input, then we want to use getc() 188 * instead of fread(), to make sure we stop fetching input after 189 * each newline. 190 / 191 int yy_is_interactive; 192 mike 1.3 193 / Whether we're considered to be at the beginning of a line. 194 * If so, '^' rules will be active on the next match, otherwise 195 * not. 196 / 197 int yy_at_bol; 198 199 / Whether to try to fill the input buffer when we reach the 200 * end of it. 201 / 202 int yy_fill_buffer; 203 204 int yy_buffer_status; 205 #define YY_BUFFER_NEW 0 206 #define YY_BUFFER_NORMAL 1 207 / When an EOF's been seen but there's still some text to process 208 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 209 * shouldn't try reading from the input source any more. We might 210 * still have a bunch of tokens to match, though, because of 211 * possible backing-up. 212 * 213 mike 1.3 * When we actually see the EOF, we change the status to "new" 214 * (via yyrestart()), so that the user can continue scanning by 215 * just pointing yyin at a new input file. 216 / 217 #define YY_BUFFER_EOF_PENDING 2 218 }; 219 220 static YY_BUFFER_STATE yy_current_buffer = 0; 221 222 / We provide macros for accessing buffer states in case in the 223 * future we want to put the buffer states in a more general 224 * "scanner state". 225 / 226 #define YY_CURRENT_BUFFER yy_current_buffer 227 228 229 / yy_hold_char holds the character lost when yytext is formed. / 230 static char yy_hold_char; 231 232 static int yy_n_chars; / number of characters read into yy_ch_buf / 233 234 mike 1.3 235 int yyleng; 236 237 / Points to current character in buffer. / 238 static char yy_c_buf_p = (char ) 0; 239 static int yy_init = 1; / whether we need to initialize / 240 static int yy_start = 0; / start state number / 241 242 / Flag which is used to allow yywrap()'s to do buffer switches 243 * instead of setting up a fresh yyin. A bit of a hack ... 244 / 245 static int yy_did_buffer_switch_on_eof; 246 247 void yyrestart YY_PROTO(( FILE input_file )); 248 249 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 250 void yy_load_buffer_state YY_PROTO(( void )); 251 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE file, int size )); 252 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 253 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE file )); 254 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 255 mike 1.3 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 256 257 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char base, yy_size_t size )); 258 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char yy_str )); 259 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char bytes, int len )); 260 261 static void yy_flex_alloc YY_PROTO(( yy_size_t )); 262 static void yy_flex_realloc YY_PROTO(( void , yy_size_t )); 263 static void yy_flex_free YY_PROTO(( void * )); 264 265 #define yy_new_buffer yy_create_buffer 266 267 #define yy_set_interactive(is_interactive) \ 268 { \ 269 if ( ! yy_current_buffer ) \ 270 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 271 yy_current_buffer->yy_is_interactive = is_interactive; \ 272 } 273 274 #define yy_set_bol(at_bol) \ 275 { \ 276 mike 1.3 if ( ! yy_current_buffer ) \ 277 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 278 yy_current_buffer->yy_at_bol = at_bol; \ 279 } 280 281 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 282 283 typedef unsigned char YY_CHAR; 284 FILE yyin = (FILE ) 0, yyout = (FILE ) 0; 285 typedef int yy_state_type; 286 extern char yytext; 287 #define yytext_ptr yytext 288 289 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 290 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 291 static int yy_get_next_buffer YY_PROTO(( void )); 292 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 293 294 / Done after the current pattern has been matched and before the 295 * corresponding action - sets up yytext. 296 / 297 mike 1.3 #define YY_DO_BEFORE_ACTION \ 298 yytext_ptr = yy_bp; \ 299 yyleng = (int) (yy_cp - yy_bp); \ 300 yy_hold_char = yy_cp; \ 301 yy_cp = '\0'; \ 302 yy_c_buf_p = yy_cp; 303 304 #define YY_NUM_RULES 68 305 #define YY_END_OF_BUFFER 69 306 static yyconst short int yy_accept[274] = 307 { 0, 308 0, 0, 69, 67, 3, 1, 26, 67, 67, 67, 309 9, 10, 67, 20, 27, 67, 17, 17, 11, 12, 310 19, 66, 66, 66, 66, 66, 66, 66, 66, 66, 311 66, 66, 66, 66, 66, 66, 66, 66, 7, 8, 312 66, 5, 6, 0, 22, 0, 65, 0, 0, 18, 313 18, 18, 13, 2, 17, 0, 66, 66, 29, 66, 314 66, 66, 66, 66, 66, 66, 66, 66, 66, 31, 315 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 316 66, 0, 21, 14, 14, 16, 13, 2, 2, 15, 317 41, 66, 66, 66, 66, 66, 66, 66, 66, 66, 318 mike 1.3 319 66, 66, 66, 66, 66, 66, 66, 66, 42, 66, 320 66, 66, 66, 66, 66, 66, 66, 66, 66, 0, 321 13, 13, 66, 66, 66, 66, 66, 66, 66, 66, 322 66, 66, 66, 66, 23, 66, 66, 66, 66, 66, 323 66, 66, 66, 66, 66, 66, 66, 24, 66, 66, 324 0, 66, 66, 66, 63, 66, 66, 66, 25, 66, 325 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 326 66, 66, 33, 66, 66, 66, 57, 66, 66, 66, 327 66, 66, 66, 53, 4, 0, 66, 66, 64, 66, 328 66, 66, 43, 66, 66, 66, 39, 66, 66, 66, 329 330 61, 62, 66, 66, 34, 58, 59, 60, 50, 66, 331 66, 54, 55, 56, 28, 66, 51, 66, 66, 66, 332 49, 66, 66, 66, 66, 66, 66, 66, 66, 66, 333 66, 52, 66, 66, 66, 30, 66, 37, 66, 66, 334 66, 66, 66, 66, 66, 66, 66, 40, 32, 38, 335 66, 66, 66, 66, 66, 66, 36, 46, 47, 66, 336 35, 66, 66, 66, 66, 66, 48, 66, 66, 66, 337 44, 45, 0 338 } ; 339 mike 1.3 340 static yyconst int yy_ec[256] = 341 { 0, 342 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 343 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 345 1, 2, 1, 5, 6, 7, 1, 1, 8, 9, 346 10, 1, 11, 12, 11, 13, 14, 15, 16, 17, 347 18, 19, 20, 21, 20, 22, 23, 24, 25, 1, 348 26, 1, 1, 1, 27, 28, 29, 30, 31, 32, 349 33, 34, 35, 36, 36, 37, 38, 39, 40, 41, 350 42, 43, 44, 45, 46, 47, 36, 36, 48, 36, 351 49, 1, 50, 1, 36, 1, 51, 28, 52, 30, 352 353 31, 32, 33, 34, 35, 36, 36, 53, 38, 39, 354 40, 41, 42, 43, 54, 45, 46, 47, 36, 55, 355 48, 36, 56, 1, 57, 1, 1, 1, 1, 1, 356 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 357 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 360 mike 1.3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 361 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 362 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 363 364 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 365 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 366 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 367 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 368 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 369 1, 1, 1, 1, 1 370 } ; 371 372 static yyconst int yy_meta[58] = 373 { 0, 374 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 375 4, 1, 5, 1, 6, 6, 6, 6, 6, 6, 376 6, 6, 6, 1, 1, 1, 7, 7, 7, 7, 377 7, 7, 3, 3, 3, 3, 3, 3, 3, 3, 378 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 379 7, 7, 3, 3, 8, 1, 1 380 } ; 381 mike 1.3 382 static yyconst short int yy_base[284] = 383 { 0, 384 0, 0, 397, 398, 398, 398, 55, 355, 0, 0, 385 398, 398, 46, 398, 0, 381, 50, 51, 398, 398, 386 398, 26, 354, 359, 39, 353, 40, 0, 352, 359, 387 343, 356, 41, 341, 355, 43, 33, 350, 398, 398, 388 41, 398, 398, 66, 398, 341, 0, 375, 0, 94, 389 70, 369, 350, 377, 0, 0, 0, 331, 35, 338, 390 69, 332, 43, 72, 65, 73, 96, 331, 66, 0, 391 332, 334, 77, 100, 95, 334, 329, 77, 106, 332, 392 319, 107, 361, 0, 121, 398, 357, 364, 398, 0, 393 0, 326, 93, 322, 333, 111, 335, 99, 315, 102, 394 395 326, 315, 325, 108, 114, 317, 110, 119, 326, 311, 396 324, 313, 308, 317, 305, 311, 318, 303, 293, 313, 397 334, 333, 130, 312, 144, 297, 313, 127, 309, 299, 398 292, 138, 141, 297, 0, 298, 304, 299, 152, 290, 399 289, 293, 299, 153, 290, 300, 132, 0, 163, 273, 400 288, 290, 150, 303, 0, 288, 141, 291, 0, 278, 401 290, 156, 280, 288, 286, 273, 283, 297, 294, 281, 402 mike 1.3 276, 160, 0, 289, 292, 289, 0, 274, 160, 151, 403 285, 288, 285, 0, 0, 164, 166, 264, 0, 264, 404 270, 260, 0, 268, 253, 166, 0, 252, 251, 260, 405 406 0, 0, 255, 167, 0, 0, 0, 0, 0, 160, 407 171, 0, 0, 0, 398, 248, 0, 261, 251, 243, 408 0, 254, 257, 256, 238, 254, 171, 239, 175, 238, 409 247, 0, 234, 249, 239, 0, 235, 0, 234, 245, 410 244, 155, 176, 233, 227, 214, 215, 0, 0, 0, 411 213, 162, 210, 198, 182, 181, 0, 0, 0, 168, 412 0, 177, 179, 179, 173, 112, 0, 78, 70, 51, 413 0, 0, 398, 227, 233, 241, 245, 75, 247, 253, 414 261, 264, 268 415 } ; 416 417 static yyconst short int yy_def[284] = 418 { 0, 419 273, 1, 273, 273, 273, 273, 274, 273, 275, 276, 420 273, 273, 277, 273, 278, 273, 279, 279, 273, 273, 421 273, 280, 280, 280, 280, 280, 280, 280, 280, 280, 422 280, 280, 280, 280, 280, 280, 280, 280, 273, 273, 423 mike 1.3 280, 273, 273, 274, 273, 273, 275, 276, 278, 273, 424 277, 277, 278, 281, 18, 282, 280, 280, 280, 280, 425 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 426 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 427 280, 273, 276, 50, 50, 273, 283, 281, 273, 282, 428 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 429 430 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 431 280, 280, 280, 280, 280, 280, 280, 280, 280, 273, 432 283, 283, 280, 280, 280, 280, 280, 280, 280, 280, 433 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 434 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 435 273, 280, 280, 280, 280, 280, 280, 280, 280, 280, 436 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 437 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 438 280, 280, 280, 280, 280, 273, 280, 280, 280, 280, 439 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 440 441 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 442 280, 280, 280, 280, 273, 280, 280, 280, 280, 280, 443 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 444 mike 1.3 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 445 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 446 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 447 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 448 280, 280, 0, 273, 273, 273, 273, 273, 273, 273, 449 273, 273, 273 450 } ; 451 452 static yyconst short int yy_nxt[456] = 453 { 0, 454 4, 5, 6, 5, 7, 8, 9, 10, 11, 12, 455 13, 14, 15, 16, 17, 18, 18, 18, 18, 18, 456 18, 18, 18, 19, 20, 21, 22, 23, 24, 25, 457 26, 27, 28, 28, 29, 28, 28, 30, 31, 32, 458 33, 34, 35, 36, 37, 38, 28, 28, 39, 40, 459 22, 41, 28, 36, 28, 42, 43, 45, 49, 45, 460 50, 51, 49, 49, 58, 62, 65, 71, 45, 59, 461 45, 75, 78, 63, 61, 79, 66, 76, 92, 59, 462 53, 272, 49, 72, 51, 51, 96, 77, 92, 62, 463 65, 71, 66, 81, 75, 94, 96, 86, 97, 99, 464 465 mike 1.3 271, 98, 104, 107, 56, 273, 49, 270, 84, 84, 466 85, 85, 85, 85, 85, 52, 52, 98, 104, 94, 467 115, 86, 97, 99, 100, 101, 108, 107, 111, 124, 468 115, 109, 116, 120, 112, 85, 85, 127, 131, 102, 469 136, 269, 129, 110, 135, 124, 138, 100, 273, 102, 470 108, 117, 129, 110, 131, 139, 116, 120, 152, 154, 471 135, 127, 138, 158, 136, 155, 162, 163, 174, 168, 472 175, 139, 169, 176, 177, 180, 188, 191, 181, 158, 473 182, 152, 195, 183, 184, 180, 205, 211, 210, 162, 474 215, 163, 216, 191, 223, 228, 229, 230, 252, 240, 475 476 188, 242, 253, 211, 264, 259, 195, 268, 252, 267, 477 205, 210, 229, 266, 215, 259, 216, 223, 228, 265, 478 264, 230, 240, 263, 262, 242, 253, 44, 44, 44, 479 44, 44, 44, 44, 44, 47, 261, 260, 47, 47, 480 47, 48, 258, 48, 48, 48, 48, 48, 48, 52, 481 52, 55, 55, 257, 55, 57, 256, 255, 57, 57, 482 57, 88, 88, 88, 88, 88, 88, 88, 88, 90, 483 90, 122, 254, 122, 251, 250, 249, 248, 247, 246, 484 245, 244, 243, 241, 239, 238, 237, 236, 235, 234, 485 233, 232, 231, 227, 226, 225, 224, 222, 221, 220, 486 mike 1.3 487 219, 218, 217, 214, 213, 212, 209, 208, 207, 206, 488 204, 203, 202, 201, 200, 199, 198, 197, 196, 194, 489 193, 192, 190, 189, 187, 186, 185, 179, 178, 173, 490 172, 171, 170, 167, 166, 165, 164, 161, 160, 159, 491 157, 156, 153, 273, 273, 151, 150, 149, 148, 147, 492 146, 145, 144, 143, 142, 141, 140, 137, 134, 133, 493 132, 130, 128, 126, 125, 123, 89, 121, 83, 119, 494 118, 114, 113, 106, 105, 103, 95, 93, 91, 89, 495 87, 49, 83, 82, 80, 74, 73, 70, 69, 68, 496 67, 64, 61, 60, 54, 46, 273, 3, 273, 273, 497 498 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 499 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 500 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 501 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 502 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 503 273, 273, 273, 273, 273 504 } ; 505 506 static yyconst short int yy_chk[456] = 507 mike 1.3 { 0, 508 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 510 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 512 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 513 1, 1, 1, 1, 1, 1, 1, 7, 13, 7, 514 13, 13, 17, 18, 22, 25, 27, 33, 44, 22, 515 44, 36, 37, 25, 41, 37, 27, 36, 59, 22, 516 278, 270, 51, 33, 51, 51, 63, 36, 59, 25, 517 27, 33, 27, 41, 36, 61, 63, 51, 64, 66, 518 519 269, 65, 69, 73, 17, 18, 50, 268, 50, 50, 520 50, 50, 50, 50, 50, 50, 50, 65, 69, 61, 521 78, 50, 64, 66, 67, 67, 74, 73, 75, 93, 522 78, 74, 79, 82, 75, 85, 85, 96, 100, 67, 523 105, 266, 98, 74, 104, 93, 107, 67, 85, 67, 524 74, 79, 98, 74, 100, 108, 79, 82, 123, 125, 525 104, 96, 107, 128, 105, 125, 132, 133, 144, 139, 526 144, 108, 139, 144, 144, 147, 153, 157, 149, 128, 527 149, 123, 162, 149, 149, 147, 172, 180, 179, 132, 528 mike 1.3 186, 133, 187, 157, 196, 204, 210, 211, 242, 227, 529 530 153, 229, 243, 180, 260, 252, 162, 265, 242, 264, 531 172, 179, 210, 263, 186, 252, 187, 196, 204, 262, 532 260, 211, 227, 256, 255, 229, 243, 274, 274, 274, 533 274, 274, 274, 274, 274, 275, 254, 253, 275, 275, 534 275, 276, 251, 276, 276, 276, 276, 276, 276, 277, 535 277, 279, 279, 247, 279, 280, 246, 245, 280, 280, 536 280, 281, 281, 281, 281, 281, 281, 281, 281, 282, 537 282, 283, 244, 283, 241, 240, 239, 237, 235, 234, 538 233, 231, 230, 228, 226, 225, 224, 223, 222, 220, 539 219, 218, 216, 203, 200, 199, 198, 195, 194, 192, 540 541 191, 190, 188, 183, 182, 181, 178, 176, 175, 174, 542 171, 170, 169, 168, 167, 166, 165, 164, 163, 161, 543 160, 158, 156, 154, 152, 151, 150, 146, 145, 143, 544 142, 141, 140, 138, 137, 136, 134, 131, 130, 129, 545 127, 126, 124, 122, 121, 120, 119, 118, 117, 116, 546 115, 114, 113, 112, 111, 110, 109, 106, 103, 102, 547 101, 99, 97, 95, 94, 92, 88, 87, 83, 81, 548 80, 77, 76, 72, 71, 68, 62, 60, 58, 54, 549 mike 1.3 53, 52, 48, 46, 38, 35, 34, 32, 31, 30, 550 29, 26, 24, 23, 16, 8, 3, 273, 273, 273, 551 552 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 553 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 554 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 555 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 556 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 557 273, 273, 273, 273, 273 558 } ; 559 560 static yy_state_type yy_last_accepting_state; 561 static char yy_last_accepting_cpos; 562 563 /* The intent behind this definition is that it'll catch 564 * any uses of REJECT which flex missed. 565 / 566 #define REJECT reject_used_but_not_detected 567 #define yymore() yymore_used_but_not_detected 568 #define YY_MORE_ADJ 0 569 #define YY_RESTORE_YY_MORE_OFFSET 570 mike 1.3 char yytext; 571 #line 1 "cimmof.l" 572 #define INITIAL 0 573 #define YY_NEVER_INTERACTIVE 1 574 #line 3 "cimmof.l" 575 576 #include "cimmofParser.h" 577 #include "memobjs.h" 578 #include "cimmof_tab.h" 579 580 /---------------------------------------------------------------/ 581 /* These routines wrap certain flex functions, keeping down the / 582 / number of external dependencies / 583 /---------------------------------------------------------------/ 584 int get_yy_buf_size_wrapper() { return YY_BUF_SIZE; } 585 586 void get_cimmof__current_buffer_wrapper() { 587 return (void )YY_CURRENT_BUFFER; 588 } 589 590 void create_cimmof_buffer_wrapper(const FILE f, int size) { 591 mike 1.3 return (void )yy_create_buffer((FILE )f, size); 592 } 593 594 int switch_to_buffer_wrapper(void buffstate) { 595 yy_switch_to_buffer((YY_BUFFER_STATE)buffstate); 596 return 0; 597 } 598 599 600 601 #line 602 "cimmof_lex.cpp" 602 603 /* Macros after this point can all be overridden by user definitions in 604 * section 1. 605 / 606 607 #ifndef YY_SKIP_YYWRAP 608 #ifdef __cplusplus 609 extern "C" int yywrap YY_PROTO(( void )); 610 #else 611 extern int yywrap YY_PROTO(( void )); 612 mike 1.3 #endif 613 #endif 614 615 #ifndef YY_NO_UNPUT 616 static void yyunput YY_PROTO(( int c, char buf_ptr )); 617 #endif 618 619 #ifndef yytext_ptr 620 static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int )); 621 #endif 622 623 #ifdef YY_NEED_STRLEN 624 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 625 #endif 626 627 #ifndef YY_NO_INPUT 628 #ifdef __cplusplus 629 static int yyinput YY_PROTO(( void )); 630 #else 631 static int input YY_PROTO(( void )); 632 #endif 633 mike 1.3 #endif 634 635 #if YY_STACK_USED 636 static int yy_start_stack_ptr = 0; 637 static int yy_start_stack_depth = 0; 638 static int yy_start_stack = 0; 639 #ifndef YY_NO_PUSH_STATE 640 static void yy_push_state YY_PROTO(( int new_state )); 641 #endif 642 #ifndef YY_NO_POP_STATE 643 static void yy_pop_state YY_PROTO(( void )); 644 #endif 645 #ifndef YY_NO_TOP_STATE 646 static int yy_top_state YY_PROTO(( void )); 647 #endif 648 649 #else 650 #define YY_NO_PUSH_STATE 1 651 #define YY_NO_POP_STATE 1 652 #define YY_NO_TOP_STATE 1 653 #endif 654 mike 1.3 655 #ifdef YY_MALLOC_DECL 656 YY_MALLOC_DECL 657 #else 658 #if __STDC__ 659 #ifndef __cplusplus 660 #include <stdlib.h> 661 #endif 662 #else 663 / Just try to get by without declaring the routines. This will fail 664 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 665 * or sizeof(void) != sizeof(int). 666 / 667 #endif 668 #endif 669 670 /* Amount of stuff to slurp up with each read. / 671 #ifndef YY_READ_BUF_SIZE 672 #define YY_READ_BUF_SIZE 8192 673 #endif 674 675 mike 1.3 / Copy whatever the last rule matched to the standard output. / 676 677 #ifndef ECHO 678 / This used to be an fputs(), but since the string might contain NUL's, 679 * we now use fwrite(). 680 / 681 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 682 #endif 683 684 / Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 685 * is returned in "result". 686 / 687 #ifndef YY_INPUT 688 #define YY_INPUT(buf,result,max_size) \ 689 if ( yy_current_buffer->yy_is_interactive ) \ 690 { \ 691 int c = '', n; \ 692 for ( n = 0; n < max_size && \ 693 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 694 buf[n] = (char) c; \ 695 if ( c == '\n' ) \ 696 mike 1.3 buf[n++] = (char) c; \ 697 if ( c == EOF && ferror( yyin ) ) \ 698 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 699 result = n; \ 700 } \ 701 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 702 && ferror( yyin ) ) \ 703 YY_FATAL_ERROR( "input in flex scanner failed" ); 704 #endif 705 706 /* No semi-colon after return; correct usage is to write "yyterminate();" - 707 * we don't want an extra ';' after the "return" because that will cause 708 * some compilers to complain about unreachable statements. 709 / 710 #ifndef yyterminate 711 #define yyterminate() return YY_NULL 712 #endif 713 714 / Number of entries by which start-condition stack grows. / 715 #ifndef YY_START_STACK_INCR 716 #define YY_START_STACK_INCR 25 717 mike 1.3 #endif 718 719 / Report a fatal error. / 720 #ifndef YY_FATAL_ERROR 721 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 722 #endif 723 724 / Default declaration of generated scanner - a define so the user can 725 * easily add parameters. 726 / 727 #ifndef YY_DECL 728 #define YY_DECL int yylex YY_PROTO(( void )) 729 #endif 730 731 / Code executed at the beginning of each rule, after yytext and yyleng 732 * have been set up. 733 / 734 #ifndef YY_USER_ACTION 735 #define YY_USER_ACTION 736 #endif 737 738 mike 1.3 / Code executed at the end of each rule. */ 739 #ifndef YY_BREAK 740 #define YY_BREAK break; 741 #endif 742 743 #define YY_RULE_SETUP \ 744 YY_USER_ACTION 745 746 YY_DECL 747 { 748 register yy_state_type yy_current_state;
749 karl 1.5 register char yy_cp, yy_bp;
750 mike 1.3 register int yy_act; 751 752 #line 32 "cimmof.l" 753 754 755 756 #line 757 "cimmof_lex.cpp" 757 758 if ( yy_init ) 759 { 760 yy_init = 0; 761 762 #ifdef YY_USER_INIT 763 YY_USER_INIT; 764 #endif 765 766 if ( ! yy_start ) 767 yy_start = 1; /* first start state / 768 769 if ( ! yyin ) 770 yyin = stdin; 771 mike 1.3 772 if ( ! yyout ) 773 yyout = stdout; 774 775 if ( ! yy_current_buffer ) 776 yy_current_buffer = 777 yy_create_buffer( yyin, YY_BUF_SIZE ); 778 779 yy_load_buffer_state(); 780 } 781 782 while ( 1 ) / loops until end-of-file is reached / 783 { 784 yy_cp = yy_c_buf_p; 785 786 / Support of yytext. / 787 yy_cp = yy_hold_char; 788 789 /* yy_bp points to the position in yy_ch_buf of the start of 790 * the current run. 791 / 792 mike 1.3 yy_bp = yy_cp; 793 794 yy_current_state = yy_start; 795 yy_match: 796 do 797 { 798 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(yy_cp)]; 799 if ( yy_accept[yy_current_state] ) 800 { 801 yy_last_accepting_state = yy_current_state; 802 yy_last_accepting_cpos = yy_cp; 803 } 804 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 805 { 806 yy_current_state = (int) yy_def[yy_current_state]; 807 if ( yy_current_state >= 274 ) 808 yy_c = yy_meta[(unsigned int) yy_c]; 809 } 810 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 811 ++yy_cp; 812 } 813 mike 1.3 while ( yy_base[yy_current_state] != 398 ); 814 815 yy_find_action: 816 yy_act = yy_accept[yy_current_state]; 817 if ( yy_act == 0 ) 818 { /* have to back up / 819 yy_cp = yy_last_accepting_cpos; 820 yy_current_state = yy_last_accepting_state; 821 yy_act = yy_accept[yy_current_state]; 822 } 823 824 YY_DO_BEFORE_ACTION; 825 826 827 do_action: / This label is used only to access EOF actions. / 828 829 830 switch ( yy_act ) 831 { / beginning of action switch / 832 case 0: / must back up / 833 / undo the effects of YY_DO_BEFORE_ACTION / 834 mike 1.3 yy_cp = yy_hold_char; 835 yy_cp = yy_last_accepting_cpos; 836 yy_current_state = yy_last_accepting_state; 837 goto yy_find_action; 838 839 case 1: 840 YY_RULE_SETUP 841 #line 35 "cimmof.l" 842 { 843 cimmofParser::Instance()->increment_lineno(); } 844 YY_BREAK 845 case 2: 846 YY_RULE_SETUP 847 #line 37 "cimmof.l" 848 { 849 cimmofParser::Instance()->increment_lineno(); } 850 YY_BREAK 851 case 3: 852 YY_RULE_SETUP 853 #line 39 "cimmof.l" 854 { /* skip white space */ } 855 mike 1.3 YY_BREAK 856 case 4: 857 YY_RULE_SETUP 858 #line 40 "cimmof.l" 859 { return(TOK_CLASS); } 860 YY_BREAK 861 case 5: 862 YY_RULE_SETUP 863 #line 41 "cimmof.l" 864 { return(TOK_LEFTCURLYBRACE); } 865 YY_BREAK 866 case 6: 867 YY_RULE_SETUP 868 #line 42 "cimmof.l" 869 { return(TOK_RIGHTCURLYBRACE); } 870 YY_BREAK 871 case 7: 872 YY_RULE_SETUP 873 #line 43 "cimmof.l" 874 { return(TOK_LEFTSQUAREBRACKET); } 875 YY_BREAK 876 mike 1.3 case 8: 877 YY_RULE_SETUP 878 #line 44 "cimmof.l" 879 { return(TOK_RIGHTSQUAREBRACKET); } 880 YY_BREAK 881 case 9: 882 YY_RULE_SETUP 883 #line 45 "cimmof.l" 884 { return(TOK_LEFTPAREN); } 885 YY_BREAK 886 case 10: 887 YY_RULE_SETUP 888 #line 46 "cimmof.l" 889 { return(TOK_RIGHTPAREN); } 890 YY_BREAK 891 case 11: 892 YY_RULE_SETUP 893 #line 47 "cimmof.l" 894 { return(TOK_COLON); } 895 YY_BREAK 896 case 12: 897 mike 1.3 YY_RULE_SETUP 898 #line 48 "cimmof.l" 899 { return(TOK_SEMICOLON); } 900 YY_BREAK 901 case 13: 902 YY_RULE_SETUP 903 #line 49 "cimmof.l" 904 { 905 cimmof_lval.strval = new String(yytext); 906 return(TOK_REAL_VALUE); } 907 YY_BREAK 908 case 14: 909 YY_RULE_SETUP 910 #line 52 "cimmof.l" 911 { cimmof_lval.strval = new String(yytext); 912 return(TOK_OCTAL_VALUE); } 913 YY_BREAK 914 case 15: 915 YY_RULE_SETUP 916 #line 54 "cimmof.l" 917 { cimmof_lval.strval = new String(yytext); 918 mike 1.3 return(TOK_HEX_VALUE); } 919 YY_BREAK 920 case 16: 921 YY_RULE_SETUP 922 #line 56 "cimmof.l" 923 { cimmof_lval.strval = new String(yytext); 924 return(TOK_BINARY_VALUE); } 925 YY_BREAK 926 case 17: 927 YY_RULE_SETUP 928 #line 58 "cimmof.l" 929 { cimmof_lval.strval = new String(yytext); 930 return(TOK_POSITIVE_DECIMAL_VALUE); } 931 YY_BREAK 932 case 18: 933 YY_RULE_SETUP 934 #line 60 "cimmof.l" 935 { cimmof_lval.strval = new String(yytext); 936 return(TOK_SIGNED_DECIMAL_VALUE); } 937 YY_BREAK 938 case 19: 939 mike 1.3 YY_RULE_SETUP 940 #line 62 "cimmof.l" 941 { return(TOK_EQUAL); } 942 YY_BREAK 943 case 20: 944 YY_RULE_SETUP 945 #line 63 "cimmof.l" 946 { return(TOK_COMMA); } 947 YY_BREAK 948 case 21: 949 YY_RULE_SETUP 950 #line 64 "cimmof.l" 951 { cimmof_lval.strval = new String(yytext); 952 return(TOK_CHAR_VALUE); } 953 YY_BREAK 954 case 22: 955 YY_RULE_SETUP 956 #line 66 "cimmof.l" 957 { cimmof_lval.strval = new String(yytext); 958 return(TOK_STRING_VALUE); } 959 YY_BREAK 960 mike 1.3 case 23: 961 YY_RULE_SETUP 962 #line 68 "cimmof.l" 963 { return(TOK_NULL_VALUE); } 964 YY_BREAK 965 case 24: 966 YY_RULE_SETUP 967 #line 69 "cimmof.l" 968 { return(TOK_TRUE); } 969 YY_BREAK 970 case 25: 971 YY_RULE_SETUP 972 #line 70 "cimmof.l" 973 { return(TOK_FALSE); } 974 YY_BREAK 975 case 26: 976 YY_RULE_SETUP 977 #line 71 "cimmof.l" 978 { return(TOK_DQUOTE); } 979 YY_BREAK 980 case 27: 981 mike 1.3 YY_RULE_SETUP 982 #line 72 "cimmof.l" 983 { return(TOK_PERIOD); } 984 YY_BREAK 985 case 28: 986 YY_RULE_SETUP 987 #line 73 "cimmof.l" 988 { return(TOK_PRAGMA); } 989 YY_BREAK 990 case 29: 991 YY_RULE_SETUP 992 #line 74 "cimmof.l" 993 { return(TOK_AS); } 994 YY_BREAK 995 case 30: 996 YY_RULE_SETUP 997 #line 75 "cimmof.l" 998 { 999 return(TOK_INSTANCE); } 1000 YY_BREAK 1001 case 31: 1002 mike 1.3 YY_RULE_SETUP 1003 #line 77 "cimmof.l" 1004 { 1005 return(TOK_OF); } 1006 YY_BREAK 1007 case 32: 1008 YY_RULE_SETUP 1009 #line 79 "cimmof.l" 1010 {return(TOK_QUALIFIER); } 1011 YY_BREAK 1012 case 33: 1013 YY_RULE_SETUP 1014 #line 80 "cimmof.l" 1015 { return(TOK_SCOPE); } 1016 YY_BREAK 1017 case 34: 1018 YY_RULE_SETUP 1019 #line 81 "cimmof.l" 1020 { return(TOK_SCHEMA); } 1021 YY_BREAK 1022 case 35: 1023 mike 1.3 YY_RULE_SETUP 1024 #line 82 "cimmof.l" 1025 { 1026 return(TOK_ASSOCIATION); } 1027 YY_BREAK 1028 case 36: 1029 YY_RULE_SETUP 1030 #line 84 "cimmof.l" 1031 { 1032 return(TOK_INDICATION); } 1033 YY_BREAK 1034 case 37: 1035 YY_RULE_SETUP 1036 #line 86 "cimmof.l" 1037 { return(TOK_PROPERTY); } 1038 YY_BREAK 1039 case 38: 1040 YY_RULE_SETUP 1041 #line 87 "cimmof.l" 1042 { return(TOK_REFERENCE); } 1043 YY_BREAK 1044 mike 1.3 case 39: 1045 YY_RULE_SETUP 1046 #line 88 "cimmof.l" 1047 { return(TOK_METHOD); } 1048 YY_BREAK 1049 case 40: 1050 YY_RULE_SETUP 1051 #line 89 "cimmof.l" 1052 {return(TOK_PARAMETER); } 1053 YY_BREAK 1054 case 41: 1055 YY_RULE_SETUP 1056 #line 90 "cimmof.l" 1057 { return(TOK_ANY); } 1058 YY_BREAK 1059 case 42: 1060 YY_RULE_SETUP 1061 #line 91 "cimmof.l" 1062 { return(TOK_REF); } 1063 YY_BREAK 1064 case 43: 1065 mike 1.3 YY_RULE_SETUP 1066 #line 92 "cimmof.l" 1067 { return(TOK_FLAVOR); } 1068 YY_BREAK 1069 case 44: 1070 YY_RULE_SETUP 1071 #line 93 "cimmof.l" 1072 { 1073 return(TOK_ENABLEOVERRIDE); } 1074 YY_BREAK 1075 case 45: 1076 YY_RULE_SETUP 1077 #line 95 "cimmof.l" 1078 { 1079 return(TOK_DISABLEOVERRIDE); } 1080 YY_BREAK 1081 case 46: 1082 YY_RULE_SETUP 1083 #line 97 "cimmof.l" 1084 { 1085 return(TOK_RESTRICTED); } 1086 mike 1.3 YY_BREAK 1087 case 47: 1088 YY_RULE_SETUP 1089 #line 99 "cimmof.l" 1090 {return(TOK_TOSUBCLASS); } 1091 YY_BREAK 1092 case 48: 1093 YY_RULE_SETUP 1094 #line 100 "cimmof.l" 1095 { 1096 return(TOK_TRANSLATABLE); } 1097 YY_BREAK 1098 case 49: 1099 YY_RULE_SETUP 1100 #line 102 "cimmof.l" 1101 { return(TOK_INCLUDE); } 1102 YY_BREAK 1103 case 50: 1104 YY_RULE_SETUP 1105 #line 103 "cimmof.l" 1106 { return(TOK_DT_STR); } 1107 mike 1.3 YY_BREAK 1108 case 51: 1109 YY_RULE_SETUP 1110 #line 104 "cimmof.l" 1111 { return(TOK_DT_BOOL); } 1112 YY_BREAK 1113 case 52: 1114 YY_RULE_SETUP 1115 #line 105 "cimmof.l" 1116 { return(TOK_DT_DATETIME); } 1117 YY_BREAK 1118 case 53: 1119 YY_RULE_SETUP 1120 #line 106 "cimmof.l" 1121 { return(TOK_DT_UINT8); } 1122 YY_BREAK 1123 case 54: 1124 YY_RULE_SETUP 1125 #line 107 "cimmof.l" 1126 { return(TOK_DT_UINT16); } 1127 YY_BREAK 1128 mike 1.3 case 55: 1129 YY_RULE_SETUP 1130 #line 108 "cimmof.l" 1131 { return(TOK_DT_UINT32); } 1132 YY_BREAK 1133 case 56: 1134 YY_RULE_SETUP 1135 #line 109 "cimmof.l" 1136 { return(TOK_DT_UINT64); } 1137 YY_BREAK 1138 case 57: 1139 YY_RULE_SETUP 1140 #line 110 "cimmof.l" 1141 { return(TOK_DT_SINT8); } 1142 YY_BREAK 1143 case 58: 1144 YY_RULE_SETUP 1145 #line 111 "cimmof.l" 1146 { return(TOK_DT_SINT16); } 1147 YY_BREAK 1148 case 59: 1149 mike 1.3 YY_RULE_SETUP 1150 #line 112 "cimmof.l" 1151 { return(TOK_DT_SINT32); } 1152 YY_BREAK 1153 case 60: 1154 YY_RULE_SETUP 1155 #line 113 "cimmof.l" 1156 { return(TOK_DT_SINT64); } 1157 YY_BREAK 1158 case 61: 1159 YY_RULE_SETUP 1160 #line 114 "cimmof.l" 1161 { return(TOK_DT_REAL32); } 1162 YY_BREAK 1163 case 62: 1164 YY_RULE_SETUP 1165 #line 115 "cimmof.l" 1166 { return(TOK_DT_REAL64); } 1167 YY_BREAK 1168 case 63: 1169 YY_RULE_SETUP 1170 mike 1.3 #line 116 "cimmof.l" 1171 { return(TOK_DT_CHAR8); } 1172 YY_BREAK 1173 case 64: 1174 YY_RULE_SETUP 1175 #line 117 "cimmof.l" 1176 { return(TOK_DT_CHAR16); } 1177 YY_BREAK 1178 case 65: 1179 YY_RULE_SETUP 1180 #line 118 "cimmof.l" 1181 { return(TOK_ALIAS_IDENTIFIER); } 1182 YY_BREAK 1183 case 66: 1184 YY_RULE_SETUP 1185 #line 119 "cimmof.l" 1186 { cimmof_lval.strval = new String(yytext); 1187 return(TOK_SIMPLE_IDENTIFIER); } 1188 YY_BREAK 1189 case 67: 1190 YY_RULE_SETUP 1191 mike 1.3 #line 121 "cimmof.l"
1192 bob 1.4 { cimmof_lval.strval = new String(yytext); 1193 return(TOK_UNEXPECTED_CHAR); }
1194 mike 1.3 YY_BREAK 1195 case 68: 1196 YY_RULE_SETUP
1197 bob 1.4 #line 124 "cimmof.l"
1198 mike 1.3 ECHO; 1199 YY_BREAK
1200 bob 1.4 #line 1201 "cimmof_lex.cpp"
1201 mike 1.3 case YY_STATE_EOF(INITIAL): 1202 yyterminate(); 1203 1204 case YY_END_OF_BUFFER: 1205 { 1206 /* Amount of text matched not including the EOB char. / 1207 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1208 1209 / Undo the effects of YY_DO_BEFORE_ACTION. / 1210 yy_cp = yy_hold_char; 1211 YY_RESTORE_YY_MORE_OFFSET 1212 1213 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1214 { 1215 /* We're scanning a new file or input source. It's 1216 * possible that this happened because the user 1217 * just pointed yyin at a new source and called 1218 * yylex(). If so, then we have to assure 1219 * consistency between yy_current_buffer and our 1220 * globals. Here is the right place to do so, because 1221 * this is the first action (other than possibly a 1222 mike 1.3 * back-up) that will match for the new input source. 1223 / 1224 yy_n_chars = yy_current_buffer->yy_n_chars; 1225 yy_current_buffer->yy_input_file = yyin; 1226 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1227 } 1228 1229 / Note that here we test for yy_c_buf_p "<=" to the position 1230 * of the first EOB in the buffer, since yy_c_buf_p will 1231 * already have been incremented past the NUL character 1232 * (since all states make transitions on EOB to the 1233 * end-of-buffer state). Contrast this with the test 1234 * in input(). 1235 / 1236 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1237 { / This was really a NUL. / 1238 yy_state_type yy_next_state; 1239 1240 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1241 1242 yy_current_state = yy_get_previous_state(); 1243 mike 1.3 1244 / Okay, we're now positioned to make the NUL 1245 * transition. We couldn't have 1246 * yy_get_previous_state() go ahead and do it 1247 * for us because it doesn't know how to deal 1248 * with the possibility of jamming (and we don't 1249 * want to build jamming into it because then it 1250 * will run more slowly). 1251 / 1252 1253 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1254 1255 yy_bp = yytext_ptr + YY_MORE_ADJ; 1256 1257 if ( yy_next_state ) 1258 { 1259 / Consume the NUL. / 1260 yy_cp = ++yy_c_buf_p; 1261 yy_current_state = yy_next_state; 1262 goto yy_match; 1263 } 1264 mike 1.3 1265 else 1266 { 1267 yy_cp = yy_c_buf_p; 1268 goto yy_find_action; 1269 } 1270 } 1271 1272 else switch ( yy_get_next_buffer() ) 1273 { 1274 case EOB_ACT_END_OF_FILE: 1275 { 1276 yy_did_buffer_switch_on_eof = 0; 1277 1278 if ( yywrap() ) 1279 { 1280 / Note: because we've taken care in 1281 * yy_get_next_buffer() to have set up 1282 * yytext, we can now set up 1283 * yy_c_buf_p so that if some total 1284 * hoser (like flex itself) wants to 1285 mike 1.3 * call the scanner after we return the 1286 * YY_NULL, it'll still work - another 1287 * YY_NULL will get returned. 1288 / 1289 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1290 1291 yy_act = YY_STATE_EOF(YY_START); 1292 goto do_action; 1293 } 1294 1295 else 1296 { 1297 if ( ! yy_did_buffer_switch_on_eof ) 1298 YY_NEW_FILE; 1299 } 1300 break; 1301 } 1302 1303 case EOB_ACT_CONTINUE_SCAN: 1304 yy_c_buf_p = 1305 yytext_ptr + yy_amount_of_matched_text; 1306 mike 1.3 1307 yy_current_state = yy_get_previous_state(); 1308 1309 yy_cp = yy_c_buf_p; 1310 yy_bp = yytext_ptr + YY_MORE_ADJ; 1311 goto yy_match; 1312 1313 case EOB_ACT_LAST_MATCH: 1314 yy_c_buf_p = 1315 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1316 1317 yy_current_state = yy_get_previous_state(); 1318 1319 yy_cp = yy_c_buf_p; 1320 yy_bp = yytext_ptr + YY_MORE_ADJ; 1321 goto yy_find_action; 1322 } 1323 break; 1324 } 1325 1326 default: 1327 mike 1.3 YY_FATAL_ERROR( 1328 "fatal flex scanner internal error--no action found" ); 1329 } / end of action switch / 1330 } / end of scanning one token / 1331 } / end of yylex / 1332 1333 1334 / yy_get_next_buffer - try to read in a new buffer 1335 * 1336 * Returns a code representing an action: 1337 * EOB_ACT_LAST_MATCH - 1338 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1339 * EOB_ACT_END_OF_FILE - end of file 1340 / 1341 1342 static int yy_get_next_buffer() 1343 { 1344 register char dest = yy_current_buffer->yy_ch_buf; 1345 register char source = yytext_ptr; 1346 register int number_to_move, i; 1347 int ret_val; 1348 mike 1.3 1349 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1350 YY_FATAL_ERROR( 1351 "fatal flex scanner internal error--end of buffer missed" ); 1352 1353 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1354 { / Don't try to fill the buffer, so this is an EOF. / 1355 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1356 { 1357 / We matched a single character, the EOB, so 1358 * treat this as a final EOF. 1359 / 1360 return EOB_ACT_END_OF_FILE; 1361 } 1362 1363 else 1364 { 1365 / We matched some text prior to the EOB, first 1366 * process it. 1367 / 1368 return EOB_ACT_LAST_MATCH; 1369 mike 1.3 } 1370 } 1371 1372 / Try to read more data. / 1373 1374 / First move last chars to start of buffer. / 1375 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1376 1377 for ( i = 0; i < number_to_move; ++i ) 1378 (dest++) = (source++); 1379 1380 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1381 / don't do the read, it's not guaranteed to return an EOF, 1382 * just force an EOF 1383 / 1384 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1385 1386 else 1387 { 1388 int num_to_read = 1389 yy_current_buffer->yy_buf_size - number_to_move - 1; 1390 mike 1.3 1391 while ( num_to_read <= 0 ) 1392 { / Not enough room in the buffer - grow it. / 1393 #ifdef YY_USES_REJECT 1394 YY_FATAL_ERROR( 1395 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1396 #else 1397 1398 / just a shorter name for the current buffer / 1399 YY_BUFFER_STATE b = yy_current_buffer; 1400 1401 int yy_c_buf_p_offset = 1402 (int) (yy_c_buf_p - b->yy_ch_buf); 1403 1404 if ( b->yy_is_our_buffer ) 1405 { 1406 int new_size = b->yy_buf_size 2; 1407 1408 if ( new_size <= 0 ) 1409 b->yy_buf_size += b->yy_buf_size / 8; 1410 else 1411 mike 1.3 b->yy_buf_size = 2; 1412 1413 b->yy_ch_buf = (char ) 1414 /* Include room in for 2 EOB chars. / 1415 yy_flex_realloc( (void ) b->yy_ch_buf, 1416 b->yy_buf_size + 2 ); 1417 } 1418 else 1419 /* Can't grow it, we don't own it. / 1420 b->yy_ch_buf = 0; 1421 1422 if ( ! b->yy_ch_buf ) 1423 YY_FATAL_ERROR( 1424 "fatal error - scanner input buffer overflow" ); 1425 1426 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1427 1428 num_to_read = yy_current_buffer->yy_buf_size - 1429 number_to_move - 1; 1430 #endif 1431 } 1432 mike 1.3 1433 if ( num_to_read > YY_READ_BUF_SIZE ) 1434 num_to_read = YY_READ_BUF_SIZE; 1435 1436 / Read in more data. / 1437 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1438 yy_n_chars, num_to_read ); 1439 1440 yy_current_buffer->yy_n_chars = yy_n_chars; 1441 } 1442 1443 if ( yy_n_chars == 0 ) 1444 { 1445 if ( number_to_move == YY_MORE_ADJ ) 1446 { 1447 ret_val = EOB_ACT_END_OF_FILE; 1448 yyrestart( yyin ); 1449 } 1450 1451 else 1452 { 1453 mike 1.3 ret_val = EOB_ACT_LAST_MATCH; 1454 yy_current_buffer->yy_buffer_status = 1455 YY_BUFFER_EOF_PENDING; 1456 } 1457 } 1458 1459 else 1460 ret_val = EOB_ACT_CONTINUE_SCAN; 1461 1462 yy_n_chars += number_to_move; 1463 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1464 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1465 1466 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1467 1468 return ret_val; 1469 } 1470 1471 1472 / yy_get_previous_state - get the state just before the EOB char was reached / 1473 1474 mike 1.3 static yy_state_type yy_get_previous_state() 1475 { 1476 register yy_state_type yy_current_state; 1477 register char yy_cp; 1478 1479 yy_current_state = yy_start; 1480 1481 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1482 { 1483 register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1); 1484 if ( yy_accept[yy_current_state] ) 1485 { 1486 yy_last_accepting_state = yy_current_state; 1487 yy_last_accepting_cpos = yy_cp; 1488 } 1489 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1490 { 1491 yy_current_state = (int) yy_def[yy_current_state]; 1492 if ( yy_current_state >= 274 ) 1493 yy_c = yy_meta[(unsigned int) yy_c]; 1494 } 1495 mike 1.3 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1496 } 1497 1498 return yy_current_state; 1499 } 1500 1501 1502 /* yy_try_NUL_trans - try to make a transition on the NUL character 1503 * 1504 * synopsis 1505 * next_state = yy_try_NUL_trans( current_state ); 1506 / 1507 1508 #ifdef YY_USE_PROTOS 1509 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1510 #else 1511 static yy_state_type yy_try_NUL_trans( yy_current_state ) 1512 yy_state_type yy_current_state; 1513 #endif 1514 { 1515 register int yy_is_jam; 1516 mike 1.3 register char yy_cp = yy_c_buf_p; 1517 1518 register YY_CHAR yy_c = 1; 1519 if ( yy_accept[yy_current_state] ) 1520 { 1521 yy_last_accepting_state = yy_current_state; 1522 yy_last_accepting_cpos = yy_cp; 1523 } 1524 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1525 { 1526 yy_current_state = (int) yy_def[yy_current_state]; 1527 if ( yy_current_state >= 274 ) 1528 yy_c = yy_meta[(unsigned int) yy_c]; 1529 } 1530 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1531 yy_is_jam = (yy_current_state == 273); 1532 1533 return yy_is_jam ? 0 : yy_current_state; 1534 } 1535 1536 1537 mike 1.3 #ifndef YY_NO_UNPUT 1538 #ifdef YY_USE_PROTOS 1539 static void yyunput( int c, register char yy_bp ) 1540 #else 1541 static void yyunput( c, yy_bp ) 1542 int c; 1543 register char yy_bp; 1544 #endif 1545 { 1546 register char yy_cp = yy_c_buf_p; 1547 1548 / undo effects of setting up yytext / 1549 yy_cp = yy_hold_char; 1550 1551 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1552 { /* need to shift things up to make room / 1553 / +2 for EOB chars. / 1554 register int number_to_move = yy_n_chars + 2; 1555 register char dest = &yy_current_buffer->yy_ch_buf[ 1556 yy_current_buffer->yy_buf_size + 2]; 1557 register char source = 1558 mike 1.3 &yy_current_buffer->yy_ch_buf[number_to_move]; 1559 1560 while ( source > yy_current_buffer->yy_ch_buf ) 1561 --dest = --source; 1562 1563 yy_cp += (int) (dest - source); 1564 yy_bp += (int) (dest - source); 1565 yy_current_buffer->yy_n_chars = 1566 yy_n_chars = yy_current_buffer->yy_buf_size; 1567 1568 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1569 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1570 } 1571 1572 --yy_cp = (char) c; 1573 1574 1575 yytext_ptr = yy_bp; 1576 yy_hold_char = yy_cp; 1577 yy_c_buf_p = yy_cp; 1578 } 1579 mike 1.3 #endif / ifndef YY_NO_UNPUT / 1580 1581 1582 #ifdef __cplusplus 1583 static int yyinput() 1584 #else 1585 static int input() 1586 #endif 1587 { 1588 int c; 1589 1590 yy_c_buf_p = yy_hold_char; 1591 1592 if ( yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1593 { 1594 / yy_c_buf_p now points to the character we want to return. 1595 * If this occurs before the EOB characters, then it's a 1596 * valid NUL; if not, then we've hit the end of the buffer. 1597 / 1598 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1599 / This was really a NUL. / 1600 mike 1.3 yy_c_buf_p = '\0'; 1601 1602 else 1603 { /* need more input / 1604 int offset = yy_c_buf_p - yytext_ptr; 1605 ++yy_c_buf_p; 1606 1607 switch ( yy_get_next_buffer() ) 1608 { 1609 case EOB_ACT_LAST_MATCH: 1610 / This happens because yy_g_n_b() 1611 * sees that we've accumulated a 1612 * token and flags that we need to 1613 * try matching the token before 1614 * proceeding. But for input(), 1615 * there's no matching to consider. 1616 * So convert the EOB_ACT_LAST_MATCH 1617 * to EOB_ACT_END_OF_FILE. 1618 / 1619 1620 / Reset buffer status. / 1621 mike 1.3 yyrestart( yyin ); 1622 1623 / fall through / 1624 1625 case EOB_ACT_END_OF_FILE: 1626 { 1627 if ( yywrap() ) 1628 return EOF; 1629 1630 if ( ! yy_did_buffer_switch_on_eof ) 1631 YY_NEW_FILE; 1632 #ifdef __cplusplus 1633 return yyinput(); 1634 #else 1635 return input(); 1636 #endif 1637 } 1638 1639 case EOB_ACT_CONTINUE_SCAN: 1640 yy_c_buf_p = yytext_ptr + offset; 1641 break; 1642 mike 1.3 } 1643 } 1644 } 1645 1646 c = (unsigned char ) yy_c_buf_p; / cast for 8-bit char's / 1647 yy_c_buf_p = '\0'; /* preserve yytext / 1648 yy_hold_char = ++yy_c_buf_p; 1649 1650 1651 return c; 1652 } 1653 1654 1655 #ifdef YY_USE_PROTOS 1656 void yyrestart( FILE input_file ) 1657 #else 1658 void yyrestart( input_file ) 1659 FILE input_file; 1660 #endif 1661 { 1662 if ( ! yy_current_buffer ) 1663 mike 1.3 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1664 1665 yy_init_buffer( yy_current_buffer, input_file ); 1666 yy_load_buffer_state(); 1667 } 1668 1669 1670 #ifdef YY_USE_PROTOS 1671 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1672 #else 1673 void yy_switch_to_buffer( new_buffer ) 1674 YY_BUFFER_STATE new_buffer; 1675 #endif 1676 { 1677 if ( yy_current_buffer == new_buffer ) 1678 return; 1679 1680 if ( yy_current_buffer ) 1681 { 1682 /* Flush out information for old buffer. / 1683 yy_c_buf_p = yy_hold_char; 1684 mike 1.3 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1685 yy_current_buffer->yy_n_chars = yy_n_chars; 1686 } 1687 1688 yy_current_buffer = new_buffer; 1689 yy_load_buffer_state(); 1690 1691 /* We don't actually know whether we did this switch during 1692 * EOF (yywrap()) processing, but the only time this flag 1693 * is looked at is after yywrap() is called, so it's safe 1694 * to go ahead and always set it. 1695 / 1696 yy_did_buffer_switch_on_eof = 1; 1697 } 1698 1699 1700 #ifdef YY_USE_PROTOS 1701 void yy_load_buffer_state( void ) 1702 #else 1703 void yy_load_buffer_state() 1704 #endif 1705 mike 1.3 { 1706 yy_n_chars = yy_current_buffer->yy_n_chars; 1707 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1708 yyin = yy_current_buffer->yy_input_file; 1709 yy_hold_char = yy_c_buf_p; 1710 } 1711 1712 1713 #ifdef YY_USE_PROTOS 1714 YY_BUFFER_STATE yy_create_buffer( FILE file, int size ) 1715 #else 1716 YY_BUFFER_STATE yy_create_buffer( file, size ) 1717 FILE file; 1718 int size; 1719 #endif 1720 { 1721 YY_BUFFER_STATE b; 1722 1723 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1724 if ( ! b ) 1725 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1726 mike 1.3 1727 b->yy_buf_size = size; 1728 1729 /* yy_ch_buf has to be 2 characters longer than the size given because 1730 * we need to put in 2 end-of-buffer characters. 1731 / 1732 b->yy_ch_buf = (char ) yy_flex_alloc( b->yy_buf_size + 2 ); 1733 if ( ! b->yy_ch_buf ) 1734 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1735 1736 b->yy_is_our_buffer = 1; 1737 1738 yy_init_buffer( b, file ); 1739 1740 return b; 1741 } 1742 1743 1744 #ifdef YY_USE_PROTOS 1745 void yy_delete_buffer( YY_BUFFER_STATE b ) 1746 #else 1747 mike 1.3 void yy_delete_buffer( b ) 1748 YY_BUFFER_STATE b; 1749 #endif 1750 { 1751 if ( ! b ) 1752 return; 1753 1754 if ( b == yy_current_buffer ) 1755 yy_current_buffer = (YY_BUFFER_STATE) 0; 1756 1757 if ( b->yy_is_our_buffer ) 1758 yy_flex_free( (void ) b->yy_ch_buf ); 1759 1760 yy_flex_free( (void ) b ); 1761 } 1762 1763 1764 #ifndef YY_ALWAYS_INTERACTIVE 1765 #ifndef YY_NEVER_INTERACTIVE 1766 extern int isatty YY_PROTO(( int )); 1767 #endif 1768 mike 1.3 #endif 1769 1770 #ifdef YY_USE_PROTOS 1771 void yy_init_buffer( YY_BUFFER_STATE b, FILE file ) 1772 #else 1773 void yy_init_buffer( b, file ) 1774 YY_BUFFER_STATE b; 1775 FILE file; 1776 #endif 1777 1778 1779 { 1780 yy_flush_buffer( b ); 1781 1782 b->yy_input_file = file; 1783 b->yy_fill_buffer = 1; 1784 1785 #if YY_ALWAYS_INTERACTIVE 1786 b->yy_is_interactive = 1; 1787 #else 1788 #if YY_NEVER_INTERACTIVE 1789 mike 1.3 b->yy_is_interactive = 0; 1790 #else 1791 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1792 #endif 1793 #endif 1794 } 1795 1796 1797 #ifdef YY_USE_PROTOS 1798 void yy_flush_buffer( YY_BUFFER_STATE b ) 1799 #else 1800 void yy_flush_buffer( b ) 1801 YY_BUFFER_STATE b; 1802 #endif 1803 1804 { 1805 if ( ! b ) 1806 return; 1807 1808 b->yy_n_chars = 0; 1809 1810 mike 1.3 /* We always need two end-of-buffer characters. The first causes 1811 * a transition to the end-of-buffer state. The second causes 1812 * a jam in that state. 1813 / 1814 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1815 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1816 1817 b->yy_buf_pos = &b->yy_ch_buf[0]; 1818 1819 b->yy_at_bol = 1; 1820 b->yy_buffer_status = YY_BUFFER_NEW; 1821 1822 if ( b == yy_current_buffer ) 1823 yy_load_buffer_state(); 1824 } 1825 1826 1827 #ifndef YY_NO_SCAN_BUFFER 1828 #ifdef YY_USE_PROTOS 1829 YY_BUFFER_STATE yy_scan_buffer( char base, yy_size_t size ) 1830 #else 1831 mike 1.3 YY_BUFFER_STATE yy_scan_buffer( base, size ) 1832 char base; 1833 yy_size_t size; 1834 #endif 1835 { 1836 YY_BUFFER_STATE b; 1837 1838 if ( size < 2 \|\| 1839 base[size-2] != YY_END_OF_BUFFER_CHAR \|\| 1840 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1841 / They forgot to leave room for the EOB's. / 1842 return 0; 1843 1844 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1845 if ( ! b ) 1846 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1847 1848 b->yy_buf_size = size - 2; / "- 2" to take care of EOB's / 1849 b->yy_buf_pos = b->yy_ch_buf = base; 1850 b->yy_is_our_buffer = 0; 1851 b->yy_input_file = 0; 1852 mike 1.3 b->yy_n_chars = b->yy_buf_size; 1853 b->yy_is_interactive = 0; 1854 b->yy_at_bol = 1; 1855 b->yy_fill_buffer = 0; 1856 b->yy_buffer_status = YY_BUFFER_NEW; 1857 1858 yy_switch_to_buffer( b ); 1859 1860 return b; 1861 } 1862 #endif 1863 1864 1865 #ifndef YY_NO_SCAN_STRING 1866 #ifdef YY_USE_PROTOS 1867 YY_BUFFER_STATE yy_scan_string( yyconst char yy_str ) 1868 #else 1869 YY_BUFFER_STATE yy_scan_string( yy_str ) 1870 yyconst char yy_str; 1871 #endif 1872 { 1873 mike 1.3 int len; 1874 for ( len = 0; yy_str[len]; ++len ) 1875 ; 1876 1877 return yy_scan_bytes( yy_str, len ); 1878 } 1879 #endif 1880 1881 1882 #ifndef YY_NO_SCAN_BYTES 1883 #ifdef YY_USE_PROTOS 1884 YY_BUFFER_STATE yy_scan_bytes( yyconst char bytes, int len ) 1885 #else 1886 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1887 yyconst char bytes; 1888 int len; 1889 #endif 1890 { 1891 YY_BUFFER_STATE b; 1892 char buf; 1893 yy_size_t n; 1894 mike 1.3 int i; 1895 1896 /* Get memory for full buffer, including space for trailing EOB's. / 1897 n = len + 2; 1898 buf = (char ) yy_flex_alloc( n ); 1899 if ( ! buf ) 1900 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1901 1902 for ( i = 0; i < len; ++i ) 1903 buf[i] = bytes[i]; 1904 1905 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1906 1907 b = yy_scan_buffer( buf, n ); 1908 if ( ! b ) 1909 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1910 1911 /* It's okay to grow etc. this buffer, and we should throw it 1912 * away when we're done. 1913 / 1914 b->yy_is_our_buffer = 1; 1915 mike 1.3 1916 return b; 1917 } 1918 #endif 1919 1920 1921 #ifndef YY_NO_PUSH_STATE 1922 #ifdef YY_USE_PROTOS 1923 static void yy_push_state( int new_state ) 1924 #else 1925 static void yy_push_state( new_state ) 1926 int new_state; 1927 #endif 1928 { 1929 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1930 { 1931 yy_size_t new_size; 1932 1933 yy_start_stack_depth += YY_START_STACK_INCR; 1934 new_size = yy_start_stack_depth sizeof( int ); 1935 1936 mike 1.3 if ( ! yy_start_stack ) 1937 yy_start_stack = (int ) yy_flex_alloc( new_size ); 1938 1939 else 1940 yy_start_stack = (int ) yy_flex_realloc( 1941 (void ) yy_start_stack, new_size ); 1942 1943 if ( ! yy_start_stack ) 1944 YY_FATAL_ERROR( 1945 "out of memory expanding start-condition stack" ); 1946 } 1947 1948 yy_start_stack[yy_start_stack_ptr++] = YY_START; 1949 1950 BEGIN(new_state); 1951 } 1952 #endif 1953 1954 1955 #ifndef YY_NO_POP_STATE 1956 static void yy_pop_state() 1957 mike 1.3 { 1958 if ( --yy_start_stack_ptr < 0 ) 1959 YY_FATAL_ERROR( "start-condition stack underflow" ); 1960 1961 BEGIN(yy_start_stack[yy_start_stack_ptr]); 1962 } 1963 #endif 1964 1965 1966 #ifndef YY_NO_TOP_STATE 1967 static int yy_top_state() 1968 { 1969 return yy_start_stack[yy_start_stack_ptr - 1]; 1970 } 1971 #endif 1972 1973 #ifndef YY_EXIT_FAILURE 1974 #define YY_EXIT_FAILURE 2 1975 #endif 1976 1977 #ifdef YY_USE_PROTOS 1978 mike 1.3 static void yy_fatal_error( yyconst char msg[] ) 1979 #else 1980 static void yy_fatal_error( msg ) 1981 char msg[]; 1982 #endif 1983 { 1984 (void) fprintf( stderr, "%s\n", msg ); 1985 exit( YY_EXIT_FAILURE ); 1986 } 1987 1988 1989 1990 / Redefine yyless() so it works in section 3 code. / 1991 1992 #undef yyless 1993 #define yyless(n) \ 1994 do \ 1995 { \ 1996 / Undo effects of setting up yytext. / \ 1997 yytext[yyleng] = yy_hold_char; \ 1998 yy_c_buf_p = yytext + n; \ 1999 mike 1.3 yy_hold_char = yy_c_buf_p; \ 2000 yy_c_buf_p = '\0'; \ 2001 yyleng = n; \ 2002 } \ 2003 while ( 0 ) 2004 2005 2006 / Internal utility routines. / 2007 2008 #ifndef yytext_ptr 2009 #ifdef YY_USE_PROTOS 2010 static void yy_flex_strncpy( char s1, yyconst char s2, int n ) 2011 #else 2012 static void yy_flex_strncpy( s1, s2, n ) 2013 char s1; 2014 yyconst char s2; 2015 int n; 2016 #endif 2017 { 2018 register int i; 2019 for ( i = 0; i < n; ++i ) 2020 mike 1.3 s1[i] = s2[i]; 2021 } 2022 #endif 2023 2024 #ifdef YY_NEED_STRLEN 2025 #ifdef YY_USE_PROTOS 2026 static int yy_flex_strlen( yyconst char s ) 2027 #else 2028 static int yy_flex_strlen( s ) 2029 yyconst char s; 2030 #endif 2031 { 2032 register int n; 2033 for ( n = 0; s[n]; ++n ) 2034 ; 2035 2036 return n; 2037 } 2038 #endif 2039 2040 2041 mike 1.3 #ifdef YY_USE_PROTOS 2042 static void yy_flex_alloc( yy_size_t size ) 2043 #else 2044 static void yy_flex_alloc( size ) 2045 yy_size_t size; 2046 #endif 2047 { 2048 return (void ) malloc( size ); 2049 } 2050 2051 #ifdef YY_USE_PROTOS 2052 static void yy_flex_realloc( void ptr, yy_size_t size ) 2053 #else 2054 static void yy_flex_realloc( ptr, size ) 2055 void ptr; 2056 yy_size_t size; 2057 #endif 2058 { 2059 /* The cast to (char ) in the following accommodates both 2060 implementations that use char* generic pointers, and those 2061 * that use void* generic pointers. It works with the latter 2062 mike 1.3 * because both ANSI C and C++ allow castless assignment from 2063 * any pointer type to void, and deal with argument conversions 2064 as though doing an assignment. 2065 / 2066 return (void ) realloc( (char ) ptr, size ); 2067 } 2068 2069 #ifdef YY_USE_PROTOS 2070 static void yy_flex_free( void ptr ) 2071 #else 2072 static void yy_flex_free( ptr ) 2073 void *ptr; 2074 #endif 2075 { 2076 free( ptr ); 2077 } 2078 2079 #if YY_MAIN 2080 int main() 2081 { 2082 yylex(); 2083 mike 1.3 return 0; 2084 } 2085 #endif
2086 bob 1.4 #line 124 "cimmof.l"
2087 mike 1.3 2088 2089 void cimmof_yy_less(int n) { 2090 yyless(n); 2091 }

No CVS admin address has been configured