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