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