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