1
2 #line 3 "tokens.c"
3
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 31
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
34 #include <inttypes.h>
35 typedef int8_t flex_int8_t;
36 typedef uint8_t flex_uint8_t;
37 typedef int16_t flex_int16_t;
38 typedef uint16_t flex_uint16_t;
39 typedef int32_t flex_int32_t;
40 typedef uint32_t flex_uint32_t;
41 #else
42 typedef signed char flex_int8_t;
43 typedef short int flex_int16_t;
44 typedef int flex_int32_t;
45 typedef unsigned char flex_uint8_t;
46 typedef unsigned short int flex_uint16_t;
47 typedef unsigned int flex_uint32_t;
48 #endif /* ! C99 */
49
50 /* Limits of integral types. */
51 #ifndef INT8_MIN
52 #define INT8_MIN (-128)
53 #endif
54 #ifndef INT16_MIN
55 #define INT16_MIN (-32767-1)
56 #endif
57 #ifndef INT32_MIN
58 #define INT32_MIN (-2147483647-1)
59 #endif
60 #ifndef INT8_MAX
61 #define INT8_MAX (127)
62 #endif
63 #ifndef INT16_MAX
64 #define INT16_MAX (32767)
65 #endif
66 #ifndef INT32_MAX
67 #define INT32_MAX (2147483647)
68 #endif
69 #ifndef UINT8_MAX
70 #define UINT8_MAX (255U)
71 #endif
72 #ifndef UINT16_MAX
73 #define UINT16_MAX (65535U)
74 #endif
75 #ifndef UINT32_MAX
76 #define UINT32_MAX (4294967295U)
77 #endif
78
79 #endif /* ! FLEXINT_H */
80
81 #ifdef __cplusplus
82
83 /* The "const" storage-class-modifier is valid. */
84 #define YY_USE_CONST
85
86 #else /* ! __cplusplus */
87
88 #if __STDC__
89
90 #define YY_USE_CONST
91
92 #endif /* __STDC__ */
93 #endif /* ! __cplusplus */
94
95 #ifdef YY_USE_CONST
96 #define yyconst const
97 #else
98 #define yyconst
99 #endif
100
101 /* Returned upon end-of-file. */
102 #define YY_NULL 0
103
104 /* Promotes a possibly negative, possibly signed char to an unsigned
105 * integer for use as an array index. If the signed char is negative,
106 * we want to instead treat it as an 8-bit unsigned char, hence the
107 * double cast.
108 */
109 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
110
111 /* Enter a start condition. This macro really ought to take a parameter,
112 * but we do it the disgusting crufty way forced on us by the ()-less
113 * definition of BEGIN.
114 */
115 #define BEGIN (yy_start) = 1 + 2 *
116
117 /* Translate the current start state into a value that can be later handed
118 * to BEGIN to return to the state. The YYSTATE alias is for lex
119 * compatibility.
120 */
121 #define YY_START (((yy_start) - 1) / 2)
122 #define YYSTATE YY_START
123
124 /* Action number for EOF rule of a given start state. */
125 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
126
127 /* Special action meaning "start processing a new file". */
128 #define YY_NEW_FILE yyrestart(yyin )
129
130 #define YY_END_OF_BUFFER_CHAR 0
131
132 /* Size of default input buffer. */
133 #ifndef YY_BUF_SIZE
134 #define YY_BUF_SIZE 16384
135 #endif
136
137 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
138 #define YY_TYPEDEF_YY_BUFFER_STATE
139 typedef struct yy_buffer_state *YY_BUFFER_STATE;
140 #endif
141
142 extern int yyleng;
143
144 extern FILE *yyin, *yyout;
145
146 #define EOB_ACT_CONTINUE_SCAN 0
147 #define EOB_ACT_END_OF_FILE 1
148 #define EOB_ACT_LAST_MATCH 2
149
150 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
151 * access to the local variable yy_act. Since yyless() is a macro, it would break
152 * existing scanners that call yyless() from OUTSIDE yylex.
153 * One obvious solution it to make yy_act a global. I tried that, and saw
154 * a 5% performance hit in a non-yylineno scanner, because yy_act is
155 * normally declared as a register variable-- so it is not worth it.
156 */
157 #define YY_LESS_LINENO(n) \
158 do { \
159 int yyl;\
160 for ( yyl = n; yyl < yyleng; ++yyl )\
161 if ( yytext[yyl] == '\n' )\
162 --yylineno;\
163 }while(0)
164
165 /* Return all but the first "n" matched characters back to the input stream. */
166 #define yyless(n) \
167 do \
168 { \
169 /* Undo effects of setting up yytext. */ \
170 int yyless_macro_arg = (n); \
171 YY_LESS_LINENO(yyless_macro_arg);\
172 *yy_cp = (yy_hold_char); \
173 YY_RESTORE_YY_MORE_OFFSET \
174 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
175 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
176 } \
177 while ( 0 )
178
179 #define unput(c) yyunput( c, (yytext_ptr) )
180
181 /* The following is because we cannot portably get our hands on size_t
182 * (without autoconf's help, which isn't available because we want
183 * flex-generated scanners to compile on their own).
184 */
185
186 #ifndef YY_TYPEDEF_YY_SIZE_T
187 #define YY_TYPEDEF_YY_SIZE_T
188 typedef unsigned int yy_size_t;
189 #endif
190
191 #ifndef YY_STRUCT_YY_BUFFER_STATE
192 #define YY_STRUCT_YY_BUFFER_STATE
193 struct yy_buffer_state
194 {
195 FILE *yy_input_file;
196
197 char *yy_ch_buf; /* input buffer */
198 char *yy_buf_pos; /* current position in input buffer */
199
200 /* Size of input buffer in bytes, not including room for EOB
201 * characters.
202 */
203 yy_size_t yy_buf_size;
204
205 /* Number of characters read into yy_ch_buf, not including EOB
206 * characters.
207 */
208 int yy_n_chars;
209
210 /* Whether we "own" the buffer - i.e., we know we created it,
211 * and can realloc() it to grow it, and should free() it to
212 * delete it.
213 */
214 int yy_is_our_buffer;
215
216 /* Whether this is an "interactive" input source; if so, and
217 * if we're using stdio for input, then we want to use getc()
218 * instead of fread(), to make sure we stop fetching input after
219 * each newline.
220 */
221 int yy_is_interactive;
222
223 /* Whether we're considered to be at the beginning of a line.
224 * If so, '^' rules will be active on the next match, otherwise
225 * not.
226 */
227 int yy_at_bol;
228
229 int yy_bs_lineno; /**< The line count. */
230 int yy_bs_column; /**< The column count. */
231
232 /* Whether to try to fill the input buffer when we reach the
233 * end of it.
234 */
235 int yy_fill_buffer;
236
237 int yy_buffer_status;
238
239 #define YY_BUFFER_NEW 0
240 #define YY_BUFFER_NORMAL 1
241 /* When an EOF's been seen but there's still some text to process
242 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
243 * shouldn't try reading from the input source any more. We might
244 * still have a bunch of tokens to match, though, because of
245 * possible backing-up.
246 *
247 * When we actually see the EOF, we change the status to "new"
248 * (via yyrestart()), so that the user can continue scanning by
249 * just pointing yyin at a new input file.
250 */
251 #define YY_BUFFER_EOF_PENDING 2
252
253 };
254 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
255
256 /* Stack of input buffers. */
257 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
258 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
259 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
260
261 /* We provide macros for accessing buffer states in case in the
262 * future we want to put the buffer states in a more general
263 * "scanner state".
264 *
265 * Returns the top of the stack, or NULL.
266 */
267 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
268 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
269 : NULL)
270
271 /* Same as previous macro, but useful when we know that the buffer stack is not
272 * NULL or when we need an lvalue. For internal use only.
273 */
274 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
275
276 /* yy_hold_char holds the character lost when yytext is formed. */
277 static char yy_hold_char;
278 static int yy_n_chars; /* number of characters read into yy_ch_buf */
279 int yyleng;
280
281 /* Points to current character in buffer. */
282 static char *yy_c_buf_p = (char *) 0;
283 static int yy_init = 1; /* whether we need to initialize */
284 static int yy_start = 0; /* start state number */
285
286 /* Flag which is used to allow yywrap()'s to do buffer switches
287 * instead of setting up a fresh yyin. A bit of a hack ...
288 */
289 static int yy_did_buffer_switch_on_eof;
290
291 void yyrestart (FILE *input_file );
292 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
293 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
294 void yy_delete_buffer (YY_BUFFER_STATE b );
295 void yy_flush_buffer (YY_BUFFER_STATE b );
296 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
297 void yypop_buffer_state (void );
298
299 static void yyensure_buffer_stack (void );
300 static void yy_load_buffer_state (void );
301 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
302
303 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
304
305 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
306 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
307 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );
308
309 void *yyalloc (yy_size_t );
310 void *yyrealloc (void *,yy_size_t );
311 void yyfree (void * );
312
313 #define yy_new_buffer yy_create_buffer
314
315 #define yy_set_interactive(is_interactive) \
316 { \
317 if ( ! YY_CURRENT_BUFFER ){ \
318 yyensure_buffer_stack (); \
319 YY_CURRENT_BUFFER_LVALUE = \
320 yy_create_buffer(yyin,YY_BUF_SIZE ); \
321 } \
322 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
323 }
324
325 #define yy_set_bol(at_bol) \
326 { \
327 if ( ! YY_CURRENT_BUFFER ){\
328 yyensure_buffer_stack (); \
329 YY_CURRENT_BUFFER_LVALUE = \
330 yy_create_buffer(yyin,YY_BUF_SIZE ); \
331 } \
332 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
333 }
334
335 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
336
337 /* Begin user sect3 */
338
339 typedef unsigned char YY_CHAR;
340
341 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
342
343 typedef int yy_state_type;
344
345 extern int yylineno;
346
347 int yylineno = 1;
348
349 extern char *yytext;
350 #define yytext_ptr yytext
351
352 static yy_state_type yy_get_previous_state (void );
353 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
354 static int yy_get_next_buffer (void );
355 static void yy_fatal_error (yyconst char msg[] );
356
357 /* Done after the current pattern has been matched and before the
358 * corresponding action - sets up yytext.
359 */
360 #define YY_DO_BEFORE_ACTION \
361 (yytext_ptr) = yy_bp; \
362 yyleng = (size_t) (yy_cp - yy_bp); \
363 (yy_hold_char) = *yy_cp; \
364 *yy_cp = '\0'; \
365 (yy_c_buf_p) = yy_cp;
366
367 #define YY_NUM_RULES 10
368 #define YY_END_OF_BUFFER 11
369 /* This struct is not used in this scanner,
370 but its presence is necessary. */
371 struct yy_trans_info
372 {
373 flex_int32_t yy_verify;
374 flex_int32_t yy_nxt;
375 };
376 static yyconst flex_int16_t yy_accept[33] =
377 { 0,
378 2, 2, 0, 0, 11, 10, 2, 6, 7, 1,
379 4, 6, 2, 5, 5, 8, 9, 2, 6, 6,
380 1, 1, 1, 6, 2, 5, 5, 5, 8, 3,
381 3, 0
382 } ;
383
384 static yyconst flex_int32_t yy_ec[256] =
385 { 0,
386 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
387 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
389 1, 2, 4, 5, 6, 4, 4, 4, 4, 4,
390 4, 4, 4, 4, 7, 4, 4, 8, 8, 8,
391 8, 8, 8, 8, 8, 8, 8, 4, 9, 1,
392 10, 1, 4, 4, 7, 7, 7, 7, 11, 7,
393 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
394 7, 7, 12, 13, 7, 7, 7, 7, 7, 7,
395 4, 4, 4, 1, 7, 1, 7, 7, 7, 7,
396
397 11, 7, 7, 7, 7, 7, 7, 7, 7, 7,
398 7, 7, 7, 7, 12, 13, 7, 7, 7, 7,
399 7, 7, 4, 1, 4, 4, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 1, 1, 4, 4, 1, 1, 1, 1, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 1, 1, 1, 1, 1
414 } ;
415
416 static yyconst flex_int32_t yy_meta[14] =
417 { 0,
418 1, 2, 3, 4, 5, 4, 6, 4, 4, 1,
419 6, 6, 6
420 } ;
421
422 static yyconst flex_int16_t yy_base[39] =
423 { 0,
424 0, 12, 41, 40, 40, 88, 0, 19, 88, 25,
425 88, 30, 40, 37, 11, 0, 88, 0, 12, 11,
426 0, 0, 9, 42, 54, 56, 0, 4, 0, 7,
427 0, 88, 59, 64, 64, 69, 75, 81
428 } ;
429
430 static yyconst flex_int16_t yy_def[39] =
431 { 0,
432 32, 1, 33, 33, 32, 32, 34, 35, 32, 32,
433 32, 35, 36, 12, 14, 37, 32, 34, 35, 32,
434 38, 10, 38, 35, 36, 36, 14, 14, 37, 35,
435 14, 0, 32, 32, 32, 32, 32, 32
436 } ;
437
438 static yyconst flex_int16_t yy_nxt[102] =
439 { 0,
440 6, 7, 7, 8, 9, 10, 8, 8, 6, 11,
441 8, 12, 8, 13, 13, 20, 31, 23, 14, 20,
442 20, 28, 14, 15, 14, 21, 21, 20, 22, 21,
443 22, 22, 22, 23, 21, 22, 22, 22, 20, 32,
444 24, 25, 25, 27, 17, 17, 32, 27, 27, 27,
445 20, 32, 32, 32, 30, 25, 25, 32, 32, 16,
446 16, 16, 16, 16, 16, 18, 18, 19, 32, 19,
447 26, 26, 32, 32, 26, 29, 29, 29, 29, 32,
448 29, 21, 21, 32, 21, 21, 21, 5, 32, 32,
449 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
450
451 32
452 } ;
453
454 static yyconst flex_int16_t yy_chk[102] =
455 { 0,
456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 1, 1, 1, 2, 2, 30, 28, 23, 2, 20,
458 19, 15, 2, 2, 2, 10, 10, 8, 10, 10,
459 10, 10, 10, 10, 10, 10, 10, 10, 12, 5,
460 12, 13, 13, 14, 4, 3, 0, 14, 14, 14,
461 24, 0, 0, 0, 24, 25, 25, 26, 26, 33,
462 33, 33, 33, 33, 33, 34, 34, 35, 0, 35,
463 36, 36, 0, 0, 36, 37, 37, 37, 37, 0,
464 37, 38, 38, 0, 38, 38, 38, 32, 32, 32,
465 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
466
467 32
468 } ;
469
470 /* Table of booleans, true if rule could match eol. */
471 static yyconst flex_int32_t yy_rule_can_match_eol[11] =
472 { 0,
473 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, };
474
475 static yy_state_type yy_last_accepting_state;
476 static char *yy_last_accepting_cpos;
477
478 extern int yy_flex_debug;
479 int yy_flex_debug = 0;
480
481 /* The intent behind this definition is that it'll catch
482 * any uses of REJECT which flex missed.
483 */
484 #define REJECT reject_used_but_not_detected
485 #define yymore() yymore_used_but_not_detected
486 #define YY_MORE_ADJ 0
487 #define YY_RESTORE_YY_MORE_OFFSET
488 char *yytext;
489 #line 1 "conf/tokens.l"
490 /* Hey Emacs, this is code for lex to eat, treat it as -*-C-*- code
491 *
492 * Copyright (C) 2003, 2004 Joachim Nilsson <joachim!nilsson()member!fsf!org>
493 *
494 * qADSL is free software; you can redistribute it and/or modify it
495 * under the terms of the GNU General Public License as published by
496 * the Free Software Foundation; either version 2 of the License,
497 * or (at your option) any later version.
498 *
499 * qADSL is distributed in the hope that it will be useful, but
500 * WITHOUT ANY WARRANTY; without even the implied warranty of
501 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
502 * GNU General Public License for more details.
503 *
504 * You should have received a copy of the GNU General Public License
505 * along with this program; if not, write to the Free Software
506 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
507 */
508 #line 20 "conf/tokens.l"
509
510 #ifdef HAVE_CONFIG_H
511 #include "config.h"
512 #endif
513
514 #include <stdio.h>
515 #include <string.h>
516
517 #include "parser.h"
518
519 #ifdef YYDEBUG
520 #define log(args...) fprintf (stderr, args);
521 #else
522 #define log(args...)
523 #endif
524
525
526 /* %option reentrant */
527 /* %option bison-bridge */
528 /* %option noyywrap */
529 #line 530 "tokens.c"
530
531 #define INITIAL 0
532 #define ARG_MODE 1
533
534 #ifndef YY_NO_UNISTD_H
535 /* Special case for "unistd.h", since it is non-ANSI. We include it way
536 * down here because we want the user's section 1 to have been scanned first.
537 * The user has a chance to override it with an option.
538 */
539 #include <unistd.h>
540 #endif
541
542 #ifndef YY_EXTRA_TYPE
543 #define YY_EXTRA_TYPE void *
544 #endif
545
546 /* Macros after this point can all be overridden by user definitions in
547 * section 1.
548 */
549
550 #ifndef YY_SKIP_YYWRAP
551 #ifdef __cplusplus
552 extern "C" int yywrap (void );
553 #else
554 extern int yywrap (void );
555 #endif
556 #endif
557
558 #ifndef yytext_ptr
559 static void yy_flex_strncpy (char *,yyconst char *,int );
560 #endif
561
562 #ifdef YY_NEED_STRLEN
563 static int yy_flex_strlen (yyconst char * );
564 #endif
565
566 #ifndef YY_NO_INPUT
567
568 #ifdef __cplusplus
569 static int yyinput (void );
570 #else
571 static int input (void );
572 #endif
573
574 #endif
575
576 /* Amount of stuff to slurp up with each read. */
577 #ifndef YY_READ_BUF_SIZE
578 #define YY_READ_BUF_SIZE 8192
579 #endif
580
581 /* Copy whatever the last rule matched to the standard output. */
582 #ifndef ECHO
583 /* This used to be an fputs(), but since the string might contain NUL's,
584 * we now use fwrite().
585 */
586 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
587 #endif
588
589 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
590 * is returned in "result".
591 */
592 #ifndef YY_INPUT
593 #define YY_INPUT(buf,result,max_size) \
594 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
595 { \
596 int c = '*'; \
597 size_t n; \
598 for ( n = 0; n < max_size && \
599 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
600 buf[n] = (char) c; \
601 if ( c == '\n' ) \
602 buf[n++] = (char) c; \
603 if ( c == EOF && ferror( yyin ) ) \
604 YY_FATAL_ERROR( "input in flex scanner failed" ); \
605 result = n; \
606 } \
607 else \
608 { \
609 errno=0; \
610 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
611 { \
612 if( errno != EINTR) \
613 { \
614 YY_FATAL_ERROR( "input in flex scanner failed" ); \
615 break; \
616 } \
617 errno=0; \
618 clearerr(yyin); \
619 } \
620 }\
621 \
622
623 #endif
624
625 /* No semi-colon after return; correct usage is to write "yyterminate();" -
626 * we don't want an extra ';' after the "return" because that will cause
627 * some compilers to complain about unreachable statements.
628 */
629 #ifndef yyterminate
630 #define yyterminate() return YY_NULL
631 #endif
632
633 /* Number of entries by which start-condition stack grows. */
634 #ifndef YY_START_STACK_INCR
635 #define YY_START_STACK_INCR 25
636 #endif
637
638 /* Report a fatal error. */
639 #ifndef YY_FATAL_ERROR
640 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
641 #endif
642
643 /* end tables serialization structures and prototypes */
644
645 /* Default declaration of generated scanner - a define so the user can
646 * easily add parameters.
647 */
648 #ifndef YY_DECL
649 #define YY_DECL_IS_OURS 1
650
651 extern int yylex (void);
652
653 #define YY_DECL int yylex (void)
654 #endif /* !YY_DECL */
655
656 /* Code executed at the beginning of each rule, after yytext and yyleng
657 * have been set up.
658 */
659 #ifndef YY_USER_ACTION
660 #define YY_USER_ACTION
661 #endif
662
663 /* Code executed at the end of each rule. */
664 #ifndef YY_BREAK
665 #define YY_BREAK break;
666 #endif
667
668 #define YY_RULE_SETUP \
669 if ( yyleng > 0 ) \
670 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
671 (yytext[yyleng - 1] == '\n'); \
672 YY_USER_ACTION
673
674 /** The main scanner function which does all the work.
675 */
676 YY_DECL
677 {
678 register yy_state_type yy_current_state;
679 register char *yy_cp, *yy_bp;
680 register int yy_act;
681
682 #line 55 "conf/tokens.l"
683
684
685 #line 686 "tokens.c"
686
687 if ( (yy_init) )
688 {
689 (yy_init) = 0;
690
691 #ifdef YY_USER_INIT
692 YY_USER_INIT;
693 #endif
694
695 if ( ! (yy_start) )
696 (yy_start) = 1; /* first start state */
697
698 if ( ! yyin )
699 yyin = stdin;
700
701 if ( ! yyout )
702 yyout = stdout;
703
704 if ( ! YY_CURRENT_BUFFER ) {
705 yyensure_buffer_stack ();
706 YY_CURRENT_BUFFER_LVALUE =
707 yy_create_buffer(yyin,YY_BUF_SIZE );
708 }
709
710 yy_load_buffer_state( );
711 }
712
713 while ( 1 ) /* loops until end-of-file is reached */
714 {
715 yy_cp = (yy_c_buf_p);
716
717 /* Support of yytext. */
718 *yy_cp = (yy_hold_char);
719
720 /* yy_bp points to the position in yy_ch_buf of the start of
721 * the current run.
722 */
723 yy_bp = yy_cp;
724
725 yy_current_state = (yy_start);
726 yy_current_state += YY_AT_BOL();
727 yy_match:
728 do
729 {
730 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
731 if ( yy_accept[yy_current_state] )
732 {
733 (yy_last_accepting_state) = yy_current_state;
734 (yy_last_accepting_cpos) = yy_cp;
735 }
736 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
737 {
738 yy_current_state = (int) yy_def[yy_current_state];
739 if ( yy_current_state >= 33 )
740 yy_c = yy_meta[(unsigned int) yy_c];
741 }
742 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
743 ++yy_cp;
744 }
745 while ( yy_base[yy_current_state] != 88 );
746
747 yy_find_action:
748 yy_act = yy_accept[yy_current_state];
749 if ( yy_act == 0 )
750 { /* have to back up */
751 yy_cp = (yy_last_accepting_cpos);
752 yy_current_state = (yy_last_accepting_state);
753 yy_act = yy_accept[yy_current_state];
754 }
755
756 YY_DO_BEFORE_ACTION;
757
758 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
759 {
760 int yyl;
761 for ( yyl = 0; yyl < yyleng; ++yyl )
762 if ( yytext[yyl] == '\n' )
763
764 yylineno++;
765 ;
766 }
767
768 do_action: /* This label is used only to access EOF actions. */
769
770 switch ( yy_act )
771 { /* beginning of action switch */
772 case 0: /* must back up */
773 /* undo the effects of YY_DO_BEFORE_ACTION */
774 *yy_cp = (yy_hold_char);
775 yy_cp = (yy_last_accepting_cpos);
776 yy_current_state = (yy_last_accepting_state);
777 goto yy_find_action;
778
779 case 1:
780 YY_RULE_SETUP
781 #line 57 "conf/tokens.l"
782 {log ("%s", yytext);}
783 YY_BREAK
784 case 2:
785 /* rule 2 can match eol */
786 YY_RULE_SETUP
787 #line 59 "conf/tokens.l"
788 {log ("%s", yytext);}
789 YY_BREAK
790 case 3:
791 YY_RULE_SETUP
792 #line 61 "conf/tokens.l"
793 {log ("SET ");
794 return SET;}
795 YY_BREAK
796 case 4:
797 YY_RULE_SETUP
798 #line 64 "conf/tokens.l"
799 {log (" EQU ");
800 return EQU;}
801 YY_BREAK
802 case 5:
803 /* rule 5 can match eol */
804 YY_RULE_SETUP
805 #line 67 "conf/tokens.l"
806 {yylval.str = strdup(yytext); /*XXX - Check for NULL */
807 log ("ID(%s)", yylval.str);
808 return ID;}
809 YY_BREAK
810 case 6:
811 YY_RULE_SETUP
812 #line 71 "conf/tokens.l"
813 {yylval.str = strdup(yytext); /* XXX - Check for NULL */
814 log ("ARG(%s)", yylval.str);
815 return ARG;}
816 YY_BREAK
817 case 7:
818 YY_RULE_SETUP
819 #line 75 "conf/tokens.l"
820 {BEGIN(ARG_MODE); yylval.str = NULL;}
821 YY_BREAK
822 case 8:
823 /* rule 8 can match eol */
824 YY_RULE_SETUP
825 #line 76 "conf/tokens.l"
826 {yylval.str = strdup(yytext);
827 log ("ARG(%s)", yylval.str);}
828 YY_BREAK
829 case 9:
830 YY_RULE_SETUP
831 #line 78 "conf/tokens.l"
832 {BEGIN(INITIAL); if (!yylval.str) yylval.str = strdup(""); return ARG;}
833 YY_BREAK
834 case 10:
835 YY_RULE_SETUP
836 #line 80 "conf/tokens.l"
837 ECHO;
838 YY_BREAK
839 #line 840 "tokens.c"
840 case YY_STATE_EOF(INITIAL):
841 case YY_STATE_EOF(ARG_MODE):
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_LVALUE->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_LVALUE->yy_n_chars;
865 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
866 YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->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 /* yy_get_next_buffer - try to read in a new buffer
974 *
975 * Returns a code representing an action:
976 * EOB_ACT_LAST_MATCH -
977 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
978 * EOB_ACT_END_OF_FILE - end of file
979 */
yy_get_next_buffer(void)980 static int yy_get_next_buffer (void)
981 {
982 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
983 register char *source = (yytext_ptr);
984 register int number_to_move, i;
985 int ret_val;
986
987 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
988 YY_FATAL_ERROR(
989 "fatal flex scanner internal error--end of buffer missed" );
990
991 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
992 { /* Don't try to fill the buffer, so this is an EOF. */
993 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
994 {
995 /* We matched a single character, the EOB, so
996 * treat this as a final EOF.
997 */
998 return EOB_ACT_END_OF_FILE;
999 }
1000
1001 else
1002 {
1003 /* We matched some text prior to the EOB, first
1004 * process it.
1005 */
1006 return EOB_ACT_LAST_MATCH;
1007 }
1008 }
1009
1010 /* Try to read more data. */
1011
1012 /* First move last chars to start of buffer. */
1013 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1014
1015 for ( i = 0; i < number_to_move; ++i )
1016 *(dest++) = *(source++);
1017
1018 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1019 /* don't do the read, it's not guaranteed to return an EOF,
1020 * just force an EOF
1021 */
1022 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1023
1024 else
1025 {
1026 size_t num_to_read =
1027 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1028
1029 while ( num_to_read <= 0 )
1030 { /* Not enough room in the buffer - grow it. */
1031
1032 /* just a shorter name for the current buffer */
1033 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1034
1035 int yy_c_buf_p_offset =
1036 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1037
1038 if ( b->yy_is_our_buffer )
1039 {
1040 int new_size = b->yy_buf_size * 2;
1041
1042 if ( new_size <= 0 )
1043 b->yy_buf_size += b->yy_buf_size / 8;
1044 else
1045 b->yy_buf_size *= 2;
1046
1047 b->yy_ch_buf = (char *)
1048 /* Include room in for 2 EOB chars. */
1049 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1050 }
1051 else
1052 /* Can't grow it, we don't own it. */
1053 b->yy_ch_buf = 0;
1054
1055 if ( ! b->yy_ch_buf )
1056 YY_FATAL_ERROR(
1057 "fatal error - scanner input buffer overflow" );
1058
1059 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1060
1061 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1062 number_to_move - 1;
1063
1064 }
1065
1066 if ( num_to_read > YY_READ_BUF_SIZE )
1067 num_to_read = YY_READ_BUF_SIZE;
1068
1069 /* Read in more data. */
1070 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1071 (yy_n_chars), num_to_read );
1072
1073 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1074 }
1075
1076 if ( (yy_n_chars) == 0 )
1077 {
1078 if ( number_to_move == YY_MORE_ADJ )
1079 {
1080 ret_val = EOB_ACT_END_OF_FILE;
1081 yyrestart(yyin );
1082 }
1083
1084 else
1085 {
1086 ret_val = EOB_ACT_LAST_MATCH;
1087 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1088 YY_BUFFER_EOF_PENDING;
1089 }
1090 }
1091
1092 else
1093 ret_val = EOB_ACT_CONTINUE_SCAN;
1094
1095 (yy_n_chars) += number_to_move;
1096 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1097 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1098
1099 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1100
1101 return ret_val;
1102 }
1103
1104 /* yy_get_previous_state - get the state just before the EOB char was reached */
1105
yy_get_previous_state(void)1106 static yy_state_type yy_get_previous_state (void)
1107 {
1108 register yy_state_type yy_current_state;
1109 register char *yy_cp;
1110
1111 yy_current_state = (yy_start);
1112 yy_current_state += YY_AT_BOL();
1113
1114 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1115 {
1116 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1117 if ( yy_accept[yy_current_state] )
1118 {
1119 (yy_last_accepting_state) = yy_current_state;
1120 (yy_last_accepting_cpos) = yy_cp;
1121 }
1122 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1123 {
1124 yy_current_state = (int) yy_def[yy_current_state];
1125 if ( yy_current_state >= 33 )
1126 yy_c = yy_meta[(unsigned int) yy_c];
1127 }
1128 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1129 }
1130
1131 return yy_current_state;
1132 }
1133
1134 /* yy_try_NUL_trans - try to make a transition on the NUL character
1135 *
1136 * synopsis
1137 * next_state = yy_try_NUL_trans( current_state );
1138 */
yy_try_NUL_trans(yy_state_type yy_current_state)1139 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1140 {
1141 register int yy_is_jam;
1142 register char *yy_cp = (yy_c_buf_p);
1143
1144 register YY_CHAR yy_c = 1;
1145 if ( yy_accept[yy_current_state] )
1146 {
1147 (yy_last_accepting_state) = yy_current_state;
1148 (yy_last_accepting_cpos) = yy_cp;
1149 }
1150 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1151 {
1152 yy_current_state = (int) yy_def[yy_current_state];
1153 if ( yy_current_state >= 33 )
1154 yy_c = yy_meta[(unsigned int) yy_c];
1155 }
1156 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1157 yy_is_jam = (yy_current_state == 32);
1158
1159 return yy_is_jam ? 0 : yy_current_state;
1160 }
1161
1162 #ifndef YY_NO_INPUT
1163 #ifdef __cplusplus
yyinput(void)1164 static int yyinput (void)
1165 #else
1166 static int input (void)
1167 #endif
1168
1169 {
1170 int c;
1171
1172 *(yy_c_buf_p) = (yy_hold_char);
1173
1174 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1175 {
1176 /* yy_c_buf_p now points to the character we want to return.
1177 * If this occurs *before* the EOB characters, then it's a
1178 * valid NUL; if not, then we've hit the end of the buffer.
1179 */
1180 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1181 /* This was really a NUL. */
1182 *(yy_c_buf_p) = '\0';
1183
1184 else
1185 { /* need more input */
1186 int offset = (yy_c_buf_p) - (yytext_ptr);
1187 ++(yy_c_buf_p);
1188
1189 switch ( yy_get_next_buffer( ) )
1190 {
1191 case EOB_ACT_LAST_MATCH:
1192 /* This happens because yy_g_n_b()
1193 * sees that we've accumulated a
1194 * token and flags that we need to
1195 * try matching the token before
1196 * proceeding. But for input(),
1197 * there's no matching to consider.
1198 * So convert the EOB_ACT_LAST_MATCH
1199 * to EOB_ACT_END_OF_FILE.
1200 */
1201
1202 /* Reset buffer status. */
1203 yyrestart(yyin );
1204
1205 /*FALLTHROUGH*/
1206
1207 case EOB_ACT_END_OF_FILE:
1208 {
1209 if ( yywrap( ) )
1210 return EOF;
1211
1212 if ( ! (yy_did_buffer_switch_on_eof) )
1213 YY_NEW_FILE;
1214 #ifdef __cplusplus
1215 return yyinput();
1216 #else
1217 return input();
1218 #endif
1219 }
1220
1221 case EOB_ACT_CONTINUE_SCAN:
1222 (yy_c_buf_p) = (yytext_ptr) + offset;
1223 break;
1224 }
1225 }
1226 }
1227
1228 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1229 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1230 (yy_hold_char) = *++(yy_c_buf_p);
1231
1232 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1233 if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
1234
1235 yylineno++;
1236 ;
1237
1238 return c;
1239 }
1240 #endif /* ifndef YY_NO_INPUT */
1241
1242 /** Immediately switch to a different input stream.
1243 * @param input_file A readable stream.
1244 *
1245 * @note This function does not reset the start condition to @c INITIAL .
1246 */
yyrestart(FILE * input_file)1247 void yyrestart (FILE * input_file )
1248 {
1249
1250 if ( ! YY_CURRENT_BUFFER ){
1251 yyensure_buffer_stack ();
1252 YY_CURRENT_BUFFER_LVALUE =
1253 yy_create_buffer(yyin,YY_BUF_SIZE );
1254 }
1255
1256 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1257 yy_load_buffer_state( );
1258 }
1259
1260 /** Switch to a different input buffer.
1261 * @param new_buffer The new input buffer.
1262 *
1263 */
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)1264 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1265 {
1266
1267 /* TODO. We should be able to replace this entire function body
1268 * with
1269 * yypop_buffer_state();
1270 * yypush_buffer_state(new_buffer);
1271 */
1272 yyensure_buffer_stack ();
1273 if ( YY_CURRENT_BUFFER == new_buffer )
1274 return;
1275
1276 if ( YY_CURRENT_BUFFER )
1277 {
1278 /* Flush out information for old buffer. */
1279 *(yy_c_buf_p) = (yy_hold_char);
1280 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1281 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1282 }
1283
1284 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1285 yy_load_buffer_state( );
1286
1287 /* We don't actually know whether we did this switch during
1288 * EOF (yywrap()) processing, but the only time this flag
1289 * is looked at is after yywrap() is called, so it's safe
1290 * to go ahead and always set it.
1291 */
1292 (yy_did_buffer_switch_on_eof) = 1;
1293 }
1294
yy_load_buffer_state(void)1295 static void yy_load_buffer_state (void)
1296 {
1297 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1298 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1299 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1300 (yy_hold_char) = *(yy_c_buf_p);
1301 }
1302
1303 /** Allocate and initialize an input buffer state.
1304 * @param file A readable stream.
1305 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1306 *
1307 * @return the allocated buffer state.
1308 */
yy_create_buffer(FILE * file,int size)1309 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1310 {
1311 YY_BUFFER_STATE b;
1312
1313 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1314 if ( ! b )
1315 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1316
1317 b->yy_buf_size = size;
1318
1319 /* yy_ch_buf has to be 2 characters longer than the size given because
1320 * we need to put in 2 end-of-buffer characters.
1321 */
1322 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1323 if ( ! b->yy_ch_buf )
1324 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1325
1326 b->yy_is_our_buffer = 1;
1327
1328 yy_init_buffer(b,file );
1329
1330 return b;
1331 }
1332
1333 /** Destroy the buffer.
1334 * @param b a buffer created with yy_create_buffer()
1335 *
1336 */
yy_delete_buffer(YY_BUFFER_STATE b)1337 void yy_delete_buffer (YY_BUFFER_STATE b )
1338 {
1339
1340 if ( ! b )
1341 return;
1342
1343 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1344 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1345
1346 if ( b->yy_is_our_buffer )
1347 yyfree((void *) b->yy_ch_buf );
1348
1349 yyfree((void *) b );
1350 }
1351
1352 #ifndef __cplusplus
1353 extern int isatty (int );
1354 #endif /* __cplusplus */
1355
1356 /* Initializes or reinitializes a buffer.
1357 * This function is sometimes called more than once on the same buffer,
1358 * such as during a yyrestart() or at EOF.
1359 */
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)1360 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1361
1362 {
1363 int oerrno = errno;
1364
1365 yy_flush_buffer(b );
1366
1367 b->yy_input_file = file;
1368 b->yy_fill_buffer = 1;
1369
1370 /* If b is the current buffer, then yy_init_buffer was _probably_
1371 * called from yyrestart() or through yy_get_next_buffer.
1372 * In that case, we don't want to reset the lineno or column.
1373 */
1374 if (b != YY_CURRENT_BUFFER){
1375 b->yy_bs_lineno = 1;
1376 b->yy_bs_column = 0;
1377 }
1378
1379 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1380
1381 errno = oerrno;
1382 }
1383
1384 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1385 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1386 *
1387 */
yy_flush_buffer(YY_BUFFER_STATE b)1388 void yy_flush_buffer (YY_BUFFER_STATE b )
1389 {
1390 if ( ! b )
1391 return;
1392
1393 b->yy_n_chars = 0;
1394
1395 /* We always need two end-of-buffer characters. The first causes
1396 * a transition to the end-of-buffer state. The second causes
1397 * a jam in that state.
1398 */
1399 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1400 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1401
1402 b->yy_buf_pos = &b->yy_ch_buf[0];
1403
1404 b->yy_at_bol = 1;
1405 b->yy_buffer_status = YY_BUFFER_NEW;
1406
1407 if ( b == YY_CURRENT_BUFFER )
1408 yy_load_buffer_state( );
1409 }
1410
1411 /** Pushes the new state onto the stack. The new state becomes
1412 * the current state. This function will allocate the stack
1413 * if necessary.
1414 * @param new_buffer The new state.
1415 *
1416 */
yypush_buffer_state(YY_BUFFER_STATE new_buffer)1417 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1418 {
1419 if (new_buffer == NULL)
1420 return;
1421
1422 yyensure_buffer_stack();
1423
1424 /* This block is copied from yy_switch_to_buffer. */
1425 if ( YY_CURRENT_BUFFER )
1426 {
1427 /* Flush out information for old buffer. */
1428 *(yy_c_buf_p) = (yy_hold_char);
1429 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1430 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1431 }
1432
1433 /* Only push if top exists. Otherwise, replace top. */
1434 if (YY_CURRENT_BUFFER)
1435 (yy_buffer_stack_top)++;
1436 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1437
1438 /* copied from yy_switch_to_buffer. */
1439 yy_load_buffer_state( );
1440 (yy_did_buffer_switch_on_eof) = 1;
1441 }
1442
1443 /** Removes and deletes the top of the stack, if present.
1444 * The next element becomes the new top.
1445 *
1446 */
yypop_buffer_state(void)1447 void yypop_buffer_state (void)
1448 {
1449 if (!YY_CURRENT_BUFFER)
1450 return;
1451
1452 yy_delete_buffer(YY_CURRENT_BUFFER );
1453 YY_CURRENT_BUFFER_LVALUE = NULL;
1454 if ((yy_buffer_stack_top) > 0)
1455 --(yy_buffer_stack_top);
1456
1457 if (YY_CURRENT_BUFFER) {
1458 yy_load_buffer_state( );
1459 (yy_did_buffer_switch_on_eof) = 1;
1460 }
1461 }
1462
1463 /* Allocates the stack if it does not exist.
1464 * Guarantees space for at least one push.
1465 */
yyensure_buffer_stack(void)1466 static void yyensure_buffer_stack (void)
1467 {
1468 int num_to_alloc;
1469
1470 if (!(yy_buffer_stack)) {
1471
1472 /* First allocation is just for 2 elements, since we don't know if this
1473 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1474 * immediate realloc on the next call.
1475 */
1476 num_to_alloc = 1;
1477 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1478 (num_to_alloc * sizeof(struct yy_buffer_state*)
1479 );
1480
1481 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1482
1483 (yy_buffer_stack_max) = num_to_alloc;
1484 (yy_buffer_stack_top) = 0;
1485 return;
1486 }
1487
1488 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1489
1490 /* Increase the buffer to prepare for a possible push. */
1491 int grow_size = 8 /* arbitrary grow size */;
1492
1493 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1494 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1495 ((yy_buffer_stack),
1496 num_to_alloc * sizeof(struct yy_buffer_state*)
1497 );
1498
1499 /* zero only the new slots.*/
1500 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1501 (yy_buffer_stack_max) = num_to_alloc;
1502 }
1503 }
1504
1505 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1506 * @param base the character buffer
1507 * @param size the size in bytes of the character buffer
1508 *
1509 * @return the newly allocated buffer state object.
1510 */
yy_scan_buffer(char * base,yy_size_t size)1511 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1512 {
1513 YY_BUFFER_STATE b;
1514
1515 if ( size < 2 ||
1516 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1517 base[size-1] != YY_END_OF_BUFFER_CHAR )
1518 /* They forgot to leave room for the EOB's. */
1519 return 0;
1520
1521 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1522 if ( ! b )
1523 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1524
1525 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1526 b->yy_buf_pos = b->yy_ch_buf = base;
1527 b->yy_is_our_buffer = 0;
1528 b->yy_input_file = 0;
1529 b->yy_n_chars = b->yy_buf_size;
1530 b->yy_is_interactive = 0;
1531 b->yy_at_bol = 1;
1532 b->yy_fill_buffer = 0;
1533 b->yy_buffer_status = YY_BUFFER_NEW;
1534
1535 yy_switch_to_buffer(b );
1536
1537 return b;
1538 }
1539
1540 /** Setup the input buffer state to scan a string. The next call to yylex() will
1541 * scan from a @e copy of @a str.
1542 * @param str a NUL-terminated string to scan
1543 *
1544 * @return the newly allocated buffer state object.
1545 * @note If you want to scan bytes that may contain NUL values, then use
1546 * yy_scan_bytes() instead.
1547 */
yy_scan_string(yyconst char * yy_str)1548 YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str )
1549 {
1550
1551 return yy_scan_bytes(yy_str,strlen(yy_str) );
1552 }
1553
1554 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1555 * scan from a @e copy of @a bytes.
1556 * @param bytes the byte buffer to scan
1557 * @param len the number of bytes in the buffer pointed to by @a bytes.
1558 *
1559 * @return the newly allocated buffer state object.
1560 */
yy_scan_bytes(yyconst char * bytes,int len)1561 YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len )
1562 {
1563 YY_BUFFER_STATE b;
1564 char *buf;
1565 yy_size_t n;
1566 int i;
1567
1568 /* Get memory for full buffer, including space for trailing EOB's. */
1569 n = len + 2;
1570 buf = (char *) yyalloc(n );
1571 if ( ! buf )
1572 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1573
1574 for ( i = 0; i < len; ++i )
1575 buf[i] = bytes[i];
1576
1577 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1578
1579 b = yy_scan_buffer(buf,n );
1580 if ( ! b )
1581 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1582
1583 /* It's okay to grow etc. this buffer, and we should throw it
1584 * away when we're done.
1585 */
1586 b->yy_is_our_buffer = 1;
1587
1588 return b;
1589 }
1590
1591 #ifndef YY_EXIT_FAILURE
1592 #define YY_EXIT_FAILURE 2
1593 #endif
1594
yy_fatal_error(yyconst char * msg)1595 static void yy_fatal_error (yyconst char* msg )
1596 {
1597 (void) fprintf( stderr, "%s\n", msg );
1598 exit( YY_EXIT_FAILURE );
1599 }
1600
1601 /* Redefine yyless() so it works in section 3 code. */
1602
1603 #undef yyless
1604 #define yyless(n) \
1605 do \
1606 { \
1607 /* Undo effects of setting up yytext. */ \
1608 int yyless_macro_arg = (n); \
1609 YY_LESS_LINENO(yyless_macro_arg);\
1610 yytext[yyleng] = (yy_hold_char); \
1611 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1612 (yy_hold_char) = *(yy_c_buf_p); \
1613 *(yy_c_buf_p) = '\0'; \
1614 yyleng = yyless_macro_arg; \
1615 } \
1616 while ( 0 )
1617
1618 /* Accessor methods (get/set functions) to struct members. */
1619
1620 /** Get the current line number.
1621 *
1622 */
yyget_lineno(void)1623 int yyget_lineno (void)
1624 {
1625
1626 return yylineno;
1627 }
1628
1629 /** Get the input stream.
1630 *
1631 */
yyget_in(void)1632 FILE *yyget_in (void)
1633 {
1634 return yyin;
1635 }
1636
1637 /** Get the output stream.
1638 *
1639 */
yyget_out(void)1640 FILE *yyget_out (void)
1641 {
1642 return yyout;
1643 }
1644
1645 /** Get the length of the current token.
1646 *
1647 */
yyget_leng(void)1648 int yyget_leng (void)
1649 {
1650 return yyleng;
1651 }
1652
1653 /** Get the current token.
1654 *
1655 */
1656
yyget_text(void)1657 char *yyget_text (void)
1658 {
1659 return yytext;
1660 }
1661
1662 /** Set the current line number.
1663 * @param line_number
1664 *
1665 */
yyset_lineno(int line_number)1666 void yyset_lineno (int line_number )
1667 {
1668
1669 yylineno = line_number;
1670 }
1671
1672 /** Set the input stream. This does not discard the current
1673 * input buffer.
1674 * @param in_str A readable stream.
1675 *
1676 * @see yy_switch_to_buffer
1677 */
yyset_in(FILE * in_str)1678 void yyset_in (FILE * in_str )
1679 {
1680 yyin = in_str ;
1681 }
1682
yyset_out(FILE * out_str)1683 void yyset_out (FILE * out_str )
1684 {
1685 yyout = out_str ;
1686 }
1687
yyget_debug(void)1688 int yyget_debug (void)
1689 {
1690 return yy_flex_debug;
1691 }
1692
yyset_debug(int bdebug)1693 void yyset_debug (int bdebug )
1694 {
1695 yy_flex_debug = bdebug ;
1696 }
1697
1698 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
yylex_destroy(void)1699 int yylex_destroy (void)
1700 {
1701
1702 /* Pop the buffer stack, destroying each element. */
1703 while(YY_CURRENT_BUFFER){
1704 yy_delete_buffer(YY_CURRENT_BUFFER );
1705 YY_CURRENT_BUFFER_LVALUE = NULL;
1706 yypop_buffer_state();
1707 }
1708
1709 /* Destroy the stack itself. */
1710 yyfree((yy_buffer_stack) );
1711 (yy_buffer_stack) = NULL;
1712
1713 return 0;
1714 }
1715
1716 /*
1717 * Internal utility routines.
1718 */
1719
1720 #ifndef yytext_ptr
yy_flex_strncpy(char * s1,yyconst char * s2,int n)1721 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1722 {
1723 register int i;
1724 for ( i = 0; i < n; ++i )
1725 s1[i] = s2[i];
1726 }
1727 #endif
1728
1729 #ifdef YY_NEED_STRLEN
yy_flex_strlen(yyconst char * s)1730 static int yy_flex_strlen (yyconst char * s )
1731 {
1732 register int n;
1733 for ( n = 0; s[n]; ++n )
1734 ;
1735
1736 return n;
1737 }
1738 #endif
1739
yyalloc(yy_size_t size)1740 void *yyalloc (yy_size_t size )
1741 {
1742 return (void *) malloc( size );
1743 }
1744
yyrealloc(void * ptr,yy_size_t size)1745 void *yyrealloc (void * ptr, yy_size_t size )
1746 {
1747 /* The cast to (char *) in the following accommodates both
1748 * implementations that use char* generic pointers, and those
1749 * that use void* generic pointers. It works with the latter
1750 * because both ANSI C and C++ allow castless assignment from
1751 * any pointer type to void*, and deal with argument conversions
1752 * as though doing an assignment.
1753 */
1754 return (void *) realloc( (char *) ptr, size );
1755 }
1756
yyfree(void * ptr)1757 void yyfree (void * ptr )
1758 {
1759 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1760 }
1761
1762 #define YYTABLES_NAME "yytables"
1763
1764 #undef YY_NEW_FILE
1765 #undef YY_FLUSH_BUFFER
1766 #undef yy_set_bol
1767 #undef yy_new_buffer
1768 #undef yy_set_interactive
1769 #undef yytext_ptr
1770 #undef YY_DO_BEFORE_ACTION
1771
1772 #ifdef YY_DECL_IS_OURS
1773 #undef YY_DECL_IS_OURS
1774 #undef YY_DECL
1775 #endif
1776 #line 80 "conf/tokens.l"
1777
1778
1779
yywrap(void)1780 int yywrap (void)
1781 {
1782 return 1;
1783 }
1784
1785