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