1 /*
2 ** Inserted at beginning of c files generated by flex
3 ** REMEMBER: Change flex.reset too.
4 */
5
6 /*@-allmacros@*/
7 /*@-pred@*/
8 /*@-globstate@*/
9 /*@-null@*/
10 /*@+boolint@*/
11 /*@+charint@*/
12 /*@-macrospec@*/
13 /*@-macroredef@*/
14 /*@-exitarg@*/
15 /*@-compdef@*/
16 /*@-uniondef@*/
17 /*@+ignorequals@*/
18 /*@-noreturn@*/
19 /*@-mustfree@*/
20 /*@-compdestroy@*/
21 /*@-branchstate@*/
22 /*@-unreachable@*/
23 /*@-varuse@*/
24 /*@-fcnuse@*/
25 /*@-exportlocal@*/
26 /*@-evalorderuncon@*/
27 /*@-exportheader@*/
28 /*@-redecl@*/
29 /*@-loopswitchbreak@*/
30 /*@-switchswitchbreak@*/
31 /*@-sizeoftype@*/
32 /*@-czechfcns@*/
33 /*@-noparams@*/
34 /*@-ansireserved@*/
35 /*@-ifblock@*/
36 /*@-whileblock@*/
37 /*@-forblock@*/
38 /*@-elseifcomplete@*/
39 /*@+ptrnegate@*/
40 /*@-onlytrans@*/
41 /*@-temptrans@*/
42 /*@-immediatetrans@*/
43 /*@-namechecks@*/
44 /*@+matchanyintegral@*/
45 /*@-statictrans@*/
46 /*@-compmempass@*/
47 /*@-forempty@*/
48 /*@-evalorder@*/
49 /*@-retalias@*/
50 /*@-dependenttrans@*/
51 /*@-noeffect@*/
52 /*@-protoparammatch@*/
53 /*@-casebreak@*/
54 /*@-retvalother@*/
55 /*@-exportheader@*/
56
57 /*drl added 11/27/2001*/
58
59
60 # ifdef __LCLINT__
61 /*@-redecl@*/ /*@-type@*/
62 extern int cgrammar_lsllex (void);
63 /*@=redecl@*/ /*@=type@*/
64
65 /*
66 ** Need to do this because ECHO is defined by the Posix library.
67 ** flex shouldn't use it.
68 */
69
70 /*@notfunction@*/
71 # define ECHO \
72 fwrite (yytext, yyleng, 1, yyout)
73
74 # ifndef DEFFILENO
75 extern /*@external@*/ int fileno (/* FILE *stream */);
76 # define DEFFILENO
77 # endif
78 # endif
79
80 # ifdef OSF
81 # undef __GNUC__
82 # endif
83
84 /*@-redecl@*/
85
86 /* < end of flex.head > */
87
88 /* A lexical scanner generated by flex*/
89
90 /* Scanner skeleton version:
91 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
92 */
93
94 #define FLEX_SCANNER
95 #define YY_FLEX_MAJOR_VERSION 2
96 #define YY_FLEX_MINOR_VERSION 5
97
98 #include <stdio.h>
99 #include <unistd.h>
100
101
102 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
103 #ifdef c_plusplus
104 #ifndef __cplusplus
105 #define __cplusplus
106 #endif
107 #endif
108
109
110 #ifdef __cplusplus
111
112 #include <stdlib.h>
113
114 /* Use prototypes in function declarations. */
115 #define YY_USE_PROTOS
116
117 /* The "const" storage-class-modifier is valid. */
118 #define YY_USE_CONST
119
120 #else /* ! __cplusplus */
121
122 #if __STDC__
123
124 #define YY_USE_PROTOS
125 #define YY_USE_CONST
126
127 #endif /* __STDC__ */
128 #endif /* ! __cplusplus */
129
130 #ifdef __TURBOC__
131 #pragma warn -rch
132 #pragma warn -use
133 #include <io.h>
134 #include <stdlib.h>
135 #define YY_USE_CONST
136 #define YY_USE_PROTOS
137 #endif
138
139 #ifdef YY_USE_CONST
140 #define yyconst const
141 #else
142 #define yyconst
143 #endif
144
145
146 #ifdef YY_USE_PROTOS
147 #define YY_PROTO(proto) proto
148 #else
149 #define YY_PROTO(proto) ()
150 #endif
151
152 /* Returned upon end-of-file. */
153 #define YY_NULL 0
154
155 /* Promotes a possibly negative, possibly signed char to an unsigned
156 * integer for use as an array index. If the signed char is negative,
157 * we want to instead treat it as an 8-bit unsigned char, hence the
158 * double cast.
159 */
160 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
161
162 /* Enter a start condition. This macro really ought to take a parameter,
163 * but we do it the disgusting crufty way forced on us by the ()-less
164 * definition of BEGIN.
165 */
166 #define BEGIN yy_start = 1 + 2 *
167
168 /* Translate the current start state into a value that can be later handed
169 * to BEGIN to return to the state. The YYSTATE alias is for lex
170 * compatibility.
171 */
172 #define YY_START ((yy_start - 1) / 2)
173 #define YYSTATE YY_START
174
175 /* Action number for EOF rule of a given start state. */
176 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
177
178 /* Special action meaning "start processing a new file". */
179 #define YY_NEW_FILE yyrestart( yyin )
180
181 #define YY_END_OF_BUFFER_CHAR 0
182
183 /* Size of default input buffer. */
184 #define YY_BUF_SIZE 16384
185
186 typedef struct yy_buffer_state *YY_BUFFER_STATE;
187
188 extern int yyleng;
189 extern FILE *yyin, *yyout;
190
191 #define EOB_ACT_CONTINUE_SCAN 0
192 #define EOB_ACT_END_OF_FILE 1
193 #define EOB_ACT_LAST_MATCH 2
194
195 /* The funky do-while in the following #define is used to turn the definition
196 * int a single C statement (which needs a semi-colon terminator). This
197 * avoids problems with code like:
198 *
199 * if ( condition_holds )
200 * yyless( 5 );
201 * else
202 * do_something_else();
203 *
204 * Prior to using the do-while the compiler would get upset at the
205 * "else" because it interpreted the "if" statement as being all
206 * done when it reached the ';' after the yyless() call.
207 */
208
209 /* Return all but the first 'n' matched characters back to the input stream. */
210
211 #define yyless(n) \
212 do \
213 { \
214 /* Undo effects of setting up yytext. */ \
215 *yy_cp = yy_hold_char; \
216 YY_RESTORE_YY_MORE_OFFSET \
217 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
218 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
219 } \
220 while ( 0 )
221
222 #define unput(c) yyunput( c, yytext_ptr )
223
224 /* Some routines like yy_flex_realloc() are emitted as static but are
225 not called by all lexers. This generates warnings in some compilers,
226 notably GCC. Arrange to suppress these. */
227 #ifdef __GNUC__
228 #define YY_MAY_BE_UNUSED __attribute__((unused))
229 #else
230 #define YY_MAY_BE_UNUSED
231 #endif
232
233 /* The following is because we cannot portably get our hands on size_t
234 * (without autoconf's help, which isn't available because we want
235 * flex-generated scanners to compile on their own).
236 */
237 typedef unsigned int yy_size_t;
238
239
240 struct yy_buffer_state
241 {
242 FILE *yy_input_file;
243
244 char *yy_ch_buf; /* input buffer */
245 char *yy_buf_pos; /* current position in input buffer */
246
247 /* Size of input buffer in bytes, not including room for EOB
248 * characters.
249 */
250 yy_size_t yy_buf_size;
251
252 /* Number of characters read into yy_ch_buf, not including EOB
253 * characters.
254 */
255 int yy_n_chars;
256
257 /* Whether we "own" the buffer - i.e., we know we created it,
258 * and can realloc() it to grow it, and should free() it to
259 * delete it.
260 */
261 int yy_is_our_buffer;
262
263 /* Whether this is an "interactive" input source; if so, and
264 * if we're using stdio for input, then we want to use getc()
265 * instead of fread(), to make sure we stop fetching input after
266 * each newline.
267 */
268 int yy_is_interactive;
269
270 /* Whether we're considered to be at the beginning of a line.
271 * If so, '^' rules will be active on the next match, otherwise
272 * not.
273 */
274 int yy_at_bol;
275
276 /* Whether to try to fill the input buffer when we reach the
277 * end of it.
278 */
279 int yy_fill_buffer;
280
281 int yy_buffer_status;
282 #define YY_BUFFER_NEW 0
283 #define YY_BUFFER_NORMAL 1
284 /* When an EOF's been seen but there's still some text to process
285 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
286 * shouldn't try reading from the input source any more. We might
287 * still have a bunch of tokens to match, though, because of
288 * possible backing-up.
289 *
290 * When we actually see the EOF, we change the status to "new"
291 * (via yyrestart()), so that the user can continue scanning by
292 * just pointing yyin at a new input file.
293 */
294 #define YY_BUFFER_EOF_PENDING 2
295 };
296
297 static YY_BUFFER_STATE yy_current_buffer = 0;
298
299 /* We provide macros for accessing buffer states in case in the
300 * future we want to put the buffer states in a more general
301 * "scanner state".
302 */
303 #define YY_CURRENT_BUFFER yy_current_buffer
304
305
306 /* yy_hold_char holds the character lost when yytext is formed. */
307 static char yy_hold_char;
308
309 static int yy_n_chars; /* number of characters read into yy_ch_buf */
310
311
312 int yyleng;
313
314 /* Points to current character in buffer. */
315 static char *yy_c_buf_p = (char *) 0;
316 static int yy_init = 1; /* whether we need to initialize */
317 static int yy_start = 0; /* start state number */
318
319 /* Flag which is used to allow yywrap()'s to do buffer switches
320 * instead of setting up a fresh yyin. A bit of a hack ...
321 */
322 static int yy_did_buffer_switch_on_eof;
323
324 void yyrestart YY_PROTO(( FILE *input_file ));
325
326 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
327 void yy_load_buffer_state YY_PROTO(( void ));
328 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
329 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
330 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
331 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
332 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
333
334 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
335 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
336 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
337
338 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
339 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
340 static void yy_flex_free YY_PROTO(( void * ));
341
342 #define yy_new_buffer yy_create_buffer
343
344 #define yy_set_interactive(is_interactive) \
345 { \
346 if ( ! yy_current_buffer ) \
347 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
348 yy_current_buffer->yy_is_interactive = is_interactive; \
349 }
350
351 #define yy_set_bol(at_bol) \
352 { \
353 if ( ! yy_current_buffer ) \
354 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
355 yy_current_buffer->yy_at_bol = at_bol; \
356 }
357
358 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
359
360 typedef unsigned char YY_CHAR;
361 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
362 typedef int yy_state_type;
363 extern char *yytext;
364 #define yytext_ptr yytext
365
366 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
367 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
368 static int yy_get_next_buffer YY_PROTO(( void ));
369 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
370
371 /* Done after the current pattern has been matched and before the
372 * corresponding action - sets up yytext.
373 */
374 #define YY_DO_BEFORE_ACTION \
375 yytext_ptr = yy_bp; \
376 yyleng = (int) (yy_cp - yy_bp); \
377 yy_hold_char = *yy_cp; \
378 *yy_cp = '\0'; \
379 yy_c_buf_p = yy_cp;
380
381 #define YY_NUM_RULES 190
382 #define YY_END_OF_BUFFER 191
383 static yyconst short int yy_accept[575] =
384 { 0,
385 0, 0, 191, 189, 167, 168, 155, 189, 3, 88,
386 161, 154, 189, 149, 150, 159, 158, 146, 157, 153,
387 160, 103, 103, 147, 143, 162, 148, 163, 166, 189,
388 88, 88, 151, 188, 152, 164, 88, 88, 88, 88,
389 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
390 88, 88, 88, 88, 88, 88, 88, 88, 144, 165,
391 145, 156, 142, 0, 43, 0, 2, 88, 127, 186,
392 187, 136, 128, 0, 0, 125, 133, 123, 134, 124,
393 135, 0, 117, 1, 126, 138, 120, 96, 0, 105,
394 104, 0, 103, 132, 139, 141, 140, 131, 0, 0,
395
396 0, 0, 0, 88, 129, 88, 88, 88, 88, 88,
397 88, 88, 88, 9, 88, 88, 88, 88, 88, 88,
398 88, 13, 46, 88, 88, 88, 88, 88, 88, 88,
399 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
400 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
401 88, 88, 130, 137, 0, 0, 2, 110, 4, 0,
402 115, 116, 117, 0, 118, 119, 98, 97, 0, 114,
403 106, 107, 107, 89, 122, 121, 175, 176, 173, 178,
404 183, 174, 185, 184, 179, 182, 177, 180, 181, 0,
405 0, 0, 44, 0, 0, 0, 88, 88, 88, 88,
406
407 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
408 88, 88, 88, 88, 11, 88, 88, 27, 88, 88,
409 88, 88, 88, 88, 88, 88, 88, 88, 88, 45,
410 88, 88, 88, 88, 88, 88, 88, 78, 88, 88,
411 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
412 88, 88, 88, 88, 88, 88, 88, 88, 88, 0,
413 43, 0, 0, 117, 0, 115, 116, 0, 120, 99,
414 100, 100, 112, 113, 109, 108, 90, 92, 171, 172,
415 0, 0, 0, 0, 111, 88, 88, 88, 88, 40,
416 88, 6, 29, 88, 88, 88, 88, 88, 88, 10,
417
418 25, 88, 88, 88, 88, 12, 88, 88, 88, 53,
419 88, 31, 88, 88, 88, 88, 54, 88, 88, 72,
420 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
421 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
422 88, 88, 88, 88, 88, 88, 26, 88, 88, 88,
423 0, 117, 102, 101, 91, 93, 93, 0, 170, 0,
424 44, 0, 88, 88, 88, 88, 5, 88, 36, 88,
425 88, 88, 88, 88, 88, 88, 30, 88, 88, 88,
426 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
427 73, 88, 88, 88, 88, 88, 88, 88, 88, 32,
428
429 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
430 81, 24, 88, 88, 88, 88, 88, 18, 80, 95,
431 94, 169, 88, 84, 88, 88, 88, 88, 88, 88,
432 88, 28, 88, 39, 88, 21, 88, 56, 82, 88,
433 88, 86, 64, 88, 88, 88, 88, 88, 88, 88,
434 88, 62, 88, 88, 14, 79, 34, 15, 88, 42,
435 22, 17, 88, 88, 88, 88, 88, 76, 19, 20,
436 88, 85, 38, 49, 68, 88, 88, 8, 88, 63,
437 88, 88, 88, 66, 87, 55, 88, 88, 88, 88,
438 47, 88, 88, 61, 88, 88, 48, 65, 88, 23,
439
440 88, 88, 88, 88, 69, 7, 88, 77, 88, 88,
441 88, 88, 74, 16, 88, 41, 37, 88, 57, 88,
442 33, 35, 88, 75, 58, 88, 88, 88, 88, 88,
443 88, 71, 88, 88, 88, 88, 88, 88, 67, 88,
444 88, 88, 88, 88, 88, 88, 88, 88, 88, 50,
445 88, 88, 59, 88, 88, 70, 88, 60, 88, 88,
446 83, 88, 88, 88, 88, 88, 88, 88, 88, 52,
447 88, 88, 51, 0
448 } ;
449
450 static yyconst int yy_ec[256] =
451 { 0,
452 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
453 4, 4, 1, 1, 1, 1, 1, 1, 1, 1,
454 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
455 1, 2, 5, 6, 7, 8, 9, 10, 11, 12,
456 13, 14, 15, 16, 17, 18, 19, 20, 21, 21,
457 21, 21, 21, 21, 21, 21, 21, 22, 23, 24,
458 25, 26, 27, 28, 29, 30, 31, 30, 32, 33,
459 34, 8, 8, 8, 35, 36, 37, 8, 8, 8,
460 38, 39, 40, 41, 42, 8, 43, 44, 8, 45,
461 46, 47, 48, 49, 50, 1, 51, 52, 53, 54,
462
463 55, 56, 57, 58, 59, 8, 60, 61, 62, 63,
464 64, 65, 8, 66, 67, 68, 69, 70, 71, 72,
465 73, 74, 75, 76, 77, 78, 1, 1, 1, 1,
466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
468 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
469 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
470 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
471 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
472 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
473
474 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
476 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
477 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
478 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
479 1, 1, 1, 1, 1
480 } ;
481
482 static yyconst int yy_meta[79] =
483 { 0,
484 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
485 3, 1, 1, 1, 1, 1, 1, 1, 1, 4,
486 4, 1, 1, 1, 1, 1, 1, 1, 5, 5,
487 5, 5, 5, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 1, 1, 1, 1, 2,
489 5, 5, 5, 5, 5, 5, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 1, 1, 1, 1
492 } ;
493
494 static yyconst short int yy_base[585] =
495 { 0,
496 0, 0, 749, 750, 750, 750, 723, 73, 0, 0,
497 55, 71, 700, 750, 750, 721, 67, 750, 68, 66,
498 74, 80, 87, 750, 750, 65, 720, 77, 750, 99,
499 98, 693, 750, 750, 750, 718, 692, 28, 675, 67,
500 51, 73, 82, 676, 84, 55, 675, 687, 89, 98,
501 686, 681, 105, 102, 672, 62, 676, 674, 750, 86,
502 750, 750, 750, 132, 175, 729, 0, 0, 750, 750,
503 750, 750, 750, 144, 163, 750, 750, 750, 750, 750,
504 750, 713, 151, 750, 750, 750, 165, 172, 179, 167,
505 144, 0, 198, 705, 750, 750, 750, 704, 239, 691,
506
507 691, 176, 679, 653, 750, 671, 650, 654, 666, 653,
508 160, 656, 157, 649, 650, 647, 164, 654, 650, 647,
509 644, 0, 127, 648, 655, 648, 645, 635, 635, 637,
510 643, 636, 646, 640, 632, 636, 632, 181, 641, 138,
511 178, 641, 159, 636, 632, 624, 627, 191, 641, 195,
512 631, 634, 750, 750, 259, 240, 0, 750, 750, 271,
513 750, 750, 269, 278, 750, 750, 235, 203, 286, 290,
514 182, 750, 233, 267, 750, 750, 750, 647, 658, 750,
515 750, 750, 750, 750, 750, 750, 750, 750, 750, 647,
516 648, 275, 310, 681, 274, 244, 275, 619, 614, 617,
517
518 629, 624, 612, 624, 250, 625, 620, 622, 618, 610,
519 607, 615, 602, 617, 0, 603, 607, 610, 595, 598,
520 601, 604, 280, 594, 596, 597, 602, 589, 582, 0,
521 599, 585, 599, 592, 203, 582, 580, 0, 582, 581,
522 583, 590, 591, 575, 573, 573, 575, 584, 583, 579,
523 581, 571, 575, 566, 246, 578, 580, 569, 568, 302,
524 329, 625, 313, 317, 324, 750, 750, 322, 327, 285,
525 750, 304, 750, 750, 750, 750, 316, 319, 750, 750,
526 599, 587, 364, 350, 750, 570, 569, 560, 549, 0,
527 561, 0, 0, 560, 551, 559, 548, 553, 554, 0,
528
529 0, 547, 547, 557, 543, 0, 547, 552, 547, 0,
530 73, 0, 552, 551, 550, 535, 291, 537, 547, 0,
531 547, 541, 535, 531, 542, 527, 529, 528, 538, 524,
532 536, 526, 530, 529, 534, 533, 519, 521, 529, 527,
533 525, 517, 522, 523, 511, 523, 0, 507, 519, 519,
534 348, 351, 750, 750, 322, 750, 321, 544, 750, 355,
535 373, 568, 519, 501, 501, 502, 0, 319, 0, 503,
536 504, 510, 508, 507, 498, 497, 0, 504, 492, 496,
537 502, 500, 503, 485, 496, 490, 495, 491, 478, 479,
538 0, 495, 476, 476, 487, 481, 482, 477, 485, 0,
539
540 484, 481, 485, 482, 466, 475, 477, 462, 475, 476,
541 0, 0, 465, 473, 469, 464, 465, 0, 0, 750,
542 750, 750, 469, 0, 454, 466, 466, 455, 449, 449,
543 461, 0, 461, 463, 444, 0, 461, 0, 0, 455,
544 456, 0, 0, 448, 442, 452, 451, 441, 443, 440,
545 447, 0, 440, 447, 0, 0, 440, 0, 437, 0,
546 0, 0, 441, 435, 439, 434, 438, 0, 0, 0,
547 431, 0, 0, 0, 424, 436, 434, 0, 425, 0,
548 426, 425, 424, 0, 0, 0, 422, 420, 416, 425,
549 0, 412, 413, 0, 410, 414, 0, 0, 415, 0,
550
551 420, 420, 418, 404, 0, 0, 403, 0, 409, 401,
552 409, 27, 0, 0, 412, 0, 0, 398, 0, 411,
553 405, 0, 397, 0, 0, 389, 398, 409, 393, 404,
554 402, 0, 381, 373, 363, 372, 359, 350, 0, 354,
555 342, 356, 353, 338, 338, 349, 337, 346, 332, 0,
556 344, 343, 0, 345, 338, 0, 340, 0, 332, 326,
557 0, 322, 338, 313, 268, 198, 175, 176, 144, 0,
558 100, 104, 0, 750, 412, 416, 420, 425, 429, 431,
559 436, 441, 446, 451
560 } ;
561
562 static yyconst short int yy_def[585] =
563 { 0,
564 574, 1, 574, 574, 574, 574, 574, 575, 576, 577,
565 574, 574, 578, 574, 574, 574, 574, 574, 574, 574,
566 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
567 577, 577, 574, 574, 574, 574, 577, 577, 577, 577,
568 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
569 577, 577, 577, 577, 577, 577, 577, 577, 574, 574,
570 574, 574, 574, 575, 574, 575, 579, 577, 574, 574,
571 574, 574, 574, 578, 578, 574, 574, 574, 574, 574,
572 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
573 574, 580, 574, 574, 574, 574, 574, 574, 574, 574,
574
575 574, 581, 582, 577, 574, 577, 577, 577, 577, 577,
576 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
577 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
578 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
579 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
580 577, 577, 574, 574, 574, 583, 579, 574, 574, 574,
581 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
582 574, 574, 574, 580, 574, 574, 574, 574, 574, 574,
583 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
584 574, 581, 574, 581, 582, 582, 577, 577, 577, 577,
585
586 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
587 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
588 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
589 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
590 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
591 577, 577, 577, 577, 577, 577, 577, 577, 577, 583,
592 574, 583, 574, 574, 574, 574, 574, 574, 574, 574,
593 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
594 574, 574, 574, 584, 574, 577, 577, 577, 577, 577,
595 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
596
597 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
598 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
599 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
600 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
601 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
602 574, 574, 574, 574, 574, 574, 574, 574, 574, 584,
603 574, 584, 577, 577, 577, 577, 577, 577, 577, 577,
604 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
605 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
606 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
607
608 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
609 577, 577, 577, 577, 577, 577, 577, 577, 577, 574,
610 574, 574, 577, 577, 577, 577, 577, 577, 577, 577,
611 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
612 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
613 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
614 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
615 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
616 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
617 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
618
619 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
620 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
621 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
622 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
623 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
624 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
625 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
626 577, 577, 577, 0, 574, 574, 574, 574, 574, 574,
627 574, 574, 574, 574
628 } ;
629
630 static yyconst short int yy_nxt[829] =
631 { 0,
632 4, 5, 6, 5, 7, 8, 9, 10, 11, 12,
633 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
634 23, 24, 25, 26, 27, 28, 29, 30, 10, 10,
635 10, 10, 10, 10, 10, 31, 32, 10, 10, 10,
636 10, 10, 10, 10, 10, 33, 34, 35, 36, 37,
637 38, 39, 40, 41, 42, 43, 44, 10, 45, 46,
638 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
639 57, 10, 58, 10, 59, 60, 61, 62, 65, 69,
640 72, 77, 528, 82, 79, 83, 83, 84, 94, 95,
641 107, 78, 80, 81, 529, 73, 108, 87, 85, 88,
642
643 88, 97, 98, 102, 87, 113, 93, 93, 103, 125,
644 153, 89, 149, 126, 114, 90, 99, 110, 89, 66,
645 86, 91, 90, 92, 111, 150, 100, 381, 91, 70,
646 112, 71, 118, 115, 89, 116, 101, 65, 382, 122,
647 90, 89, 119, 129, 117, 120, 123, 90, 91, 132,
648 124, 92, 130, 133, 158, 91, 145, 131, 573, 139,
649 134, 154, 140, 141, 572, 574, 135, 146, 136, 142,
650 83, 83, 143, 74, 147, 144, 155, 155, 66, 173,
651 156, 193, 160, 161, 163, 163, 162, 217, 239, 87,
652 75, 88, 88, 169, 218, 169, 164, 165, 170, 170,
653
654 166, 240, 171, 89, 173, 160, 161, 167, 172, 244,
655 203, 162, 206, 168, 204, 87, 571, 93, 93, 164,
656 165, 207, 194, 275, 245, 166, 89, 171, 211, 89,
657 570, 212, 167, 90, 241, 172, 233, 234, 272, 91,
658 168, 235, 569, 250, 251, 261, 574, 236, 237, 252,
659 275, 242, 89, 256, 195, 257, 325, 253, 90, 254,
660 155, 155, 568, 272, 156, 326, 91, 177, 276, 178,
661 270, 179, 180, 181, 182, 183, 271, 184, 185, 186,
662 193, 187, 188, 189, 285, 263, 262, 263, 163, 163,
663 264, 264, 268, 276, 268, 270, 345, 269, 269, 346,
664
665 265, 266, 277, 271, 267, 170, 170, 261, 278, 170,
666 170, 283, 283, 286, 287, 284, 295, 296, 313, 314,
667 196, 194, 273, 265, 266, 274, 353, 277, 567, 267,
668 155, 155, 264, 264, 156, 278, 264, 264, 351, 354,
669 351, 269, 269, 352, 352, 273, 269, 269, 262, 161,
670 274, 355, 162, 353, 357, 361, 421, 356, 387, 165,
671 361, 388, 166, 420, 354, 283, 283, 352, 352, 284,
672 352, 352, 161, 427, 283, 283, 355, 162, 284, 357,
673 428, 421, 165, 266, 356, 566, 267, 166, 565, 564,
674 420, 563, 562, 561, 560, 559, 362, 558, 557, 556,
675
676 555, 362, 554, 553, 552, 551, 266, 550, 549, 548,
677 547, 267, 64, 64, 64, 64, 64, 67, 546, 545,
678 67, 68, 544, 68, 68, 74, 74, 543, 74, 74,
679 157, 542, 157, 157, 174, 174, 192, 192, 192, 192,
680 192, 195, 195, 541, 195, 195, 260, 260, 260, 260,
681 260, 360, 360, 360, 360, 360, 540, 539, 538, 537,
682 536, 535, 534, 533, 532, 531, 530, 527, 526, 525,
683 524, 523, 522, 521, 520, 519, 518, 517, 516, 515,
684 514, 513, 512, 511, 510, 509, 508, 507, 506, 505,
685 504, 503, 502, 501, 500, 499, 498, 497, 496, 495,
686
687 494, 493, 492, 491, 490, 489, 488, 487, 486, 485,
688 484, 483, 482, 481, 480, 479, 478, 477, 476, 475,
689 474, 473, 472, 471, 470, 469, 468, 467, 466, 465,
690 464, 463, 462, 461, 460, 459, 458, 457, 456, 455,
691 454, 453, 452, 451, 450, 449, 448, 447, 446, 445,
692 444, 443, 442, 441, 440, 439, 438, 437, 436, 435,
693 434, 433, 432, 431, 430, 429, 426, 425, 424, 423,
694 574, 422, 419, 418, 417, 416, 415, 414, 413, 412,
695 411, 410, 409, 408, 407, 406, 405, 404, 403, 402,
696 401, 400, 399, 398, 397, 396, 395, 394, 393, 392,
697
698 391, 390, 389, 386, 385, 384, 383, 380, 379, 378,
699 377, 376, 375, 374, 373, 372, 371, 370, 369, 368,
700 367, 366, 365, 364, 363, 359, 358, 574, 350, 349,
701 348, 347, 344, 343, 342, 341, 340, 339, 338, 337,
702 336, 335, 334, 333, 332, 331, 330, 329, 328, 327,
703 324, 323, 322, 321, 320, 319, 318, 317, 316, 315,
704 312, 311, 310, 309, 308, 307, 306, 305, 304, 303,
705 302, 301, 300, 299, 298, 297, 294, 293, 292, 291,
706 290, 289, 288, 574, 282, 281, 280, 279, 259, 258,
707 255, 249, 248, 247, 246, 243, 238, 232, 231, 230,
708
709 229, 228, 227, 226, 225, 224, 223, 222, 221, 220,
710 219, 216, 215, 214, 213, 210, 209, 208, 205, 202,
711 201, 200, 199, 198, 197, 196, 191, 190, 176, 175,
712 159, 574, 152, 151, 148, 138, 137, 128, 127, 121,
713 109, 106, 105, 104, 96, 76, 75, 63, 574, 3,
714 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
715 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
716 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
717 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
718 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
719
720 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
721 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
722 574, 574, 574, 574, 574, 574, 574, 574
723 } ;
724
725 static yyconst short int yy_chk[829] =
726 { 0,
727 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
728 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
729 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
730 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
731 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
732 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
733 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
734 1, 1, 1, 1, 1, 1, 1, 1, 8, 11,
735 12, 17, 512, 20, 19, 20, 20, 21, 26, 26,
736 38, 17, 19, 19, 512, 12, 38, 22, 21, 22,
737
738 22, 28, 28, 31, 23, 41, 23, 23, 31, 46,
739 60, 22, 56, 46, 41, 22, 30, 40, 23, 8,
740 21, 22, 23, 22, 40, 56, 30, 311, 23, 11,
741 40, 11, 43, 42, 22, 42, 30, 64, 311, 45,
742 22, 23, 43, 49, 42, 43, 45, 23, 22, 50,
743 45, 22, 49, 50, 74, 23, 54, 49, 572, 53,
744 50, 60, 53, 53, 571, 75, 50, 54, 50, 53,
745 83, 83, 53, 75, 54, 53, 65, 65, 64, 91,
746 65, 102, 83, 83, 87, 87, 83, 123, 140, 88,
747 74, 88, 88, 89, 123, 89, 87, 87, 89, 89,
748
749 87, 140, 90, 88, 91, 83, 83, 88, 90, 143,
750 111, 83, 113, 88, 111, 93, 569, 93, 93, 87,
751 87, 113, 102, 171, 143, 87, 88, 90, 117, 93,
752 568, 117, 88, 93, 141, 90, 138, 138, 168, 93,
753 88, 138, 567, 148, 148, 156, 196, 138, 138, 148,
754 171, 141, 93, 150, 196, 150, 235, 148, 93, 148,
755 155, 155, 566, 168, 155, 235, 93, 99, 173, 99,
756 167, 99, 99, 99, 99, 99, 167, 99, 99, 99,
757 192, 99, 99, 99, 195, 160, 156, 160, 163, 163,
758 160, 160, 164, 173, 164, 167, 255, 164, 164, 255,
759
760 163, 163, 174, 167, 163, 169, 169, 260, 174, 170,
761 170, 193, 193, 197, 197, 193, 205, 205, 223, 223,
762 195, 192, 170, 163, 163, 170, 270, 174, 565, 163,
763 261, 261, 263, 263, 261, 174, 264, 264, 265, 272,
764 265, 268, 268, 265, 265, 170, 269, 269, 260, 264,
765 170, 277, 264, 270, 278, 284, 357, 277, 317, 269,
766 360, 317, 269, 355, 272, 283, 283, 351, 351, 283,
767 352, 352, 264, 368, 361, 361, 277, 264, 361, 278,
768 368, 357, 269, 352, 277, 564, 352, 269, 563, 562,
769 355, 560, 559, 557, 555, 554, 284, 552, 551, 549,
770
771 548, 360, 547, 546, 545, 544, 352, 543, 542, 541,
772 540, 352, 575, 575, 575, 575, 575, 576, 538, 537,
773 576, 577, 536, 577, 577, 578, 578, 535, 578, 578,
774 579, 534, 579, 579, 580, 580, 581, 581, 581, 581,
775 581, 582, 582, 533, 582, 582, 583, 583, 583, 583,
776 583, 584, 584, 584, 584, 584, 531, 530, 529, 528,
777 527, 526, 523, 521, 520, 518, 515, 511, 510, 509,
778 507, 504, 503, 502, 501, 499, 496, 495, 493, 492,
779 490, 489, 488, 487, 483, 482, 481, 479, 477, 476,
780 475, 471, 467, 466, 465, 464, 463, 459, 457, 454,
781
782 453, 451, 450, 449, 448, 447, 446, 445, 444, 441,
783 440, 437, 435, 434, 433, 431, 430, 429, 428, 427,
784 426, 425, 423, 417, 416, 415, 414, 413, 410, 409,
785 408, 407, 406, 405, 404, 403, 402, 401, 399, 398,
786 397, 396, 395, 394, 393, 392, 390, 389, 388, 387,
787 386, 385, 384, 383, 382, 381, 380, 379, 378, 376,
788 375, 374, 373, 372, 371, 370, 366, 365, 364, 363,
789 362, 358, 350, 349, 348, 346, 345, 344, 343, 342,
790 341, 340, 339, 338, 337, 336, 335, 334, 333, 332,
791 331, 330, 329, 328, 327, 326, 325, 324, 323, 322,
792
793 321, 319, 318, 316, 315, 314, 313, 309, 308, 307,
794 305, 304, 303, 302, 299, 298, 297, 296, 295, 294,
795 291, 289, 288, 287, 286, 282, 281, 262, 259, 258,
796 257, 256, 254, 253, 252, 251, 250, 249, 248, 247,
797 246, 245, 244, 243, 242, 241, 240, 239, 237, 236,
798 234, 233, 232, 231, 229, 228, 227, 226, 225, 224,
799 222, 221, 220, 219, 218, 217, 216, 214, 213, 212,
800 211, 210, 209, 208, 207, 206, 204, 203, 202, 201,
801 200, 199, 198, 194, 191, 190, 179, 178, 152, 151,
802 149, 147, 146, 145, 144, 142, 139, 137, 136, 135,
803
804 134, 133, 132, 131, 130, 129, 128, 127, 126, 125,
805 124, 121, 120, 119, 118, 116, 115, 114, 112, 110,
806 109, 108, 107, 106, 104, 103, 101, 100, 98, 94,
807 82, 66, 58, 57, 55, 52, 51, 48, 47, 44,
808 39, 37, 36, 32, 27, 16, 13, 7, 3, 574,
809 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
810 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
811 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
812 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
813 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
814
815 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
816 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
817 574, 574, 574, 574, 574, 574, 574, 574
818 } ;
819
820 static yy_state_type yy_last_accepting_state;
821 static char *yy_last_accepting_cpos;
822
823 /* The intent behind this definition is that it'll catch
824 * any uses of REJECT which flex missed.
825 */
826 #define REJECT reject_used_but_not_detected
827 #define yymore() yymore_used_but_not_detected
828 #define YY_MORE_ADJ 0
829 #define YY_RESTORE_YY_MORE_OFFSET
830 char *yytext;
831 #define INITIAL 0
832 /*;-*-C-*-;
833 ** Splint - annotation-assisted static program checker
834 ** Copyright (C) 1994-2003 University of Virginia,
835 ** Massachusetts Institute of Technology
836 **
837 ** This program is free software; you can redistribute it and/or modify it
838 ** under the terms of the GNU General Public License as published by the
839 ** Free Software Foundation; either version 2 of the License, or (at your
840 ** option) any later version.
841 **
842 ** This program is distributed in the hope that it will be useful, but
843 ** WITHOUT ANY WARRANTY; without even the implied warranty of
844 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
845 ** General Public License for more details.
846 **
847 ** The GNU General Public License is available from http://www.gnu.org/ or
848 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
849 ** MA 02111-1307, USA.
850 **
851 ** For information on splint: splint@cs.virginia.edu
852 ** To report a bug: splint-bug@cs.virginia.edu
853 ** For more information: http://www.splint.org
854 */
855 /*
856 ** cscanner.l
857 **
858 ** Flex lexer for C.
859 ** Based on a C lexer by Nate Osgood
860 ** from hacrat@catfish.lcs.mit.edu Mon Jun 14 13:06:32 1993
861 */
862 /*
863 ** Modified by Herbert 08/19/97:
864 ** - added #include for IBM's OS/2 compiler.
865 ** - fixed weird bug with lookup of tmp files (OS/2 and MSDOS only).
866 */
867 /*
868 ** Modified by Mike Smith
869 ** Corrected missing 'line' in scanf() calls in handleSpecial().
870 ** Without this, I get an error when Splint hits a '#line' directive
871 ** in the pre-pre-processed source files. For safety, I have made these
872 ** conditional on OS2 and MSDOS because I don't understand why noone else
873 ** has seen this problem.
874 **
875 ** Modified by Mike Smith, 4th June 1997
876 ** Finally resolved the #line problem. The scanf() calls have been fixed to
877 ** allow the following #line forms:-
878 **
879 ** #line 123 "filename"
880 ** #line 123
881 ** # 123 "filename"
882 ** # 123
883 **
884 ** The last two are generated by the GNU pre-processor, apparently
885 */
886 # include "splintMacros.nf"
887 # if defined(OS2) && defined(__IBMC__)
888 /* needed for isatty()... */
889 # include <io.h>
890 # else
891
892 /*
893 ** Win32 doesn't have unistd.h
894 */
895
896 # ifndef WIN32
897 # include <unistd.h>
898 # endif
899
900 # endif
901
902 # include "basic.h"
903
904 # include "cscannerHelp.h"
905 # include "cgrammar.h"
906 # include "cgrammar_tokens.h"
907 # include "osd.h"
908
909 /*@notfunction@*/
910 # define yyinput() (incColumn (), getc (yyin))
911
912 # include "flex.head"
913
914
915 /* Macros after this point can all be overridden by user definitions in
916 * section 1.
917 */
918
919 #ifndef YY_SKIP_YYWRAP
920 #ifdef __cplusplus
921 extern "C" int yywrap YY_PROTO(( void ));
922 #else
923 extern int yywrap YY_PROTO(( void ));
924 #endif
925 #endif
926
927 #ifndef YY_NO_UNPUT
928 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
929 #endif
930
931 #ifndef yytext_ptr
932 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
933 #endif
934
935 #ifdef YY_NEED_STRLEN
936 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
937 #endif
938
939 #ifndef YY_NO_INPUT
940 #ifdef __cplusplus
941 static int yyinput YY_PROTO(( void ));
942 #else
943 static int input YY_PROTO(( void ));
944 #endif
945 #endif
946
947 #if YY_STACK_USED
948 static int yy_start_stack_ptr = 0;
949 static int yy_start_stack_depth = 0;
950 static int *yy_start_stack = 0;
951 #ifndef YY_NO_PUSH_STATE
952 static void yy_push_state YY_PROTO(( int new_state ));
953 #endif
954 #ifndef YY_NO_POP_STATE
955 static void yy_pop_state YY_PROTO(( void ));
956 #endif
957 #ifndef YY_NO_TOP_STATE
958 static int yy_top_state YY_PROTO(( void ));
959 #endif
960
961 #else
962 #define YY_NO_PUSH_STATE 1
963 #define YY_NO_POP_STATE 1
964 #define YY_NO_TOP_STATE 1
965 #endif
966
967 #ifdef YY_MALLOC_DECL
968 YY_MALLOC_DECL
969 #else
970 #if __STDC__
971 #ifndef __cplusplus
972 #include <stdlib.h>
973 #endif
974 #else
975 /* Just try to get by without declaring the routines. This will fail
976 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
977 * or sizeof(void*) != sizeof(int).
978 */
979 #endif
980 #endif
981
982 /* Amount of stuff to slurp up with each read. */
983 #ifndef YY_READ_BUF_SIZE
984 #define YY_READ_BUF_SIZE 8192
985 #endif
986
987 /* Copy whatever the last rule matched to the standard output. */
988
989 #ifndef ECHO
990 /* This used to be an fputs(), but since the string might contain NUL's,
991 * we now use fwrite().
992 */
993 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
994 #endif
995
996 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
997 * is returned in "result".
998 */
999 #ifndef YY_INPUT
1000 #define YY_INPUT(buf,result,max_size) \
1001 if ( yy_current_buffer->yy_is_interactive ) \
1002 { \
1003 int c = '*', n; \
1004 for ( n = 0; n < max_size && \
1005 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1006 buf[n] = (char) c; \
1007 if ( c == '\n' ) \
1008 buf[n++] = (char) c; \
1009 if ( c == EOF && ferror( yyin ) ) \
1010 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1011 result = n; \
1012 } \
1013 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1014 && ferror( yyin ) ) \
1015 YY_FATAL_ERROR( "input in flex scanner failed" );
1016 #endif
1017
1018 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1019 * we don't want an extra ';' after the "return" because that will cause
1020 * some compilers to complain about unreachable statements.
1021 */
1022 #ifndef yyterminate
1023 #define yyterminate() return YY_NULL
1024 #endif
1025
1026 /* Number of entries by which start-condition stack grows. */
1027 #ifndef YY_START_STACK_INCR
1028 #define YY_START_STACK_INCR 25
1029 #endif
1030
1031 /* Report a fatal error. */
1032 #ifndef YY_FATAL_ERROR
1033 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1034 #endif
1035
1036 /* Default declaration of generated scanner - a define so the user can
1037 * easily add parameters.
1038 */
1039 #ifndef YY_DECL
1040 #define YY_DECL int yylex YY_PROTO(( void ))
1041 #endif
1042
1043 /* Code executed at the beginning of each rule, after yytext and yyleng
1044 * have been set up.
1045 */
1046 #ifndef YY_USER_ACTION
1047 #define YY_USER_ACTION
1048 #endif
1049
1050 /* Code executed at the end of each rule. */
1051 #ifndef YY_BREAK
1052 #define YY_BREAK break;
1053 #endif
1054
1055 #define YY_RULE_SETUP \
1056 YY_USER_ACTION
1057
1058 YY_DECL
1059 {
1060 register yy_state_type yy_current_state;
1061 register char *yy_cp = NULL, *yy_bp = NULL;
1062 register int yy_act;
1063
1064
1065
1066
1067 if ( yy_init )
1068 {
1069 yy_init = 0;
1070
1071 #ifdef YY_USER_INIT
1072 YY_USER_INIT;
1073 #endif
1074
1075 if ( ! yy_start )
1076 yy_start = 1; /* first start state */
1077
1078 if ( ! yyin )
1079 yyin = stdin;
1080
1081 if ( ! yyout )
1082 yyout = stdout;
1083
1084 if ( ! yy_current_buffer )
1085 yy_current_buffer =
1086 yy_create_buffer( yyin, YY_BUF_SIZE );
1087
1088 yy_load_buffer_state();
1089 }
1090
1091 while ( 1 ) /* loops until end-of-file is reached */
1092 {
1093 yy_cp = yy_c_buf_p;
1094
1095 /* Support of yytext. */
1096 *yy_cp = yy_hold_char;
1097
1098 /* yy_bp points to the position in yy_ch_buf of the start of
1099 * the current run.
1100 */
1101 yy_bp = yy_cp;
1102
1103 yy_current_state = yy_start;
1104 yy_match:
1105 do
1106 {
1107 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1108 if ( yy_accept[yy_current_state] )
1109 {
1110 yy_last_accepting_state = yy_current_state;
1111 yy_last_accepting_cpos = yy_cp;
1112 }
1113 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1114 {
1115 yy_current_state = (int) yy_def[yy_current_state];
1116 if ( yy_current_state >= 575 )
1117 yy_c = yy_meta[(unsigned int) yy_c];
1118 }
1119 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1120 ++yy_cp;
1121 }
1122 while ( yy_base[yy_current_state] != 750 );
1123
1124 yy_find_action:
1125 yy_act = yy_accept[yy_current_state];
1126 if ( yy_act == 0 )
1127 { /* have to back up */
1128 yy_cp = yy_last_accepting_cpos;
1129 yy_current_state = yy_last_accepting_state;
1130 yy_act = yy_accept[yy_current_state];
1131 }
1132
1133 YY_DO_BEFORE_ACTION;
1134
1135
1136 do_action: /* This label is used only to access EOF actions. */
1137
1138
1139 switch ( yy_act )
1140 { /* beginning of action switch */
1141 case 0: /* must back up */
1142 /* undo the effects of YY_DO_BEFORE_ACTION */
1143 *yy_cp = yy_hold_char;
1144 yy_cp = yy_last_accepting_cpos;
1145 yy_current_state = yy_last_accepting_state;
1146 goto yy_find_action;
1147
1148 case 1:
1149 YY_RULE_SETUP
1150 { llfatalerror (cstring_makeLiteral ("Comment in pre-processor output")); }
1151 YY_BREAK
1152 case 2:
1153 YY_RULE_SETUP
1154 {
1155 context_saveLocation ();
1156 cscannerHelp_setTokLength (longUnsigned_toInt (mstring_length (yytext)));
1157
1158 if (cscannerHelp_processHashIdentifier
1159 (cscannerHelp_makeIdentifier (yytext + 1)))
1160 {
1161 return cscannerHelp_returnString (cstring_makeLiteral ("\"\""));
1162 }
1163 else
1164 {
1165 if (cscannerHelp_handleSpecial (yytext))
1166 {
1167 cscannerHelp_setTokLength (1);
1168 return cscannerHelp_returnToken (0);
1169 }
1170 }
1171 }
1172 YY_BREAK
1173 case 3:
1174 YY_RULE_SETUP
1175 { if (cscannerHelp_handleSpecial (yytext))
1176 {
1177 cscannerHelp_setTokLength (1); return cscannerHelp_returnToken (0);
1178 }
1179 }
1180 YY_BREAK
1181 case 4:
1182 YY_RULE_SETUP
1183 { cscannerHelp_setTokLength (3); return cscannerHelp_returnToken (CTOK_ELIPSIS); }
1184 YY_BREAK
1185 case 5:
1186 YY_RULE_SETUP
1187 { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (BREAK); }
1188 YY_BREAK
1189 case 6:
1190 YY_RULE_SETUP
1191 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CASE); }
1192 YY_BREAK
1193 case 7:
1194 YY_RULE_SETUP
1195 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (CONTINUE); }
1196 YY_BREAK
1197 case 8:
1198 YY_RULE_SETUP
1199 { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (DEFAULT); }
1200 YY_BREAK
1201 case 9:
1202 YY_RULE_SETUP
1203 { cscannerHelp_setTokLength (2); return cscannerHelp_returnToken (DO); }
1204 YY_BREAK
1205 case 10:
1206 YY_RULE_SETUP
1207 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CELSE); }
1208 YY_BREAK
1209 case 11:
1210 YY_RULE_SETUP
1211 { cscannerHelp_setTokLength (3); return cscannerHelp_returnToken (CFOR); }
1212 YY_BREAK
1213 case 12:
1214 YY_RULE_SETUP
1215 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (GOTO); }
1216 YY_BREAK
1217 case 13:
1218 YY_RULE_SETUP
1219 { cscannerHelp_setTokLength (2); return cscannerHelp_returnToken (CIF); }
1220 YY_BREAK
1221 case 14:
1222 YY_RULE_SETUP
1223 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (RETURN); }
1224 YY_BREAK
1225 case 15:
1226 YY_RULE_SETUP
1227 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (CSIZEOF); }
1228 YY_BREAK
1229 case 16:
1230 YY_RULE_SETUP
1231 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (COFFSETOF); }
1232 YY_BREAK
1233 case 17:
1234 YY_RULE_SETUP
1235 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (SWITCH); }
1236 YY_BREAK
1237 case 18:
1238 YY_RULE_SETUP
1239 { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (WHILE); }
1240 YY_BREAK
1241 case 19:
1242 YY_RULE_SETUP
1243 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (VA_ARG); }
1244 YY_BREAK
1245 case 20:
1246 YY_RULE_SETUP
1247 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (VA_DCL); }
1248 YY_BREAK
1249 case 21:
1250 YY_RULE_SETUP
1251 {
1252 /* gcc extension...this might not be appropriate */
1253 cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QINLINE); }
1254 YY_BREAK
1255 case 22:
1256 YY_RULE_SETUP
1257 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (CSTRUCT); }
1258 YY_BREAK
1259 case 23:
1260 YY_RULE_SETUP
1261 { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (CTYPEDEF); }
1262 YY_BREAK
1263 case 24:
1264 YY_RULE_SETUP
1265 { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (CUNION); }
1266 YY_BREAK
1267 case 25:
1268 YY_RULE_SETUP
1269 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CENUM); }
1270 YY_BREAK
1271 case 26:
1272 YY_RULE_SETUP
1273 { cscannerHelp_setTokLength (4); return cscannerHelp_returnType (CVOID, ctype_void); }
1274 YY_BREAK
1275 case 27:
1276 YY_RULE_SETUP
1277 { cscannerHelp_setTokLength (3); return cscannerHelp_returnType (CINT, ctype_int); }
1278 YY_BREAK
1279 case 28:
1280 YY_RULE_SETUP
1281 { cscannerHelp_setTokLength (6); return cscannerHelp_returnType (CDOUBLE, ctype_double); }
1282 YY_BREAK
1283 case 29:
1284 YY_RULE_SETUP
1285 { cscannerHelp_setTokLength (4); return cscannerHelp_returnType (CGCHAR, ctype_char); }
1286 YY_BREAK
1287 case 30:
1288 YY_RULE_SETUP
1289 { cscannerHelp_setTokLength (5); return cscannerHelp_returnType (CGFLOAT, ctype_float); }
1290 YY_BREAK
1291 case 31:
1292 YY_RULE_SETUP
1293 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (QLONG); }
1294 YY_BREAK
1295 case 32:
1296 YY_RULE_SETUP
1297 { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (QSHORT); }
1298 YY_BREAK
1299 case 33:
1300 YY_RULE_SETUP
1301 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QUNSIGNED); }
1302 YY_BREAK
1303 case 34:
1304 YY_RULE_SETUP
1305 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QSIGNED); }
1306 YY_BREAK
1307 case 35:
1308 YY_RULE_SETUP
1309 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QVOLATILE); }
1310 YY_BREAK
1311 case 36:
1312 YY_RULE_SETUP
1313 { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (QCONST); }
1314 YY_BREAK
1315 case 37:
1316 YY_RULE_SETUP
1317 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QRESTRICT); }
1318 YY_BREAK
1319 /* some systems expect this! [gack!] */
1320 case 38:
1321 YY_RULE_SETUP
1322 { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (QCONST); }
1323 YY_BREAK
1324 case 39:
1325 YY_RULE_SETUP
1326 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QEXTERN); }
1327 YY_BREAK
1328 case 40:
1329 YY_RULE_SETUP
1330 { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (QAUTO); }
1331 YY_BREAK
1332 case 41:
1333 YY_RULE_SETUP
1334 { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QREGISTER); }
1335 YY_BREAK
1336 case 42:
1337 YY_RULE_SETUP
1338 { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QSTATIC); }
1339 YY_BREAK
1340 case 43:
1341 YY_RULE_SETUP
1342 { return cscannerHelp_returnExpr (cscannerHelp_processString ()); }
1343 YY_BREAK
1344 case 44:
1345 YY_RULE_SETUP
1346 { return cscannerHelp_returnExpr (cscannerHelp_processWideString ()); }
1347 YY_BREAK
1348 case 45:
1349 YY_RULE_SETUP
1350 { return (cscannerHelp_processSpec (QOUT)); }
1351 YY_BREAK
1352 case 46:
1353 YY_RULE_SETUP
1354 { return (cscannerHelp_processSpec (QIN)); }
1355 YY_BREAK
1356 case 47:
1357 YY_RULE_SETUP
1358 { return (cscannerHelp_processSpec (QPARTIAL)); }
1359 YY_BREAK
1360 case 48:
1361 YY_RULE_SETUP
1362 { return (cscannerHelp_processSpec (QSPECIAL)); }
1363 YY_BREAK
1364 case 49:
1365 YY_RULE_SETUP
1366 { return (cscannerHelp_processSpec (QANYTYPE)); }
1367 YY_BREAK
1368 case 50:
1369 YY_RULE_SETUP
1370 { return (cscannerHelp_processSpec (QINTEGRALTYPE)); }
1371 YY_BREAK
1372 case 51:
1373 YY_RULE_SETUP
1374 { return (cscannerHelp_processSpec (QUNSIGNEDINTEGRALTYPE)); }
1375 YY_BREAK
1376 case 52:
1377 YY_RULE_SETUP
1378 { return (cscannerHelp_processSpec (QSIGNEDINTEGRALTYPE)); }
1379 YY_BREAK
1380 case 53:
1381 YY_RULE_SETUP
1382 { return (cscannerHelp_processSpec (QKEEP)); }
1383 YY_BREAK
1384 case 54:
1385 YY_RULE_SETUP
1386 { return (cscannerHelp_processSpec (QNULL)); }
1387 YY_BREAK
1388 case 55:
1389 YY_RULE_SETUP
1390 { return (cscannerHelp_processSpec (QNOTNULL)); }
1391 YY_BREAK
1392 case 56:
1393 YY_RULE_SETUP
1394 { return (cscannerHelp_processSpec (QISNULL)); }
1395 YY_BREAK
1396 case 57:
1397 YY_RULE_SETUP
1398 { return (cscannerHelp_processSpec (QTRUENULL)); }
1399 YY_BREAK
1400 case 58:
1401 YY_RULE_SETUP
1402 { return (cscannerHelp_processSpec (QFALSENULL)); }
1403 YY_BREAK
1404 case 59:
1405 YY_RULE_SETUP
1406 { return (cscannerHelp_processSpec (QTRUENULL)); }
1407 YY_BREAK
1408 case 60:
1409 YY_RULE_SETUP
1410 { return (cscannerHelp_processSpec (QFALSENULL)); }
1411 YY_BREAK
1412 case 61:
1413 YY_RULE_SETUP
1414 { return (cscannerHelp_processSpec (QRELNULL)); }
1415 YY_BREAK
1416 case 62:
1417 YY_RULE_SETUP
1418 { return (cscannerHelp_processSpec (QRELDEF)); }
1419 YY_BREAK
1420 case 63:
1421 YY_RULE_SETUP
1422 { return (cscannerHelp_processSpec (QEXPOSED)); }
1423 YY_BREAK
1424 case 64:
1425 YY_RULE_SETUP
1426 { return (cscannerHelp_processSpec (QNEWREF)); }
1427 YY_BREAK
1428 case 65:
1429 YY_RULE_SETUP
1430 { return (cscannerHelp_processSpec (QTEMPREF)); }
1431 YY_BREAK
1432 case 66:
1433 YY_RULE_SETUP
1434 { return (cscannerHelp_processSpec (QKILLREF)); }
1435 YY_BREAK
1436 case 67:
1437 YY_RULE_SETUP
1438 { return (cscannerHelp_processSpec (QREFCOUNTED)); }
1439 YY_BREAK
1440 case 68:
1441 YY_RULE_SETUP
1442 { return (cscannerHelp_processSpec (QCHECKED)); }
1443 YY_BREAK
1444 case 69:
1445 YY_RULE_SETUP
1446 { return (cscannerHelp_processSpec (QCHECKMOD)); }
1447 YY_BREAK
1448 case 70:
1449 YY_RULE_SETUP
1450 { return (cscannerHelp_processSpec (QCHECKEDSTRICT)); }
1451 YY_BREAK
1452 case 71:
1453 YY_RULE_SETUP
1454 { return (cscannerHelp_processSpec (QUNCHECKED)); }
1455 YY_BREAK
1456 case 72:
1457 YY_RULE_SETUP
1458 { return (cscannerHelp_processSpec (QONLY)); }
1459 YY_BREAK
1460 case 73:
1461 YY_RULE_SETUP
1462 { return (cscannerHelp_processSpec (QOWNED)); }
1463 YY_BREAK
1464 case 74:
1465 YY_RULE_SETUP
1466 { return (cscannerHelp_processSpec (QOBSERVER)); }
1467 YY_BREAK
1468 case 75:
1469 YY_RULE_SETUP
1470 { return (cscannerHelp_processSpec (QDEPENDENT)); }
1471 YY_BREAK
1472 case 76:
1473 YY_RULE_SETUP
1474 { return (cscannerHelp_processSpec (QUNUSED)); }
1475 YY_BREAK
1476 case 77:
1477 YY_RULE_SETUP
1478 { return (cscannerHelp_processSpec (QEXTERNAL)); }
1479 YY_BREAK
1480 case 78:
1481 YY_RULE_SETUP
1482 { return (cscannerHelp_processSpec (QSEF)); }
1483 YY_BREAK
1484 case 79:
1485 YY_RULE_SETUP
1486 { return (cscannerHelp_processSpec (QSHARED)); }
1487 YY_BREAK
1488 case 80:
1489 YY_RULE_SETUP
1490 { return (cscannerHelp_processSpec (QYIELD)); }
1491 YY_BREAK
1492 case 81:
1493 YY_RULE_SETUP
1494 { return (cscannerHelp_processSpec (QUNDEF)); }
1495 YY_BREAK
1496 case 82:
1497 YY_RULE_SETUP
1498 { return (cscannerHelp_processSpec (QKILLED)); }
1499 YY_BREAK
1500 case 83:
1501 YY_RULE_SETUP
1502 { return (cscannerHelp_processSpec (QNULLTERMINATED));}
1503 YY_BREAK
1504 case 84:
1505 YY_RULE_SETUP
1506 { return (cscannerHelp_processSpec (QMAXSET));}
1507 YY_BREAK
1508 case 85:
1509 YY_RULE_SETUP
1510 { return (cscannerHelp_processSpec (QMAXREAD));}
1511 YY_BREAK
1512 case 86:
1513 YY_RULE_SETUP
1514 { return (cscannerHelp_processSpec (QMAXSET));}
1515 YY_BREAK
1516 case 87:
1517 YY_RULE_SETUP
1518 { return (cscannerHelp_processSpec (QMAXREAD));}
1519 YY_BREAK
1520 case 88:
1521 YY_RULE_SETUP
1522 { int tok = cscannerHelp_processTextIdentifier (yytext);
1523 if (tok != BADTOK)
1524 {
1525 return (tok);
1526 }
1527 }
1528 YY_BREAK
1529 case 89:
1530 YY_RULE_SETUP
1531 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1532 return cscannerHelp_returnInt (ctype_int, cscannerHelp_processHex ()); /* evs 2000-05-17 was ctype_uint */
1533 }
1534 YY_BREAK
1535 case 90:
1536 YY_RULE_SETUP
1537 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1538 return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processHex ()); }
1539 YY_BREAK
1540 case 91:
1541 YY_RULE_SETUP
1542 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1543 return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processHex ()); }
1544 YY_BREAK
1545 case 92:
1546 YY_RULE_SETUP
1547 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1548 return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processHex ()); }
1549 YY_BREAK
1550 case 93:
1551 YY_RULE_SETUP
1552 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1553 return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processHex ()); }
1554 YY_BREAK
1555 case 94:
1556 YY_RULE_SETUP
1557 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1558 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processHex ()); }
1559 YY_BREAK
1560 case 95:
1561 YY_RULE_SETUP
1562 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1563 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processHex ()); }
1564 YY_BREAK
1565 case 96:
1566 YY_RULE_SETUP
1567 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1568 return cscannerHelp_returnInt (ctype_int, cscannerHelp_processOctal ()); }
1569 YY_BREAK
1570 case 97:
1571 YY_RULE_SETUP
1572 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1573 return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processOctal ()); }
1574 YY_BREAK
1575 case 98:
1576 YY_RULE_SETUP
1577 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1578 return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processOctal ()); }
1579 YY_BREAK
1580 case 99:
1581 YY_RULE_SETUP
1582 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1583 return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processOctal ()); }
1584 YY_BREAK
1585 case 100:
1586 YY_RULE_SETUP
1587 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1588 return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processOctal ()); }
1589 YY_BREAK
1590 case 101:
1591 YY_RULE_SETUP
1592 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1593 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processOctal ()); }
1594 YY_BREAK
1595 case 102:
1596 YY_RULE_SETUP
1597 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1598 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processOctal ()); }
1599 YY_BREAK
1600 case 103:
1601 YY_RULE_SETUP
1602 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1603 return cscannerHelp_returnInt (ctype_int, cscannerHelp_processDec ()); }
1604 YY_BREAK
1605 case 104:
1606 YY_RULE_SETUP
1607 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1608 return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processDec ()); }
1609 YY_BREAK
1610 case 105:
1611 YY_RULE_SETUP
1612 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1613 return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processDec ()); }
1614 YY_BREAK
1615 case 106:
1616 YY_RULE_SETUP
1617 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1618 return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processDec ()); }
1619 YY_BREAK
1620 case 107:
1621 YY_RULE_SETUP
1622 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1623 return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processDec ()); }
1624 YY_BREAK
1625 case 108:
1626 YY_RULE_SETUP
1627 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1628 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processDec ()); }
1629 YY_BREAK
1630 case 109:
1631 YY_RULE_SETUP
1632 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1633 return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processDec ()); }
1634 YY_BREAK
1635 case 110:
1636 YY_RULE_SETUP
1637 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1638 return cscannerHelp_returnChar (cscannerHelp_processChar ()); }
1639 YY_BREAK
1640 case 111:
1641 YY_RULE_SETUP
1642 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1643 return cscannerHelp_returnChar (cscannerHelp_processChar ()); }
1644 YY_BREAK
1645 case 112:
1646 YY_RULE_SETUP
1647 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1648 return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
1649 YY_BREAK
1650 case 113:
1651 YY_RULE_SETUP
1652 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1653 return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
1654 YY_BREAK
1655 case 114:
1656 YY_RULE_SETUP
1657 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1658 return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
1659 YY_BREAK
1660 case 115:
1661 YY_RULE_SETUP
1662 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1663 return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
1664 YY_BREAK
1665 case 116:
1666 YY_RULE_SETUP
1667 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1668 return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
1669 YY_BREAK
1670 case 117:
1671 YY_RULE_SETUP
1672 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1673 return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
1674 YY_BREAK
1675 case 118:
1676 YY_RULE_SETUP
1677 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1678 return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
1679 YY_BREAK
1680 case 119:
1681 YY_RULE_SETUP
1682 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1683 return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
1684 YY_BREAK
1685 case 120:
1686 YY_RULE_SETUP
1687 { cscannerHelp_setTokLengthT (mstring_length (yytext));
1688 return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
1689 YY_BREAK
1690 case 121:
1691 YY_RULE_SETUP
1692 { return cscannerHelp_returnTokenLength (RIGHT_ASSIGN, 3); }
1693 YY_BREAK
1694 case 122:
1695 YY_RULE_SETUP
1696 { return cscannerHelp_returnTokenLength (LEFT_ASSIGN, 3); }
1697 YY_BREAK
1698 case 123:
1699 YY_RULE_SETUP
1700 { return cscannerHelp_returnTokenLength (ADD_ASSIGN, 2); }
1701 YY_BREAK
1702 case 124:
1703 YY_RULE_SETUP
1704 { return cscannerHelp_returnTokenLength (SUB_ASSIGN, 2); }
1705 YY_BREAK
1706 case 125:
1707 YY_RULE_SETUP
1708 { return cscannerHelp_returnTokenLength (MUL_ASSIGN, 2); }
1709 YY_BREAK
1710 case 126:
1711 YY_RULE_SETUP
1712 { return cscannerHelp_returnTokenLength (DIV_ASSIGN, 2); }
1713 YY_BREAK
1714 case 127:
1715 YY_RULE_SETUP
1716 { return cscannerHelp_returnTokenLength (MOD_ASSIGN, 2); }
1717 YY_BREAK
1718 case 128:
1719 YY_RULE_SETUP
1720 { return cscannerHelp_returnTokenLength (AND_ASSIGN, 2); }
1721 YY_BREAK
1722 case 129:
1723 YY_RULE_SETUP
1724 { return cscannerHelp_returnTokenLength (XOR_ASSIGN, 2); }
1725 YY_BREAK
1726 case 130:
1727 YY_RULE_SETUP
1728 { return cscannerHelp_returnTokenLength (OR_ASSIGN, 2); }
1729 YY_BREAK
1730 case 131:
1731 YY_RULE_SETUP
1732 { return cscannerHelp_returnTokenLength (RIGHT_OP, 2); }
1733 YY_BREAK
1734 case 132:
1735 YY_RULE_SETUP
1736 { return cscannerHelp_returnTokenLength (LEFT_OP, 2); }
1737 YY_BREAK
1738 case 133:
1739 YY_RULE_SETUP
1740 { return cscannerHelp_returnTokenLength (INC_OP, 2); }
1741 YY_BREAK
1742 case 134:
1743 YY_RULE_SETUP
1744 { return cscannerHelp_returnTokenLength (DEC_OP, 2); }
1745 YY_BREAK
1746 case 135:
1747 YY_RULE_SETUP
1748 { return cscannerHelp_returnTokenLength (ARROW_OP, 2); }
1749 YY_BREAK
1750 case 136:
1751 YY_RULE_SETUP
1752 { return cscannerHelp_returnTokenLength (AND_OP, 2); }
1753 YY_BREAK
1754 case 137:
1755 YY_RULE_SETUP
1756 { return cscannerHelp_returnTokenLength (OR_OP, 2); }
1757 YY_BREAK
1758 case 138:
1759 YY_RULE_SETUP
1760 { return cscannerHelp_returnTokenLength (TCAND, 2); }
1761 YY_BREAK
1762 case 139:
1763 YY_RULE_SETUP
1764 { return cscannerHelp_returnTokenLength (LE_OP, 2); }
1765 YY_BREAK
1766 case 140:
1767 YY_RULE_SETUP
1768 { return cscannerHelp_returnTokenLength (GE_OP, 2); }
1769 YY_BREAK
1770 case 141:
1771 YY_RULE_SETUP
1772 { return cscannerHelp_returnTokenLength (EQ_OP, 2); }
1773 YY_BREAK
1774 case 142:
1775 YY_RULE_SETUP
1776 { return cscannerHelp_returnTokenLength (NE_OP, 2); }
1777 YY_BREAK
1778 case 143:
1779 YY_RULE_SETUP
1780 { return cscannerHelp_returnTokenLength (TSEMI, 1); }
1781 YY_BREAK
1782 case 144:
1783 YY_RULE_SETUP
1784 { return cscannerHelp_returnTokenLength (TLBRACE, 1); }
1785 YY_BREAK
1786 case 145:
1787 YY_RULE_SETUP
1788 { return cscannerHelp_returnTokenLength (TRBRACE, 1); }
1789 YY_BREAK
1790 case 146:
1791 YY_RULE_SETUP
1792 { return cscannerHelp_returnTokenLength (TCOMMA, 1); }
1793 YY_BREAK
1794 case 147:
1795 YY_RULE_SETUP
1796 { return cscannerHelp_returnTokenLength (TCOLON, 1); }
1797 YY_BREAK
1798 case 148:
1799 YY_RULE_SETUP
1800 { return cscannerHelp_returnTokenLength (TASSIGN, 1); }
1801 YY_BREAK
1802 case 149:
1803 YY_RULE_SETUP
1804 { return cscannerHelp_returnTokenLength (TLPAREN, 1); }
1805 YY_BREAK
1806 case 150:
1807 YY_RULE_SETUP
1808 { return cscannerHelp_returnTokenLength (TRPAREN, 1); }
1809 YY_BREAK
1810 case 151:
1811 YY_RULE_SETUP
1812 { return cscannerHelp_returnTokenLength (TLSQBR, 1); }
1813 YY_BREAK
1814 case 152:
1815 YY_RULE_SETUP
1816 { return cscannerHelp_returnTokenLength (TRSQBR, 1); }
1817 YY_BREAK
1818 case 153:
1819 YY_RULE_SETUP
1820 { return cscannerHelp_returnTokenLength (TDOT, 1); }
1821 YY_BREAK
1822 case 154:
1823 YY_RULE_SETUP
1824 { return cscannerHelp_returnTokenLength (TAMPERSAND, 1); }
1825 YY_BREAK
1826 case 155:
1827 YY_RULE_SETUP
1828 { return cscannerHelp_returnTokenLength (TEXCL, 1); }
1829 YY_BREAK
1830 case 156:
1831 YY_RULE_SETUP
1832 { return cscannerHelp_returnTokenLength (TTILDE, 1); }
1833 YY_BREAK
1834 case 157:
1835 YY_RULE_SETUP
1836 { return cscannerHelp_returnTokenLength (TMINUS, 1); }
1837 YY_BREAK
1838 case 158:
1839 YY_RULE_SETUP
1840 { return cscannerHelp_returnTokenLength (TPLUS, 1); }
1841 YY_BREAK
1842 case 159:
1843 YY_RULE_SETUP
1844 { return cscannerHelp_returnTokenLength (TMULT, 1); }
1845 YY_BREAK
1846 case 160:
1847 YY_RULE_SETUP
1848 { return cscannerHelp_returnTokenLength (TDIV, 1); }
1849 YY_BREAK
1850 case 161:
1851 YY_RULE_SETUP
1852 { return cscannerHelp_returnTokenLength (TPERCENT, 1); }
1853 YY_BREAK
1854 case 162:
1855 YY_RULE_SETUP
1856 { return cscannerHelp_returnTokenLength (TLT, 1); }
1857 YY_BREAK
1858 case 163:
1859 YY_RULE_SETUP
1860 { return cscannerHelp_returnTokenLength (TGT, 1); }
1861 YY_BREAK
1862 case 164:
1863 YY_RULE_SETUP
1864 { return cscannerHelp_returnTokenLength (TCIRC, 1); }
1865 YY_BREAK
1866 case 165:
1867 YY_RULE_SETUP
1868 { return cscannerHelp_returnTokenLength (TBAR, 1); }
1869 YY_BREAK
1870 case 166:
1871 YY_RULE_SETUP
1872 { return cscannerHelp_returnTokenLength (TQUEST, 1); }
1873 YY_BREAK
1874 case 167:
1875 YY_RULE_SETUP
1876 { incColumn (); }
1877 YY_BREAK
1878 case 168:
1879 YY_RULE_SETUP
1880 { int tok = cscannerHelp_handleNewLine ();
1881 if (tok != BADTOK) return tok; }
1882 YY_BREAK
1883 case 169:
1884 YY_RULE_SETUP
1885 { cscannerHelp_setTokLength (6);
1886
1887 if (cscannerHelp_processMacro ()) {
1888 if (context_inIterDef ())
1889 {
1890 return cscannerHelp_returnToken (LLMACROITER);
1891 }
1892 if (context_inIterEnd ())
1893 {
1894 return cscannerHelp_returnToken (LLMACROEND);
1895 }
1896 if (context_inMacro ())
1897 {
1898 return cscannerHelp_returnToken (LLMACRO);
1899 }
1900 }
1901 }
1902 YY_BREAK
1903 case 170:
1904 YY_RULE_SETUP
1905 { if (context_inHeader () || context_inFunction ())
1906 {
1907 cscannerHelp_handleMacro ();
1908 }
1909 else
1910 {
1911 int nspchar = cscannerHelp_ninput ();
1912 int nspaces;
1913
1914 /*
1915 ** This is a hack to get the column number correct.
1916 */
1917
1918 llassert (nspchar >= '0' && nspchar <= '9');
1919
1920 nspaces = nspchar - '0';
1921
1922 cscannerHelp_setTokLength (5 + nspaces);
1923
1924 if (cscannerHelp_processMacro ())
1925 {
1926 DPRINTF (("Here we are: %s", context_unparse ()));
1927
1928 if (context_inIterDef ())
1929 {
1930 return cscannerHelp_returnToken (LLMACROITER);
1931 }
1932 if (context_inIterEnd ())
1933 {
1934 return cscannerHelp_returnToken (LLMACROEND);
1935 }
1936 if (context_inMacro ())
1937 {
1938 return cscannerHelp_returnToken (LLMACRO);
1939 }
1940 }
1941 }
1942 }
1943 YY_BREAK
1944 case 171:
1945 YY_RULE_SETUP
1946 { cscannerHelp_setTokLength (4); lldiagmsg (ctype_unparseTable ()); }
1947 YY_BREAK
1948 case 172:
1949 YY_RULE_SETUP
1950 { cscannerHelp_setTokLength (4); lldiagmsg (message ("Access types: %q", typeIdSet_unparse (context_fileAccessTypes ()))); }
1951 YY_BREAK
1952 case 173:
1953 YY_RULE_SETUP
1954 { cscannerHelp_setTokLength (3);
1955 lldiagmsg (message ("%q: *** marker ***", fileloc_unparse (g_currentloc)));
1956 }
1957 YY_BREAK
1958 case 174:
1959 YY_RULE_SETUP
1960 { cscannerHelp_setTokLength (3); usymtab_printLocal (); }
1961 YY_BREAK
1962 case 175:
1963 YY_RULE_SETUP
1964 { cscannerHelp_setTokLength (3); lldiagmsg (usymtab_unparseAliases ()); }
1965 YY_BREAK
1966 case 176:
1967 YY_RULE_SETUP
1968 { cscannerHelp_setTokLength (3); lldiagmsg (context_unparse ()); }
1969 YY_BREAK
1970 case 177:
1971 YY_RULE_SETUP
1972 { cscannerHelp_setTokLength (3); lldiagmsg (context_unparseClauses ()); }
1973 YY_BREAK
1974 case 178:
1975 YY_RULE_SETUP
1976 { cscannerHelp_setTokLength (3); usymtab_printGuards (); }
1977 YY_BREAK
1978 case 179:
1979 YY_RULE_SETUP
1980 { cscannerHelp_setTokLength (3); usymtab_printOut (); }
1981 YY_BREAK
1982 case 180:
1983 YY_RULE_SETUP
1984 { cscannerHelp_setTokLength (3); usymtab_printAll (); }
1985 YY_BREAK
1986 case 181:
1987 YY_RULE_SETUP
1988 { cscannerHelp_setTokLength (3); usymtab_printComplete (); }
1989 YY_BREAK
1990 case 182:
1991 YY_RULE_SETUP
1992 { cscannerHelp_setTokLength (3); usymtab_printTypes (); }
1993 YY_BREAK
1994 case 183:
1995 YY_RULE_SETUP
1996 { cscannerHelp_setTokLength (3); lldiagmsg (usymtab_unparseStack ()); }
1997 YY_BREAK
1998 case 184:
1999 YY_RULE_SETUP
2000 { cscannerHelp_setTokLength (3); return cscannerHelp_returnToken (QDREVEALSTATE); }
2001 YY_BREAK
2002 case 185:
2003 YY_RULE_SETUP
2004 { cscannerHelp_setTokLength (3);
2005 lldiagmsg (message ("Can modify: %q",
2006 sRefSet_unparse (context_modList ())));
2007 }
2008 YY_BREAK
2009 case 186:
2010 YY_RULE_SETUP
2011 { /* BEFORE_COMMENT_MARKER */
2012 int tok;
2013 incColumn (); incColumn ();
2014 tok = cscannerHelp_handleLlSpecial ();
2015
2016 if (tok != BADTOK)
2017 {
2018 if (tok == CANNOTATION) {
2019 return (tok);
2020 } else {
2021 /* Beware - this bashes yylval! */
2022 return cscannerHelp_returnToken (tok);
2023 }
2024 }
2025 }
2026 YY_BREAK
2027 case 187:
2028 YY_RULE_SETUP
2029 { /* AFTER_COMMENT_MARKER */
2030 cscannerHelp_setTokLength (2);
2031 cscannerHelp_exitSpecPart ();
2032 return cscannerHelp_returnToken (QENDMACRO); }
2033 YY_BREAK
2034 case 188:
2035 YY_RULE_SETUP
2036 { incColumn (); cscannerHelp_setContinueLine (); }
2037 YY_BREAK
2038 case 189:
2039 YY_RULE_SETUP
2040 { incColumn ();
2041 if ((int) *yytext == 13 ) {
2042 ;
2043 } else {
2044 voptgenerror
2045 (FLG_SYNTAX,
2046 message ("Invalid character (ascii: %d), skipping character",
2047 (int)(*yytext)),
2048 g_currentloc);
2049 }
2050 }
2051 YY_BREAK
2052 case 190:
2053 YY_RULE_SETUP
2054 ECHO;
2055 YY_BREAK
2056 case YY_STATE_EOF(INITIAL):
2057 yyterminate();
2058
2059 case YY_END_OF_BUFFER:
2060 {
2061 /* Amount of text matched not including the EOB char. */
2062 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2063
2064 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2065 *yy_cp = yy_hold_char;
2066 YY_RESTORE_YY_MORE_OFFSET
2067
2068 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2069 {
2070 /* We're scanning a new file or input source. It's
2071 * possible that this happened because the user
2072 * just pointed yyin at a new source and called
2073 * yylex(). If so, then we have to assure
2074 * consistency between yy_current_buffer and our
2075 * globals. Here is the right place to do so, because
2076 * this is the first action (other than possibly a
2077 * back-up) that will match for the new input source.
2078 */
2079 yy_n_chars = yy_current_buffer->yy_n_chars;
2080 yy_current_buffer->yy_input_file = yyin;
2081 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2082 }
2083
2084 /* Note that here we test for yy_c_buf_p "<=" to the position
2085 * of the first EOB in the buffer, since yy_c_buf_p will
2086 * already have been incremented past the NUL character
2087 * (since all states make transitions on EOB to the
2088 * end-of-buffer state). Contrast this with the test
2089 * in input().
2090 */
2091 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2092 { /* This was really a NUL. */
2093 yy_state_type yy_next_state;
2094
2095 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2096
2097 yy_current_state = yy_get_previous_state();
2098
2099 /* Okay, we're now positioned to make the NUL
2100 * transition. We couldn't have
2101 * yy_get_previous_state() go ahead and do it
2102 * for us because it doesn't know how to deal
2103 * with the possibility of jamming (and we don't
2104 * want to build jamming into it because then it
2105 * will run more slowly).
2106 */
2107
2108 yy_next_state = yy_try_NUL_trans( yy_current_state );
2109
2110 yy_bp = yytext_ptr + YY_MORE_ADJ;
2111
2112 if ( yy_next_state )
2113 {
2114 /* Consume the NUL. */
2115 yy_cp = ++yy_c_buf_p;
2116 yy_current_state = yy_next_state;
2117 goto yy_match;
2118 }
2119
2120 else
2121 {
2122 yy_cp = yy_c_buf_p;
2123 goto yy_find_action;
2124 }
2125 }
2126
2127 else switch ( yy_get_next_buffer() )
2128 {
2129 case EOB_ACT_END_OF_FILE:
2130 {
2131 yy_did_buffer_switch_on_eof = 0;
2132
2133 if ( yywrap() )
2134 {
2135 /* Note: because we've taken care in
2136 * yy_get_next_buffer() to have set up
2137 * yytext, we can now set up
2138 * yy_c_buf_p so that if some total
2139 * hoser (like flex itself) wants to
2140 * call the scanner after we return the
2141 * YY_NULL, it'll still work - another
2142 * YY_NULL will get returned.
2143 */
2144 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2145
2146 yy_act = YY_STATE_EOF(YY_START);
2147 goto do_action;
2148 }
2149
2150 else
2151 {
2152 if ( ! yy_did_buffer_switch_on_eof )
2153 YY_NEW_FILE;
2154 }
2155 break;
2156 }
2157
2158 case EOB_ACT_CONTINUE_SCAN:
2159 yy_c_buf_p =
2160 yytext_ptr + yy_amount_of_matched_text;
2161
2162 yy_current_state = yy_get_previous_state();
2163
2164 yy_cp = yy_c_buf_p;
2165 yy_bp = yytext_ptr + YY_MORE_ADJ;
2166 goto yy_match;
2167
2168 case EOB_ACT_LAST_MATCH:
2169 yy_c_buf_p =
2170 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2171
2172 yy_current_state = yy_get_previous_state();
2173
2174 yy_cp = yy_c_buf_p;
2175 yy_bp = yytext_ptr + YY_MORE_ADJ;
2176 goto yy_find_action;
2177 }
2178 break;
2179 }
2180
2181 default:
2182 YY_FATAL_ERROR(
2183 "fatal flex scanner internal error--no action found" );
2184 } /* end of action switch */
2185 } /* end of scanning one token */
2186 } /* end of yylex */
2187
2188
2189 /* yy_get_next_buffer - try to read in a new buffer
2190 *
2191 * Returns a code representing an action:
2192 * EOB_ACT_LAST_MATCH -
2193 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2194 * EOB_ACT_END_OF_FILE - end of file
2195 */
2196
yy_get_next_buffer()2197 static int yy_get_next_buffer()
2198 {
2199 register char *dest = yy_current_buffer->yy_ch_buf;
2200 register char *source = yytext_ptr;
2201 register int number_to_move, i;
2202 int ret_val;
2203
2204 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2205 YY_FATAL_ERROR(
2206 "fatal flex scanner internal error--end of buffer missed" );
2207
2208 if ( yy_current_buffer->yy_fill_buffer == 0 )
2209 { /* Don't try to fill the buffer, so this is an EOF. */
2210 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2211 {
2212 /* We matched a single character, the EOB, so
2213 * treat this as a final EOF.
2214 */
2215 return EOB_ACT_END_OF_FILE;
2216 }
2217
2218 else
2219 {
2220 /* We matched some text prior to the EOB, first
2221 * process it.
2222 */
2223 return EOB_ACT_LAST_MATCH;
2224 }
2225 }
2226
2227 /* Try to read more data. */
2228
2229 /* First move last chars to start of buffer. */
2230 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2231
2232 for ( i = 0; i < number_to_move; ++i )
2233 *(dest++) = *(source++);
2234
2235 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2236 /* don't do the read, it's not guaranteed to return an EOF,
2237 * just force an EOF
2238 */
2239 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2240
2241 else
2242 {
2243 int num_to_read =
2244 yy_current_buffer->yy_buf_size - number_to_move - 1;
2245
2246 while ( num_to_read <= 0 )
2247 { /* Not enough room in the buffer - grow it. */
2248 #ifdef YY_USES_REJECT
2249 YY_FATAL_ERROR(
2250 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2251 #else
2252
2253 /* just a shorter name for the current buffer */
2254 YY_BUFFER_STATE b = yy_current_buffer;
2255
2256 int yy_c_buf_p_offset =
2257 (int) (yy_c_buf_p - b->yy_ch_buf);
2258
2259 if ( b->yy_is_our_buffer )
2260 {
2261 int new_size = b->yy_buf_size * 2;
2262
2263 if ( new_size <= 0 )
2264 b->yy_buf_size += b->yy_buf_size / 8;
2265 else
2266 b->yy_buf_size *= 2;
2267
2268 b->yy_ch_buf = (char *)
2269 /* Include room in for 2 EOB chars. */
2270 yy_flex_realloc( (void *) b->yy_ch_buf,
2271 b->yy_buf_size + 2 );
2272 }
2273 else
2274 /* Can't grow it, we don't own it. */
2275 b->yy_ch_buf = 0;
2276
2277 if ( ! b->yy_ch_buf )
2278 YY_FATAL_ERROR(
2279 "fatal error - scanner input buffer overflow" );
2280
2281 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2282
2283 num_to_read = yy_current_buffer->yy_buf_size -
2284 number_to_move - 1;
2285 #endif
2286 }
2287
2288 if ( num_to_read > YY_READ_BUF_SIZE )
2289 num_to_read = YY_READ_BUF_SIZE;
2290
2291 /* Read in more data. */
2292 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2293 yy_n_chars, num_to_read );
2294
2295 yy_current_buffer->yy_n_chars = yy_n_chars;
2296 }
2297
2298 if ( yy_n_chars == 0 )
2299 {
2300 if ( number_to_move == YY_MORE_ADJ )
2301 {
2302 ret_val = EOB_ACT_END_OF_FILE;
2303 yyrestart( yyin );
2304 }
2305
2306 else
2307 {
2308 ret_val = EOB_ACT_LAST_MATCH;
2309 yy_current_buffer->yy_buffer_status =
2310 YY_BUFFER_EOF_PENDING;
2311 }
2312 }
2313
2314 else
2315 ret_val = EOB_ACT_CONTINUE_SCAN;
2316
2317 yy_n_chars += number_to_move;
2318 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2319 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2320
2321 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2322
2323 return ret_val;
2324 }
2325
2326
2327 /* yy_get_previous_state - get the state just before the EOB char was reached */
2328
yy_get_previous_state()2329 static yy_state_type yy_get_previous_state()
2330 {
2331 register yy_state_type yy_current_state;
2332 register char *yy_cp;
2333
2334 yy_current_state = yy_start;
2335
2336 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2337 {
2338 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2339 if ( yy_accept[yy_current_state] )
2340 {
2341 yy_last_accepting_state = yy_current_state;
2342 yy_last_accepting_cpos = yy_cp;
2343 }
2344 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2345 {
2346 yy_current_state = (int) yy_def[yy_current_state];
2347 if ( yy_current_state >= 575 )
2348 yy_c = yy_meta[(unsigned int) yy_c];
2349 }
2350 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2351 }
2352
2353 return yy_current_state;
2354 }
2355
2356
2357 /* yy_try_NUL_trans - try to make a transition on the NUL character
2358 *
2359 * synopsis
2360 * next_state = yy_try_NUL_trans( current_state );
2361 */
2362
2363 #ifdef YY_USE_PROTOS
yy_try_NUL_trans(yy_state_type yy_current_state)2364 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2365 #else
2366 static yy_state_type yy_try_NUL_trans( yy_current_state )
2367 yy_state_type yy_current_state;
2368 #endif
2369 {
2370 register int yy_is_jam;
2371 register char *yy_cp = yy_c_buf_p;
2372
2373 register YY_CHAR yy_c = 1;
2374 if ( yy_accept[yy_current_state] )
2375 {
2376 yy_last_accepting_state = yy_current_state;
2377 yy_last_accepting_cpos = yy_cp;
2378 }
2379 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2380 {
2381 yy_current_state = (int) yy_def[yy_current_state];
2382 if ( yy_current_state >= 575 )
2383 yy_c = yy_meta[(unsigned int) yy_c];
2384 }
2385 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2386 yy_is_jam = (yy_current_state == 574);
2387
2388 return yy_is_jam ? 0 : yy_current_state;
2389 }
2390
2391
2392 #ifndef YY_NO_UNPUT
2393 #ifdef YY_USE_PROTOS
yyunput(int c,register char * yy_bp)2394 static void yyunput( int c, register char *yy_bp )
2395 #else
2396 static void yyunput( c, yy_bp )
2397 int c;
2398 register char *yy_bp;
2399 #endif
2400 {
2401 register char *yy_cp = yy_c_buf_p;
2402
2403 /* undo effects of setting up yytext */
2404 *yy_cp = yy_hold_char;
2405
2406 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2407 { /* need to shift things up to make room */
2408 /* +2 for EOB chars. */
2409 register int number_to_move = yy_n_chars + 2;
2410 register char *dest = &yy_current_buffer->yy_ch_buf[
2411 yy_current_buffer->yy_buf_size + 2];
2412 register char *source =
2413 &yy_current_buffer->yy_ch_buf[number_to_move];
2414
2415 while ( source > yy_current_buffer->yy_ch_buf )
2416 *--dest = *--source;
2417
2418 yy_cp += (int) (dest - source);
2419 yy_bp += (int) (dest - source);
2420 yy_current_buffer->yy_n_chars =
2421 yy_n_chars = yy_current_buffer->yy_buf_size;
2422
2423 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2424 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2425 }
2426
2427 *--yy_cp = (char) c;
2428
2429
2430 yytext_ptr = yy_bp;
2431 yy_hold_char = *yy_cp;
2432 yy_c_buf_p = yy_cp;
2433 }
2434 #endif /* ifndef YY_NO_UNPUT */
2435
2436
2437 #ifndef YY_NO_INPUT
2438 #ifdef __cplusplus
yyinput()2439 static int yyinput()
2440 #else
2441 static int input()
2442 #endif
2443 {
2444 int c;
2445
2446 *yy_c_buf_p = yy_hold_char;
2447
2448 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2449 {
2450 /* yy_c_buf_p now points to the character we want to return.
2451 * If this occurs *before* the EOB characters, then it's a
2452 * valid NUL; if not, then we've hit the end of the buffer.
2453 */
2454 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2455 /* This was really a NUL. */
2456 *yy_c_buf_p = '\0';
2457
2458 else
2459 { /* need more input */
2460 int offset = yy_c_buf_p - yytext_ptr;
2461 ++yy_c_buf_p;
2462
2463 switch ( yy_get_next_buffer() )
2464 {
2465 case EOB_ACT_LAST_MATCH:
2466 /* This happens because yy_g_n_b()
2467 * sees that we've accumulated a
2468 * token and flags that we need to
2469 * try matching the token before
2470 * proceeding. But for input(),
2471 * there's no matching to consider.
2472 * So convert the EOB_ACT_LAST_MATCH
2473 * to EOB_ACT_END_OF_FILE.
2474 */
2475
2476 /* Reset buffer status. */
2477 yyrestart( yyin );
2478
2479 /* fall through */
2480
2481 case EOB_ACT_END_OF_FILE:
2482 {
2483 if ( yywrap() )
2484 return EOF;
2485
2486 if ( ! yy_did_buffer_switch_on_eof )
2487 YY_NEW_FILE;
2488 #ifdef __cplusplus
2489 return yyinput();
2490 #else
2491 return input();
2492 #endif
2493 }
2494
2495 case EOB_ACT_CONTINUE_SCAN:
2496 yy_c_buf_p = yytext_ptr + offset;
2497 break;
2498 }
2499 }
2500 }
2501
2502 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
2503 *yy_c_buf_p = '\0'; /* preserve yytext */
2504 yy_hold_char = *++yy_c_buf_p;
2505
2506
2507 return c;
2508 }
2509 #endif /* YY_NO_INPUT */
2510
2511 #ifdef YY_USE_PROTOS
yyrestart(FILE * input_file)2512 void yyrestart( FILE *input_file )
2513 #else
2514 void yyrestart( input_file )
2515 FILE *input_file;
2516 #endif
2517 {
2518 if ( ! yy_current_buffer )
2519 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2520
2521 yy_init_buffer( yy_current_buffer, input_file );
2522 yy_load_buffer_state();
2523 }
2524
2525
2526 #ifdef YY_USE_PROTOS
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)2527 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2528 #else
2529 void yy_switch_to_buffer( new_buffer )
2530 YY_BUFFER_STATE new_buffer;
2531 #endif
2532 {
2533 if ( yy_current_buffer == new_buffer )
2534 return;
2535
2536 if ( yy_current_buffer )
2537 {
2538 /* Flush out information for old buffer. */
2539 *yy_c_buf_p = yy_hold_char;
2540 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2541 yy_current_buffer->yy_n_chars = yy_n_chars;
2542 }
2543
2544 yy_current_buffer = new_buffer;
2545 yy_load_buffer_state();
2546
2547 /* We don't actually know whether we did this switch during
2548 * EOF (yywrap()) processing, but the only time this flag
2549 * is looked at is after yywrap() is called, so it's safe
2550 * to go ahead and always set it.
2551 */
2552 yy_did_buffer_switch_on_eof = 1;
2553 }
2554
2555
2556 #ifdef YY_USE_PROTOS
yy_load_buffer_state(void)2557 void yy_load_buffer_state( void )
2558 #else
2559 void yy_load_buffer_state()
2560 #endif
2561 {
2562 yy_n_chars = yy_current_buffer->yy_n_chars;
2563 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2564 yyin = yy_current_buffer->yy_input_file;
2565 yy_hold_char = *yy_c_buf_p;
2566 }
2567
2568
2569 #ifdef YY_USE_PROTOS
yy_create_buffer(FILE * file,int size)2570 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2571 #else
2572 YY_BUFFER_STATE yy_create_buffer( file, size )
2573 FILE *file;
2574 int size;
2575 #endif
2576 {
2577 YY_BUFFER_STATE b;
2578
2579 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2580 if ( ! b )
2581 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2582
2583 b->yy_buf_size = size;
2584
2585 /* yy_ch_buf has to be 2 characters longer than the size given because
2586 * we need to put in 2 end-of-buffer characters.
2587 */
2588 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2589 if ( ! b->yy_ch_buf )
2590 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2591
2592 b->yy_is_our_buffer = 1;
2593
2594 yy_init_buffer( b, file );
2595
2596 return b;
2597 }
2598
2599
2600 #ifdef YY_USE_PROTOS
yy_delete_buffer(YY_BUFFER_STATE b)2601 void yy_delete_buffer( YY_BUFFER_STATE b )
2602 #else
2603 void yy_delete_buffer( b )
2604 YY_BUFFER_STATE b;
2605 #endif
2606 {
2607 if ( ! b )
2608 return;
2609
2610 if ( b == yy_current_buffer )
2611 yy_current_buffer = (YY_BUFFER_STATE) 0;
2612
2613 if ( b->yy_is_our_buffer )
2614 yy_flex_free( (void *) b->yy_ch_buf );
2615
2616 yy_flex_free( (void *) b );
2617 }
2618
2619
2620
2621 #ifdef YY_USE_PROTOS
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)2622 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2623 #else
2624 void yy_init_buffer( b, file )
2625 YY_BUFFER_STATE b;
2626 FILE *file;
2627 #endif
2628
2629
2630 {
2631 yy_flush_buffer( b );
2632
2633 b->yy_input_file = file;
2634 b->yy_fill_buffer = 1;
2635
2636 #if YY_ALWAYS_INTERACTIVE
2637 b->yy_is_interactive = 1;
2638 #else
2639 #if YY_NEVER_INTERACTIVE
2640 b->yy_is_interactive = 0;
2641 #else
2642 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2643 #endif
2644 #endif
2645 }
2646
2647
2648 #ifdef YY_USE_PROTOS
yy_flush_buffer(YY_BUFFER_STATE b)2649 void yy_flush_buffer( YY_BUFFER_STATE b )
2650 #else
2651 void yy_flush_buffer( b )
2652 YY_BUFFER_STATE b;
2653 #endif
2654
2655 {
2656 if ( ! b )
2657 return;
2658
2659 b->yy_n_chars = 0;
2660
2661 /* We always need two end-of-buffer characters. The first causes
2662 * a transition to the end-of-buffer state. The second causes
2663 * a jam in that state.
2664 */
2665 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2666 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2667
2668 b->yy_buf_pos = &b->yy_ch_buf[0];
2669
2670 b->yy_at_bol = 1;
2671 b->yy_buffer_status = YY_BUFFER_NEW;
2672
2673 if ( b == yy_current_buffer )
2674 yy_load_buffer_state();
2675 }
2676
2677
2678 #ifndef YY_NO_SCAN_BUFFER
2679 #ifdef YY_USE_PROTOS
yy_scan_buffer(char * base,yy_size_t size)2680 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2681 #else
2682 YY_BUFFER_STATE yy_scan_buffer( base, size )
2683 char *base;
2684 yy_size_t size;
2685 #endif
2686 {
2687 YY_BUFFER_STATE b;
2688
2689 if ( size < 2 ||
2690 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2691 base[size-1] != YY_END_OF_BUFFER_CHAR )
2692 /* They forgot to leave room for the EOB's. */
2693 return 0;
2694
2695 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2696 if ( ! b )
2697 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2698
2699 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2700 b->yy_buf_pos = b->yy_ch_buf = base;
2701 b->yy_is_our_buffer = 0;
2702 b->yy_input_file = 0;
2703 b->yy_n_chars = b->yy_buf_size;
2704 b->yy_is_interactive = 0;
2705 b->yy_at_bol = 1;
2706 b->yy_fill_buffer = 0;
2707 b->yy_buffer_status = YY_BUFFER_NEW;
2708
2709 yy_switch_to_buffer( b );
2710
2711 return b;
2712 }
2713 #endif
2714
2715
2716 #ifndef YY_NO_SCAN_STRING
2717 #ifdef YY_USE_PROTOS
yy_scan_string(yyconst char * yy_str)2718 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2719 #else
2720 YY_BUFFER_STATE yy_scan_string( yy_str )
2721 yyconst char *yy_str;
2722 #endif
2723 {
2724 int len;
2725 for ( len = 0; yy_str[len]; ++len )
2726 ;
2727
2728 return yy_scan_bytes( yy_str, len );
2729 }
2730 #endif
2731
2732
2733 #ifndef YY_NO_SCAN_BYTES
2734 #ifdef YY_USE_PROTOS
yy_scan_bytes(yyconst char * bytes,int len)2735 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2736 #else
2737 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2738 yyconst char *bytes;
2739 int len;
2740 #endif
2741 {
2742 YY_BUFFER_STATE b;
2743 char *buf;
2744 yy_size_t n;
2745 int i;
2746
2747 /* Get memory for full buffer, including space for trailing EOB's. */
2748 n = len + 2;
2749 buf = (char *) yy_flex_alloc( n );
2750 if ( ! buf )
2751 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2752
2753 for ( i = 0; i < len; ++i )
2754 buf[i] = bytes[i];
2755
2756 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2757
2758 b = yy_scan_buffer( buf, n );
2759 if ( ! b )
2760 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2761
2762 /* It's okay to grow etc. this buffer, and we should throw it
2763 * away when we're done.
2764 */
2765 b->yy_is_our_buffer = 1;
2766
2767 return b;
2768 }
2769 #endif
2770
2771
2772 #ifndef YY_NO_PUSH_STATE
2773 #ifdef YY_USE_PROTOS
yy_push_state(int new_state)2774 static void yy_push_state( int new_state )
2775 #else
2776 static void yy_push_state( new_state )
2777 int new_state;
2778 #endif
2779 {
2780 if ( yy_start_stack_ptr >= yy_start_stack_depth )
2781 {
2782 yy_size_t new_size;
2783
2784 yy_start_stack_depth += YY_START_STACK_INCR;
2785 new_size = yy_start_stack_depth * sizeof( int );
2786
2787 if ( ! yy_start_stack )
2788 yy_start_stack = (int *) yy_flex_alloc( new_size );
2789
2790 else
2791 yy_start_stack = (int *) yy_flex_realloc(
2792 (void *) yy_start_stack, new_size );
2793
2794 if ( ! yy_start_stack )
2795 YY_FATAL_ERROR(
2796 "out of memory expanding start-condition stack" );
2797 }
2798
2799 yy_start_stack[yy_start_stack_ptr++] = YY_START;
2800
2801 BEGIN(new_state);
2802 }
2803 #endif
2804
2805
2806 #ifndef YY_NO_POP_STATE
yy_pop_state()2807 static void yy_pop_state()
2808 {
2809 if ( --yy_start_stack_ptr < 0 )
2810 YY_FATAL_ERROR( "start-condition stack underflow" );
2811
2812 BEGIN(yy_start_stack[yy_start_stack_ptr]);
2813 }
2814 #endif
2815
2816
2817 #ifndef YY_NO_TOP_STATE
yy_top_state()2818 static int yy_top_state()
2819 {
2820 return yy_start_stack[yy_start_stack_ptr - 1];
2821 }
2822 #endif
2823
2824 #ifndef YY_EXIT_FAILURE
2825 #define YY_EXIT_FAILURE 2
2826 #endif
2827
2828 #ifdef YY_USE_PROTOS
yy_fatal_error(yyconst char msg[])2829 static void yy_fatal_error( yyconst char msg[] )
2830 #else
2831 static void yy_fatal_error( msg )
2832 char msg[];
2833 #endif
2834 {
2835 (void) fprintf( stderr, "%s\n", msg );
2836 exit( YY_EXIT_FAILURE );
2837 }
2838
2839
2840
2841 /* Redefine yyless() so it works in section 3 code. */
2842
2843 #undef yyless
2844 #define yyless(n) \
2845 do \
2846 { \
2847 /* Undo effects of setting up yytext. */ \
2848 yytext[yyleng] = yy_hold_char; \
2849 yy_c_buf_p = yytext + n; \
2850 yy_hold_char = *yy_c_buf_p; \
2851 *yy_c_buf_p = '\0'; \
2852 yyleng = n; \
2853 } \
2854 while ( 0 )
2855
2856
2857 /* Internal utility routines. */
2858
2859 #ifndef yytext_ptr
2860 #ifdef YY_USE_PROTOS
yy_flex_strncpy(char * s1,yyconst char * s2,int n)2861 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2862 #else
2863 static void yy_flex_strncpy( s1, s2, n )
2864 char *s1;
2865 yyconst char *s2;
2866 int n;
2867 #endif
2868 {
2869 register int i;
2870 for ( i = 0; i < n; ++i )
2871 s1[i] = s2[i];
2872 }
2873 #endif
2874
2875 #ifdef YY_NEED_STRLEN
2876 #ifdef YY_USE_PROTOS
yy_flex_strlen(yyconst char * s)2877 static int yy_flex_strlen( yyconst char *s )
2878 #else
2879 static int yy_flex_strlen( s )
2880 yyconst char *s;
2881 #endif
2882 {
2883 register int n;
2884 for ( n = 0; s[n]; ++n )
2885 ;
2886
2887 return n;
2888 }
2889 #endif
2890
2891
2892 #ifdef YY_USE_PROTOS
yy_flex_alloc(yy_size_t size)2893 static void *yy_flex_alloc( yy_size_t size )
2894 #else
2895 static void *yy_flex_alloc( size )
2896 yy_size_t size;
2897 #endif
2898 {
2899 return (void *) malloc( size );
2900 }
2901
2902 #ifdef YY_USE_PROTOS
yy_flex_realloc(void * ptr,yy_size_t size)2903 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2904 #else
2905 static void *yy_flex_realloc( ptr, size )
2906 void *ptr;
2907 yy_size_t size;
2908 #endif
2909 {
2910 /* The cast to (char *) in the following accommodates both
2911 * implementations that use char* generic pointers, and those
2912 * that use void* generic pointers. It works with the latter
2913 * because both ANSI C and C++ allow castless assignment from
2914 * any pointer type to void*, and deal with argument conversions
2915 * as though doing an assignment.
2916 */
2917 return (void *) realloc( (char *) ptr, size );
2918 }
2919
2920 #ifdef YY_USE_PROTOS
yy_flex_free(void * ptr)2921 static void yy_flex_free( void *ptr )
2922 #else
2923 static void yy_flex_free( ptr )
2924 void *ptr;
2925 #endif
2926 {
2927 free( ptr );
2928 }
2929
2930 #if YY_MAIN
main()2931 int main()
2932 {
2933 yylex();
2934 return 0;
2935 }
2936 #endif
2937
2938
2939 /*
2940 ** These need to go here, after flex-generated code defined input and unput.
2941 */
2942
cscanner_input(void)2943 int cscanner_input (void)
2944 {
2945 return input (); /* input is a static procedure defined by flex-generated code */
2946 }
2947
cscanner_unput(int c)2948 void cscanner_unput (int c)
2949 {
2950 unput (c); /* unput is a static procedure defined by flex-generated code */
2951 }
2952
2953
2954
2955 /*
2956 ** Resets flags set by flex.head.
2957 */
2958
2959
2960 /*@=allmacros@*/
2961 /*@=pred@*/
2962 /*@=globstate@*/
2963 /*@=null@*/
2964 /*@=boolint@*/
2965 /*@=charint@*/
2966 /*@=macrospec@*/
2967 /*@=macroredef@*/
2968 /*@=exitarg@*/
2969 /*@=compdef@*/
2970 /*@=uniondef@*/
2971 /*@=ignorequals@*/
2972 /*@=noreturn@*/
2973 /*@=mustfree@*/
2974 /*@=compdestroy@*/
2975 /*@=branchstate@*/
2976 /*@=unreachable@*/
2977 /*@=varuse@*/
2978 /*@=fcnuse@*/
2979 /*@=exportlocal@*/
2980 /*@=evalorderuncon@*/
2981 /*@=exportheader@*/
2982 /*@=redecl@*/
2983 /*@=loopswitchbreak@*/
2984 /*@=switchswitchbreak@*/
2985 /*@=sizeoftype@*/
2986 /*@=czechfcns@*/
2987 /*@=noparams@*/
2988 /*@=ansireserved@*/
2989 /*@=ifblock@*/
2990 /*@=whileblock@*/
2991 /*@=forblock@*/
2992 /*@=elseifcomplete@*/
2993 /*@=ptrnegate@*/
2994 /*@=onlytrans@*/
2995 /*@=temptrans@*/
2996 /*@=immediatetrans@*/
2997 /*@=namechecks@*/
2998 /*@=matchanyintegral@*/
2999 /*@=statictrans@*/
3000 /*@=compmempass@*/
3001 /*@=forempty@*/
3002 /*@=evalorder@*/
3003 /*@=retalias@*/
3004 /*@=redecl@*/
3005 /*@=retvalother@*/
3006
3007 # ifdef OSF
3008 # define __GNUC__
3009 # endif
3010
3011