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