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