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