Annotation of embedaddon/strongswan/src/libstrongswan/settings/settings_lexer.c, revision 1.1.1.1
1.1 misho 1: #line 2 "settings/settings_lexer.c"
2:
3: #line 4 "settings/settings_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 settings_parser__create_buffer_ALREADY_DEFINED
30: #else
31: #define yy_create_buffer settings_parser__create_buffer
32: #endif
33:
34: #ifdef yy_delete_buffer
35: #define settings_parser__delete_buffer_ALREADY_DEFINED
36: #else
37: #define yy_delete_buffer settings_parser__delete_buffer
38: #endif
39:
40: #ifdef yy_scan_buffer
41: #define settings_parser__scan_buffer_ALREADY_DEFINED
42: #else
43: #define yy_scan_buffer settings_parser__scan_buffer
44: #endif
45:
46: #ifdef yy_scan_string
47: #define settings_parser__scan_string_ALREADY_DEFINED
48: #else
49: #define yy_scan_string settings_parser__scan_string
50: #endif
51:
52: #ifdef yy_scan_bytes
53: #define settings_parser__scan_bytes_ALREADY_DEFINED
54: #else
55: #define yy_scan_bytes settings_parser__scan_bytes
56: #endif
57:
58: #ifdef yy_init_buffer
59: #define settings_parser__init_buffer_ALREADY_DEFINED
60: #else
61: #define yy_init_buffer settings_parser__init_buffer
62: #endif
63:
64: #ifdef yy_flush_buffer
65: #define settings_parser__flush_buffer_ALREADY_DEFINED
66: #else
67: #define yy_flush_buffer settings_parser__flush_buffer
68: #endif
69:
70: #ifdef yy_load_buffer_state
71: #define settings_parser__load_buffer_state_ALREADY_DEFINED
72: #else
73: #define yy_load_buffer_state settings_parser__load_buffer_state
74: #endif
75:
76: #ifdef yy_switch_to_buffer
77: #define settings_parser__switch_to_buffer_ALREADY_DEFINED
78: #else
79: #define yy_switch_to_buffer settings_parser__switch_to_buffer
80: #endif
81:
82: #ifdef yypush_buffer_state
83: #define settings_parser_push_buffer_state_ALREADY_DEFINED
84: #else
85: #define yypush_buffer_state settings_parser_push_buffer_state
86: #endif
87:
88: #ifdef yypop_buffer_state
89: #define settings_parser_pop_buffer_state_ALREADY_DEFINED
90: #else
91: #define yypop_buffer_state settings_parser_pop_buffer_state
92: #endif
93:
94: #ifdef yyensure_buffer_stack
95: #define settings_parser_ensure_buffer_stack_ALREADY_DEFINED
96: #else
97: #define yyensure_buffer_stack settings_parser_ensure_buffer_stack
98: #endif
99:
100: #ifdef yylex
101: #define settings_parser_lex_ALREADY_DEFINED
102: #else
103: #define yylex settings_parser_lex
104: #endif
105:
106: #ifdef yyrestart
107: #define settings_parser_restart_ALREADY_DEFINED
108: #else
109: #define yyrestart settings_parser_restart
110: #endif
111:
112: #ifdef yylex_init
113: #define settings_parser_lex_init_ALREADY_DEFINED
114: #else
115: #define yylex_init settings_parser_lex_init
116: #endif
117:
118: #ifdef yylex_init_extra
119: #define settings_parser_lex_init_extra_ALREADY_DEFINED
120: #else
121: #define yylex_init_extra settings_parser_lex_init_extra
122: #endif
123:
124: #ifdef yylex_destroy
125: #define settings_parser_lex_destroy_ALREADY_DEFINED
126: #else
127: #define yylex_destroy settings_parser_lex_destroy
128: #endif
129:
130: #ifdef yyget_debug
131: #define settings_parser_get_debug_ALREADY_DEFINED
132: #else
133: #define yyget_debug settings_parser_get_debug
134: #endif
135:
136: #ifdef yyset_debug
137: #define settings_parser_set_debug_ALREADY_DEFINED
138: #else
139: #define yyset_debug settings_parser_set_debug
140: #endif
141:
142: #ifdef yyget_extra
143: #define settings_parser_get_extra_ALREADY_DEFINED
144: #else
145: #define yyget_extra settings_parser_get_extra
146: #endif
147:
148: #ifdef yyset_extra
149: #define settings_parser_set_extra_ALREADY_DEFINED
150: #else
151: #define yyset_extra settings_parser_set_extra
152: #endif
153:
154: #ifdef yyget_in
155: #define settings_parser_get_in_ALREADY_DEFINED
156: #else
157: #define yyget_in settings_parser_get_in
158: #endif
159:
160: #ifdef yyset_in
161: #define settings_parser_set_in_ALREADY_DEFINED
162: #else
163: #define yyset_in settings_parser_set_in
164: #endif
165:
166: #ifdef yyget_out
167: #define settings_parser_get_out_ALREADY_DEFINED
168: #else
169: #define yyget_out settings_parser_get_out
170: #endif
171:
172: #ifdef yyset_out
173: #define settings_parser_set_out_ALREADY_DEFINED
174: #else
175: #define yyset_out settings_parser_set_out
176: #endif
177:
178: #ifdef yyget_leng
179: #define settings_parser_get_leng_ALREADY_DEFINED
180: #else
181: #define yyget_leng settings_parser_get_leng
182: #endif
183:
184: #ifdef yyget_text
185: #define settings_parser_get_text_ALREADY_DEFINED
186: #else
187: #define yyget_text settings_parser_get_text
188: #endif
189:
190: #ifdef yyget_lineno
191: #define settings_parser_get_lineno_ALREADY_DEFINED
192: #else
193: #define yyget_lineno settings_parser_get_lineno
194: #endif
195:
196: #ifdef yyset_lineno
197: #define settings_parser_set_lineno_ALREADY_DEFINED
198: #else
199: #define yyset_lineno settings_parser_set_lineno
200: #endif
201:
202: #ifdef yyget_column
203: #define settings_parser_get_column_ALREADY_DEFINED
204: #else
205: #define yyget_column settings_parser_get_column
206: #endif
207:
208: #ifdef yyset_column
209: #define settings_parser_set_column_ALREADY_DEFINED
210: #else
211: #define yyset_column settings_parser_set_column
212: #endif
213:
214: #ifdef yywrap
215: #define settings_parser_wrap_ALREADY_DEFINED
216: #else
217: #define yywrap settings_parser_wrap
218: #endif
219:
220: /* %endif */
221:
222: #ifdef yyget_lval
223: #define settings_parser_get_lval_ALREADY_DEFINED
224: #else
225: #define yyget_lval settings_parser_get_lval
226: #endif
227:
228: #ifdef yyset_lval
229: #define settings_parser_set_lval_ALREADY_DEFINED
230: #else
231: #define yyset_lval settings_parser_set_lval
232: #endif
233:
234: #ifdef yyalloc
235: #define settings_parser_alloc_ALREADY_DEFINED
236: #else
237: #define yyalloc settings_parser_alloc
238: #endif
239:
240: #ifdef yyrealloc
241: #define settings_parser_realloc_ALREADY_DEFINED
242: #else
243: #define yyrealloc settings_parser_realloc
244: #endif
245:
246: #ifdef yyfree
247: #define settings_parser_free_ALREADY_DEFINED
248: #else
249: #define yyfree settings_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 settings_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 39
664: #define YY_END_OF_BUFFER 40
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[85] =
673: { 0,
674: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
675: 40, 12, 2, 3, 2, 11, 1, 7, 6, 8,
676: 9, 12, 4, 5, 17, 14, 15, 14, 18, 13,
677: 16, 23, 20, 21, 19, 22, 29, 25, 24, 26,
678: 27, 38, 30, 31, 32, 12, 2, 2, 1, 1,
679: 3, 0, 12, 17, 0, 14, 14, 13, 13, 15,
680: 0, 23, 20, 29, 28, 38, 37, 36, 37, 33,
681: 34, 35, 1, 12, 17, 13, 12, 12, 12, 12,
682: 0, 10, 10, 0
683: } ;
684:
685: static const YY_CHAR yy_ec[256] =
686: { 0,
687: 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
688: 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
689: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
690: 1, 5, 1, 6, 7, 1, 1, 1, 1, 1,
691: 1, 1, 1, 8, 1, 9, 1, 1, 1, 1,
692: 1, 1, 1, 1, 1, 1, 1, 10, 1, 1,
693: 11, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
695: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
696: 1, 12, 1, 1, 1, 1, 1, 1, 13, 14,
697:
698: 15, 1, 1, 1, 16, 1, 1, 17, 1, 18,
699: 1, 1, 1, 19, 1, 20, 21, 1, 1, 1,
700: 1, 1, 22, 1, 23, 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: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
708:
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, 1, 1, 1, 1, 1,
714: 1, 1, 1, 1, 1
715: } ;
716:
717: static const YY_CHAR yy_meta[24] =
718: { 0,
719: 1, 2, 3, 4, 5, 6, 5, 7, 8, 7,
720: 9, 10, 1, 1, 1, 1, 1, 1, 1, 1,
721: 1, 7, 5
722: } ;
723:
724: static const flex_int16_t yy_base[103] =
725: { 0,
726: 0, 0, 23, 0, 45, 67, 89, 111, 49, 50,
727: 124, 0, 133, 335, 55, 335, 60, 335, 335, 335,
728: 335, 104, 335, 335, 112, 139, 335, 73, 335, 62,
729: 335, 0, 74, 335, 335, 335, 0, 335, 335, 335,
730: 0, 0, 335, 335, 144, 0, 0, 78, 0, 81,
731: 335, 117, 106, 102, 0, 0, 84, 0, 94, 335,
732: 107, 0, 97, 0, 335, 0, 335, 335, 106, 335,
733: 335, 335, 0, 89, 78, 0, 60, 53, 43, 98,
734: 102, 335, 103, 335, 164, 174, 184, 194, 204, 214,
735: 224, 234, 244, 249, 255, 264, 274, 284, 294, 304,
736:
737: 314, 324
738: } ;
739:
740: static const flex_int16_t yy_def[103] =
741: { 0,
742: 84, 1, 84, 3, 85, 85, 86, 86, 87, 87,
743: 84, 88, 84, 84, 84, 84, 89, 84, 84, 84,
744: 84, 88, 84, 84, 90, 84, 84, 84, 84, 91,
745: 84, 92, 84, 84, 84, 84, 93, 84, 84, 84,
746: 94, 95, 84, 84, 96, 88, 13, 84, 97, 89,
747: 84, 98, 88, 90, 99, 26, 84, 100, 91, 84,
748: 101, 92, 84, 93, 84, 95, 84, 84, 84, 84,
749: 84, 84, 97, 88, 99, 100, 88, 88, 88, 88,
750: 102, 84, 102, 0, 84, 84, 84, 84, 84, 84,
751: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
752:
753: 84, 84
754: } ;
755:
756: static const flex_int16_t yy_nxt[359] =
757: { 0,
758: 12, 13, 14, 15, 13, 16, 17, 18, 19, 20,
759: 21, 12, 12, 12, 12, 22, 12, 12, 12, 12,
760: 12, 23, 24, 25, 26, 27, 28, 26, 29, 30,
761: 31, 29, 29, 29, 25, 25, 25, 25, 25, 25,
762: 25, 25, 25, 25, 29, 29, 33, 34, 35, 33,
763: 36, 34, 43, 43, 44, 44, 48, 80, 48, 48,
764: 45, 45, 51, 52, 60, 61, 79, 34, 33, 34,
765: 35, 33, 36, 34, 57, 63, 57, 57, 63, 48,
766: 78, 48, 48, 51, 52, 57, 55, 57, 57, 34,
767: 38, 38, 39, 38, 40, 38, 60, 61, 63, 81,
768:
769: 41, 63, 81, 83, 83, 77, 83, 83, 68, 60,
770: 55, 38, 38, 38, 39, 38, 40, 38, 74, 51,
771: 55, 53, 41, 84, 84, 84, 84, 84, 84, 84,
772: 84, 84, 84, 38, 47, 84, 48, 47, 84, 49,
773: 56, 84, 57, 56, 84, 58, 68, 69, 84, 84,
774: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
775: 84, 70, 71, 72, 32, 32, 32, 32, 32, 32,
776: 32, 32, 32, 32, 37, 37, 37, 37, 37, 37,
777: 37, 37, 37, 37, 42, 42, 42, 42, 42, 42,
778: 42, 42, 42, 42, 46, 84, 84, 84, 84, 84,
779:
780: 84, 84, 84, 46, 50, 50, 50, 50, 50, 50,
781: 50, 50, 50, 50, 54, 84, 84, 84, 84, 84,
782: 84, 54, 84, 54, 59, 59, 59, 59, 59, 59,
783: 59, 59, 59, 59, 62, 84, 84, 84, 84, 84,
784: 62, 62, 62, 62, 64, 84, 84, 84, 84, 84,
785: 64, 64, 64, 65, 65, 66, 66, 66, 84, 66,
786: 84, 66, 66, 66, 67, 67, 67, 67, 67, 67,
787: 67, 67, 67, 67, 73, 73, 84, 84, 73, 73,
788: 73, 73, 73, 73, 52, 52, 52, 52, 52, 52,
789: 52, 52, 52, 52, 75, 84, 84, 84, 84, 84,
790:
791: 84, 84, 84, 75, 76, 76, 84, 84, 76, 76,
792: 76, 76, 76, 76, 61, 61, 61, 61, 61, 61,
793: 61, 61, 61, 61, 82, 82, 82, 82, 82, 82,
794: 82, 82, 84, 82, 11, 84, 84, 84, 84, 84,
795: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
796: 84, 84, 84, 84, 84, 84, 84, 84
797: } ;
798:
799: static const flex_int16_t yy_chk[359] =
800: { 0,
801: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
802: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
803: 1, 1, 1, 3, 3, 3, 3, 3, 3, 3,
804: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
805: 3, 3, 3, 3, 3, 3, 5, 5, 5, 5,
806: 5, 5, 9, 10, 9, 10, 15, 79, 15, 15,
807: 9, 10, 17, 17, 30, 30, 78, 5, 6, 6,
808: 6, 6, 6, 6, 28, 33, 28, 28, 33, 48,
809: 77, 48, 48, 50, 50, 57, 75, 57, 57, 6,
810: 7, 7, 7, 7, 7, 7, 59, 59, 63, 80,
811:
812: 7, 63, 80, 81, 83, 74, 81, 83, 69, 61,
813: 54, 7, 8, 8, 8, 8, 8, 8, 53, 52,
814: 25, 22, 8, 11, 0, 0, 0, 0, 0, 0,
815: 0, 0, 0, 8, 13, 0, 13, 13, 0, 13,
816: 26, 0, 26, 26, 0, 26, 45, 45, 0, 0,
817: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
818: 0, 45, 45, 45, 85, 85, 85, 85, 85, 85,
819: 85, 85, 85, 85, 86, 86, 86, 86, 86, 86,
820: 86, 86, 86, 86, 87, 87, 87, 87, 87, 87,
821: 87, 87, 87, 87, 88, 0, 0, 0, 0, 0,
822:
823: 0, 0, 0, 88, 89, 89, 89, 89, 89, 89,
824: 89, 89, 89, 89, 90, 0, 0, 0, 0, 0,
825: 0, 90, 0, 90, 91, 91, 91, 91, 91, 91,
826: 91, 91, 91, 91, 92, 0, 0, 0, 0, 0,
827: 92, 92, 92, 92, 93, 0, 0, 0, 0, 0,
828: 93, 93, 93, 94, 94, 95, 95, 95, 0, 95,
829: 0, 95, 95, 95, 96, 96, 96, 96, 96, 96,
830: 96, 96, 96, 96, 97, 97, 0, 0, 97, 97,
831: 97, 97, 97, 97, 98, 98, 98, 98, 98, 98,
832: 98, 98, 98, 98, 99, 0, 0, 0, 0, 0,
833:
834: 0, 0, 0, 99, 100, 100, 0, 0, 100, 100,
835: 100, 100, 100, 100, 101, 101, 101, 101, 101, 101,
836: 101, 101, 101, 101, 102, 102, 102, 102, 102, 102,
837: 102, 102, 0, 102, 84, 84, 84, 84, 84, 84,
838: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
839: 84, 84, 84, 84, 84, 84, 84, 84
840: } ;
841:
842: /* Table of booleans, true if rule could match eol. */
843: static const flex_int32_t yy_rule_can_match_eol[40] =
844: { 0,
845: 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
846: 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
847: };
848:
849: static const flex_int16_t yy_rule_linenum[39] =
850: { 0,
851: 71, 72, 73, 75, 76, 78, 79, 81, 86, 91,
852: 96, 101, 107, 108, 109, 111, 113, 118, 125, 126,
853: 128, 149, 155, 162, 165, 185, 188, 191, 194, 200,
854: 201, 203, 223, 224, 225, 226, 227, 228
855: } ;
856:
857: /* The intent behind this definition is that it'll catch
858: * any uses of REJECT which flex missed.
859: */
860: #define REJECT reject_used_but_not_detected
861: #define yymore() yymore_used_but_not_detected
862: #define YY_MORE_ADJ 0
863: #define YY_RESTORE_YY_MORE_OFFSET
864: #line 1 "settings/settings_lexer.l"
865: #line 2 "settings/settings_lexer.l"
866: /*
867: * Copyright (C) 2014-2018 Tobias Brunner
868: * HSR Hochschule fuer Technik Rapperswil
869: *
870: * This program is free software; you can redistribute it and/or modify it
871: * under the terms of the GNU General Public License as published by the
872: * Free Software Foundation; either version 2 of the License, or (at your
873: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
874: *
875: * This program is distributed in the hope that it will be useful, but
876: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
877: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
878: * for more details.
879: */
880:
881: #include <utils/parser_helper.h>
882:
883: #include "settings_parser.h"
884:
885: bool settings_parser_open_next_file(parser_helper_t *ctx);
886:
887: static void include_files(parser_helper_t *ctx);
888:
889: #line 890 "settings/settings_lexer.c"
890: /* use start conditions stack */
891: /* do not declare unneeded functions */
892: #define YY_NO_INPUT 1
893: /* do not include unistd.h as it might conflict with our scanner states */
894: #define YY_NO_UNISTD_H 1
895: /* due to that disable interactive mode, which requires isatty() */
896: /* don't use global variables, and interact properly with bison */
897: /* maintain the line number */
898: /* don't generate a default rule */
899: /* prefix function/variable declarations */
900: /* don't change the name of the output file otherwise autotools has issues */
901: /* type of our extra data */
902: /* state used to scan references */
903:
904: /* state used to scan values */
905:
906: /* state used to scan include file patterns */
907:
908: /* state used to scan quoted strings */
909:
910: /* pattern for section/key names */
911: #line 912 "settings/settings_lexer.c"
912:
913: #define INITIAL 0
914: #define ref 1
915: #define val 2
916: #define inc 3
917: #define str 4
918:
919: #ifndef YY_NO_UNISTD_H
920: /* Special case for "unistd.h", since it is non-ANSI. We include it way
921: * down here because we want the user's section 1 to have been scanned first.
922: * The user has a chance to override it with an option.
923: */
924: /* %if-c-only */
925: #include <unistd.h>
926: /* %endif */
927: /* %if-c++-only */
928: /* %endif */
929: #endif
930:
931: #define YY_EXTRA_TYPE parser_helper_t*
932:
933: /* %if-c-only Reentrant structure and macros (non-C++). */
934: /* %if-reentrant */
935:
936: /* Holds the entire state of the reentrant scanner. */
937: struct yyguts_t
938: {
939:
940: /* User-defined. Not touched by flex. */
941: YY_EXTRA_TYPE yyextra_r;
942:
943: /* The rest are the same as the globals declared in the non-reentrant scanner. */
944: FILE *yyin_r, *yyout_r;
945: size_t yy_buffer_stack_top; /**< index of top of stack. */
946: size_t yy_buffer_stack_max; /**< capacity of stack. */
947: YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
948: char yy_hold_char;
949: int yy_n_chars;
950: int yyleng_r;
951: char *yy_c_buf_p;
952: int yy_init;
953: int yy_start;
954: int yy_did_buffer_switch_on_eof;
955: int yy_start_stack_ptr;
956: int yy_start_stack_depth;
957: int *yy_start_stack;
958: yy_state_type yy_last_accepting_state;
959: char* yy_last_accepting_cpos;
960:
961: int yylineno_r;
962: int yy_flex_debug_r;
963:
964: char *yytext_r;
965: int yy_more_flag;
966: int yy_more_len;
967:
968: YYSTYPE * yylval_r;
969:
970: }; /* end struct yyguts_t */
971:
972: /* %if-c-only */
973:
974: static int yy_init_globals ( yyscan_t yyscanner );
975:
976: /* %endif */
977:
978: /* %if-reentrant */
979:
980: /* This must go here because YYSTYPE and YYLTYPE are included
981: * from bison output in section 1.*/
982: # define yylval yyg->yylval_r
983:
984: int yylex_init (yyscan_t* scanner);
985:
986: int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
987:
988: /* %endif */
989:
990: /* %endif End reentrant structures and macros. */
991:
992: /* Accessor methods to globals.
993: These are made visible to non-reentrant scanners for convenience. */
994:
995: int yylex_destroy ( yyscan_t yyscanner );
996:
997: int yyget_debug ( yyscan_t yyscanner );
998:
999: void yyset_debug ( int debug_flag , yyscan_t yyscanner );
1000:
1001: YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
1002:
1003: void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
1004:
1005: FILE *yyget_in ( yyscan_t yyscanner );
1006:
1007: void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
1008:
1009: FILE *yyget_out ( yyscan_t yyscanner );
1010:
1011: void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
1012:
1013: int yyget_leng ( yyscan_t yyscanner );
1014:
1015: char *yyget_text ( yyscan_t yyscanner );
1016:
1017: int yyget_lineno ( yyscan_t yyscanner );
1018:
1019: void yyset_lineno ( int _line_number , yyscan_t yyscanner );
1020:
1021: int yyget_column ( yyscan_t yyscanner );
1022:
1023: void yyset_column ( int _column_no , yyscan_t yyscanner );
1024:
1025: /* %if-bison-bridge */
1026:
1027: YYSTYPE * yyget_lval ( yyscan_t yyscanner );
1028:
1029: void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
1030:
1031: /* %endif */
1032:
1033: /* Macros after this point can all be overridden by user definitions in
1034: * section 1.
1035: */
1036:
1037: #ifndef YY_SKIP_YYWRAP
1038: #ifdef __cplusplus
1039: extern "C" int yywrap ( yyscan_t yyscanner );
1040: #else
1041: extern int yywrap ( yyscan_t yyscanner );
1042: #endif
1043: #endif
1044:
1045: /* %not-for-header */
1046: #ifndef YY_NO_UNPUT
1047:
1048: static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner);
1049:
1050: #endif
1051: /* %ok-for-header */
1052:
1053: /* %endif */
1054:
1055: #ifndef yytext_ptr
1056: static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
1057: #endif
1058:
1059: #ifdef YY_NEED_STRLEN
1060: static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
1061: #endif
1062:
1063: #ifndef YY_NO_INPUT
1064: /* %if-c-only Standard (non-C++) definition */
1065: /* %not-for-header */
1066: #ifdef __cplusplus
1067: static int yyinput ( yyscan_t yyscanner );
1068: #else
1069: static int input ( yyscan_t yyscanner );
1070: #endif
1071: /* %ok-for-header */
1072:
1073: /* %endif */
1074: #endif
1075:
1076: /* %if-c-only */
1077:
1078: static void yy_push_state ( int _new_state , yyscan_t yyscanner);
1079:
1080: static void yy_pop_state ( yyscan_t yyscanner );
1081:
1082: static int yy_top_state ( yyscan_t yyscanner );
1083:
1084: /* %endif */
1085:
1086: /* Amount of stuff to slurp up with each read. */
1087: #ifndef YY_READ_BUF_SIZE
1088: #ifdef __ia64__
1089: /* On IA-64, the buffer size is 16k, not 8k */
1090: #define YY_READ_BUF_SIZE 16384
1091: #else
1092: #define YY_READ_BUF_SIZE 8192
1093: #endif /* __ia64__ */
1094: #endif
1095:
1096: /* Copy whatever the last rule matched to the standard output. */
1097: #ifndef ECHO
1098: /* %if-c-only Standard (non-C++) definition */
1099: /* This used to be an fputs(), but since the string might contain NUL's,
1100: * we now use fwrite().
1101: */
1102: #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1103: /* %endif */
1104: /* %if-c++-only C++ definition */
1105: /* %endif */
1106: #endif
1107:
1108: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1109: * is returned in "result".
1110: */
1111: #ifndef YY_INPUT
1112: #define YY_INPUT(buf,result,max_size) \
1113: /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
1114: if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1115: { \
1116: int c = '*'; \
1117: int n; \
1118: for ( n = 0; n < max_size && \
1119: (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1120: buf[n] = (char) c; \
1121: if ( c == '\n' ) \
1122: buf[n++] = (char) c; \
1123: if ( c == EOF && ferror( yyin ) ) \
1124: YY_FATAL_ERROR( "input in flex scanner failed" ); \
1125: result = n; \
1126: } \
1127: else \
1128: { \
1129: errno=0; \
1130: while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
1131: { \
1132: if( errno != EINTR) \
1133: { \
1134: YY_FATAL_ERROR( "input in flex scanner failed" ); \
1135: break; \
1136: } \
1137: errno=0; \
1138: clearerr(yyin); \
1139: } \
1140: }\
1141: \
1142: /* %if-c++-only C++ definition \ */\
1143: /* %endif */
1144:
1145: #endif
1146:
1147: /* No semi-colon after return; correct usage is to write "yyterminate();" -
1148: * we don't want an extra ';' after the "return" because that will cause
1149: * some compilers to complain about unreachable statements.
1150: */
1151: #ifndef yyterminate
1152: #define yyterminate() return YY_NULL
1153: #endif
1154:
1155: /* Number of entries by which start-condition stack grows. */
1156: #ifndef YY_START_STACK_INCR
1157: #define YY_START_STACK_INCR 25
1158: #endif
1159:
1160: /* Report a fatal error. */
1161: #ifndef YY_FATAL_ERROR
1162: /* %if-c-only */
1163: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1164: /* %endif */
1165: /* %if-c++-only */
1166: /* %endif */
1167: #endif
1168:
1169: /* %if-tables-serialization structures and prototypes */
1170: /* %not-for-header */
1171: /* %ok-for-header */
1172:
1173: /* %not-for-header */
1174: /* %tables-yydmap generated elements */
1175: /* %endif */
1176: /* end tables serialization structures and prototypes */
1177:
1178: /* %ok-for-header */
1179:
1180: /* Default declaration of generated scanner - a define so the user can
1181: * easily add parameters.
1182: */
1183: #ifndef YY_DECL
1184: #define YY_DECL_IS_OURS 1
1185: /* %if-c-only Standard (non-C++) definition */
1186:
1187: extern int yylex \
1188: (YYSTYPE * yylval_param , yyscan_t yyscanner);
1189:
1190: #define YY_DECL int yylex \
1191: (YYSTYPE * yylval_param , yyscan_t yyscanner)
1192: /* %endif */
1193: /* %if-c++-only C++ definition */
1194: /* %endif */
1195: #endif /* !YY_DECL */
1196:
1197: /* Code executed at the beginning of each rule, after yytext and yyleng
1198: * have been set up.
1199: */
1200: #ifndef YY_USER_ACTION
1201: #define YY_USER_ACTION
1202: #endif
1203:
1204: /* Code executed at the end of each rule. */
1205: #ifndef YY_BREAK
1206: #define YY_BREAK /*LINTED*/break;
1207: #endif
1208:
1209: /* %% [6.0] YY_RULE_SETUP definition goes here */
1210: #define YY_RULE_SETUP \
1211: YY_USER_ACTION
1212:
1213: /* %not-for-header */
1214: /** The main scanner function which does all the work.
1215: */
1216: YY_DECL
1217: {
1218: yy_state_type yy_current_state;
1219: char *yy_cp, *yy_bp;
1220: int yy_act;
1221: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1222:
1223: yylval = yylval_param;
1224:
1225: if ( !yyg->yy_init )
1226: {
1227: yyg->yy_init = 1;
1228:
1229: #ifdef YY_USER_INIT
1230: YY_USER_INIT;
1231: #endif
1232:
1233: if ( ! yyg->yy_start )
1234: yyg->yy_start = 1; /* first start state */
1235:
1236: if ( ! yyin )
1237: /* %if-c-only */
1238: yyin = stdin;
1239: /* %endif */
1240: /* %if-c++-only */
1241: /* %endif */
1242:
1243: if ( ! yyout )
1244: /* %if-c-only */
1245: yyout = stdout;
1246: /* %endif */
1247: /* %if-c++-only */
1248: /* %endif */
1249:
1250: if ( ! YY_CURRENT_BUFFER ) {
1251: yyensure_buffer_stack (yyscanner);
1252: YY_CURRENT_BUFFER_LVALUE =
1253: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1254: }
1255:
1256: yy_load_buffer_state( yyscanner );
1257: }
1258:
1259: {
1260: /* %% [7.0] user's declarations go here */
1261: #line 69 "settings/settings_lexer.l"
1262:
1263:
1264: #line 1265 "settings/settings_lexer.c"
1265:
1266: while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1267: {
1268: /* %% [8.0] yymore()-related code goes here */
1269: yy_cp = yyg->yy_c_buf_p;
1270:
1271: /* Support of yytext. */
1272: *yy_cp = yyg->yy_hold_char;
1273:
1274: /* yy_bp points to the position in yy_ch_buf of the start of
1275: * the current run.
1276: */
1277: yy_bp = yy_cp;
1278:
1279: /* %% [9.0] code to set up and find next match goes here */
1280: yy_current_state = yyg->yy_start;
1281: yy_match:
1282: do
1283: {
1284: YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1285: if ( yy_accept[yy_current_state] )
1286: {
1287: yyg->yy_last_accepting_state = yy_current_state;
1288: yyg->yy_last_accepting_cpos = yy_cp;
1289: }
1290: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1291: {
1292: yy_current_state = (int) yy_def[yy_current_state];
1293: if ( yy_current_state >= 85 )
1294: yy_c = yy_meta[yy_c];
1295: }
1296: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1297: ++yy_cp;
1298: }
1299: while ( yy_current_state != 84 );
1300: yy_cp = yyg->yy_last_accepting_cpos;
1301: yy_current_state = yyg->yy_last_accepting_state;
1302:
1303: yy_find_action:
1304: /* %% [10.0] code to find the action number goes here */
1305: yy_act = yy_accept[yy_current_state];
1306:
1307: YY_DO_BEFORE_ACTION;
1308:
1309: /* %% [11.0] code for yylineno update goes here */
1310:
1311: if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1312: {
1313: int yyl;
1314: for ( yyl = 0; yyl < yyleng; ++yyl )
1315: if ( yytext[yyl] == '\n' )
1316:
1317: do{ yylineno++;
1318: yycolumn=0;
1319: }while(0)
1320: ;
1321: }
1322:
1323: do_action: /* This label is used only to access EOF actions. */
1324:
1325: /* %% [12.0] debug code goes here */
1326: if ( yy_flex_debug )
1327: {
1328: if ( yy_act == 0 )
1329: fprintf( stderr, "--scanner backing up\n" );
1330: else if ( yy_act < 39 )
1331: fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
1332: (long)yy_rule_linenum[yy_act], yytext );
1333: else if ( yy_act == 39 )
1334: fprintf( stderr, "--accepting default rule (\"%s\")\n",
1335: yytext );
1336: else if ( yy_act == 40 )
1337: fprintf( stderr, "--(end of buffer or a NUL)\n" );
1338: else
1339: fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
1340: }
1341:
1342: switch ( yy_act )
1343: { /* beginning of action switch */
1344: /* %% [13.0] actions go here */
1345: case 0: /* must back up */
1346: /* undo the effects of YY_DO_BEFORE_ACTION */
1347: *yy_cp = yyg->yy_hold_char;
1348: yy_cp = yyg->yy_last_accepting_cpos;
1349: yy_current_state = yyg->yy_last_accepting_state;
1350: goto yy_find_action;
1351:
1352: case 1:
1353: YY_RULE_SETUP
1354: #line 71 "settings/settings_lexer.l"
1355: /* eat comments */
1356: YY_BREAK
1357: case 2:
1358: YY_RULE_SETUP
1359: #line 72 "settings/settings_lexer.l"
1360: /* eat whitespace */
1361: YY_BREAK
1362: case 3:
1363: /* rule 3 can match eol */
1364: YY_RULE_SETUP
1365: #line 73 "settings/settings_lexer.l"
1366: /* eat newlines and comments at the end of a line */
1367: YY_BREAK
1368: case 4:
1369: #line 76 "settings/settings_lexer.l"
1370: case 5:
1371: YY_RULE_SETUP
1372: #line 76 "settings/settings_lexer.l"
1373: return yytext[0];
1374: YY_BREAK
1375: case 6:
1376: YY_RULE_SETUP
1377: #line 78 "settings/settings_lexer.l"
1378: return DOT;
1379: YY_BREAK
1380: case 7:
1381: YY_RULE_SETUP
1382: #line 79 "settings/settings_lexer.l"
1383: return COMMA;
1384: YY_BREAK
1385: case 8:
1386: YY_RULE_SETUP
1387: #line 81 "settings/settings_lexer.l"
1388: {
1389: yy_push_state(ref, yyscanner);
1390: return COLON;
1391: }
1392: YY_BREAK
1393: case 9:
1394: YY_RULE_SETUP
1395: #line 86 "settings/settings_lexer.l"
1396: {
1397: yy_push_state(val, yyscanner);
1398: return yytext[0];
1399: }
1400: YY_BREAK
1401: case 10:
1402: /* rule 10 can match eol */
1403: *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
1404: YY_LINENO_REWIND_TO(yy_cp - 1);
1405: yyg->yy_c_buf_p = yy_cp -= 1;
1406: YY_DO_BEFORE_ACTION; /* set up yytext again */
1407: YY_RULE_SETUP
1408: #line 91 "settings/settings_lexer.l"
1409: {
1410: yyextra->string_init(yyextra);
1411: yy_push_state(inc, yyscanner);
1412: }
1413: YY_BREAK
1414: case 11:
1415: YY_RULE_SETUP
1416: #line 96 "settings/settings_lexer.l"
1417: {
1418: PARSER_DBG1(yyextra, "unexpected string detected");
1419: return STRING_ERROR;
1420: }
1421: YY_BREAK
1422: case 12:
1423: YY_RULE_SETUP
1424: #line 101 "settings/settings_lexer.l"
1425: {
1426: yylval->s = strdup(yytext);
1427: return NAME;
1428: }
1429: YY_BREAK
1430:
1431: case 13:
1432: YY_RULE_SETUP
1433: #line 107 "settings/settings_lexer.l"
1434: /* eat comments */
1435: YY_BREAK
1436: case 14:
1437: YY_RULE_SETUP
1438: #line 108 "settings/settings_lexer.l"
1439: /* eat whitespace */
1440: YY_BREAK
1441: case 15:
1442: /* rule 15 can match eol */
1443: YY_RULE_SETUP
1444: #line 109 "settings/settings_lexer.l"
1445: /* eat newlines and comments at the end of a line */
1446: YY_BREAK
1447: case 16:
1448: YY_RULE_SETUP
1449: #line 111 "settings/settings_lexer.l"
1450: return COMMA;
1451: YY_BREAK
1452: case 17:
1453: YY_RULE_SETUP
1454: #line 113 "settings/settings_lexer.l"
1455: {
1456: yylval->s = strdup(yytext);
1457: return NAME;
1458: }
1459: YY_BREAK
1460: case 18:
1461: YY_RULE_SETUP
1462: #line 118 "settings/settings_lexer.l"
1463: {
1464: unput(yytext[0]);
1465: yy_pop_state(yyscanner);
1466: }
1467: YY_BREAK
1468:
1469:
1470: case 19:
1471: YY_RULE_SETUP
1472: #line 125 "settings/settings_lexer.l"
1473: /* just ignore these */
1474: YY_BREAK
1475: case 20:
1476: YY_RULE_SETUP
1477: #line 126 "settings/settings_lexer.l"
1478:
1479: YY_BREAK
1480: case YY_STATE_EOF(val):
1481: #line 127 "settings/settings_lexer.l"
1482: case 21:
1483: /* rule 21 can match eol */
1484: YY_RULE_SETUP
1485: #line 128 "settings/settings_lexer.l"
1486: {
1487: if (*yytext)
1488: {
1489: switch (yytext[0])
1490: {
1491: case '\n':
1492: /* put the newline back to fix the line numbers */
1493: unput('\n');
1494: yy_set_bol(0);
1495: break;
1496: case '#':
1497: case '}':
1498: /* these are parsed outside of this start condition */
1499: unput(yytext[0]);
1500: break;
1501: }
1502: }
1503: yy_pop_state(yyscanner);
1504: return NEWLINE;
1505: }
1506: YY_BREAK
1507: case 22:
1508: YY_RULE_SETUP
1509: #line 149 "settings/settings_lexer.l"
1510: {
1511: yyextra->string_init(yyextra);
1512: yy_push_state(str, yyscanner);
1513: }
1514: YY_BREAK
1515: /* same as above, but allow more characters */
1516: case 23:
1517: YY_RULE_SETUP
1518: #line 155 "settings/settings_lexer.l"
1519: {
1520: yylval->s = strdup(yytext);
1521: return NAME;
1522: }
1523: YY_BREAK
1524:
1525:
1526: case 24:
1527: YY_RULE_SETUP
1528: #line 162 "settings/settings_lexer.l"
1529: /* just ignore these */
1530: YY_BREAK
1531: /* we allow all characters except #, } and spaces, they can be escaped */
1532: case YY_STATE_EOF(inc):
1533: #line 164 "settings/settings_lexer.l"
1534: case 25:
1535: /* rule 25 can match eol */
1536: YY_RULE_SETUP
1537: #line 165 "settings/settings_lexer.l"
1538: {
1539: if (*yytext)
1540: {
1541: switch (yytext[0])
1542: {
1543: case '\n':
1544: /* put the newline back to fix the line numbers */
1545: unput('\n');
1546: yy_set_bol(0);
1547: break;
1548: case '#':
1549: case '}':
1550: /* these are parsed outside of this start condition */
1551: unput(yytext[0]);
1552: break;
1553: }
1554: }
1555: include_files(yyextra);
1556: yy_pop_state(yyscanner);
1557: }
1558: YY_BREAK
1559: case 26:
1560: YY_RULE_SETUP
1561: #line 185 "settings/settings_lexer.l"
1562: { /* string include */
1563: yy_push_state(str, yyscanner);
1564: }
1565: YY_BREAK
1566: case 27:
1567: YY_RULE_SETUP
1568: #line 188 "settings/settings_lexer.l"
1569: {
1570: yyextra->string_add(yyextra, yytext);
1571: }
1572: YY_BREAK
1573: case 28:
1574: YY_RULE_SETUP
1575: #line 191 "settings/settings_lexer.l"
1576: {
1577: yyextra->string_add(yyextra, yytext+1);
1578: }
1579: YY_BREAK
1580: case 29:
1581: YY_RULE_SETUP
1582: #line 194 "settings/settings_lexer.l"
1583: {
1584: yyextra->string_add(yyextra, yytext);
1585: }
1586: YY_BREAK
1587:
1588:
1589: case 30:
1590: YY_RULE_SETUP
1591: #line 200 "settings/settings_lexer.l"
1592: /* just ignore these */
1593: YY_BREAK
1594: case 31:
1595: #line 202 "settings/settings_lexer.l"
1596: YY_RULE_SETUP
1597: case YY_STATE_EOF(str):
1598: #line 202 "settings/settings_lexer.l"
1599: case 32:
1600: YY_RULE_SETUP
1601: #line 203 "settings/settings_lexer.l"
1602: {
1603: if (!streq(yytext, "\""))
1604: {
1605: PARSER_DBG1(yyextra, "unterminated string detected");
1606: return STRING_ERROR;
1607: }
1608: if (yy_top_state(yyscanner) == inc)
1609: { /* string include */
1610: include_files(yyextra);
1611: yy_pop_state(yyscanner);
1612: yy_pop_state(yyscanner);
1613: }
1614: else
1615: {
1616: yy_pop_state(yyscanner);
1617: yylval->s = yyextra->string_get(yyextra);
1618: return STRING;
1619: }
1620: }
1621: YY_BREAK
1622: case 33:
1623: YY_RULE_SETUP
1624: #line 223 "settings/settings_lexer.l"
1625: yyextra->string_add(yyextra, "\n");
1626: YY_BREAK
1627: case 34:
1628: YY_RULE_SETUP
1629: #line 224 "settings/settings_lexer.l"
1630: yyextra->string_add(yyextra, "\r");
1631: YY_BREAK
1632: case 35:
1633: YY_RULE_SETUP
1634: #line 225 "settings/settings_lexer.l"
1635: yyextra->string_add(yyextra, "\t");
1636: YY_BREAK
1637: case 36:
1638: /* rule 36 can match eol */
1639: YY_RULE_SETUP
1640: #line 226 "settings/settings_lexer.l"
1641: /* merge lines that end with escaped EOL characters */
1642: YY_BREAK
1643: case 37:
1644: YY_RULE_SETUP
1645: #line 227 "settings/settings_lexer.l"
1646: yyextra->string_add(yyextra, yytext+1);
1647: YY_BREAK
1648: case 38:
1649: /* rule 38 can match eol */
1650: YY_RULE_SETUP
1651: #line 228 "settings/settings_lexer.l"
1652: {
1653: yyextra->string_add(yyextra, yytext);
1654: }
1655: YY_BREAK
1656:
1657: case YY_STATE_EOF(INITIAL):
1658: case YY_STATE_EOF(ref):
1659: #line 233 "settings/settings_lexer.l"
1660: {
1661: settings_parser_pop_buffer_state(yyscanner);
1662: if (!settings_parser_open_next_file(yyextra) && !YY_CURRENT_BUFFER)
1663: {
1664: yyterminate();
1665: }
1666: }
1667: YY_BREAK
1668: case 39:
1669: YY_RULE_SETUP
1670: #line 241 "settings/settings_lexer.l"
1671: YY_FATAL_ERROR( "flex scanner jammed" );
1672: YY_BREAK
1673: #line 1674 "settings/settings_lexer.c"
1674:
1675: case YY_END_OF_BUFFER:
1676: {
1677: /* Amount of text matched not including the EOB char. */
1678: int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1679:
1680: /* Undo the effects of YY_DO_BEFORE_ACTION. */
1681: *yy_cp = yyg->yy_hold_char;
1682: YY_RESTORE_YY_MORE_OFFSET
1683:
1684: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1685: {
1686: /* We're scanning a new file or input source. It's
1687: * possible that this happened because the user
1688: * just pointed yyin at a new source and called
1689: * yylex(). If so, then we have to assure
1690: * consistency between YY_CURRENT_BUFFER and our
1691: * globals. Here is the right place to do so, because
1692: * this is the first action (other than possibly a
1693: * back-up) that will match for the new input source.
1694: */
1695: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1696: /* %if-c-only */
1697: YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1698: /* %endif */
1699: /* %if-c++-only */
1700: /* %endif */
1701: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1702: }
1703:
1704: /* Note that here we test for yy_c_buf_p "<=" to the position
1705: * of the first EOB in the buffer, since yy_c_buf_p will
1706: * already have been incremented past the NUL character
1707: * (since all states make transitions on EOB to the
1708: * end-of-buffer state). Contrast this with the test
1709: * in input().
1710: */
1711: if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1712: { /* This was really a NUL. */
1713: yy_state_type yy_next_state;
1714:
1715: yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1716:
1717: yy_current_state = yy_get_previous_state( yyscanner );
1718:
1719: /* Okay, we're now positioned to make the NUL
1720: * transition. We couldn't have
1721: * yy_get_previous_state() go ahead and do it
1722: * for us because it doesn't know how to deal
1723: * with the possibility of jamming (and we don't
1724: * want to build jamming into it because then it
1725: * will run more slowly).
1726: */
1727:
1728: yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1729:
1730: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1731:
1732: if ( yy_next_state )
1733: {
1734: /* Consume the NUL. */
1735: yy_cp = ++yyg->yy_c_buf_p;
1736: yy_current_state = yy_next_state;
1737: goto yy_match;
1738: }
1739:
1740: else
1741: {
1742: /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
1743: yy_cp = yyg->yy_last_accepting_cpos;
1744: yy_current_state = yyg->yy_last_accepting_state;
1745: goto yy_find_action;
1746: }
1747: }
1748:
1749: else switch ( yy_get_next_buffer( yyscanner ) )
1750: {
1751: case EOB_ACT_END_OF_FILE:
1752: {
1753: yyg->yy_did_buffer_switch_on_eof = 0;
1754:
1755: if ( yywrap( yyscanner ) )
1756: {
1757: /* Note: because we've taken care in
1758: * yy_get_next_buffer() to have set up
1759: * yytext, we can now set up
1760: * yy_c_buf_p so that if some total
1761: * hoser (like flex itself) wants to
1762: * call the scanner after we return the
1763: * YY_NULL, it'll still work - another
1764: * YY_NULL will get returned.
1765: */
1766: yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1767:
1768: yy_act = YY_STATE_EOF(YY_START);
1769: goto do_action;
1770: }
1771:
1772: else
1773: {
1774: if ( ! yyg->yy_did_buffer_switch_on_eof )
1775: YY_NEW_FILE;
1776: }
1777: break;
1778: }
1779:
1780: case EOB_ACT_CONTINUE_SCAN:
1781: yyg->yy_c_buf_p =
1782: yyg->yytext_ptr + yy_amount_of_matched_text;
1783:
1784: yy_current_state = yy_get_previous_state( yyscanner );
1785:
1786: yy_cp = yyg->yy_c_buf_p;
1787: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1788: goto yy_match;
1789:
1790: case EOB_ACT_LAST_MATCH:
1791: yyg->yy_c_buf_p =
1792: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1793:
1794: yy_current_state = yy_get_previous_state( yyscanner );
1795:
1796: yy_cp = yyg->yy_c_buf_p;
1797: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1798: goto yy_find_action;
1799: }
1800: break;
1801: }
1802:
1803: default:
1804: YY_FATAL_ERROR(
1805: "fatal flex scanner internal error--no action found" );
1806: } /* end of action switch */
1807: } /* end of scanning one token */
1808: } /* end of user's declarations */
1809: } /* end of yylex */
1810: /* %ok-for-header */
1811:
1812: /* %if-c++-only */
1813: /* %not-for-header */
1814: /* %ok-for-header */
1815:
1816: /* %endif */
1817:
1818: /* yy_get_next_buffer - try to read in a new buffer
1819: *
1820: * Returns a code representing an action:
1821: * EOB_ACT_LAST_MATCH -
1822: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1823: * EOB_ACT_END_OF_FILE - end of file
1824: */
1825: /* %if-c-only */
1826: static int yy_get_next_buffer (yyscan_t yyscanner)
1827: /* %endif */
1828: /* %if-c++-only */
1829: /* %endif */
1830: {
1831: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1832: char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1833: char *source = yyg->yytext_ptr;
1834: int number_to_move, i;
1835: int ret_val;
1836:
1837: if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1838: YY_FATAL_ERROR(
1839: "fatal flex scanner internal error--end of buffer missed" );
1840:
1841: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1842: { /* Don't try to fill the buffer, so this is an EOF. */
1843: if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1844: {
1845: /* We matched a single character, the EOB, so
1846: * treat this as a final EOF.
1847: */
1848: return EOB_ACT_END_OF_FILE;
1849: }
1850:
1851: else
1852: {
1853: /* We matched some text prior to the EOB, first
1854: * process it.
1855: */
1856: return EOB_ACT_LAST_MATCH;
1857: }
1858: }
1859:
1860: /* Try to read more data. */
1861:
1862: /* First move last chars to start of buffer. */
1863: number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1864:
1865: for ( i = 0; i < number_to_move; ++i )
1866: *(dest++) = *(source++);
1867:
1868: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1869: /* don't do the read, it's not guaranteed to return an EOF,
1870: * just force an EOF
1871: */
1872: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1873:
1874: else
1875: {
1876: int num_to_read =
1877: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1878:
1879: while ( num_to_read <= 0 )
1880: { /* Not enough room in the buffer - grow it. */
1881:
1882: /* just a shorter name for the current buffer */
1883: YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1884:
1885: int yy_c_buf_p_offset =
1886: (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1887:
1888: if ( b->yy_is_our_buffer )
1889: {
1890: int new_size = b->yy_buf_size * 2;
1891:
1892: if ( new_size <= 0 )
1893: b->yy_buf_size += b->yy_buf_size / 8;
1894: else
1895: b->yy_buf_size *= 2;
1896:
1897: b->yy_ch_buf = (char *)
1898: /* Include room in for 2 EOB chars. */
1899: yyrealloc( (void *) b->yy_ch_buf,
1900: (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1901: }
1902: else
1903: /* Can't grow it, we don't own it. */
1904: b->yy_ch_buf = NULL;
1905:
1906: if ( ! b->yy_ch_buf )
1907: YY_FATAL_ERROR(
1908: "fatal error - scanner input buffer overflow" );
1909:
1910: yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1911:
1912: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1913: number_to_move - 1;
1914:
1915: }
1916:
1917: if ( num_to_read > YY_READ_BUF_SIZE )
1918: num_to_read = YY_READ_BUF_SIZE;
1919:
1920: /* Read in more data. */
1921: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1922: yyg->yy_n_chars, num_to_read );
1923:
1924: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1925: }
1926:
1927: if ( yyg->yy_n_chars == 0 )
1928: {
1929: if ( number_to_move == YY_MORE_ADJ )
1930: {
1931: ret_val = EOB_ACT_END_OF_FILE;
1932: yyrestart( yyin , yyscanner);
1933: }
1934:
1935: else
1936: {
1937: ret_val = EOB_ACT_LAST_MATCH;
1938: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1939: YY_BUFFER_EOF_PENDING;
1940: }
1941: }
1942:
1943: else
1944: ret_val = EOB_ACT_CONTINUE_SCAN;
1945:
1946: if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1947: /* Extend the array by 50%, plus the number we really need. */
1948: int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1949: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1950: (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1951: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1952: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1953: /* "- 2" to take care of EOB's */
1954: YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1955: }
1956:
1957: yyg->yy_n_chars += number_to_move;
1958: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1959: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1960:
1961: yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1962:
1963: return ret_val;
1964: }
1965:
1966: /* yy_get_previous_state - get the state just before the EOB char was reached */
1967:
1968: /* %if-c-only */
1969: /* %not-for-header */
1970: static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1971: /* %endif */
1972: /* %if-c++-only */
1973: /* %endif */
1974: {
1975: yy_state_type yy_current_state;
1976: char *yy_cp;
1977: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1978:
1979: /* %% [15.0] code to get the start state into yy_current_state goes here */
1980: yy_current_state = yyg->yy_start;
1981:
1982: for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1983: {
1984: /* %% [16.0] code to find the next state goes here */
1985: YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1986: if ( yy_accept[yy_current_state] )
1987: {
1988: yyg->yy_last_accepting_state = yy_current_state;
1989: yyg->yy_last_accepting_cpos = yy_cp;
1990: }
1991: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1992: {
1993: yy_current_state = (int) yy_def[yy_current_state];
1994: if ( yy_current_state >= 85 )
1995: yy_c = yy_meta[yy_c];
1996: }
1997: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1998: }
1999:
2000: return yy_current_state;
2001: }
2002:
2003: /* yy_try_NUL_trans - try to make a transition on the NUL character
2004: *
2005: * synopsis
2006: * next_state = yy_try_NUL_trans( current_state );
2007: */
2008: /* %if-c-only */
2009: static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
2010: /* %endif */
2011: /* %if-c++-only */
2012: /* %endif */
2013: {
2014: int yy_is_jam;
2015: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
2016: /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
2017: char *yy_cp = yyg->yy_c_buf_p;
2018:
2019: YY_CHAR yy_c = 1;
2020: if ( yy_accept[yy_current_state] )
2021: {
2022: yyg->yy_last_accepting_state = yy_current_state;
2023: yyg->yy_last_accepting_cpos = yy_cp;
2024: }
2025: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2026: {
2027: yy_current_state = (int) yy_def[yy_current_state];
2028: if ( yy_current_state >= 85 )
2029: yy_c = yy_meta[yy_c];
2030: }
2031: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
2032: yy_is_jam = (yy_current_state == 84);
2033:
2034: (void)yyg;
2035: return yy_is_jam ? 0 : yy_current_state;
2036: }
2037:
2038: #ifndef YY_NO_UNPUT
2039: /* %if-c-only */
2040:
2041: static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
2042: /* %endif */
2043: /* %if-c++-only */
2044: /* %endif */
2045: {
2046: char *yy_cp;
2047: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2048:
2049: yy_cp = yyg->yy_c_buf_p;
2050:
2051: /* undo effects of setting up yytext */
2052: *yy_cp = yyg->yy_hold_char;
2053:
2054: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2055: { /* need to shift things up to make room */
2056: /* +2 for EOB chars. */
2057: int number_to_move = yyg->yy_n_chars + 2;
2058: char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2059: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2060: char *source =
2061: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2062:
2063: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2064: *--dest = *--source;
2065:
2066: yy_cp += (int) (dest - source);
2067: yy_bp += (int) (dest - source);
2068: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2069: yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2070:
2071: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2072: YY_FATAL_ERROR( "flex scanner push-back overflow" );
2073: }
2074:
2075: *--yy_cp = (char) c;
2076:
2077: /* %% [18.0] update yylineno here */
2078:
2079: if ( c == '\n' ){
2080: --yylineno;
2081: }
2082:
2083: yyg->yytext_ptr = yy_bp;
2084: yyg->yy_hold_char = *yy_cp;
2085: yyg->yy_c_buf_p = yy_cp;
2086: }
2087: /* %if-c-only */
2088:
2089: /* %endif */
2090: #endif
2091:
2092: /* %if-c-only */
2093: #ifndef YY_NO_INPUT
2094: #ifdef __cplusplus
2095: static int yyinput (yyscan_t yyscanner)
2096: #else
2097: static int input (yyscan_t yyscanner)
2098: #endif
2099:
2100: /* %endif */
2101: /* %if-c++-only */
2102: /* %endif */
2103: {
2104: int c;
2105: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2106:
2107: *yyg->yy_c_buf_p = yyg->yy_hold_char;
2108:
2109: if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2110: {
2111: /* yy_c_buf_p now points to the character we want to return.
2112: * If this occurs *before* the EOB characters, then it's a
2113: * valid NUL; if not, then we've hit the end of the buffer.
2114: */
2115: if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2116: /* This was really a NUL. */
2117: *yyg->yy_c_buf_p = '\0';
2118:
2119: else
2120: { /* need more input */
2121: int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
2122: ++yyg->yy_c_buf_p;
2123:
2124: switch ( yy_get_next_buffer( yyscanner ) )
2125: {
2126: case EOB_ACT_LAST_MATCH:
2127: /* This happens because yy_g_n_b()
2128: * sees that we've accumulated a
2129: * token and flags that we need to
2130: * try matching the token before
2131: * proceeding. But for input(),
2132: * there's no matching to consider.
2133: * So convert the EOB_ACT_LAST_MATCH
2134: * to EOB_ACT_END_OF_FILE.
2135: */
2136:
2137: /* Reset buffer status. */
2138: yyrestart( yyin , yyscanner);
2139:
2140: /*FALLTHROUGH*/
2141:
2142: case EOB_ACT_END_OF_FILE:
2143: {
2144: if ( yywrap( yyscanner ) )
2145: return 0;
2146:
2147: if ( ! yyg->yy_did_buffer_switch_on_eof )
2148: YY_NEW_FILE;
2149: #ifdef __cplusplus
2150: return yyinput(yyscanner);
2151: #else
2152: return input(yyscanner);
2153: #endif
2154: }
2155:
2156: case EOB_ACT_CONTINUE_SCAN:
2157: yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2158: break;
2159: }
2160: }
2161: }
2162:
2163: c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2164: *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
2165: yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2166:
2167: /* %% [19.0] update BOL and yylineno */
2168: if ( c == '\n' )
2169:
2170: do{ yylineno++;
2171: yycolumn=0;
2172: }while(0)
2173: ;
2174:
2175: return c;
2176: }
2177: /* %if-c-only */
2178: #endif /* ifndef YY_NO_INPUT */
2179: /* %endif */
2180:
2181: /** Immediately switch to a different input stream.
2182: * @param input_file A readable stream.
2183: * @param yyscanner The scanner object.
2184: * @note This function does not reset the start condition to @c INITIAL .
2185: */
2186: /* %if-c-only */
2187: void yyrestart (FILE * input_file , yyscan_t yyscanner)
2188: /* %endif */
2189: /* %if-c++-only */
2190: /* %endif */
2191: {
2192: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2193:
2194: if ( ! YY_CURRENT_BUFFER ){
2195: yyensure_buffer_stack (yyscanner);
2196: YY_CURRENT_BUFFER_LVALUE =
2197: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
2198: }
2199:
2200: yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
2201: yy_load_buffer_state( yyscanner );
2202: }
2203:
2204: /* %if-c++-only */
2205: /* %endif */
2206:
2207: /** Switch to a different input buffer.
2208: * @param new_buffer The new input buffer.
2209: * @param yyscanner The scanner object.
2210: */
2211: /* %if-c-only */
2212: void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2213: /* %endif */
2214: /* %if-c++-only */
2215: /* %endif */
2216: {
2217: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2218:
2219: /* TODO. We should be able to replace this entire function body
2220: * with
2221: * yypop_buffer_state();
2222: * yypush_buffer_state(new_buffer);
2223: */
2224: yyensure_buffer_stack (yyscanner);
2225: if ( YY_CURRENT_BUFFER == new_buffer )
2226: return;
2227:
2228: if ( YY_CURRENT_BUFFER )
2229: {
2230: /* Flush out information for old buffer. */
2231: *yyg->yy_c_buf_p = yyg->yy_hold_char;
2232: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2233: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2234: }
2235:
2236: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2237: yy_load_buffer_state( yyscanner );
2238:
2239: /* We don't actually know whether we did this switch during
2240: * EOF (yywrap()) processing, but the only time this flag
2241: * is looked at is after yywrap() is called, so it's safe
2242: * to go ahead and always set it.
2243: */
2244: yyg->yy_did_buffer_switch_on_eof = 1;
2245: }
2246:
2247: /* %if-c-only */
2248: static void yy_load_buffer_state (yyscan_t yyscanner)
2249: /* %endif */
2250: /* %if-c++-only */
2251: /* %endif */
2252: {
2253: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2254: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2255: yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2256: /* %if-c-only */
2257: yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2258: /* %endif */
2259: /* %if-c++-only */
2260: /* %endif */
2261: yyg->yy_hold_char = *yyg->yy_c_buf_p;
2262: }
2263:
2264: /** Allocate and initialize an input buffer state.
2265: * @param file A readable stream.
2266: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2267: * @param yyscanner The scanner object.
2268: * @return the allocated buffer state.
2269: */
2270: /* %if-c-only */
2271: YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
2272: /* %endif */
2273: /* %if-c++-only */
2274: /* %endif */
2275: {
2276: YY_BUFFER_STATE b;
2277:
2278: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
2279: if ( ! b )
2280: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2281:
2282: b->yy_buf_size = size;
2283:
2284: /* yy_ch_buf has to be 2 characters longer than the size given because
2285: * we need to put in 2 end-of-buffer characters.
2286: */
2287: b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
2288: if ( ! b->yy_ch_buf )
2289: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2290:
2291: b->yy_is_our_buffer = 1;
2292:
2293: yy_init_buffer( b, file , yyscanner);
2294:
2295: return b;
2296: }
2297:
2298: /* %if-c++-only */
2299: /* %endif */
2300:
2301: /** Destroy the buffer.
2302: * @param b a buffer created with yy_create_buffer()
2303: * @param yyscanner The scanner object.
2304: */
2305: /* %if-c-only */
2306: void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2307: /* %endif */
2308: /* %if-c++-only */
2309: /* %endif */
2310: {
2311: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2312:
2313: if ( ! b )
2314: return;
2315:
2316: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2317: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2318:
2319: if ( b->yy_is_our_buffer )
2320: yyfree( (void *) b->yy_ch_buf , yyscanner );
2321:
2322: yyfree( (void *) b , yyscanner );
2323: }
2324:
2325: /* Initializes or reinitializes a buffer.
2326: * This function is sometimes called more than once on the same buffer,
2327: * such as during a yyrestart() or at EOF.
2328: */
2329: /* %if-c-only */
2330: static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
2331: /* %endif */
2332: /* %if-c++-only */
2333: /* %endif */
2334:
2335: {
2336: int oerrno = errno;
2337: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2338:
2339: yy_flush_buffer( b , yyscanner);
2340:
2341: /* %if-c-only */
2342: b->yy_input_file = file;
2343: /* %endif */
2344: /* %if-c++-only */
2345: /* %endif */
2346: b->yy_fill_buffer = 1;
2347:
2348: /* If b is the current buffer, then yy_init_buffer was _probably_
2349: * called from yyrestart() or through yy_get_next_buffer.
2350: * In that case, we don't want to reset the lineno or column.
2351: */
2352: if (b != YY_CURRENT_BUFFER){
2353: b->yy_bs_lineno = 1;
2354: b->yy_bs_column = 0;
2355: }
2356:
2357: /* %if-c-only */
2358:
2359: b->yy_is_interactive = 0;
2360:
2361: /* %endif */
2362: /* %if-c++-only */
2363: /* %endif */
2364: errno = oerrno;
2365: }
2366:
2367: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2368: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2369: * @param yyscanner The scanner object.
2370: */
2371: /* %if-c-only */
2372: void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2373: /* %endif */
2374: /* %if-c++-only */
2375: /* %endif */
2376: {
2377: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2378: if ( ! b )
2379: return;
2380:
2381: b->yy_n_chars = 0;
2382:
2383: /* We always need two end-of-buffer characters. The first causes
2384: * a transition to the end-of-buffer state. The second causes
2385: * a jam in that state.
2386: */
2387: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2388: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2389:
2390: b->yy_buf_pos = &b->yy_ch_buf[0];
2391:
2392: b->yy_at_bol = 1;
2393: b->yy_buffer_status = YY_BUFFER_NEW;
2394:
2395: if ( b == YY_CURRENT_BUFFER )
2396: yy_load_buffer_state( yyscanner );
2397: }
2398:
2399: /* %if-c-or-c++ */
2400: /** Pushes the new state onto the stack. The new state becomes
2401: * the current state. This function will allocate the stack
2402: * if necessary.
2403: * @param new_buffer The new state.
2404: * @param yyscanner The scanner object.
2405: */
2406: /* %if-c-only */
2407: void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2408: /* %endif */
2409: /* %if-c++-only */
2410: /* %endif */
2411: {
2412: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2413: if (new_buffer == NULL)
2414: return;
2415:
2416: yyensure_buffer_stack(yyscanner);
2417:
2418: /* This block is copied from yy_switch_to_buffer. */
2419: if ( YY_CURRENT_BUFFER )
2420: {
2421: /* Flush out information for old buffer. */
2422: *yyg->yy_c_buf_p = yyg->yy_hold_char;
2423: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2424: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2425: }
2426:
2427: /* Only push if top exists. Otherwise, replace top. */
2428: if (YY_CURRENT_BUFFER)
2429: yyg->yy_buffer_stack_top++;
2430: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2431:
2432: /* copied from yy_switch_to_buffer. */
2433: yy_load_buffer_state( yyscanner );
2434: yyg->yy_did_buffer_switch_on_eof = 1;
2435: }
2436: /* %endif */
2437:
2438: /* %if-c-or-c++ */
2439: /** Removes and deletes the top of the stack, if present.
2440: * The next element becomes the new top.
2441: * @param yyscanner The scanner object.
2442: */
2443: /* %if-c-only */
2444: void yypop_buffer_state (yyscan_t yyscanner)
2445: /* %endif */
2446: /* %if-c++-only */
2447: /* %endif */
2448: {
2449: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2450: if (!YY_CURRENT_BUFFER)
2451: return;
2452:
2453: yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
2454: YY_CURRENT_BUFFER_LVALUE = NULL;
2455: if (yyg->yy_buffer_stack_top > 0)
2456: --yyg->yy_buffer_stack_top;
2457:
2458: if (YY_CURRENT_BUFFER) {
2459: yy_load_buffer_state( yyscanner );
2460: yyg->yy_did_buffer_switch_on_eof = 1;
2461: }
2462: }
2463: /* %endif */
2464:
2465: /* %if-c-or-c++ */
2466: /* Allocates the stack if it does not exist.
2467: * Guarantees space for at least one push.
2468: */
2469: /* %if-c-only */
2470: static void yyensure_buffer_stack (yyscan_t yyscanner)
2471: /* %endif */
2472: /* %if-c++-only */
2473: /* %endif */
2474: {
2475: yy_size_t num_to_alloc;
2476: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2477:
2478: if (!yyg->yy_buffer_stack) {
2479:
2480: /* First allocation is just for 2 elements, since we don't know if this
2481: * scanner will even need a stack. We use 2 instead of 1 to avoid an
2482: * immediate realloc on the next call.
2483: */
2484: num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2485: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
2486: (num_to_alloc * sizeof(struct yy_buffer_state*)
2487: , yyscanner);
2488: if ( ! yyg->yy_buffer_stack )
2489: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2490:
2491: memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2492:
2493: yyg->yy_buffer_stack_max = num_to_alloc;
2494: yyg->yy_buffer_stack_top = 0;
2495: return;
2496: }
2497:
2498: if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2499:
2500: /* Increase the buffer to prepare for a possible push. */
2501: yy_size_t grow_size = 8 /* arbitrary grow size */;
2502:
2503: num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2504: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
2505: (yyg->yy_buffer_stack,
2506: num_to_alloc * sizeof(struct yy_buffer_state*)
2507: , yyscanner);
2508: if ( ! yyg->yy_buffer_stack )
2509: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2510:
2511: /* zero only the new slots.*/
2512: memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2513: yyg->yy_buffer_stack_max = num_to_alloc;
2514: }
2515: }
2516: /* %endif */
2517:
2518: /* %if-c-only */
2519: /** Setup the input buffer state to scan directly from a user-specified character buffer.
2520: * @param base the character buffer
2521: * @param size the size in bytes of the character buffer
2522: * @param yyscanner The scanner object.
2523: * @return the newly allocated buffer state object.
2524: */
2525: YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2526: {
2527: YY_BUFFER_STATE b;
2528:
2529: if ( size < 2 ||
2530: base[size-2] != YY_END_OF_BUFFER_CHAR ||
2531: base[size-1] != YY_END_OF_BUFFER_CHAR )
2532: /* They forgot to leave room for the EOB's. */
2533: return NULL;
2534:
2535: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
2536: if ( ! b )
2537: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2538:
2539: b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
2540: b->yy_buf_pos = b->yy_ch_buf = base;
2541: b->yy_is_our_buffer = 0;
2542: b->yy_input_file = NULL;
2543: b->yy_n_chars = b->yy_buf_size;
2544: b->yy_is_interactive = 0;
2545: b->yy_at_bol = 1;
2546: b->yy_fill_buffer = 0;
2547: b->yy_buffer_status = YY_BUFFER_NEW;
2548:
2549: yy_switch_to_buffer( b , yyscanner );
2550:
2551: return b;
2552: }
2553: /* %endif */
2554:
2555: /* %if-c-only */
2556: /** Setup the input buffer state to scan a string. The next call to yylex() will
2557: * scan from a @e copy of @a str.
2558: * @param yystr a NUL-terminated string to scan
2559: * @param yyscanner The scanner object.
2560: * @return the newly allocated buffer state object.
2561: * @note If you want to scan bytes that may contain NUL values, then use
2562: * yy_scan_bytes() instead.
2563: */
2564: YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
2565: {
2566:
2567: return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
2568: }
2569: /* %endif */
2570:
2571: /* %if-c-only */
2572: /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2573: * scan from a @e copy of @a bytes.
2574: * @param yybytes the byte buffer to scan
2575: * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2576: * @param yyscanner The scanner object.
2577: * @return the newly allocated buffer state object.
2578: */
2579: YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
2580: {
2581: YY_BUFFER_STATE b;
2582: char *buf;
2583: yy_size_t n;
2584: int i;
2585:
2586: /* Get memory for full buffer, including space for trailing EOB's. */
2587: n = (yy_size_t) (_yybytes_len + 2);
2588: buf = (char *) yyalloc( n , yyscanner );
2589: if ( ! buf )
2590: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2591:
2592: for ( i = 0; i < _yybytes_len; ++i )
2593: buf[i] = yybytes[i];
2594:
2595: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2596:
2597: b = yy_scan_buffer( buf, n , yyscanner);
2598: if ( ! b )
2599: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2600:
2601: /* It's okay to grow etc. this buffer, and we should throw it
2602: * away when we're done.
2603: */
2604: b->yy_is_our_buffer = 1;
2605:
2606: return b;
2607: }
2608: /* %endif */
2609:
2610: /* %if-c-only */
2611: static void yy_push_state (int _new_state , yyscan_t yyscanner)
2612: /* %endif */
2613: /* %if-c++-only */
2614: /* %endif */
2615: {
2616: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2617: if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
2618: {
2619: yy_size_t new_size;
2620:
2621: yyg->yy_start_stack_depth += YY_START_STACK_INCR;
2622: new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int );
2623:
2624: if ( ! yyg->yy_start_stack )
2625: yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner );
2626:
2627: else
2628: yyg->yy_start_stack = (int *) yyrealloc(
2629: (void *) yyg->yy_start_stack, new_size , yyscanner );
2630:
2631: if ( ! yyg->yy_start_stack )
2632: YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
2633: }
2634:
2635: yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
2636:
2637: BEGIN(_new_state);
2638: }
2639:
2640: /* %if-c-only */
2641: static void yy_pop_state (yyscan_t yyscanner)
2642: /* %endif */
2643: /* %if-c++-only */
2644: /* %endif */
2645: {
2646: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2647: if ( --yyg->yy_start_stack_ptr < 0 )
2648: YY_FATAL_ERROR( "start-condition stack underflow" );
2649:
2650: BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
2651: }
2652:
2653: /* %if-c-only */
2654: static int yy_top_state (yyscan_t yyscanner)
2655: /* %endif */
2656: /* %if-c++-only */
2657: /* %endif */
2658: {
2659: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2660: return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
2661: }
2662:
2663: #ifndef YY_EXIT_FAILURE
2664: #define YY_EXIT_FAILURE 2
2665: #endif
2666:
2667: /* %if-c-only */
2668: static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
2669: {
2670: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2671: (void)yyg;
2672: fprintf( stderr, "%s\n", msg );
2673: exit( YY_EXIT_FAILURE );
2674: }
2675: /* %endif */
2676: /* %if-c++-only */
2677: /* %endif */
2678:
2679: /* Redefine yyless() so it works in section 3 code. */
2680:
2681: #undef yyless
2682: #define yyless(n) \
2683: do \
2684: { \
2685: /* Undo effects of setting up yytext. */ \
2686: int yyless_macro_arg = (n); \
2687: YY_LESS_LINENO(yyless_macro_arg);\
2688: yytext[yyleng] = yyg->yy_hold_char; \
2689: yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2690: yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2691: *yyg->yy_c_buf_p = '\0'; \
2692: yyleng = yyless_macro_arg; \
2693: } \
2694: while ( 0 )
2695:
2696: /* Accessor methods (get/set functions) to struct members. */
2697:
2698: /* %if-c-only */
2699: /* %if-reentrant */
2700:
2701: /** Get the user-defined data for this scanner.
2702: * @param yyscanner The scanner object.
2703: */
2704: YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
2705: {
2706: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2707: return yyextra;
2708: }
2709:
2710: /* %endif */
2711:
2712: /** Get the current line number.
2713: * @param yyscanner The scanner object.
2714: */
2715: int yyget_lineno (yyscan_t yyscanner)
2716: {
2717: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2718:
2719: if (! YY_CURRENT_BUFFER)
2720: return 0;
2721:
2722: return yylineno;
2723: }
2724:
2725: /** Get the current column number.
2726: * @param yyscanner The scanner object.
2727: */
2728: int yyget_column (yyscan_t yyscanner)
2729: {
2730: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2731:
2732: if (! YY_CURRENT_BUFFER)
2733: return 0;
2734:
2735: return yycolumn;
2736: }
2737:
2738: /** Get the input stream.
2739: * @param yyscanner The scanner object.
2740: */
2741: FILE *yyget_in (yyscan_t yyscanner)
2742: {
2743: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2744: return yyin;
2745: }
2746:
2747: /** Get the output stream.
2748: * @param yyscanner The scanner object.
2749: */
2750: FILE *yyget_out (yyscan_t yyscanner)
2751: {
2752: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2753: return yyout;
2754: }
2755:
2756: /** Get the length of the current token.
2757: * @param yyscanner The scanner object.
2758: */
2759: int yyget_leng (yyscan_t yyscanner)
2760: {
2761: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2762: return yyleng;
2763: }
2764:
2765: /** Get the current token.
2766: * @param yyscanner The scanner object.
2767: */
2768:
2769: char *yyget_text (yyscan_t yyscanner)
2770: {
2771: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2772: return yytext;
2773: }
2774:
2775: /* %if-reentrant */
2776:
2777: /** Set the user-defined data. This data is never touched by the scanner.
2778: * @param user_defined The data to be associated with this scanner.
2779: * @param yyscanner The scanner object.
2780: */
2781: void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2782: {
2783: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2784: yyextra = user_defined ;
2785: }
2786:
2787: /* %endif */
2788:
2789: /** Set the current line number.
2790: * @param _line_number line number
2791: * @param yyscanner The scanner object.
2792: */
2793: void yyset_lineno (int _line_number , yyscan_t yyscanner)
2794: {
2795: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2796:
2797: /* lineno is only valid if an input buffer exists. */
2798: if (! YY_CURRENT_BUFFER )
2799: YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
2800:
2801: yylineno = _line_number;
2802: }
2803:
2804: /** Set the current column.
2805: * @param _column_no column number
2806: * @param yyscanner The scanner object.
2807: */
2808: void yyset_column (int _column_no , yyscan_t yyscanner)
2809: {
2810: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2811:
2812: /* column is only valid if an input buffer exists. */
2813: if (! YY_CURRENT_BUFFER )
2814: YY_FATAL_ERROR( "yyset_column called with no buffer" );
2815:
2816: yycolumn = _column_no;
2817: }
2818:
2819: /** Set the input stream. This does not discard the current
2820: * input buffer.
2821: * @param _in_str A readable stream.
2822: * @param yyscanner The scanner object.
2823: * @see yy_switch_to_buffer
2824: */
2825: void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2826: {
2827: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2828: yyin = _in_str ;
2829: }
2830:
2831: void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2832: {
2833: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2834: yyout = _out_str ;
2835: }
2836:
2837: int yyget_debug (yyscan_t yyscanner)
2838: {
2839: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2840: return yy_flex_debug;
2841: }
2842:
2843: void yyset_debug (int _bdebug , yyscan_t yyscanner)
2844: {
2845: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2846: yy_flex_debug = _bdebug ;
2847: }
2848:
2849: /* %endif */
2850:
2851: /* %if-reentrant */
2852: /* Accessor methods for yylval and yylloc */
2853:
2854: /* %if-bison-bridge */
2855:
2856: YYSTYPE * yyget_lval (yyscan_t yyscanner)
2857: {
2858: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2859: return yylval;
2860: }
2861:
2862: void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
2863: {
2864: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2865: yylval = yylval_param;
2866: }
2867:
2868: /* %endif */
2869:
2870: /* User-visible API */
2871:
2872: /* yylex_init is special because it creates the scanner itself, so it is
2873: * the ONLY reentrant function that doesn't take the scanner as the last argument.
2874: * That's why we explicitly handle the declaration, instead of using our macros.
2875: */
2876: int yylex_init(yyscan_t* ptr_yy_globals)
2877: {
2878: if (ptr_yy_globals == NULL){
2879: errno = EINVAL;
2880: return 1;
2881: }
2882:
2883: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2884:
2885: if (*ptr_yy_globals == NULL){
2886: errno = ENOMEM;
2887: return 1;
2888: }
2889:
2890: /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2891: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2892:
2893: return yy_init_globals ( *ptr_yy_globals );
2894: }
2895:
2896: /* yylex_init_extra has the same functionality as yylex_init, but follows the
2897: * convention of taking the scanner as the last argument. Note however, that
2898: * this is a *pointer* to a scanner, as it will be allocated by this call (and
2899: * is the reason, too, why this function also must handle its own declaration).
2900: * The user defined value in the first argument will be available to yyalloc in
2901: * the yyextra field.
2902: */
2903: int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2904: {
2905: struct yyguts_t dummy_yyguts;
2906:
2907: yyset_extra (yy_user_defined, &dummy_yyguts);
2908:
2909: if (ptr_yy_globals == NULL){
2910: errno = EINVAL;
2911: return 1;
2912: }
2913:
2914: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2915:
2916: if (*ptr_yy_globals == NULL){
2917: errno = ENOMEM;
2918: return 1;
2919: }
2920:
2921: /* By setting to 0xAA, we expose bugs in
2922: yy_init_globals. Leave at 0x00 for releases. */
2923: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2924:
2925: yyset_extra (yy_user_defined, *ptr_yy_globals);
2926:
2927: return yy_init_globals ( *ptr_yy_globals );
2928: }
2929:
2930: /* %endif if-c-only */
2931:
2932: /* %if-c-only */
2933: static int yy_init_globals (yyscan_t yyscanner)
2934: {
2935: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2936: /* Initialization is the same as for the non-reentrant scanner.
2937: * This function is called from yylex_destroy(), so don't allocate here.
2938: */
2939:
2940: yyg->yy_buffer_stack = NULL;
2941: yyg->yy_buffer_stack_top = 0;
2942: yyg->yy_buffer_stack_max = 0;
2943: yyg->yy_c_buf_p = NULL;
2944: yyg->yy_init = 0;
2945: yyg->yy_start = 0;
2946:
2947: yyg->yy_start_stack_ptr = 0;
2948: yyg->yy_start_stack_depth = 0;
2949: yyg->yy_start_stack = NULL;
2950:
2951: /* Defined in main.c */
2952: #ifdef YY_STDINIT
2953: yyin = stdin;
2954: yyout = stdout;
2955: #else
2956: yyin = NULL;
2957: yyout = NULL;
2958: #endif
2959:
2960: /* For future reference: Set errno on error, since we are called by
2961: * yylex_init()
2962: */
2963: return 0;
2964: }
2965: /* %endif */
2966:
2967: /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
2968: /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2969: int yylex_destroy (yyscan_t yyscanner)
2970: {
2971: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2972:
2973: /* Pop the buffer stack, destroying each element. */
2974: while(YY_CURRENT_BUFFER){
2975: yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2976: YY_CURRENT_BUFFER_LVALUE = NULL;
2977: yypop_buffer_state(yyscanner);
2978: }
2979:
2980: /* Destroy the stack itself. */
2981: yyfree(yyg->yy_buffer_stack , yyscanner);
2982: yyg->yy_buffer_stack = NULL;
2983:
2984: /* Destroy the start condition stack. */
2985: yyfree( yyg->yy_start_stack , yyscanner );
2986: yyg->yy_start_stack = NULL;
2987:
2988: /* Reset the globals. This is important in a non-reentrant scanner so the next time
2989: * yylex() is called, initialization will occur. */
2990: yy_init_globals( yyscanner);
2991:
2992: /* %if-reentrant */
2993: /* Destroy the main struct (reentrant only). */
2994: yyfree ( yyscanner , yyscanner );
2995: yyscanner = NULL;
2996: /* %endif */
2997: return 0;
2998: }
2999: /* %endif */
3000:
3001: /*
3002: * Internal utility routines.
3003: */
3004:
3005: #ifndef yytext_ptr
3006: static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
3007: {
3008: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3009: (void)yyg;
3010:
3011: int i;
3012: for ( i = 0; i < n; ++i )
3013: s1[i] = s2[i];
3014: }
3015: #endif
3016:
3017: #ifdef YY_NEED_STRLEN
3018: static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
3019: {
3020: int n;
3021: for ( n = 0; s[n]; ++n )
3022: ;
3023:
3024: return n;
3025: }
3026: #endif
3027:
3028: void *yyalloc (yy_size_t size , yyscan_t yyscanner)
3029: {
3030: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3031: (void)yyg;
3032: return malloc(size);
3033: }
3034:
3035: void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
3036: {
3037: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3038: (void)yyg;
3039:
3040: /* The cast to (char *) in the following accommodates both
3041: * implementations that use char* generic pointers, and those
3042: * that use void* generic pointers. It works with the latter
3043: * because both ANSI C and C++ allow castless assignment from
3044: * any pointer type to void*, and deal with argument conversions
3045: * as though doing an assignment.
3046: */
3047: return realloc(ptr, size);
3048: }
3049:
3050: void yyfree (void * ptr , yyscan_t yyscanner)
3051: {
3052: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3053: (void)yyg;
3054: free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
3055: }
3056:
3057: /* %if-tables-serialization definitions */
3058: /* %define-yytables The name for this specific scanner's tables. */
3059: #define YYTABLES_NAME "yytables"
3060: /* %endif */
3061:
3062: /* %ok-for-header */
3063:
3064: #line 241 "settings/settings_lexer.l"
3065:
3066:
3067: /**
3068: * Open the next file, if any is queued and readable, otherwise returns FALSE.
3069: */
3070: bool settings_parser_open_next_file(parser_helper_t *ctx)
3071: {
3072: FILE *file;
3073:
3074: file = ctx->file_next(ctx);
3075: if (!file)
3076: {
3077: return FALSE;
3078: }
3079:
3080: settings_parser_set_in(file, ctx->scanner);
3081: settings_parser_push_buffer_state(
3082: settings_parser__create_buffer(file, YY_BUF_SIZE,
3083: ctx->scanner), ctx->scanner);
3084: return TRUE;
3085: }
3086:
3087: /**
3088: * Assumes that the file pattern to include is currently stored as string on
3089: * the helper object.
3090: */
3091: static void include_files(parser_helper_t *ctx)
3092: {
3093: char *pattern = ctx->string_get(ctx);
3094:
3095: ctx->file_include(ctx, pattern);
3096: free(pattern);
3097:
3098: settings_parser_open_next_file(ctx);
3099: }
3100:
3101: /**
3102: * Load the given string to be parsed next
3103: */
3104: void settings_parser_load_string(parser_helper_t *ctx, const char *content)
3105: {
3106: settings_parser__scan_string(content, ctx->scanner);
3107: }
3108:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to settings_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 / libstrongswan / settings