Annotation of src/usr.bin/lex/flex.skl, Revision 1.18
1.18 ! millert 1: /* $OpenBSD: flex.skl,v 1.17 2020/08/06 17:23:29 deraadt Exp $ */
1.2 deraadt 2:
1.13 tedu 3: %# -*-C-*- vi: set ft=c:
4: %# This file is processed in several stages.
5: %# Here are the stages, as best as I can describe:
6: %#
7: %# 1. flex.skl is processed through GNU m4 during the
8: %# pre-compilation stage of flex. Only macros starting
9: %# with `m4preproc_' are processed, and quoting is normal.
10: %#
11: %# 2. The preprocessed skeleton is translated verbatim into a
12: %# C array, saved as "skel.c" and compiled into the flex binary.
13: %#
14: %# 3. At runtime, the skeleton is generated and filtered (again)
15: %# through m4. Macros beginning with `m4_' will be processed.
16: %# The quoting is "[[" and "]]" so we don't interfere with
17: %# user code.
18: %#
19: %# All generate macros for the m4 stage contain the text "m4" or "M4"
20: %# in them. This is to distinguish them from CPP macros.
21: %# The exception to this rule is YY_G, which is an m4 macro,
22: %# but it needs to be remain short because it is used everywhere.
23: %#
1.1 deraadt 24: /* A lexical scanner generated by flex */
25:
1.13 tedu 26: %# Macros for preproc stage.
27: m4preproc_changecom
28:
29: %# Macros for runtime processing stage.
30: m4_changecom
31: m4_changequote
32: m4_changequote([[, ]])
33:
34: %#
35: %# Lines in this skeleton starting with a "%" character are "control lines"
36: %# and affect the generation of the scanner. The possible control codes are
37: %# listed and processed in misc.c.
38: %#
39: %# %# - A comment. The current line is omitted from the generated scanner.
40: %# %if-c++-only - The following lines are printed for C++ scanners ONLY.
41: %# %if-c-only - The following lines are NOT printed for C++ scanners.
42: %# %if-c-or-c++ - The following lines are printed in BOTH C and C++ scanners.
43: %# %if-reentrant - Print for reentrant scanners.(push)
44: %# %if-not-reentrant - Print for non-reentrant scanners. (push)
45: %# %if-bison-bridge - Print for bison-bridge. (push)
46: %# %if-not-bison-bridge - Print for non-bison-bridge. (push)
47: %# %endif - pop from the previous if code.
48: %# %% - A stop-point, where code is inserted by flex.
49: %# Each stop-point is numbered here and also in the code generator.
50: %# (See gen.c, etc. for details.)
51: %# %not-for-header - Begin code that should NOT appear in a ".h" file.
52: %# %ok-for-header - %c and %e are used for building a header file.
53: %# %if-tables-serialization
54: %#
55: %# All control-lines EXCEPT comment lines ("%#") will be inserted into
56: %# the generated scanner as a C-style comment. This is to aid those who
57: %# edit the skeleton.
58: %#
59:
60: %not-for-header
61: %if-c-only
62: %if-not-reentrant
63: m4_ifelse(M4_YY_PREFIX,yy,,
64: #define yy_create_buffer M4_YY_PREFIX[[_create_buffer]]
65: #define yy_delete_buffer M4_YY_PREFIX[[_delete_buffer]]
66: #define yy_flex_debug M4_YY_PREFIX[[_flex_debug]]
67: #define yy_init_buffer M4_YY_PREFIX[[_init_buffer]]
68: #define yy_flush_buffer M4_YY_PREFIX[[_flush_buffer]]
69: #define yy_load_buffer_state M4_YY_PREFIX[[_load_buffer_state]]
70: #define yy_switch_to_buffer M4_YY_PREFIX[[_switch_to_buffer]]
71: #define yyin M4_YY_PREFIX[[in]]
72: #define yyleng M4_YY_PREFIX[[leng]]
73: #define yylex M4_YY_PREFIX[[lex]]
74: #define yylineno M4_YY_PREFIX[[lineno]]
75: #define yyout M4_YY_PREFIX[[out]]
76: #define yyrestart M4_YY_PREFIX[[restart]]
77: #define yytext M4_YY_PREFIX[[text]]
78: #define yywrap M4_YY_PREFIX[[wrap]]
79: #define yyalloc M4_YY_PREFIX[[alloc]]
80: #define yyrealloc M4_YY_PREFIX[[realloc]]
81: #define yyfree M4_YY_PREFIX[[free]]
82: )
83: %endif
84: %endif
85: %ok-for-header
1.1 deraadt 86:
87: #define FLEX_SCANNER
1.13 tedu 88: #define YY_FLEX_MAJOR_VERSION FLEX_MAJOR_VERSION
89: #define YY_FLEX_MINOR_VERSION FLEX_MINOR_VERSION
90: #define YY_FLEX_SUBMINOR_VERSION FLEX_SUBMINOR_VERSION
91: #if YY_FLEX_SUBMINOR_VERSION > 0
92: #define FLEX_BETA
93: #endif
94:
95: %# Some negated symbols
96: m4_ifdef( [[M4_YY_IN_HEADER]], , [[m4_define([[M4_YY_NOT_IN_HEADER]], [[]])]])
97: m4_ifdef( [[M4_YY_REENTRANT]], , [[m4_define([[M4_YY_NOT_REENTRANT]], [[]])]])
98:
99: %# This is the m4 way to say "(stack_used || is_reentrant)
100: m4_ifdef( [[M4_YY_STACK_USED]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])
101: m4_ifdef( [[M4_YY_REENTRANT]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])
102:
103: %# Prefixes.
104: %# The complexity here is necessary so that m4 preserves
105: %# the argument lists to each C function.
106:
107:
108: m4_ifdef( [[M4_YY_PREFIX]],, [[m4_define([[M4_YY_PREFIX]], [[yy]])]])
109:
110: m4preproc_define(`M4_GEN_PREFIX',
111: ``m4_define(yy[[$1]], [[M4_YY_PREFIX[[$1]]m4_ifelse($'`#,0,,[[($'`@)]])]])'')
112:
113: %if-c++-only
114: /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
115: * following macro. This is required in order to pass the c++-multiple-scanners
116: * test in the regression suite. We get reports that it breaks inheritance.
117: * We will address this in a future release of flex, or omit the C++ scanner
118: * altogether.
119: */
120: #define yyFlexLexer M4_YY_PREFIX[[FlexLexer]]
121: %endif
122:
123: %if-c-only
124: M4_GEN_PREFIX(`_create_buffer')
125: M4_GEN_PREFIX(`_delete_buffer')
126: M4_GEN_PREFIX(`_scan_buffer')
127: M4_GEN_PREFIX(`_scan_string')
128: M4_GEN_PREFIX(`_scan_bytes')
129: M4_GEN_PREFIX(`_init_buffer')
130: M4_GEN_PREFIX(`_flush_buffer')
131: M4_GEN_PREFIX(`_load_buffer_state')
132: M4_GEN_PREFIX(`_switch_to_buffer')
133: M4_GEN_PREFIX(`push_buffer_state')
134: M4_GEN_PREFIX(`pop_buffer_state')
135: M4_GEN_PREFIX(`ensure_buffer_stack')
136: M4_GEN_PREFIX(`lex')
137: M4_GEN_PREFIX(`restart')
138: M4_GEN_PREFIX(`lex_init')
139: M4_GEN_PREFIX(`lex_init_extra')
140: M4_GEN_PREFIX(`lex_destroy')
141: M4_GEN_PREFIX(`get_debug')
142: M4_GEN_PREFIX(`set_debug')
143: M4_GEN_PREFIX(`get_extra')
144: M4_GEN_PREFIX(`set_extra')
145: M4_GEN_PREFIX(`get_in')
146: M4_GEN_PREFIX(`set_in')
147: M4_GEN_PREFIX(`get_out')
148: M4_GEN_PREFIX(`set_out')
149: M4_GEN_PREFIX(`get_leng')
150: M4_GEN_PREFIX(`get_text')
151: M4_GEN_PREFIX(`get_lineno')
152: M4_GEN_PREFIX(`set_lineno')
153: m4_ifdef( [[M4_YY_REENTRANT]],
154: [[
155: M4_GEN_PREFIX(`get_column')
156: M4_GEN_PREFIX(`set_column')
157: ]])
158: M4_GEN_PREFIX(`wrap')
159: %endif
160:
161: m4_ifdef( [[M4_YY_BISON_LVAL]],
162: [[
163: M4_GEN_PREFIX(`get_lval')
164: M4_GEN_PREFIX(`set_lval')
165: ]])
166:
167: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
168: [[
169: M4_GEN_PREFIX(`get_lloc')
170: M4_GEN_PREFIX(`set_lloc')
171: ]])
172:
173:
174: M4_GEN_PREFIX(`alloc')
175: M4_GEN_PREFIX(`realloc')
176: M4_GEN_PREFIX(`free')
177:
178: %if-c-only
179: m4_ifdef( [[M4_YY_NOT_REENTRANT]],
180: [[
181: M4_GEN_PREFIX(`text')
182: M4_GEN_PREFIX(`leng')
183: M4_GEN_PREFIX(`in')
184: M4_GEN_PREFIX(`out')
185: M4_GEN_PREFIX(`_flex_debug')
186: M4_GEN_PREFIX(`lineno')
187: ]])
188: %endif
189:
190:
191: m4_ifdef( [[M4_YY_TABLES_EXTERNAL]],
192: [[
193: M4_GEN_PREFIX(`tables_fload')
194: M4_GEN_PREFIX(`tables_destroy')
195: M4_GEN_PREFIX(`TABLES_NAME')
196: ]])
197:
198: /* First, we deal with platform-specific or compiler-specific issues. */
1.1 deraadt 199:
1.13 tedu 200: /* begin standard C headers. */
201: %if-c-only
1.1 deraadt 202: #include <stdio.h>
1.13 tedu 203: #include <string.h>
1.6 millert 204: #include <errno.h>
1.13 tedu 205: #include <stdlib.h>
206: %endif
1.1 deraadt 207:
1.13 tedu 208: %if-tables-serialization
209: #include <sys/types.h>
210: #include <netinet/in.h>
211: %endif
212: /* end standard C headers. */
213:
214: %if-c-or-c++
215: m4preproc_include(`flexint.h')
216: %endif
217:
218: %if-c++-only
219: /* begin standard C++ headers. */
220: #include <iostream>
221: #include <errno.h>
222: #include <cstdlib>
223: #include <cstdio>
224: #include <cstring>
225: /* end standard C++ headers. */
226: %endif
1.1 deraadt 227:
228: #ifdef __cplusplus
229:
230: /* The "const" storage-class-modifier is valid. */
231: #define YY_USE_CONST
232:
233: #else /* ! __cplusplus */
234:
1.13 tedu 235: /* C99 requires __STDC__ to be defined as 1. */
236: #if defined (__STDC__)
1.1 deraadt 237:
238: #define YY_USE_CONST
239:
1.13 tedu 240: #endif /* defined (__STDC__) */
1.1 deraadt 241: #endif /* ! __cplusplus */
242:
243: #ifdef YY_USE_CONST
244: #define yyconst const
245: #else
246: #define yyconst
247: #endif
248:
1.13 tedu 249: %# For compilers that can not handle prototypes.
250: %# e.g.,
251: %# The function prototype
252: %# int foo(int x, char* y);
253: %#
254: %# ...should be written as
255: %# int foo M4_YY_PARAMS(int x, char* y);
256: %#
257: %# ...which could possibly generate
258: %# int foo ();
259: %#
260: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_PROTOS]],
261: [[
262: m4_define( [[M4_YY_PARAMS]], [[()]])
263: ]],
264: [[
265: m4_define( [[M4_YY_PARAMS]], [[($*)]])
266: ]])
1.1 deraadt 267:
1.13 tedu 268: %not-for-header
1.1 deraadt 269: /* Returned upon end-of-file. */
270: #define YY_NULL 0
1.13 tedu 271: %ok-for-header
1.1 deraadt 272:
1.13 tedu 273: %not-for-header
1.1 deraadt 274: /* Promotes a possibly negative, possibly signed char to an unsigned
275: * integer for use as an array index. If the signed char is negative,
276: * we want to instead treat it as an 8-bit unsigned char, hence the
277: * double cast.
278: */
279: #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
1.13 tedu 280: %ok-for-header
281:
282:
283:
284: %if-reentrant
285:
286: /* An opaque pointer. */
287: #ifndef YY_TYPEDEF_YY_SCANNER_T
288: #define YY_TYPEDEF_YY_SCANNER_T
289: typedef void* yyscan_t;
290: #endif
291:
292: %# Declare yyguts variable
293: m4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*)yyscanner]])
294: %# Perform a noop access on yyguts to prevent unused variable complains
295: m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[(void)yyg]])
296: %# For use wherever a Global is accessed or assigned.
297: m4_define( [[YY_G]], [[yyg->$1]])
298:
299: %# For use in function prototypes to append the additional argument.
300: m4_define( [[M4_YY_PROTO_LAST_ARG]], [[, yyscan_t yyscanner]])
301: m4_define( [[M4_YY_PROTO_ONLY_ARG]], [[yyscan_t yyscanner]])
302:
303: %# For use in function definitions to append the additional argument.
304: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
305: [[
306: m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscanner]])
307: m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscanner]])
308: ]],
309: [[
310: m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscan_t yyscanner]])
311: m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscan_t yyscanner]])
312: ]])
313: m4_define( [[M4_YY_DECL_LAST_ARG]], [[yyscan_t yyscanner;]])
314:
315: %# For use in function calls to pass the additional argument.
316: m4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]])
317: m4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]])
318:
319: %# For use in function documentation to adjust for additional argument.
320: m4_define( [[M4_YY_DOC_PARAM]], [[@param yyscanner The scanner object.]])
321:
322: /* For convenience, these vars (plus the bison vars far below)
323: are macros in the reentrant scanner. */
324: #define yyin YY_G(yyin_r)
325: #define yyout YY_G(yyout_r)
326: #define yyextra YY_G(yyextra_r)
327: #define yyleng YY_G(yyleng_r)
328: #define yytext YY_G(yytext_r)
329: #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
330: #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
331: #define yy_flex_debug YY_G(yy_flex_debug_r)
332:
333: m4_define( [[M4_YY_INCR_LINENO]],
334: [[
335: do{ yylineno++;
336: yycolumn=0;
337: }while(0)
338: ]])
339:
340: %endif
341:
342:
343:
344: %if-not-reentrant
345:
346: m4_define( [[M4_YY_INCR_LINENO]],
347: [[
348: yylineno++;
349: ]])
350:
351: %# Define these macros to be no-ops.
352: m4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]])
353: m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[m4_dnl]])
354: m4_define( [[YY_G]], [[($1)]])
355: m4_define( [[M4_YY_PROTO_LAST_ARG]])
356: m4_define( [[M4_YY_PROTO_ONLY_ARG]], [[void]])
357: m4_define( [[M4_YY_DEF_LAST_ARG]])
358:
359: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
360: [[
361: m4_define( [[M4_YY_DEF_ONLY_ARG]])
362: ]],
363: [[
364: m4_define( [[M4_YY_DEF_ONLY_ARG]], [[void]])
365: ]])
366: m4_define([[M4_YY_DECL_LAST_ARG]])
367: m4_define([[M4_YY_CALL_LAST_ARG]])
368: m4_define([[M4_YY_CALL_ONLY_ARG]])
369: m4_define( [[M4_YY_DOC_PARAM]], [[]])
370:
371: %endif
372:
373:
374: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
375: [[
376: %# For compilers that need traditional function definitions.
377: %# e.g.,
378: %# The function prototype taking 2 arguments
379: %# int foo (int x, char* y)
380: %#
381: %# ...should be written as
382: %# int foo YYFARGS2(int,x, char*,y)
383: %#
384: %# ...which could possibly generate
385: %# int foo (x,y,yyscanner)
386: %# int x;
387: %# char * y;
388: %# yyscan_t yyscanner;
389: %#
390: %# Generate traditional function defs
391: m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG) [[\]]
392: M4_YY_DECL_LAST_ARG]])
393: m4_define( [[YYFARGS1]], [[($2 M4_YY_DEF_LAST_ARG) [[\]]
394: $1 $2; [[\]]
395: M4_YY_DECL_LAST_ARG]])
396: m4_define( [[YYFARGS2]], [[($2,$4 M4_YY_DEF_LAST_ARG) [[\]]
397: $1 $2; [[\]]
398: $3 $4; [[\]]
399: M4_YY_DECL_LAST_ARG]])
400: m4_define( [[YYFARGS3]], [[($2,$4,$6 M4_YY_DEF_LAST_ARG) [[\]]
401: $1 $2; [[\]]
402: $3 $4; [[\]]
403: $5 $6; [[\]]
404: M4_YY_DECL_LAST_ARG]])
405: ]],
406: [[
407: %# Generate C99 function defs.
408: m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG)]])
409: m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]])
410: m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]])
411: m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]])
412: ]])
1.1 deraadt 413:
1.13 tedu 414: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
415: [[
1.1 deraadt 416: /* Enter a start condition. This macro really ought to take a parameter,
417: * but we do it the disgusting crufty way forced on us by the ()-less
418: * definition of BEGIN.
419: */
1.13 tedu 420: #define BEGIN YY_G(yy_start) = 1 + 2 *
421: ]])
1.1 deraadt 422:
1.13 tedu 423: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
424: [[
1.1 deraadt 425: /* Translate the current start state into a value that can be later handed
426: * to BEGIN to return to the state. The YYSTATE alias is for lex
427: * compatibility.
428: */
1.13 tedu 429: #define YY_START ((YY_G(yy_start) - 1) / 2)
1.1 deraadt 430: #define YYSTATE YY_START
1.13 tedu 431: ]])
1.1 deraadt 432:
1.13 tedu 433: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
434: [[
1.1 deraadt 435: /* Action number for EOF rule of a given start state. */
436: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
1.13 tedu 437: ]])
1.1 deraadt 438:
1.13 tedu 439: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
440: [[
1.1 deraadt 441: /* Special action meaning "start processing a new file". */
1.13 tedu 442: #define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG )
443: ]])
1.1 deraadt 444:
1.13 tedu 445: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
446: [[
1.1 deraadt 447: #define YY_END_OF_BUFFER_CHAR 0
1.13 tedu 448: ]])
1.1 deraadt 449:
450: /* Size of default input buffer. */
1.13 tedu 451: #ifndef YY_BUF_SIZE
1.1 deraadt 452: #define YY_BUF_SIZE 16384
1.13 tedu 453: #endif
454:
455: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
456: [[
457: /* The state buf must be large enough to hold one state per character in the main buffer.
458: */
459: #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
460: ]])
461:
1.1 deraadt 462:
1.13 tedu 463: #ifndef YY_TYPEDEF_YY_BUFFER_STATE
464: #define YY_TYPEDEF_YY_BUFFER_STATE
1.1 deraadt 465: typedef struct yy_buffer_state *YY_BUFFER_STATE;
1.13 tedu 466: #endif
467:
468: #ifndef YY_TYPEDEF_YY_SIZE_T
469: #define YY_TYPEDEF_YY_SIZE_T
1.15 tedu 470: typedef size_t yy_size_t;
1.13 tedu 471: #endif
1.1 deraadt 472:
1.13 tedu 473: %if-not-reentrant
474: extern yy_size_t yyleng;
475: %endif
476:
477: %if-c-only
478: %if-not-reentrant
1.1 deraadt 479: extern FILE *yyin, *yyout;
1.13 tedu 480: %endif
481: %endif
1.1 deraadt 482:
1.13 tedu 483: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
484: [[
1.1 deraadt 485: #define EOB_ACT_CONTINUE_SCAN 0
486: #define EOB_ACT_END_OF_FILE 1
487: #define EOB_ACT_LAST_MATCH 2
1.13 tedu 488: ]])
1.1 deraadt 489:
1.13 tedu 490: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
491: [[
492: m4_ifdef( [[M4_YY_USE_LINENO]],
493: [[
494: /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
495: * access to the local variable yy_act. Since yyless() is a macro, it would break
496: * existing scanners that call yyless() from OUTSIDE yylex.
497: * One obvious solution it to make yy_act a global. I tried that, and saw
498: * a 5% performance hit in a non-yylineno scanner, because yy_act is
499: * normally declared as a register variable-- so it is not worth it.
500: */
501: #define YY_LESS_LINENO(n) \
502: do { \
503: int yyl;\
504: for ( yyl = n; yyl < yyleng; ++yyl )\
505: if ( yytext[yyl] == '\n' )\
506: --yylineno;\
507: }while(0)
508: #define YY_LINENO_REWIND_TO(dst) \
509: do {\
510: const char *p;\
511: for ( p = yy_cp-1; p >= (dst); --p)\
512: if ( *p == '\n' )\
513: --yylineno;\
514: }while(0)
515: ]],
516: [[
517: #define YY_LESS_LINENO(n)
518: #define YY_LINENO_REWIND_TO(ptr)
519: ]])
520: ]])
521:
522: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
523: [[
524: /* Return all but the first "n" matched characters back to the input stream. */
1.1 deraadt 525: #define yyless(n) \
526: do \
527: { \
528: /* Undo effects of setting up yytext. */ \
1.13 tedu 529: int yyless_macro_arg = (n); \
530: YY_LESS_LINENO(yyless_macro_arg);\
531: *yy_cp = YY_G(yy_hold_char); \
1.3 millert 532: YY_RESTORE_YY_MORE_OFFSET \
1.13 tedu 533: YY_G(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
1.1 deraadt 534: YY_DO_BEFORE_ACTION; /* set up yytext again */ \
535: } \
536: while ( 0 )
1.13 tedu 537: ]])
1.1 deraadt 538:
1.13 tedu 539: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
540: [[
541: #define unput(c) yyunput( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG )
542: ]])
1.1 deraadt 543:
1.13 tedu 544: #ifndef YY_STRUCT_YY_BUFFER_STATE
545: #define YY_STRUCT_YY_BUFFER_STATE
1.1 deraadt 546: struct yy_buffer_state
547: {
1.13 tedu 548: %if-c-only
1.1 deraadt 549: FILE *yy_input_file;
1.13 tedu 550: %endif
551:
552: %if-c++-only
1.7 espie 553: std::istream* yy_input_file;
1.13 tedu 554: %endif
555:
1.1 deraadt 556:
557: char *yy_ch_buf; /* input buffer */
558: char *yy_buf_pos; /* current position in input buffer */
559:
560: /* Size of input buffer in bytes, not including room for EOB
561: * characters.
562: */
563: yy_size_t yy_buf_size;
564:
565: /* Number of characters read into yy_ch_buf, not including EOB
566: * characters.
567: */
1.13 tedu 568: yy_size_t yy_n_chars;
1.1 deraadt 569:
570: /* Whether we "own" the buffer - i.e., we know we created it,
571: * and can realloc() it to grow it, and should free() it to
572: * delete it.
573: */
574: int yy_is_our_buffer;
575:
576: /* Whether this is an "interactive" input source; if so, and
577: * if we're using stdio for input, then we want to use getc()
578: * instead of fread(), to make sure we stop fetching input after
579: * each newline.
580: */
581: int yy_is_interactive;
582:
583: /* Whether we're considered to be at the beginning of a line.
584: * If so, '^' rules will be active on the next match, otherwise
585: * not.
586: */
587: int yy_at_bol;
588:
1.13 tedu 589: int yy_bs_lineno; /**< The line count. */
590: int yy_bs_column; /**< The column count. */
591:
592:
1.1 deraadt 593: /* Whether to try to fill the input buffer when we reach the
594: * end of it.
595: */
596: int yy_fill_buffer;
597:
598: int yy_buffer_status;
1.13 tedu 599: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
600: [[
1.1 deraadt 601: #define YY_BUFFER_NEW 0
602: #define YY_BUFFER_NORMAL 1
603: /* When an EOF's been seen but there's still some text to process
604: * then we mark the buffer as YY_EOF_PENDING, to indicate that we
605: * shouldn't try reading from the input source any more. We might
606: * still have a bunch of tokens to match, though, because of
607: * possible backing-up.
608: *
609: * When we actually see the EOF, we change the status to "new"
610: * (via yyrestart()), so that the user can continue scanning by
611: * just pointing yyin at a new input file.
612: */
613: #define YY_BUFFER_EOF_PENDING 2
1.13 tedu 614: ]])
1.1 deraadt 615: };
1.13 tedu 616: #endif /* !YY_STRUCT_YY_BUFFER_STATE */
1.1 deraadt 617:
1.13 tedu 618: %if-c-only Standard (non-C++) definition
619: %not-for-header
620: %if-not-reentrant
621:
622: /* Stack of input buffers. */
623: static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
624: static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
625: static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
626: %endif
627: %ok-for-header
628: %endif
1.1 deraadt 629:
1.13 tedu 630: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
631: [[
1.1 deraadt 632: /* We provide macros for accessing buffer states in case in the
633: * future we want to put the buffer states in a more general
634: * "scanner state".
1.13 tedu 635: *
636: * Returns the top of the stack, or NULL.
637: */
638: #define YY_CURRENT_BUFFER ( YY_G(yy_buffer_stack) \
639: ? YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] \
640: : NULL)
641: ]])
642:
643: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
644: [[
645: /* Same as previous macro, but useful when we know that the buffer stack is not
646: * NULL or when we need an lvalue. For internal use only.
1.1 deraadt 647: */
1.13 tedu 648: #define YY_CURRENT_BUFFER_LVALUE YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]
649: ]])
1.1 deraadt 650:
1.13 tedu 651: %if-c-only Standard (non-C++) definition
1.1 deraadt 652:
1.13 tedu 653: %if-not-reentrant
654: %not-for-header
1.1 deraadt 655: /* yy_hold_char holds the character lost when yytext is formed. */
656: static char yy_hold_char;
1.13 tedu 657: static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
658: yy_size_t yyleng;
1.1 deraadt 659:
660: /* Points to current character in buffer. */
661: static char *yy_c_buf_p = (char *) 0;
1.13 tedu 662: static int yy_init = 0; /* whether we need to initialize */
1.1 deraadt 663: static int yy_start = 0; /* start state number */
664:
665: /* Flag which is used to allow yywrap()'s to do buffer switches
666: * instead of setting up a fresh yyin. A bit of a hack ...
667: */
668: static int yy_did_buffer_switch_on_eof;
1.13 tedu 669: %ok-for-header
670: %endif
1.1 deraadt 671:
1.13 tedu 672: void yyrestart M4_YY_PARAMS( FILE *input_file M4_YY_PROTO_LAST_ARG );
673: void yy_switch_to_buffer M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );
674: YY_BUFFER_STATE yy_create_buffer M4_YY_PARAMS( FILE *file, int size M4_YY_PROTO_LAST_ARG );
675: void yy_delete_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );
676: void yy_flush_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );
677: void yypush_buffer_state M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );
678: void yypop_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
679:
680: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
681: [[
682: static void yyensure_buffer_stack M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
683: static void yy_load_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
684: static void yy_init_buffer M4_YY_PARAMS( YY_BUFFER_STATE b, FILE *file M4_YY_PROTO_LAST_ARG );
685: ]])
686:
687: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
688: [[
689: #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG)
690: ]])
691:
692: YY_BUFFER_STATE yy_scan_buffer M4_YY_PARAMS( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG );
693: YY_BUFFER_STATE yy_scan_string M4_YY_PARAMS( yyconst char *yy_str M4_YY_PROTO_LAST_ARG );
694: YY_BUFFER_STATE yy_scan_bytes M4_YY_PARAMS( yyconst char *bytes, yy_size_t len M4_YY_PROTO_LAST_ARG );
695:
696: %endif
697:
698: void *yyalloc M4_YY_PARAMS( yy_size_t M4_YY_PROTO_LAST_ARG );
699: void *yyrealloc M4_YY_PARAMS( void *, yy_size_t M4_YY_PROTO_LAST_ARG );
700: void yyfree M4_YY_PARAMS( void * M4_YY_PROTO_LAST_ARG );
1.1 deraadt 701:
1.13 tedu 702: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
703: [[
1.1 deraadt 704: #define yy_new_buffer yy_create_buffer
1.13 tedu 705: ]])
1.1 deraadt 706:
1.13 tedu 707: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
708: [[
1.1 deraadt 709: #define yy_set_interactive(is_interactive) \
710: { \
1.13 tedu 711: if ( ! YY_CURRENT_BUFFER ){ \
712: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \
713: YY_CURRENT_BUFFER_LVALUE = \
714: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
715: } \
716: YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
1.1 deraadt 717: }
1.13 tedu 718: ]])
1.1 deraadt 719:
1.13 tedu 720: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
721: [[
1.1 deraadt 722: #define yy_set_bol(at_bol) \
723: { \
1.13 tedu 724: if ( ! YY_CURRENT_BUFFER ){\
725: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \
726: YY_CURRENT_BUFFER_LVALUE = \
727: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
728: } \
729: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
730: }
731: ]])
732:
733: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
734: [[
735: #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
736: ]])
737:
738: %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
739:
740: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
741: [[
742: %% [1.5] DFA
743: ]])
744:
745: %if-c-only Standard (non-C++) definition
746:
747: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
748: [[
749: static yy_state_type yy_get_previous_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
750: static yy_state_type yy_try_NUL_trans M4_YY_PARAMS( yy_state_type current_state M4_YY_PROTO_LAST_ARG);
751: static int yy_get_next_buffer M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
752: static void yy_fatal_error M4_YY_PARAMS( yyconst char msg[] M4_YY_PROTO_LAST_ARG );
753: ]])
1.1 deraadt 754:
1.13 tedu 755: %endif
1.1 deraadt 756:
1.13 tedu 757: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
758: [[
1.1 deraadt 759: /* Done after the current pattern has been matched and before the
760: * corresponding action - sets up yytext.
761: */
762: #define YY_DO_BEFORE_ACTION \
1.13 tedu 763: YY_G(yytext_ptr) = yy_bp; \
764: %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \
765: YY_G(yy_hold_char) = *yy_cp; \
1.1 deraadt 766: *yy_cp = '\0'; \
1.13 tedu 767: %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \
768: YY_G(yy_c_buf_p) = yy_cp;
769: ]])
770:
771: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
772: [[
773: %% [4.0] data tables for the DFA and the user's section 1 definitions go here
774: ]])
775:
776: m4_ifdef( [[M4_YY_IN_HEADER]], [[#ifdef YY_HEADER_EXPORT_START_CONDITIONS]])
777: M4_YY_SC_DEFS
778: m4_ifdef( [[M4_YY_IN_HEADER]], [[#endif]])
779:
780: m4_ifdef( [[M4_YY_NO_UNISTD_H]],,
781: [[
782: #ifndef YY_NO_UNISTD_H
783: /* Special case for "unistd.h", since it is non-ANSI. We include it way
784: * down here because we want the user's section 1 to have been scanned first.
785: * The user has a chance to override it with an option.
786: */
787: %if-c-only
788: #include <unistd.h>
789: %endif
790: %if-c++-only
791: #include <unistd.h>
792: %endif
793: #endif
794: ]])
1.1 deraadt 795:
1.13 tedu 796: m4_ifdef( [[M4_EXTRA_TYPE_DEFS]],
797: [[
798: #define YY_EXTRA_TYPE M4_EXTRA_TYPE_DEFS
799: ]],
800: [[
801: #ifndef YY_EXTRA_TYPE
802: #define YY_EXTRA_TYPE void *
803: #endif
804: ]]
805: )
806:
807: %if-c-only Reentrant structure and macros (non-C++).
808: %if-reentrant
809:
810: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
811: [[
812: /* Holds the entire state of the reentrant scanner. */
813: struct yyguts_t
814: {
815:
816: /* User-defined. Not touched by flex. */
817: YY_EXTRA_TYPE yyextra_r;
818:
819: /* The rest are the same as the globals declared in the non-reentrant scanner. */
820: FILE *yyin_r, *yyout_r;
821: size_t yy_buffer_stack_top; /**< index of top of stack. */
822: size_t yy_buffer_stack_max; /**< capacity of stack. */
823: YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
824: char yy_hold_char;
825: yy_size_t yy_n_chars;
826: yy_size_t yyleng_r;
827: char *yy_c_buf_p;
828: int yy_init;
829: int yy_start;
830: int yy_did_buffer_switch_on_eof;
831: int yy_start_stack_ptr;
832: int yy_start_stack_depth;
833: int *yy_start_stack;
834: yy_state_type yy_last_accepting_state;
835: char* yy_last_accepting_cpos;
836:
837: int yylineno_r;
838: int yy_flex_debug_r;
839:
840: m4_ifdef( [[M4_YY_USES_REJECT]],
841: [[
842: yy_state_type *yy_state_buf;
843: yy_state_type *yy_state_ptr;
844: char *yy_full_match;
845: int yy_lp;
846:
847: /* These are only needed for trailing context rules,
848: * but there's no conditional variable for that yet. */
849: int yy_looking_for_trail_begin;
850: int yy_full_lp;
851: int *yy_full_state;
852: ]])
853:
854: m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
855: [[
856: char yytext_r[YYLMAX];
857: char *yytext_ptr;
858: int yy_more_offset;
859: int yy_prev_more_offset;
860: ]],
861: [[
862: char *yytext_r;
863: int yy_more_flag;
864: int yy_more_len;
865: ]])
866:
867: m4_ifdef( [[M4_YY_BISON_LVAL]],
868: [[
869: YYSTYPE * yylval_r;
870: ]])
871:
872: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
873: [[
874: YYLTYPE * yylloc_r;
875: ]])
876:
877: }; /* end struct yyguts_t */
878: ]])
879:
880:
881: %if-c-only
882: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
883: [[
884: static int yy_init_globals M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
885: ]])
886: %endif
887:
888: %if-reentrant
889:
890: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
891: [[
892: m4_ifdef( [[M4_YY_BISON_LVAL]],
893: [[
894: /* This must go here because YYSTYPE and YYLTYPE are included
895: * from bison output in section 1.*/
896: # define yylval YY_G(yylval_r)
897: ]])
898:
899: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
900: [[
901: # define yylloc YY_G(yylloc_r)
902: ]])
903: ]])
904:
905: int yylex_init M4_YY_PARAMS(yyscan_t* scanner);
906:
907: int yylex_init_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
908:
909: %endif
910:
911: %endif End reentrant structures and macros.
912:
913: /* Accessor methods to globals.
914: These are made visible to non-reentrant scanners for convenience. */
915:
916: m4_ifdef( [[M4_YY_NO_DESTROY]],,
917: [[
918: int yylex_destroy M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
919: ]])
920:
921: m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
922: [[
923: int yyget_debug M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
924: ]])
925:
926: m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
927: [[
928: void yyset_debug M4_YY_PARAMS( int debug_flag M4_YY_PROTO_LAST_ARG );
929: ]])
930:
931: m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
932: [[
933: YY_EXTRA_TYPE yyget_extra M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
934: ]])
935:
936: m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
937: [[
938: void yyset_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG );
939: ]])
940:
941: m4_ifdef( [[M4_YY_NO_GET_IN]],,
942: [[
943: FILE *yyget_in M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
944: ]])
945:
946: m4_ifdef( [[M4_YY_NO_SET_IN]],,
947: [[
948: void yyset_in M4_YY_PARAMS( FILE * in_str M4_YY_PROTO_LAST_ARG );
949: ]])
950:
951: m4_ifdef( [[M4_YY_NO_GET_OUT]],,
952: [[
953: FILE *yyget_out M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
954: ]])
955:
956: m4_ifdef( [[M4_YY_NO_SET_OUT]],,
957: [[
958: void yyset_out M4_YY_PARAMS( FILE * out_str M4_YY_PROTO_LAST_ARG );
959: ]])
960:
961: m4_ifdef( [[M4_YY_NO_GET_LENG]],,
962: [[
963: yy_size_t yyget_leng M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
964: ]])
965:
966: m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
967: [[
968: char *yyget_text M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
969: ]])
970:
971: m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
972: [[
973: int yyget_lineno M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
974: ]])
975:
976: m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
977: [[
978: void yyset_lineno M4_YY_PARAMS( int line_number M4_YY_PROTO_LAST_ARG );
979: ]])
980:
981: m4_ifdef( [[M4_YY_REENTRANT]],
982: [[
983: m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
984: [[
985: int yyget_column M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
986: ]])
987: ]])
988:
989: m4_ifdef( [[M4_YY_REENTRANT]],
990: [[
991: m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
992: [[
993: void yyset_column M4_YY_PARAMS( int column_no M4_YY_PROTO_LAST_ARG );
994: ]])
995: ]])
996:
997: %if-bison-bridge
998: m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
999: [[
1000: YYSTYPE * yyget_lval M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1001: ]])
1002:
1003: void yyset_lval M4_YY_PARAMS( YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG );
1004:
1005: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
1006: [[
1007: m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
1008: [[
1009: YYLTYPE *yyget_lloc M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1010: ]])
1011:
1012: m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
1013: [[
1014: void yyset_lloc M4_YY_PARAMS( YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG );
1015: ]])
1016: ]])
1017: %endif
1.1 deraadt 1018:
1019: /* Macros after this point can all be overridden by user definitions in
1020: * section 1.
1021: */
1022:
1023: #ifndef YY_SKIP_YYWRAP
1024: #ifdef __cplusplus
1.13 tedu 1025: extern "C" int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1.1 deraadt 1026: #else
1.13 tedu 1027: extern int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1.1 deraadt 1028: #endif
1029: #endif
1030:
1.13 tedu 1031: %not-for-header
1032: m4_ifdef( [[M4_YY_NO_UNPUT]],,
1033: [[
1034: static void yyunput M4_YY_PARAMS( int c, char *buf_ptr M4_YY_PROTO_LAST_ARG);
1035: ]])
1036: %ok-for-header
1037: %endif
1.1 deraadt 1038:
1039: #ifndef yytext_ptr
1.13 tedu 1040: static void yy_flex_strncpy M4_YY_PARAMS( char *, yyconst char *, int M4_YY_PROTO_LAST_ARG);
1.1 deraadt 1041: #endif
1042:
1.3 millert 1043: #ifdef YY_NEED_STRLEN
1.13 tedu 1044: static int yy_flex_strlen M4_YY_PARAMS( yyconst char * M4_YY_PROTO_LAST_ARG);
1.3 millert 1045: #endif
1046:
1.1 deraadt 1047: #ifndef YY_NO_INPUT
1.13 tedu 1048: %if-c-only Standard (non-C++) definition
1049: %not-for-header
1.1 deraadt 1050: #ifdef __cplusplus
1.13 tedu 1051: static int yyinput M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1.1 deraadt 1052: #else
1.13 tedu 1053: static int input M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1.1 deraadt 1054: #endif
1.13 tedu 1055: %ok-for-header
1056: %endif
1.1 deraadt 1057: #endif
1058:
1059:
1.13 tedu 1060: %if-c-only
1061: %# TODO: This is messy.
1062: m4_ifdef( [[M4_YY_STACK_USED]],
1063: [[
1064:
1065: m4_ifdef( [[M4_YY_NOT_REENTRANT]],
1066: [[
1067: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1068: [[
1069: static int yy_start_stack_ptr = 0;
1070: static int yy_start_stack_depth = 0;
1071: static int *yy_start_stack = NULL;
1072: ]])
1073: ]])
1074:
1075: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1076: [[
1077: m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
1078: [[
1079: static void yy_push_state M4_YY_PARAMS( int new_state M4_YY_PROTO_LAST_ARG);
1080: ]])
1081: m4_ifdef( [[M4_YY_NO_POP_STATE]],,
1082: [[
1083: static void yy_pop_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1084: ]])
1085: m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
1086: [[
1087: static int yy_top_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
1088: ]])
1089: ]])
1090:
1091: ]],
1092: [[
1093: m4_define( [[M4_YY_NO_PUSH_STATE]])
1094: m4_define( [[M4_YY_NO_POP_STATE]])
1095: m4_define( [[M4_YY_NO_TOP_STATE]])
1096: ]])
1097: %endif
1.1 deraadt 1098:
1099: /* Amount of stuff to slurp up with each read. */
1100: #ifndef YY_READ_BUF_SIZE
1101: #define YY_READ_BUF_SIZE 8192
1102: #endif
1103:
1.13 tedu 1104: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1105: [[
1.1 deraadt 1106: /* Copy whatever the last rule matched to the standard output. */
1107: #ifndef ECHO
1.13 tedu 1108: %if-c-only Standard (non-C++) definition
1.1 deraadt 1109: /* This used to be an fputs(), but since the string might contain NUL's,
1110: * we now use fwrite().
1111: */
1.13 tedu 1112: #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1113: %endif
1114: %if-c++-only C++ definition
1.1 deraadt 1115: #define ECHO LexerOutput( yytext, yyleng )
1.13 tedu 1116: %endif
1.1 deraadt 1117: #endif
1.13 tedu 1118: ]])
1.1 deraadt 1119:
1.13 tedu 1120: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1121: [[
1.1 deraadt 1122: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1123: * is returned in "result".
1124: */
1125: #ifndef YY_INPUT
1126: #define YY_INPUT(buf,result,max_size) \
1.13 tedu 1127: %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \
1128: \
1129: %if-c++-only C++ definition \
1.1 deraadt 1130: if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
1131: YY_FATAL_ERROR( "input in flex scanner failed" );
1.13 tedu 1132: %endif
1133:
1.1 deraadt 1134: #endif
1.13 tedu 1135: ]])
1.1 deraadt 1136:
1.13 tedu 1137: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1138: [[
1.1 deraadt 1139: /* No semi-colon after return; correct usage is to write "yyterminate();" -
1140: * we don't want an extra ';' after the "return" because that will cause
1141: * some compilers to complain about unreachable statements.
1142: */
1143: #ifndef yyterminate
1144: #define yyterminate() return YY_NULL
1145: #endif
1.13 tedu 1146: ]])
1.1 deraadt 1147:
1148: /* Number of entries by which start-condition stack grows. */
1149: #ifndef YY_START_STACK_INCR
1150: #define YY_START_STACK_INCR 25
1151: #endif
1152:
1.13 tedu 1153: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1154: [[
1.1 deraadt 1155: /* Report a fatal error. */
1156: #ifndef YY_FATAL_ERROR
1.13 tedu 1157: %if-c-only
1158: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg M4_YY_CALL_LAST_ARG)
1159: %endif
1160: %if-c++-only
1.1 deraadt 1161: #define YY_FATAL_ERROR(msg) LexerError( msg )
1.13 tedu 1162: %endif
1.1 deraadt 1163: #endif
1.13 tedu 1164: ]])
1165:
1166: %if-tables-serialization structures and prototypes
1167: m4preproc_include(`tables_shared.h')
1168:
1169: /* Load the DFA tables from the given stream. */
1170: int yytables_fload M4_YY_PARAMS(FILE * fp M4_YY_PROTO_LAST_ARG);
1171:
1172: /* Unload the tables from memory. */
1173: int yytables_destroy M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG);
1174: %not-for-header
1175:
1176: /** Describes a mapping from a serialized table id to its deserialized state in
1177: * this scanner. This is the bridge between our "generic" deserialization code
1178: * and the specifics of this scanner.
1179: */
1180: struct yytbl_dmap {
1181: enum yytbl_id dm_id;/**< table identifier */
1182: void **dm_arr; /**< address of pointer to store the deserialized table. */
1183: size_t dm_sz; /**< local sizeof() each element in table. */
1184: };
1185:
1186: /** A {0,0,0}-terminated list of structs, forming the map */
1187: static struct yytbl_dmap yydmap[] =
1188: {
1189: %tables-yydmap generated elements
1190: {0,0,0}
1191: };
1192:
1193: /** A tables-reader object to maintain some state in the read. */
1194: struct yytbl_reader {
1195: FILE * fp; /**< input stream */
1196: flex_uint32_t bread; /**< bytes read since beginning of current tableset */
1197: };
1198:
1199: %endif
1200: /* end tables serialization structures and prototypes */
1201:
1202: %ok-for-header
1.1 deraadt 1203:
1204: /* Default declaration of generated scanner - a define so the user can
1205: * easily add parameters.
1206: */
1207: #ifndef YY_DECL
1.13 tedu 1208: #define YY_DECL_IS_OURS 1
1209: %if-c-only Standard (non-C++) definition
1210:
1211:
1212: m4_define( [[M4_YY_LEX_PROTO]], [[M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG)]])
1213: m4_define( [[M4_YY_LEX_DECLARATION]], [[YYFARGS0(void)]])
1214:
1215: m4_ifdef( [[M4_YY_BISON_LVAL]],
1216: [[
1217: m4_dnl The bison pure parser is used. Redefine yylex to
1218: m4_dnl accept the lval parameter.
1219:
1220: m4_define( [[M4_YY_LEX_PROTO]], [[\]]
1221: [[M4_YY_PARAMS(YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG)]])
1222: m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
1223: [[YYFARGS1(YYSTYPE *,yylval_param)]])
1224: ]])
1225:
1226: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
1227: [[
1228: m4_dnl Locations are used. yylex should also accept the ylloc parameter.
1229:
1230: m4_define( [[M4_YY_LEX_PROTO]], [[\]]
1231: [[M4_YY_PARAMS(YYSTYPE * yylval_param, YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG)]])
1232: m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
1233: [[YYFARGS2(YYSTYPE *,yylval_param, YYLTYPE *,yylloc_param)]])
1234: ]])
1235:
1236: extern int yylex M4_YY_LEX_PROTO;
1237:
1238: #define YY_DECL int yylex M4_YY_LEX_DECLARATION
1239: %endif
1240: %if-c++-only C++ definition
1.1 deraadt 1241: #define YY_DECL int yyFlexLexer::yylex()
1.13 tedu 1242: %endif
1243: #endif /* !YY_DECL */
1.1 deraadt 1244:
1.13 tedu 1245: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1246: [[
1.1 deraadt 1247: /* Code executed at the beginning of each rule, after yytext and yyleng
1248: * have been set up.
1249: */
1250: #ifndef YY_USER_ACTION
1251: #define YY_USER_ACTION
1252: #endif
1.13 tedu 1253: ]])
1.1 deraadt 1254:
1.13 tedu 1255: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1256: [[
1.1 deraadt 1257: /* Code executed at the end of each rule. */
1258: #ifndef YY_BREAK
1259: #define YY_BREAK break;
1260: #endif
1.13 tedu 1261: ]])
1.1 deraadt 1262:
1.13 tedu 1263: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1264: [[
1265: %% [6.0] YY_RULE_SETUP definition goes here
1266: ]])
1.1 deraadt 1267:
1.13 tedu 1268: %not-for-header
1269: /** The main scanner function which does all the work.
1270: */
1.1 deraadt 1271: YY_DECL
1.13 tedu 1272: {
1273: yy_state_type yy_current_state;
1274: char *yy_cp, *yy_bp;
1275: int yy_act;
1276: M4_YY_DECL_GUTS_VAR();
1277:
1278: m4_ifdef( [[M4_YY_NOT_REENTRANT]],
1279: [[
1280: m4_ifdef( [[M4_YY_BISON_LVAL]],
1281: [[
1282: YYSTYPE * yylval;
1283: ]])
1284: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
1285: [[
1286: YYLTYPE * yylloc;
1287: ]])
1288: ]])
1289:
1290: m4_ifdef( [[M4_YY_BISON_LVAL]],
1291: [[
1292: yylval = yylval_param;
1293: ]])
1294:
1295: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
1296: [[
1297: yylloc = yylloc_param;
1298: ]])
1.1 deraadt 1299:
1.13 tedu 1300: if ( !YY_G(yy_init) )
1.1 deraadt 1301: {
1.13 tedu 1302: YY_G(yy_init) = 1;
1.1 deraadt 1303:
1304: #ifdef YY_USER_INIT
1305: YY_USER_INIT;
1306: #endif
1307:
1.13 tedu 1308: m4_ifdef( [[M4_YY_USES_REJECT]],
1309: [[
1310: /* Create the reject buffer large enough to save one state per allowed character. */
1.17 deraadt 1311: if ( ! YY_G(yy_state_buf) )
1312: YY_G(yy_state_buf) = (yy_state_type *)
1313: yyalloc(YY_STATE_BUF_SIZE M4_YY_CALL_LAST_ARG);
1314: if ( ! YY_G(yy_state_buf) )
1315: YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1.13 tedu 1316: ]])
1317:
1318: if ( ! YY_G(yy_start) )
1319: YY_G(yy_start) = 1; /* first start state */
1.1 deraadt 1320:
1.17 deraadt 1321: if ( ! yyin ) {
1.13 tedu 1322: %if-c-only
1.1 deraadt 1323: yyin = stdin;
1.13 tedu 1324: %endif
1325: %if-c++-only
1326: yyin = & std::cin;
1327: %endif
1.17 deraadt 1328: }
1.1 deraadt 1329:
1.17 deraadt 1330: if ( ! yyout ) {
1.13 tedu 1331: %if-c-only
1.1 deraadt 1332: yyout = stdout;
1.13 tedu 1333: %endif
1334: %if-c++-only
1335: yyout = & std::cout;
1336: %endif
1.17 deraadt 1337: }
1.13 tedu 1338:
1339: if ( ! YY_CURRENT_BUFFER ) {
1340: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
1341: YY_CURRENT_BUFFER_LVALUE =
1342: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
1343: }
1.1 deraadt 1344:
1.13 tedu 1345: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
1.17 deraadt 1346: }
1.1 deraadt 1347:
1.13 tedu 1348: {
1349: %% [7.0] user's declarations go here
1350:
1.1 deraadt 1351: while ( 1 ) /* loops until end-of-file is reached */
1352: {
1.13 tedu 1353: %% [8.0] yymore()-related code goes here
1354: yy_cp = YY_G(yy_c_buf_p);
1.1 deraadt 1355:
1356: /* Support of yytext. */
1.13 tedu 1357: *yy_cp = YY_G(yy_hold_char);
1.1 deraadt 1358:
1359: /* yy_bp points to the position in yy_ch_buf of the start of
1360: * the current run.
1361: */
1362: yy_bp = yy_cp;
1363:
1.13 tedu 1364: %% [9.0] code to set up and find next match goes here
1.1 deraadt 1365:
1366: yy_find_action:
1.13 tedu 1367: %% [10.0] code to find the action number goes here
1.1 deraadt 1368:
1369: YY_DO_BEFORE_ACTION;
1370:
1.13 tedu 1371: %% [11.0] code for yylineno update goes here
1.1 deraadt 1372:
1373: do_action: /* This label is used only to access EOF actions. */
1374:
1.13 tedu 1375: %% [12.0] debug code goes here
1.1 deraadt 1376:
1377: switch ( yy_act )
1378: { /* beginning of action switch */
1.13 tedu 1379: %% [13.0] actions go here
1.1 deraadt 1380:
1381: case YY_END_OF_BUFFER:
1382: {
1383: /* Amount of text matched not including the EOB char. */
1.13 tedu 1384: int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;
1.1 deraadt 1385:
1386: /* Undo the effects of YY_DO_BEFORE_ACTION. */
1.13 tedu 1387: *yy_cp = YY_G(yy_hold_char);
1.3 millert 1388: YY_RESTORE_YY_MORE_OFFSET
1.1 deraadt 1389:
1.13 tedu 1390: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1.1 deraadt 1391: {
1392: /* We're scanning a new file or input source. It's
1393: * possible that this happened because the user
1394: * just pointed yyin at a new source and called
1395: * yylex(). If so, then we have to assure
1.13 tedu 1396: * consistency between YY_CURRENT_BUFFER and our
1.1 deraadt 1397: * globals. Here is the right place to do so, because
1398: * this is the first action (other than possibly a
1399: * back-up) that will match for the new input source.
1400: */
1.13 tedu 1401: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1402: YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1403: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1.1 deraadt 1404: }
1405:
1406: /* Note that here we test for yy_c_buf_p "<=" to the position
1407: * of the first EOB in the buffer, since yy_c_buf_p will
1408: * already have been incremented past the NUL character
1409: * (since all states make transitions on EOB to the
1410: * end-of-buffer state). Contrast this with the test
1411: * in input().
1412: */
1.13 tedu 1413: if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
1.1 deraadt 1414: { /* This was really a NUL. */
1415: yy_state_type yy_next_state;
1416:
1.13 tedu 1417: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;
1.1 deraadt 1418:
1.13 tedu 1419: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1420:
1421: /* Okay, we're now positioned to make the NUL
1422: * transition. We couldn't have
1423: * yy_get_previous_state() go ahead and do it
1424: * for us because it doesn't know how to deal
1425: * with the possibility of jamming (and we don't
1426: * want to build jamming into it because then it
1427: * will run more slowly).
1428: */
1429:
1.13 tedu 1430: yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG);
1.1 deraadt 1431:
1.13 tedu 1432: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1433:
1434: if ( yy_next_state )
1435: {
1436: /* Consume the NUL. */
1.13 tedu 1437: yy_cp = ++YY_G(yy_c_buf_p);
1.1 deraadt 1438: yy_current_state = yy_next_state;
1439: goto yy_match;
1440: }
1441:
1442: else
1443: {
1.13 tedu 1444: %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here
1.1 deraadt 1445: goto yy_find_action;
1446: }
1447: }
1448:
1.13 tedu 1449: else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1450: {
1451: case EOB_ACT_END_OF_FILE:
1452: {
1.13 tedu 1453: YY_G(yy_did_buffer_switch_on_eof) = 0;
1.1 deraadt 1454:
1.13 tedu 1455: if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1456: {
1457: /* Note: because we've taken care in
1458: * yy_get_next_buffer() to have set up
1459: * yytext, we can now set up
1460: * yy_c_buf_p so that if some total
1461: * hoser (like flex itself) wants to
1462: * call the scanner after we return the
1463: * YY_NULL, it'll still work - another
1464: * YY_NULL will get returned.
1465: */
1.13 tedu 1466: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1467:
1468: yy_act = YY_STATE_EOF(YY_START);
1469: goto do_action;
1470: }
1471:
1472: else
1473: {
1.13 tedu 1474: if ( ! YY_G(yy_did_buffer_switch_on_eof) )
1.1 deraadt 1475: YY_NEW_FILE;
1476: }
1477: break;
1478: }
1479:
1480: case EOB_ACT_CONTINUE_SCAN:
1.13 tedu 1481: YY_G(yy_c_buf_p) =
1482: YY_G(yytext_ptr) + yy_amount_of_matched_text;
1.1 deraadt 1483:
1.13 tedu 1484: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1485:
1.13 tedu 1486: yy_cp = YY_G(yy_c_buf_p);
1487: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1488: goto yy_match;
1489:
1490: case EOB_ACT_LAST_MATCH:
1.13 tedu 1491: YY_G(yy_c_buf_p) =
1492: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];
1.1 deraadt 1493:
1.13 tedu 1494: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1495:
1.13 tedu 1496: yy_cp = YY_G(yy_c_buf_p);
1497: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1498: goto yy_find_action;
1499: }
1500: break;
1501: }
1502:
1503: default:
1504: YY_FATAL_ERROR(
1505: "fatal flex scanner internal error--no action found" );
1506: } /* end of action switch */
1507: } /* end of scanning one token */
1.13 tedu 1508: } /* end of user's declarations */
1509: } /* end of yylex */
1510: %ok-for-header
1511:
1512: %if-c++-only
1513: %not-for-header
1514: /* The contents of this function are C++ specific, so the YY_G macro is not used.
1515: */
1.7 espie 1516: yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1.13 tedu 1517: {
1.1 deraadt 1518: yyin = arg_yyin;
1519: yyout = arg_yyout;
1520: yy_c_buf_p = 0;
1.13 tedu 1521: yy_init = 0;
1.1 deraadt 1522: yy_start = 0;
1523: yy_flex_debug = 0;
1524: yylineno = 1; // this will only get updated if %option yylineno
1525:
1526: yy_did_buffer_switch_on_eof = 0;
1527:
1528: yy_looking_for_trail_begin = 0;
1529: yy_more_flag = 0;
1530: yy_more_len = 0;
1.3 millert 1531: yy_more_offset = yy_prev_more_offset = 0;
1.1 deraadt 1532:
1533: yy_start_stack_ptr = yy_start_stack_depth = 0;
1.13 tedu 1534: yy_start_stack = NULL;
1.1 deraadt 1535:
1.13 tedu 1536: yy_buffer_stack = 0;
1537: yy_buffer_stack_top = 0;
1538: yy_buffer_stack_max = 0;
1.1 deraadt 1539:
1.13 tedu 1540:
1541: m4_ifdef( [[M4_YY_USES_REJECT]],
1542: [[
1543: yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE];
1544: ]],
1545: [[
1.1 deraadt 1546: yy_state_buf = 0;
1.13 tedu 1547: ]])
1548: }
1.1 deraadt 1549:
1.13 tedu 1550: /* The contents of this function are C++ specific, so the YY_G macro is not used.
1551: */
1.1 deraadt 1552: yyFlexLexer::~yyFlexLexer()
1.13 tedu 1553: {
1554: delete [] yy_state_buf;
1555: yyfree( yy_start_stack M4_YY_CALL_LAST_ARG );
1556: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
1557: yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG );
1558: }
1.1 deraadt 1559:
1.13 tedu 1560: /* The contents of this function are C++ specific, so the YY_G macro is not used.
1561: */
1.7 espie 1562: void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1.13 tedu 1563: {
1.1 deraadt 1564: if ( new_in )
1565: {
1.13 tedu 1566: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
1567: yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG);
1.1 deraadt 1568: }
1569:
1570: if ( new_out )
1571: yyout = new_out;
1.13 tedu 1572: }
1.1 deraadt 1573:
1574: #ifdef YY_INTERACTIVE
1575: int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
1576: #else
1577: int yyFlexLexer::LexerInput( char* buf, int max_size )
1578: #endif
1.13 tedu 1579: {
1.1 deraadt 1580: if ( yyin->eof() || yyin->fail() )
1581: return 0;
1582:
1583: #ifdef YY_INTERACTIVE
1584: yyin->get( buf[0] );
1585:
1586: if ( yyin->eof() )
1587: return 0;
1588:
1589: if ( yyin->bad() )
1590: return -1;
1591:
1592: return 1;
1593:
1594: #else
1595: (void) yyin->read( buf, max_size );
1596:
1597: if ( yyin->bad() )
1598: return -1;
1599: else
1600: return yyin->gcount();
1601: #endif
1.13 tedu 1602: }
1.1 deraadt 1603:
1604: void yyFlexLexer::LexerOutput( const char* buf, int size )
1.13 tedu 1605: {
1.1 deraadt 1606: (void) yyout->write( buf, size );
1.13 tedu 1607: }
1608: %ok-for-header
1609: %endif
1.1 deraadt 1610:
1.13 tedu 1611: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
1612: [[
1.1 deraadt 1613: /* yy_get_next_buffer - try to read in a new buffer
1614: *
1615: * Returns a code representing an action:
1616: * EOB_ACT_LAST_MATCH -
1617: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1618: * EOB_ACT_END_OF_FILE - end of file
1619: */
1.13 tedu 1620: %if-c-only
1621: static int yy_get_next_buffer YYFARGS0(void)
1622: %endif
1623: %if-c++-only
1624: int yyFlexLexer::yy_get_next_buffer()
1625: %endif
1626: {
1627: M4_YY_DECL_GUTS_VAR();
1628: char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1629: char *source = YY_G(yytext_ptr);
1630: int number_to_move, i;
1.1 deraadt 1631: int ret_val;
1632:
1.13 tedu 1633: if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] )
1.1 deraadt 1634: YY_FATAL_ERROR(
1635: "fatal flex scanner internal error--end of buffer missed" );
1636:
1.13 tedu 1637: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1.1 deraadt 1638: { /* Don't try to fill the buffer, so this is an EOF. */
1.13 tedu 1639: if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
1.1 deraadt 1640: {
1.3 millert 1641: /* We matched a single character, the EOB, so
1.1 deraadt 1642: * treat this as a final EOF.
1643: */
1644: return EOB_ACT_END_OF_FILE;
1645: }
1646:
1647: else
1648: {
1649: /* We matched some text prior to the EOB, first
1650: * process it.
1651: */
1652: return EOB_ACT_LAST_MATCH;
1653: }
1654: }
1655:
1656: /* Try to read more data. */
1657:
1658: /* First move last chars to start of buffer. */
1.13 tedu 1659: number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;
1.1 deraadt 1660:
1661: for ( i = 0; i < number_to_move; ++i )
1662: *(dest++) = *(source++);
1663:
1.13 tedu 1664: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1.1 deraadt 1665: /* don't do the read, it's not guaranteed to return an EOF,
1666: * just force an EOF
1667: */
1.13 tedu 1668: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0;
1.1 deraadt 1669:
1670: else
1671: {
1.13 tedu 1672: yy_size_t num_to_read =
1673: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1.1 deraadt 1674:
1675: while ( num_to_read <= 0 )
1676: { /* Not enough room in the buffer - grow it. */
1.13 tedu 1677: m4_ifdef( [[M4_YY_USES_REJECT]],
1678: [[
1.1 deraadt 1679: YY_FATAL_ERROR(
1680: "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1.13 tedu 1681: ]],
1682: [[
1.1 deraadt 1683: /* just a shorter name for the current buffer */
1.13 tedu 1684: YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1.1 deraadt 1685:
1686: int yy_c_buf_p_offset =
1.13 tedu 1687: (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
1.1 deraadt 1688:
1689: if ( b->yy_is_our_buffer )
1690: {
1.13 tedu 1691: yy_size_t new_size = b->yy_buf_size * 2;
1.1 deraadt 1692:
1693: if ( new_size <= 0 )
1694: b->yy_buf_size += b->yy_buf_size / 8;
1695: else
1696: b->yy_buf_size *= 2;
1697:
1698: b->yy_ch_buf = (char *)
1699: /* Include room in for 2 EOB chars. */
1.13 tedu 1700: yyrealloc( (void *) b->yy_ch_buf,
1701: b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
1.1 deraadt 1702: }
1703: else
1704: /* Can't grow it, we don't own it. */
1705: b->yy_ch_buf = 0;
1706:
1707: if ( ! b->yy_ch_buf )
1708: YY_FATAL_ERROR(
1709: "fatal error - scanner input buffer overflow" );
1710:
1.13 tedu 1711: YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1.1 deraadt 1712:
1.13 tedu 1713: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1.1 deraadt 1714: number_to_move - 1;
1.13 tedu 1715: ]])
1.1 deraadt 1716: }
1717:
1718: if ( num_to_read > YY_READ_BUF_SIZE )
1719: num_to_read = YY_READ_BUF_SIZE;
1720:
1721: /* Read in more data. */
1.13 tedu 1722: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1723: YY_G(yy_n_chars), num_to_read );
1.4 millert 1724:
1.13 tedu 1725: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
1.1 deraadt 1726: }
1727:
1.13 tedu 1728: if ( YY_G(yy_n_chars) == 0 )
1.1 deraadt 1729: {
1730: if ( number_to_move == YY_MORE_ADJ )
1731: {
1732: ret_val = EOB_ACT_END_OF_FILE;
1.13 tedu 1733: yyrestart( yyin M4_YY_CALL_LAST_ARG);
1.1 deraadt 1734: }
1735:
1736: else
1737: {
1738: ret_val = EOB_ACT_LAST_MATCH;
1.13 tedu 1739: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1.1 deraadt 1740: YY_BUFFER_EOF_PENDING;
1741: }
1742: }
1743:
1744: else
1745: ret_val = EOB_ACT_CONTINUE_SCAN;
1746:
1.13 tedu 1747: if ((yy_size_t) (YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1748: /* Extend the array by 50%, plus the number we really need. */
1749: yy_size_t new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);
1750: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1751: (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size M4_YY_CALL_LAST_ARG );
1752: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1753: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1.16 millert 1754: /* "- 2" to take care of EOB's */
1755: YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1.13 tedu 1756: }
1757:
1758: YY_G(yy_n_chars) += number_to_move;
1759: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1760: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1.1 deraadt 1761:
1.13 tedu 1762: YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1.1 deraadt 1763:
1764: return ret_val;
1.13 tedu 1765: }
1766: ]])
1.1 deraadt 1767:
1768: /* yy_get_previous_state - get the state just before the EOB char was reached */
1769:
1.13 tedu 1770: %if-c-only
1771: %not-for-header
1772: static yy_state_type yy_get_previous_state YYFARGS0(void)
1773: %endif
1774: %if-c++-only
1775: yy_state_type yyFlexLexer::yy_get_previous_state()
1776: %endif
1777: {
1778: yy_state_type yy_current_state;
1779: char *yy_cp;
1780: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1781:
1.13 tedu 1782: %% [15.0] code to get the start state into yy_current_state goes here
1.1 deraadt 1783:
1.13 tedu 1784: for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
1.1 deraadt 1785: {
1.13 tedu 1786: %% [16.0] code to find the next state goes here
1.1 deraadt 1787: }
1788:
1789: return yy_current_state;
1.13 tedu 1790: }
1.1 deraadt 1791:
1792:
1793: /* yy_try_NUL_trans - try to make a transition on the NUL character
1794: *
1795: * synopsis
1796: * next_state = yy_try_NUL_trans( current_state );
1797: */
1.13 tedu 1798: %if-c-only
1799: static yy_state_type yy_try_NUL_trans YYFARGS1( yy_state_type, yy_current_state)
1800: %endif
1801: %if-c++-only
1802: yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
1803: %endif
1804: {
1805: int yy_is_jam;
1806: M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */
1807: %% [17.0] code to find the next state, and perhaps do backing up, goes here
1.1 deraadt 1808:
1.18 ! millert 1809: M4_YY_NOOP_GUTS_VAR();
1.13 tedu 1810: return yy_is_jam ? 0 : yy_current_state;
1811: }
1.1 deraadt 1812:
1813:
1.13 tedu 1814: %if-c-only
1815: m4_ifdef( [[M4_YY_NO_UNPUT]],,
1816: [[
1817: static void yyunput YYFARGS2( int,c, char *,yy_bp)
1818: %endif
1819: %if-c++-only
1820: void yyFlexLexer::yyunput( int c, char* yy_bp)
1821: %endif
1822: {
1823: char *yy_cp;
1824: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1825:
1.13 tedu 1826: yy_cp = YY_G(yy_c_buf_p);
1.1 deraadt 1827:
1828: /* undo effects of setting up yytext */
1.13 tedu 1829: *yy_cp = YY_G(yy_hold_char);
1.1 deraadt 1830:
1.13 tedu 1831: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1.1 deraadt 1832: { /* need to shift things up to make room */
1833: /* +2 for EOB chars. */
1.13 tedu 1834: yy_size_t number_to_move = YY_G(yy_n_chars) + 2;
1835: char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1836: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1837: char *source =
1838: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1.1 deraadt 1839:
1.13 tedu 1840: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1.1 deraadt 1841: *--dest = *--source;
1842:
1843: yy_cp += (int) (dest - source);
1844: yy_bp += (int) (dest - source);
1.13 tedu 1845: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1846: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1.1 deraadt 1847:
1.13 tedu 1848: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1.1 deraadt 1849: YY_FATAL_ERROR( "flex scanner push-back overflow" );
1850: }
1851:
1852: *--yy_cp = (char) c;
1853:
1.13 tedu 1854: %% [18.0] update yylineno here
1855: m4_ifdef( [[M4_YY_USE_LINENO]],
1856: [[
1857: if ( c == '\n' ){
1858: --yylineno;
1859: }
1860: ]])
1861:
1862: YY_G(yytext_ptr) = yy_bp;
1863: YY_G(yy_hold_char) = *yy_cp;
1864: YY_G(yy_c_buf_p) = yy_cp;
1865: }
1866: %if-c-only
1867: ]])
1868: %endif
1.1 deraadt 1869:
1.13 tedu 1870: %if-c-only
1.11 millert 1871: #ifndef YY_NO_INPUT
1.1 deraadt 1872: #ifdef __cplusplus
1.13 tedu 1873: static int yyinput YYFARGS0(void)
1.1 deraadt 1874: #else
1.13 tedu 1875: static int input YYFARGS0(void)
1.1 deraadt 1876: #endif
1.13 tedu 1877:
1878: %endif
1879: %if-c++-only
1880: int yyFlexLexer::yyinput()
1881: %endif
1882: {
1.1 deraadt 1883: int c;
1.13 tedu 1884: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1885:
1.13 tedu 1886: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
1.1 deraadt 1887:
1.13 tedu 1888: if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1.1 deraadt 1889: {
1890: /* yy_c_buf_p now points to the character we want to return.
1891: * If this occurs *before* the EOB characters, then it's a
1892: * valid NUL; if not, then we've hit the end of the buffer.
1893: */
1.13 tedu 1894: if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
1.1 deraadt 1895: /* This was really a NUL. */
1.13 tedu 1896: *YY_G(yy_c_buf_p) = '\0';
1.1 deraadt 1897:
1898: else
1899: { /* need more input */
1.13 tedu 1900: yy_size_t offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
1901: ++YY_G(yy_c_buf_p);
1.1 deraadt 1902:
1.13 tedu 1903: switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1904: {
1.4 millert 1905: case EOB_ACT_LAST_MATCH:
1906: /* This happens because yy_g_n_b()
1907: * sees that we've accumulated a
1908: * token and flags that we need to
1909: * try matching the token before
1910: * proceeding. But for input(),
1911: * there's no matching to consider.
1912: * So convert the EOB_ACT_LAST_MATCH
1913: * to EOB_ACT_END_OF_FILE.
1914: */
1915:
1916: /* Reset buffer status. */
1.13 tedu 1917: yyrestart( yyin M4_YY_CALL_LAST_ARG);
1.4 millert 1918:
1.13 tedu 1919: /*FALLTHROUGH*/
1.4 millert 1920:
1.1 deraadt 1921: case EOB_ACT_END_OF_FILE:
1922: {
1.13 tedu 1923: if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1924: return EOF;
1925:
1.13 tedu 1926: if ( ! YY_G(yy_did_buffer_switch_on_eof) )
1.1 deraadt 1927: YY_NEW_FILE;
1928: #ifdef __cplusplus
1.13 tedu 1929: return yyinput(M4_YY_CALL_ONLY_ARG);
1.1 deraadt 1930: #else
1.13 tedu 1931: return input(M4_YY_CALL_ONLY_ARG);
1.1 deraadt 1932: #endif
1933: }
1934:
1935: case EOB_ACT_CONTINUE_SCAN:
1.13 tedu 1936: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
1.1 deraadt 1937: break;
1938: }
1939: }
1940: }
1941:
1.13 tedu 1942: c = *(unsigned char *) YY_G(yy_c_buf_p); /* cast for 8-bit char's */
1943: *YY_G(yy_c_buf_p) = '\0'; /* preserve yytext */
1944: YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);
1.1 deraadt 1945:
1.13 tedu 1946: %% [19.0] update BOL and yylineno
1.1 deraadt 1947:
1948: return c;
1.13 tedu 1949: }
1950: %if-c-only
1.11 millert 1951: #endif /* ifndef YY_NO_INPUT */
1.13 tedu 1952: %endif
1.1 deraadt 1953:
1.13 tedu 1954: /** Immediately switch to a different input stream.
1955: * @param input_file A readable stream.
1956: * M4_YY_DOC_PARAM
1957: * @note This function does not reset the start condition to @c INITIAL .
1958: */
1959: %if-c-only
1960: void yyrestart YYFARGS1( FILE *,input_file)
1961: %endif
1962: %if-c++-only
1963: void yyFlexLexer::yyrestart( std::istream* input_file )
1964: %endif
1965: {
1966: M4_YY_DECL_GUTS_VAR();
1967:
1968: if ( ! YY_CURRENT_BUFFER ){
1969: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
1970: YY_CURRENT_BUFFER_LVALUE =
1971: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
1972: }
1973:
1974: yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG);
1975: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
1976: }
1977:
1978: /** Switch to a different input buffer.
1979: * @param new_buffer The new input buffer.
1980: * M4_YY_DOC_PARAM
1981: */
1982: %if-c-only
1983: void yy_switch_to_buffer YYFARGS1( YY_BUFFER_STATE ,new_buffer)
1984: %endif
1985: %if-c++-only
1986: void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1987: %endif
1988: {
1989: M4_YY_DECL_GUTS_VAR();
1990:
1991: /* TODO. We should be able to replace this entire function body
1992: * with
1993: * yypop_buffer_state();
1994: * yypush_buffer_state(new_buffer);
1995: */
1996: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
1997: if ( YY_CURRENT_BUFFER == new_buffer )
1.1 deraadt 1998: return;
1999:
1.13 tedu 2000: if ( YY_CURRENT_BUFFER )
1.1 deraadt 2001: {
2002: /* Flush out information for old buffer. */
1.13 tedu 2003: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
2004: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
2005: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
1.1 deraadt 2006: }
2007:
1.13 tedu 2008: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2009: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 2010:
2011: /* We don't actually know whether we did this switch during
2012: * EOF (yywrap()) processing, but the only time this flag
2013: * is looked at is after yywrap() is called, so it's safe
2014: * to go ahead and always set it.
2015: */
1.13 tedu 2016: YY_G(yy_did_buffer_switch_on_eof) = 1;
2017: }
1.1 deraadt 2018:
2019:
1.13 tedu 2020: %if-c-only
2021: static void yy_load_buffer_state YYFARGS0(void)
2022: %endif
2023: %if-c++-only
2024: void yyFlexLexer::yy_load_buffer_state()
2025: %endif
2026: {
2027: M4_YY_DECL_GUTS_VAR();
2028: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2029: YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2030: yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2031: YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
2032: }
2033:
2034: /** Allocate and initialize an input buffer state.
2035: * @param file A readable stream.
2036: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2037: * M4_YY_DOC_PARAM
2038: * @return the allocated buffer state.
2039: */
2040: %if-c-only
2041: YY_BUFFER_STATE yy_create_buffer YYFARGS2( FILE *,file, int ,size)
2042: %endif
2043: %if-c++-only
2044: YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
2045: %endif
2046: {
1.1 deraadt 2047: YY_BUFFER_STATE b;
1.13 tedu 2048: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2049:
1.13 tedu 2050: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
1.1 deraadt 2051: if ( ! b )
2052: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2053:
2054: b->yy_buf_size = size;
2055:
2056: /* yy_ch_buf has to be 2 characters longer than the size given because
2057: * we need to put in 2 end-of-buffer characters.
2058: */
1.13 tedu 2059: b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
1.1 deraadt 2060: if ( ! b->yy_ch_buf )
2061: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2062:
2063: b->yy_is_our_buffer = 1;
2064:
1.13 tedu 2065: yy_init_buffer( b, file M4_YY_CALL_LAST_ARG);
1.1 deraadt 2066:
2067: return b;
1.13 tedu 2068: }
1.1 deraadt 2069:
1.13 tedu 2070: /** Destroy the buffer.
2071: * @param b a buffer created with yy_create_buffer()
2072: * M4_YY_DOC_PARAM
2073: */
2074: %if-c-only
2075: void yy_delete_buffer YYFARGS1( YY_BUFFER_STATE ,b)
2076: %endif
2077: %if-c++-only
2078: void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
2079: %endif
2080: {
2081: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2082:
2083: if ( ! b )
2084: return;
2085:
1.13 tedu 2086: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2087: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1.1 deraadt 2088:
2089: if ( b->yy_is_our_buffer )
1.13 tedu 2090: yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG );
1.1 deraadt 2091:
1.13 tedu 2092: yyfree( (void *) b M4_YY_CALL_LAST_ARG );
2093: }
1.1 deraadt 2094:
2095:
1.13 tedu 2096: /* Initializes or reinitializes a buffer.
2097: * This function is sometimes called more than once on the same buffer,
2098: * such as during a yyrestart() or at EOF.
2099: */
2100: %if-c-only
2101: static void yy_init_buffer YYFARGS2( YY_BUFFER_STATE ,b, FILE *,file)
2102: %endif
2103: %if-c++-only
2104: void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
2105: %endif
1.1 deraadt 2106:
1.13 tedu 2107: {
1.6 millert 2108: int oerrno = errno;
1.13 tedu 2109: M4_YY_DECL_GUTS_VAR();
1.6 millert 2110:
1.13 tedu 2111: yy_flush_buffer( b M4_YY_CALL_LAST_ARG);
1.1 deraadt 2112:
2113: b->yy_input_file = file;
2114: b->yy_fill_buffer = 1;
2115:
1.13 tedu 2116: /* If b is the current buffer, then yy_init_buffer was _probably_
2117: * called from yyrestart() or through yy_get_next_buffer.
2118: * In that case, we don't want to reset the lineno or column.
2119: */
2120: if (b != YY_CURRENT_BUFFER){
2121: b->yy_bs_lineno = 1;
2122: b->yy_bs_column = 0;
2123: }
2124:
2125: %if-c-only
2126: m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]],
2127: [[
1.1 deraadt 2128: b->yy_is_interactive = 1;
1.13 tedu 2129: ]],
2130: [[
2131: m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],
2132: [[
2133: b->yy_is_interactive = 0;
2134: ]],
2135: [[
2136: b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2137: ]])
2138: ]])
2139: %endif
2140: %if-c++-only
1.1 deraadt 2141: b->yy_is_interactive = 0;
1.13 tedu 2142: %endif
1.6 millert 2143: errno = oerrno;
1.13 tedu 2144: }
1.1 deraadt 2145:
1.13 tedu 2146: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2147: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2148: * M4_YY_DOC_PARAM
2149: */
2150: %if-c-only
2151: void yy_flush_buffer YYFARGS1( YY_BUFFER_STATE ,b)
2152: %endif
2153: %if-c++-only
2154: void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
2155: %endif
2156: {
2157: M4_YY_DECL_GUTS_VAR();
1.4 millert 2158: if ( ! b )
2159: return;
2160:
1.1 deraadt 2161: b->yy_n_chars = 0;
2162:
2163: /* We always need two end-of-buffer characters. The first causes
2164: * a transition to the end-of-buffer state. The second causes
2165: * a jam in that state.
2166: */
2167: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2168: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2169:
2170: b->yy_buf_pos = &b->yy_ch_buf[0];
2171:
2172: b->yy_at_bol = 1;
2173: b->yy_buffer_status = YY_BUFFER_NEW;
2174:
1.13 tedu 2175: if ( b == YY_CURRENT_BUFFER )
2176: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
2177: }
2178:
2179: %if-c-or-c++
2180: /** Pushes the new state onto the stack. The new state becomes
2181: * the current state. This function will allocate the stack
2182: * if necessary.
2183: * @param new_buffer The new state.
2184: * M4_YY_DOC_PARAM
2185: */
2186: %if-c-only
2187: void yypush_buffer_state YYFARGS1(YY_BUFFER_STATE,new_buffer)
2188: %endif
2189: %if-c++-only
2190: void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
2191: %endif
2192: {
2193: M4_YY_DECL_GUTS_VAR();
2194: if (new_buffer == NULL)
2195: return;
2196:
2197: yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG);
2198:
2199: /* This block is copied from yy_switch_to_buffer. */
2200: if ( YY_CURRENT_BUFFER )
2201: {
2202: /* Flush out information for old buffer. */
2203: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
2204: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
2205: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
2206: }
2207:
2208: /* Only push if top exists. Otherwise, replace top. */
2209: if (YY_CURRENT_BUFFER)
2210: YY_G(yy_buffer_stack_top)++;
2211: YY_CURRENT_BUFFER_LVALUE = new_buffer;
2212:
2213: /* copied from yy_switch_to_buffer. */
2214: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
2215: YY_G(yy_did_buffer_switch_on_eof) = 1;
2216: }
2217: %endif
2218:
2219:
2220: %if-c-or-c++
2221: /** Removes and deletes the top of the stack, if present.
2222: * The next element becomes the new top.
2223: * M4_YY_DOC_PARAM
2224: */
2225: %if-c-only
2226: void yypop_buffer_state YYFARGS0(void)
2227: %endif
2228: %if-c++-only
2229: void yyFlexLexer::yypop_buffer_state (void)
2230: %endif
2231: {
2232: M4_YY_DECL_GUTS_VAR();
2233: if (!YY_CURRENT_BUFFER)
2234: return;
2235:
2236: yy_delete_buffer(YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
2237: YY_CURRENT_BUFFER_LVALUE = NULL;
2238: if (YY_G(yy_buffer_stack_top) > 0)
2239: --YY_G(yy_buffer_stack_top);
2240:
2241: if (YY_CURRENT_BUFFER) {
2242: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
2243: YY_G(yy_did_buffer_switch_on_eof) = 1;
2244: }
2245: }
2246: %endif
2247:
2248:
2249: %if-c-or-c++
2250: /* Allocates the stack if it does not exist.
2251: * Guarantees space for at least one push.
2252: */
2253: %if-c-only
2254: static void yyensure_buffer_stack YYFARGS0(void)
2255: %endif
2256: %if-c++-only
2257: void yyFlexLexer::yyensure_buffer_stack(void)
2258: %endif
2259: {
2260: yy_size_t num_to_alloc;
2261: M4_YY_DECL_GUTS_VAR();
2262:
2263: if (!YY_G(yy_buffer_stack)) {
2264:
2265: /* First allocation is just for 2 elements, since we don't know if this
2266: * scanner will even need a stack. We use 2 instead of 1 to avoid an
2267: * immediate realloc on the next call.
2268: */
2269: num_to_alloc = 1;
2270: YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2271: (num_to_alloc * sizeof(struct yy_buffer_state*)
2272: M4_YY_CALL_LAST_ARG);
2273: if ( ! YY_G(yy_buffer_stack) )
2274: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2275:
2276:
2277: memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2278:
2279: YY_G(yy_buffer_stack_max) = num_to_alloc;
2280: YY_G(yy_buffer_stack_top) = 0;
2281: return;
1.1 deraadt 2282: }
2283:
1.13 tedu 2284: if (YY_G(yy_buffer_stack_top) >= (YY_G(yy_buffer_stack_max)) - 1){
1.1 deraadt 2285:
1.13 tedu 2286: /* Increase the buffer to prepare for a possible push. */
2287: int grow_size = 8 /* arbitrary grow size */;
2288:
2289: num_to_alloc = YY_G(yy_buffer_stack_max) + grow_size;
2290: YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2291: (YY_G(yy_buffer_stack),
2292: num_to_alloc * sizeof(struct yy_buffer_state*)
2293: M4_YY_CALL_LAST_ARG);
2294: if ( ! YY_G(yy_buffer_stack) )
2295: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2296:
2297: /* zero only the new slots.*/
2298: memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2299: YY_G(yy_buffer_stack_max) = num_to_alloc;
2300: }
2301: }
2302: %endif
2303:
2304:
2305:
2306:
2307: m4_ifdef( [[M4_YY_NO_SCAN_BUFFER]],,
2308: [[
2309: %if-c-only
2310: /** Setup the input buffer state to scan directly from a user-specified character buffer.
2311: * @param base the character buffer
2312: * @param size the size in bytes of the character buffer
2313: * M4_YY_DOC_PARAM
2314: * @return the newly allocated buffer state object.
2315: */
2316: YY_BUFFER_STATE yy_scan_buffer YYFARGS2( char *,base, yy_size_t ,size)
2317: {
1.1 deraadt 2318: YY_BUFFER_STATE b;
1.13 tedu 2319: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2320:
2321: if ( size < 2 ||
2322: base[size-2] != YY_END_OF_BUFFER_CHAR ||
2323: base[size-1] != YY_END_OF_BUFFER_CHAR )
2324: /* They forgot to leave room for the EOB's. */
2325: return 0;
2326:
1.13 tedu 2327: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
1.1 deraadt 2328: if ( ! b )
2329: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2330:
2331: b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2332: b->yy_buf_pos = b->yy_ch_buf = base;
2333: b->yy_is_our_buffer = 0;
2334: b->yy_input_file = 0;
2335: b->yy_n_chars = b->yy_buf_size;
2336: b->yy_is_interactive = 0;
2337: b->yy_at_bol = 1;
2338: b->yy_fill_buffer = 0;
2339: b->yy_buffer_status = YY_BUFFER_NEW;
2340:
1.13 tedu 2341: yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG );
1.1 deraadt 2342:
2343: return b;
1.13 tedu 2344: }
2345: %endif
2346: ]])
1.1 deraadt 2347:
2348:
1.13 tedu 2349: m4_ifdef( [[M4_YY_NO_SCAN_STRING]],,
2350: [[
2351: %if-c-only
2352: /** Setup the input buffer state to scan a string. The next call to yylex() will
2353: * scan from a @e copy of @a str.
2354: * @param yystr a NUL-terminated string to scan
2355: * M4_YY_DOC_PARAM
2356: * @return the newly allocated buffer state object.
2357: * @note If you want to scan bytes that may contain NUL values, then use
2358: * yy_scan_bytes() instead.
2359: */
2360: YY_BUFFER_STATE yy_scan_string YYFARGS1( yyconst char *, yystr)
2361: {
2362: m4_dnl M4_YY_DECL_GUTS_VAR();
2363:
2364: return yy_scan_bytes( yystr, strlen(yystr) M4_YY_CALL_LAST_ARG);
2365: }
2366: %endif
2367: ]])
2368:
2369:
2370: m4_ifdef( [[M4_YY_NO_SCAN_BYTES]],,
2371: [[
2372: %if-c-only
2373: /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2374: * scan from a @e copy of @a bytes.
2375: * @param yybytes the byte buffer to scan
2376: * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2377: * M4_YY_DOC_PARAM
2378: * @return the newly allocated buffer state object.
2379: */
2380: YY_BUFFER_STATE yy_scan_bytes YYFARGS2( yyconst char *,yybytes, yy_size_t ,_yybytes_len)
2381: {
1.1 deraadt 2382: YY_BUFFER_STATE b;
2383: char *buf;
2384: yy_size_t n;
1.13 tedu 2385: yy_size_t i;
2386: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2387:
2388: /* Get memory for full buffer, including space for trailing EOB's. */
1.13 tedu 2389: n = _yybytes_len + 2;
2390: buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG );
1.1 deraadt 2391: if ( ! buf )
2392: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2393:
1.13 tedu 2394: for ( i = 0; i < _yybytes_len; ++i )
2395: buf[i] = yybytes[i];
1.1 deraadt 2396:
1.13 tedu 2397: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1.1 deraadt 2398:
1.13 tedu 2399: b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG);
1.1 deraadt 2400: if ( ! b )
2401: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2402:
2403: /* It's okay to grow etc. this buffer, and we should throw it
2404: * away when we're done.
2405: */
2406: b->yy_is_our_buffer = 1;
2407:
2408: return b;
1.13 tedu 2409: }
2410: %endif
2411: ]])
2412:
2413:
2414: m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
2415: [[
2416: %if-c-only
2417: static void yy_push_state YYFARGS1( int ,new_state)
2418: %endif
2419: %if-c++-only
2420: void yyFlexLexer::yy_push_state( int new_state )
2421: %endif
2422: {
2423: M4_YY_DECL_GUTS_VAR();
2424: if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) )
1.1 deraadt 2425: {
2426: yy_size_t new_size;
2427:
1.13 tedu 2428: YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
2429: new_size = YY_G(yy_start_stack_depth) * sizeof( int );
1.1 deraadt 2430:
1.13 tedu 2431: if ( ! YY_G(yy_start_stack) )
2432: YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG );
1.1 deraadt 2433:
2434: else
1.13 tedu 2435: YY_G(yy_start_stack) = (int *) yyrealloc(
2436: (void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG );
1.1 deraadt 2437:
1.13 tedu 2438: if ( ! YY_G(yy_start_stack) )
2439: YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1.1 deraadt 2440: }
2441:
1.13 tedu 2442: YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START;
1.1 deraadt 2443:
2444: BEGIN(new_state);
1.13 tedu 2445: }
2446: ]])
1.1 deraadt 2447:
2448:
1.13 tedu 2449: m4_ifdef( [[M4_YY_NO_POP_STATE]],,
2450: [[
2451: %if-c-only
2452: static void yy_pop_state YYFARGS0(void)
2453: %endif
2454: %if-c++-only
2455: void yyFlexLexer::yy_pop_state()
2456: %endif
2457: {
2458: M4_YY_DECL_GUTS_VAR();
2459: if ( --YY_G(yy_start_stack_ptr) < 0 )
1.1 deraadt 2460: YY_FATAL_ERROR( "start-condition stack underflow" );
2461:
1.13 tedu 2462: BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
2463: }
2464: ]])
2465:
2466:
2467: m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
2468: [[
2469: %if-c-only
2470: static int yy_top_state YYFARGS0(void)
2471: %endif
2472: %if-c++-only
2473: int yyFlexLexer::yy_top_state()
2474: %endif
2475: {
2476: M4_YY_DECL_GUTS_VAR();
2477: return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1];
2478: }
2479: ]])
1.1 deraadt 2480:
2481: #ifndef YY_EXIT_FAILURE
2482: #define YY_EXIT_FAILURE 2
2483: #endif
2484:
1.13 tedu 2485: %if-c-only
2486: static void yy_fatal_error YYFARGS1(yyconst char*, msg)
2487: {
2488: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2489: (void) fprintf( stderr, "%s\n", msg );
2490: exit( YY_EXIT_FAILURE );
1.13 tedu 2491: }
2492: %endif
2493: %if-c++-only
1.1 deraadt 2494: void yyFlexLexer::LexerError( yyconst char msg[] )
1.13 tedu 2495: {
2496: M4_YY_DECL_GUTS_VAR();
2497: std::cerr << msg << std::endl;
1.1 deraadt 2498: exit( YY_EXIT_FAILURE );
1.13 tedu 2499: }
2500: %endif
1.1 deraadt 2501:
2502: /* Redefine yyless() so it works in section 3 code. */
2503:
2504: #undef yyless
2505: #define yyless(n) \
2506: do \
2507: { \
2508: /* Undo effects of setting up yytext. */ \
1.13 tedu 2509: int yyless_macro_arg = (n); \
2510: YY_LESS_LINENO(yyless_macro_arg);\
2511: yytext[yyleng] = YY_G(yy_hold_char); \
2512: YY_G(yy_c_buf_p) = yytext + yyless_macro_arg; \
2513: YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
2514: *YY_G(yy_c_buf_p) = '\0'; \
2515: yyleng = yyless_macro_arg; \
1.1 deraadt 2516: } \
2517: while ( 0 )
2518:
2519:
2520:
1.13 tedu 2521: /* Accessor methods (get/set functions) to struct members. */
2522:
2523: %if-c-only
2524: %if-reentrant
2525: m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
2526: [[
2527: /** Get the user-defined data for this scanner.
2528: * M4_YY_DOC_PARAM
2529: */
2530: YY_EXTRA_TYPE yyget_extra YYFARGS0(void)
2531: {
2532: M4_YY_DECL_GUTS_VAR();
2533: return yyextra;
2534: }
2535: ]])
2536: %endif
2537:
2538: m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
2539: [[
2540: /** Get the current line number.
2541: * M4_YY_DOC_PARAM
2542: */
2543: int yyget_lineno YYFARGS0(void)
2544: {
2545: M4_YY_DECL_GUTS_VAR();
2546:
2547: m4_ifdef( [[M4_YY_REENTRANT]],
2548: [[
2549: if (! YY_CURRENT_BUFFER)
2550: return 0;
2551: ]])
2552: return yylineno;
2553: }
2554: ]])
2555:
2556: m4_ifdef( [[M4_YY_REENTRANT]],
2557: [[
2558: m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
2559: [[
2560: /** Get the current column number.
2561: * M4_YY_DOC_PARAM
2562: */
2563: int yyget_column YYFARGS0(void)
2564: {
2565: M4_YY_DECL_GUTS_VAR();
2566:
2567: m4_ifdef( [[M4_YY_REENTRANT]],
2568: [[
2569: if (! YY_CURRENT_BUFFER)
2570: return 0;
2571: ]])
2572: return yycolumn;
2573: }
2574: ]])
2575: ]])
2576:
2577: m4_ifdef( [[M4_YY_NO_GET_IN]],,
2578: [[
2579: /** Get the input stream.
2580: * M4_YY_DOC_PARAM
2581: */
2582: FILE *yyget_in YYFARGS0(void)
2583: {
2584: M4_YY_DECL_GUTS_VAR();
2585: return yyin;
2586: }
2587: ]])
2588:
2589: m4_ifdef( [[M4_YY_NO_GET_OUT]],,
2590: [[
2591: /** Get the output stream.
2592: * M4_YY_DOC_PARAM
2593: */
2594: FILE *yyget_out YYFARGS0(void)
2595: {
2596: M4_YY_DECL_GUTS_VAR();
2597: return yyout;
2598: }
2599: ]])
2600:
2601: m4_ifdef( [[M4_YY_NO_GET_LENG]],,
2602: [[
2603: /** Get the length of the current token.
2604: * M4_YY_DOC_PARAM
2605: */
2606: yy_size_t yyget_leng YYFARGS0(void)
2607: {
2608: M4_YY_DECL_GUTS_VAR();
2609: return yyleng;
2610: }
2611: ]])
2612:
2613: /** Get the current token.
2614: * M4_YY_DOC_PARAM
2615: */
2616: m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
2617: [[
2618: char *yyget_text YYFARGS0(void)
2619: {
2620: M4_YY_DECL_GUTS_VAR();
2621: return yytext;
2622: }
2623: ]])
2624:
2625: %if-reentrant
2626: m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
2627: [[
2628: /** Set the user-defined data. This data is never touched by the scanner.
2629: * @param user_defined The data to be associated with this scanner.
2630: * M4_YY_DOC_PARAM
2631: */
2632: void yyset_extra YYFARGS1( YY_EXTRA_TYPE ,user_defined)
2633: {
2634: M4_YY_DECL_GUTS_VAR();
2635: yyextra = user_defined ;
2636: }
2637: ]])
2638: %endif
2639:
2640: m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
2641: [[
2642: /** Set the current line number.
2643: * @param line_number
2644: * M4_YY_DOC_PARAM
2645: */
2646: void yyset_lineno YYFARGS1( int ,line_number)
2647: {
2648: M4_YY_DECL_GUTS_VAR();
2649:
2650: m4_ifdef( [[M4_YY_REENTRANT]],
2651: [[
2652: /* lineno is only valid if an input buffer exists. */
2653: if (! YY_CURRENT_BUFFER )
2654: YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
2655: ]])
2656: yylineno = line_number;
2657: }
2658: ]])
2659:
2660: m4_ifdef( [[M4_YY_REENTRANT]],
2661: [[
2662: m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
2663: [[
2664: /** Set the current column.
2665: * @param line_number
2666: * M4_YY_DOC_PARAM
2667: */
2668: void yyset_column YYFARGS1( int , column_no)
2669: {
2670: M4_YY_DECL_GUTS_VAR();
2671:
2672: m4_ifdef( [[M4_YY_REENTRANT]],
2673: [[
2674: /* column is only valid if an input buffer exists. */
2675: if (! YY_CURRENT_BUFFER )
2676: YY_FATAL_ERROR( "yyset_column called with no buffer" );
2677: ]])
2678: yycolumn = column_no;
2679: }
2680: ]])
2681: ]])
2682:
2683:
2684: m4_ifdef( [[M4_YY_NO_SET_IN]],,
2685: [[
2686: /** Set the input stream. This does not discard the current
2687: * input buffer.
2688: * @param in_str A readable stream.
2689: * M4_YY_DOC_PARAM
2690: * @see yy_switch_to_buffer
2691: */
2692: void yyset_in YYFARGS1( FILE * ,in_str)
2693: {
2694: M4_YY_DECL_GUTS_VAR();
2695: yyin = in_str ;
2696: }
2697: ]])
2698:
2699: m4_ifdef( [[M4_YY_NO_SET_OUT]],,
2700: [[
2701: void yyset_out YYFARGS1( FILE * ,out_str)
2702: {
2703: M4_YY_DECL_GUTS_VAR();
2704: yyout = out_str ;
2705: }
2706: ]])
2707:
2708:
2709: m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
2710: [[
2711: int yyget_debug YYFARGS0(void)
2712: {
2713: M4_YY_DECL_GUTS_VAR();
2714: return yy_flex_debug;
2715: }
2716: ]])
2717:
2718: m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
2719: [[
2720: void yyset_debug YYFARGS1( int ,bdebug)
2721: {
2722: M4_YY_DECL_GUTS_VAR();
2723: yy_flex_debug = bdebug ;
2724: }
2725: ]])
2726: %endif
2727:
2728: %if-reentrant
2729: /* Accessor methods for yylval and yylloc */
2730:
2731: %if-bison-bridge
2732: m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
2733: [[
2734: YYSTYPE * yyget_lval YYFARGS0(void)
2735: {
2736: M4_YY_DECL_GUTS_VAR();
2737: return yylval;
2738: }
2739: ]])
2740:
2741: m4_ifdef( [[M4_YY_NO_SET_LVAL]],,
2742: [[
2743: void yyset_lval YYFARGS1( YYSTYPE * ,yylval_param)
2744: {
2745: M4_YY_DECL_GUTS_VAR();
2746: yylval = yylval_param;
2747: }
2748: ]])
2749:
2750: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
2751: [[
2752: m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
2753: [[
2754: YYLTYPE *yyget_lloc YYFARGS0(void)
2755: {
2756: M4_YY_DECL_GUTS_VAR();
2757: return yylloc;
2758: }
2759: ]])
2760:
2761: m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
2762: [[
2763: void yyset_lloc YYFARGS1( YYLTYPE * ,yylloc_param)
2764: {
2765: M4_YY_DECL_GUTS_VAR();
2766: yylloc = yylloc_param;
2767: }
2768: ]])
2769: ]])
2770:
2771: %endif
2772:
2773:
2774: /* User-visible API */
2775:
2776: /* yylex_init is special because it creates the scanner itself, so it is
2777: * the ONLY reentrant function that doesn't take the scanner as the last argument.
2778: * That's why we explicitly handle the declaration, instead of using our macros.
2779: */
2780: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
2781: [[
2782: int yylex_init( ptr_yy_globals )
2783: yyscan_t* ptr_yy_globals;
2784: ]],
2785: [[
2786: int yylex_init(yyscan_t* ptr_yy_globals)
2787: ]])
2788: {
2789: if (ptr_yy_globals == NULL){
2790: errno = EINVAL;
2791: return 1;
2792: }
2793:
2794: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2795:
2796: if (*ptr_yy_globals == NULL){
2797: errno = ENOMEM;
2798: return 1;
2799: }
2800:
2801: /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2802: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2803:
2804: return yy_init_globals ( *ptr_yy_globals );
2805: }
2806:
2807:
2808: /* yylex_init_extra has the same functionality as yylex_init, but follows the
2809: * convention of taking the scanner as the last argument. Note however, that
2810: * this is a *pointer* to a scanner, as it will be allocated by this call (and
2811: * is the reason, too, why this function also must handle its own declaration).
2812: * The user defined value in the first argument will be available to yyalloc in
2813: * the yyextra field.
2814: */
2815: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
2816: [[
2817: int yylex_init_extra( yy_user_defined, ptr_yy_globals )
2818: YY_EXTRA_TYPE yy_user_defined;
2819: yyscan_t* ptr_yy_globals;
2820: ]],
2821: [[
2822: int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2823: ]])
2824: {
2825: struct yyguts_t dummy_yyguts;
2826:
2827: yyset_extra (yy_user_defined, &dummy_yyguts);
2828:
2829: if (ptr_yy_globals == NULL){
2830: errno = EINVAL;
2831: return 1;
2832: }
2833:
2834: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2835:
2836: if (*ptr_yy_globals == NULL){
2837: errno = ENOMEM;
2838: return 1;
2839: }
2840:
2841: /* By setting to 0xAA, we expose bugs in
2842: yy_init_globals. Leave at 0x00 for releases. */
2843: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2844:
2845: yyset_extra (yy_user_defined, *ptr_yy_globals);
2846:
2847: return yy_init_globals ( *ptr_yy_globals );
2848: }
2849:
2850: %endif if-c-only
2851:
2852:
2853: %if-c-only
2854: static int yy_init_globals YYFARGS0(void)
2855: {
2856: M4_YY_DECL_GUTS_VAR();
2857: /* Initialization is the same as for the non-reentrant scanner.
2858: * This function is called from yylex_destroy(), so don't allocate here.
2859: */
2860:
2861: m4_ifdef( [[M4_YY_USE_LINENO]],
2862: [[
2863: m4_ifdef( [[M4_YY_NOT_REENTRANT]],
2864: [[
2865: /* We do not touch yylineno unless the option is enabled. */
2866: yylineno = 1;
2867: ]])
2868: ]])
2869: YY_G(yy_buffer_stack) = 0;
2870: YY_G(yy_buffer_stack_top) = 0;
2871: YY_G(yy_buffer_stack_max) = 0;
2872: YY_G(yy_c_buf_p) = (char *) 0;
2873: YY_G(yy_init) = 0;
2874: YY_G(yy_start) = 0;
2875:
2876: m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
2877: [[
2878: YY_G(yy_start_stack_ptr) = 0;
2879: YY_G(yy_start_stack_depth) = 0;
2880: YY_G(yy_start_stack) = NULL;
2881: ]])
2882:
2883: m4_ifdef( [[M4_YY_USES_REJECT]],
2884: [[
2885: YY_G(yy_state_buf) = 0;
2886: YY_G(yy_state_ptr) = 0;
2887: YY_G(yy_full_match) = 0;
2888: YY_G(yy_lp) = 0;
2889: ]])
2890:
2891: m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
2892: [[
2893: YY_G(yytext_ptr) = 0;
2894: YY_G(yy_more_offset) = 0;
2895: YY_G(yy_prev_more_offset) = 0;
2896: ]])
2897:
2898: /* Defined in main.c */
2899: #ifdef YY_STDINIT
2900: yyin = stdin;
2901: yyout = stdout;
2902: #else
2903: yyin = (FILE *) 0;
2904: yyout = (FILE *) 0;
2905: #endif
2906:
2907: /* For future reference: Set errno on error, since we are called by
2908: * yylex_init()
2909: */
2910: return 0;
2911: }
2912: %endif
2913:
2914:
2915: %if-c-only SNIP! this currently causes conflicts with the c++ scanner
2916: /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2917: int yylex_destroy YYFARGS0(void)
2918: {
2919: M4_YY_DECL_GUTS_VAR();
2920:
2921: /* Pop the buffer stack, destroying each element. */
2922: while(YY_CURRENT_BUFFER){
2923: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG );
2924: YY_CURRENT_BUFFER_LVALUE = NULL;
2925: yypop_buffer_state(M4_YY_CALL_ONLY_ARG);
2926: }
2927:
2928: /* Destroy the stack itself. */
2929: yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG);
2930: YY_G(yy_buffer_stack) = NULL;
2931:
2932: m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
2933: [[
2934: /* Destroy the start condition stack. */
2935: yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG );
2936: YY_G(yy_start_stack) = NULL;
2937: ]])
2938:
2939: m4_ifdef( [[M4_YY_USES_REJECT]],
2940: [[
2941: yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG);
2942: YY_G(yy_state_buf) = NULL;
2943: ]])
2944:
2945: /* Reset the globals. This is important in a non-reentrant scanner so the next time
2946: * yylex() is called, initialization will occur. */
2947: yy_init_globals( M4_YY_CALL_ONLY_ARG);
2948:
2949: %if-reentrant
2950: /* Destroy the main struct (reentrant only). */
2951: yyfree ( yyscanner M4_YY_CALL_LAST_ARG );
2952: yyscanner = NULL;
2953: %endif
2954: return 0;
2955: }
2956: %endif
2957:
2958:
2959: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
2960: [[
2961: /*
2962: * Internal utility routines.
2963: */
2964: ]])
2965:
2966: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
2967: [[
1.1 deraadt 2968: #ifndef yytext_ptr
1.13 tedu 2969: static void yy_flex_strncpy YYFARGS3( char*,s1, yyconst char *,s2, int,n)
2970: {
2971: int i;
1.1 deraadt 2972: for ( i = 0; i < n; ++i )
2973: s1[i] = s2[i];
1.13 tedu 2974: }
1.3 millert 2975: #endif
1.13 tedu 2976: ]])
1.3 millert 2977:
1.13 tedu 2978: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
2979: [[
1.3 millert 2980: #ifdef YY_NEED_STRLEN
1.13 tedu 2981: static int yy_flex_strlen YYFARGS1( yyconst char *,s)
2982: {
2983: int n;
1.3 millert 2984: for ( n = 0; s[n]; ++n )
2985: ;
2986:
2987: return n;
1.13 tedu 2988: }
1.1 deraadt 2989: #endif
1.13 tedu 2990: ]])
1.1 deraadt 2991:
1.13 tedu 2992: m4_ifdef( [[M4_YY_NO_FLEX_ALLOC]],,
2993: [[
2994: void *yyalloc YYFARGS1( yy_size_t ,size)
2995: {
1.1 deraadt 2996: return (void *) malloc( size );
1.13 tedu 2997: }
2998: ]])
1.1 deraadt 2999:
1.13 tedu 3000: m4_ifdef( [[M4_YY_NO_FLEX_REALLOC]],,
3001: [[
3002: void *yyrealloc YYFARGS2( void *,ptr, yy_size_t ,size)
3003: {
1.1 deraadt 3004: /* The cast to (char *) in the following accommodates both
3005: * implementations that use char* generic pointers, and those
3006: * that use void* generic pointers. It works with the latter
3007: * because both ANSI C and C++ allow castless assignment from
3008: * any pointer type to void*, and deal with argument conversions
3009: * as though doing an assignment.
3010: */
3011: return (void *) realloc( (char *) ptr, size );
1.13 tedu 3012: }
3013: ]])
1.1 deraadt 3014:
1.13 tedu 3015: m4_ifdef( [[M4_YY_NO_FLEX_FREE]],,
3016: [[
3017: void yyfree YYFARGS1( void *,ptr)
3018: {
3019: free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
3020: }
3021: ]])
3022:
3023: %if-tables-serialization definitions
3024: m4preproc_include(`tables_shared.c')
3025:
3026: static int yytbl_read8 (void *v, struct yytbl_reader * rd)
3027: {
3028: errno = 0;
3029: if (fread (v, sizeof (flex_uint8_t), 1, rd->fp) != 1){
3030: errno = EIO;
3031: return -1;
3032: }
3033: rd->bread += sizeof(flex_uint8_t);
3034: return 0;
3035: }
3036:
3037: static int yytbl_read16 (void *v, struct yytbl_reader * rd)
3038: {
3039: errno = 0;
3040: if (fread (v, sizeof (flex_uint16_t), 1, rd->fp) != 1){
3041: errno = EIO;
3042: return -1;
3043: }
3044: *((flex_uint16_t *) v) = ntohs (*((flex_uint16_t *) v));
3045: rd->bread += sizeof(flex_uint16_t);
3046: return 0;
3047: }
3048:
3049: static int yytbl_read32 (void *v, struct yytbl_reader * rd)
3050: {
3051: errno = 0;
3052: if (fread (v, sizeof (flex_uint32_t), 1, rd->fp) != 1){
3053: errno = EIO;
3054: return -1;
3055: }
3056: *((flex_uint32_t *) v) = ntohl (*((flex_uint32_t *) v));
3057: rd->bread += sizeof(flex_uint32_t);
3058: return 0;
3059: }
3060:
3061: /** Read the header */
3062: static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader *, rd)
3063: {
3064: int bytes;
3065: memset (th, 0, sizeof (struct yytbl_hdr));
3066:
3067: if (yytbl_read32 (&(th->th_magic), rd) != 0)
3068: return -1;
3069:
3070: if (th->th_magic != YYTBL_MAGIC){
3071: YY_FATAL_ERROR( "bad magic number" ); /* TODO: not fatal. */
3072: return -1;
3073: }
3074:
3075: if (yytbl_read32 (&(th->th_hsize), rd) != 0
3076: || yytbl_read32 (&(th->th_ssize), rd) != 0
3077: || yytbl_read16 (&(th->th_flags), rd) != 0)
3078: return -1;
3079:
3080: /* Sanity check on header size. Greater than 1k suggests some funny business. */
3081: if (th->th_hsize < 16 || th->th_hsize > 1024){
3082: YY_FATAL_ERROR( "insane header size detected" ); /* TODO: not fatal. */
3083: return -1;
3084: }
3085:
3086: /* Allocate enough space for the version and name fields */
3087: bytes = th->th_hsize - 14;
3088: th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
3089: if ( ! th->th_version )
3090: YY_FATAL_ERROR( "out of dynamic memory in yytbl_hdr_read()" );
3091:
3092: /* we read it all into th_version, and point th_name into that data */
3093: if (fread (th->th_version, 1, bytes, rd->fp) != bytes){
3094: errno = EIO;
3095: yyfree(th->th_version M4_YY_CALL_LAST_ARG);
3096: th->th_version = NULL;
3097: return -1;
3098: }
3099: else
3100: rd->bread += bytes;
3101:
3102: th->th_name = th->th_version + strlen (th->th_version) + 1;
3103: return 0;
3104: }
3105:
3106: /** lookup id in the dmap list.
3107: * @param dmap pointer to first element in list
3108: * @return NULL if not found.
3109: */
3110: static struct yytbl_dmap *yytbl_dmap_lookup YYFARGS2(struct yytbl_dmap *, dmap,
3111: int, id)
3112: {
3113: while (dmap->dm_id)
3114: if (dmap->dm_id == id)
3115: return dmap;
3116: else
3117: dmap++;
3118: return NULL;
3119: }
3120:
3121: /** Read a table while mapping its contents to the local array.
3122: * @param dmap used to performing mapping
3123: * @return 0 on success
3124: */
3125: static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_reader*, rd)
3126: {
3127: struct yytbl_data td;
3128: struct yytbl_dmap *transdmap=0;
3129: int len, i, rv, inner_loop_count;
3130: void *p=0;
3131:
3132: memset (&td, 0, sizeof (struct yytbl_data));
3133:
3134: if (yytbl_read16 (&td.td_id, rd) != 0
3135: || yytbl_read16 (&td.td_flags, rd) != 0
3136: || yytbl_read32 (&td.td_hilen, rd) != 0
3137: || yytbl_read32 (&td.td_lolen, rd) != 0)
3138: return -1;
3139:
3140: /* Lookup the map for the transition table so we have it in case we need it
3141: * inside the loop below. This scanner might not even have a transition
3142: * table, which is ok.
3143: */
3144: transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG);
3145:
3146: if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL){
3147: YY_FATAL_ERROR( "table id not found in map." ); /* TODO: not fatal. */
3148: return -1;
3149: }
3150:
3151: /* Allocate space for table.
3152: * The --full yy_transition table is a special case, since we
3153: * need the dmap.dm_sz entry to tell us the sizeof the individual
3154: * struct members.
3155: */
3156: {
3157: size_t bytes;
3158:
3159: if ((td.td_flags & YYTD_STRUCT))
3160: bytes = sizeof(struct yy_trans_info) * td.td_lolen * (td.td_hilen ? td.td_hilen : 1);
3161: else
3162: bytes = td.td_lolen * (td.td_hilen ? td.td_hilen : 1) * dmap->dm_sz;
3163:
3164: if(M4_YY_TABLES_VERIFY)
3165: /* We point to the array itself */
3166: p = dmap->dm_arr;
3167: else
3168: /* We point to the address of a pointer. */
3169: *dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
3170: if ( ! p )
3171: YY_FATAL_ERROR( "out of dynamic memory in yytbl_data_load()" );
3172: }
3173:
3174: /* If it's a struct, we read 2 integers to get one element */
3175: if ((td.td_flags & YYTD_STRUCT) != 0)
3176: inner_loop_count = 2;
3177: else
3178: inner_loop_count = 1;
3179:
3180: /* read and map each element.
3181: * This loop iterates once for each element of the td_data array.
3182: * Notice that we increment 'i' in the inner loop.
3183: */
3184: len = yytbl_calc_total_len (&td);
3185: for (i = 0; i < len; ){
3186: int j;
3187:
3188:
3189: /* This loop really executes exactly 1 or 2 times.
3190: * The second time is to handle the second member of the
3191: * YYTD_STRUCT for the yy_transition array.
3192: */
3193: for (j = 0; j < inner_loop_count; j++, i++) {
3194: flex_int32_t t32;
3195:
3196: /* read into t32 no matter what the real size is. */
3197: {
3198: flex_int16_t t16;
3199: flex_int8_t t8;
3200:
3201: switch (YYTDFLAGS2BYTES (td.td_flags)) {
3202: case sizeof (flex_int32_t):
3203: rv = yytbl_read32 (&t32, rd);
3204: break;
3205: case sizeof (flex_int16_t):
3206: rv = yytbl_read16 (&t16, rd);
3207: t32 = t16;
3208: break;
3209: case sizeof (flex_int8_t):
3210: rv = yytbl_read8 (&t8, rd);
3211: t32 = t8;
3212: break;
3213: default:
3214: YY_FATAL_ERROR( "invalid td_flags" ); /* TODO: not fatal. */
3215: return -1;
3216: }
3217: }
3218: if (rv != 0)
3219: return -1;
3220:
3221: /* copy into the deserialized array... */
3222:
3223: if ((td.td_flags & YYTD_STRUCT)) {
3224: /* t32 is the j'th member of a two-element struct. */
3225: void *v;
3226:
3227: v = j == 0 ? &(((struct yy_trans_info *) p)->yy_verify)
3228: : &(((struct yy_trans_info *) p)->yy_nxt);
3229:
3230: switch (dmap->dm_sz) {
3231: case sizeof (flex_int32_t):
3232: if (M4_YY_TABLES_VERIFY){
3233: if( ((flex_int32_t *) v)[0] != (flex_int32_t) t32)
3234: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int32_t" );
3235: }else
3236: ((flex_int32_t *) v)[0] = (flex_int32_t) t32;
3237: break;
3238: case sizeof (flex_int16_t):
3239: if (M4_YY_TABLES_VERIFY ){
3240: if(((flex_int16_t *) v)[0] != (flex_int16_t) t32)
3241: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int16_t" );
3242: }else
3243: ((flex_int16_t *) v)[0] = (flex_int16_t) t32;
3244: break;
3245: case sizeof(flex_int8_t):
3246: if (M4_YY_TABLES_VERIFY ){
3247: if( ((flex_int8_t *) v)[0] != (flex_int8_t) t32)
3248: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int8_t" );
3249: }else
3250: ((flex_int8_t *) v)[0] = (flex_int8_t) t32;
3251: break;
3252: default:
3253: YY_FATAL_ERROR( "invalid dmap->dm_sz for struct" ); /* TODO: not fatal. */
3254: return -1;
3255: }
3256:
3257: /* if we're done with j, increment p */
3258: if (j == 1)
3259: p = (struct yy_trans_info *) p + 1;
3260: }
3261: else if ((td.td_flags & YYTD_PTRANS)) {
3262: /* t32 is an index into the transition array. */
3263: struct yy_trans_info *v;
3264:
3265:
3266: if (!transdmap){
3267: YY_FATAL_ERROR( "transition table not found" ); /* TODO: not fatal. */
3268: return -1;
3269: }
3270:
3271: if( M4_YY_TABLES_VERIFY)
3272: v = &(((struct yy_trans_info *) (transdmap->dm_arr))[t32]);
3273: else
3274: v = &((*((struct yy_trans_info **) (transdmap->dm_arr)))[t32]);
3275:
3276: if(M4_YY_TABLES_VERIFY ){
3277: if( ((struct yy_trans_info **) p)[0] != v)
3278: YY_FATAL_ERROR( "tables verification failed at YYTD_PTRANS" );
3279: }else
3280: ((struct yy_trans_info **) p)[0] = v;
3281:
3282: /* increment p */
3283: p = (struct yy_trans_info **) p + 1;
3284: }
3285: else {
3286: /* t32 is a plain int. copy data, then incrememnt p. */
3287: switch (dmap->dm_sz) {
3288: case sizeof (flex_int32_t):
3289: if(M4_YY_TABLES_VERIFY ){
3290: if( ((flex_int32_t *) p)[0] != (flex_int32_t) t32)
3291: YY_FATAL_ERROR( "tables verification failed at flex_int32_t" );
3292: }else
3293: ((flex_int32_t *) p)[0] = (flex_int32_t) t32;
3294: p = ((flex_int32_t *) p) + 1;
3295: break;
3296: case sizeof (flex_int16_t):
3297: if(M4_YY_TABLES_VERIFY ){
3298: if( ((flex_int16_t *) p)[0] != (flex_int16_t) t32)
3299: YY_FATAL_ERROR( "tables verification failed at flex_int16_t" );
3300: }else
3301: ((flex_int16_t *) p)[0] = (flex_int16_t) t32;
3302: p = ((flex_int16_t *) p) + 1;
3303: break;
3304: case sizeof (flex_int8_t):
3305: if(M4_YY_TABLES_VERIFY ){
3306: if( ((flex_int8_t *) p)[0] != (flex_int8_t) t32)
3307: YY_FATAL_ERROR( "tables verification failed at flex_int8_t" );
3308: }else
3309: ((flex_int8_t *) p)[0] = (flex_int8_t) t32;
3310: p = ((flex_int8_t *) p) + 1;
3311: break;
3312: default:
3313: YY_FATAL_ERROR( "invalid dmap->dm_sz for plain int" ); /* TODO: not fatal. */
3314: return -1;
3315: }
3316: }
3317: }
3318:
3319: }
3320:
3321: /* Now eat padding. */
3322: {
3323: int pad;
3324: pad = yypad64(rd->bread);
3325: while(--pad >= 0){
3326: flex_int8_t t8;
3327: if(yytbl_read8(&t8,rd) != 0)
3328: return -1;
3329: }
3330: }
3331:
3332: return 0;
3333: }
3334:
3335: %define-yytables The name for this specific scanner's tables.
3336:
3337: /* Find the key and load the DFA tables from the given stream. */
3338: static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key)
3339: {
3340: int rv=0;
3341: struct yytbl_hdr th;
3342: struct yytbl_reader rd;
3343:
3344: rd.fp = fp;
3345: th.th_version = NULL;
3346:
3347: /* Keep trying until we find the right set of tables or end of file. */
3348: while (!feof(rd.fp)) {
3349: rd.bread = 0;
3350: if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0){
3351: rv = -1;
3352: goto return_rv;
3353: }
3354:
3355: /* A NULL key means choose the first set of tables. */
3356: if (key == NULL)
3357: break;
3358:
3359: if (strcmp(th.th_name,key) != 0){
3360: /* Skip ahead to next set */
3361: fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR);
3362: yyfree(th.th_version M4_YY_CALL_LAST_ARG);
3363: th.th_version = NULL;
3364: }
3365: else
3366: break;
3367: }
3368:
3369: while (rd.bread < th.th_ssize){
3370: /* Load the data tables */
3371: if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){
3372: rv = -1;
3373: goto return_rv;
3374: }
3375: }
3376:
3377: return_rv:
3378: if(th.th_version){
3379: yyfree(th.th_version M4_YY_CALL_LAST_ARG);
3380: th.th_version = NULL;
3381: }
3382:
3383: return rv;
3384: }
3385:
3386: /** Load the DFA tables for this scanner from the given stream. */
3387: int yytables_fload YYFARGS1(FILE *, fp)
3388: {
3389:
3390: if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0)
3391: return -1;
3392: return 0;
3393: }
3394:
3395: /** Destroy the loaded tables, freeing memory, etc.. */
3396: int yytables_destroy YYFARGS0(void)
3397: {
3398: struct yytbl_dmap *dmap=0;
3399:
3400: if(!M4_YY_TABLES_VERIFY){
3401: /* Walk the dmap, freeing the pointers */
3402: for(dmap=yydmap; dmap->dm_id; dmap++) {
3403: void * v;
3404: v = dmap->dm_arr;
3405: if(v && *(char**)v){
3406: yyfree(*(char**)v M4_YY_CALL_LAST_ARG);
3407: *(char**)v = NULL;
3408: }
3409: }
3410: }
3411:
3412: return 0;
3413: }
3414:
3415: /* end table serialization code definitions */
3416: %endif
3417:
3418:
3419: m4_ifdef([[M4_YY_MAIN]], [[
3420: int main M4_YY_PARAMS(void);
3421:
3422: int main ()
3423: {
3424:
3425: %if-reentrant
3426: yyscan_t lexer;
3427: yylex_init(&lexer);
3428: yylex( lexer );
3429: yylex_destroy( lexer);
1.1 deraadt 3430:
1.13 tedu 3431: %endif
3432: %if-not-reentrant
1.1 deraadt 3433: yylex();
1.13 tedu 3434: %endif
3435:
1.1 deraadt 3436: return 0;
1.13 tedu 3437: }
3438: ]])
3439:
3440: %ok-for-header
3441: m4_ifdef( [[M4_YY_IN_HEADER]],
3442: [[
3443: #undef YY_NEW_FILE
3444: #undef YY_FLUSH_BUFFER
3445: #undef yy_set_bol
3446: #undef yy_new_buffer
3447: #undef yy_set_interactive
3448: #undef YY_DO_BEFORE_ACTION
3449:
3450: #ifdef YY_DECL_IS_OURS
3451: #undef YY_DECL_IS_OURS
3452: #undef YY_DECL
1.1 deraadt 3453: #endif
1.13 tedu 3454: ]])
![[BACK]](/icons/back.gif){kind=icon}
Return to flex.skl CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex