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