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

No CVS admin address has been configured