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