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
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
205 {
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 */
215
216 /* Number of characters read into yy_ch_buf, not including EOB
217 * characters.
218 */
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 */
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 */
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 */
239
242
243 /* Whether to try to fill the input buffer when we reach the
244 * end of it.
245 */
247
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;
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 */
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 */
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 );
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
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
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. */
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;
614
616static char *yy_full_match;
617static int yy_lp;
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
643#line 1 "isdn_cdb.lex"
644
645#line 7 "isdn_cdb.lex"
646#include "isdn_cdb_def.h"
647#line 647 "lex.yy.c"
648#line 648 "lex.yy.c"
649
650#define INITIAL 0
651#define Main 1
652#define NextLine 2
653#define NewEntry 3
654#define Value 4
655
656#ifndef YY_NO_UNISTD_H
657/* Special case for "unistd.h", since it is non-ANSI. We include it way
658 * down here because we want the user's section 1 to have been scanned first.
659 * The user has a chance to override it with an option.
660 */
661#include <unistd.h>
662#endif
663
664#ifndef YY_EXTRA_TYPE
665#define YY_EXTRA_TYPE void *
666#endif
667
668static int yy_init_globals ( void );
669
670/* Accessor methods to globals.
671 These are made visible to non-reentrant scanners for convenience. */
672
673int yylex_destroy ( void );
674
675int yyget_debug ( void );
676
677void yyset_debug ( int debug_flag );
678
680
681void yyset_extra ( YY_EXTRA_TYPE user_defined );
682
683FILE *yyget_in ( void );
684
685void yyset_in ( FILE * _in_str );
686
687FILE *yyget_out ( void );
688
689void yyset_out ( FILE * _out_str );
690
691 int yyget_leng ( void );
692
693char *yyget_text ( void );
694
695int yyget_lineno ( void );
696
697void yyset_lineno ( int _line_number );
698
699/* Macros after this point can all be overridden by user definitions in
700 * section 1.
701 */
702
703#ifndef YY_SKIP_YYWRAP
704#ifdef __cplusplus
705extern "C" int yywrap ( void );
706#else
707extern int yywrap ( void );
708#endif
709#endif
710
711#ifndef YY_NO_UNPUT
712
713 static void yyunput ( int c, char *buf_ptr );
714
715#endif
716
717#ifndef yytext_ptr
718static void yy_flex_strncpy ( char *, const char *, int );
719#endif
720
721#ifdef YY_NEED_STRLEN
722static int yy_flex_strlen ( const char * );
723#endif
724
725#ifndef YY_NO_INPUT
726#ifdef __cplusplus
727static int yyinput ( void );
728#else
729static int input ( void );
730#endif
731
732#endif
733
734/* Amount of stuff to slurp up with each read. */
735#ifndef YY_READ_BUF_SIZE
736#ifdef __ia64__
737/* On IA-64, the buffer size is 16k, not 8k */
738#define YY_READ_BUF_SIZE 16384
739#else
740#define YY_READ_BUF_SIZE 8192
741#endif /* __ia64__ */
742#endif
743
744/* Copy whatever the last rule matched to the standard output. */
745#ifndef ECHO
746/* This used to be an fputs(), but since the string might contain NUL's,
747 * we now use fwrite().
748 */
749#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
750#endif
751
752/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
753 * is returned in "result".
754 */
755#ifndef YY_INPUT
756#define YY_INPUT(buf,result,max_size) \
757 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
758 { \
759 int c = '*'; \
760 int n; \
761 for ( n = 0; n < max_size && \
762 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
763 buf[n] = (char) c; \
764 if ( c == '\n' ) \
765 buf[n++] = (char) c; \
766 if ( c == EOF && ferror( yyin ) ) \
767 YY_FATAL_ERROR( "input in flex scanner failed" ); \
768 result = n; \
769 } \
770 else \
771 { \
772 errno=0; \
773 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
774 { \
775 if( errno != EINTR) \
776 { \
777 YY_FATAL_ERROR( "input in flex scanner failed" ); \
778 break; \
779 } \
780 errno=0; \
781 clearerr(yyin); \
782 } \
783 }\
784\
785
786#endif
787
788/* No semi-colon after return; correct usage is to write "yyterminate();" -
789 * we don't want an extra ';' after the "return" because that will cause
790 * some compilers to complain about unreachable statements.
791 */
792#ifndef yyterminate
793#define yyterminate() return YY_NULL
794#endif
795
796/* Number of entries by which start-condition stack grows. */
797#ifndef YY_START_STACK_INCR
798#define YY_START_STACK_INCR 25
799#endif
800
801/* Report a fatal error. */
802#ifndef YY_FATAL_ERROR
803#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
804#endif
805
806/* end tables serialization structures and prototypes */
807
808/* Default declaration of generated scanner - a define so the user can
809 * easily add parameters.
810 */
811#ifndef YY_DECL
812#define YY_DECL_IS_OURS 1
813
814extern int yylex (void);
815
816#define YY_DECL int yylex (void)
817#endif /* !YY_DECL */
818
819/* Code executed at the beginning of each rule, after yytext and yyleng
820 * have been set up.
821 */
822#ifndef YY_USER_ACTION
823#define YY_USER_ACTION
824#endif
825
826/* Code executed at the end of each rule. */
827#ifndef YY_BREAK
828#define YY_BREAK /*LINTED*/break;
829#endif
830
831#define YY_RULE_SETUP \
832 if ( yyleng > 0 ) \
833 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
834 (yytext[yyleng - 1] == '\n'); \
835 YY_USER_ACTION
836
840{
841 yy_state_type yy_current_state;
842 char *yy_cp, *yy_bp;
844
845 if ( !(yy_init) )
846 {
847 (yy_init) = 1;
848
849#ifdef YY_USER_INIT
850 YY_USER_INIT;
851#endif
852
853 /* Create the reject buffer large enough to save one state per allowed character. */
854 if ( ! (yy_state_buf) )
856 if ( ! (yy_state_buf) )
857 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
858
859 if ( ! (yy_start) )
860 (yy_start) = 1; /* first start state */
861
862 if ( ! yyin )
863 yyin = stdin;
864
865 if ( ! yyout )
866 yyout = stdout;
867
868 if ( ! YY_CURRENT_BUFFER ) {
872 }
873
875 }
876
877 {
878#line 9 "isdn_cdb.lex"
879
880#line 11 "isdn_cdb.lex"
881 int item = 0;
882
883#line 883 "lex.yy.c"
884
885 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
886 {
887 yy_cp = (yy_c_buf_p);
888
889 /* Support of yytext. */
890 *yy_cp = (yy_hold_char);
891
892 /* yy_bp points to the position in yy_ch_buf of the start of
893 * the current run.
894 */
895 yy_bp = yy_cp;
896
897 yy_current_state = (yy_start);
898 yy_current_state += YY_AT_BOL();
899
901 *(yy_state_ptr)++ = yy_current_state;
902
903yy_match:
904 do
905 {
906 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
907 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
908 {
909 yy_current_state = (int) yy_def[yy_current_state];
910 if ( yy_current_state >= 254 )
911 yy_c = yy_meta[yy_c];
912 }
913 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
914 *(yy_state_ptr)++ = yy_current_state;
915 ++yy_cp;
916 }
917 while ( yy_base[yy_current_state] != 262 );
918
919yy_find_action:
920 yy_current_state = *--(yy_state_ptr);
921 (yy_lp) = yy_accept[yy_current_state];
922find_rule: /* we branch to this label when backing up */
923 for ( ; ; ) /* until we find what rule we matched */
924 {
925 if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
926 {
930 {
932 {
935 break;
936 }
937 }
938 else if ( yy_act & YY_TRAILING_MASK )
939 {
942 }
943 else
944 {
947 (yy_full_lp) = (yy_lp);
948 break;
949 }
950 ++(yy_lp);
951 goto find_rule;
952 }
953 --yy_cp;
954 yy_current_state = *--(yy_state_ptr);
955 (yy_lp) = yy_accept[yy_current_state];
956 }
957
959
961 {
962 int yyl;
963 for ( yyl = 0; yyl < yyleng; ++yyl )
964 if ( yytext[yyl] == '\n' )
965
966 yylineno++;
967;
968 }
969
970do_action: /* This label is used only to access EOF actions. */
971
972 switch ( yy_act )
973 { /* beginning of action switch */
974
975case 1:
977#line 14 "isdn_cdb.lex"
980case 2:
982#line 15 "isdn_cdb.lex"
983{
984 if (new_entry())
985 exit(99);
987 }
989case 3:
991#line 20 "isdn_cdb.lex"
992;
994case 4:
995/* rule 4 can match eol */
997#line 21 "isdn_cdb.lex"
998;
1000
1001
1002case 5:
1004#line 25 "isdn_cdb.lex"
1005;
1006 YY_BREAK
1007case 6:
1008/* rule 6 can match eol */
1010#line 26 "isdn_cdb.lex"
1011BEGIN Main;
1012 YY_BREAK
1013
1014
1015case 7:
1017#line 30 "isdn_cdb.lex"
1018{item=vendor; BEGIN Value;}
1019 YY_BREAK
1020case 8:
1022#line 31 "isdn_cdb.lex"
1023{item=device; BEGIN Value;}
1024 YY_BREAK
1025case 9:
1027#line 32 "isdn_cdb.lex"
1028{item=vendor_id; BEGIN Value;}
1029 YY_BREAK
1030case 10:
1032#line 33 "isdn_cdb.lex"
1033{item=device_id; BEGIN Value;}
1034 YY_BREAK
1035case 11:
1037#line 34 "isdn_cdb.lex"
1038{item=subvendor_id; BEGIN Value;}
1039 YY_BREAK
1040case 12:
1042#line 35 "isdn_cdb.lex"
1043{item=subdevice_id; BEGIN Value;}
1044 YY_BREAK
1045case 13:
1047#line 36 "isdn_cdb.lex"
1048{item=device_class; BEGIN Value;}
1049 YY_BREAK
1050case 14:
1052#line 37 "isdn_cdb.lex"
1053{item=bus_type; BEGIN Value;}
1054 YY_BREAK
1055case 15:
1057#line 38 "isdn_cdb.lex"
1058{item=vario; BEGIN Value;}
1059 YY_BREAK
1060case 16:
1062#line 39 "isdn_cdb.lex"
1063{item=SMP; BEGIN Value;}
1064 YY_BREAK
1065case 17:
1067#line 40 "isdn_cdb.lex"
1068{item=drv_id; BEGIN Value;}
1069 YY_BREAK
1070case 18:
1072#line 41 "isdn_cdb.lex"
1073{item=drv_subtyp; BEGIN Value;}
1074 YY_BREAK
1075case 19:
1077#line 42 "isdn_cdb.lex"
1078{item=drv_typ; BEGIN Value;}
1079 YY_BREAK
1080case 20:
1082#line 43 "isdn_cdb.lex"
1083{item=interface; BEGIN Value;}
1084 YY_BREAK
1085case 21:
1087#line 44 "isdn_cdb.lex"
1088{item=line_cnt; BEGIN Value;}
1089 YY_BREAK
1090case 22:
1092#line 45 "isdn_cdb.lex"
1093{item=line_protocol; BEGIN Value;}
1094 YY_BREAK
1095case 23:
1097#line 46 "isdn_cdb.lex"
1098{item=module; BEGIN Value;}
1099 YY_BREAK
1100case 24:
1102#line 47 "isdn_cdb.lex"
1103{item=need_packages; BEGIN Value;}
1104 YY_BREAK
1105case 25:
1107#line 48 "isdn_cdb.lex"
1108{item=supported; BEGIN Value;}
1109 YY_BREAK
1110case 26:
1112#line 49 "isdn_cdb.lex"
1113{item=feature; BEGIN Value;}
1114 YY_BREAK
1115case 27:
1117#line 50 "isdn_cdb.lex"
1118{item=info; BEGIN Value;}
1119 YY_BREAK
1120case 28:
1122#line 51 "isdn_cdb.lex"
1123{item=special; BEGIN Value;}
1124 YY_BREAK
1125case 29:
1127#line 52 "isdn_cdb.lex"
1128{item=firmware; BEGIN Value;}
1129 YY_BREAK
1130case 30:
1132#line 53 "isdn_cdb.lex"
1134 YY_BREAK
1135case 31:
1137#line 54 "isdn_cdb.lex"
1138{item=IRQ; BEGIN Value;}
1139 YY_BREAK
1140case 32:
1142#line 55 "isdn_cdb.lex"
1143{item=IO; BEGIN Value;}
1144 YY_BREAK
1145case 33:
1147#line 56 "isdn_cdb.lex"
1148{item=MEMBASE; BEGIN Value;}
1149 YY_BREAK
1150case 34:
1152#line 57 "isdn_cdb.lex"
1154 YY_BREAK
1155case 35:
1157#line 58 "isdn_cdb.lex"
1158{item=revision; BEGIN Value;}
1159 YY_BREAK
1160case 36:
1161/* rule 36 can match eol */
1163#line 59 "isdn_cdb.lex"
1164BEGIN Main;
1165 YY_BREAK
1166
1167
1168case 37:
1170#line 63 "isdn_cdb.lex"
1172 YY_BREAK
1173case 38:
1174/* rule 38 can match eol */
1176#line 64 "isdn_cdb.lex"
1178 YY_BREAK
1179
1180case 39:
1182#line 66 "isdn_cdb.lex"
1183ECHO;
1184 YY_BREAK
1185#line 1185 "lex.yy.c"
1186 case YY_STATE_EOF(INITIAL):
1187 case YY_STATE_EOF(Main):
1188 case YY_STATE_EOF(NextLine):
1189 case YY_STATE_EOF(NewEntry):
1190 case YY_STATE_EOF(Value):
1191 yyterminate();
1192
1193 case YY_END_OF_BUFFER:
1194 {
1195 /* Amount of text matched not including the EOB char. */
1196 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1197
1198 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1199 *yy_cp = (yy_hold_char);
1201
1202 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1203 {
1204 /* We're scanning a new file or input source. It's
1205 * possible that this happened because the user
1206 * just pointed yyin at a new source and called
1207 * yylex(). If so, then we have to assure
1208 * consistency between YY_CURRENT_BUFFER and our
1209 * globals. Here is the right place to do so, because
1210 * this is the first action (other than possibly a
1211 * back-up) that will match for the new input source.
1212 */
1213 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1214 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1215 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1216 }
1217
1218 /* Note that here we test for yy_c_buf_p "<=" to the position
1219 * of the first EOB in the buffer, since yy_c_buf_p will
1220 * already have been incremented past the NUL character
1221 * (since all states make transitions on EOB to the
1222 * end-of-buffer state). Contrast this with the test
1223 * in input().
1224 */
1225 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1226 { /* This was really a NUL. */
1227 yy_state_type yy_next_state;
1228
1229 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1230
1231 yy_current_state = yy_get_previous_state( );
1232
1233 /* Okay, we're now positioned to make the NUL
1234 * transition. We couldn't have
1235 * yy_get_previous_state() go ahead and do it
1236 * for us because it doesn't know how to deal
1237 * with the possibility of jamming (and we don't
1238 * want to build jamming into it because then it
1239 * will run more slowly).
1240 */
1241
1242 yy_next_state = yy_try_NUL_trans( yy_current_state );
1243
1245
1246 if ( yy_next_state )
1247 {
1248 /* Consume the NUL. */
1249 yy_cp = ++(yy_c_buf_p);
1250 yy_current_state = yy_next_state;
1251 goto yy_match;
1252 }
1253
1254 else
1255 {
1256 yy_cp = (yy_c_buf_p);
1257 goto yy_find_action;
1258 }
1259 }
1260
1261 else switch ( yy_get_next_buffer( ) )
1262 {
1264 {
1266
1267 if ( yywrap( ) )
1268 {
1269 /* Note: because we've taken care in
1270 * yy_get_next_buffer() to have set up
1271 * yytext, we can now set up
1272 * yy_c_buf_p so that if some total
1273 * hoser (like flex itself) wants to
1274 * call the scanner after we return the
1275 * YY_NULL, it'll still work - another
1276 * YY_NULL will get returned.
1277 */
1279
1281 goto do_action;
1282 }
1283
1284 else
1285 {
1288 }
1289 break;
1290 }
1291
1293 (yy_c_buf_p) =
1294 (yytext_ptr) + yy_amount_of_matched_text;
1295
1296 yy_current_state = yy_get_previous_state( );
1297
1298 yy_cp = (yy_c_buf_p);
1300 goto yy_match;
1301
1302 case EOB_ACT_LAST_MATCH:
1303 (yy_c_buf_p) =
1304 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1305
1306 yy_current_state = yy_get_previous_state( );
1307
1308 yy_cp = (yy_c_buf_p);
1310 goto yy_find_action;
1311 }
1312 break;
1313 }
1314
1315 default:
1317 "fatal flex scanner internal error--no action found" );
1318 } /* end of action switch */
1319 } /* end of scanning one token */
1320 } /* end of user's declarations */
1321} /* end of yylex */
1322
1323/* yy_get_next_buffer - try to read in a new buffer
1324 *
1325 * Returns a code representing an action:
1326 * EOB_ACT_LAST_MATCH -
1327 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1328 * EOB_ACT_END_OF_FILE - end of file
1329 */
1330static int yy_get_next_buffer (void)
1331{
1332 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1333 char *source = (yytext_ptr);
1334 int number_to_move, i;
1335 int ret_val;
1336
1337 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1339 "fatal flex scanner internal error--end of buffer missed" );
1340
1341 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1342 { /* Don't try to fill the buffer, so this is an EOF. */
1343 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1344 {
1345 /* We matched a single character, the EOB, so
1346 * treat this as a final EOF.
1347 */
1348 return EOB_ACT_END_OF_FILE;
1349 }
1350
1351 else
1352 {
1353 /* We matched some text prior to the EOB, first
1354 * process it.
1355 */
1356 return EOB_ACT_LAST_MATCH;
1357 }
1358 }
1359
1360 /* Try to read more data. */
1361
1362 /* First move last chars to start of buffer. */
1363 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1364
1365 for ( i = 0; i < number_to_move; ++i )
1366 *(dest++) = *(source++);
1367
1368 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1369 /* don't do the read, it's not guaranteed to return an EOF,
1370 * just force an EOF
1371 */
1372 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1373
1374 else
1375 {
1376 int num_to_read =
1377 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1378
1379 while ( num_to_read <= 0 )
1380 { /* Not enough room in the buffer - grow it. */
1381
1383"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1384
1385 }
1386
1387 if ( num_to_read > YY_READ_BUF_SIZE )
1388 num_to_read = YY_READ_BUF_SIZE;
1389
1390 /* Read in more data. */
1391 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1392 (yy_n_chars), num_to_read );
1393
1394 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1395 }
1396
1397 if ( (yy_n_chars) == 0 )
1398 {
1399 if ( number_to_move == YY_MORE_ADJ )
1400 {
1401 ret_val = EOB_ACT_END_OF_FILE;
1402 yyrestart( yyin );
1403 }
1404
1405 else
1406 {
1407 ret_val = EOB_ACT_LAST_MATCH;
1408 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1410 }
1411 }
1412
1413 else
1414 ret_val = EOB_ACT_CONTINUE_SCAN;
1415
1416 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1417 /* Extend the array by 50%, plus the number we really need. */
1418 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1419 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1420 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1421 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1422 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1423 /* "- 2" to take care of EOB's */
1424 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1425 }
1426
1427 (yy_n_chars) += number_to_move;
1430
1431 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1432
1433 return ret_val;
1434}
1435
1436/* yy_get_previous_state - get the state just before the EOB char was reached */
1437
1439{
1440 yy_state_type yy_current_state;
1441 char *yy_cp;
1442
1443 yy_current_state = (yy_start);
1444 yy_current_state += YY_AT_BOL();
1445
1447 *(yy_state_ptr)++ = yy_current_state;
1448
1449 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1450 {
1451 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1452 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1453 {
1454 yy_current_state = (int) yy_def[yy_current_state];
1455 if ( yy_current_state >= 254 )
1456 yy_c = yy_meta[yy_c];
1457 }
1458 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1459 *(yy_state_ptr)++ = yy_current_state;
1460 }
1461
1462 return yy_current_state;
1463}
1464
1465/* yy_try_NUL_trans - try to make a transition on the NUL character
1466 *
1467 * synopsis
1468 * next_state = yy_try_NUL_trans( current_state );
1469 */
1471{
1472 int yy_is_jam;
1473
1474 YY_CHAR yy_c = 1;
1475 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1476 {
1477 yy_current_state = (int) yy_def[yy_current_state];
1478 if ( yy_current_state >= 254 )
1479 yy_c = yy_meta[yy_c];
1480 }
1481 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1482 yy_is_jam = (yy_current_state == 253);
1483 if ( ! yy_is_jam )
1484 *(yy_state_ptr)++ = yy_current_state;
1485
1486 return yy_is_jam ? 0 : yy_current_state;
1487}
1488
1489#ifndef YY_NO_UNPUT
1490
1491 static void yyunput (int c, char * yy_bp )
1492{
1493 char *yy_cp;
1494
1495 yy_cp = (yy_c_buf_p);
1496
1497 /* undo effects of setting up yytext */
1498 *yy_cp = (yy_hold_char);
1499
1500 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1501 { /* need to shift things up to make room */
1502 /* +2 for EOB chars. */
1503 int number_to_move = (yy_n_chars) + 2;
1504 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1505 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1506 char *source =
1507 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1508
1509 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1510 *--dest = *--source;
1511
1512 yy_cp += (int) (dest - source);
1513 yy_bp += (int) (dest - source);
1514 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1515 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1516
1517 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1518 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1519 }
1520
1521 *--yy_cp = (char) c;
1522
1523 if ( c == '\n' ){
1524 --yylineno;
1525 }
1526
1527 (yytext_ptr) = yy_bp;
1528 (yy_hold_char) = *yy_cp;
1529 (yy_c_buf_p) = yy_cp;
1530}
1531
1532#endif
1533
1534#ifndef YY_NO_INPUT
1535#ifdef __cplusplus
1536 static int yyinput (void)
1537#else
1538 static int input (void)
1539#endif
1540
1541{
1542 int c;
1543
1544 *(yy_c_buf_p) = (yy_hold_char);
1545
1547 {
1548 /* yy_c_buf_p now points to the character we want to return.
1549 * If this occurs *before* the EOB characters, then it's a
1550 * valid NUL; if not, then we've hit the end of the buffer.
1551 */
1552 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1553 /* This was really a NUL. */
1554 *(yy_c_buf_p) = '\0';
1555
1556 else
1557 { /* need more input */
1558 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1559 ++(yy_c_buf_p);
1560
1561 switch ( yy_get_next_buffer( ) )
1562 {
1563 case EOB_ACT_LAST_MATCH:
1564 /* This happens because yy_g_n_b()
1565 * sees that we've accumulated a
1566 * token and flags that we need to
1567 * try matching the token before
1568 * proceeding. But for input(),
1569 * there's no matching to consider.
1570 * So convert the EOB_ACT_LAST_MATCH
1571 * to EOB_ACT_END_OF_FILE.
1572 */
1573
1574 /* Reset buffer status. */
1575 yyrestart( yyin );
1576
1577 /*FALLTHROUGH*/
1578
1580 {
1581 if ( yywrap( ) )
1582 return 0;
1583
1586#ifdef __cplusplus
1587 return yyinput();
1588#else
1589 return input();
1590#endif
1591 }
1592
1594 (yy_c_buf_p) = (yytext_ptr) + offset;
1595 break;
1596 }
1597 }
1598 }
1599
1600 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1601 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1602 (yy_hold_char) = *++(yy_c_buf_p);
1603
1604 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1605 if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
1606
1607 yylineno++;
1608;
1609
1610 return c;
1611}
1612#endif /* ifndef YY_NO_INPUT */
1613
1619 void yyrestart (FILE * input_file )
1620{
1621
1622 if ( ! YY_CURRENT_BUFFER ){
1626 }
1627
1628 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1630}
1631
1637{
1638
1639 /* TODO. We should be able to replace this entire function body
1640 * with
1641 * yypop_buffer_state();
1642 * yypush_buffer_state(new_buffer);
1643 */
1645 if ( YY_CURRENT_BUFFER == new_buffer )
1646 return;
1647
1648 if ( YY_CURRENT_BUFFER )
1649 {
1650 /* Flush out information for old buffer. */
1651 *(yy_c_buf_p) = (yy_hold_char);
1652 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1653 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1654 }
1655
1656 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1658
1659 /* We don't actually know whether we did this switch during
1660 * EOF (yywrap()) processing, but the only time this flag
1661 * is looked at is after yywrap() is called, so it's safe
1662 * to go ahead and always set it.
1663 */
1665}
1666
1667static void yy_load_buffer_state (void)
1668{
1669 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1671 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1672 (yy_hold_char) = *(yy_c_buf_p);
1673}
1674
1681 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1682{
1684
1685 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1686 if ( ! b )
1687 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1688
1689 b->yy_buf_size = size;
1690
1691 /* yy_ch_buf has to be 2 characters longer than the size given because
1692 * we need to put in 2 end-of-buffer characters.
1693 */
1694 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1695 if ( ! b->yy_ch_buf )
1696 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1697
1698 b->yy_is_our_buffer = 1;
1699
1700 yy_init_buffer( b, file );
1701
1702 return b;
1703}
1704
1710{
1711
1712 if ( ! b )
1713 return;
1714
1715 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1717
1718 if ( b->yy_is_our_buffer )
1719 yyfree( (void *) b->yy_ch_buf );
1720
1721 yyfree( (void *) b );
1722}
1723
1724/* Initializes or reinitializes a buffer.
1725 * This function is sometimes called more than once on the same buffer,
1726 * such as during a yyrestart() or at EOF.
1727 */
1728 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1729
1730{
1731 int oerrno = errno;
1732
1733 yy_flush_buffer( b );
1734
1735 b->yy_input_file = file;
1736 b->yy_fill_buffer = 1;
1737
1738 /* If b is the current buffer, then yy_init_buffer was _probably_
1739 * called from yyrestart() or through yy_get_next_buffer.
1740 * In that case, we don't want to reset the lineno or column.
1741 */
1742 if (b != YY_CURRENT_BUFFER){
1743 b->yy_bs_lineno = 1;
1744 b->yy_bs_column = 0;
1745 }
1746
1747 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1748
1749 errno = oerrno;
1750}
1751
1757{
1758 if ( ! b )
1759 return;
1760
1761 b->yy_n_chars = 0;
1762
1763 /* We always need two end-of-buffer characters. The first causes
1764 * a transition to the end-of-buffer state. The second causes
1765 * a jam in that state.
1766 */
1769
1770 b->yy_buf_pos = &b->yy_ch_buf[0];
1771
1772 b->yy_at_bol = 1;
1774
1775 if ( b == YY_CURRENT_BUFFER )
1777}
1778
1786{
1787 if (new_buffer == NULL)
1788 return;
1789
1791
1792 /* This block is copied from yy_switch_to_buffer. */
1793 if ( YY_CURRENT_BUFFER )
1794 {
1795 /* Flush out information for old buffer. */
1796 *(yy_c_buf_p) = (yy_hold_char);
1797 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1798 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1799 }
1800
1801 /* Only push if top exists. Otherwise, replace top. */
1804 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1805
1806 /* copied from yy_switch_to_buffer. */
1809}
1810
1816{
1817 if (!YY_CURRENT_BUFFER)
1818 return;
1819
1822 if ((yy_buffer_stack_top) > 0)
1824
1825 if (YY_CURRENT_BUFFER) {
1828 }
1829}
1830
1831/* Allocates the stack if it does not exist.
1832 * Guarantees space for at least one push.
1833 */
1834static void yyensure_buffer_stack (void)
1835{
1836 yy_size_t num_to_alloc;
1837
1838 if (!(yy_buffer_stack)) {
1839
1840 /* First allocation is just for 2 elements, since we don't know if this
1841 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1842 * immediate realloc on the next call.
1843 */
1844 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1846 (num_to_alloc * sizeof(struct yy_buffer_state*)
1847 );
1848 if ( ! (yy_buffer_stack) )
1849 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1850
1851 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1852
1853 (yy_buffer_stack_max) = num_to_alloc;
1854 (yy_buffer_stack_top) = 0;
1855 return;
1856 }
1857
1858 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1859
1860 /* Increase the buffer to prepare for a possible push. */
1861 yy_size_t grow_size = 8 /* arbitrary grow size */;
1862
1863 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1865 ((yy_buffer_stack),
1866 num_to_alloc * sizeof(struct yy_buffer_state*)
1867 );
1868 if ( ! (yy_buffer_stack) )
1869 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1870
1871 /* zero only the new slots.*/
1872 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1873 (yy_buffer_stack_max) = num_to_alloc;
1874 }
1875}
1876
1884{
1886
1887 if ( size < 2 ||
1888 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1889 base[size-1] != YY_END_OF_BUFFER_CHAR )
1890 /* They forgot to leave room for the EOB's. */
1891 return NULL;
1892
1893 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1894 if ( ! b )
1895 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1896
1897 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1898 b->yy_buf_pos = b->yy_ch_buf = base;
1899 b->yy_is_our_buffer = 0;
1900 b->yy_input_file = NULL;
1901 b->yy_n_chars = b->yy_buf_size;
1902 b->yy_is_interactive = 0;
1903 b->yy_at_bol = 1;
1904 b->yy_fill_buffer = 0;
1906
1908
1909 return b;
1910}
1911
1920YY_BUFFER_STATE yy_scan_string (const char * yystr )
1921{
1922
1923 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1924}
1925
1933YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1934{
1936 char *buf;
1937 yy_size_t n;
1938 int i;
1939
1940 /* Get memory for full buffer, including space for trailing EOB's. */
1941 n = (yy_size_t) (_yybytes_len + 2);
1942 buf = (char *) yyalloc( n );
1943 if ( ! buf )
1944 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1945
1946 for ( i = 0; i < _yybytes_len; ++i )
1947 buf[i] = yybytes[i];
1948
1949 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1950
1951 b = yy_scan_buffer( buf, n );
1952 if ( ! b )
1953 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1954
1955 /* It's okay to grow etc. this buffer, and we should throw it
1956 * away when we're done.
1957 */
1958 b->yy_is_our_buffer = 1;
1959
1960 return b;
1961}
1962
1963#ifndef YY_EXIT_FAILURE
1964#define YY_EXIT_FAILURE 2
1965#endif
1966
1967static void yynoreturn yy_fatal_error (const char* msg )
1968{
1969 fprintf( stderr, "%s\n", msg );
1970 exit( YY_EXIT_FAILURE );
1971}
1972
1973/* Redefine yyless() so it works in section 3 code. */
1974
1975#undef yyless
1976#define yyless(n) \
1977 do \
1978 { \
1979 /* Undo effects of setting up yytext. */ \
1980 int yyless_macro_arg = (n); \
1981 YY_LESS_LINENO(yyless_macro_arg);\
1982 yytext[yyleng] = (yy_hold_char); \
1983 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1984 (yy_hold_char) = *(yy_c_buf_p); \
1985 *(yy_c_buf_p) = '\0'; \
1986 yyleng = yyless_macro_arg; \
1987 } \
1988 while ( 0 )
1989
1990/* Accessor methods (get/set functions) to struct members. */
1991
1996{
1997
1998 return yylineno;
1999}
2000
2004FILE *yyget_in (void)
2005{
2006 return yyin;
2007}
2008
2012FILE *yyget_out (void)
2013{
2014 return yyout;
2015}
2016
2020int yyget_leng (void)
2021{
2022 return yyleng;
2023}
2024
2028
2029char *yyget_text (void)
2030{
2031 return yytext;
2032}
2033
2038void yyset_lineno (int _line_number )
2039{
2040
2041 yylineno = _line_number;
2042}
2043
2050void yyset_in (FILE * _in_str )
2051{
2052 yyin = _in_str ;
2053}
2054
2055void yyset_out (FILE * _out_str )
2056{
2057 yyout = _out_str ;
2058}
2059
2060int yyget_debug (void)
2061{
2062 return yy_flex_debug;
2063}
2064
2065void yyset_debug (int _bdebug )
2066{
2067 yy_flex_debug = _bdebug ;
2068}
2069
2070static int yy_init_globals (void)
2071{
2072 /* Initialization is the same as for the non-reentrant scanner.
2073 * This function is called from yylex_destroy(), so don't allocate here.
2074 */
2075
2076 /* We do not touch yylineno unless the option is enabled. */
2077 yylineno = 1;
2078
2079 (yy_buffer_stack) = NULL;
2080 (yy_buffer_stack_top) = 0;
2081 (yy_buffer_stack_max) = 0;
2082 (yy_c_buf_p) = NULL;
2083 (yy_init) = 0;
2084 (yy_start) = 0;
2085
2086 (yy_state_buf) = 0;
2087 (yy_state_ptr) = 0;
2088 (yy_full_match) = 0;
2089 (yy_lp) = 0;
2090
2091/* Defined in main.c */
2092#ifdef YY_STDINIT
2093 yyin = stdin;
2094 yyout = stdout;
2095#else
2096 yyin = NULL;
2097 yyout = NULL;
2098#endif
2099
2100 /* For future reference: Set errno on error, since we are called by
2101 * yylex_init()
2102 */
2103 return 0;
2104}
2105
2106/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2108{
2109
2110 /* Pop the buffer stack, destroying each element. */
2111 while(YY_CURRENT_BUFFER){
2115 }
2116
2117 /* Destroy the stack itself. */
2119 (yy_buffer_stack) = NULL;
2120
2121 yyfree ( (yy_state_buf) );
2122 (yy_state_buf) = NULL;
2123
2124 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2125 * yylex() is called, initialization will occur. */
2126 yy_init_globals( );
2127
2128 return 0;
2129}
2130
2131/*
2132 * Internal utility routines.
2133 */
2134
2135#ifndef yytext_ptr
2136static void yy_flex_strncpy (char* s1, const char * s2, int n )
2137{
2138
2139 int i;
2140 for ( i = 0; i < n; ++i )
2141 s1[i] = s2[i];
2142}
2143#endif
2144
2145#ifdef YY_NEED_STRLEN
2146static int yy_flex_strlen (const char * s )
2147{
2148 int n;
2149 for ( n = 0; s[n]; ++n )
2150 ;
2151
2152 return n;
2153}
2154#endif
2155
2156void *yyalloc (yy_size_t size )
2157{
2158 return malloc(size);
2159}
2160
2161void *yyrealloc (void * ptr, yy_size_t size )
2162{
2163
2164 /* The cast to (char *) in the following accommodates both
2165 * implementations that use char* generic pointers, and those
2166 * that use void* generic pointers. It works with the latter
2167 * because both ANSI C and C++ allow castless assignment from
2168 * any pointer type to void*, and deal with argument conversions
2169 * as though doing an assignment.
2170 */
2171 return realloc(ptr, size);
2172}
2173
2174void yyfree (void * ptr )
2175{
2176 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2177}
2178
2179#define YYTABLES_NAME "yytables"
2180
2181#line 66 "isdn_cdb.lex"
void add_current_item(int item, char *val)
Definition cdb_read.c:252
int new_entry(void)
Definition cdb_read.c:231
@ SMP
Definition isdn_cdb_def.h:15
@ IRQ
Definition isdn_cdb_def.h:30
@ line_cnt
Definition isdn_cdb_def.h:20
@ vendor_id
Definition isdn_cdb_def.h:7
@ MEMBASE
Definition isdn_cdb_def.h:32
@ device_id
Definition isdn_cdb_def.h:8
@ line_protocol
Definition isdn_cdb_def.h:21
@ feature
Definition isdn_cdb_def.h:25
@ interface
Definition isdn_cdb_def.h:19
@ bus_type
Definition isdn_cdb_def.h:13
@ need_packages
Definition isdn_cdb_def.h:23
@ subdevice_id
Definition isdn_cdb_def.h:10
@ short_description
Definition isdn_cdb_def.h:29
@ firmware
Definition isdn_cdb_def.h:28
@ subvendor_id
Definition isdn_cdb_def.h:9
@ info
Definition isdn_cdb_def.h:26
@ device
Definition isdn_cdb_def.h:6
@ supported
Definition isdn_cdb_def.h:24
@ device_class
Definition isdn_cdb_def.h:12
@ vario
Definition isdn_cdb_def.h:14
@ drv_typ
Definition isdn_cdb_def.h:18
@ drv_id
Definition isdn_cdb_def.h:16
@ special
Definition isdn_cdb_def.h:27
@ drv_subtyp
Definition isdn_cdb_def.h:17
@ alternative_name
Definition isdn_cdb_def.h:33
@ vendor
Definition isdn_cdb_def.h:5
@ IO
Definition isdn_cdb_def.h:31
@ revision
Definition isdn_cdb_def.h:11
#define YY_NEW_FILE
Definition lex.yy.c:127
FILE * yyget_in(void)
Get the input stream.
Definition lex.yy.c:2004
unsigned char flex_uint8_t
Definition lex.yy.c:53
static char yy_hold_char
Definition lex.yy.c:287
void yyset_in(FILE *_in_str)
Set the input stream.
Definition lex.yy.c:2050
static int input(void)
Definition lex.yy.c:1538
int yyleng
Definition lex.yy.c:289
static void yyunput(int c, char *buf_ptr)
Definition lex.yy.c:1491
static void yynoreturn yy_fatal_error(const char *msg)
Definition lex.yy.c:1967
#define YY_EXTRA_TYPE
Definition lex.yy.c:665
#define NewEntry
Definition lex.yy.c:653
static const flex_int16_t yy_base[259]
Definition lex.yy.c:465
FILE * yyout
Definition lex.yy.c:159
void yyset_extra(YY_EXTRA_TYPE user_defined)
static int yy_start
Definition lex.yy.c:294
short int flex_int16_t
Definition lex.yy.c:51
static void yyensure_buffer_stack(void)
Definition lex.yy.c:1834
void yy_flush_buffer(YY_BUFFER_STATE b)
Discard all buffered characters.
Definition lex.yy.c:1756
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Switch to a different input buffer.
Definition lex.yy.c:1636
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition lex.yy.c:270
unsigned int flex_uint32_t
Definition lex.yy.c:55
int yyget_lineno(void)
Get the current line number.
Definition lex.yy.c:1995
static int yy_get_next_buffer(void)
Definition lex.yy.c:1330
#define YY_BREAK
Definition lex.yy.c:828
static size_t yy_buffer_stack_max
capacity of stack.
Definition lex.yy.c:269
#define yynoreturn
Definition lex.yy.c:102
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition lex.yy.c:1470
int yy_act
Definition lex.yy.c:843
#define Value
Definition lex.yy.c:654
void yypush_buffer_state(YY_BUFFER_STATE new_buffer)
Pushes the new state onto the stack.
Definition lex.yy.c:1785
static yy_state_type * yy_state_ptr
Definition lex.yy.c:615
int yyget_debug(void)
Definition lex.yy.c:2060
struct yy_buffer_state * YY_BUFFER_STATE
Definition lex.yy.c:149
#define YYLMAX
Definition lex.yy.c:638
#define YY_BUFFER_NEW
Definition lex.yy.c:250
FILE * yyget_out(void)
Get the output stream.
Definition lex.yy.c:2012
#define YY_RESTORE_YY_MORE_OFFSET
Definition lex.yy.c:636
static int yy_did_buffer_switch_on_eof
Definition lex.yy.c:299
static int yy_init_globals(void)
Definition lex.yy.c:2070
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Allocate and initialize an input buffer state.
Definition lex.yy.c:1681
static const flex_int32_t yy_rule_can_match_eol[40]
Definition lex.yy.c:606
#define Main
Definition lex.yy.c:651
int yylineno
Definition lex.yy.c:351
static char * yy_full_match
Definition lex.yy.c:616
#define YY_BUFFER_NORMAL
Definition lex.yy.c:251
char * yy_cp
Definition lex.yy.c:842
void yypop_buffer_state(void)
Removes and deletes the top of the stack, if present.
Definition lex.yy.c:1815
#define YY_MORE_ADJ
Definition lex.yy.c:635
#define YY_RULE_SETUP
Definition lex.yy.c:831
static const flex_int16_t yy_accept[255]
Definition lex.yy.c:393
static const YY_CHAR yy_meta[40]
Definition lex.yy.c:457
void yyfree(void *)
Definition lex.yy.c:2174
#define YY_AT_BOL()
Definition lex.yy.c:341
int yy_flex_debug
Definition lex.yy.c:613
static const flex_int16_t yy_acclist[73]
Definition lex.yy.c:381
#define YY_TRAILING_MASK
Definition lex.yy.c:621
signed char flex_int8_t
Definition lex.yy.c:50
void * yyalloc(yy_size_t)
Definition lex.yy.c:2156
#define EOB_ACT_END_OF_FILE
Definition lex.yy.c:162
#define YY_TRAILING_HEAD_MASK
Definition lex.yy.c:622
YY_BUFFER_STATE yy_scan_string(const char *yy_str)
Setup the input buffer state to scan a string.
Definition lex.yy.c:1920
#define YY_CURRENT_BUFFER_LVALUE
Definition lex.yy.c:284
int yyget_leng(void)
Get the length of the current token.
Definition lex.yy.c:2020
int flex_int32_t
Definition lex.yy.c:52
static const flex_int16_t yy_chk[302]
Definition lex.yy.c:567
FILE * yyin
Definition lex.yy.c:345
static const flex_int16_t yy_def[259]
Definition lex.yy.c:497
#define YY_START
Definition lex.yy.c:122
#define NextLine
Definition lex.yy.c:652
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:1933
static const flex_int16_t yy_nxt[302]
Definition lex.yy.c:529
int yylex(void)
int yywrap(void)
Definition isdn_cdb.c:10
int yy_state_type
Definition lex.yy.c:347
static int yy_full_lp
Definition lex.yy.c:619
static yy_state_type * yy_state_buf
Definition lex.yy.c:615
static int yy_looking_for_trail_begin
Definition lex.yy.c:618
#define YY_CURRENT_BUFFER
Definition lex.yy.c:278
#define INITIAL
Definition lex.yy.c:650
char * yy_bp
Definition lex.yy.c:842
static int yy_n_chars
Definition lex.yy.c:288
#define YY_READ_BUF_SIZE
Definition lex.yy.c:740
static int yy_lp
Definition lex.yy.c:617
#define YY_INPUT(buf, result, max_size)
Definition lex.yy.c:756
#define ECHO
Definition lex.yy.c:749
#define YY_END_OF_BUFFER
Definition lex.yy.c:373
#define YY_STATE_EOF(state)
Definition lex.yy.c:125
int yylex_destroy(void)
Definition lex.yy.c:2107
void yyrestart(FILE *input_file)
Immediately switch to a different input stream.
Definition lex.yy.c:1619
#define BEGIN
Definition lex.yy.c:117
#define YY_END_OF_BUFFER_CHAR
Definition lex.yy.c:128
void * yyrealloc(void *, yy_size_t)
Definition lex.yy.c:2161
#define YY_FATAL_ERROR(msg)
Definition lex.yy.c:803
static int * yy_full_state
Definition lex.yy.c:620
#define YY_STATE_BUF_SIZE
Definition lex.yy.c:145
#define yyterminate()
Definition lex.yy.c:793
unsigned short int flex_uint16_t
Definition lex.yy.c:54
void yyset_debug(int debug_flag)
Definition lex.yy.c:2065
static void yy_load_buffer_state(void)
Definition lex.yy.c:1667
static void yy_flex_strncpy(char *, const char *, int)
Definition lex.yy.c:2136
void yyset_lineno(int _line_number)
Set the current line number.
Definition lex.yy.c:2038
flex_uint8_t YY_CHAR
Definition lex.yy.c:343
#define YY_DO_BEFORE_ACTION
Definition lex.yy.c:363
char * yyget_text(void)
Get the current token.
Definition lex.yy.c:2029
#define EOB_ACT_LAST_MATCH
Definition lex.yy.c:163
size_t yy_size_t
Definition lex.yy.c:154
#define YY_BUFFER_EOF_PENDING
Definition lex.yy.c:262
static yy_state_type yy_get_previous_state(void)
Definition lex.yy.c:1438
void yyset_out(FILE *_out_str)
Definition lex.yy.c:2055
YY_EXTRA_TYPE yyget_extra(void)
static const YY_CHAR yy_ec[256]
Definition lex.yy.c:425
static char * yy_c_buf_p
Definition lex.yy.c:292
#define EOB_ACT_CONTINUE_SCAN
Definition lex.yy.c:161
static size_t yy_buffer_stack_top
index of top of stack.
Definition lex.yy.c:268
#define YY_DECL
Definition lex.yy.c:816
void yy_delete_buffer(YY_BUFFER_STATE b)
Destroy the buffer.
Definition lex.yy.c:1709
#define YY_BUF_SIZE
Definition lex.yy.c:139
char * yytext_ptr
Definition lex.yy.c:642
#define YY_EXIT_FAILURE
Definition lex.yy.c:1964
static int yy_init
Definition lex.yy.c:293
#define YY_SC_TO_UI(c)
Definition lex.yy.c:111
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition lex.yy.c:1728
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:1883
char yytext[]
Definition lex.yy.c:641
Definition lex.yy.c:205
int yy_n_chars
Definition lex.yy.c:219
int yy_bs_column
The column count.
Definition lex.yy.c:241
int yy_buf_size
Definition lex.yy.c:214
FILE * yy_input_file
Definition lex.yy.c:206
char * yy_buf_pos
Definition lex.yy.c:209
int yy_fill_buffer
Definition lex.yy.c:246
int yy_buffer_status
Definition lex.yy.c:248
int yy_is_our_buffer
Definition lex.yy.c:225
int yy_bs_lineno
The line count.
Definition lex.yy.c:240
int yy_at_bol
Definition lex.yy.c:238
int yy_is_interactive
Definition lex.yy.c:232
char * yy_ch_buf
Definition lex.yy.c:208
Definition lex.yy.c:377
flex_int32_t yy_verify
Definition lex.yy.c:378
flex_int32_t yy_nxt
Definition lex.yy.c:379