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