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