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;
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;
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#include "isdn_cdb_def.h"
587#line 588 "lex.yy.c"
588#line 589 "lex.yy.c"
589
590#define INITIAL 0
591#define Main 1
592#define NextLine 2
593#define NewEntry 3
594#define Value 4
595
596#ifndef YY_NO_UNISTD_H
597/* Special case for "unistd.h", since it is non-ANSI. We include it way
598 * down here because we want the user's section 1 to have been scanned first.
599 * The user has a chance to override it with an option.
600 */
601#include <unistd.h>
602#endif
603
604#ifndef YY_EXTRA_TYPE
605#define YY_EXTRA_TYPE void *
606#endif
607
608static int yy_init_globals ( void );
609
610/* Accessor methods to globals.
611 These are made visible to non-reentrant scanners for convenience. */
612
613int yylex_destroy ( void );
614
615int yyget_debug ( void );
616
617void yyset_debug ( int debug_flag );
618
619YY_EXTRA_TYPE yyget_extra ( void );
620
621void yyset_extra ( YY_EXTRA_TYPE user_defined );
622
623FILE *yyget_in ( void );
624
625void yyset_in ( FILE * _in_str );
626
627FILE *yyget_out ( void );
628
629void yyset_out ( FILE * _out_str );
630
631 int yyget_leng ( void );
632
633char *yyget_text ( void );
634
635int yyget_lineno ( void );
636
637void yyset_lineno ( int _line_number );
638
639/* Macros after this point can all be overridden by user definitions in
640 * section 1.
641 */
642
643#ifndef YY_SKIP_YYWRAP
644#ifdef __cplusplus
645extern "C" int yywrap ( void );
646#else
647extern int yywrap ( void );
648#endif
649#endif
650
651#ifndef YY_NO_UNPUT
652
653 static void yyunput ( int c, char *buf_ptr );
654
655#endif
656
657#ifndef yytext_ptr
658static void yy_flex_strncpy ( char *, const char *, int );
659#endif
660
661#ifdef YY_NEED_STRLEN
662static int yy_flex_strlen ( const char * );
663#endif
664
665#ifndef YY_NO_INPUT
666#ifdef __cplusplus
667static int yyinput ( void );
668#else
669static int input ( void );
670#endif
671
672#endif
673
674/* Amount of stuff to slurp up with each read. */
675#ifndef YY_READ_BUF_SIZE
676#ifdef __ia64__
677/* On IA-64, the buffer size is 16k, not 8k */
678#define YY_READ_BUF_SIZE 16384
679#else
680#define YY_READ_BUF_SIZE 8192
681#endif /* __ia64__ */
682#endif
683
684/* Copy whatever the last rule matched to the standard output. */
685#ifndef ECHO
686/* This used to be an fputs(), but since the string might contain NUL's,
687 * we now use fwrite().
688 */
689#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
690#endif
691
692/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
693 * is returned in "result".
694 */
695#ifndef YY_INPUT
696#define YY_INPUT(buf,result,max_size) \
697 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
698 { \
699 int c = '*'; \
700 int n; \
701 for ( n = 0; n < max_size && \
702 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
703 buf[n] = (char) c; \
704 if ( c == '\n' ) \
705 buf[n++] = (char) c; \
706 if ( c == EOF && ferror( yyin ) ) \
707 YY_FATAL_ERROR( "input in flex scanner failed" ); \
708 result = n; \
709 } \
710 else \
711 { \
712 errno=0; \
713 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
714 { \
715 if( errno != EINTR) \
716 { \
717 YY_FATAL_ERROR( "input in flex scanner failed" ); \
718 break; \
719 } \
720 errno=0; \
721 clearerr(yyin); \
722 } \
723 }\
724\
725
726#endif
727
728/* No semi-colon after return; correct usage is to write "yyterminate();" -
729 * we don't want an extra ';' after the "return" because that will cause
730 * some compilers to complain about unreachable statements.
731 */
732#ifndef yyterminate
733#define yyterminate() return YY_NULL
734#endif
735
736/* Number of entries by which start-condition stack grows. */
737#ifndef YY_START_STACK_INCR
738#define YY_START_STACK_INCR 25
739#endif
740
741/* Report a fatal error. */
742#ifndef YY_FATAL_ERROR
743#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
744#endif
745
746/* end tables serialization structures and prototypes */
747
748/* Default declaration of generated scanner - a define so the user can
749 * easily add parameters.
750 */
751#ifndef YY_DECL
752#define YY_DECL_IS_OURS 1
753
754extern int yylex (void);
755
756#define YY_DECL int yylex (void)
757#endif /* !YY_DECL */
758
759/* Code executed at the beginning of each rule, after yytext and yyleng
760 * have been set up.
761 */
762#ifndef YY_USER_ACTION
763#define YY_USER_ACTION
764#endif
765
766/* Code executed at the end of each rule. */
767#ifndef YY_BREAK
768#define YY_BREAK /*LINTED*/break;
769#endif
770
771#define YY_RULE_SETUP \
772 if ( yyleng > 0 ) \
773 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
774 (yytext[yyleng - 1] == '\n'); \
775 YY_USER_ACTION
776
779YY_DECL
780{
781 yy_state_type yy_current_state;
782 char *yy_cp, *yy_bp;
783 int yy_act;
784
785 if ( !(yy_init) )
786 {
787 (yy_init) = 1;
788
789#ifdef YY_USER_INIT
790 YY_USER_INIT;
791#endif
792
793 if ( ! (yy_start) )
794 (yy_start) = 1; /* first start state */
795
796 if ( ! yyin )
797 yyin = stdin;
798
799 if ( ! yyout )
800 yyout = stdout;
801
802 if ( ! YY_CURRENT_BUFFER ) {
803 yyensure_buffer_stack ();
804 YY_CURRENT_BUFFER_LVALUE =
805 yy_create_buffer( yyin, YY_BUF_SIZE );
806 }
807
808 yy_load_buffer_state( );
809 }
810
811 {
812#line 9 "isdn_cdb.lex"
813
814#line 11 "isdn_cdb.lex"
815 int item = 0;
816
817#line 818 "lex.yy.c"
818
819 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
820 {
821 yy_cp = (yy_c_buf_p);
822
823 /* Support of yytext. */
824 *yy_cp = (yy_hold_char);
825
826 /* yy_bp points to the position in yy_ch_buf of the start of
827 * the current run.
828 */
829 yy_bp = yy_cp;
830
831 yy_current_state = (yy_start);
832 yy_current_state += YY_AT_BOL();
833yy_match:
834 do
835 {
836 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
837 if ( yy_accept[yy_current_state] )
838 {
839 (yy_last_accepting_state) = yy_current_state;
840 (yy_last_accepting_cpos) = yy_cp;
841 }
842 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
843 {
844 yy_current_state = (int) yy_def[yy_current_state];
845 if ( yy_current_state >= 254 )
846 yy_c = yy_meta[yy_c];
847 }
848 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
849 ++yy_cp;
850 }
851 while ( yy_base[yy_current_state] != 262 );
852
853yy_find_action:
854 yy_act = yy_accept[yy_current_state];
855 if ( yy_act == 0 )
856 { /* have to back up */
857 yy_cp = (yy_last_accepting_cpos);
858 yy_current_state = (yy_last_accepting_state);
859 yy_act = yy_accept[yy_current_state];
860 }
861
862 YY_DO_BEFORE_ACTION;
863
864do_action: /* This label is used only to access EOF actions. */
865
866 switch ( yy_act )
867 { /* beginning of action switch */
868 case 0: /* must back up */
869 /* undo the effects of YY_DO_BEFORE_ACTION */
870 *yy_cp = (yy_hold_char);
871 yy_cp = (yy_last_accepting_cpos);
872 yy_current_state = (yy_last_accepting_state);
873 goto yy_find_action;
874
875case 1:
876YY_RULE_SETUP
877#line 14 "isdn_cdb.lex"
878BEGIN NextLine;
879 YY_BREAK
880case 2:
881YY_RULE_SETUP
882#line 15 "isdn_cdb.lex"
883{
884 if (new_entry())
885 exit(99);
886 BEGIN NewEntry;
887 }
888 YY_BREAK
889case 3:
890YY_RULE_SETUP
891#line 20 "isdn_cdb.lex"
892;
893 YY_BREAK
894case 4:
895/* rule 4 can match eol */
896YY_RULE_SETUP
897#line 21 "isdn_cdb.lex"
898;
899 YY_BREAK
900
901
902case 5:
903YY_RULE_SETUP
904#line 25 "isdn_cdb.lex"
905;
906 YY_BREAK
907case 6:
908/* rule 6 can match eol */
909YY_RULE_SETUP
910#line 26 "isdn_cdb.lex"
911BEGIN Main;
912 YY_BREAK
913
914
915case 7:
916YY_RULE_SETUP
917#line 30 "isdn_cdb.lex"
918{item=vendor; BEGIN Value;}
919 YY_BREAK
920case 8:
921YY_RULE_SETUP
922#line 31 "isdn_cdb.lex"
923{item=device; BEGIN Value;}
924 YY_BREAK
925case 9:
926YY_RULE_SETUP
927#line 32 "isdn_cdb.lex"
928{item=vendor_id; BEGIN Value;}
929 YY_BREAK
930case 10:
931YY_RULE_SETUP
932#line 33 "isdn_cdb.lex"
933{item=device_id; BEGIN Value;}
934 YY_BREAK
935case 11:
936YY_RULE_SETUP
937#line 34 "isdn_cdb.lex"
938{item=subvendor_id; BEGIN Value;}
939 YY_BREAK
940case 12:
941YY_RULE_SETUP
942#line 35 "isdn_cdb.lex"
943{item=subdevice_id; BEGIN Value;}
944 YY_BREAK
945case 13:
946YY_RULE_SETUP
947#line 36 "isdn_cdb.lex"
948{item=device_class; BEGIN Value;}
949 YY_BREAK
950case 14:
951YY_RULE_SETUP
952#line 37 "isdn_cdb.lex"
953{item=bus_type; BEGIN Value;}
954 YY_BREAK
955case 15:
956YY_RULE_SETUP
957#line 38 "isdn_cdb.lex"
958{item=vario; BEGIN Value;}
959 YY_BREAK
960case 16:
961YY_RULE_SETUP
962#line 39 "isdn_cdb.lex"
963{item=SMP; BEGIN Value;}
964 YY_BREAK
965case 17:
966YY_RULE_SETUP
967#line 40 "isdn_cdb.lex"
968{item=drv_id; BEGIN Value;}
969 YY_BREAK
970case 18:
971YY_RULE_SETUP
972#line 41 "isdn_cdb.lex"
973{item=drv_subtyp; BEGIN Value;}
974 YY_BREAK
975case 19:
976YY_RULE_SETUP
977#line 42 "isdn_cdb.lex"
978{item=drv_typ; BEGIN Value;}
979 YY_BREAK
980case 20:
981YY_RULE_SETUP
982#line 43 "isdn_cdb.lex"
983{item=interface; BEGIN Value;}
984 YY_BREAK
985case 21:
986YY_RULE_SETUP
987#line 44 "isdn_cdb.lex"
988{item=line_cnt; BEGIN Value;}
989 YY_BREAK
990case 22:
991YY_RULE_SETUP
992#line 45 "isdn_cdb.lex"
993{item=line_protocol; BEGIN Value;}
994 YY_BREAK
995case 23:
996YY_RULE_SETUP
997#line 46 "isdn_cdb.lex"
998{item=module; BEGIN Value;}
999 YY_BREAK
1000case 24:
1001YY_RULE_SETUP
1002#line 47 "isdn_cdb.lex"
1003{item=need_packages; BEGIN Value;}
1004 YY_BREAK
1005case 25:
1006YY_RULE_SETUP
1007#line 48 "isdn_cdb.lex"
1008{item=supported; BEGIN Value;}
1009 YY_BREAK
1010case 26:
1011YY_RULE_SETUP
1012#line 49 "isdn_cdb.lex"
1013{item=feature; BEGIN Value;}
1014 YY_BREAK
1015case 27:
1016YY_RULE_SETUP
1017#line 50 "isdn_cdb.lex"
1018{item=info; BEGIN Value;}
1019 YY_BREAK
1020case 28:
1021YY_RULE_SETUP
1022#line 51 "isdn_cdb.lex"
1023{item=special; BEGIN Value;}
1024 YY_BREAK
1025case 29:
1026YY_RULE_SETUP
1027#line 52 "isdn_cdb.lex"
1028{item=firmware; BEGIN Value;}
1029 YY_BREAK
1030case 30:
1031YY_RULE_SETUP
1032#line 53 "isdn_cdb.lex"
1033{item=short_description; BEGIN Value;}
1034 YY_BREAK
1035case 31:
1036YY_RULE_SETUP
1037#line 54 "isdn_cdb.lex"
1038{item=IRQ; BEGIN Value;}
1039 YY_BREAK
1040case 32:
1041YY_RULE_SETUP
1042#line 55 "isdn_cdb.lex"
1043{item=IO; BEGIN Value;}
1044 YY_BREAK
1045case 33:
1046YY_RULE_SETUP
1047#line 56 "isdn_cdb.lex"
1048{item=MEMBASE; BEGIN Value;}
1049 YY_BREAK
1050case 34:
1051YY_RULE_SETUP
1052#line 57 "isdn_cdb.lex"
1053{item=alternative_name; BEGIN Value;}
1054 YY_BREAK
1055case 35:
1056YY_RULE_SETUP
1057#line 58 "isdn_cdb.lex"
1058{item=revision; BEGIN Value;}
1059 YY_BREAK
1060case 36:
1061/* rule 36 can match eol */
1062YY_RULE_SETUP
1063#line 59 "isdn_cdb.lex"
1064BEGIN Main;
1065 YY_BREAK
1066
1067
1068case 37:
1069YY_RULE_SETUP
1070#line 63 "isdn_cdb.lex"
1071BEGIN NewEntry;
1072 YY_BREAK
1073case 38:
1074/* rule 38 can match eol */
1075*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1076YY_LINENO_REWIND_TO(yy_cp - 1);
1077(yy_c_buf_p) = yy_cp -= 1;
1078YY_DO_BEFORE_ACTION; /* set up yytext again */
1079YY_RULE_SETUP
1080#line 64 "isdn_cdb.lex"
1081add_current_item(item, yytext);
1082 YY_BREAK
1083
1084case 39:
1085YY_RULE_SETUP
1086#line 66 "isdn_cdb.lex"
1087ECHO;
1088 YY_BREAK
1089#line 1090 "lex.yy.c"
1090case YY_STATE_EOF(INITIAL):
1091case YY_STATE_EOF(Main):
1092case YY_STATE_EOF(NextLine):
1093case YY_STATE_EOF(NewEntry):
1094case YY_STATE_EOF(Value):
1095 yyterminate();
1096
1097 case YY_END_OF_BUFFER:
1098 {
1099 /* Amount of text matched not including the EOB char. */
1100 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1101
1102 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1103 *yy_cp = (yy_hold_char);
1104 YY_RESTORE_YY_MORE_OFFSET
1105
1106 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1107 {
1108 /* We're scanning a new file or input source. It's
1109 * possible that this happened because the user
1110 * just pointed yyin at a new source and called
1111 * yylex(). If so, then we have to assure
1112 * consistency between YY_CURRENT_BUFFER and our
1113 * globals. Here is the right place to do so, because
1114 * this is the first action (other than possibly a
1115 * back-up) that will match for the new input source.
1116 */
1117 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1118 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1119 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1120 }
1121
1122 /* Note that here we test for yy_c_buf_p "<=" to the position
1123 * of the first EOB in the buffer, since yy_c_buf_p will
1124 * already have been incremented past the NUL character
1125 * (since all states make transitions on EOB to the
1126 * end-of-buffer state). Contrast this with the test
1127 * in input().
1128 */
1129 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1130 { /* This was really a NUL. */
1131 yy_state_type yy_next_state;
1132
1133 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1134
1135 yy_current_state = yy_get_previous_state( );
1136
1137 /* Okay, we're now positioned to make the NUL
1138 * transition. We couldn't have
1139 * yy_get_previous_state() go ahead and do it
1140 * for us because it doesn't know how to deal
1141 * with the possibility of jamming (and we don't
1142 * want to build jamming into it because then it
1143 * will run more slowly).
1144 */
1145
1146 yy_next_state = yy_try_NUL_trans( yy_current_state );
1147
1148 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1149
1150 if ( yy_next_state )
1151 {
1152 /* Consume the NUL. */
1153 yy_cp = ++(yy_c_buf_p);
1154 yy_current_state = yy_next_state;
1155 goto yy_match;
1156 }
1157
1158 else
1159 {
1160 yy_cp = (yy_c_buf_p);
1161 goto yy_find_action;
1162 }
1163 }
1164
1165 else switch ( yy_get_next_buffer( ) )
1166 {
1167 case EOB_ACT_END_OF_FILE:
1168 {
1169 (yy_did_buffer_switch_on_eof) = 0;
1170
1171 if ( yywrap( ) )
1172 {
1173 /* Note: because we've taken care in
1174 * yy_get_next_buffer() to have set up
1175 * yytext, we can now set up
1176 * yy_c_buf_p so that if some total
1177 * hoser (like flex itself) wants to
1178 * call the scanner after we return the
1179 * YY_NULL, it'll still work - another
1180 * YY_NULL will get returned.
1181 */
1182 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1183
1184 yy_act = YY_STATE_EOF(YY_START);
1185 goto do_action;
1186 }
1187
1188 else
1189 {
1190 if ( ! (yy_did_buffer_switch_on_eof) )
1191 YY_NEW_FILE;
1192 }
1193 break;
1194 }
1195
1196 case EOB_ACT_CONTINUE_SCAN:
1197 (yy_c_buf_p) =
1198 (yytext_ptr) + yy_amount_of_matched_text;
1199
1200 yy_current_state = yy_get_previous_state( );
1201
1202 yy_cp = (yy_c_buf_p);
1203 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1204 goto yy_match;
1205
1206 case EOB_ACT_LAST_MATCH:
1207 (yy_c_buf_p) =
1208 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1209
1210 yy_current_state = yy_get_previous_state( );
1211
1212 yy_cp = (yy_c_buf_p);
1213 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1214 goto yy_find_action;
1215 }
1216 break;
1217 }
1218
1219 default:
1220 YY_FATAL_ERROR(
1221 "fatal flex scanner internal error--no action found" );
1222 } /* end of action switch */
1223 } /* end of scanning one token */
1224 } /* end of user's declarations */
1225} /* end of yylex */
1226
1227/* yy_get_next_buffer - try to read in a new buffer
1228 *
1229 * Returns a code representing an action:
1230 * EOB_ACT_LAST_MATCH -
1231 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1232 * EOB_ACT_END_OF_FILE - end of file
1233 */
1234static int yy_get_next_buffer (void)
1235{
1236 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1237 char *source = (yytext_ptr);
1238 int number_to_move, i;
1239 int ret_val;
1240
1241 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1242 YY_FATAL_ERROR(
1243 "fatal flex scanner internal error--end of buffer missed" );
1244
1245 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1246 { /* Don't try to fill the buffer, so this is an EOF. */
1247 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1248 {
1249 /* We matched a single character, the EOB, so
1250 * treat this as a final EOF.
1251 */
1252 return EOB_ACT_END_OF_FILE;
1253 }
1254
1255 else
1256 {
1257 /* We matched some text prior to the EOB, first
1258 * process it.
1259 */
1260 return EOB_ACT_LAST_MATCH;
1261 }
1262 }
1263
1264 /* Try to read more data. */
1265
1266 /* First move last chars to start of buffer. */
1267 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1268
1269 for ( i = 0; i < number_to_move; ++i )
1270 *(dest++) = *(source++);
1271
1272 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1273 /* don't do the read, it's not guaranteed to return an EOF,
1274 * just force an EOF
1275 */
1276 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1277
1278 else
1279 {
1280 int num_to_read =
1281 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1282
1283 while ( num_to_read <= 0 )
1284 { /* Not enough room in the buffer - grow it. */
1285
1286 /* just a shorter name for the current buffer */
1287 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1288
1289 int yy_c_buf_p_offset =
1290 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1291
1292 if ( b->yy_is_our_buffer )
1293 {
1294 int new_size = b->yy_buf_size * 2;
1295
1296 if ( new_size <= 0 )
1297 b->yy_buf_size += b->yy_buf_size / 8;
1298 else
1299 b->yy_buf_size *= 2;
1300
1301 b->yy_ch_buf = (char *)
1302 /* Include room in for 2 EOB chars. */
1303 yyrealloc( (void *) b->yy_ch_buf,
1304 (yy_size_t) (b->yy_buf_size + 2) );
1305 }
1306 else
1307 /* Can't grow it, we don't own it. */
1308 b->yy_ch_buf = NULL;
1309
1310 if ( ! b->yy_ch_buf )
1311 YY_FATAL_ERROR(
1312 "fatal error - scanner input buffer overflow" );
1313
1314 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1315
1316 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1317 number_to_move - 1;
1318
1319 }
1320
1321 if ( num_to_read > YY_READ_BUF_SIZE )
1322 num_to_read = YY_READ_BUF_SIZE;
1323
1324 /* Read in more data. */
1325 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1326 (yy_n_chars), num_to_read );
1327
1328 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1329 }
1330
1331 if ( (yy_n_chars) == 0 )
1332 {
1333 if ( number_to_move == YY_MORE_ADJ )
1334 {
1335 ret_val = EOB_ACT_END_OF_FILE;
1336 yyrestart( yyin );
1337 }
1338
1339 else
1340 {
1341 ret_val = EOB_ACT_LAST_MATCH;
1342 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1343 YY_BUFFER_EOF_PENDING;
1344 }
1345 }
1346
1347 else
1348 ret_val = EOB_ACT_CONTINUE_SCAN;
1349
1350 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1351 /* Extend the array by 50%, plus the number we really need. */
1352 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1353 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1354 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1355 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1356 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1357 /* "- 2" to take care of EOB's */
1358 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1359 }
1360
1361 (yy_n_chars) += number_to_move;
1362 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1363 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1364
1365 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1366
1367 return ret_val;
1368}
1369
1370/* yy_get_previous_state - get the state just before the EOB char was reached */
1371
1372 static yy_state_type yy_get_previous_state (void)
1373{
1374 yy_state_type yy_current_state;
1375 char *yy_cp;
1376
1377 yy_current_state = (yy_start);
1378 yy_current_state += YY_AT_BOL();
1379
1380 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1381 {
1382 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1383 if ( yy_accept[yy_current_state] )
1384 {
1385 (yy_last_accepting_state) = yy_current_state;
1386 (yy_last_accepting_cpos) = yy_cp;
1387 }
1388 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1389 {
1390 yy_current_state = (int) yy_def[yy_current_state];
1391 if ( yy_current_state >= 254 )
1392 yy_c = yy_meta[yy_c];
1393 }
1394 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1395 }
1396
1397 return yy_current_state;
1398}
1399
1400/* yy_try_NUL_trans - try to make a transition on the NUL character
1401 *
1402 * synopsis
1403 * next_state = yy_try_NUL_trans( current_state );
1404 */
1405 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1406{
1407 int yy_is_jam;
1408 char *yy_cp = (yy_c_buf_p);
1409
1410 YY_CHAR yy_c = 1;
1411 if ( yy_accept[yy_current_state] )
1412 {
1413 (yy_last_accepting_state) = yy_current_state;
1414 (yy_last_accepting_cpos) = yy_cp;
1415 }
1416 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1417 {
1418 yy_current_state = (int) yy_def[yy_current_state];
1419 if ( yy_current_state >= 254 )
1420 yy_c = yy_meta[yy_c];
1421 }
1422 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1423 yy_is_jam = (yy_current_state == 253);
1424
1425 return yy_is_jam ? 0 : yy_current_state;
1426}
1427
1428#ifndef YY_NO_UNPUT
1429
1430 static void yyunput (int c, char * yy_bp )
1431{
1432 char *yy_cp;
1433
1434 yy_cp = (yy_c_buf_p);
1435
1436 /* undo effects of setting up yytext */
1437 *yy_cp = (yy_hold_char);
1438
1439 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1440 { /* need to shift things up to make room */
1441 /* +2 for EOB chars. */
1442 int number_to_move = (yy_n_chars) + 2;
1443 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1444 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1445 char *source =
1446 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1447
1448 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1449 *--dest = *--source;
1450
1451 yy_cp += (int) (dest - source);
1452 yy_bp += (int) (dest - source);
1453 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1454 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1455
1456 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1457 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1458 }
1459
1460 *--yy_cp = (char) c;
1461
1462 (yytext_ptr) = yy_bp;
1463 (yy_hold_char) = *yy_cp;
1464 (yy_c_buf_p) = yy_cp;
1465}
1466
1467#endif
1468
1469#ifndef YY_NO_INPUT
1470#ifdef __cplusplus
1471 static int yyinput (void)
1472#else
1473 static int input (void)
1474#endif
1475
1476{
1477 int c;
1478
1479 *(yy_c_buf_p) = (yy_hold_char);
1480
1481 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1482 {
1483 /* yy_c_buf_p now points to the character we want to return.
1484 * If this occurs *before* the EOB characters, then it's a
1485 * valid NUL; if not, then we've hit the end of the buffer.
1486 */
1487 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1488 /* This was really a NUL. */
1489 *(yy_c_buf_p) = '\0';
1490
1491 else
1492 { /* need more input */
1493 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1494 ++(yy_c_buf_p);
1495
1496 switch ( yy_get_next_buffer( ) )
1497 {
1498 case EOB_ACT_LAST_MATCH:
1499 /* This happens because yy_g_n_b()
1500 * sees that we've accumulated a
1501 * token and flags that we need to
1502 * try matching the token before
1503 * proceeding. But for input(),
1504 * there's no matching to consider.
1505 * So convert the EOB_ACT_LAST_MATCH
1506 * to EOB_ACT_END_OF_FILE.
1507 */
1508
1509 /* Reset buffer status. */
1510 yyrestart( yyin );
1511
1512 /*FALLTHROUGH*/
1513
1514 case EOB_ACT_END_OF_FILE:
1515 {
1516 if ( yywrap( ) )
1517 return 0;
1518
1519 if ( ! (yy_did_buffer_switch_on_eof) )
1520 YY_NEW_FILE;
1521#ifdef __cplusplus
1522 return yyinput();
1523#else
1524 return input();
1525#endif
1526 }
1527
1528 case EOB_ACT_CONTINUE_SCAN:
1529 (yy_c_buf_p) = (yytext_ptr) + offset;
1530 break;
1531 }
1532 }
1533 }
1534
1535 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1536 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1537 (yy_hold_char) = *++(yy_c_buf_p);
1538
1539 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1540
1541 return c;
1542}
1543#endif /* ifndef YY_NO_INPUT */
1544
1550 void yyrestart (FILE * input_file )
1551{
1552
1553 if ( ! YY_CURRENT_BUFFER ){
1554 yyensure_buffer_stack ();
1555 YY_CURRENT_BUFFER_LVALUE =
1556 yy_create_buffer( yyin, YY_BUF_SIZE );
1557 }
1558
1559 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1560 yy_load_buffer_state( );
1561}
1562
1567 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1568{
1569
1570 /* TODO. We should be able to replace this entire function body
1571 * with
1572 * yypop_buffer_state();
1573 * yypush_buffer_state(new_buffer);
1574 */
1575 yyensure_buffer_stack ();
1576 if ( YY_CURRENT_BUFFER == new_buffer )
1577 return;
1578
1579 if ( YY_CURRENT_BUFFER )
1580 {
1581 /* Flush out information for old buffer. */
1582 *(yy_c_buf_p) = (yy_hold_char);
1583 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1584 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1585 }
1586
1587 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1588 yy_load_buffer_state( );
1589
1590 /* We don't actually know whether we did this switch during
1591 * EOF (yywrap()) processing, but the only time this flag
1592 * is looked at is after yywrap() is called, so it's safe
1593 * to go ahead and always set it.
1594 */
1595 (yy_did_buffer_switch_on_eof) = 1;
1596}
1597
1598static void yy_load_buffer_state (void)
1599{
1600 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1601 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1602 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1603 (yy_hold_char) = *(yy_c_buf_p);
1604}
1605
1612 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1613{
1614 YY_BUFFER_STATE b;
1615
1616 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1617 if ( ! b )
1618 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1619
1620 b->yy_buf_size = size;
1621
1622 /* yy_ch_buf has to be 2 characters longer than the size given because
1623 * we need to put in 2 end-of-buffer characters.
1624 */
1625 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1626 if ( ! b->yy_ch_buf )
1627 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1628
1629 b->yy_is_our_buffer = 1;
1630
1631 yy_init_buffer( b, file );
1632
1633 return b;
1634}
1635
1640 void yy_delete_buffer (YY_BUFFER_STATE b )
1641{
1642
1643 if ( ! b )
1644 return;
1645
1646 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1647 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1648
1649 if ( b->yy_is_our_buffer )
1650 yyfree( (void *) b->yy_ch_buf );
1651
1652 yyfree( (void *) b );
1653}
1654
1655/* Initializes or reinitializes a buffer.
1656 * This function is sometimes called more than once on the same buffer,
1657 * such as during a yyrestart() or at EOF.
1658 */
1659 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1660
1661{
1662 int oerrno = errno;
1663
1664 yy_flush_buffer( b );
1665
1666 b->yy_input_file = file;
1667 b->yy_fill_buffer = 1;
1668
1669 /* If b is the current buffer, then yy_init_buffer was _probably_
1670 * called from yyrestart() or through yy_get_next_buffer.
1671 * In that case, we don't want to reset the lineno or column.
1672 */
1673 if (b != YY_CURRENT_BUFFER){
1674 b->yy_bs_lineno = 1;
1675 b->yy_bs_column = 0;
1676 }
1677
1678 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1679
1680 errno = oerrno;
1681}
1682
1687 void yy_flush_buffer (YY_BUFFER_STATE b )
1688{
1689 if ( ! b )
1690 return;
1691
1692 b->yy_n_chars = 0;
1693
1694 /* We always need two end-of-buffer characters. The first causes
1695 * a transition to the end-of-buffer state. The second causes
1696 * a jam in that state.
1697 */
1698 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1699 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1700
1701 b->yy_buf_pos = &b->yy_ch_buf[0];
1702
1703 b->yy_at_bol = 1;
1704 b->yy_buffer_status = YY_BUFFER_NEW;
1705
1706 if ( b == YY_CURRENT_BUFFER )
1707 yy_load_buffer_state( );
1708}
1709
1716void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1717{
1718 if (new_buffer == NULL)
1719 return;
1720
1721 yyensure_buffer_stack();
1722
1723 /* This block is copied from yy_switch_to_buffer. */
1724 if ( YY_CURRENT_BUFFER )
1725 {
1726 /* Flush out information for old buffer. */
1727 *(yy_c_buf_p) = (yy_hold_char);
1728 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1729 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1730 }
1731
1732 /* Only push if top exists. Otherwise, replace top. */
1733 if (YY_CURRENT_BUFFER)
1734 (yy_buffer_stack_top)++;
1735 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1736
1737 /* copied from yy_switch_to_buffer. */
1738 yy_load_buffer_state( );
1739 (yy_did_buffer_switch_on_eof) = 1;
1740}
1741
1746void yypop_buffer_state (void)
1747{
1748 if (!YY_CURRENT_BUFFER)
1749 return;
1750
1751 yy_delete_buffer(YY_CURRENT_BUFFER );
1752 YY_CURRENT_BUFFER_LVALUE = NULL;
1753 if ((yy_buffer_stack_top) > 0)
1754 --(yy_buffer_stack_top);
1755
1756 if (YY_CURRENT_BUFFER) {
1757 yy_load_buffer_state( );
1758 (yy_did_buffer_switch_on_eof) = 1;
1759 }
1760}
1761
1762/* Allocates the stack if it does not exist.
1763 * Guarantees space for at least one push.
1764 */
1765static void yyensure_buffer_stack (void)
1766{
1767 yy_size_t num_to_alloc;
1768
1769 if (!(yy_buffer_stack)) {
1770
1771 /* First allocation is just for 2 elements, since we don't know if this
1772 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1773 * immediate realloc on the next call.
1774 */
1775 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1776 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1777 (num_to_alloc * sizeof(struct yy_buffer_state*)
1778 );
1779 if ( ! (yy_buffer_stack) )
1780 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1781
1782 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1783
1784 (yy_buffer_stack_max) = num_to_alloc;
1785 (yy_buffer_stack_top) = 0;
1786 return;
1787 }
1788
1789 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1790
1791 /* Increase the buffer to prepare for a possible push. */
1792 yy_size_t grow_size = 8 /* arbitrary grow size */;
1793
1794 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1795 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1796 ((yy_buffer_stack),
1797 num_to_alloc * sizeof(struct yy_buffer_state*)
1798 );
1799 if ( ! (yy_buffer_stack) )
1800 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1801
1802 /* zero only the new slots.*/
1803 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1804 (yy_buffer_stack_max) = num_to_alloc;
1805 }
1806}
1807
1814YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1815{
1816 YY_BUFFER_STATE b;
1817
1818 if ( size < 2 ||
1819 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1820 base[size-1] != YY_END_OF_BUFFER_CHAR )
1821 /* They forgot to leave room for the EOB's. */
1822 return NULL;
1823
1824 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1825 if ( ! b )
1826 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1827
1828 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1829 b->yy_buf_pos = b->yy_ch_buf = base;
1830 b->yy_is_our_buffer = 0;
1831 b->yy_input_file = NULL;
1832 b->yy_n_chars = b->yy_buf_size;
1833 b->yy_is_interactive = 0;
1834 b->yy_at_bol = 1;
1835 b->yy_fill_buffer = 0;
1836 b->yy_buffer_status = YY_BUFFER_NEW;
1837
1838 yy_switch_to_buffer( b );
1839
1840 return b;
1841}
1842
1851YY_BUFFER_STATE yy_scan_string (const char * yystr )
1852{
1853
1854 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1855}
1856
1864YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1865{
1866 YY_BUFFER_STATE b;
1867 char *buf;
1868 yy_size_t n;
1869 int i;
1870
1871 /* Get memory for full buffer, including space for trailing EOB's. */
1872 n = (yy_size_t) (_yybytes_len + 2);
1873 buf = (char *) yyalloc( n );
1874 if ( ! buf )
1875 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1876
1877 for ( i = 0; i < _yybytes_len; ++i )
1878 buf[i] = yybytes[i];
1879
1880 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1881
1882 b = yy_scan_buffer( buf, n );
1883 if ( ! b )
1884 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1885
1886 /* It's okay to grow etc. this buffer, and we should throw it
1887 * away when we're done.
1888 */
1889 b->yy_is_our_buffer = 1;
1890
1891 return b;
1892}
1893
1894#ifndef YY_EXIT_FAILURE
1895#define YY_EXIT_FAILURE 2
1896#endif
1897
1898static void yynoreturn yy_fatal_error (const char* msg )
1899{
1900 fprintf( stderr, "%s\n", msg );
1901 exit( YY_EXIT_FAILURE );
1902}
1903
1904/* Redefine yyless() so it works in section 3 code. */
1905
1906#undef yyless
1907#define yyless(n) \
1908 do \
1909 { \
1910 /* Undo effects of setting up yytext. */ \
1911 int yyless_macro_arg = (n); \
1912 YY_LESS_LINENO(yyless_macro_arg);\
1913 yytext[yyleng] = (yy_hold_char); \
1914 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1915 (yy_hold_char) = *(yy_c_buf_p); \
1916 *(yy_c_buf_p) = '\0'; \
1917 yyleng = yyless_macro_arg; \
1918 } \
1919 while ( 0 )
1920
1921/* Accessor methods (get/set functions) to struct members. */
1922
1926int yyget_lineno (void)
1927{
1928
1929 return yylineno;
1930}
1931
1935FILE *yyget_in (void)
1936{
1937 return yyin;
1938}
1939
1943FILE *yyget_out (void)
1944{
1945 return yyout;
1946}
1947
1951int yyget_leng (void)
1952{
1953 return yyleng;
1954}
1955
1960char *yyget_text (void)
1961{
1962 return yytext;
1963}
1964
1969void yyset_lineno (int _line_number )
1970{
1971
1972 yylineno = _line_number;
1973}
1974
1981void yyset_in (FILE * _in_str )
1982{
1983 yyin = _in_str ;
1984}
1985
1986void yyset_out (FILE * _out_str )
1987{
1988 yyout = _out_str ;
1989}
1990
1991int yyget_debug (void)
1992{
1993 return yy_flex_debug;
1994}
1995
1996void yyset_debug (int _bdebug )
1997{
1998 yy_flex_debug = _bdebug ;
1999}
2000
2001static int yy_init_globals (void)
2002{
2003 /* Initialization is the same as for the non-reentrant scanner.
2004 * This function is called from yylex_destroy(), so don't allocate here.
2005 */
2006
2007 (yy_buffer_stack) = NULL;
2008 (yy_buffer_stack_top) = 0;
2009 (yy_buffer_stack_max) = 0;
2010 (yy_c_buf_p) = NULL;
2011 (yy_init) = 0;
2012 (yy_start) = 0;
2013
2014/* Defined in main.c */
2015#ifdef YY_STDINIT
2016 yyin = stdin;
2017 yyout = stdout;
2018#else
2019 yyin = NULL;
2020 yyout = NULL;
2021#endif
2022
2023 /* For future reference: Set errno on error, since we are called by
2024 * yylex_init()
2025 */
2026 return 0;
2027}
2028
2029/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2030int yylex_destroy (void)
2031{
2032
2033 /* Pop the buffer stack, destroying each element. */
2034 while(YY_CURRENT_BUFFER){
2035 yy_delete_buffer( YY_CURRENT_BUFFER );
2036 YY_CURRENT_BUFFER_LVALUE = NULL;
2037 yypop_buffer_state();
2038 }
2039
2040 /* Destroy the stack itself. */
2041 yyfree((yy_buffer_stack) );
2042 (yy_buffer_stack) = NULL;
2043
2044 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2045 * yylex() is called, initialization will occur. */
2046 yy_init_globals( );
2047
2048 return 0;
2049}
2050
2051/*
2052 * Internal utility routines.
2053 */
2054
2055#ifndef yytext_ptr
2056static void yy_flex_strncpy (char* s1, const char * s2, int n )
2057{
2058
2059 int i;
2060 for ( i = 0; i < n; ++i )
2061 s1[i] = s2[i];
2062}
2063#endif
2064
2065#ifdef YY_NEED_STRLEN
2066static int yy_flex_strlen (const char * s )
2067{
2068 int n;
2069 for ( n = 0; s[n]; ++n )
2070 ;
2071
2072 return n;
2073}
2074#endif
2075
2076void *yyalloc (yy_size_t size )
2077{
2078 return malloc(size);
2079}
2080
2081void *yyrealloc (void * ptr, yy_size_t size )
2082{
2083
2084 /* The cast to (char *) in the following accommodates both
2085 * implementations that use char* generic pointers, and those
2086 * that use void* generic pointers. It works with the latter
2087 * because both ANSI C and C++ allow castless assignment from
2088 * any pointer type to void*, and deal with argument conversions
2089 * as though doing an assignment.
2090 */
2091 return realloc(ptr, size);
2092}
2093
2094void yyfree (void * ptr )
2095{
2096 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2097}
2098
2099#define YYTABLES_NAME "yytables"
2100
2101#line 66 "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:1935
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:1981
input
static int input(void)
Definition lex.yy.c:1473
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:1430
yy_fatal_error
static void yynoreturn yy_fatal_error(const char *msg)
Definition lex.yy.c:1898
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition lex.yy.c:605
NewEntry
#define NewEntry
Definition lex.yy.c:593
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:1765
yy_flush_buffer
void yy_flush_buffer(YY_BUFFER_STATE b)
Discard all buffered characters.
Definition lex.yy.c:1687
yy_switch_to_buffer
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Switch to a different input buffer.
Definition lex.yy.c:1567
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:1926
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition lex.yy.c:1234
YY_BREAK
#define YY_BREAK
Definition lex.yy.c:768
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:1405
yy_act
int yy_act
Definition lex.yy.c:783
Value
#define Value
Definition lex.yy.c:594
yypush_buffer_state
void yypush_buffer_state(YY_BUFFER_STATE new_buffer)
Pushes the new state onto the stack.
Definition lex.yy.c:1716
yyget_debug
int yyget_debug(void)
Definition lex.yy.c:1991
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:1943
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:2001
yy_create_buffer
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Allocate and initialize an input buffer state.
Definition lex.yy.c:1612
Main
#define Main
Definition lex.yy.c:591
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:782
yypop_buffer_state
void yypop_buffer_state(void)
Removes and deletes the top of the stack, if present.
Definition lex.yy.c:1746
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:771
yy_meta
static const YY_CHAR yy_meta[40]
Definition lex.yy.c:421
yyfree
void yyfree(void *)
Definition lex.yy.c:2094
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:2076
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:1851
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:1951
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:592
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:1864
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:10
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:590
yy_bp
char * yy_bp
Definition lex.yy.c:782
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:680
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition lex.yy.c:696
ECHO
#define ECHO
Definition lex.yy.c:689
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:2030
yyrestart
void yyrestart(FILE *input_file)
Immediately switch to a different input stream.
Definition lex.yy.c:1550
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:2081
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition lex.yy.c:743
yyterminate
#define yyterminate()
Definition lex.yy.c:733
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:1996
yy_load_buffer_state
static void yy_load_buffer_state(void)
Definition lex.yy.c:1598
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:1969
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:1960
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:1372
yyset_out
void yyset_out(FILE *_out_str)
Definition lex.yy.c:1986
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:756
yy_delete_buffer
void yy_delete_buffer(YY_BUFFER_STATE b)
Destroy the buffer.
Definition lex.yy.c:1640
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition lex.yy.c:134
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition lex.yy.c:1895
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:1659
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:1814
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