Annotation of embedaddon/confuse/src/lexer.c, revision 1.1.1.1
1.1 misho 1: #line 2 "lexer.c"
2:
3: #line 4 "lexer.c"
4:
5: #define YY_INT_ALIGNED short int
6:
7: /* A lexical scanner generated by flex */
8:
9: #define yy_create_buffer cfg_yy_create_buffer
10: #define yy_delete_buffer cfg_yy_delete_buffer
11: #define yy_flex_debug cfg_yy_flex_debug
12: #define yy_init_buffer cfg_yy_init_buffer
13: #define yy_flush_buffer cfg_yy_flush_buffer
14: #define yy_load_buffer_state cfg_yy_load_buffer_state
15: #define yy_switch_to_buffer cfg_yy_switch_to_buffer
16: #define yyin cfg_yyin
17: #define yyleng cfg_yyleng
18: #define yylex cfg_yylex
19: #define yylineno cfg_yylineno
20: #define yyout cfg_yyout
21: #define yyrestart cfg_yyrestart
22: #define yytext cfg_yytext
23: #define yywrap cfg_yywrap
24: #define yyalloc cfg_yyalloc
25: #define yyrealloc cfg_yyrealloc
26: #define yyfree cfg_yyfree
27:
28: #define FLEX_SCANNER
29: #define YY_FLEX_MAJOR_VERSION 2
30: #define YY_FLEX_MINOR_VERSION 5
31: #define YY_FLEX_SUBMINOR_VERSION 35
32: #if YY_FLEX_SUBMINOR_VERSION > 0
33: #define FLEX_BETA
34: #endif
35:
36: /* First, we deal with platform-specific or compiler-specific issues. */
37:
38: /* begin standard C headers. */
39: #include <stdio.h>
40: #include <string.h>
41: #include <errno.h>
42: #include <stdlib.h>
43:
44: /* end standard C headers. */
45:
46: /* flex integer type definitions */
47:
48: #ifndef FLEXINT_H
49: #define FLEXINT_H
50:
51: /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52:
53: #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54:
55: /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56: * if you want the limit (max/min) macros for int types.
57: */
58: #ifndef __STDC_LIMIT_MACROS
59: #define __STDC_LIMIT_MACROS 1
60: #endif
61:
62: #include <inttypes.h>
63: typedef int8_t flex_int8_t;
64: typedef uint8_t flex_uint8_t;
65: typedef int16_t flex_int16_t;
66: typedef uint16_t flex_uint16_t;
67: typedef int32_t flex_int32_t;
68: typedef uint32_t flex_uint32_t;
69: #else
70: typedef signed char flex_int8_t;
71: typedef short int flex_int16_t;
72: typedef int flex_int32_t;
73: typedef unsigned char flex_uint8_t;
74: typedef unsigned short int flex_uint16_t;
75: typedef unsigned int flex_uint32_t;
76: #endif /* ! C99 */
77:
78: /* Limits of integral types. */
79: #ifndef INT8_MIN
80: #define INT8_MIN (-128)
81: #endif
82: #ifndef INT16_MIN
83: #define INT16_MIN (-32767-1)
84: #endif
85: #ifndef INT32_MIN
86: #define INT32_MIN (-2147483647-1)
87: #endif
88: #ifndef INT8_MAX
89: #define INT8_MAX (127)
90: #endif
91: #ifndef INT16_MAX
92: #define INT16_MAX (32767)
93: #endif
94: #ifndef INT32_MAX
95: #define INT32_MAX (2147483647)
96: #endif
97: #ifndef UINT8_MAX
98: #define UINT8_MAX (255U)
99: #endif
100: #ifndef UINT16_MAX
101: #define UINT16_MAX (65535U)
102: #endif
103: #ifndef UINT32_MAX
104: #define UINT32_MAX (4294967295U)
105: #endif
106:
107: #endif /* ! FLEXINT_H */
108:
109: #ifdef __cplusplus
110:
111: /* The "const" storage-class-modifier is valid. */
112: #define YY_USE_CONST
113:
114: #else /* ! __cplusplus */
115:
116: /* C99 requires __STDC__ to be defined as 1. */
117: #if defined (__STDC__)
118:
119: #define YY_USE_CONST
120:
121: #endif /* defined (__STDC__) */
122: #endif /* ! __cplusplus */
123:
124: #ifdef YY_USE_CONST
125: #define yyconst const
126: #else
127: #define yyconst
128: #endif
129:
130: /* Returned upon end-of-file. */
131: #define YY_NULL 0
132:
133: /* Promotes a possibly negative, possibly signed char to an unsigned
134: * integer for use as an array index. If the signed char is negative,
135: * we want to instead treat it as an 8-bit unsigned char, hence the
136: * double cast.
137: */
138: #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
139:
140: /* Enter a start condition. This macro really ought to take a parameter,
141: * but we do it the disgusting crufty way forced on us by the ()-less
142: * definition of BEGIN.
143: */
144: #define BEGIN (yy_start) = 1 + 2 *
145:
146: /* Translate the current start state into a value that can be later handed
147: * to BEGIN to return to the state. The YYSTATE alias is for lex
148: * compatibility.
149: */
150: #define YY_START (((yy_start) - 1) / 2)
151: #define YYSTATE YY_START
152:
153: /* Action number for EOF rule of a given start state. */
154: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155:
156: /* Special action meaning "start processing a new file". */
157: #define YY_NEW_FILE cfg_yyrestart(cfg_yyin )
158:
159: #define YY_END_OF_BUFFER_CHAR 0
160:
161: /* Size of default input buffer. */
162: #ifndef YY_BUF_SIZE
163: #define YY_BUF_SIZE 16384
164: #endif
165:
166: /* The state buf must be large enough to hold one state per character in the main buffer.
167: */
168: #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
169:
170: #ifndef YY_TYPEDEF_YY_BUFFER_STATE
171: #define YY_TYPEDEF_YY_BUFFER_STATE
172: typedef struct yy_buffer_state *YY_BUFFER_STATE;
173: #endif
174:
175: extern int cfg_yyleng;
176:
177: extern FILE *cfg_yyin, *cfg_yyout;
178:
179: #define EOB_ACT_CONTINUE_SCAN 0
180: #define EOB_ACT_END_OF_FILE 1
181: #define EOB_ACT_LAST_MATCH 2
182:
183: #define YY_LESS_LINENO(n)
184:
185: /* Return all but the first "n" matched characters back to the input stream. */
186: #define yyless(n) \
187: do \
188: { \
189: /* Undo effects of setting up cfg_yytext. */ \
190: int yyless_macro_arg = (n); \
191: YY_LESS_LINENO(yyless_macro_arg);\
192: *yy_cp = (yy_hold_char); \
193: YY_RESTORE_YY_MORE_OFFSET \
194: (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195: YY_DO_BEFORE_ACTION; /* set up cfg_yytext again */ \
196: } \
197: while ( 0 )
198:
199: #define unput(c) yyunput( c, (yytext_ptr) )
200:
201: #ifndef YY_TYPEDEF_YY_SIZE_T
202: #define YY_TYPEDEF_YY_SIZE_T
203: typedef size_t yy_size_t;
204: #endif
205:
206: #ifndef YY_STRUCT_YY_BUFFER_STATE
207: #define YY_STRUCT_YY_BUFFER_STATE
208: struct yy_buffer_state
209: {
210: FILE *yy_input_file;
211:
212: char *yy_ch_buf; /* input buffer */
213: char *yy_buf_pos; /* current position in input buffer */
214:
215: /* Size of input buffer in bytes, not including room for EOB
216: * characters.
217: */
218: yy_size_t yy_buf_size;
219:
220: /* Number of characters read into yy_ch_buf, not including EOB
221: * characters.
222: */
223: int yy_n_chars;
224:
225: /* Whether we "own" the buffer - i.e., we know we created it,
226: * and can realloc() it to grow it, and should free() it to
227: * delete it.
228: */
229: int yy_is_our_buffer;
230:
231: /* Whether this is an "interactive" input source; if so, and
232: * if we're using stdio for input, then we want to use getc()
233: * instead of fread(), to make sure we stop fetching input after
234: * each newline.
235: */
236: int yy_is_interactive;
237:
238: /* Whether we're considered to be at the beginning of a line.
239: * If so, '^' rules will be active on the next match, otherwise
240: * not.
241: */
242: int yy_at_bol;
243:
244: int yy_bs_lineno; /**< The line count. */
245: int yy_bs_column; /**< The column count. */
246:
247: /* Whether to try to fill the input buffer when we reach the
248: * end of it.
249: */
250: int yy_fill_buffer;
251:
252: int yy_buffer_status;
253:
254: #define YY_BUFFER_NEW 0
255: #define YY_BUFFER_NORMAL 1
256: /* When an EOF's been seen but there's still some text to process
257: * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258: * shouldn't try reading from the input source any more. We might
259: * still have a bunch of tokens to match, though, because of
260: * possible backing-up.
261: *
262: * When we actually see the EOF, we change the status to "new"
263: * (via cfg_yyrestart()), so that the user can continue scanning by
264: * just pointing cfg_yyin at a new input file.
265: */
266: #define YY_BUFFER_EOF_PENDING 2
267:
268: };
269: #endif /* !YY_STRUCT_YY_BUFFER_STATE */
270:
271: /* Stack of input buffers. */
272: static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
273: static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
274: static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
275:
276: /* We provide macros for accessing buffer states in case in the
277: * future we want to put the buffer states in a more general
278: * "scanner state".
279: *
280: * Returns the top of the stack, or NULL.
281: */
282: #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283: ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
284: : NULL)
285:
286: /* Same as previous macro, but useful when we know that the buffer stack is not
287: * NULL or when we need an lvalue. For internal use only.
288: */
289: #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
290:
291: /* yy_hold_char holds the character lost when cfg_yytext is formed. */
292: static char yy_hold_char;
293: static int yy_n_chars; /* number of characters read into yy_ch_buf */
294: int cfg_yyleng;
295:
296: /* Points to current character in buffer. */
297: static char *yy_c_buf_p = (char *) 0;
298: static int yy_init = 0; /* whether we need to initialize */
299: static int yy_start = 0; /* start state number */
300:
301: /* Flag which is used to allow cfg_yywrap()'s to do buffer switches
302: * instead of setting up a fresh cfg_yyin. A bit of a hack ...
303: */
304: static int yy_did_buffer_switch_on_eof;
305:
306: void cfg_yyrestart (FILE *input_file );
307: void cfg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
308: YY_BUFFER_STATE cfg_yy_create_buffer (FILE *file,int size );
309: void cfg_yy_delete_buffer (YY_BUFFER_STATE b );
310: void cfg_yy_flush_buffer (YY_BUFFER_STATE b );
311: void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buffer );
312: void cfg_yypop_buffer_state (void );
313:
314: static void cfg_yyensure_buffer_stack (void );
315: static void cfg_yy_load_buffer_state (void );
316: static void cfg_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
317:
318: #define YY_FLUSH_BUFFER cfg_yy_flush_buffer(YY_CURRENT_BUFFER )
319:
320: YY_BUFFER_STATE cfg_yy_scan_buffer (char *base,yy_size_t size );
321: YY_BUFFER_STATE cfg_yy_scan_string (yyconst char *yy_str );
322: YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char *bytes,int len );
323:
324: void *cfg_yyalloc (yy_size_t );
325: void *cfg_yyrealloc (void *,yy_size_t );
326: void cfg_yyfree (void * );
327:
328: #define yy_new_buffer cfg_yy_create_buffer
329:
330: #define yy_set_interactive(is_interactive) \
331: { \
332: if ( ! YY_CURRENT_BUFFER ){ \
333: cfg_yyensure_buffer_stack (); \
334: YY_CURRENT_BUFFER_LVALUE = \
335: cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE ); \
336: } \
337: YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
338: }
339:
340: #define yy_set_bol(at_bol) \
341: { \
342: if ( ! YY_CURRENT_BUFFER ){\
343: cfg_yyensure_buffer_stack (); \
344: YY_CURRENT_BUFFER_LVALUE = \
345: cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE ); \
346: } \
347: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
348: }
349:
350: #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
351:
352: /* Begin user sect3 */
353:
354: #define cfg_yywrap(n) 1
355: #define YY_SKIP_YYWRAP
356:
357: typedef unsigned char YY_CHAR;
358:
359: FILE *cfg_yyin = (FILE *) 0, *cfg_yyout = (FILE *) 0;
360:
361: typedef int yy_state_type;
362:
363: extern int cfg_yylineno;
364:
365: int cfg_yylineno = 1;
366:
367: extern char *cfg_yytext;
368: #define yytext_ptr cfg_yytext
369:
370: static yy_state_type yy_get_previous_state (void );
371: static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
372: static int yy_get_next_buffer (void );
373: static void yy_fatal_error (yyconst char msg[] );
374:
375: /* Done after the current pattern has been matched and before the
376: * corresponding action - sets up cfg_yytext.
377: */
378: #define YY_DO_BEFORE_ACTION \
379: (yytext_ptr) = yy_bp; \
380: cfg_yyleng = (size_t) (yy_cp - yy_bp); \
381: (yy_hold_char) = *yy_cp; \
382: *yy_cp = '\0'; \
383: (yy_c_buf_p) = yy_cp;
384:
385: #define YY_NUM_RULES 44
386: #define YY_END_OF_BUFFER 45
387: /* This struct is not used in this scanner,
388: but its presence is necessary. */
389: struct yy_trans_info
390: {
391: flex_int32_t yy_verify;
392: flex_int32_t yy_nxt;
393: };
394: static yyconst flex_int16_t yy_accept[85] =
395: { 0,
396: 0, 0, 12, 12, 0, 0, 0, 0, 45, 42,
397: 1, 2, 43, 16, 3, 42, 34, 6, 7, 43,
398: 10, 42, 8, 4, 5, 12, 14, 13, 33, 19,
399: 17, 33, 44, 40, 36, 35, 44, 42, 42, 1,
400: 3, 0, 9, 42, 11, 3, 12, 13, 13, 15,
401: 33, 33, 32, 20, 21, 22, 28, 26, 29, 27,
402: 24, 25, 30, 31, 32, 40, 39, 37, 38, 0,
403: 41, 3, 3, 33, 0, 18, 21, 22, 23, 3,
404: 18, 21, 23, 0
405: } ;
406:
407: static yyconst flex_int32_t yy_ec[256] =
408: { 0,
409: 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
410: 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
411: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412: 1, 2, 1, 5, 6, 7, 1, 1, 8, 9,
413: 10, 11, 12, 13, 1, 1, 14, 15, 15, 15,
414: 15, 15, 15, 15, 15, 16, 16, 1, 1, 1,
415: 17, 1, 1, 1, 18, 18, 18, 18, 18, 18,
416: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418: 1, 19, 1, 1, 1, 1, 20, 21, 18, 18,
419:
420: 22, 23, 1, 1, 1, 1, 1, 1, 1, 24,
421: 1, 1, 1, 25, 1, 26, 1, 27, 1, 28,
422: 1, 1, 29, 1, 30, 1, 1, 1, 1, 1,
423: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
426: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
430:
431: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
432: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
433: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
434: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
435: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
436: 1, 1, 1, 1, 1
437: } ;
438:
439: static yyconst flex_int32_t yy_meta[31] =
440: { 0,
441: 1, 2, 3, 2, 4, 2, 1, 5, 2, 2,
442: 6, 2, 2, 1, 7, 7, 2, 7, 8, 7,
443: 7, 7, 7, 1, 1, 1, 1, 1, 2, 2
444: } ;
445:
446: static yyconst flex_int16_t yy_base[102] =
447: { 0,
448: 0, 0, 28, 29, 30, 31, 38, 39, 131, 116,
449: 127, 293, 293, 293, 0, 30, 293, 293, 293, 111,
450: 293, 34, 293, 293, 293, 0, 293, 40, 0, 293,
451: 293, 98, 57, 0, 293, 293, 67, 107, 41, 116,
452: 0, 59, 293, 62, 293, 86, 0, 42, 50, 293,
453: 0, 114, 293, 293, 47, 50, 293, 293, 293, 293,
454: 293, 293, 293, 293, 0, 0, 293, 293, 293, 44,
455: 293, 144, 0, 117, 41, 0, 52, 108, 0, 0,
456: 293, 110, 293, 293, 174, 182, 190, 198, 206, 214,
457: 222, 230, 238, 245, 253, 260, 268, 276, 62, 284,
458:
459: 36
460: } ;
461:
462: static yyconst flex_int16_t yy_def[102] =
463: { 0,
464: 84, 1, 85, 85, 86, 86, 87, 87, 84, 88,
465: 84, 84, 84, 84, 89, 88, 84, 84, 84, 84,
466: 84, 90, 84, 84, 84, 91, 84, 92, 93, 84,
467: 84, 93, 94, 95, 84, 84, 96, 88, 90, 84,
468: 89, 97, 84, 88, 84, 84, 91, 92, 92, 84,
469: 93, 98, 84, 84, 84, 84, 84, 84, 84, 84,
470: 84, 84, 84, 84, 99, 95, 84, 84, 84, 97,
471: 84, 84, 46, 98, 100, 93, 84, 84, 101, 72,
472: 84, 84, 84, 0, 84, 84, 84, 84, 84, 84,
473: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
474:
475: 84
476: } ;
477:
478: static yyconst flex_int16_t yy_nxt[324] =
479: { 0,
480: 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
481: 13, 20, 21, 22, 10, 10, 23, 10, 10, 10,
482: 10, 10, 10, 10, 10, 10, 10, 10, 24, 25,
483: 27, 27, 30, 30, 31, 31, 32, 32, 28, 28,
484: 35, 35, 83, 39, 45, 36, 36, 46, 33, 33,
485: 49, 84, 84, 50, 39, 84, 37, 37, 42, 54,
486: 49, 77, 78, 50, 78, 78, 82, 78, 79, 68,
487: 81, 55, 56, 71, 69, 39, 57, 58, 59, 60,
488: 61, 62, 63, 64, 65, 69, 72, 41, 71, 41,
489: 41, 41, 72, 41, 41, 41, 41, 41, 41, 73,
490:
491: 72, 72, 41, 72, 72, 72, 72, 72, 72, 72,
492: 72, 72, 72, 72, 41, 41, 75, 40, 75, 75,
493: 39, 75, 78, 78, 78, 78, 52, 43, 40, 39,
494: 84, 84, 75, 84, 84, 75, 84, 84, 84, 84,
495: 84, 84, 84, 76, 80, 41, 76, 41, 41, 41,
496: 80, 41, 41, 41, 41, 41, 41, 73, 80, 80,
497: 41, 80, 80, 80, 80, 80, 80, 80, 80, 80,
498: 80, 80, 41, 41, 26, 26, 26, 26, 26, 26,
499: 26, 26, 29, 29, 29, 29, 29, 29, 29, 29,
500: 34, 34, 34, 34, 34, 34, 34, 34, 38, 84,
501:
502: 84, 84, 84, 84, 38, 38, 41, 41, 84, 41,
503: 41, 41, 41, 41, 44, 84, 84, 84, 84, 44,
504: 44, 44, 47, 47, 84, 47, 47, 84, 47, 47,
505: 48, 48, 84, 48, 48, 48, 48, 48, 51, 51,
506: 84, 84, 51, 51, 51, 53, 53, 53, 53, 53,
507: 53, 53, 53, 66, 66, 84, 66, 84, 66, 66,
508: 67, 67, 67, 67, 67, 67, 67, 67, 70, 70,
509: 70, 70, 70, 70, 70, 70, 74, 74, 74, 74,
510: 74, 74, 74, 74, 75, 75, 75, 75, 75, 75,
511: 75, 75, 9, 84, 84, 84, 84, 84, 84, 84,
512:
513: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
514: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
515: 84, 84, 84
516: } ;
517:
518: static yyconst flex_int16_t yy_chk[324] =
519: { 0,
520: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
521: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
522: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
523: 3, 4, 5, 6, 5, 6, 5, 6, 3, 4,
524: 7, 8, 101, 16, 22, 7, 8, 22, 5, 6,
525: 28, 39, 48, 28, 39, 48, 7, 8, 16, 33,
526: 49, 55, 55, 49, 56, 56, 77, 77, 99, 37,
527: 75, 33, 33, 70, 37, 44, 33, 33, 33, 33,
528: 33, 33, 33, 33, 33, 37, 46, 46, 42, 46,
529: 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
530:
531: 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
532: 46, 46, 46, 46, 46, 46, 52, 40, 52, 74,
533: 38, 74, 78, 78, 82, 82, 32, 20, 11, 10,
534: 9, 0, 52, 0, 0, 74, 0, 0, 0, 0,
535: 0, 0, 0, 52, 72, 72, 74, 72, 72, 72,
536: 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
537: 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
538: 72, 72, 72, 72, 85, 85, 85, 85, 85, 85,
539: 85, 85, 86, 86, 86, 86, 86, 86, 86, 86,
540: 87, 87, 87, 87, 87, 87, 87, 87, 88, 0,
541:
542: 0, 0, 0, 0, 88, 88, 89, 89, 0, 89,
543: 89, 89, 89, 89, 90, 0, 0, 0, 0, 90,
544: 90, 90, 91, 91, 0, 91, 91, 0, 91, 91,
545: 92, 92, 0, 92, 92, 92, 92, 92, 93, 93,
546: 0, 0, 93, 93, 93, 94, 94, 94, 94, 94,
547: 94, 94, 94, 95, 95, 0, 95, 0, 95, 95,
548: 96, 96, 96, 96, 96, 96, 96, 96, 97, 97,
549: 97, 97, 97, 97, 97, 97, 98, 98, 98, 98,
550: 98, 98, 98, 98, 100, 100, 100, 100, 100, 100,
551: 100, 100, 84, 84, 84, 84, 84, 84, 84, 84,
552:
553: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
554: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
555: 84, 84, 84
556: } ;
557:
558: static yy_state_type yy_last_accepting_state;
559: static char *yy_last_accepting_cpos;
560:
561: extern int cfg_yy_flex_debug;
562: int cfg_yy_flex_debug = 0;
563:
564: /* The intent behind this definition is that it'll catch
565: * any uses of REJECT which flex missed.
566: */
567: #define REJECT reject_used_but_not_detected
568: #define yymore() yymore_used_but_not_detected
569: #define YY_MORE_ADJ 0
570: #define YY_RESTORE_YY_MORE_OFFSET
571: char *cfg_yytext;
572: #line 1 "lexer.l"
573: #line 2 "lexer.l"
574: /*
575: * Copyright (c) 2002,2003,2007 Martin Hedenfalk <martin@bzero.se>
576: *
577: * Permission to use, copy, modify, and distribute this software for any
578: * purpose with or without fee is hereby granted, provided that the above
579: * copyright notice and this permission notice appear in all copies.
580: *
581: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
582: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
583: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
584: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
585: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
586: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
587: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
588: */
589:
590: #ifdef HAVE_CONFIG_H
591: # include <config.h>
592: #endif
593:
594: #include <assert.h>
595:
596: #ifdef HAVE_STRING_H
597: # include <string.h>
598: #endif
599: #include "confuse.h"
600:
601: #include <errno.h>
602:
603: #if defined(ENABLE_NLS) && defined(HAVE_GETTEXT)
604: # include <libintl.h>
605: # define _(str) dgettext(PACKAGE, str)
606: #else
607: # define _(str) str
608: #endif
609: #define N_(str) str
610:
611: /*
612: * Prevent compilation of static input() function in generated code
613: * This function is never used but GCC 4.3 will warn about it.
614: */
615: #define YY_NO_INPUT
616:
617: typedef char * YYSTYPE;
618: extern YYSTYPE cfg_yylval;
619:
620: #define YY_DECL int cfg_yylex ( cfg_t *cfg )
621:
622: /* temporary buffer for the quoted strings scanner
623: */
624: char *cfg_qstring = NULL;
625: static unsigned int qstring_index = 0;
626: static unsigned int qstring_len = 0;
627: static void qputc(char ch);
628: #define CFG_QSTRING_BUFSIZ 32
629:
630: #define MAX_INCLUDE_DEPTH 10
631: struct {
632: YY_BUFFER_STATE state;
633: char *filename;
634: unsigned int line;
635: } cfg_include_stack[MAX_INCLUDE_DEPTH];
636: int cfg_include_stack_ptr = 0;
637:
638: static YY_BUFFER_STATE pre_string_scan_state = 0;
639: static YY_BUFFER_STATE string_scan_state = 0;
640:
641: /* start conditions
642: */
643:
644:
645:
646: #line 647 "lexer.c"
647:
648: #define INITIAL 0
649: #define comment 1
650: #define dq_str 2
651: #define sq_str 3
652:
653: #ifndef YY_NO_UNISTD_H
654: /* Special case for "unistd.h", since it is non-ANSI. We include it way
655: * down here because we want the user's section 1 to have been scanned first.
656: * The user has a chance to override it with an option.
657: */
658: #include <unistd.h>
659: #endif
660:
661: #ifndef YY_EXTRA_TYPE
662: #define YY_EXTRA_TYPE void *
663: #endif
664:
665: static int yy_init_globals (void );
666:
667: /* Accessor methods to globals.
668: These are made visible to non-reentrant scanners for convenience. */
669:
670: int cfg_yylex_destroy (void );
671:
672: int cfg_yyget_debug (void );
673:
674: void cfg_yyset_debug (int debug_flag );
675:
676: YY_EXTRA_TYPE cfg_yyget_extra (void );
677:
678: void cfg_yyset_extra (YY_EXTRA_TYPE user_defined );
679:
680: FILE *cfg_yyget_in (void );
681:
682: void cfg_yyset_in (FILE * in_str );
683:
684: FILE *cfg_yyget_out (void );
685:
686: void cfg_yyset_out (FILE * out_str );
687:
688: int cfg_yyget_leng (void );
689:
690: char *cfg_yyget_text (void );
691:
692: int cfg_yyget_lineno (void );
693:
694: void cfg_yyset_lineno (int line_number );
695:
696: /* Macros after this point can all be overridden by user definitions in
697: * section 1.
698: */
699:
700: #ifndef YY_SKIP_YYWRAP
701: #ifdef __cplusplus
702: extern "C" int cfg_yywrap (void );
703: #else
704: extern int cfg_yywrap (void );
705: #endif
706: #endif
707:
708: static void yyunput (int c,char *buf_ptr );
709:
710: #ifndef yytext_ptr
711: static void yy_flex_strncpy (char *,yyconst char *,int );
712: #endif
713:
714: #ifdef YY_NEED_STRLEN
715: static int yy_flex_strlen (yyconst char * );
716: #endif
717:
718: #ifndef YY_NO_INPUT
719:
720: #ifdef __cplusplus
721: static int yyinput (void );
722: #else
723: static int input (void );
724: #endif
725:
726: #endif
727:
728: /* Amount of stuff to slurp up with each read. */
729: #ifndef YY_READ_BUF_SIZE
730: #define YY_READ_BUF_SIZE 8192
731: #endif
732:
733: /* Copy whatever the last rule matched to the standard output. */
734: #ifndef ECHO
735: /* This used to be an fputs(), but since the string might contain NUL's,
736: * we now use fwrite().
737: */
738: #define ECHO fwrite( cfg_yytext, cfg_yyleng, 1, cfg_yyout )
739: #endif
740:
741: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
742: * is returned in "result".
743: */
744: #ifndef YY_INPUT
745: #define YY_INPUT(buf,result,max_size) \
746: if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
747: { \
748: int c = '*'; \
749: int n; \
750: for ( n = 0; n < max_size && \
751: (c = getc( cfg_yyin )) != EOF && c != '\n'; ++n ) \
752: buf[n] = (char) c; \
753: if ( c == '\n' ) \
754: buf[n++] = (char) c; \
755: if ( c == EOF && ferror( cfg_yyin ) ) \
756: YY_FATAL_ERROR( "input in flex scanner failed" ); \
757: result = n; \
758: } \
759: else \
760: { \
761: errno=0; \
762: while ( (result = fread(buf, 1, max_size, cfg_yyin))==0 && ferror(cfg_yyin)) \
763: { \
764: if( errno != EINTR) \
765: { \
766: YY_FATAL_ERROR( "input in flex scanner failed" ); \
767: break; \
768: } \
769: errno=0; \
770: clearerr(cfg_yyin); \
771: } \
772: }\
773: \
774:
775: #endif
776:
777: /* No semi-colon after return; correct usage is to write "yyterminate();" -
778: * we don't want an extra ';' after the "return" because that will cause
779: * some compilers to complain about unreachable statements.
780: */
781: #ifndef yyterminate
782: #define yyterminate() return YY_NULL
783: #endif
784:
785: /* Number of entries by which start-condition stack grows. */
786: #ifndef YY_START_STACK_INCR
787: #define YY_START_STACK_INCR 25
788: #endif
789:
790: /* Report a fatal error. */
791: #ifndef YY_FATAL_ERROR
792: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
793: #endif
794:
795: /* end tables serialization structures and prototypes */
796:
797: /* Default declaration of generated scanner - a define so the user can
798: * easily add parameters.
799: */
800: #ifndef YY_DECL
801: #define YY_DECL_IS_OURS 1
802:
803: extern int cfg_yylex (void);
804:
805: #define YY_DECL int cfg_yylex (void)
806: #endif /* !YY_DECL */
807:
808: /* Code executed at the beginning of each rule, after cfg_yytext and cfg_yyleng
809: * have been set up.
810: */
811: #ifndef YY_USER_ACTION
812: #define YY_USER_ACTION
813: #endif
814:
815: /* Code executed at the end of each rule. */
816: #ifndef YY_BREAK
817: #define YY_BREAK break;
818: #endif
819:
820: #define YY_RULE_SETUP \
821: YY_USER_ACTION
822:
823: /** The main scanner function which does all the work.
824: */
825: YY_DECL
826: {
827: register yy_state_type yy_current_state;
828: register char *yy_cp, *yy_bp;
829: register int yy_act;
830:
831: #line 79 "lexer.l"
832:
833:
834: #line 835 "lexer.c"
835:
836: if ( !(yy_init) )
837: {
838: (yy_init) = 1;
839:
840: #ifdef YY_USER_INIT
841: YY_USER_INIT;
842: #endif
843:
844: if ( ! (yy_start) )
845: (yy_start) = 1; /* first start state */
846:
847: if ( ! cfg_yyin )
848: cfg_yyin = stdin;
849:
850: if ( ! cfg_yyout )
851: cfg_yyout = stdout;
852:
853: if ( ! YY_CURRENT_BUFFER ) {
854: cfg_yyensure_buffer_stack ();
855: YY_CURRENT_BUFFER_LVALUE =
856: cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE );
857: }
858:
859: cfg_yy_load_buffer_state( );
860: }
861:
862: while ( 1 ) /* loops until end-of-file is reached */
863: {
864: yy_cp = (yy_c_buf_p);
865:
866: /* Support of cfg_yytext. */
867: *yy_cp = (yy_hold_char);
868:
869: /* yy_bp points to the position in yy_ch_buf of the start of
870: * the current run.
871: */
872: yy_bp = yy_cp;
873:
874: yy_current_state = (yy_start);
875: yy_match:
876: do
877: {
878: register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
879: if ( yy_accept[yy_current_state] )
880: {
881: (yy_last_accepting_state) = yy_current_state;
882: (yy_last_accepting_cpos) = yy_cp;
883: }
884: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
885: {
886: yy_current_state = (int) yy_def[yy_current_state];
887: if ( yy_current_state >= 85 )
888: yy_c = yy_meta[(unsigned int) yy_c];
889: }
890: yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
891: ++yy_cp;
892: }
893: while ( yy_base[yy_current_state] != 293 );
894:
895: yy_find_action:
896: yy_act = yy_accept[yy_current_state];
897: if ( yy_act == 0 )
898: { /* have to back up */
899: yy_cp = (yy_last_accepting_cpos);
900: yy_current_state = (yy_last_accepting_state);
901: yy_act = yy_accept[yy_current_state];
902: }
903:
904: YY_DO_BEFORE_ACTION;
905:
906: do_action: /* This label is used only to access EOF actions. */
907:
908: switch ( yy_act )
909: { /* beginning of action switch */
910: case 0: /* must back up */
911: /* undo the effects of YY_DO_BEFORE_ACTION */
912: *yy_cp = (yy_hold_char);
913: yy_cp = (yy_last_accepting_cpos);
914: yy_current_state = (yy_last_accepting_state);
915: goto yy_find_action;
916:
917: case 1:
918: YY_RULE_SETUP
919: #line 81 "lexer.l"
920: /* eat up whitespace */
921: YY_BREAK
922: case 2:
923: /* rule 2 can match eol */
924: YY_RULE_SETUP
925: #line 83 "lexer.l"
926: cfg->line++; /* keep track of line number */
927: YY_BREAK
928: case 3:
929: YY_RULE_SETUP
930: #line 85 "lexer.l"
931: /* eat up one-line comments */
932: YY_BREAK
933: /* special keywords/symbols
934: */
935: case 4:
936: YY_RULE_SETUP
937: #line 89 "lexer.l"
938: { cfg_yylval = cfg_yytext; return '{'; }
939: YY_BREAK
940: case 5:
941: YY_RULE_SETUP
942: #line 90 "lexer.l"
943: { cfg_yylval = cfg_yytext; return '}'; }
944: YY_BREAK
945: case 6:
946: YY_RULE_SETUP
947: #line 91 "lexer.l"
948: { cfg_yylval = cfg_yytext; return '('; }
949: YY_BREAK
950: case 7:
951: YY_RULE_SETUP
952: #line 92 "lexer.l"
953: { cfg_yylval = cfg_yytext; return ')'; }
954: YY_BREAK
955: case 8:
956: YY_RULE_SETUP
957: #line 93 "lexer.l"
958: { cfg_yylval = cfg_yytext; return '='; }
959: YY_BREAK
960: case 9:
961: YY_RULE_SETUP
962: #line 94 "lexer.l"
963: { cfg_yylval = cfg_yytext; return '+'; }
964: YY_BREAK
965: case 10:
966: YY_RULE_SETUP
967: #line 95 "lexer.l"
968: { cfg_yylval = cfg_yytext; return ','; }
969: YY_BREAK
970: /* handle multi-line C-style comments
971: */
972: case 11:
973: YY_RULE_SETUP
974: #line 99 "lexer.l"
975: BEGIN(comment);
976: YY_BREAK
977: case 12:
978: YY_RULE_SETUP
979: #line 100 "lexer.l"
980: /* eat anything that's not a '*' */
981: YY_BREAK
982: case 13:
983: YY_RULE_SETUP
984: #line 101 "lexer.l"
985: /* eat up '*'s not followed by '/'s */
986: YY_BREAK
987: case 14:
988: /* rule 14 can match eol */
989: YY_RULE_SETUP
990: #line 102 "lexer.l"
991: cfg->line++;
992: YY_BREAK
993: case 15:
994: YY_RULE_SETUP
995: #line 103 "lexer.l"
996: BEGIN(INITIAL);
997: YY_BREAK
998: /* handle C-style strings
999: */
1000: case 16:
1001: YY_RULE_SETUP
1002: #line 107 "lexer.l"
1003: {
1004: qstring_index = 0;
1005: BEGIN(dq_str);
1006: }
1007: YY_BREAK
1008: case 17:
1009: YY_RULE_SETUP
1010: #line 111 "lexer.l"
1011: { /* saw closing quote - all done */
1012: BEGIN(INITIAL);
1013: qputc('\0');
1014: cfg_yylval = cfg_qstring;
1015: return CFGT_STR;
1016: }
1017: YY_BREAK
1018: case 18:
1019: /* rule 18 can match eol */
1020: YY_RULE_SETUP
1021: #line 117 "lexer.l"
1022: { /* environment variable substitution */
1023: char *var;
1024: char *e;
1025: cfg_yytext[strlen(cfg_yytext) - 1] = 0;
1026: e = strchr(cfg_yytext+2, ':');
1027: if(e && e[1] == '-')
1028: *e = 0;
1029: else
1030: e = 0;
1031: var = getenv(cfg_yytext+2);
1032: if(!var && e)
1033: var = e+2;
1034: while(var && *var)
1035: qputc(*var++);
1036: }
1037: YY_BREAK
1038: case 19:
1039: /* rule 19 can match eol */
1040: YY_RULE_SETUP
1041: #line 132 "lexer.l"
1042: {
1043: qputc('\n');
1044: cfg->line++;
1045: }
1046: YY_BREAK
1047: case 20:
1048: /* rule 20 can match eol */
1049: YY_RULE_SETUP
1050: #line 136 "lexer.l"
1051: { /* allow continuing on next line */
1052: /* no-op */
1053: cfg->line++;
1054: }
1055: YY_BREAK
1056: case 21:
1057: YY_RULE_SETUP
1058: #line 140 "lexer.l"
1059: { /* octal escape sequence */
1060: unsigned int result;
1061: sscanf(cfg_yytext + 1, "%o", &result);
1062: if(result > 0xFF) {
1063: cfg_error(cfg, _("invalid octal number '%s'"), cfg_yytext);
1064: return 0;
1065: }
1066: qputc(result);
1067: }
1068: YY_BREAK
1069: case 22:
1070: YY_RULE_SETUP
1071: #line 149 "lexer.l"
1072: {
1073: cfg_error(cfg, _("bad escape sequence '%s'"), cfg_yytext);
1074: return 0;
1075: }
1076: YY_BREAK
1077: case 23:
1078: YY_RULE_SETUP
1079: #line 153 "lexer.l"
1080: { /* hexadecimal escape sequence */
1081: unsigned int result;
1082: sscanf(cfg_yytext + 2, "%x", &result);
1083: qputc(result);
1084: }
1085: YY_BREAK
1086: case 24:
1087: YY_RULE_SETUP
1088: #line 158 "lexer.l"
1089: {
1090: qputc('\n');
1091: }
1092: YY_BREAK
1093: case 25:
1094: YY_RULE_SETUP
1095: #line 161 "lexer.l"
1096: {
1097: qputc('\r');
1098: }
1099: YY_BREAK
1100: case 26:
1101: YY_RULE_SETUP
1102: #line 164 "lexer.l"
1103: {
1104: qputc('\b');
1105: }
1106: YY_BREAK
1107: case 27:
1108: YY_RULE_SETUP
1109: #line 167 "lexer.l"
1110: {
1111: qputc('\f');
1112: }
1113: YY_BREAK
1114: case 28:
1115: YY_RULE_SETUP
1116: #line 170 "lexer.l"
1117: {
1118: qputc('\007');
1119: }
1120: YY_BREAK
1121: case 29:
1122: YY_RULE_SETUP
1123: #line 173 "lexer.l"
1124: {
1125: qputc('\033');
1126: }
1127: YY_BREAK
1128: case 30:
1129: YY_RULE_SETUP
1130: #line 176 "lexer.l"
1131: {
1132: qputc('\t');
1133: }
1134: YY_BREAK
1135: case 31:
1136: YY_RULE_SETUP
1137: #line 179 "lexer.l"
1138: {
1139: qputc('\v');
1140: }
1141: YY_BREAK
1142: case 32:
1143: YY_RULE_SETUP
1144: #line 182 "lexer.l"
1145: {
1146: qputc(cfg_yytext[1]);
1147: }
1148: YY_BREAK
1149: case 33:
1150: YY_RULE_SETUP
1151: #line 185 "lexer.l"
1152: {
1153: char *yptr = cfg_yytext;
1154: while(*yptr) {
1155: qputc(*yptr++);
1156: }
1157: }
1158: YY_BREAK
1159: /* single-quoted string ('...') */
1160: case 34:
1161: YY_RULE_SETUP
1162: #line 193 "lexer.l"
1163: {
1164: qstring_index = 0;
1165: BEGIN(sq_str);
1166: }
1167: YY_BREAK
1168: case 35:
1169: YY_RULE_SETUP
1170: #line 197 "lexer.l"
1171: { /* saw closing quote - all done */
1172: BEGIN(INITIAL);
1173: qputc('\0');
1174: cfg_yylval = cfg_qstring;
1175: return CFGT_STR;
1176: }
1177: YY_BREAK
1178: case 36:
1179: /* rule 36 can match eol */
1180: YY_RULE_SETUP
1181: #line 203 "lexer.l"
1182: {
1183: qputc('\n');
1184: cfg->line++;
1185: }
1186: YY_BREAK
1187: case 37:
1188: /* rule 37 can match eol */
1189: YY_RULE_SETUP
1190: #line 207 "lexer.l"
1191: { /* allow continuing on next line */
1192: /* no-op */
1193: cfg->line++;
1194: }
1195: YY_BREAK
1196: case 38:
1197: YY_RULE_SETUP
1198: #line 211 "lexer.l"
1199: {
1200: qputc(cfg_yytext[1]);
1201: }
1202: YY_BREAK
1203: case 39:
1204: /* rule 39 can match eol */
1205: YY_RULE_SETUP
1206: #line 214 "lexer.l"
1207: {
1208: qputc(cfg_yytext[0]);
1209: qputc(cfg_yytext[1]);
1210: }
1211: YY_BREAK
1212: case 40:
1213: YY_RULE_SETUP
1214: #line 218 "lexer.l"
1215: {
1216: char *cp = cfg_yytext;
1217: while(*cp != '\0') {
1218: qputc(*cp++);
1219: }
1220: }
1221: YY_BREAK
1222: case YY_STATE_EOF(sq_str):
1223: #line 224 "lexer.l"
1224: {
1225: cfg_error(cfg, _("unterminated string constant"));
1226: return 0;
1227: }
1228: YY_BREAK
1229: case YY_STATE_EOF(INITIAL):
1230: case YY_STATE_EOF(comment):
1231: case YY_STATE_EOF(dq_str):
1232: #line 229 "lexer.l"
1233: {
1234: if (cfg_include_stack_ptr <= 0)
1235: {
1236: return EOF;
1237: }
1238: else
1239: {
1240: cfg_yy_delete_buffer(YY_CURRENT_BUFFER );
1241: fclose(cfg_yyin);
1242: cfg_yyin = 0;
1243: --cfg_include_stack_ptr;
1244: cfg_yy_switch_to_buffer(cfg_include_stack[cfg_include_stack_ptr].state );
1245: free(cfg->filename);
1246: cfg->filename = cfg_include_stack[cfg_include_stack_ptr].filename;
1247: cfg->line = cfg_include_stack[cfg_include_stack_ptr].line;
1248: }
1249: }
1250: YY_BREAK
1251: case 41:
1252: /* rule 41 can match eol */
1253: YY_RULE_SETUP
1254: #line 248 "lexer.l"
1255: {
1256: char *var;
1257: char *e;
1258: cfg_yytext[strlen(cfg_yytext) - 1] = 0;
1259: e = strchr(cfg_yytext+2, ':');
1260: if(e && e[1] == '-')
1261: *e = 0;
1262: else
1263: e = 0;
1264: var = getenv(cfg_yytext+2);
1265: if(!var && e)
1266: var = e+2;
1267: if(!var)
1268: var = "";
1269: cfg_yylval = var;
1270: return CFGT_STR;
1271: }
1272: YY_BREAK
1273: /* an unquoted string
1274: * a slash can't be followed by another slash (c++
1275: * comment) or an asterisk (C multi-line comment)
1276: */
1277: case 42:
1278: YY_RULE_SETUP
1279: #line 270 "lexer.l"
1280: {
1281: cfg_yylval = cfg_yytext;
1282: return CFGT_STR;
1283: }
1284: YY_BREAK
1285: case 43:
1286: YY_RULE_SETUP
1287: #line 275 "lexer.l"
1288: /* eat any non-matching characters */
1289: YY_BREAK
1290: case 44:
1291: YY_RULE_SETUP
1292: #line 277 "lexer.l"
1293: ECHO;
1294: YY_BREAK
1295: #line 1296 "lexer.c"
1296:
1297: case YY_END_OF_BUFFER:
1298: {
1299: /* Amount of text matched not including the EOB char. */
1300: int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1301:
1302: /* Undo the effects of YY_DO_BEFORE_ACTION. */
1303: *yy_cp = (yy_hold_char);
1304: YY_RESTORE_YY_MORE_OFFSET
1305:
1306: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1307: {
1308: /* We're scanning a new file or input source. It's
1309: * possible that this happened because the user
1310: * just pointed cfg_yyin at a new source and called
1311: * cfg_yylex(). If so, then we have to assure
1312: * consistency between YY_CURRENT_BUFFER and our
1313: * globals. Here is the right place to do so, because
1314: * this is the first action (other than possibly a
1315: * back-up) that will match for the new input source.
1316: */
1317: (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1318: YY_CURRENT_BUFFER_LVALUE->yy_input_file = cfg_yyin;
1319: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1320: }
1321:
1322: /* Note that here we test for yy_c_buf_p "<=" to the position
1323: * of the first EOB in the buffer, since yy_c_buf_p will
1324: * already have been incremented past the NUL character
1325: * (since all states make transitions on EOB to the
1326: * end-of-buffer state). Contrast this with the test
1327: * in input().
1328: */
1329: if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1330: { /* This was really a NUL. */
1331: yy_state_type yy_next_state;
1332:
1333: (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1334:
1335: yy_current_state = yy_get_previous_state( );
1336:
1337: /* Okay, we're now positioned to make the NUL
1338: * transition. We couldn't have
1339: * yy_get_previous_state() go ahead and do it
1340: * for us because it doesn't know how to deal
1341: * with the possibility of jamming (and we don't
1342: * want to build jamming into it because then it
1343: * will run more slowly).
1344: */
1345:
1346: yy_next_state = yy_try_NUL_trans( yy_current_state );
1347:
1348: yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1349:
1350: if ( yy_next_state )
1351: {
1352: /* Consume the NUL. */
1353: yy_cp = ++(yy_c_buf_p);
1354: yy_current_state = yy_next_state;
1355: goto yy_match;
1356: }
1357:
1358: else
1359: {
1360: yy_cp = (yy_c_buf_p);
1361: goto yy_find_action;
1362: }
1363: }
1364:
1365: else switch ( yy_get_next_buffer( ) )
1366: {
1367: case EOB_ACT_END_OF_FILE:
1368: {
1369: (yy_did_buffer_switch_on_eof) = 0;
1370:
1371: if ( cfg_yywrap( ) )
1372: {
1373: /* Note: because we've taken care in
1374: * yy_get_next_buffer() to have set up
1375: * cfg_yytext, we can now set up
1376: * yy_c_buf_p so that if some total
1377: * hoser (like flex itself) wants to
1378: * call the scanner after we return the
1379: * YY_NULL, it'll still work - another
1380: * YY_NULL will get returned.
1381: */
1382: (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1383:
1384: yy_act = YY_STATE_EOF(YY_START);
1385: goto do_action;
1386: }
1387:
1388: else
1389: {
1390: if ( ! (yy_did_buffer_switch_on_eof) )
1391: YY_NEW_FILE;
1392: }
1393: break;
1394: }
1395:
1396: case EOB_ACT_CONTINUE_SCAN:
1397: (yy_c_buf_p) =
1398: (yytext_ptr) + yy_amount_of_matched_text;
1399:
1400: yy_current_state = yy_get_previous_state( );
1401:
1402: yy_cp = (yy_c_buf_p);
1403: yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1404: goto yy_match;
1405:
1406: case EOB_ACT_LAST_MATCH:
1407: (yy_c_buf_p) =
1408: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1409:
1410: yy_current_state = yy_get_previous_state( );
1411:
1412: yy_cp = (yy_c_buf_p);
1413: yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1414: goto yy_find_action;
1415: }
1416: break;
1417: }
1418:
1419: default:
1420: YY_FATAL_ERROR(
1421: "fatal flex scanner internal error--no action found" );
1422: } /* end of action switch */
1423: } /* end of scanning one token */
1424: } /* end of cfg_yylex */
1425:
1426: /* yy_get_next_buffer - try to read in a new buffer
1427: *
1428: * Returns a code representing an action:
1429: * EOB_ACT_LAST_MATCH -
1430: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1431: * EOB_ACT_END_OF_FILE - end of file
1432: */
1433: static int yy_get_next_buffer (void)
1434: {
1435: register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1436: register char *source = (yytext_ptr);
1437: register int number_to_move, i;
1438: int ret_val;
1439:
1440: if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1441: YY_FATAL_ERROR(
1442: "fatal flex scanner internal error--end of buffer missed" );
1443:
1444: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1445: { /* Don't try to fill the buffer, so this is an EOF. */
1446: if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1447: {
1448: /* We matched a single character, the EOB, so
1449: * treat this as a final EOF.
1450: */
1451: return EOB_ACT_END_OF_FILE;
1452: }
1453:
1454: else
1455: {
1456: /* We matched some text prior to the EOB, first
1457: * process it.
1458: */
1459: return EOB_ACT_LAST_MATCH;
1460: }
1461: }
1462:
1463: /* Try to read more data. */
1464:
1465: /* First move last chars to start of buffer. */
1466: number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1467:
1468: for ( i = 0; i < number_to_move; ++i )
1469: *(dest++) = *(source++);
1470:
1471: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1472: /* don't do the read, it's not guaranteed to return an EOF,
1473: * just force an EOF
1474: */
1475: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1476:
1477: else
1478: {
1479: int num_to_read =
1480: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1481:
1482: while ( num_to_read <= 0 )
1483: { /* Not enough room in the buffer - grow it. */
1484:
1485: /* just a shorter name for the current buffer */
1486: YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1487:
1488: int yy_c_buf_p_offset =
1489: (int) ((yy_c_buf_p) - b->yy_ch_buf);
1490:
1491: if ( b->yy_is_our_buffer )
1492: {
1493: int new_size = b->yy_buf_size * 2;
1494:
1495: if ( new_size <= 0 )
1496: b->yy_buf_size += b->yy_buf_size / 8;
1497: else
1498: b->yy_buf_size *= 2;
1499:
1500: b->yy_ch_buf = (char *)
1501: /* Include room in for 2 EOB chars. */
1502: cfg_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1503: }
1504: else
1505: /* Can't grow it, we don't own it. */
1506: b->yy_ch_buf = 0;
1507:
1508: if ( ! b->yy_ch_buf )
1509: YY_FATAL_ERROR(
1510: "fatal error - scanner input buffer overflow" );
1511:
1512: (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1513:
1514: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1515: number_to_move - 1;
1516:
1517: }
1518:
1519: if ( num_to_read > YY_READ_BUF_SIZE )
1520: num_to_read = YY_READ_BUF_SIZE;
1521:
1522: /* Read in more data. */
1523: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1524: (yy_n_chars), (size_t) num_to_read );
1525:
1526: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1527: }
1528:
1529: if ( (yy_n_chars) == 0 )
1530: {
1531: if ( number_to_move == YY_MORE_ADJ )
1532: {
1533: ret_val = EOB_ACT_END_OF_FILE;
1534: cfg_yyrestart(cfg_yyin );
1535: }
1536:
1537: else
1538: {
1539: ret_val = EOB_ACT_LAST_MATCH;
1540: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1541: YY_BUFFER_EOF_PENDING;
1542: }
1543: }
1544:
1545: else
1546: ret_val = EOB_ACT_CONTINUE_SCAN;
1547:
1548: if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1549: /* Extend the array by 50%, plus the number we really need. */
1550: yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1551: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cfg_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1552: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1553: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1554: }
1555:
1556: (yy_n_chars) += number_to_move;
1557: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1558: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1559:
1560: (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1561:
1562: return ret_val;
1563: }
1564:
1565: /* yy_get_previous_state - get the state just before the EOB char was reached */
1566:
1567: static yy_state_type yy_get_previous_state (void)
1568: {
1569: register yy_state_type yy_current_state;
1570: register char *yy_cp;
1571:
1572: yy_current_state = (yy_start);
1573:
1574: for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1575: {
1576: register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1577: if ( yy_accept[yy_current_state] )
1578: {
1579: (yy_last_accepting_state) = yy_current_state;
1580: (yy_last_accepting_cpos) = yy_cp;
1581: }
1582: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1583: {
1584: yy_current_state = (int) yy_def[yy_current_state];
1585: if ( yy_current_state >= 85 )
1586: yy_c = yy_meta[(unsigned int) yy_c];
1587: }
1588: yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1589: }
1590:
1591: return yy_current_state;
1592: }
1593:
1594: /* yy_try_NUL_trans - try to make a transition on the NUL character
1595: *
1596: * synopsis
1597: * next_state = yy_try_NUL_trans( current_state );
1598: */
1599: static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1600: {
1601: register int yy_is_jam;
1602: register char *yy_cp = (yy_c_buf_p);
1603:
1604: register YY_CHAR yy_c = 1;
1605: if ( yy_accept[yy_current_state] )
1606: {
1607: (yy_last_accepting_state) = yy_current_state;
1608: (yy_last_accepting_cpos) = yy_cp;
1609: }
1610: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1611: {
1612: yy_current_state = (int) yy_def[yy_current_state];
1613: if ( yy_current_state >= 85 )
1614: yy_c = yy_meta[(unsigned int) yy_c];
1615: }
1616: yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1617: yy_is_jam = (yy_current_state == 84);
1618:
1619: return yy_is_jam ? 0 : yy_current_state;
1620: }
1621:
1622: static void yyunput (int c, register char * yy_bp )
1623: {
1624: register char *yy_cp;
1625:
1626: yy_cp = (yy_c_buf_p);
1627:
1628: /* undo effects of setting up cfg_yytext */
1629: *yy_cp = (yy_hold_char);
1630:
1631: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1632: { /* need to shift things up to make room */
1633: /* +2 for EOB chars. */
1634: register int number_to_move = (yy_n_chars) + 2;
1635: register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1636: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1637: register char *source =
1638: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1639:
1640: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1641: *--dest = *--source;
1642:
1643: yy_cp += (int) (dest - source);
1644: yy_bp += (int) (dest - source);
1645: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1646: (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1647:
1648: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1649: YY_FATAL_ERROR( "flex scanner push-back overflow" );
1650: }
1651:
1652: *--yy_cp = (char) c;
1653:
1654: (yytext_ptr) = yy_bp;
1655: (yy_hold_char) = *yy_cp;
1656: (yy_c_buf_p) = yy_cp;
1657: }
1658:
1659: #ifndef YY_NO_INPUT
1660: #ifdef __cplusplus
1661: static int yyinput (void)
1662: #else
1663: static int input (void)
1664: #endif
1665:
1666: {
1667: int c;
1668:
1669: *(yy_c_buf_p) = (yy_hold_char);
1670:
1671: if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1672: {
1673: /* yy_c_buf_p now points to the character we want to return.
1674: * If this occurs *before* the EOB characters, then it's a
1675: * valid NUL; if not, then we've hit the end of the buffer.
1676: */
1677: if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1678: /* This was really a NUL. */
1679: *(yy_c_buf_p) = '\0';
1680:
1681: else
1682: { /* need more input */
1683: int offset = (yy_c_buf_p) - (yytext_ptr);
1684: ++(yy_c_buf_p);
1685:
1686: switch ( yy_get_next_buffer( ) )
1687: {
1688: case EOB_ACT_LAST_MATCH:
1689: /* This happens because yy_g_n_b()
1690: * sees that we've accumulated a
1691: * token and flags that we need to
1692: * try matching the token before
1693: * proceeding. But for input(),
1694: * there's no matching to consider.
1695: * So convert the EOB_ACT_LAST_MATCH
1696: * to EOB_ACT_END_OF_FILE.
1697: */
1698:
1699: /* Reset buffer status. */
1700: cfg_yyrestart(cfg_yyin );
1701:
1702: /*FALLTHROUGH*/
1703:
1704: case EOB_ACT_END_OF_FILE:
1705: {
1706: if ( cfg_yywrap( ) )
1707: return EOF;
1708:
1709: if ( ! (yy_did_buffer_switch_on_eof) )
1710: YY_NEW_FILE;
1711: #ifdef __cplusplus
1712: return yyinput();
1713: #else
1714: return input();
1715: #endif
1716: }
1717:
1718: case EOB_ACT_CONTINUE_SCAN:
1719: (yy_c_buf_p) = (yytext_ptr) + offset;
1720: break;
1721: }
1722: }
1723: }
1724:
1725: c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1726: *(yy_c_buf_p) = '\0'; /* preserve cfg_yytext */
1727: (yy_hold_char) = *++(yy_c_buf_p);
1728:
1729: return c;
1730: }
1731: #endif /* ifndef YY_NO_INPUT */
1732:
1733: /** Immediately switch to a different input stream.
1734: * @param input_file A readable stream.
1735: *
1736: * @note This function does not reset the start condition to @c INITIAL .
1737: */
1738: void cfg_yyrestart (FILE * input_file )
1739: {
1740:
1741: if ( ! YY_CURRENT_BUFFER ){
1742: cfg_yyensure_buffer_stack ();
1743: YY_CURRENT_BUFFER_LVALUE =
1744: cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE );
1745: }
1746:
1747: cfg_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1748: cfg_yy_load_buffer_state( );
1749: }
1750:
1751: /** Switch to a different input buffer.
1752: * @param new_buffer The new input buffer.
1753: *
1754: */
1755: void cfg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1756: {
1757:
1758: /* TODO. We should be able to replace this entire function body
1759: * with
1760: * cfg_yypop_buffer_state();
1761: * cfg_yypush_buffer_state(new_buffer);
1762: */
1763: cfg_yyensure_buffer_stack ();
1764: if ( YY_CURRENT_BUFFER == new_buffer )
1765: return;
1766:
1767: if ( YY_CURRENT_BUFFER )
1768: {
1769: /* Flush out information for old buffer. */
1770: *(yy_c_buf_p) = (yy_hold_char);
1771: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1772: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1773: }
1774:
1775: YY_CURRENT_BUFFER_LVALUE = new_buffer;
1776: cfg_yy_load_buffer_state( );
1777:
1778: /* We don't actually know whether we did this switch during
1779: * EOF (cfg_yywrap()) processing, but the only time this flag
1780: * is looked at is after cfg_yywrap() is called, so it's safe
1781: * to go ahead and always set it.
1782: */
1783: (yy_did_buffer_switch_on_eof) = 1;
1784: }
1785:
1786: static void cfg_yy_load_buffer_state (void)
1787: {
1788: (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1789: (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1790: cfg_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1791: (yy_hold_char) = *(yy_c_buf_p);
1792: }
1793:
1794: /** Allocate and initialize an input buffer state.
1795: * @param file A readable stream.
1796: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1797: *
1798: * @return the allocated buffer state.
1799: */
1800: YY_BUFFER_STATE cfg_yy_create_buffer (FILE * file, int size )
1801: {
1802: YY_BUFFER_STATE b;
1803:
1804: b = (YY_BUFFER_STATE) cfg_yyalloc(sizeof( struct yy_buffer_state ) );
1805: if ( ! b )
1806: YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_create_buffer()" );
1807:
1808: b->yy_buf_size = size;
1809:
1810: /* yy_ch_buf has to be 2 characters longer than the size given because
1811: * we need to put in 2 end-of-buffer characters.
1812: */
1813: b->yy_ch_buf = (char *) cfg_yyalloc(b->yy_buf_size + 2 );
1814: if ( ! b->yy_ch_buf )
1815: YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_create_buffer()" );
1816:
1817: b->yy_is_our_buffer = 1;
1818:
1819: cfg_yy_init_buffer(b,file );
1820:
1821: return b;
1822: }
1823:
1824: /** Destroy the buffer.
1825: * @param b a buffer created with cfg_yy_create_buffer()
1826: *
1827: */
1828: void cfg_yy_delete_buffer (YY_BUFFER_STATE b )
1829: {
1830:
1831: if ( ! b )
1832: return;
1833:
1834: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1835: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1836:
1837: if ( b->yy_is_our_buffer )
1838: cfg_yyfree((void *) b->yy_ch_buf );
1839:
1840: cfg_yyfree((void *) b );
1841: }
1842:
1843: #ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
1844: #ifdef __cplusplus
1845: extern "C" {
1846: #endif
1847: #ifdef __THROW /* this is a gnuism */
1848: extern int isatty (int ) __THROW;
1849: #else
1850: extern int isatty (int );
1851: #endif
1852: #ifdef __cplusplus
1853: }
1854: #endif
1855: #endif
1856:
1857: /* Initializes or reinitializes a buffer.
1858: * This function is sometimes called more than once on the same buffer,
1859: * such as during a cfg_yyrestart() or at EOF.
1860: */
1861: static void cfg_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1862:
1863: {
1864: int oerrno = errno;
1865:
1866: cfg_yy_flush_buffer(b );
1867:
1868: b->yy_input_file = file;
1869: b->yy_fill_buffer = 1;
1870:
1871: /* If b is the current buffer, then cfg_yy_init_buffer was _probably_
1872: * called from cfg_yyrestart() or through yy_get_next_buffer.
1873: * In that case, we don't want to reset the lineno or column.
1874: */
1875: if (b != YY_CURRENT_BUFFER){
1876: b->yy_bs_lineno = 1;
1877: b->yy_bs_column = 0;
1878: }
1879:
1880: b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1881:
1882: errno = oerrno;
1883: }
1884:
1885: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1886: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1887: *
1888: */
1889: void cfg_yy_flush_buffer (YY_BUFFER_STATE b )
1890: {
1891: if ( ! b )
1892: return;
1893:
1894: b->yy_n_chars = 0;
1895:
1896: /* We always need two end-of-buffer characters. The first causes
1897: * a transition to the end-of-buffer state. The second causes
1898: * a jam in that state.
1899: */
1900: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1901: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1902:
1903: b->yy_buf_pos = &b->yy_ch_buf[0];
1904:
1905: b->yy_at_bol = 1;
1906: b->yy_buffer_status = YY_BUFFER_NEW;
1907:
1908: if ( b == YY_CURRENT_BUFFER )
1909: cfg_yy_load_buffer_state( );
1910: }
1911:
1912: /** Pushes the new state onto the stack. The new state becomes
1913: * the current state. This function will allocate the stack
1914: * if necessary.
1915: * @param new_buffer The new state.
1916: *
1917: */
1918: void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1919: {
1920: if (new_buffer == NULL)
1921: return;
1922:
1923: cfg_yyensure_buffer_stack();
1924:
1925: /* This block is copied from cfg_yy_switch_to_buffer. */
1926: if ( YY_CURRENT_BUFFER )
1927: {
1928: /* Flush out information for old buffer. */
1929: *(yy_c_buf_p) = (yy_hold_char);
1930: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1931: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1932: }
1933:
1934: /* Only push if top exists. Otherwise, replace top. */
1935: if (YY_CURRENT_BUFFER)
1936: (yy_buffer_stack_top)++;
1937: YY_CURRENT_BUFFER_LVALUE = new_buffer;
1938:
1939: /* copied from cfg_yy_switch_to_buffer. */
1940: cfg_yy_load_buffer_state( );
1941: (yy_did_buffer_switch_on_eof) = 1;
1942: }
1943:
1944: /** Removes and deletes the top of the stack, if present.
1945: * The next element becomes the new top.
1946: *
1947: */
1948: void cfg_yypop_buffer_state (void)
1949: {
1950: if (!YY_CURRENT_BUFFER)
1951: return;
1952:
1953: cfg_yy_delete_buffer(YY_CURRENT_BUFFER );
1954: YY_CURRENT_BUFFER_LVALUE = NULL;
1955: if ((yy_buffer_stack_top) > 0)
1956: --(yy_buffer_stack_top);
1957:
1958: if (YY_CURRENT_BUFFER) {
1959: cfg_yy_load_buffer_state( );
1960: (yy_did_buffer_switch_on_eof) = 1;
1961: }
1962: }
1963:
1964: /* Allocates the stack if it does not exist.
1965: * Guarantees space for at least one push.
1966: */
1967: static void cfg_yyensure_buffer_stack (void)
1968: {
1969: int num_to_alloc;
1970:
1971: if (!(yy_buffer_stack)) {
1972:
1973: /* First allocation is just for 2 elements, since we don't know if this
1974: * scanner will even need a stack. We use 2 instead of 1 to avoid an
1975: * immediate realloc on the next call.
1976: */
1977: num_to_alloc = 1;
1978: (yy_buffer_stack) = (struct yy_buffer_state**)cfg_yyalloc
1979: (num_to_alloc * sizeof(struct yy_buffer_state*)
1980: );
1981: if ( ! (yy_buffer_stack) )
1982: YY_FATAL_ERROR( "out of dynamic memory in cfg_yyensure_buffer_stack()" );
1983:
1984: memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1985:
1986: (yy_buffer_stack_max) = num_to_alloc;
1987: (yy_buffer_stack_top) = 0;
1988: return;
1989: }
1990:
1991: if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1992:
1993: /* Increase the buffer to prepare for a possible push. */
1994: int grow_size = 8 /* arbitrary grow size */;
1995:
1996: num_to_alloc = (yy_buffer_stack_max) + grow_size;
1997: (yy_buffer_stack) = (struct yy_buffer_state**)cfg_yyrealloc
1998: ((yy_buffer_stack),
1999: num_to_alloc * sizeof(struct yy_buffer_state*)
2000: );
2001: if ( ! (yy_buffer_stack) )
2002: YY_FATAL_ERROR( "out of dynamic memory in cfg_yyensure_buffer_stack()" );
2003:
2004: /* zero only the new slots.*/
2005: memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2006: (yy_buffer_stack_max) = num_to_alloc;
2007: }
2008: }
2009:
2010: /** Setup the input buffer state to scan directly from a user-specified character buffer.
2011: * @param base the character buffer
2012: * @param size the size in bytes of the character buffer
2013: *
2014: * @return the newly allocated buffer state object.
2015: */
2016: YY_BUFFER_STATE cfg_yy_scan_buffer (char * base, yy_size_t size )
2017: {
2018: YY_BUFFER_STATE b;
2019:
2020: if ( size < 2 ||
2021: base[size-2] != YY_END_OF_BUFFER_CHAR ||
2022: base[size-1] != YY_END_OF_BUFFER_CHAR )
2023: /* They forgot to leave room for the EOB's. */
2024: return 0;
2025:
2026: b = (YY_BUFFER_STATE) cfg_yyalloc(sizeof( struct yy_buffer_state ) );
2027: if ( ! b )
2028: YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_scan_buffer()" );
2029:
2030: b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2031: b->yy_buf_pos = b->yy_ch_buf = base;
2032: b->yy_is_our_buffer = 0;
2033: b->yy_input_file = 0;
2034: b->yy_n_chars = b->yy_buf_size;
2035: b->yy_is_interactive = 0;
2036: b->yy_at_bol = 1;
2037: b->yy_fill_buffer = 0;
2038: b->yy_buffer_status = YY_BUFFER_NEW;
2039:
2040: cfg_yy_switch_to_buffer(b );
2041:
2042: return b;
2043: }
2044:
2045: /** Setup the input buffer state to scan a string. The next call to cfg_yylex() will
2046: * scan from a @e copy of @a str.
2047: * @param yystr a NUL-terminated string to scan
2048: *
2049: * @return the newly allocated buffer state object.
2050: * @note If you want to scan bytes that may contain NUL values, then use
2051: * cfg_yy_scan_bytes() instead.
2052: */
2053: YY_BUFFER_STATE cfg_yy_scan_string (yyconst char * yystr )
2054: {
2055:
2056: return cfg_yy_scan_bytes(yystr,strlen(yystr) );
2057: }
2058:
2059: /** Setup the input buffer state to scan the given bytes. The next call to cfg_yylex() will
2060: * scan from a @e copy of @a bytes.
2061: * @param bytes the byte buffer to scan
2062: * @param len the number of bytes in the buffer pointed to by @a bytes.
2063: *
2064: * @return the newly allocated buffer state object.
2065: */
2066: YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
2067: {
2068: YY_BUFFER_STATE b;
2069: char *buf;
2070: yy_size_t n;
2071: int i;
2072:
2073: /* Get memory for full buffer, including space for trailing EOB's. */
2074: n = _yybytes_len + 2;
2075: buf = (char *) cfg_yyalloc(n );
2076: if ( ! buf )
2077: YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_scan_bytes()" );
2078:
2079: for ( i = 0; i < _yybytes_len; ++i )
2080: buf[i] = yybytes[i];
2081:
2082: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2083:
2084: b = cfg_yy_scan_buffer(buf,n );
2085: if ( ! b )
2086: YY_FATAL_ERROR( "bad buffer in cfg_yy_scan_bytes()" );
2087:
2088: /* It's okay to grow etc. this buffer, and we should throw it
2089: * away when we're done.
2090: */
2091: b->yy_is_our_buffer = 1;
2092:
2093: return b;
2094: }
2095:
2096: #ifndef YY_EXIT_FAILURE
2097: #define YY_EXIT_FAILURE 2
2098: #endif
2099:
2100: static void yy_fatal_error (yyconst char* msg )
2101: {
2102: (void) fprintf( stderr, "%s\n", msg );
2103: exit( YY_EXIT_FAILURE );
2104: }
2105:
2106: /* Redefine yyless() so it works in section 3 code. */
2107:
2108: #undef yyless
2109: #define yyless(n) \
2110: do \
2111: { \
2112: /* Undo effects of setting up cfg_yytext. */ \
2113: int yyless_macro_arg = (n); \
2114: YY_LESS_LINENO(yyless_macro_arg);\
2115: cfg_yytext[cfg_yyleng] = (yy_hold_char); \
2116: (yy_c_buf_p) = cfg_yytext + yyless_macro_arg; \
2117: (yy_hold_char) = *(yy_c_buf_p); \
2118: *(yy_c_buf_p) = '\0'; \
2119: cfg_yyleng = yyless_macro_arg; \
2120: } \
2121: while ( 0 )
2122:
2123: /* Accessor methods (get/set functions) to struct members. */
2124:
2125: /** Get the current line number.
2126: *
2127: */
2128: int cfg_yyget_lineno (void)
2129: {
2130:
2131: return cfg_yylineno;
2132: }
2133:
2134: /** Get the input stream.
2135: *
2136: */
2137: FILE *cfg_yyget_in (void)
2138: {
2139: return cfg_yyin;
2140: }
2141:
2142: /** Get the output stream.
2143: *
2144: */
2145: FILE *cfg_yyget_out (void)
2146: {
2147: return cfg_yyout;
2148: }
2149:
2150: /** Get the length of the current token.
2151: *
2152: */
2153: int cfg_yyget_leng (void)
2154: {
2155: return cfg_yyleng;
2156: }
2157:
2158: /** Get the current token.
2159: *
2160: */
2161:
2162: char *cfg_yyget_text (void)
2163: {
2164: return cfg_yytext;
2165: }
2166:
2167: /** Set the current line number.
2168: * @param line_number
2169: *
2170: */
2171: void cfg_yyset_lineno (int line_number )
2172: {
2173:
2174: cfg_yylineno = line_number;
2175: }
2176:
2177: /** Set the input stream. This does not discard the current
2178: * input buffer.
2179: * @param in_str A readable stream.
2180: *
2181: * @see cfg_yy_switch_to_buffer
2182: */
2183: void cfg_yyset_in (FILE * in_str )
2184: {
2185: cfg_yyin = in_str ;
2186: }
2187:
2188: void cfg_yyset_out (FILE * out_str )
2189: {
2190: cfg_yyout = out_str ;
2191: }
2192:
2193: int cfg_yyget_debug (void)
2194: {
2195: return cfg_yy_flex_debug;
2196: }
2197:
2198: void cfg_yyset_debug (int bdebug )
2199: {
2200: cfg_yy_flex_debug = bdebug ;
2201: }
2202:
2203: static int yy_init_globals (void)
2204: {
2205: /* Initialization is the same as for the non-reentrant scanner.
2206: * This function is called from cfg_yylex_destroy(), so don't allocate here.
2207: */
2208:
2209: (yy_buffer_stack) = 0;
2210: (yy_buffer_stack_top) = 0;
2211: (yy_buffer_stack_max) = 0;
2212: (yy_c_buf_p) = (char *) 0;
2213: (yy_init) = 0;
2214: (yy_start) = 0;
2215:
2216: /* Defined in main.c */
2217: #ifdef YY_STDINIT
2218: cfg_yyin = stdin;
2219: cfg_yyout = stdout;
2220: #else
2221: cfg_yyin = (FILE *) 0;
2222: cfg_yyout = (FILE *) 0;
2223: #endif
2224:
2225: /* For future reference: Set errno on error, since we are called by
2226: * cfg_yylex_init()
2227: */
2228: return 0;
2229: }
2230:
2231: /* cfg_yylex_destroy is for both reentrant and non-reentrant scanners. */
2232: int cfg_yylex_destroy (void)
2233: {
2234:
2235: /* Pop the buffer stack, destroying each element. */
2236: while(YY_CURRENT_BUFFER){
2237: cfg_yy_delete_buffer(YY_CURRENT_BUFFER );
2238: YY_CURRENT_BUFFER_LVALUE = NULL;
2239: cfg_yypop_buffer_state();
2240: }
2241:
2242: /* Destroy the stack itself. */
2243: cfg_yyfree((yy_buffer_stack) );
2244: (yy_buffer_stack) = NULL;
2245:
2246: /* Reset the globals. This is important in a non-reentrant scanner so the next time
2247: * cfg_yylex() is called, initialization will occur. */
2248: yy_init_globals( );
2249:
2250: return 0;
2251: }
2252:
2253: /*
2254: * Internal utility routines.
2255: */
2256:
2257: #ifndef yytext_ptr
2258: static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2259: {
2260: register int i;
2261: for ( i = 0; i < n; ++i )
2262: s1[i] = s2[i];
2263: }
2264: #endif
2265:
2266: #ifdef YY_NEED_STRLEN
2267: static int yy_flex_strlen (yyconst char * s )
2268: {
2269: register int n;
2270: for ( n = 0; s[n]; ++n )
2271: ;
2272:
2273: return n;
2274: }
2275: #endif
2276:
2277: void *cfg_yyalloc (yy_size_t size )
2278: {
2279: return (void *) malloc( size );
2280: }
2281:
2282: void *cfg_yyrealloc (void * ptr, yy_size_t size )
2283: {
2284: /* The cast to (char *) in the following accommodates both
2285: * implementations that use char* generic pointers, and those
2286: * that use void* generic pointers. It works with the latter
2287: * because both ANSI C and C++ allow castless assignment from
2288: * any pointer type to void*, and deal with argument conversions
2289: * as though doing an assignment.
2290: */
2291: return (void *) realloc( (char *) ptr, size );
2292: }
2293:
2294: void cfg_yyfree (void * ptr )
2295: {
2296: free( (char *) ptr ); /* see cfg_yyrealloc() for (char *) cast */
2297: }
2298:
2299: #define YYTABLES_NAME "yytables"
2300:
2301: #line 277 "lexer.l"
2302:
2303:
2304:
2305: void cfg_dummy_function(void)
2306: {
2307: /* please compiler :-)
2308: * otherwise "defined but not used" warning
2309: */
2310: yyunput(0, 0);
2311: }
2312:
2313: int cfg_lexer_include(cfg_t *cfg, const char *filename)
2314: {
2315: char *xfilename;
2316:
2317: if(cfg_include_stack_ptr >= MAX_INCLUDE_DEPTH) {
2318: cfg_error(cfg, _("includes nested too deeply"));
2319: return 1;
2320: }
2321:
2322: cfg_include_stack[cfg_include_stack_ptr].state = YY_CURRENT_BUFFER;
2323: cfg_include_stack[cfg_include_stack_ptr].filename = cfg->filename;
2324: cfg_include_stack[cfg_include_stack_ptr].line = cfg->line;
2325: cfg_include_stack_ptr++;
2326:
2327: xfilename = cfg_tilde_expand(filename);
2328:
2329: cfg_yyin = fopen(xfilename, "r");
2330:
2331: if(!cfg_yyin) {
2332: cfg_error(cfg, "%s: %s", xfilename, strerror(errno));
2333: free(xfilename);
2334: return 1;
2335: }
2336:
2337: cfg->filename = xfilename;
2338: cfg->line = 1;
2339:
2340: cfg_yy_switch_to_buffer(cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE));
2341: return 0;
2342: }
2343:
2344: /* write a character to the quoted string buffer, and reallocate as
2345: * necessary
2346: */
2347: static void qputc(char ch)
2348: {
2349: if(qstring_index >= qstring_len) {
2350: qstring_len += CFG_QSTRING_BUFSIZ;
2351: cfg_qstring = (char *)realloc(cfg_qstring, qstring_len);
2352: assert(cfg_qstring);
2353: memset(cfg_qstring + qstring_index, 0, CFG_QSTRING_BUFSIZ);
2354: }
2355: cfg_qstring[qstring_index++] = ch;
2356: }
2357:
2358: void cfg_scan_string_begin(const char *buf)
2359: {
2360: pre_string_scan_state = YY_CURRENT_BUFFER;
2361:
2362: /* cfg_yy_scan_string does a cfg_yy_switch_to_buffer call for us
2363: */
2364: string_scan_state = cfg_yy_scan_string(buf);
2365: }
2366:
2367: void cfg_scan_string_end(void)
2368: {
2369: /* restore to previous state
2370: */
2371: cfg_yy_delete_buffer(string_scan_state);
2372: if (pre_string_scan_state)
2373: cfg_yy_switch_to_buffer(pre_string_scan_state);
2374: free(cfg_qstring);
2375: cfg_qstring = 0;
2376: qstring_index = qstring_len = 0;
2377: string_scan_state = 0;
2378: }
2379:
2380: static YY_BUFFER_STATE pre_fp_scan_state;
2381: static YY_BUFFER_STATE fp_scan_state;
2382:
2383: void cfg_scan_fp_begin(FILE *fp)
2384: {
2385: pre_fp_scan_state = YY_CURRENT_BUFFER;
2386: fp_scan_state = cfg_yy_create_buffer(fp,YY_BUF_SIZE);
2387: cfg_yy_switch_to_buffer(fp_scan_state);
2388: }
2389:
2390: void cfg_scan_fp_end(void)
2391: {
2392: /* restore to previous state
2393: */
2394: cfg_yy_delete_buffer(fp_scan_state);
2395: if(pre_fp_scan_state)
2396: cfg_yy_switch_to_buffer(pre_fp_scan_state);
2397: free(cfg_qstring);
2398: cfg_qstring = 0;
2399: qstring_index = qstring_len = 0;
2400: }
2401:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lexer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / confuse / src