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