38946613ef2e0ec6f744f64a542f8059f2ae1fdf
[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,2000, James McKenzie.
410  *                      All rights reserved
411  * Copyright (c) 1998,2000, 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.6  2000/07/17 10:43:34  root
426  *  #
427  *
428  *  Revision 1.5  2000/07/16 14:05:28  root
429  *  #
430  *
431  *  Revision 1.4  2000/07/16 13:18:10  root
432  *  #
433  *
434  *  Revision 1.1  2000/07/16 13:16:33  root
435  *  #
436  *
437  *  Revision 1.3  1999/09/13 11:17:35  root
438  *  \#
439  *
440  *  Revision 1.2  1999/09/13 11:08:34  root
441  *  \#
442  *
443  *  Revision 1.1  1999/09/13 11:04:13  root
444  *  \#
445  *
446  *  Revision 1.10  1999/09/12 19:08:24  chris
447  *  Another attempt at C comments.
448  *
449  *  Revision 1.9  1999/09/12 17:38:45  chris
450  *  Implemented proper MAC reading.
451  *
452  *  Revision 1.8  1999/09/12 03:27:43  chris
453  *  Changes to enable error reporting in yacc grammar.
454  *
455  *  Revision 1.7  1999/09/11 19:30:26  chris
456  *  Fixed hex number support.
457  *
458  *  Revision 1.6  1999/09/11 19:25:06  chris
459  *  No major changes.
460  *
461  *  Revision 1.5  1999/09/11 19:24:23  chris
462  *  Removed support for C-style comments, inserted support for C++ ones. Comment support actually works now
463  *
464  *  Revision 1.4  1999/09/11 19:02:25  chris
465  *  Fixed bug in comment support.
466  *
467  *  Revision 1.3  1999/09/11 19:00:43  chris
468  *  Added support for comments.
469  *
470  *  Revision 1.2  1999/09/11 18:57:31  chris
471  *  Initial revision.
472  *
473  *  
474  */
475 #define COMMENT 1
476
477 #line 76 "rpld_conf.lex"
478 static char rcsid[]="$Id: rpld_conf.lex,v 1.6 2000/07/17 10:43:34 root Exp $";
479
480 #include <stdio.h>
481 #include <string.h>
482 #include <stdlib.h>
483 #include "rpld_conf.tab.h"
484
485
486 // line number
487 int lineno = 1;
488
489 // function to convert hex digits to a MAC address
490 void strtomac(char *s, char *mac);
491
492 void strtomac(char *s, char *mac)
493 {
494         // mac address *must* be in form 00:11:22:33:44:55
495         int i;
496
497         for (i = 0; i < 6; i++) *(mac + i) = (unsigned char)strtol(s + i * 3, NULL, 16);
498 }
499
500
501 #line 502 "rpld_conf.yy.c"
502
503 /* Macros after this point can all be overridden by user definitions in
504  * section 1.
505  */
506
507 #ifndef YY_SKIP_YYWRAP
508 #ifdef __cplusplus
509 extern "C" int yywrap YY_PROTO(( void ));
510 #else
511 extern int yywrap YY_PROTO(( void ));
512 #endif
513 #endif
514
515 #ifndef YY_NO_UNPUT
516 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
517 #endif
518
519 #ifndef yytext_ptr
520 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
521 #endif
522
523 #ifdef YY_NEED_STRLEN
524 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
525 #endif
526
527 #ifndef YY_NO_INPUT
528 #ifdef __cplusplus
529 static int yyinput YY_PROTO(( void ));
530 #else
531 static int input YY_PROTO(( void ));
532 #endif
533 #endif
534
535 #if YY_STACK_USED
536 static int yy_start_stack_ptr = 0;
537 static int yy_start_stack_depth = 0;
538 static int *yy_start_stack = 0;
539 #ifndef YY_NO_PUSH_STATE
540 static void yy_push_state YY_PROTO(( int new_state ));
541 #endif
542 #ifndef YY_NO_POP_STATE
543 static void yy_pop_state YY_PROTO(( void ));
544 #endif
545 #ifndef YY_NO_TOP_STATE
546 static int yy_top_state YY_PROTO(( void ));
547 #endif
548
549 #else
550 #define YY_NO_PUSH_STATE 1
551 #define YY_NO_POP_STATE 1
552 #define YY_NO_TOP_STATE 1
553 #endif
554
555 #ifdef YY_MALLOC_DECL
556 YY_MALLOC_DECL
557 #else
558 #if __STDC__
559 #ifndef __cplusplus
560 #include <stdlib.h>
561 #endif
562 #else
563 /* Just try to get by without declaring the routines.  This will fail
564  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
565  * or sizeof(void*) != sizeof(int).
566  */
567 #endif
568 #endif
569
570 /* Amount of stuff to slurp up with each read. */
571 #ifndef YY_READ_BUF_SIZE
572 #define YY_READ_BUF_SIZE 8192
573 #endif
574
575 /* Copy whatever the last rule matched to the standard output. */
576
577 #ifndef ECHO
578 /* This used to be an fputs(), but since the string might contain NUL's,
579  * we now use fwrite().
580  */
581 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
582 #endif
583
584 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
585  * is returned in "result".
586  */
587 #ifndef YY_INPUT
588 #define YY_INPUT(buf,result,max_size) \
589         if ( yy_current_buffer->yy_is_interactive ) \
590                 { \
591                 int c = '*', n; \
592                 for ( n = 0; n < max_size && \
593                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
594                         buf[n] = (char) c; \
595                 if ( c == '\n' ) \
596                         buf[n++] = (char) c; \
597                 if ( c == EOF && ferror( yyin ) ) \
598                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
599                 result = n; \
600                 } \
601         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
602                   && ferror( yyin ) ) \
603                 YY_FATAL_ERROR( "input in flex scanner failed" );
604 #endif
605
606 /* No semi-colon after return; correct usage is to write "yyterminate();" -
607  * we don't want an extra ';' after the "return" because that will cause
608  * some compilers to complain about unreachable statements.
609  */
610 #ifndef yyterminate
611 #define yyterminate() return YY_NULL
612 #endif
613
614 /* Number of entries by which start-condition stack grows. */
615 #ifndef YY_START_STACK_INCR
616 #define YY_START_STACK_INCR 25
617 #endif
618
619 /* Report a fatal error. */
620 #ifndef YY_FATAL_ERROR
621 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
622 #endif
623
624 /* Default declaration of generated scanner - a define so the user can
625  * easily add parameters.
626  */
627 #ifndef YY_DECL
628 #define YY_DECL int yylex YY_PROTO(( void ))
629 #endif
630
631 /* Code executed at the beginning of each rule, after yytext and yyleng
632  * have been set up.
633  */
634 #ifndef YY_USER_ACTION
635 #define YY_USER_ACTION
636 #endif
637
638 /* Code executed at the end of each rule. */
639 #ifndef YY_BREAK
640 #define YY_BREAK break;
641 #endif
642
643 #define YY_RULE_SETUP \
644         YY_USER_ACTION
645
646 YY_DECL
647         {
648         register yy_state_type yy_current_state;
649         register char *yy_cp = NULL, *yy_bp = NULL;
650         register int yy_act;
651
652 #line 104 "rpld_conf.lex"
653
654
655 #line 656 "rpld_conf.yy.c"
656
657         if ( yy_init )
658                 {
659                 yy_init = 0;
660
661 #ifdef YY_USER_INIT
662                 YY_USER_INIT;
663 #endif
664
665                 if ( ! yy_start )
666                         yy_start = 1;   /* first start state */
667
668                 if ( ! yyin )
669                         yyin = stdin;
670
671                 if ( ! yyout )
672                         yyout = stdout;
673
674                 if ( ! yy_current_buffer )
675                         yy_current_buffer =
676                                 yy_create_buffer( yyin, YY_BUF_SIZE );
677
678                 yy_load_buffer_state();
679                 }
680
681         while ( 1 )             /* loops until end-of-file is reached */
682                 {
683                 yy_cp = yy_c_buf_p;
684
685                 /* Support of yytext. */
686                 *yy_cp = yy_hold_char;
687
688                 /* yy_bp points to the position in yy_ch_buf of the start of
689                  * the current run.
690                  */
691                 yy_bp = yy_cp;
692
693                 yy_current_state = yy_start;
694 yy_match:
695                 do
696                         {
697                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
698                         if ( yy_accept[yy_current_state] )
699                                 {
700                                 yy_last_accepting_state = yy_current_state;
701                                 yy_last_accepting_cpos = yy_cp;
702                                 }
703                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
704                                 {
705                                 yy_current_state = (int) yy_def[yy_current_state];
706                                 if ( yy_current_state >= 51 )
707                                         yy_c = yy_meta[(unsigned int) yy_c];
708                                 }
709                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
710                         ++yy_cp;
711                         }
712                 while ( yy_base[yy_current_state] != 110 );
713
714 yy_find_action:
715                 yy_act = yy_accept[yy_current_state];
716                 if ( yy_act == 0 )
717                         { /* have to back up */
718                         yy_cp = yy_last_accepting_cpos;
719                         yy_current_state = yy_last_accepting_state;
720                         yy_act = yy_accept[yy_current_state];
721                         }
722
723                 YY_DO_BEFORE_ACTION;
724
725
726 do_action:      /* This label is used only to access EOF actions. */
727
728
729                 switch ( yy_act )
730         { /* beginning of action switch */
731                         case 0: /* must back up */
732                         /* undo the effects of YY_DO_BEFORE_ACTION */
733                         *yy_cp = yy_hold_char;
734                         yy_cp = yy_last_accepting_cpos;
735                         yy_current_state = yy_last_accepting_state;
736                         goto yy_find_action;
737
738 case 1:
739 YY_RULE_SETUP
740 #line 106 "rpld_conf.lex"
741 ;
742         YY_BREAK
743 case 2:
744 YY_RULE_SETUP
745 #line 107 "rpld_conf.lex"
746 { lineno++; }
747         YY_BREAK
748 case 3:
749 YY_RULE_SETUP
750 #line 109 "rpld_conf.lex"
751 ;
752         YY_BREAK
753 case 4:
754 YY_RULE_SETUP
755 #line 111 "rpld_conf.lex"
756 BEGIN COMMENT;
757         YY_BREAK
758 case 5:
759 #line 113 "rpld_conf.lex"
760 case 6:
761 YY_RULE_SETUP
762 #line 113 "rpld_conf.lex"
763 ;
764         YY_BREAK
765 case 7:
766 YY_RULE_SETUP
767 #line 114 "rpld_conf.lex"
768 BEGIN INITIAL;
769         YY_BREAK
770 case 8:
771 YY_RULE_SETUP
772 #line 116 "rpld_conf.lex"
773 { return BLOCK_START; }
774         YY_BREAK
775 case 9:
776 YY_RULE_SETUP
777 #line 118 "rpld_conf.lex"
778 { return BLOCK_END; }
779         YY_BREAK
780 case 10:
781 YY_RULE_SETUP
782 #line 120 "rpld_conf.lex"
783 {
784                                 strtomac(yytext, (yylval.mac_address));
785                                 return MACADDR;
786                         }
787         YY_BREAK
788 case 11:
789 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
790 yy_c_buf_p = yy_cp = yy_bp + 17;
791 YY_DO_BEFORE_ACTION; /* set up yytext again */
792 YY_RULE_SETUP
793 #line 125 "rpld_conf.lex"
794 {
795                                 strtomac(yytext, (yylval.pm.mac_address));
796                                 yylval.pm.mac_len = yytext[13] - '0';
797                                 return MACADDR_PARTIAL;
798                         }
799         YY_BREAK
800 case 12:
801 YY_RULE_SETUP
802 #line 131 "rpld_conf.lex"
803 {
804                                 yylval.number = strtol(yytext + 2, NULL, 16);
805                                 return NUMBER;
806                         }
807         YY_BREAK
808 case 13:
809 YY_RULE_SETUP
810 #line 136 "rpld_conf.lex"
811 {
812                                 int i; i = strtol(yytext, NULL, 10);
813                                 yylval.number = i; return NUMBER;
814                         }
815         YY_BREAK
816 case 14:
817 YY_RULE_SETUP
818 #line 141 "rpld_conf.lex"
819 { yylval.name = strdup(yytext); return NAME; }
820         YY_BREAK
821 case 15:
822 YY_RULE_SETUP
823 #line 143 "rpld_conf.lex"
824 { yylval.text = strdup(yytext + 1); *(yylval.text + strlen(yylval.text) - 1) = 0; return TEXT;}
825         YY_BREAK
826 case 16:
827 YY_RULE_SETUP
828 #line 145 "rpld_conf.lex"
829 { return yytext[0]; }
830         YY_BREAK
831 case 17:
832 YY_RULE_SETUP
833 #line 147 "rpld_conf.lex"
834 ECHO;
835         YY_BREAK
836 #line 837 "rpld_conf.yy.c"
837 case YY_STATE_EOF(INITIAL):
838 case YY_STATE_EOF(COMMENT):
839         yyterminate();
840
841         case YY_END_OF_BUFFER:
842                 {
843                 /* Amount of text matched not including the EOB char. */
844                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
845
846                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
847                 *yy_cp = yy_hold_char;
848                 YY_RESTORE_YY_MORE_OFFSET
849
850                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
851                         {
852                         /* We're scanning a new file or input source.  It's
853                          * possible that this happened because the user
854                          * just pointed yyin at a new source and called
855                          * yylex().  If so, then we have to assure
856                          * consistency between yy_current_buffer and our
857                          * globals.  Here is the right place to do so, because
858                          * this is the first action (other than possibly a
859                          * back-up) that will match for the new input source.
860                          */
861                         yy_n_chars = yy_current_buffer->yy_n_chars;
862                         yy_current_buffer->yy_input_file = yyin;
863                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
864                         }
865
866                 /* Note that here we test for yy_c_buf_p "<=" to the position
867                  * of the first EOB in the buffer, since yy_c_buf_p will
868                  * already have been incremented past the NUL character
869                  * (since all states make transitions on EOB to the
870                  * end-of-buffer state).  Contrast this with the test
871                  * in input().
872                  */
873                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
874                         { /* This was really a NUL. */
875                         yy_state_type yy_next_state;
876
877                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
878
879                         yy_current_state = yy_get_previous_state();
880
881                         /* Okay, we're now positioned to make the NUL
882                          * transition.  We couldn't have
883                          * yy_get_previous_state() go ahead and do it
884                          * for us because it doesn't know how to deal
885                          * with the possibility of jamming (and we don't
886                          * want to build jamming into it because then it
887                          * will run more slowly).
888                          */
889
890                         yy_next_state = yy_try_NUL_trans( yy_current_state );
891
892                         yy_bp = yytext_ptr + YY_MORE_ADJ;
893
894                         if ( yy_next_state )
895                                 {
896                                 /* Consume the NUL. */
897                                 yy_cp = ++yy_c_buf_p;
898                                 yy_current_state = yy_next_state;
899                                 goto yy_match;
900                                 }
901
902                         else
903                                 {
904                                 yy_cp = yy_c_buf_p;
905                                 goto yy_find_action;
906                                 }
907                         }
908
909                 else switch ( yy_get_next_buffer() )
910                         {
911                         case EOB_ACT_END_OF_FILE:
912                                 {
913                                 yy_did_buffer_switch_on_eof = 0;
914
915                                 if ( yywrap() )
916                                         {
917                                         /* Note: because we've taken care in
918                                          * yy_get_next_buffer() to have set up
919                                          * yytext, we can now set up
920                                          * yy_c_buf_p so that if some total
921                                          * hoser (like flex itself) wants to
922                                          * call the scanner after we return the
923                                          * YY_NULL, it'll still work - another
924                                          * YY_NULL will get returned.
925                                          */
926                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
927
928                                         yy_act = YY_STATE_EOF(YY_START);
929                                         goto do_action;
930                                         }
931
932                                 else
933                                         {
934                                         if ( ! yy_did_buffer_switch_on_eof )
935                                                 YY_NEW_FILE;
936                                         }
937                                 break;
938                                 }
939
940                         case EOB_ACT_CONTINUE_SCAN:
941                                 yy_c_buf_p =
942                                         yytext_ptr + yy_amount_of_matched_text;
943
944                                 yy_current_state = yy_get_previous_state();
945
946                                 yy_cp = yy_c_buf_p;
947                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
948                                 goto yy_match;
949
950                         case EOB_ACT_LAST_MATCH:
951                                 yy_c_buf_p =
952                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
953
954                                 yy_current_state = yy_get_previous_state();
955
956                                 yy_cp = yy_c_buf_p;
957                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
958                                 goto yy_find_action;
959                         }
960                 break;
961                 }
962
963         default:
964                 YY_FATAL_ERROR(
965                         "fatal flex scanner internal error--no action found" );
966         } /* end of action switch */
967                 } /* end of scanning one token */
968         } /* end of yylex */
969
970
971 /* yy_get_next_buffer - try to read in a new buffer
972  *
973  * Returns a code representing an action:
974  *      EOB_ACT_LAST_MATCH -
975  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
976  *      EOB_ACT_END_OF_FILE - end of file
977  */
978
979 static int yy_get_next_buffer()
980         {
981         register char *dest = yy_current_buffer->yy_ch_buf;
982         register char *source = yytext_ptr;
983         register int number_to_move, i;
984         int ret_val;
985
986         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
987                 YY_FATAL_ERROR(
988                 "fatal flex scanner internal error--end of buffer missed" );
989
990         if ( yy_current_buffer->yy_fill_buffer == 0 )
991                 { /* Don't try to fill the buffer, so this is an EOF. */
992                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
993                         {
994                         /* We matched a single character, the EOB, so
995                          * treat this as a final EOF.
996                          */
997                         return EOB_ACT_END_OF_FILE;
998                         }
999
1000                 else
1001                         {
1002                         /* We matched some text prior to the EOB, first
1003                          * process it.
1004                          */
1005                         return EOB_ACT_LAST_MATCH;
1006                         }
1007                 }
1008
1009         /* Try to read more data. */
1010
1011         /* First move last chars to start of buffer. */
1012         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1013
1014         for ( i = 0; i < number_to_move; ++i )
1015                 *(dest++) = *(source++);
1016
1017         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1018                 /* don't do the read, it's not guaranteed to return an EOF,
1019                  * just force an EOF
1020                  */
1021                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1022
1023         else
1024                 {
1025                 int num_to_read =
1026                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1027
1028                 while ( num_to_read <= 0 )
1029                         { /* Not enough room in the buffer - grow it. */
1030 #ifdef YY_USES_REJECT
1031                         YY_FATAL_ERROR(
1032 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1033 #else
1034
1035                         /* just a shorter name for the current buffer */
1036                         YY_BUFFER_STATE b = yy_current_buffer;
1037
1038                         int yy_c_buf_p_offset =
1039                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1040
1041                         if ( b->yy_is_our_buffer )
1042                                 {
1043                                 int new_size = b->yy_buf_size * 2;
1044
1045                                 if ( new_size <= 0 )
1046                                         b->yy_buf_size += b->yy_buf_size / 8;
1047                                 else
1048                                         b->yy_buf_size *= 2;
1049
1050                                 b->yy_ch_buf = (char *)
1051                                         /* Include room in for 2 EOB chars. */
1052                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1053                                                          b->yy_buf_size + 2 );
1054                                 }
1055                         else
1056                                 /* Can't grow it, we don't own it. */
1057                                 b->yy_ch_buf = 0;
1058
1059                         if ( ! b->yy_ch_buf )
1060                                 YY_FATAL_ERROR(
1061                                 "fatal error - scanner input buffer overflow" );
1062
1063                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1064
1065                         num_to_read = yy_current_buffer->yy_buf_size -
1066                                                 number_to_move - 1;
1067 #endif
1068                         }
1069
1070                 if ( num_to_read > YY_READ_BUF_SIZE )
1071                         num_to_read = YY_READ_BUF_SIZE;
1072
1073                 /* Read in more data. */
1074                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1075                         yy_n_chars, num_to_read );
1076
1077                 yy_current_buffer->yy_n_chars = yy_n_chars;
1078                 }
1079
1080         if ( yy_n_chars == 0 )
1081                 {
1082                 if ( number_to_move == YY_MORE_ADJ )
1083                         {
1084                         ret_val = EOB_ACT_END_OF_FILE;
1085                         yyrestart( yyin );
1086                         }
1087
1088                 else
1089                         {
1090                         ret_val = EOB_ACT_LAST_MATCH;
1091                         yy_current_buffer->yy_buffer_status =
1092                                 YY_BUFFER_EOF_PENDING;
1093                         }
1094                 }
1095
1096         else
1097                 ret_val = EOB_ACT_CONTINUE_SCAN;
1098
1099         yy_n_chars += number_to_move;
1100         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1101         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1102
1103         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1104
1105         return ret_val;
1106         }
1107
1108
1109 /* yy_get_previous_state - get the state just before the EOB char was reached */
1110
1111 static yy_state_type yy_get_previous_state()
1112         {
1113         register yy_state_type yy_current_state;
1114         register char *yy_cp;
1115
1116         yy_current_state = yy_start;
1117
1118         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1119                 {
1120                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1121                 if ( yy_accept[yy_current_state] )
1122                         {
1123                         yy_last_accepting_state = yy_current_state;
1124                         yy_last_accepting_cpos = yy_cp;
1125                         }
1126                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1127                         {
1128                         yy_current_state = (int) yy_def[yy_current_state];
1129                         if ( yy_current_state >= 51 )
1130                                 yy_c = yy_meta[(unsigned int) yy_c];
1131                         }
1132                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1133                 }
1134
1135         return yy_current_state;
1136         }
1137
1138
1139 /* yy_try_NUL_trans - try to make a transition on the NUL character
1140  *
1141  * synopsis
1142  *      next_state = yy_try_NUL_trans( current_state );
1143  */
1144
1145 #ifdef YY_USE_PROTOS
1146 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1147 #else
1148 static yy_state_type yy_try_NUL_trans( yy_current_state )
1149 yy_state_type yy_current_state;
1150 #endif
1151         {
1152         register int yy_is_jam;
1153         register char *yy_cp = yy_c_buf_p;
1154
1155         register YY_CHAR yy_c = 1;
1156         if ( yy_accept[yy_current_state] )
1157                 {
1158                 yy_last_accepting_state = yy_current_state;
1159                 yy_last_accepting_cpos = yy_cp;
1160                 }
1161         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1162                 {
1163                 yy_current_state = (int) yy_def[yy_current_state];
1164                 if ( yy_current_state >= 51 )
1165                         yy_c = yy_meta[(unsigned int) yy_c];
1166                 }
1167         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1168         yy_is_jam = (yy_current_state == 50);
1169
1170         return yy_is_jam ? 0 : yy_current_state;
1171         }
1172
1173
1174 #ifndef YY_NO_UNPUT
1175 #ifdef YY_USE_PROTOS
1176 static void yyunput( int c, register char *yy_bp )
1177 #else
1178 static void yyunput( c, yy_bp )
1179 int c;
1180 register char *yy_bp;
1181 #endif
1182         {
1183         register char *yy_cp = yy_c_buf_p;
1184
1185         /* undo effects of setting up yytext */
1186         *yy_cp = yy_hold_char;
1187
1188         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1189                 { /* need to shift things up to make room */
1190                 /* +2 for EOB chars. */
1191                 register int number_to_move = yy_n_chars + 2;
1192                 register char *dest = &yy_current_buffer->yy_ch_buf[
1193                                         yy_current_buffer->yy_buf_size + 2];
1194                 register char *source =
1195                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1196
1197                 while ( source > yy_current_buffer->yy_ch_buf )
1198                         *--dest = *--source;
1199
1200                 yy_cp += (int) (dest - source);
1201                 yy_bp += (int) (dest - source);
1202                 yy_current_buffer->yy_n_chars =
1203                         yy_n_chars = yy_current_buffer->yy_buf_size;
1204
1205                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1206                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1207                 }
1208
1209         *--yy_cp = (char) c;
1210
1211
1212         yytext_ptr = yy_bp;
1213         yy_hold_char = *yy_cp;
1214         yy_c_buf_p = yy_cp;
1215         }
1216 #endif  /* ifndef YY_NO_UNPUT */
1217
1218
1219 #ifdef __cplusplus
1220 static int yyinput()
1221 #else
1222 static int input()
1223 #endif
1224         {
1225         int c;
1226
1227         *yy_c_buf_p = yy_hold_char;
1228
1229         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1230                 {
1231                 /* yy_c_buf_p now points to the character we want to return.
1232                  * If this occurs *before* the EOB characters, then it's a
1233                  * valid NUL; if not, then we've hit the end of the buffer.
1234                  */
1235                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1236                         /* This was really a NUL. */
1237                         *yy_c_buf_p = '\0';
1238
1239                 else
1240                         { /* need more input */
1241                         int offset = yy_c_buf_p - yytext_ptr;
1242                         ++yy_c_buf_p;
1243
1244                         switch ( yy_get_next_buffer() )
1245                                 {
1246                                 case EOB_ACT_LAST_MATCH:
1247                                         /* This happens because yy_g_n_b()
1248                                          * sees that we've accumulated a
1249                                          * token and flags that we need to
1250                                          * try matching the token before
1251                                          * proceeding.  But for input(),
1252                                          * there's no matching to consider.
1253                                          * So convert the EOB_ACT_LAST_MATCH
1254                                          * to EOB_ACT_END_OF_FILE.
1255                                          */
1256
1257                                         /* Reset buffer status. */
1258                                         yyrestart( yyin );
1259
1260                                         /* fall through */
1261
1262                                 case EOB_ACT_END_OF_FILE:
1263                                         {
1264                                         if ( yywrap() )
1265                                                 return EOF;
1266
1267                                         if ( ! yy_did_buffer_switch_on_eof )
1268                                                 YY_NEW_FILE;
1269 #ifdef __cplusplus
1270                                         return yyinput();
1271 #else
1272                                         return input();
1273 #endif
1274                                         }
1275
1276                                 case EOB_ACT_CONTINUE_SCAN:
1277                                         yy_c_buf_p = yytext_ptr + offset;
1278                                         break;
1279                                 }
1280                         }
1281                 }
1282
1283         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1284         *yy_c_buf_p = '\0';     /* preserve yytext */
1285         yy_hold_char = *++yy_c_buf_p;
1286
1287
1288         return c;
1289         }
1290
1291
1292 #ifdef YY_USE_PROTOS
1293 void yyrestart( FILE *input_file )
1294 #else
1295 void yyrestart( input_file )
1296 FILE *input_file;
1297 #endif
1298         {
1299         if ( ! yy_current_buffer )
1300                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1301
1302         yy_init_buffer( yy_current_buffer, input_file );
1303         yy_load_buffer_state();
1304         }
1305
1306
1307 #ifdef YY_USE_PROTOS
1308 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1309 #else
1310 void yy_switch_to_buffer( new_buffer )
1311 YY_BUFFER_STATE new_buffer;
1312 #endif
1313         {
1314         if ( yy_current_buffer == new_buffer )
1315                 return;
1316
1317         if ( yy_current_buffer )
1318                 {
1319                 /* Flush out information for old buffer. */
1320                 *yy_c_buf_p = yy_hold_char;
1321                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1322                 yy_current_buffer->yy_n_chars = yy_n_chars;
1323                 }
1324
1325         yy_current_buffer = new_buffer;
1326         yy_load_buffer_state();
1327
1328         /* We don't actually know whether we did this switch during
1329          * EOF (yywrap()) processing, but the only time this flag
1330          * is looked at is after yywrap() is called, so it's safe
1331          * to go ahead and always set it.
1332          */
1333         yy_did_buffer_switch_on_eof = 1;
1334         }
1335
1336
1337 #ifdef YY_USE_PROTOS
1338 void yy_load_buffer_state( void )
1339 #else
1340 void yy_load_buffer_state()
1341 #endif
1342         {
1343         yy_n_chars = yy_current_buffer->yy_n_chars;
1344         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1345         yyin = yy_current_buffer->yy_input_file;
1346         yy_hold_char = *yy_c_buf_p;
1347         }
1348
1349
1350 #ifdef YY_USE_PROTOS
1351 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1352 #else
1353 YY_BUFFER_STATE yy_create_buffer( file, size )
1354 FILE *file;
1355 int size;
1356 #endif
1357         {
1358         YY_BUFFER_STATE b;
1359
1360         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1361         if ( ! b )
1362                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1363
1364         b->yy_buf_size = size;
1365
1366         /* yy_ch_buf has to be 2 characters longer than the size given because
1367          * we need to put in 2 end-of-buffer characters.
1368          */
1369         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1370         if ( ! b->yy_ch_buf )
1371                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1372
1373         b->yy_is_our_buffer = 1;
1374
1375         yy_init_buffer( b, file );
1376
1377         return b;
1378         }
1379
1380
1381 #ifdef YY_USE_PROTOS
1382 void yy_delete_buffer( YY_BUFFER_STATE b )
1383 #else
1384 void yy_delete_buffer( b )
1385 YY_BUFFER_STATE b;
1386 #endif
1387         {
1388         if ( ! b )
1389                 return;
1390
1391         if ( b == yy_current_buffer )
1392                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1393
1394         if ( b->yy_is_our_buffer )
1395                 yy_flex_free( (void *) b->yy_ch_buf );
1396
1397         yy_flex_free( (void *) b );
1398         }
1399
1400
1401 #ifndef YY_ALWAYS_INTERACTIVE
1402 #ifndef YY_NEVER_INTERACTIVE
1403 extern int isatty YY_PROTO(( int ));
1404 #endif
1405 #endif
1406
1407 #ifdef YY_USE_PROTOS
1408 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1409 #else
1410 void yy_init_buffer( b, file )
1411 YY_BUFFER_STATE b;
1412 FILE *file;
1413 #endif
1414
1415
1416         {
1417         yy_flush_buffer( b );
1418
1419         b->yy_input_file = file;
1420         b->yy_fill_buffer = 1;
1421
1422 #if YY_ALWAYS_INTERACTIVE
1423         b->yy_is_interactive = 1;
1424 #else
1425 #if YY_NEVER_INTERACTIVE
1426         b->yy_is_interactive = 0;
1427 #else
1428         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1429 #endif
1430 #endif
1431         }
1432
1433
1434 #ifdef YY_USE_PROTOS
1435 void yy_flush_buffer( YY_BUFFER_STATE b )
1436 #else
1437 void yy_flush_buffer( b )
1438 YY_BUFFER_STATE b;
1439 #endif
1440
1441         {
1442         if ( ! b )
1443                 return;
1444
1445         b->yy_n_chars = 0;
1446
1447         /* We always need two end-of-buffer characters.  The first causes
1448          * a transition to the end-of-buffer state.  The second causes
1449          * a jam in that state.
1450          */
1451         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1452         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1453
1454         b->yy_buf_pos = &b->yy_ch_buf[0];
1455
1456         b->yy_at_bol = 1;
1457         b->yy_buffer_status = YY_BUFFER_NEW;
1458
1459         if ( b == yy_current_buffer )
1460                 yy_load_buffer_state();
1461         }
1462
1463
1464 #ifndef YY_NO_SCAN_BUFFER
1465 #ifdef YY_USE_PROTOS
1466 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1467 #else
1468 YY_BUFFER_STATE yy_scan_buffer( base, size )
1469 char *base;
1470 yy_size_t size;
1471 #endif
1472         {
1473         YY_BUFFER_STATE b;
1474
1475         if ( size < 2 ||
1476              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1477              base[size-1] != YY_END_OF_BUFFER_CHAR )
1478                 /* They forgot to leave room for the EOB's. */
1479                 return 0;
1480
1481         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1482         if ( ! b )
1483                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1484
1485         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1486         b->yy_buf_pos = b->yy_ch_buf = base;
1487         b->yy_is_our_buffer = 0;
1488         b->yy_input_file = 0;
1489         b->yy_n_chars = b->yy_buf_size;
1490         b->yy_is_interactive = 0;
1491         b->yy_at_bol = 1;
1492         b->yy_fill_buffer = 0;
1493         b->yy_buffer_status = YY_BUFFER_NEW;
1494
1495         yy_switch_to_buffer( b );
1496
1497         return b;
1498         }
1499 #endif
1500
1501
1502 #ifndef YY_NO_SCAN_STRING
1503 #ifdef YY_USE_PROTOS
1504 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1505 #else
1506 YY_BUFFER_STATE yy_scan_string( yy_str )
1507 yyconst char *yy_str;
1508 #endif
1509         {
1510         int len;
1511         for ( len = 0; yy_str[len]; ++len )
1512                 ;
1513
1514         return yy_scan_bytes( yy_str, len );
1515         }
1516 #endif
1517
1518
1519 #ifndef YY_NO_SCAN_BYTES
1520 #ifdef YY_USE_PROTOS
1521 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1522 #else
1523 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1524 yyconst char *bytes;
1525 int len;
1526 #endif
1527         {
1528         YY_BUFFER_STATE b;
1529         char *buf;
1530         yy_size_t n;
1531         int i;
1532
1533         /* Get memory for full buffer, including space for trailing EOB's. */
1534         n = len + 2;
1535         buf = (char *) yy_flex_alloc( n );
1536         if ( ! buf )
1537                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1538
1539         for ( i = 0; i < len; ++i )
1540                 buf[i] = bytes[i];
1541
1542         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1543
1544         b = yy_scan_buffer( buf, n );
1545         if ( ! b )
1546                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1547
1548         /* It's okay to grow etc. this buffer, and we should throw it
1549          * away when we're done.
1550          */
1551         b->yy_is_our_buffer = 1;
1552
1553         return b;
1554         }
1555 #endif
1556
1557
1558 #ifndef YY_NO_PUSH_STATE
1559 #ifdef YY_USE_PROTOS
1560 static void yy_push_state( int new_state )
1561 #else
1562 static void yy_push_state( new_state )
1563 int new_state;
1564 #endif
1565         {
1566         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1567                 {
1568                 yy_size_t new_size;
1569
1570                 yy_start_stack_depth += YY_START_STACK_INCR;
1571                 new_size = yy_start_stack_depth * sizeof( int );
1572
1573                 if ( ! yy_start_stack )
1574                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1575
1576                 else
1577                         yy_start_stack = (int *) yy_flex_realloc(
1578                                         (void *) yy_start_stack, new_size );
1579
1580                 if ( ! yy_start_stack )
1581                         YY_FATAL_ERROR(
1582                         "out of memory expanding start-condition stack" );
1583                 }
1584
1585         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1586
1587         BEGIN(new_state);
1588         }
1589 #endif
1590
1591
1592 #ifndef YY_NO_POP_STATE
1593 static void yy_pop_state()
1594         {
1595         if ( --yy_start_stack_ptr < 0 )
1596                 YY_FATAL_ERROR( "start-condition stack underflow" );
1597
1598         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1599         }
1600 #endif
1601
1602
1603 #ifndef YY_NO_TOP_STATE
1604 static int yy_top_state()
1605         {
1606         return yy_start_stack[yy_start_stack_ptr - 1];
1607         }
1608 #endif
1609
1610 #ifndef YY_EXIT_FAILURE
1611 #define YY_EXIT_FAILURE 2
1612 #endif
1613
1614 #ifdef YY_USE_PROTOS
1615 static void yy_fatal_error( yyconst char msg[] )
1616 #else
1617 static void yy_fatal_error( msg )
1618 char msg[];
1619 #endif
1620         {
1621         (void) fprintf( stderr, "%s\n", msg );
1622         exit( YY_EXIT_FAILURE );
1623         }
1624
1625
1626
1627 /* Redefine yyless() so it works in section 3 code. */
1628
1629 #undef yyless
1630 #define yyless(n) \
1631         do \
1632                 { \
1633                 /* Undo effects of setting up yytext. */ \
1634                 yytext[yyleng] = yy_hold_char; \
1635                 yy_c_buf_p = yytext + n; \
1636                 yy_hold_char = *yy_c_buf_p; \
1637                 *yy_c_buf_p = '\0'; \
1638                 yyleng = n; \
1639                 } \
1640         while ( 0 )
1641
1642
1643 /* Internal utility routines. */
1644
1645 #ifndef yytext_ptr
1646 #ifdef YY_USE_PROTOS
1647 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1648 #else
1649 static void yy_flex_strncpy( s1, s2, n )
1650 char *s1;
1651 yyconst char *s2;
1652 int n;
1653 #endif
1654         {
1655         register int i;
1656         for ( i = 0; i < n; ++i )
1657                 s1[i] = s2[i];
1658         }
1659 #endif
1660
1661 #ifdef YY_NEED_STRLEN
1662 #ifdef YY_USE_PROTOS
1663 static int yy_flex_strlen( yyconst char *s )
1664 #else
1665 static int yy_flex_strlen( s )
1666 yyconst char *s;
1667 #endif
1668         {
1669         register int n;
1670         for ( n = 0; s[n]; ++n )
1671                 ;
1672
1673         return n;
1674         }
1675 #endif
1676
1677
1678 #ifdef YY_USE_PROTOS
1679 static void *yy_flex_alloc( yy_size_t size )
1680 #else
1681 static void *yy_flex_alloc( size )
1682 yy_size_t size;
1683 #endif
1684         {
1685         return (void *) malloc( size );
1686         }
1687
1688 #ifdef YY_USE_PROTOS
1689 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1690 #else
1691 static void *yy_flex_realloc( ptr, size )
1692 void *ptr;
1693 yy_size_t size;
1694 #endif
1695         {
1696         /* The cast to (char *) in the following accommodates both
1697          * implementations that use char* generic pointers, and those
1698          * that use void* generic pointers.  It works with the latter
1699          * because both ANSI C and C++ allow castless assignment from
1700          * any pointer type to void*, and deal with argument conversions
1701          * as though doing an assignment.
1702          */
1703         return (void *) realloc( (char *) ptr, size );
1704         }
1705
1706 #ifdef YY_USE_PROTOS
1707 static void yy_flex_free( void *ptr )
1708 #else
1709 static void yy_flex_free( ptr )
1710 void *ptr;
1711 #endif
1712         {
1713         free( ptr );
1714         }
1715
1716 #if YY_MAIN
1717 int main()
1718         {
1719         yylex();
1720         return 0;
1721         }
1722 #endif
1723 #line 147 "rpld_conf.lex"
1724
1725
1726
1727 int yywrap()
1728 {
1729         return 1;
1730 }
1731