Bug Summary

File:src/usr.sbin/unbound/obj/conftest.c
Warning:line 782, column 19
Array subscript is undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

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