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