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