Bug Summary

File:obj-scan-build/conftest.c
Location:line 948, column 5
Description:Value stored to 'yy_current_state' is never read

Annotated Source Code

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