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