Bug Summary

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