Bug Summary

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