Annotation of embedaddon/strongswan/src/starter/parser/lexer.c, revision 1.1.1.1
1.1 misho 1: #line 2 "parser/lexer.c"
2:
3: #line 4 "parser/lexer.c"
4:
5: #define YY_INT_ALIGNED short int
6:
7: /* A lexical scanner generated by flex */
8:
9: /* %not-for-header */
10: /* %if-c-only */
11: /* %if-not-reentrant */
12: /* %endif */
13: /* %endif */
14: /* %ok-for-header */
15:
16: #define FLEX_SCANNER
17: #define YY_FLEX_MAJOR_VERSION 2
18: #define YY_FLEX_MINOR_VERSION 6
19: #define YY_FLEX_SUBMINOR_VERSION 4
20: #if YY_FLEX_SUBMINOR_VERSION > 0
21: #define FLEX_BETA
22: #endif
23:
24: /* %if-c++-only */
25: /* %endif */
26:
27: /* %if-c-only */
28: #ifdef yy_create_buffer
29: #define conf_parser__create_buffer_ALREADY_DEFINED
30: #else
31: #define yy_create_buffer conf_parser__create_buffer
32: #endif
33:
34: #ifdef yy_delete_buffer
35: #define conf_parser__delete_buffer_ALREADY_DEFINED
36: #else
37: #define yy_delete_buffer conf_parser__delete_buffer
38: #endif
39:
40: #ifdef yy_scan_buffer
41: #define conf_parser__scan_buffer_ALREADY_DEFINED
42: #else
43: #define yy_scan_buffer conf_parser__scan_buffer
44: #endif
45:
46: #ifdef yy_scan_string
47: #define conf_parser__scan_string_ALREADY_DEFINED
48: #else
49: #define yy_scan_string conf_parser__scan_string
50: #endif
51:
52: #ifdef yy_scan_bytes
53: #define conf_parser__scan_bytes_ALREADY_DEFINED
54: #else
55: #define yy_scan_bytes conf_parser__scan_bytes
56: #endif
57:
58: #ifdef yy_init_buffer
59: #define conf_parser__init_buffer_ALREADY_DEFINED
60: #else
61: #define yy_init_buffer conf_parser__init_buffer
62: #endif
63:
64: #ifdef yy_flush_buffer
65: #define conf_parser__flush_buffer_ALREADY_DEFINED
66: #else
67: #define yy_flush_buffer conf_parser__flush_buffer
68: #endif
69:
70: #ifdef yy_load_buffer_state
71: #define conf_parser__load_buffer_state_ALREADY_DEFINED
72: #else
73: #define yy_load_buffer_state conf_parser__load_buffer_state
74: #endif
75:
76: #ifdef yy_switch_to_buffer
77: #define conf_parser__switch_to_buffer_ALREADY_DEFINED
78: #else
79: #define yy_switch_to_buffer conf_parser__switch_to_buffer
80: #endif
81:
82: #ifdef yypush_buffer_state
83: #define conf_parser_push_buffer_state_ALREADY_DEFINED
84: #else
85: #define yypush_buffer_state conf_parser_push_buffer_state
86: #endif
87:
88: #ifdef yypop_buffer_state
89: #define conf_parser_pop_buffer_state_ALREADY_DEFINED
90: #else
91: #define yypop_buffer_state conf_parser_pop_buffer_state
92: #endif
93:
94: #ifdef yyensure_buffer_stack
95: #define conf_parser_ensure_buffer_stack_ALREADY_DEFINED
96: #else
97: #define yyensure_buffer_stack conf_parser_ensure_buffer_stack
98: #endif
99:
100: #ifdef yylex
101: #define conf_parser_lex_ALREADY_DEFINED
102: #else
103: #define yylex conf_parser_lex
104: #endif
105:
106: #ifdef yyrestart
107: #define conf_parser_restart_ALREADY_DEFINED
108: #else
109: #define yyrestart conf_parser_restart
110: #endif
111:
112: #ifdef yylex_init
113: #define conf_parser_lex_init_ALREADY_DEFINED
114: #else
115: #define yylex_init conf_parser_lex_init
116: #endif
117:
118: #ifdef yylex_init_extra
119: #define conf_parser_lex_init_extra_ALREADY_DEFINED
120: #else
121: #define yylex_init_extra conf_parser_lex_init_extra
122: #endif
123:
124: #ifdef yylex_destroy
125: #define conf_parser_lex_destroy_ALREADY_DEFINED
126: #else
127: #define yylex_destroy conf_parser_lex_destroy
128: #endif
129:
130: #ifdef yyget_debug
131: #define conf_parser_get_debug_ALREADY_DEFINED
132: #else
133: #define yyget_debug conf_parser_get_debug
134: #endif
135:
136: #ifdef yyset_debug
137: #define conf_parser_set_debug_ALREADY_DEFINED
138: #else
139: #define yyset_debug conf_parser_set_debug
140: #endif
141:
142: #ifdef yyget_extra
143: #define conf_parser_get_extra_ALREADY_DEFINED
144: #else
145: #define yyget_extra conf_parser_get_extra
146: #endif
147:
148: #ifdef yyset_extra
149: #define conf_parser_set_extra_ALREADY_DEFINED
150: #else
151: #define yyset_extra conf_parser_set_extra
152: #endif
153:
154: #ifdef yyget_in
155: #define conf_parser_get_in_ALREADY_DEFINED
156: #else
157: #define yyget_in conf_parser_get_in
158: #endif
159:
160: #ifdef yyset_in
161: #define conf_parser_set_in_ALREADY_DEFINED
162: #else
163: #define yyset_in conf_parser_set_in
164: #endif
165:
166: #ifdef yyget_out
167: #define conf_parser_get_out_ALREADY_DEFINED
168: #else
169: #define yyget_out conf_parser_get_out
170: #endif
171:
172: #ifdef yyset_out
173: #define conf_parser_set_out_ALREADY_DEFINED
174: #else
175: #define yyset_out conf_parser_set_out
176: #endif
177:
178: #ifdef yyget_leng
179: #define conf_parser_get_leng_ALREADY_DEFINED
180: #else
181: #define yyget_leng conf_parser_get_leng
182: #endif
183:
184: #ifdef yyget_text
185: #define conf_parser_get_text_ALREADY_DEFINED
186: #else
187: #define yyget_text conf_parser_get_text
188: #endif
189:
190: #ifdef yyget_lineno
191: #define conf_parser_get_lineno_ALREADY_DEFINED
192: #else
193: #define yyget_lineno conf_parser_get_lineno
194: #endif
195:
196: #ifdef yyset_lineno
197: #define conf_parser_set_lineno_ALREADY_DEFINED
198: #else
199: #define yyset_lineno conf_parser_set_lineno
200: #endif
201:
202: #ifdef yyget_column
203: #define conf_parser_get_column_ALREADY_DEFINED
204: #else
205: #define yyget_column conf_parser_get_column
206: #endif
207:
208: #ifdef yyset_column
209: #define conf_parser_set_column_ALREADY_DEFINED
210: #else
211: #define yyset_column conf_parser_set_column
212: #endif
213:
214: #ifdef yywrap
215: #define conf_parser_wrap_ALREADY_DEFINED
216: #else
217: #define yywrap conf_parser_wrap
218: #endif
219:
220: /* %endif */
221:
222: #ifdef yyget_lval
223: #define conf_parser_get_lval_ALREADY_DEFINED
224: #else
225: #define yyget_lval conf_parser_get_lval
226: #endif
227:
228: #ifdef yyset_lval
229: #define conf_parser_set_lval_ALREADY_DEFINED
230: #else
231: #define yyset_lval conf_parser_set_lval
232: #endif
233:
234: #ifdef yyalloc
235: #define conf_parser_alloc_ALREADY_DEFINED
236: #else
237: #define yyalloc conf_parser_alloc
238: #endif
239:
240: #ifdef yyrealloc
241: #define conf_parser_realloc_ALREADY_DEFINED
242: #else
243: #define yyrealloc conf_parser_realloc
244: #endif
245:
246: #ifdef yyfree
247: #define conf_parser_free_ALREADY_DEFINED
248: #else
249: #define yyfree conf_parser_free
250: #endif
251:
252: /* %if-c-only */
253:
254: /* %endif */
255:
256: /* First, we deal with platform-specific or compiler-specific issues. */
257:
258: /* begin standard C headers. */
259: /* %if-c-only */
260: #include <stdio.h>
261: #include <string.h>
262: #include <errno.h>
263: #include <stdlib.h>
264: /* %endif */
265:
266: /* %if-tables-serialization */
267: /* %endif */
268: /* end standard C headers. */
269:
270: /* %if-c-or-c++ */
271: /* flex integer type definitions */
272:
273: #ifndef FLEXINT_H
274: #define FLEXINT_H
275:
276: /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
277:
278: #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
279:
280: /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
281: * if you want the limit (max/min) macros for int types.
282: */
283: #ifndef __STDC_LIMIT_MACROS
284: #define __STDC_LIMIT_MACROS 1
285: #endif
286:
287: #include <inttypes.h>
288: typedef int8_t flex_int8_t;
289: typedef uint8_t flex_uint8_t;
290: typedef int16_t flex_int16_t;
291: typedef uint16_t flex_uint16_t;
292: typedef int32_t flex_int32_t;
293: typedef uint32_t flex_uint32_t;
294: #else
295: typedef signed char flex_int8_t;
296: typedef short int flex_int16_t;
297: typedef int flex_int32_t;
298: typedef unsigned char flex_uint8_t;
299: typedef unsigned short int flex_uint16_t;
300: typedef unsigned int flex_uint32_t;
301:
302: /* Limits of integral types. */
303: #ifndef INT8_MIN
304: #define INT8_MIN (-128)
305: #endif
306: #ifndef INT16_MIN
307: #define INT16_MIN (-32767-1)
308: #endif
309: #ifndef INT32_MIN
310: #define INT32_MIN (-2147483647-1)
311: #endif
312: #ifndef INT8_MAX
313: #define INT8_MAX (127)
314: #endif
315: #ifndef INT16_MAX
316: #define INT16_MAX (32767)
317: #endif
318: #ifndef INT32_MAX
319: #define INT32_MAX (2147483647)
320: #endif
321: #ifndef UINT8_MAX
322: #define UINT8_MAX (255U)
323: #endif
324: #ifndef UINT16_MAX
325: #define UINT16_MAX (65535U)
326: #endif
327: #ifndef UINT32_MAX
328: #define UINT32_MAX (4294967295U)
329: #endif
330:
331: #ifndef SIZE_MAX
332: #define SIZE_MAX (~(size_t)0)
333: #endif
334:
335: #endif /* ! C99 */
336:
337: #endif /* ! FLEXINT_H */
338:
339: /* %endif */
340:
341: /* begin standard C++ headers. */
342: /* %if-c++-only */
343: /* %endif */
344:
345: /* TODO: this is always defined, so inline it */
346: #define yyconst const
347:
348: #if defined(__GNUC__) && __GNUC__ >= 3
349: #define yynoreturn __attribute__((__noreturn__))
350: #else
351: #define yynoreturn
352: #endif
353:
354: /* %not-for-header */
355: /* Returned upon end-of-file. */
356: #define YY_NULL 0
357: /* %ok-for-header */
358:
359: /* %not-for-header */
360: /* Promotes a possibly negative, possibly signed char to an
361: * integer in range [0..255] for use as an array index.
362: */
363: #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
364: /* %ok-for-header */
365:
366: /* %if-reentrant */
367:
368: /* An opaque pointer. */
369: #ifndef YY_TYPEDEF_YY_SCANNER_T
370: #define YY_TYPEDEF_YY_SCANNER_T
371: typedef void* yyscan_t;
372: #endif
373:
374: /* For convenience, these vars (plus the bison vars far below)
375: are macros in the reentrant scanner. */
376: #define yyin yyg->yyin_r
377: #define yyout yyg->yyout_r
378: #define yyextra yyg->yyextra_r
379: #define yyleng yyg->yyleng_r
380: #define yytext yyg->yytext_r
381: #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
382: #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
383: #define yy_flex_debug yyg->yy_flex_debug_r
384:
385: /* %endif */
386:
387: /* %if-not-reentrant */
388: /* %endif */
389:
390: /* Enter a start condition. This macro really ought to take a parameter,
391: * but we do it the disgusting crufty way forced on us by the ()-less
392: * definition of BEGIN.
393: */
394: #define BEGIN yyg->yy_start = 1 + 2 *
395: /* Translate the current start state into a value that can be later handed
396: * to BEGIN to return to the state. The YYSTATE alias is for lex
397: * compatibility.
398: */
399: #define YY_START ((yyg->yy_start - 1) / 2)
400: #define YYSTATE YY_START
401: /* Action number for EOF rule of a given start state. */
402: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
403: /* Special action meaning "start processing a new file". */
404: #define YY_NEW_FILE yyrestart( yyin , yyscanner )
405: #define YY_END_OF_BUFFER_CHAR 0
406:
407: /* Size of default input buffer. */
408: #ifndef YY_BUF_SIZE
409: #ifdef __ia64__
410: /* On IA-64, the buffer size is 16k, not 8k.
411: * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
412: * Ditto for the __ia64__ case accordingly.
413: */
414: #define YY_BUF_SIZE 32768
415: #else
416: #define YY_BUF_SIZE 16384
417: #endif /* __ia64__ */
418: #endif
419:
420: /* The state buf must be large enough to hold one state per character in the main buffer.
421: */
422: #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
423:
424: #ifndef YY_TYPEDEF_YY_BUFFER_STATE
425: #define YY_TYPEDEF_YY_BUFFER_STATE
426: typedef struct yy_buffer_state *YY_BUFFER_STATE;
427: #endif
428:
429: #ifndef YY_TYPEDEF_YY_SIZE_T
430: #define YY_TYPEDEF_YY_SIZE_T
431: typedef size_t yy_size_t;
432: #endif
433:
434: /* %if-not-reentrant */
435: /* %endif */
436:
437: /* %if-c-only */
438: /* %if-not-reentrant */
439: /* %endif */
440: /* %endif */
441:
442: #define EOB_ACT_CONTINUE_SCAN 0
443: #define EOB_ACT_END_OF_FILE 1
444: #define EOB_ACT_LAST_MATCH 2
445:
446: /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
447: * access to the local variable yy_act. Since yyless() is a macro, it would break
448: * existing scanners that call yyless() from OUTSIDE yylex.
449: * One obvious solution it to make yy_act a global. I tried that, and saw
450: * a 5% performance hit in a non-yylineno scanner, because yy_act is
451: * normally declared as a register variable-- so it is not worth it.
452: */
453: #define YY_LESS_LINENO(n) \
454: do { \
455: int yyl;\
456: for ( yyl = n; yyl < yyleng; ++yyl )\
457: if ( yytext[yyl] == '\n' )\
458: --yylineno;\
459: }while(0)
460: #define YY_LINENO_REWIND_TO(dst) \
461: do {\
462: const char *p;\
463: for ( p = yy_cp-1; p >= (dst); --p)\
464: if ( *p == '\n' )\
465: --yylineno;\
466: }while(0)
467:
468: /* Return all but the first "n" matched characters back to the input stream. */
469: #define yyless(n) \
470: do \
471: { \
472: /* Undo effects of setting up yytext. */ \
473: int yyless_macro_arg = (n); \
474: YY_LESS_LINENO(yyless_macro_arg);\
475: *yy_cp = yyg->yy_hold_char; \
476: YY_RESTORE_YY_MORE_OFFSET \
477: yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
478: YY_DO_BEFORE_ACTION; /* set up yytext again */ \
479: } \
480: while ( 0 )
481: #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
482:
483: #ifndef YY_STRUCT_YY_BUFFER_STATE
484: #define YY_STRUCT_YY_BUFFER_STATE
485: struct yy_buffer_state
486: {
487: /* %if-c-only */
488: FILE *yy_input_file;
489: /* %endif */
490:
491: /* %if-c++-only */
492: /* %endif */
493:
494: char *yy_ch_buf; /* input buffer */
495: char *yy_buf_pos; /* current position in input buffer */
496:
497: /* Size of input buffer in bytes, not including room for EOB
498: * characters.
499: */
500: int yy_buf_size;
501:
502: /* Number of characters read into yy_ch_buf, not including EOB
503: * characters.
504: */
505: int yy_n_chars;
506:
507: /* Whether we "own" the buffer - i.e., we know we created it,
508: * and can realloc() it to grow it, and should free() it to
509: * delete it.
510: */
511: int yy_is_our_buffer;
512:
513: /* Whether this is an "interactive" input source; if so, and
514: * if we're using stdio for input, then we want to use getc()
515: * instead of fread(), to make sure we stop fetching input after
516: * each newline.
517: */
518: int yy_is_interactive;
519:
520: /* Whether we're considered to be at the beginning of a line.
521: * If so, '^' rules will be active on the next match, otherwise
522: * not.
523: */
524: int yy_at_bol;
525:
526: int yy_bs_lineno; /**< The line count. */
527: int yy_bs_column; /**< The column count. */
528:
529: /* Whether to try to fill the input buffer when we reach the
530: * end of it.
531: */
532: int yy_fill_buffer;
533:
534: int yy_buffer_status;
535:
536: #define YY_BUFFER_NEW 0
537: #define YY_BUFFER_NORMAL 1
538: /* When an EOF's been seen but there's still some text to process
539: * then we mark the buffer as YY_EOF_PENDING, to indicate that we
540: * shouldn't try reading from the input source any more. We might
541: * still have a bunch of tokens to match, though, because of
542: * possible backing-up.
543: *
544: * When we actually see the EOF, we change the status to "new"
545: * (via yyrestart()), so that the user can continue scanning by
546: * just pointing yyin at a new input file.
547: */
548: #define YY_BUFFER_EOF_PENDING 2
549:
550: };
551: #endif /* !YY_STRUCT_YY_BUFFER_STATE */
552:
553: /* %if-c-only Standard (non-C++) definition */
554: /* %not-for-header */
555: /* %if-not-reentrant */
556: /* %endif */
557: /* %ok-for-header */
558:
559: /* %endif */
560:
561: /* We provide macros for accessing buffer states in case in the
562: * future we want to put the buffer states in a more general
563: * "scanner state".
564: *
565: * Returns the top of the stack, or NULL.
566: */
567: #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
568: ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
569: : NULL)
570: /* Same as previous macro, but useful when we know that the buffer stack is not
571: * NULL or when we need an lvalue. For internal use only.
572: */
573: #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
574:
575: /* %if-c-only Standard (non-C++) definition */
576:
577: /* %if-not-reentrant */
578: /* %not-for-header */
579: /* %ok-for-header */
580:
581: /* %endif */
582:
583: void yyrestart ( FILE *input_file , yyscan_t yyscanner );
584: void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
585: YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
586: void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
587: void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
588: void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
589: void yypop_buffer_state ( yyscan_t yyscanner );
590:
591: static void yyensure_buffer_stack ( yyscan_t yyscanner );
592: static void yy_load_buffer_state ( yyscan_t yyscanner );
593: static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
594: #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
595:
596: YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
597: YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
598: YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
599:
600: /* %endif */
601:
602: void *yyalloc ( yy_size_t , yyscan_t yyscanner );
603: void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
604: void yyfree ( void * , yyscan_t yyscanner );
605:
606: #define yy_new_buffer yy_create_buffer
607: #define yy_set_interactive(is_interactive) \
608: { \
609: if ( ! YY_CURRENT_BUFFER ){ \
610: yyensure_buffer_stack (yyscanner); \
611: YY_CURRENT_BUFFER_LVALUE = \
612: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
613: } \
614: YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
615: }
616: #define yy_set_bol(at_bol) \
617: { \
618: if ( ! YY_CURRENT_BUFFER ){\
619: yyensure_buffer_stack (yyscanner); \
620: YY_CURRENT_BUFFER_LVALUE = \
621: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
622: } \
623: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
624: }
625: #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
626:
627: /* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
628: /* Begin user sect3 */
629:
630: #define conf_parser_wrap(yyscanner) (/*CONSTCOND*/1)
631: #define YY_SKIP_YYWRAP
632:
633: #define FLEX_DEBUG
634: typedef flex_uint8_t YY_CHAR;
635:
636: typedef int yy_state_type;
637:
638: #define yytext_ptr yytext_r
639:
640: /* %% [1.5] DFA */
641:
642: /* %if-c-only Standard (non-C++) definition */
643:
644: static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
645: static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
646: static int yy_get_next_buffer ( yyscan_t yyscanner );
647: static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
648:
649: /* %endif */
650:
651: /* Done after the current pattern has been matched and before the
652: * corresponding action - sets up yytext.
653: */
654: #define YY_DO_BEFORE_ACTION \
655: yyg->yytext_ptr = yy_bp; \
656: /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
657: yyleng = (int) (yy_cp - yy_bp); \
658: yyg->yy_hold_char = *yy_cp; \
659: *yy_cp = '\0'; \
660: /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
661: yyg->yy_c_buf_p = yy_cp;
662: /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
663: #define YY_NUM_RULES 26
664: #define YY_END_OF_BUFFER 27
665: /* This struct is not used in this scanner,
666: but its presence is necessary. */
667: struct yy_trans_info
668: {
669: flex_int32_t yy_verify;
670: flex_int32_t yy_nxt;
671: };
672: static const flex_int16_t yy_accept[80] =
673: { 0,
674: 0, 0, 0, 0, 0, 0, 27, 12, 3, 5,
675: 11, 4, 6, 12, 12, 2, 12, 12, 17, 13,
676: 14, 15, 25, 18, 19, 12, 3, 4, 4, 0,
677: 12, 2, 0, 9, 12, 12, 17, 16, 25, 24,
678: 23, 24, 20, 21, 22, 12, 0, 12, 12, 12,
679: 0, 12, 8, 12, 12, 0, 12, 12, 12, 0,
680: 12, 12, 12, 0, 0, 12, 0, 0, 0, 12,
681: 0, 1, 10, 10, 0, 0, 0, 7, 0
682: } ;
683:
684: static const YY_CHAR yy_ec[256] =
685: { 0,
686: 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
687: 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
688: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
689: 1, 5, 1, 6, 7, 1, 1, 1, 1, 1,
690: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
691: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
692: 8, 1, 1, 9, 1, 1, 1, 1, 1, 1,
693: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
695: 1, 10, 1, 1, 1, 1, 11, 1, 12, 13,
696:
697: 14, 15, 16, 1, 17, 1, 1, 18, 1, 19,
698: 20, 21, 1, 22, 23, 24, 25, 26, 1, 1,
699: 1, 1, 1, 1, 27, 1, 1, 1, 1, 1,
700: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
701: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
702: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
703: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
704: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
705: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
706: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
707:
708: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
709: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
710: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
711: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
712: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
713: 1, 1, 1, 1, 1
714: } ;
715:
716: static const YY_CHAR yy_meta[28] =
717: { 0,
718: 1, 2, 3, 1, 2, 4, 2, 5, 1, 6,
719: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
720: 1, 1, 1, 1, 1, 1, 1
721: } ;
722:
723: static const flex_int16_t yy_base[91] =
724: { 0,
725: 0, 16, 41, 50, 4, 5, 101, 0, 24, 184,
726: 184, 0, 184, 92, 79, 32, 16, 83, 0, 184,
727: 184, 56, 0, 184, 81, 0, 33, 0, 0, 0,
728: 84, 62, 81, 0, 75, 71, 0, 184, 0, 184,
729: 184, 89, 184, 184, 184, 73, 68, 1, 66, 62,
730: 63, 65, 0, 64, 67, 62, 62, 57, 62, 55,
731: 67, 47, 63, 40, 31, 104, 68, 47, 35, 111,
732: 42, 184, 184, 69, 17, 7, 9, 184, 184, 119,
733: 125, 131, 137, 143, 149, 154, 159, 165, 171, 177
734: } ;
735:
736: static const flex_int16_t yy_def[91] =
737: { 0,
738: 80, 80, 81, 81, 82, 82, 79, 83, 79, 79,
739: 79, 84, 79, 83, 83, 79, 83, 83, 85, 79,
740: 79, 79, 86, 79, 87, 83, 79, 84, 84, 83,
741: 83, 79, 79, 83, 83, 83, 85, 79, 86, 79,
742: 79, 79, 79, 79, 79, 83, 79, 83, 83, 83,
743: 79, 83, 83, 83, 83, 79, 83, 83, 83, 79,
744: 83, 83, 83, 79, 79, 88, 89, 90, 79, 88,
745: 90, 79, 79, 89, 79, 79, 79, 79, 0, 79,
746: 79, 79, 79, 79, 79, 79, 79, 79, 79, 79
747: } ;
748:
749: static const flex_int16_t yy_nxt[212] =
750: { 0,
751: 79, 9, 10, 79, 9, 11, 12, 13, 14, 24,
752: 24, 79, 79, 25, 25, 52, 15, 16, 10, 53,
753: 16, 11, 12, 13, 14, 27, 34, 17, 27, 78,
754: 28, 77, 15, 32, 27, 35, 32, 27, 28, 28,
755: 76, 18, 20, 20, 72, 20, 21, 20, 75, 72,
756: 22, 20, 20, 69, 20, 21, 20, 33, 68, 22,
757: 38, 38, 38, 32, 67, 66, 32, 67, 28, 74,
758: 74, 65, 74, 74, 64, 63, 62, 61, 60, 59,
759: 58, 57, 38, 41, 42, 56, 55, 33, 54, 51,
760: 50, 41, 49, 48, 47, 46, 36, 31, 30, 43,
761:
762: 79, 79, 44, 79, 45, 71, 72, 79, 71, 71,
763: 71, 71, 71, 72, 79, 71, 71, 71, 71, 8,
764: 8, 8, 8, 8, 8, 19, 19, 19, 19, 19,
765: 19, 23, 23, 23, 23, 23, 23, 26, 79, 79,
766: 79, 79, 26, 29, 29, 79, 29, 29, 29, 37,
767: 79, 79, 79, 37, 39, 39, 39, 79, 39, 40,
768: 40, 40, 40, 40, 40, 70, 70, 70, 70, 70,
769: 70, 73, 73, 73, 73, 79, 73, 71, 71, 71,
770: 71, 71, 71, 7, 79, 79, 79, 79, 79, 79,
771: 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
772:
773: 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
774: 79
775: } ;
776:
777: static const flex_int16_t yy_chk[212] =
778: { 0,
779: 0, 1, 1, 0, 1, 1, 1, 1, 1, 5,
780: 6, 0, 0, 5, 6, 48, 1, 2, 2, 48,
781: 2, 2, 2, 2, 2, 9, 17, 2, 9, 77,
782: 9, 76, 2, 16, 27, 17, 16, 27, 16, 27,
783: 75, 2, 3, 3, 71, 3, 3, 3, 69, 68,
784: 3, 4, 4, 65, 4, 4, 4, 16, 64, 4,
785: 22, 22, 22, 32, 63, 62, 32, 63, 32, 67,
786: 74, 61, 67, 74, 60, 59, 58, 57, 56, 55,
787: 54, 52, 22, 25, 25, 51, 50, 32, 49, 47,
788: 46, 42, 36, 35, 33, 31, 18, 15, 14, 25,
789:
790: 7, 0, 25, 0, 25, 66, 66, 0, 66, 66,
791: 66, 66, 70, 70, 0, 70, 70, 70, 70, 80,
792: 80, 80, 80, 80, 80, 81, 81, 81, 81, 81,
793: 81, 82, 82, 82, 82, 82, 82, 83, 0, 0,
794: 0, 0, 83, 84, 84, 0, 84, 84, 84, 85,
795: 0, 0, 0, 85, 86, 86, 86, 0, 86, 87,
796: 87, 87, 87, 87, 87, 88, 88, 88, 88, 88,
797: 88, 89, 89, 89, 89, 0, 89, 90, 90, 90,
798: 90, 90, 90, 79, 79, 79, 79, 79, 79, 79,
799: 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
800:
801: 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
802: 79
803: } ;
804:
805: /* Table of booleans, true if rule could match eol. */
806: static const flex_int32_t yy_rule_can_match_eol[27] =
807: { 0,
808: 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
809: 0, 0, 0, 1, 0, 1, 0, };
810:
811: static const flex_int16_t yy_rule_linenum[26] =
812: { 0,
813: 65, 66, 67, 68, 70, 72, 73, 74, 75, 77,
814: 82, 87, 95, 114, 117, 120, 123, 129, 131, 150,
815: 151, 152, 153, 154, 155
816: } ;
817:
818: /* The intent behind this definition is that it'll catch
819: * any uses of REJECT which flex missed.
820: */
821: #define REJECT reject_used_but_not_detected
822: #define yymore() yymore_used_but_not_detected
823: #define YY_MORE_ADJ 0
824: #define YY_RESTORE_YY_MORE_OFFSET
825: #line 1 "parser/lexer.l"
826: #line 2 "parser/lexer.l"
827: /*
828: * Copyright (C) 2013-2014 Tobias Brunner
829: * HSR Hochschule fuer Technik Rapperswil
830: *
831: * This program is free software; you can redistribute it and/or modify it
832: * under the terms of the GNU General Public License as published by the
833: * Free Software Foundation; either version 2 of the License, or (at your
834: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
835: *
836: * This program is distributed in the hope that it will be useful, but
837: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
838: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
839: * for more details.
840: */
841:
842: #include <utils/parser_helper.h>
843: #include <parser/conf_parser.h>
844:
845: #include "parser.h"
846:
847: bool conf_parser_open_next_file(parser_helper_t *ctx);
848:
849: static void include_files(parser_helper_t *ctx);
850:
851: #line 852 "parser/lexer.c"
852: /* use start conditions stack */
853: /* do not declare unneeded functions */
854: #define YY_NO_INPUT 1
855: /* do not include unistd.h as it might conflict with our scanner states */
856: #define YY_NO_UNISTD_H 1
857: /* due to that disable interactive mode, which requires isatty() */
858: /* don't use global variables, and interact properly with bison */
859: /* maintain the line number */
860: /* don't generate a default rule */
861: /* prefix function/variable declarations */
862: /* don't change the name of the output file otherwise autotools has issues */
863: /* type of our extra data */
864: /* state used to scan include file patterns */
865:
866: /* state used to scan quoted strings */
867:
868: #line 869 "parser/lexer.c"
869:
870: #define INITIAL 0
871: #define inc 1
872: #define str 2
873:
874: #ifndef YY_NO_UNISTD_H
875: /* Special case for "unistd.h", since it is non-ANSI. We include it way
876: * down here because we want the user's section 1 to have been scanned first.
877: * The user has a chance to override it with an option.
878: */
879: /* %if-c-only */
880: #include <unistd.h>
881: /* %endif */
882: /* %if-c++-only */
883: /* %endif */
884: #endif
885:
886: #define YY_EXTRA_TYPE parser_helper_t*
887:
888: /* %if-c-only Reentrant structure and macros (non-C++). */
889: /* %if-reentrant */
890:
891: /* Holds the entire state of the reentrant scanner. */
892: struct yyguts_t
893: {
894:
895: /* User-defined. Not touched by flex. */
896: YY_EXTRA_TYPE yyextra_r;
897:
898: /* The rest are the same as the globals declared in the non-reentrant scanner. */
899: FILE *yyin_r, *yyout_r;
900: size_t yy_buffer_stack_top; /**< index of top of stack. */
901: size_t yy_buffer_stack_max; /**< capacity of stack. */
902: YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
903: char yy_hold_char;
904: int yy_n_chars;
905: int yyleng_r;
906: char *yy_c_buf_p;
907: int yy_init;
908: int yy_start;
909: int yy_did_buffer_switch_on_eof;
910: int yy_start_stack_ptr;
911: int yy_start_stack_depth;
912: int *yy_start_stack;
913: yy_state_type yy_last_accepting_state;
914: char* yy_last_accepting_cpos;
915:
916: int yylineno_r;
917: int yy_flex_debug_r;
918:
919: char *yytext_r;
920: int yy_more_flag;
921: int yy_more_len;
922:
923: YYSTYPE * yylval_r;
924:
925: }; /* end struct yyguts_t */
926:
927: /* %if-c-only */
928:
929: static int yy_init_globals ( yyscan_t yyscanner );
930:
931: /* %endif */
932:
933: /* %if-reentrant */
934:
935: /* This must go here because YYSTYPE and YYLTYPE are included
936: * from bison output in section 1.*/
937: # define yylval yyg->yylval_r
938:
939: int yylex_init (yyscan_t* scanner);
940:
941: int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
942:
943: /* %endif */
944:
945: /* %endif End reentrant structures and macros. */
946:
947: /* Accessor methods to globals.
948: These are made visible to non-reentrant scanners for convenience. */
949:
950: int yylex_destroy ( yyscan_t yyscanner );
951:
952: int yyget_debug ( yyscan_t yyscanner );
953:
954: void yyset_debug ( int debug_flag , yyscan_t yyscanner );
955:
956: YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
957:
958: void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
959:
960: FILE *yyget_in ( yyscan_t yyscanner );
961:
962: void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
963:
964: FILE *yyget_out ( yyscan_t yyscanner );
965:
966: void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
967:
968: int yyget_leng ( yyscan_t yyscanner );
969:
970: char *yyget_text ( yyscan_t yyscanner );
971:
972: int yyget_lineno ( yyscan_t yyscanner );
973:
974: void yyset_lineno ( int _line_number , yyscan_t yyscanner );
975:
976: int yyget_column ( yyscan_t yyscanner );
977:
978: void yyset_column ( int _column_no , yyscan_t yyscanner );
979:
980: /* %if-bison-bridge */
981:
982: YYSTYPE * yyget_lval ( yyscan_t yyscanner );
983:
984: void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
985:
986: /* %endif */
987:
988: /* Macros after this point can all be overridden by user definitions in
989: * section 1.
990: */
991:
992: #ifndef YY_SKIP_YYWRAP
993: #ifdef __cplusplus
994: extern "C" int yywrap ( yyscan_t yyscanner );
995: #else
996: extern int yywrap ( yyscan_t yyscanner );
997: #endif
998: #endif
999:
1000: /* %not-for-header */
1001: #ifndef YY_NO_UNPUT
1002:
1003: static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner);
1004:
1005: #endif
1006: /* %ok-for-header */
1007:
1008: /* %endif */
1009:
1010: #ifndef yytext_ptr
1011: static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
1012: #endif
1013:
1014: #ifdef YY_NEED_STRLEN
1015: static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
1016: #endif
1017:
1018: #ifndef YY_NO_INPUT
1019: /* %if-c-only Standard (non-C++) definition */
1020: /* %not-for-header */
1021: #ifdef __cplusplus
1022: static int yyinput ( yyscan_t yyscanner );
1023: #else
1024: static int input ( yyscan_t yyscanner );
1025: #endif
1026: /* %ok-for-header */
1027:
1028: /* %endif */
1029: #endif
1030:
1031: /* %if-c-only */
1032:
1033: static void yy_push_state ( int _new_state , yyscan_t yyscanner);
1034:
1035: static void yy_pop_state ( yyscan_t yyscanner );
1036:
1037: static int yy_top_state ( yyscan_t yyscanner );
1038:
1039: /* %endif */
1040:
1041: /* Amount of stuff to slurp up with each read. */
1042: #ifndef YY_READ_BUF_SIZE
1043: #ifdef __ia64__
1044: /* On IA-64, the buffer size is 16k, not 8k */
1045: #define YY_READ_BUF_SIZE 16384
1046: #else
1047: #define YY_READ_BUF_SIZE 8192
1048: #endif /* __ia64__ */
1049: #endif
1050:
1051: /* Copy whatever the last rule matched to the standard output. */
1052: #ifndef ECHO
1053: /* %if-c-only Standard (non-C++) definition */
1054: /* This used to be an fputs(), but since the string might contain NUL's,
1055: * we now use fwrite().
1056: */
1057: #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1058: /* %endif */
1059: /* %if-c++-only C++ definition */
1060: /* %endif */
1061: #endif
1062:
1063: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1064: * is returned in "result".
1065: */
1066: #ifndef YY_INPUT
1067: #define YY_INPUT(buf,result,max_size) \
1068: /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
1069: if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1070: { \
1071: int c = '*'; \
1072: int n; \
1073: for ( n = 0; n < max_size && \
1074: (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1075: buf[n] = (char) c; \
1076: if ( c == '\n' ) \
1077: buf[n++] = (char) c; \
1078: if ( c == EOF && ferror( yyin ) ) \
1079: YY_FATAL_ERROR( "input in flex scanner failed" ); \
1080: result = n; \
1081: } \
1082: else \
1083: { \
1084: errno=0; \
1085: while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
1086: { \
1087: if( errno != EINTR) \
1088: { \
1089: YY_FATAL_ERROR( "input in flex scanner failed" ); \
1090: break; \
1091: } \
1092: errno=0; \
1093: clearerr(yyin); \
1094: } \
1095: }\
1096: \
1097: /* %if-c++-only C++ definition \ */\
1098: /* %endif */
1099:
1100: #endif
1101:
1102: /* No semi-colon after return; correct usage is to write "yyterminate();" -
1103: * we don't want an extra ';' after the "return" because that will cause
1104: * some compilers to complain about unreachable statements.
1105: */
1106: #ifndef yyterminate
1107: #define yyterminate() return YY_NULL
1108: #endif
1109:
1110: /* Number of entries by which start-condition stack grows. */
1111: #ifndef YY_START_STACK_INCR
1112: #define YY_START_STACK_INCR 25
1113: #endif
1114:
1115: /* Report a fatal error. */
1116: #ifndef YY_FATAL_ERROR
1117: /* %if-c-only */
1118: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1119: /* %endif */
1120: /* %if-c++-only */
1121: /* %endif */
1122: #endif
1123:
1124: /* %if-tables-serialization structures and prototypes */
1125: /* %not-for-header */
1126: /* %ok-for-header */
1127:
1128: /* %not-for-header */
1129: /* %tables-yydmap generated elements */
1130: /* %endif */
1131: /* end tables serialization structures and prototypes */
1132:
1133: /* %ok-for-header */
1134:
1135: /* Default declaration of generated scanner - a define so the user can
1136: * easily add parameters.
1137: */
1138: #ifndef YY_DECL
1139: #define YY_DECL_IS_OURS 1
1140: /* %if-c-only Standard (non-C++) definition */
1141:
1142: extern int yylex \
1143: (YYSTYPE * yylval_param , yyscan_t yyscanner);
1144:
1145: #define YY_DECL int yylex \
1146: (YYSTYPE * yylval_param , yyscan_t yyscanner)
1147: /* %endif */
1148: /* %if-c++-only C++ definition */
1149: /* %endif */
1150: #endif /* !YY_DECL */
1151:
1152: /* Code executed at the beginning of each rule, after yytext and yyleng
1153: * have been set up.
1154: */
1155: #ifndef YY_USER_ACTION
1156: #define YY_USER_ACTION
1157: #endif
1158:
1159: /* Code executed at the end of each rule. */
1160: #ifndef YY_BREAK
1161: #define YY_BREAK /*LINTED*/break;
1162: #endif
1163:
1164: /* %% [6.0] YY_RULE_SETUP definition goes here */
1165: #define YY_RULE_SETUP \
1166: if ( yyleng > 0 ) \
1167: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1168: (yytext[yyleng - 1] == '\n'); \
1169: YY_USER_ACTION
1170:
1171: /* %not-for-header */
1172: /** The main scanner function which does all the work.
1173: */
1174: YY_DECL
1175: {
1176: yy_state_type yy_current_state;
1177: char *yy_cp, *yy_bp;
1178: int yy_act;
1179: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1180:
1181: yylval = yylval_param;
1182:
1183: if ( !yyg->yy_init )
1184: {
1185: yyg->yy_init = 1;
1186:
1187: #ifdef YY_USER_INIT
1188: YY_USER_INIT;
1189: #endif
1190:
1191: if ( ! yyg->yy_start )
1192: yyg->yy_start = 1; /* first start state */
1193:
1194: if ( ! yyin )
1195: /* %if-c-only */
1196: yyin = stdin;
1197: /* %endif */
1198: /* %if-c++-only */
1199: /* %endif */
1200:
1201: if ( ! yyout )
1202: /* %if-c-only */
1203: yyout = stdout;
1204: /* %endif */
1205: /* %if-c++-only */
1206: /* %endif */
1207:
1208: if ( ! YY_CURRENT_BUFFER ) {
1209: yyensure_buffer_stack (yyscanner);
1210: YY_CURRENT_BUFFER_LVALUE =
1211: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1212: }
1213:
1214: yy_load_buffer_state( yyscanner );
1215: }
1216:
1217: {
1218: /* %% [7.0] user's declarations go here */
1219: #line 63 "parser/lexer.l"
1220:
1221:
1222: #line 1223 "parser/lexer.c"
1223:
1224: while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1225: {
1226: /* %% [8.0] yymore()-related code goes here */
1227: yy_cp = yyg->yy_c_buf_p;
1228:
1229: /* Support of yytext. */
1230: *yy_cp = yyg->yy_hold_char;
1231:
1232: /* yy_bp points to the position in yy_ch_buf of the start of
1233: * the current run.
1234: */
1235: yy_bp = yy_cp;
1236:
1237: /* %% [9.0] code to set up and find next match goes here */
1238: yy_current_state = yyg->yy_start;
1239: yy_current_state += YY_AT_BOL();
1240: yy_match:
1241: do
1242: {
1243: YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1244: if ( yy_accept[yy_current_state] )
1245: {
1246: yyg->yy_last_accepting_state = yy_current_state;
1247: yyg->yy_last_accepting_cpos = yy_cp;
1248: }
1249: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1250: {
1251: yy_current_state = (int) yy_def[yy_current_state];
1252: if ( yy_current_state >= 80 )
1253: yy_c = yy_meta[yy_c];
1254: }
1255: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1256: ++yy_cp;
1257: }
1258: while ( yy_current_state != 79 );
1259: yy_cp = yyg->yy_last_accepting_cpos;
1260: yy_current_state = yyg->yy_last_accepting_state;
1261:
1262: yy_find_action:
1263: /* %% [10.0] code to find the action number goes here */
1264: yy_act = yy_accept[yy_current_state];
1265:
1266: YY_DO_BEFORE_ACTION;
1267:
1268: /* %% [11.0] code for yylineno update goes here */
1269:
1270: if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1271: {
1272: int yyl;
1273: for ( yyl = 0; yyl < yyleng; ++yyl )
1274: if ( yytext[yyl] == '\n' )
1275:
1276: do{ yylineno++;
1277: yycolumn=0;
1278: }while(0)
1279: ;
1280: }
1281:
1282: do_action: /* This label is used only to access EOF actions. */
1283:
1284: /* %% [12.0] debug code goes here */
1285: if ( yy_flex_debug )
1286: {
1287: if ( yy_act == 0 )
1288: fprintf( stderr, "--scanner backing up\n" );
1289: else if ( yy_act < 26 )
1290: fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
1291: (long)yy_rule_linenum[yy_act], yytext );
1292: else if ( yy_act == 26 )
1293: fprintf( stderr, "--accepting default rule (\"%s\")\n",
1294: yytext );
1295: else if ( yy_act == 27 )
1296: fprintf( stderr, "--(end of buffer or a NUL)\n" );
1297: else
1298: fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
1299: }
1300:
1301: switch ( yy_act )
1302: { /* beginning of action switch */
1303: /* %% [13.0] actions go here */
1304: case 0: /* must back up */
1305: /* undo the effects of YY_DO_BEFORE_ACTION */
1306: *yy_cp = yyg->yy_hold_char;
1307: yy_cp = yyg->yy_last_accepting_cpos;
1308: yy_current_state = yyg->yy_last_accepting_state;
1309: goto yy_find_action;
1310:
1311: case 1:
1312: *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
1313: yyg->yy_c_buf_p = yy_cp -= 1;
1314: YY_DO_BEFORE_ACTION; /* set up yytext again */
1315: YY_RULE_SETUP
1316: #line 65 "parser/lexer.l"
1317: /* eat legacy version declaration */
1318: YY_BREAK
1319: case 2:
1320: YY_RULE_SETUP
1321: #line 66 "parser/lexer.l"
1322: return SPACES;
1323: YY_BREAK
1324: case 3:
1325: YY_RULE_SETUP
1326: #line 67 "parser/lexer.l"
1327: /* eat other whitespace */
1328: YY_BREAK
1329: case 4:
1330: YY_RULE_SETUP
1331: #line 68 "parser/lexer.l"
1332: /* eat comments */
1333: YY_BREAK
1334: case 5:
1335: /* rule 5 can match eol */
1336: YY_RULE_SETUP
1337: #line 70 "parser/lexer.l"
1338: return NEWLINE;
1339: YY_BREAK
1340: case 6:
1341: YY_RULE_SETUP
1342: #line 72 "parser/lexer.l"
1343: return EQ;
1344: YY_BREAK
1345: case 7:
1346: YY_RULE_SETUP
1347: #line 73 "parser/lexer.l"
1348: return CONFIG_SETUP;
1349: YY_BREAK
1350: case 8:
1351: YY_RULE_SETUP
1352: #line 74 "parser/lexer.l"
1353: return CONN;
1354: YY_BREAK
1355: case 9:
1356: YY_RULE_SETUP
1357: #line 75 "parser/lexer.l"
1358: return CA;
1359: YY_BREAK
1360: case 10:
1361: /* rule 10 can match eol */
1362: *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
1363: YY_LINENO_REWIND_TO(yy_cp - 1);
1364: yyg->yy_c_buf_p = yy_cp -= 1;
1365: YY_DO_BEFORE_ACTION; /* set up yytext again */
1366: YY_RULE_SETUP
1367: #line 77 "parser/lexer.l"
1368: {
1369: yyextra->string_init(yyextra);
1370: yy_push_state(inc, yyscanner);
1371: }
1372: YY_BREAK
1373: case 11:
1374: YY_RULE_SETUP
1375: #line 82 "parser/lexer.l"
1376: {
1377: yyextra->string_init(yyextra);
1378: yy_push_state(str, yyscanner);
1379: }
1380: YY_BREAK
1381: case 12:
1382: YY_RULE_SETUP
1383: #line 87 "parser/lexer.l"
1384: {
1385: yylval->s = strdup(yytext);
1386: return STRING;
1387: }
1388: YY_BREAK
1389:
1390: /* we allow all characters except # and spaces, they can be escaped */
1391: case YY_STATE_EOF(inc):
1392: #line 94 "parser/lexer.l"
1393: case 13:
1394: /* rule 13 can match eol */
1395: YY_RULE_SETUP
1396: #line 95 "parser/lexer.l"
1397: {
1398: if (*yytext)
1399: {
1400: switch (yytext[0])
1401: {
1402: case '\n':
1403: /* put the newline back to fix the line numbers */
1404: unput('\n');
1405: yy_set_bol(0);
1406: break;
1407: case '#':
1408: /* comments are parsed outside of this start condition */
1409: unput(yytext[0]);
1410: break;
1411: }
1412: }
1413: include_files(yyextra);
1414: yy_pop_state(yyscanner);
1415: }
1416: YY_BREAK
1417: case 14:
1418: YY_RULE_SETUP
1419: #line 114 "parser/lexer.l"
1420: { /* string include */
1421: yy_push_state(str, yyscanner);
1422: }
1423: YY_BREAK
1424: case 15:
1425: YY_RULE_SETUP
1426: #line 117 "parser/lexer.l"
1427: {
1428: yyextra->string_add(yyextra, yytext);
1429: }
1430: YY_BREAK
1431: case 16:
1432: YY_RULE_SETUP
1433: #line 120 "parser/lexer.l"
1434: {
1435: yyextra->string_add(yyextra, yytext+1);
1436: }
1437: YY_BREAK
1438: case 17:
1439: YY_RULE_SETUP
1440: #line 123 "parser/lexer.l"
1441: {
1442: yyextra->string_add(yyextra, yytext);
1443: }
1444: YY_BREAK
1445:
1446:
1447: case 18:
1448: #line 130 "parser/lexer.l"
1449: YY_RULE_SETUP
1450: case YY_STATE_EOF(str):
1451: #line 130 "parser/lexer.l"
1452: case 19:
1453: YY_RULE_SETUP
1454: #line 131 "parser/lexer.l"
1455: {
1456: if (!streq(yytext, "\""))
1457: {
1458: PARSER_DBG1(yyextra, "unterminated string detected");
1459: return STRING_ERROR;
1460: }
1461: if (yy_top_state(yyscanner) == inc)
1462: { /* string include */
1463: include_files(yyextra);
1464: yy_pop_state(yyscanner);
1465: yy_pop_state(yyscanner);
1466: }
1467: else
1468: {
1469: yy_pop_state(yyscanner);
1470: yylval->s = yyextra->string_get(yyextra);
1471: return STRING;
1472: }
1473: }
1474: YY_BREAK
1475: case 20:
1476: YY_RULE_SETUP
1477: #line 150 "parser/lexer.l"
1478: yyextra->string_add(yyextra, "\n");
1479: YY_BREAK
1480: case 21:
1481: YY_RULE_SETUP
1482: #line 151 "parser/lexer.l"
1483: yyextra->string_add(yyextra, "\r");
1484: YY_BREAK
1485: case 22:
1486: YY_RULE_SETUP
1487: #line 152 "parser/lexer.l"
1488: yyextra->string_add(yyextra, "\t");
1489: YY_BREAK
1490: case 23:
1491: /* rule 23 can match eol */
1492: YY_RULE_SETUP
1493: #line 153 "parser/lexer.l"
1494: /* merge lines that end with EOL characters */
1495: YY_BREAK
1496: case 24:
1497: YY_RULE_SETUP
1498: #line 154 "parser/lexer.l"
1499: yyextra->string_add(yyextra, yytext+1);
1500: YY_BREAK
1501: case 25:
1502: /* rule 25 can match eol */
1503: YY_RULE_SETUP
1504: #line 155 "parser/lexer.l"
1505: {
1506: yyextra->string_add(yyextra, yytext);
1507: }
1508: YY_BREAK
1509:
1510: case YY_STATE_EOF(INITIAL):
1511: #line 160 "parser/lexer.l"
1512: {
1513: conf_parser_pop_buffer_state(yyscanner);
1514: if (!conf_parser_open_next_file(yyextra) && !YY_CURRENT_BUFFER)
1515: {
1516: yyterminate();
1517: }
1518: }
1519: YY_BREAK
1520: case 26:
1521: YY_RULE_SETUP
1522: #line 168 "parser/lexer.l"
1523: YY_FATAL_ERROR( "flex scanner jammed" );
1524: YY_BREAK
1525: #line 1526 "parser/lexer.c"
1526:
1527: case YY_END_OF_BUFFER:
1528: {
1529: /* Amount of text matched not including the EOB char. */
1530: int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1531:
1532: /* Undo the effects of YY_DO_BEFORE_ACTION. */
1533: *yy_cp = yyg->yy_hold_char;
1534: YY_RESTORE_YY_MORE_OFFSET
1535:
1536: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1537: {
1538: /* We're scanning a new file or input source. It's
1539: * possible that this happened because the user
1540: * just pointed yyin at a new source and called
1541: * yylex(). If so, then we have to assure
1542: * consistency between YY_CURRENT_BUFFER and our
1543: * globals. Here is the right place to do so, because
1544: * this is the first action (other than possibly a
1545: * back-up) that will match for the new input source.
1546: */
1547: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1548: /* %if-c-only */
1549: YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1550: /* %endif */
1551: /* %if-c++-only */
1552: /* %endif */
1553: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1554: }
1555:
1556: /* Note that here we test for yy_c_buf_p "<=" to the position
1557: * of the first EOB in the buffer, since yy_c_buf_p will
1558: * already have been incremented past the NUL character
1559: * (since all states make transitions on EOB to the
1560: * end-of-buffer state). Contrast this with the test
1561: * in input().
1562: */
1563: if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1564: { /* This was really a NUL. */
1565: yy_state_type yy_next_state;
1566:
1567: yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1568:
1569: yy_current_state = yy_get_previous_state( yyscanner );
1570:
1571: /* Okay, we're now positioned to make the NUL
1572: * transition. We couldn't have
1573: * yy_get_previous_state() go ahead and do it
1574: * for us because it doesn't know how to deal
1575: * with the possibility of jamming (and we don't
1576: * want to build jamming into it because then it
1577: * will run more slowly).
1578: */
1579:
1580: yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1581:
1582: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1583:
1584: if ( yy_next_state )
1585: {
1586: /* Consume the NUL. */
1587: yy_cp = ++yyg->yy_c_buf_p;
1588: yy_current_state = yy_next_state;
1589: goto yy_match;
1590: }
1591:
1592: else
1593: {
1594: /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
1595: yy_cp = yyg->yy_last_accepting_cpos;
1596: yy_current_state = yyg->yy_last_accepting_state;
1597: goto yy_find_action;
1598: }
1599: }
1600:
1601: else switch ( yy_get_next_buffer( yyscanner ) )
1602: {
1603: case EOB_ACT_END_OF_FILE:
1604: {
1605: yyg->yy_did_buffer_switch_on_eof = 0;
1606:
1607: if ( yywrap( yyscanner ) )
1608: {
1609: /* Note: because we've taken care in
1610: * yy_get_next_buffer() to have set up
1611: * yytext, we can now set up
1612: * yy_c_buf_p so that if some total
1613: * hoser (like flex itself) wants to
1614: * call the scanner after we return the
1615: * YY_NULL, it'll still work - another
1616: * YY_NULL will get returned.
1617: */
1618: yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1619:
1620: yy_act = YY_STATE_EOF(YY_START);
1621: goto do_action;
1622: }
1623:
1624: else
1625: {
1626: if ( ! yyg->yy_did_buffer_switch_on_eof )
1627: YY_NEW_FILE;
1628: }
1629: break;
1630: }
1631:
1632: case EOB_ACT_CONTINUE_SCAN:
1633: yyg->yy_c_buf_p =
1634: yyg->yytext_ptr + yy_amount_of_matched_text;
1635:
1636: yy_current_state = yy_get_previous_state( yyscanner );
1637:
1638: yy_cp = yyg->yy_c_buf_p;
1639: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1640: goto yy_match;
1641:
1642: case EOB_ACT_LAST_MATCH:
1643: yyg->yy_c_buf_p =
1644: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1645:
1646: yy_current_state = yy_get_previous_state( yyscanner );
1647:
1648: yy_cp = yyg->yy_c_buf_p;
1649: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1650: goto yy_find_action;
1651: }
1652: break;
1653: }
1654:
1655: default:
1656: YY_FATAL_ERROR(
1657: "fatal flex scanner internal error--no action found" );
1658: } /* end of action switch */
1659: } /* end of scanning one token */
1660: } /* end of user's declarations */
1661: } /* end of yylex */
1662: /* %ok-for-header */
1663:
1664: /* %if-c++-only */
1665: /* %not-for-header */
1666: /* %ok-for-header */
1667:
1668: /* %endif */
1669:
1670: /* yy_get_next_buffer - try to read in a new buffer
1671: *
1672: * Returns a code representing an action:
1673: * EOB_ACT_LAST_MATCH -
1674: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1675: * EOB_ACT_END_OF_FILE - end of file
1676: */
1677: /* %if-c-only */
1678: static int yy_get_next_buffer (yyscan_t yyscanner)
1679: /* %endif */
1680: /* %if-c++-only */
1681: /* %endif */
1682: {
1683: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1684: char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1685: char *source = yyg->yytext_ptr;
1686: int number_to_move, i;
1687: int ret_val;
1688:
1689: if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1690: YY_FATAL_ERROR(
1691: "fatal flex scanner internal error--end of buffer missed" );
1692:
1693: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1694: { /* Don't try to fill the buffer, so this is an EOF. */
1695: if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1696: {
1697: /* We matched a single character, the EOB, so
1698: * treat this as a final EOF.
1699: */
1700: return EOB_ACT_END_OF_FILE;
1701: }
1702:
1703: else
1704: {
1705: /* We matched some text prior to the EOB, first
1706: * process it.
1707: */
1708: return EOB_ACT_LAST_MATCH;
1709: }
1710: }
1711:
1712: /* Try to read more data. */
1713:
1714: /* First move last chars to start of buffer. */
1715: number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1716:
1717: for ( i = 0; i < number_to_move; ++i )
1718: *(dest++) = *(source++);
1719:
1720: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1721: /* don't do the read, it's not guaranteed to return an EOF,
1722: * just force an EOF
1723: */
1724: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1725:
1726: else
1727: {
1728: int num_to_read =
1729: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1730:
1731: while ( num_to_read <= 0 )
1732: { /* Not enough room in the buffer - grow it. */
1733:
1734: /* just a shorter name for the current buffer */
1735: YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1736:
1737: int yy_c_buf_p_offset =
1738: (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1739:
1740: if ( b->yy_is_our_buffer )
1741: {
1742: int new_size = b->yy_buf_size * 2;
1743:
1744: if ( new_size <= 0 )
1745: b->yy_buf_size += b->yy_buf_size / 8;
1746: else
1747: b->yy_buf_size *= 2;
1748:
1749: b->yy_ch_buf = (char *)
1750: /* Include room in for 2 EOB chars. */
1751: yyrealloc( (void *) b->yy_ch_buf,
1752: (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1753: }
1754: else
1755: /* Can't grow it, we don't own it. */
1756: b->yy_ch_buf = NULL;
1757:
1758: if ( ! b->yy_ch_buf )
1759: YY_FATAL_ERROR(
1760: "fatal error - scanner input buffer overflow" );
1761:
1762: yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1763:
1764: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1765: number_to_move - 1;
1766:
1767: }
1768:
1769: if ( num_to_read > YY_READ_BUF_SIZE )
1770: num_to_read = YY_READ_BUF_SIZE;
1771:
1772: /* Read in more data. */
1773: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1774: yyg->yy_n_chars, num_to_read );
1775:
1776: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1777: }
1778:
1779: if ( yyg->yy_n_chars == 0 )
1780: {
1781: if ( number_to_move == YY_MORE_ADJ )
1782: {
1783: ret_val = EOB_ACT_END_OF_FILE;
1784: yyrestart( yyin , yyscanner);
1785: }
1786:
1787: else
1788: {
1789: ret_val = EOB_ACT_LAST_MATCH;
1790: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1791: YY_BUFFER_EOF_PENDING;
1792: }
1793: }
1794:
1795: else
1796: ret_val = EOB_ACT_CONTINUE_SCAN;
1797:
1798: if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1799: /* Extend the array by 50%, plus the number we really need. */
1800: int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1801: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1802: (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1803: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1804: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1805: /* "- 2" to take care of EOB's */
1806: YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1807: }
1808:
1809: yyg->yy_n_chars += number_to_move;
1810: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1811: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1812:
1813: yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1814:
1815: return ret_val;
1816: }
1817:
1818: /* yy_get_previous_state - get the state just before the EOB char was reached */
1819:
1820: /* %if-c-only */
1821: /* %not-for-header */
1822: static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1823: /* %endif */
1824: /* %if-c++-only */
1825: /* %endif */
1826: {
1827: yy_state_type yy_current_state;
1828: char *yy_cp;
1829: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1830:
1831: /* %% [15.0] code to get the start state into yy_current_state goes here */
1832: yy_current_state = yyg->yy_start;
1833: yy_current_state += YY_AT_BOL();
1834:
1835: for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1836: {
1837: /* %% [16.0] code to find the next state goes here */
1838: YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1839: if ( yy_accept[yy_current_state] )
1840: {
1841: yyg->yy_last_accepting_state = yy_current_state;
1842: yyg->yy_last_accepting_cpos = yy_cp;
1843: }
1844: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1845: {
1846: yy_current_state = (int) yy_def[yy_current_state];
1847: if ( yy_current_state >= 80 )
1848: yy_c = yy_meta[yy_c];
1849: }
1850: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1851: }
1852:
1853: return yy_current_state;
1854: }
1855:
1856: /* yy_try_NUL_trans - try to make a transition on the NUL character
1857: *
1858: * synopsis
1859: * next_state = yy_try_NUL_trans( current_state );
1860: */
1861: /* %if-c-only */
1862: static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1863: /* %endif */
1864: /* %if-c++-only */
1865: /* %endif */
1866: {
1867: int yy_is_jam;
1868: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1869: /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
1870: char *yy_cp = yyg->yy_c_buf_p;
1871:
1872: YY_CHAR yy_c = 1;
1873: if ( yy_accept[yy_current_state] )
1874: {
1875: yyg->yy_last_accepting_state = yy_current_state;
1876: yyg->yy_last_accepting_cpos = yy_cp;
1877: }
1878: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1879: {
1880: yy_current_state = (int) yy_def[yy_current_state];
1881: if ( yy_current_state >= 80 )
1882: yy_c = yy_meta[yy_c];
1883: }
1884: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1885: yy_is_jam = (yy_current_state == 79);
1886:
1887: (void)yyg;
1888: return yy_is_jam ? 0 : yy_current_state;
1889: }
1890:
1891: #ifndef YY_NO_UNPUT
1892: /* %if-c-only */
1893:
1894: static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
1895: /* %endif */
1896: /* %if-c++-only */
1897: /* %endif */
1898: {
1899: char *yy_cp;
1900: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1901:
1902: yy_cp = yyg->yy_c_buf_p;
1903:
1904: /* undo effects of setting up yytext */
1905: *yy_cp = yyg->yy_hold_char;
1906:
1907: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1908: { /* need to shift things up to make room */
1909: /* +2 for EOB chars. */
1910: int number_to_move = yyg->yy_n_chars + 2;
1911: char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1912: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1913: char *source =
1914: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1915:
1916: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1917: *--dest = *--source;
1918:
1919: yy_cp += (int) (dest - source);
1920: yy_bp += (int) (dest - source);
1921: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1922: yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1923:
1924: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1925: YY_FATAL_ERROR( "flex scanner push-back overflow" );
1926: }
1927:
1928: *--yy_cp = (char) c;
1929:
1930: /* %% [18.0] update yylineno here */
1931:
1932: if ( c == '\n' ){
1933: --yylineno;
1934: }
1935:
1936: yyg->yytext_ptr = yy_bp;
1937: yyg->yy_hold_char = *yy_cp;
1938: yyg->yy_c_buf_p = yy_cp;
1939: }
1940: /* %if-c-only */
1941:
1942: /* %endif */
1943: #endif
1944:
1945: /* %if-c-only */
1946: #ifndef YY_NO_INPUT
1947: #ifdef __cplusplus
1948: static int yyinput (yyscan_t yyscanner)
1949: #else
1950: static int input (yyscan_t yyscanner)
1951: #endif
1952:
1953: /* %endif */
1954: /* %if-c++-only */
1955: /* %endif */
1956: {
1957: int c;
1958: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1959:
1960: *yyg->yy_c_buf_p = yyg->yy_hold_char;
1961:
1962: if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1963: {
1964: /* yy_c_buf_p now points to the character we want to return.
1965: * If this occurs *before* the EOB characters, then it's a
1966: * valid NUL; if not, then we've hit the end of the buffer.
1967: */
1968: if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1969: /* This was really a NUL. */
1970: *yyg->yy_c_buf_p = '\0';
1971:
1972: else
1973: { /* need more input */
1974: int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
1975: ++yyg->yy_c_buf_p;
1976:
1977: switch ( yy_get_next_buffer( yyscanner ) )
1978: {
1979: case EOB_ACT_LAST_MATCH:
1980: /* This happens because yy_g_n_b()
1981: * sees that we've accumulated a
1982: * token and flags that we need to
1983: * try matching the token before
1984: * proceeding. But for input(),
1985: * there's no matching to consider.
1986: * So convert the EOB_ACT_LAST_MATCH
1987: * to EOB_ACT_END_OF_FILE.
1988: */
1989:
1990: /* Reset buffer status. */
1991: yyrestart( yyin , yyscanner);
1992:
1993: /*FALLTHROUGH*/
1994:
1995: case EOB_ACT_END_OF_FILE:
1996: {
1997: if ( yywrap( yyscanner ) )
1998: return 0;
1999:
2000: if ( ! yyg->yy_did_buffer_switch_on_eof )
2001: YY_NEW_FILE;
2002: #ifdef __cplusplus
2003: return yyinput(yyscanner);
2004: #else
2005: return input(yyscanner);
2006: #endif
2007: }
2008:
2009: case EOB_ACT_CONTINUE_SCAN:
2010: yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2011: break;
2012: }
2013: }
2014: }
2015:
2016: c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2017: *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
2018: yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2019:
2020: /* %% [19.0] update BOL and yylineno */
2021: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2022: if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
2023:
2024: do{ yylineno++;
2025: yycolumn=0;
2026: }while(0)
2027: ;
2028:
2029: return c;
2030: }
2031: /* %if-c-only */
2032: #endif /* ifndef YY_NO_INPUT */
2033: /* %endif */
2034:
2035: /** Immediately switch to a different input stream.
2036: * @param input_file A readable stream.
2037: * @param yyscanner The scanner object.
2038: * @note This function does not reset the start condition to @c INITIAL .
2039: */
2040: /* %if-c-only */
2041: void yyrestart (FILE * input_file , yyscan_t yyscanner)
2042: /* %endif */
2043: /* %if-c++-only */
2044: /* %endif */
2045: {
2046: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2047:
2048: if ( ! YY_CURRENT_BUFFER ){
2049: yyensure_buffer_stack (yyscanner);
2050: YY_CURRENT_BUFFER_LVALUE =
2051: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
2052: }
2053:
2054: yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
2055: yy_load_buffer_state( yyscanner );
2056: }
2057:
2058: /* %if-c++-only */
2059: /* %endif */
2060:
2061: /** Switch to a different input buffer.
2062: * @param new_buffer The new input buffer.
2063: * @param yyscanner The scanner object.
2064: */
2065: /* %if-c-only */
2066: void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2067: /* %endif */
2068: /* %if-c++-only */
2069: /* %endif */
2070: {
2071: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2072:
2073: /* TODO. We should be able to replace this entire function body
2074: * with
2075: * yypop_buffer_state();
2076: * yypush_buffer_state(new_buffer);
2077: */
2078: yyensure_buffer_stack (yyscanner);
2079: if ( YY_CURRENT_BUFFER == new_buffer )
2080: return;
2081:
2082: if ( YY_CURRENT_BUFFER )
2083: {
2084: /* Flush out information for old buffer. */
2085: *yyg->yy_c_buf_p = yyg->yy_hold_char;
2086: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2087: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2088: }
2089:
2090: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2091: yy_load_buffer_state( yyscanner );
2092:
2093: /* We don't actually know whether we did this switch during
2094: * EOF (yywrap()) processing, but the only time this flag
2095: * is looked at is after yywrap() is called, so it's safe
2096: * to go ahead and always set it.
2097: */
2098: yyg->yy_did_buffer_switch_on_eof = 1;
2099: }
2100:
2101: /* %if-c-only */
2102: static void yy_load_buffer_state (yyscan_t yyscanner)
2103: /* %endif */
2104: /* %if-c++-only */
2105: /* %endif */
2106: {
2107: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2108: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2109: yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2110: /* %if-c-only */
2111: yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2112: /* %endif */
2113: /* %if-c++-only */
2114: /* %endif */
2115: yyg->yy_hold_char = *yyg->yy_c_buf_p;
2116: }
2117:
2118: /** Allocate and initialize an input buffer state.
2119: * @param file A readable stream.
2120: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2121: * @param yyscanner The scanner object.
2122: * @return the allocated buffer state.
2123: */
2124: /* %if-c-only */
2125: YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
2126: /* %endif */
2127: /* %if-c++-only */
2128: /* %endif */
2129: {
2130: YY_BUFFER_STATE b;
2131:
2132: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
2133: if ( ! b )
2134: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2135:
2136: b->yy_buf_size = size;
2137:
2138: /* yy_ch_buf has to be 2 characters longer than the size given because
2139: * we need to put in 2 end-of-buffer characters.
2140: */
2141: b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
2142: if ( ! b->yy_ch_buf )
2143: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2144:
2145: b->yy_is_our_buffer = 1;
2146:
2147: yy_init_buffer( b, file , yyscanner);
2148:
2149: return b;
2150: }
2151:
2152: /* %if-c++-only */
2153: /* %endif */
2154:
2155: /** Destroy the buffer.
2156: * @param b a buffer created with yy_create_buffer()
2157: * @param yyscanner The scanner object.
2158: */
2159: /* %if-c-only */
2160: void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2161: /* %endif */
2162: /* %if-c++-only */
2163: /* %endif */
2164: {
2165: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2166:
2167: if ( ! b )
2168: return;
2169:
2170: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2171: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2172:
2173: if ( b->yy_is_our_buffer )
2174: yyfree( (void *) b->yy_ch_buf , yyscanner );
2175:
2176: yyfree( (void *) b , yyscanner );
2177: }
2178:
2179: /* Initializes or reinitializes a buffer.
2180: * This function is sometimes called more than once on the same buffer,
2181: * such as during a yyrestart() or at EOF.
2182: */
2183: /* %if-c-only */
2184: static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
2185: /* %endif */
2186: /* %if-c++-only */
2187: /* %endif */
2188:
2189: {
2190: int oerrno = errno;
2191: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2192:
2193: yy_flush_buffer( b , yyscanner);
2194:
2195: /* %if-c-only */
2196: b->yy_input_file = file;
2197: /* %endif */
2198: /* %if-c++-only */
2199: /* %endif */
2200: b->yy_fill_buffer = 1;
2201:
2202: /* If b is the current buffer, then yy_init_buffer was _probably_
2203: * called from yyrestart() or through yy_get_next_buffer.
2204: * In that case, we don't want to reset the lineno or column.
2205: */
2206: if (b != YY_CURRENT_BUFFER){
2207: b->yy_bs_lineno = 1;
2208: b->yy_bs_column = 0;
2209: }
2210:
2211: /* %if-c-only */
2212:
2213: b->yy_is_interactive = 0;
2214:
2215: /* %endif */
2216: /* %if-c++-only */
2217: /* %endif */
2218: errno = oerrno;
2219: }
2220:
2221: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2222: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2223: * @param yyscanner The scanner object.
2224: */
2225: /* %if-c-only */
2226: void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2227: /* %endif */
2228: /* %if-c++-only */
2229: /* %endif */
2230: {
2231: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2232: if ( ! b )
2233: return;
2234:
2235: b->yy_n_chars = 0;
2236:
2237: /* We always need two end-of-buffer characters. The first causes
2238: * a transition to the end-of-buffer state. The second causes
2239: * a jam in that state.
2240: */
2241: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2242: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2243:
2244: b->yy_buf_pos = &b->yy_ch_buf[0];
2245:
2246: b->yy_at_bol = 1;
2247: b->yy_buffer_status = YY_BUFFER_NEW;
2248:
2249: if ( b == YY_CURRENT_BUFFER )
2250: yy_load_buffer_state( yyscanner );
2251: }
2252:
2253: /* %if-c-or-c++ */
2254: /** Pushes the new state onto the stack. The new state becomes
2255: * the current state. This function will allocate the stack
2256: * if necessary.
2257: * @param new_buffer The new state.
2258: * @param yyscanner The scanner object.
2259: */
2260: /* %if-c-only */
2261: void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2262: /* %endif */
2263: /* %if-c++-only */
2264: /* %endif */
2265: {
2266: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2267: if (new_buffer == NULL)
2268: return;
2269:
2270: yyensure_buffer_stack(yyscanner);
2271:
2272: /* This block is copied from yy_switch_to_buffer. */
2273: if ( YY_CURRENT_BUFFER )
2274: {
2275: /* Flush out information for old buffer. */
2276: *yyg->yy_c_buf_p = yyg->yy_hold_char;
2277: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2278: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2279: }
2280:
2281: /* Only push if top exists. Otherwise, replace top. */
2282: if (YY_CURRENT_BUFFER)
2283: yyg->yy_buffer_stack_top++;
2284: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2285:
2286: /* copied from yy_switch_to_buffer. */
2287: yy_load_buffer_state( yyscanner );
2288: yyg->yy_did_buffer_switch_on_eof = 1;
2289: }
2290: /* %endif */
2291:
2292: /* %if-c-or-c++ */
2293: /** Removes and deletes the top of the stack, if present.
2294: * The next element becomes the new top.
2295: * @param yyscanner The scanner object.
2296: */
2297: /* %if-c-only */
2298: void yypop_buffer_state (yyscan_t yyscanner)
2299: /* %endif */
2300: /* %if-c++-only */
2301: /* %endif */
2302: {
2303: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2304: if (!YY_CURRENT_BUFFER)
2305: return;
2306:
2307: yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
2308: YY_CURRENT_BUFFER_LVALUE = NULL;
2309: if (yyg->yy_buffer_stack_top > 0)
2310: --yyg->yy_buffer_stack_top;
2311:
2312: if (YY_CURRENT_BUFFER) {
2313: yy_load_buffer_state( yyscanner );
2314: yyg->yy_did_buffer_switch_on_eof = 1;
2315: }
2316: }
2317: /* %endif */
2318:
2319: /* %if-c-or-c++ */
2320: /* Allocates the stack if it does not exist.
2321: * Guarantees space for at least one push.
2322: */
2323: /* %if-c-only */
2324: static void yyensure_buffer_stack (yyscan_t yyscanner)
2325: /* %endif */
2326: /* %if-c++-only */
2327: /* %endif */
2328: {
2329: yy_size_t num_to_alloc;
2330: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2331:
2332: if (!yyg->yy_buffer_stack) {
2333:
2334: /* First allocation is just for 2 elements, since we don't know if this
2335: * scanner will even need a stack. We use 2 instead of 1 to avoid an
2336: * immediate realloc on the next call.
2337: */
2338: num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2339: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
2340: (num_to_alloc * sizeof(struct yy_buffer_state*)
2341: , yyscanner);
2342: if ( ! yyg->yy_buffer_stack )
2343: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2344:
2345: memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2346:
2347: yyg->yy_buffer_stack_max = num_to_alloc;
2348: yyg->yy_buffer_stack_top = 0;
2349: return;
2350: }
2351:
2352: if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2353:
2354: /* Increase the buffer to prepare for a possible push. */
2355: yy_size_t grow_size = 8 /* arbitrary grow size */;
2356:
2357: num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2358: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
2359: (yyg->yy_buffer_stack,
2360: num_to_alloc * sizeof(struct yy_buffer_state*)
2361: , yyscanner);
2362: if ( ! yyg->yy_buffer_stack )
2363: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2364:
2365: /* zero only the new slots.*/
2366: memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2367: yyg->yy_buffer_stack_max = num_to_alloc;
2368: }
2369: }
2370: /* %endif */
2371:
2372: /* %if-c-only */
2373: /** Setup the input buffer state to scan directly from a user-specified character buffer.
2374: * @param base the character buffer
2375: * @param size the size in bytes of the character buffer
2376: * @param yyscanner The scanner object.
2377: * @return the newly allocated buffer state object.
2378: */
2379: YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2380: {
2381: YY_BUFFER_STATE b;
2382:
2383: if ( size < 2 ||
2384: base[size-2] != YY_END_OF_BUFFER_CHAR ||
2385: base[size-1] != YY_END_OF_BUFFER_CHAR )
2386: /* They forgot to leave room for the EOB's. */
2387: return NULL;
2388:
2389: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
2390: if ( ! b )
2391: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2392:
2393: b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
2394: b->yy_buf_pos = b->yy_ch_buf = base;
2395: b->yy_is_our_buffer = 0;
2396: b->yy_input_file = NULL;
2397: b->yy_n_chars = b->yy_buf_size;
2398: b->yy_is_interactive = 0;
2399: b->yy_at_bol = 1;
2400: b->yy_fill_buffer = 0;
2401: b->yy_buffer_status = YY_BUFFER_NEW;
2402:
2403: yy_switch_to_buffer( b , yyscanner );
2404:
2405: return b;
2406: }
2407: /* %endif */
2408:
2409: /* %if-c-only */
2410: /** Setup the input buffer state to scan a string. The next call to yylex() will
2411: * scan from a @e copy of @a str.
2412: * @param yystr a NUL-terminated string to scan
2413: * @param yyscanner The scanner object.
2414: * @return the newly allocated buffer state object.
2415: * @note If you want to scan bytes that may contain NUL values, then use
2416: * yy_scan_bytes() instead.
2417: */
2418: YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
2419: {
2420:
2421: return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
2422: }
2423: /* %endif */
2424:
2425: /* %if-c-only */
2426: /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2427: * scan from a @e copy of @a bytes.
2428: * @param yybytes the byte buffer to scan
2429: * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2430: * @param yyscanner The scanner object.
2431: * @return the newly allocated buffer state object.
2432: */
2433: YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
2434: {
2435: YY_BUFFER_STATE b;
2436: char *buf;
2437: yy_size_t n;
2438: int i;
2439:
2440: /* Get memory for full buffer, including space for trailing EOB's. */
2441: n = (yy_size_t) (_yybytes_len + 2);
2442: buf = (char *) yyalloc( n , yyscanner );
2443: if ( ! buf )
2444: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2445:
2446: for ( i = 0; i < _yybytes_len; ++i )
2447: buf[i] = yybytes[i];
2448:
2449: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2450:
2451: b = yy_scan_buffer( buf, n , yyscanner);
2452: if ( ! b )
2453: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2454:
2455: /* It's okay to grow etc. this buffer, and we should throw it
2456: * away when we're done.
2457: */
2458: b->yy_is_our_buffer = 1;
2459:
2460: return b;
2461: }
2462: /* %endif */
2463:
2464: /* %if-c-only */
2465: static void yy_push_state (int _new_state , yyscan_t yyscanner)
2466: /* %endif */
2467: /* %if-c++-only */
2468: /* %endif */
2469: {
2470: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2471: if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
2472: {
2473: yy_size_t new_size;
2474:
2475: yyg->yy_start_stack_depth += YY_START_STACK_INCR;
2476: new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int );
2477:
2478: if ( ! yyg->yy_start_stack )
2479: yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner );
2480:
2481: else
2482: yyg->yy_start_stack = (int *) yyrealloc(
2483: (void *) yyg->yy_start_stack, new_size , yyscanner );
2484:
2485: if ( ! yyg->yy_start_stack )
2486: YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
2487: }
2488:
2489: yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
2490:
2491: BEGIN(_new_state);
2492: }
2493:
2494: /* %if-c-only */
2495: static void yy_pop_state (yyscan_t yyscanner)
2496: /* %endif */
2497: /* %if-c++-only */
2498: /* %endif */
2499: {
2500: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2501: if ( --yyg->yy_start_stack_ptr < 0 )
2502: YY_FATAL_ERROR( "start-condition stack underflow" );
2503:
2504: BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
2505: }
2506:
2507: /* %if-c-only */
2508: static int yy_top_state (yyscan_t yyscanner)
2509: /* %endif */
2510: /* %if-c++-only */
2511: /* %endif */
2512: {
2513: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2514: return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
2515: }
2516:
2517: #ifndef YY_EXIT_FAILURE
2518: #define YY_EXIT_FAILURE 2
2519: #endif
2520:
2521: /* %if-c-only */
2522: static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
2523: {
2524: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2525: (void)yyg;
2526: fprintf( stderr, "%s\n", msg );
2527: exit( YY_EXIT_FAILURE );
2528: }
2529: /* %endif */
2530: /* %if-c++-only */
2531: /* %endif */
2532:
2533: /* Redefine yyless() so it works in section 3 code. */
2534:
2535: #undef yyless
2536: #define yyless(n) \
2537: do \
2538: { \
2539: /* Undo effects of setting up yytext. */ \
2540: int yyless_macro_arg = (n); \
2541: YY_LESS_LINENO(yyless_macro_arg);\
2542: yytext[yyleng] = yyg->yy_hold_char; \
2543: yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2544: yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2545: *yyg->yy_c_buf_p = '\0'; \
2546: yyleng = yyless_macro_arg; \
2547: } \
2548: while ( 0 )
2549:
2550: /* Accessor methods (get/set functions) to struct members. */
2551:
2552: /* %if-c-only */
2553: /* %if-reentrant */
2554:
2555: /** Get the user-defined data for this scanner.
2556: * @param yyscanner The scanner object.
2557: */
2558: YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
2559: {
2560: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2561: return yyextra;
2562: }
2563:
2564: /* %endif */
2565:
2566: /** Get the current line number.
2567: * @param yyscanner The scanner object.
2568: */
2569: int yyget_lineno (yyscan_t yyscanner)
2570: {
2571: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2572:
2573: if (! YY_CURRENT_BUFFER)
2574: return 0;
2575:
2576: return yylineno;
2577: }
2578:
2579: /** Get the current column number.
2580: * @param yyscanner The scanner object.
2581: */
2582: int yyget_column (yyscan_t yyscanner)
2583: {
2584: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2585:
2586: if (! YY_CURRENT_BUFFER)
2587: return 0;
2588:
2589: return yycolumn;
2590: }
2591:
2592: /** Get the input stream.
2593: * @param yyscanner The scanner object.
2594: */
2595: FILE *yyget_in (yyscan_t yyscanner)
2596: {
2597: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2598: return yyin;
2599: }
2600:
2601: /** Get the output stream.
2602: * @param yyscanner The scanner object.
2603: */
2604: FILE *yyget_out (yyscan_t yyscanner)
2605: {
2606: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2607: return yyout;
2608: }
2609:
2610: /** Get the length of the current token.
2611: * @param yyscanner The scanner object.
2612: */
2613: int yyget_leng (yyscan_t yyscanner)
2614: {
2615: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2616: return yyleng;
2617: }
2618:
2619: /** Get the current token.
2620: * @param yyscanner The scanner object.
2621: */
2622:
2623: char *yyget_text (yyscan_t yyscanner)
2624: {
2625: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2626: return yytext;
2627: }
2628:
2629: /* %if-reentrant */
2630:
2631: /** Set the user-defined data. This data is never touched by the scanner.
2632: * @param user_defined The data to be associated with this scanner.
2633: * @param yyscanner The scanner object.
2634: */
2635: void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2636: {
2637: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2638: yyextra = user_defined ;
2639: }
2640:
2641: /* %endif */
2642:
2643: /** Set the current line number.
2644: * @param _line_number line number
2645: * @param yyscanner The scanner object.
2646: */
2647: void yyset_lineno (int _line_number , yyscan_t yyscanner)
2648: {
2649: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2650:
2651: /* lineno is only valid if an input buffer exists. */
2652: if (! YY_CURRENT_BUFFER )
2653: YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
2654:
2655: yylineno = _line_number;
2656: }
2657:
2658: /** Set the current column.
2659: * @param _column_no column number
2660: * @param yyscanner The scanner object.
2661: */
2662: void yyset_column (int _column_no , yyscan_t yyscanner)
2663: {
2664: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2665:
2666: /* column is only valid if an input buffer exists. */
2667: if (! YY_CURRENT_BUFFER )
2668: YY_FATAL_ERROR( "yyset_column called with no buffer" );
2669:
2670: yycolumn = _column_no;
2671: }
2672:
2673: /** Set the input stream. This does not discard the current
2674: * input buffer.
2675: * @param _in_str A readable stream.
2676: * @param yyscanner The scanner object.
2677: * @see yy_switch_to_buffer
2678: */
2679: void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2680: {
2681: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2682: yyin = _in_str ;
2683: }
2684:
2685: void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2686: {
2687: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2688: yyout = _out_str ;
2689: }
2690:
2691: int yyget_debug (yyscan_t yyscanner)
2692: {
2693: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2694: return yy_flex_debug;
2695: }
2696:
2697: void yyset_debug (int _bdebug , yyscan_t yyscanner)
2698: {
2699: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2700: yy_flex_debug = _bdebug ;
2701: }
2702:
2703: /* %endif */
2704:
2705: /* %if-reentrant */
2706: /* Accessor methods for yylval and yylloc */
2707:
2708: /* %if-bison-bridge */
2709:
2710: YYSTYPE * yyget_lval (yyscan_t yyscanner)
2711: {
2712: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2713: return yylval;
2714: }
2715:
2716: void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
2717: {
2718: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2719: yylval = yylval_param;
2720: }
2721:
2722: /* %endif */
2723:
2724: /* User-visible API */
2725:
2726: /* yylex_init is special because it creates the scanner itself, so it is
2727: * the ONLY reentrant function that doesn't take the scanner as the last argument.
2728: * That's why we explicitly handle the declaration, instead of using our macros.
2729: */
2730: int yylex_init(yyscan_t* ptr_yy_globals)
2731: {
2732: if (ptr_yy_globals == NULL){
2733: errno = EINVAL;
2734: return 1;
2735: }
2736:
2737: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2738:
2739: if (*ptr_yy_globals == NULL){
2740: errno = ENOMEM;
2741: return 1;
2742: }
2743:
2744: /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2745: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2746:
2747: return yy_init_globals ( *ptr_yy_globals );
2748: }
2749:
2750: /* yylex_init_extra has the same functionality as yylex_init, but follows the
2751: * convention of taking the scanner as the last argument. Note however, that
2752: * this is a *pointer* to a scanner, as it will be allocated by this call (and
2753: * is the reason, too, why this function also must handle its own declaration).
2754: * The user defined value in the first argument will be available to yyalloc in
2755: * the yyextra field.
2756: */
2757: int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2758: {
2759: struct yyguts_t dummy_yyguts;
2760:
2761: yyset_extra (yy_user_defined, &dummy_yyguts);
2762:
2763: if (ptr_yy_globals == NULL){
2764: errno = EINVAL;
2765: return 1;
2766: }
2767:
2768: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2769:
2770: if (*ptr_yy_globals == NULL){
2771: errno = ENOMEM;
2772: return 1;
2773: }
2774:
2775: /* By setting to 0xAA, we expose bugs in
2776: yy_init_globals. Leave at 0x00 for releases. */
2777: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2778:
2779: yyset_extra (yy_user_defined, *ptr_yy_globals);
2780:
2781: return yy_init_globals ( *ptr_yy_globals );
2782: }
2783:
2784: /* %endif if-c-only */
2785:
2786: /* %if-c-only */
2787: static int yy_init_globals (yyscan_t yyscanner)
2788: {
2789: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2790: /* Initialization is the same as for the non-reentrant scanner.
2791: * This function is called from yylex_destroy(), so don't allocate here.
2792: */
2793:
2794: yyg->yy_buffer_stack = NULL;
2795: yyg->yy_buffer_stack_top = 0;
2796: yyg->yy_buffer_stack_max = 0;
2797: yyg->yy_c_buf_p = NULL;
2798: yyg->yy_init = 0;
2799: yyg->yy_start = 0;
2800:
2801: yyg->yy_start_stack_ptr = 0;
2802: yyg->yy_start_stack_depth = 0;
2803: yyg->yy_start_stack = NULL;
2804:
2805: /* Defined in main.c */
2806: #ifdef YY_STDINIT
2807: yyin = stdin;
2808: yyout = stdout;
2809: #else
2810: yyin = NULL;
2811: yyout = NULL;
2812: #endif
2813:
2814: /* For future reference: Set errno on error, since we are called by
2815: * yylex_init()
2816: */
2817: return 0;
2818: }
2819: /* %endif */
2820:
2821: /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
2822: /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2823: int yylex_destroy (yyscan_t yyscanner)
2824: {
2825: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2826:
2827: /* Pop the buffer stack, destroying each element. */
2828: while(YY_CURRENT_BUFFER){
2829: yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2830: YY_CURRENT_BUFFER_LVALUE = NULL;
2831: yypop_buffer_state(yyscanner);
2832: }
2833:
2834: /* Destroy the stack itself. */
2835: yyfree(yyg->yy_buffer_stack , yyscanner);
2836: yyg->yy_buffer_stack = NULL;
2837:
2838: /* Destroy the start condition stack. */
2839: yyfree( yyg->yy_start_stack , yyscanner );
2840: yyg->yy_start_stack = NULL;
2841:
2842: /* Reset the globals. This is important in a non-reentrant scanner so the next time
2843: * yylex() is called, initialization will occur. */
2844: yy_init_globals( yyscanner);
2845:
2846: /* %if-reentrant */
2847: /* Destroy the main struct (reentrant only). */
2848: yyfree ( yyscanner , yyscanner );
2849: yyscanner = NULL;
2850: /* %endif */
2851: return 0;
2852: }
2853: /* %endif */
2854:
2855: /*
2856: * Internal utility routines.
2857: */
2858:
2859: #ifndef yytext_ptr
2860: static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
2861: {
2862: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2863: (void)yyg;
2864:
2865: int i;
2866: for ( i = 0; i < n; ++i )
2867: s1[i] = s2[i];
2868: }
2869: #endif
2870:
2871: #ifdef YY_NEED_STRLEN
2872: static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
2873: {
2874: int n;
2875: for ( n = 0; s[n]; ++n )
2876: ;
2877:
2878: return n;
2879: }
2880: #endif
2881:
2882: void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2883: {
2884: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2885: (void)yyg;
2886: return malloc(size);
2887: }
2888:
2889: void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2890: {
2891: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2892: (void)yyg;
2893:
2894: /* The cast to (char *) in the following accommodates both
2895: * implementations that use char* generic pointers, and those
2896: * that use void* generic pointers. It works with the latter
2897: * because both ANSI C and C++ allow castless assignment from
2898: * any pointer type to void*, and deal with argument conversions
2899: * as though doing an assignment.
2900: */
2901: return realloc(ptr, size);
2902: }
2903:
2904: void yyfree (void * ptr , yyscan_t yyscanner)
2905: {
2906: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2907: (void)yyg;
2908: free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2909: }
2910:
2911: /* %if-tables-serialization definitions */
2912: /* %define-yytables The name for this specific scanner's tables. */
2913: #define YYTABLES_NAME "yytables"
2914: /* %endif */
2915:
2916: /* %ok-for-header */
2917:
2918: #line 168 "parser/lexer.l"
2919:
2920:
2921: /**
2922: * Open the next file, if any is queued and readable, otherwise returns FALSE.
2923: */
2924: bool conf_parser_open_next_file(parser_helper_t *ctx)
2925: {
2926: FILE *file;
2927:
2928: file = ctx->file_next(ctx);
2929: if (!file)
2930: {
2931: return FALSE;
2932: }
2933:
2934: conf_parser_set_in(file, ctx->scanner);
2935: conf_parser_push_buffer_state(
2936: conf_parser__create_buffer(file, YY_BUF_SIZE,
2937: ctx->scanner), ctx->scanner);
2938: return TRUE;
2939: }
2940:
2941: /**
2942: * Assumes that the file pattern to include is currently stored as string on
2943: * the helper object.
2944: */
2945: static void include_files(parser_helper_t *ctx)
2946: {
2947: char *pattern = ctx->string_get(ctx);
2948:
2949: ctx->file_include(ctx, pattern);
2950: free(pattern);
2951:
2952: conf_parser_open_next_file(ctx);
2953: }
2954:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lexer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / starter / parser