Annotation of src/usr.bin/lex/flex.skl, Revision 1.13
1.13 ! tedu 1: /* $OpenBSD: flex.skl,v 1.12 2013/11/04 17:03:32 millert 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
! 470: typedef size_t yy_size_t;
! 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. */
! 1311: if ( ! YY_G(yy_state_buf) )
! 1312: YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE M4_YY_CALL_LAST_ARG);
! 1313: if ( ! YY_G(yy_state_buf) )
! 1314: YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
! 1315: ]])
! 1316:
! 1317: if ( ! YY_G(yy_start) )
! 1318: YY_G(yy_start) = 1; /* first start state */
1.1 deraadt 1319:
1320: if ( ! yyin )
1.13 ! tedu 1321: %if-c-only
1.1 deraadt 1322: yyin = stdin;
1.13 ! tedu 1323: %endif
! 1324: %if-c++-only
! 1325: yyin = & std::cin;
! 1326: %endif
1.1 deraadt 1327:
1328: if ( ! yyout )
1.13 ! tedu 1329: %if-c-only
1.1 deraadt 1330: yyout = stdout;
1.13 ! tedu 1331: %endif
! 1332: %if-c++-only
! 1333: yyout = & std::cout;
! 1334: %endif
! 1335:
! 1336: if ( ! YY_CURRENT_BUFFER ) {
! 1337: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
! 1338: YY_CURRENT_BUFFER_LVALUE =
! 1339: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
! 1340: }
1.1 deraadt 1341:
1.13 ! tedu 1342: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1343: }
1344:
1.13 ! tedu 1345: {
! 1346: %% [7.0] user's declarations go here
! 1347:
1.1 deraadt 1348: while ( 1 ) /* loops until end-of-file is reached */
1349: {
1.13 ! tedu 1350: %% [8.0] yymore()-related code goes here
! 1351: yy_cp = YY_G(yy_c_buf_p);
1.1 deraadt 1352:
1353: /* Support of yytext. */
1.13 ! tedu 1354: *yy_cp = YY_G(yy_hold_char);
1.1 deraadt 1355:
1356: /* yy_bp points to the position in yy_ch_buf of the start of
1357: * the current run.
1358: */
1359: yy_bp = yy_cp;
1360:
1.13 ! tedu 1361: %% [9.0] code to set up and find next match goes here
1.1 deraadt 1362:
1363: yy_find_action:
1.13 ! tedu 1364: %% [10.0] code to find the action number goes here
1.1 deraadt 1365:
1366: YY_DO_BEFORE_ACTION;
1367:
1.13 ! tedu 1368: %% [11.0] code for yylineno update goes here
1.1 deraadt 1369:
1370: do_action: /* This label is used only to access EOF actions. */
1371:
1.13 ! tedu 1372: %% [12.0] debug code goes here
1.1 deraadt 1373:
1374: switch ( yy_act )
1375: { /* beginning of action switch */
1.13 ! tedu 1376: %% [13.0] actions go here
1.1 deraadt 1377:
1378: case YY_END_OF_BUFFER:
1379: {
1380: /* Amount of text matched not including the EOB char. */
1.13 ! tedu 1381: int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;
1.1 deraadt 1382:
1383: /* Undo the effects of YY_DO_BEFORE_ACTION. */
1.13 ! tedu 1384: *yy_cp = YY_G(yy_hold_char);
1.3 millert 1385: YY_RESTORE_YY_MORE_OFFSET
1.1 deraadt 1386:
1.13 ! tedu 1387: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1.1 deraadt 1388: {
1389: /* We're scanning a new file or input source. It's
1390: * possible that this happened because the user
1391: * just pointed yyin at a new source and called
1392: * yylex(). If so, then we have to assure
1.13 ! tedu 1393: * consistency between YY_CURRENT_BUFFER and our
1.1 deraadt 1394: * globals. Here is the right place to do so, because
1395: * this is the first action (other than possibly a
1396: * back-up) that will match for the new input source.
1397: */
1.13 ! tedu 1398: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
! 1399: YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
! 1400: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1.1 deraadt 1401: }
1402:
1403: /* Note that here we test for yy_c_buf_p "<=" to the position
1404: * of the first EOB in the buffer, since yy_c_buf_p will
1405: * already have been incremented past the NUL character
1406: * (since all states make transitions on EOB to the
1407: * end-of-buffer state). Contrast this with the test
1408: * in input().
1409: */
1.13 ! tedu 1410: if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
1.1 deraadt 1411: { /* This was really a NUL. */
1412: yy_state_type yy_next_state;
1413:
1.13 ! tedu 1414: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;
1.1 deraadt 1415:
1.13 ! tedu 1416: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1417:
1418: /* Okay, we're now positioned to make the NUL
1419: * transition. We couldn't have
1420: * yy_get_previous_state() go ahead and do it
1421: * for us because it doesn't know how to deal
1422: * with the possibility of jamming (and we don't
1423: * want to build jamming into it because then it
1424: * will run more slowly).
1425: */
1426:
1.13 ! tedu 1427: yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG);
1.1 deraadt 1428:
1.13 ! tedu 1429: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1430:
1431: if ( yy_next_state )
1432: {
1433: /* Consume the NUL. */
1.13 ! tedu 1434: yy_cp = ++YY_G(yy_c_buf_p);
1.1 deraadt 1435: yy_current_state = yy_next_state;
1436: goto yy_match;
1437: }
1438:
1439: else
1440: {
1.13 ! tedu 1441: %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here
1.1 deraadt 1442: goto yy_find_action;
1443: }
1444: }
1445:
1.13 ! tedu 1446: else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1447: {
1448: case EOB_ACT_END_OF_FILE:
1449: {
1.13 ! tedu 1450: YY_G(yy_did_buffer_switch_on_eof) = 0;
1.1 deraadt 1451:
1.13 ! tedu 1452: if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1453: {
1454: /* Note: because we've taken care in
1455: * yy_get_next_buffer() to have set up
1456: * yytext, we can now set up
1457: * yy_c_buf_p so that if some total
1458: * hoser (like flex itself) wants to
1459: * call the scanner after we return the
1460: * YY_NULL, it'll still work - another
1461: * YY_NULL will get returned.
1462: */
1.13 ! tedu 1463: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1464:
1465: yy_act = YY_STATE_EOF(YY_START);
1466: goto do_action;
1467: }
1468:
1469: else
1470: {
1.13 ! tedu 1471: if ( ! YY_G(yy_did_buffer_switch_on_eof) )
1.1 deraadt 1472: YY_NEW_FILE;
1473: }
1474: break;
1475: }
1476:
1477: case EOB_ACT_CONTINUE_SCAN:
1.13 ! tedu 1478: YY_G(yy_c_buf_p) =
! 1479: YY_G(yytext_ptr) + yy_amount_of_matched_text;
1.1 deraadt 1480:
1.13 ! tedu 1481: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1482:
1.13 ! tedu 1483: yy_cp = YY_G(yy_c_buf_p);
! 1484: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1485: goto yy_match;
1486:
1487: case EOB_ACT_LAST_MATCH:
1.13 ! tedu 1488: YY_G(yy_c_buf_p) =
! 1489: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];
1.1 deraadt 1490:
1.13 ! tedu 1491: yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 1492:
1.13 ! tedu 1493: yy_cp = YY_G(yy_c_buf_p);
! 1494: yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
1.1 deraadt 1495: goto yy_find_action;
1496: }
1497: break;
1498: }
1499:
1500: default:
1501: YY_FATAL_ERROR(
1502: "fatal flex scanner internal error--no action found" );
1503: } /* end of action switch */
1504: } /* end of scanning one token */
1.13 ! tedu 1505: } /* end of user's declarations */
! 1506: } /* end of yylex */
! 1507: %ok-for-header
! 1508:
! 1509: %if-c++-only
! 1510: %not-for-header
! 1511: /* The contents of this function are C++ specific, so the YY_G macro is not used.
! 1512: */
1.7 espie 1513: yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1.13 ! tedu 1514: {
1.1 deraadt 1515: yyin = arg_yyin;
1516: yyout = arg_yyout;
1517: yy_c_buf_p = 0;
1.13 ! tedu 1518: yy_init = 0;
1.1 deraadt 1519: yy_start = 0;
1520: yy_flex_debug = 0;
1521: yylineno = 1; // this will only get updated if %option yylineno
1522:
1523: yy_did_buffer_switch_on_eof = 0;
1524:
1525: yy_looking_for_trail_begin = 0;
1526: yy_more_flag = 0;
1527: yy_more_len = 0;
1.3 millert 1528: yy_more_offset = yy_prev_more_offset = 0;
1.1 deraadt 1529:
1530: yy_start_stack_ptr = yy_start_stack_depth = 0;
1.13 ! tedu 1531: yy_start_stack = NULL;
1.1 deraadt 1532:
1.13 ! tedu 1533: yy_buffer_stack = 0;
! 1534: yy_buffer_stack_top = 0;
! 1535: yy_buffer_stack_max = 0;
1.1 deraadt 1536:
1.13 ! tedu 1537:
! 1538: m4_ifdef( [[M4_YY_USES_REJECT]],
! 1539: [[
! 1540: yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE];
! 1541: ]],
! 1542: [[
1.1 deraadt 1543: yy_state_buf = 0;
1.13 ! tedu 1544: ]])
! 1545: }
1.1 deraadt 1546:
1.13 ! tedu 1547: /* The contents of this function are C++ specific, so the YY_G macro is not used.
! 1548: */
1.1 deraadt 1549: yyFlexLexer::~yyFlexLexer()
1.13 ! tedu 1550: {
! 1551: delete [] yy_state_buf;
! 1552: yyfree( yy_start_stack M4_YY_CALL_LAST_ARG );
! 1553: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
! 1554: yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG );
! 1555: }
1.1 deraadt 1556:
1.13 ! tedu 1557: /* The contents of this function are C++ specific, so the YY_G macro is not used.
! 1558: */
1.7 espie 1559: void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1.13 ! tedu 1560: {
1.1 deraadt 1561: if ( new_in )
1562: {
1.13 ! tedu 1563: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
! 1564: 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 1565: }
1566:
1567: if ( new_out )
1568: yyout = new_out;
1.13 ! tedu 1569: }
1.1 deraadt 1570:
1571: #ifdef YY_INTERACTIVE
1572: int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
1573: #else
1574: int yyFlexLexer::LexerInput( char* buf, int max_size )
1575: #endif
1.13 ! tedu 1576: {
1.1 deraadt 1577: if ( yyin->eof() || yyin->fail() )
1578: return 0;
1579:
1580: #ifdef YY_INTERACTIVE
1581: yyin->get( buf[0] );
1582:
1583: if ( yyin->eof() )
1584: return 0;
1585:
1586: if ( yyin->bad() )
1587: return -1;
1588:
1589: return 1;
1590:
1591: #else
1592: (void) yyin->read( buf, max_size );
1593:
1594: if ( yyin->bad() )
1595: return -1;
1596: else
1597: return yyin->gcount();
1598: #endif
1.13 ! tedu 1599: }
1.1 deraadt 1600:
1601: void yyFlexLexer::LexerOutput( const char* buf, int size )
1.13 ! tedu 1602: {
1.1 deraadt 1603: (void) yyout->write( buf, size );
1.13 ! tedu 1604: }
! 1605: %ok-for-header
! 1606: %endif
1.1 deraadt 1607:
1.13 ! tedu 1608: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
! 1609: [[
1.1 deraadt 1610: /* yy_get_next_buffer - try to read in a new buffer
1611: *
1612: * Returns a code representing an action:
1613: * EOB_ACT_LAST_MATCH -
1614: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1615: * EOB_ACT_END_OF_FILE - end of file
1616: */
1.13 ! tedu 1617: %if-c-only
! 1618: static int yy_get_next_buffer YYFARGS0(void)
! 1619: %endif
! 1620: %if-c++-only
! 1621: int yyFlexLexer::yy_get_next_buffer()
! 1622: %endif
! 1623: {
! 1624: M4_YY_DECL_GUTS_VAR();
! 1625: char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
! 1626: char *source = YY_G(yytext_ptr);
! 1627: int number_to_move, i;
1.1 deraadt 1628: int ret_val;
1629:
1.13 ! tedu 1630: if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] )
1.1 deraadt 1631: YY_FATAL_ERROR(
1632: "fatal flex scanner internal error--end of buffer missed" );
1633:
1.13 ! tedu 1634: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1.1 deraadt 1635: { /* Don't try to fill the buffer, so this is an EOF. */
1.13 ! tedu 1636: if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
1.1 deraadt 1637: {
1.3 millert 1638: /* We matched a single character, the EOB, so
1.1 deraadt 1639: * treat this as a final EOF.
1640: */
1641: return EOB_ACT_END_OF_FILE;
1642: }
1643:
1644: else
1645: {
1646: /* We matched some text prior to the EOB, first
1647: * process it.
1648: */
1649: return EOB_ACT_LAST_MATCH;
1650: }
1651: }
1652:
1653: /* Try to read more data. */
1654:
1655: /* First move last chars to start of buffer. */
1.13 ! tedu 1656: number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;
1.1 deraadt 1657:
1658: for ( i = 0; i < number_to_move; ++i )
1659: *(dest++) = *(source++);
1660:
1.13 ! tedu 1661: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1.1 deraadt 1662: /* don't do the read, it's not guaranteed to return an EOF,
1663: * just force an EOF
1664: */
1.13 ! tedu 1665: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0;
1.1 deraadt 1666:
1667: else
1668: {
1.13 ! tedu 1669: yy_size_t num_to_read =
! 1670: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1.1 deraadt 1671:
1672: while ( num_to_read <= 0 )
1673: { /* Not enough room in the buffer - grow it. */
1.13 ! tedu 1674: m4_ifdef( [[M4_YY_USES_REJECT]],
! 1675: [[
1.1 deraadt 1676: YY_FATAL_ERROR(
1677: "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1.13 ! tedu 1678: ]],
! 1679: [[
1.1 deraadt 1680: /* just a shorter name for the current buffer */
1.13 ! tedu 1681: YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1.1 deraadt 1682:
1683: int yy_c_buf_p_offset =
1.13 ! tedu 1684: (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
1.1 deraadt 1685:
1686: if ( b->yy_is_our_buffer )
1687: {
1.13 ! tedu 1688: yy_size_t new_size = b->yy_buf_size * 2;
1.1 deraadt 1689:
1690: if ( new_size <= 0 )
1691: b->yy_buf_size += b->yy_buf_size / 8;
1692: else
1693: b->yy_buf_size *= 2;
1694:
1695: b->yy_ch_buf = (char *)
1696: /* Include room in for 2 EOB chars. */
1.13 ! tedu 1697: yyrealloc( (void *) b->yy_ch_buf,
! 1698: b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
1.1 deraadt 1699: }
1700: else
1701: /* Can't grow it, we don't own it. */
1702: b->yy_ch_buf = 0;
1703:
1704: if ( ! b->yy_ch_buf )
1705: YY_FATAL_ERROR(
1706: "fatal error - scanner input buffer overflow" );
1707:
1.13 ! tedu 1708: YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1.1 deraadt 1709:
1.13 ! tedu 1710: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1.1 deraadt 1711: number_to_move - 1;
1.13 ! tedu 1712: ]])
1.1 deraadt 1713: }
1714:
1715: if ( num_to_read > YY_READ_BUF_SIZE )
1716: num_to_read = YY_READ_BUF_SIZE;
1717:
1718: /* Read in more data. */
1.13 ! tedu 1719: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
! 1720: YY_G(yy_n_chars), num_to_read );
1.4 millert 1721:
1.13 ! tedu 1722: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
1.1 deraadt 1723: }
1724:
1.13 ! tedu 1725: if ( YY_G(yy_n_chars) == 0 )
1.1 deraadt 1726: {
1727: if ( number_to_move == YY_MORE_ADJ )
1728: {
1729: ret_val = EOB_ACT_END_OF_FILE;
1.13 ! tedu 1730: yyrestart( yyin M4_YY_CALL_LAST_ARG);
1.1 deraadt 1731: }
1732:
1733: else
1734: {
1735: ret_val = EOB_ACT_LAST_MATCH;
1.13 ! tedu 1736: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1.1 deraadt 1737: YY_BUFFER_EOF_PENDING;
1738: }
1739: }
1740:
1741: else
1742: ret_val = EOB_ACT_CONTINUE_SCAN;
1743:
1.13 ! tedu 1744: if ((yy_size_t) (YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
! 1745: /* Extend the array by 50%, plus the number we really need. */
! 1746: yy_size_t new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);
! 1747: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
! 1748: (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size M4_YY_CALL_LAST_ARG );
! 1749: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
! 1750: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
! 1751: }
! 1752:
! 1753: YY_G(yy_n_chars) += number_to_move;
! 1754: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
! 1755: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1.1 deraadt 1756:
1.13 ! tedu 1757: YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1.1 deraadt 1758:
1759: return ret_val;
1.13 ! tedu 1760: }
! 1761: ]])
1.1 deraadt 1762:
1763: /* yy_get_previous_state - get the state just before the EOB char was reached */
1764:
1.13 ! tedu 1765: %if-c-only
! 1766: %not-for-header
! 1767: static yy_state_type yy_get_previous_state YYFARGS0(void)
! 1768: %endif
! 1769: %if-c++-only
! 1770: yy_state_type yyFlexLexer::yy_get_previous_state()
! 1771: %endif
! 1772: {
! 1773: yy_state_type yy_current_state;
! 1774: char *yy_cp;
! 1775: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1776:
1.13 ! tedu 1777: %% [15.0] code to get the start state into yy_current_state goes here
1.1 deraadt 1778:
1.13 ! tedu 1779: for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
1.1 deraadt 1780: {
1.13 ! tedu 1781: %% [16.0] code to find the next state goes here
1.1 deraadt 1782: }
1783:
1784: return yy_current_state;
1.13 ! tedu 1785: }
1.1 deraadt 1786:
1787:
1788: /* yy_try_NUL_trans - try to make a transition on the NUL character
1789: *
1790: * synopsis
1791: * next_state = yy_try_NUL_trans( current_state );
1792: */
1.13 ! tedu 1793: %if-c-only
! 1794: static yy_state_type yy_try_NUL_trans YYFARGS1( yy_state_type, yy_current_state)
! 1795: %endif
! 1796: %if-c++-only
! 1797: yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
! 1798: %endif
! 1799: {
! 1800: int yy_is_jam;
! 1801: M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */
! 1802: %% [17.0] code to find the next state, and perhaps do backing up, goes here
1.1 deraadt 1803:
1.13 ! tedu 1804: M4_YY_NOOP_GUTS_VAR();
! 1805: return yy_is_jam ? 0 : yy_current_state;
! 1806: }
1.1 deraadt 1807:
1808:
1.13 ! tedu 1809: %if-c-only
! 1810: m4_ifdef( [[M4_YY_NO_UNPUT]],,
! 1811: [[
! 1812: static void yyunput YYFARGS2( int,c, char *,yy_bp)
! 1813: %endif
! 1814: %if-c++-only
! 1815: void yyFlexLexer::yyunput( int c, char* yy_bp)
! 1816: %endif
! 1817: {
! 1818: char *yy_cp;
! 1819: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1820:
1.13 ! tedu 1821: yy_cp = YY_G(yy_c_buf_p);
1.1 deraadt 1822:
1823: /* undo effects of setting up yytext */
1.13 ! tedu 1824: *yy_cp = YY_G(yy_hold_char);
1.1 deraadt 1825:
1.13 ! tedu 1826: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1.1 deraadt 1827: { /* need to shift things up to make room */
1828: /* +2 for EOB chars. */
1.13 ! tedu 1829: yy_size_t number_to_move = YY_G(yy_n_chars) + 2;
! 1830: char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
! 1831: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
! 1832: char *source =
! 1833: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1.1 deraadt 1834:
1.13 ! tedu 1835: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1.1 deraadt 1836: *--dest = *--source;
1837:
1838: yy_cp += (int) (dest - source);
1839: yy_bp += (int) (dest - source);
1.13 ! tedu 1840: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
! 1841: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1.1 deraadt 1842:
1.13 ! tedu 1843: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1.1 deraadt 1844: YY_FATAL_ERROR( "flex scanner push-back overflow" );
1845: }
1846:
1847: *--yy_cp = (char) c;
1848:
1.13 ! tedu 1849: %% [18.0] update yylineno here
! 1850: m4_ifdef( [[M4_YY_USE_LINENO]],
! 1851: [[
! 1852: if ( c == '\n' ){
! 1853: --yylineno;
! 1854: }
! 1855: ]])
! 1856:
! 1857: YY_G(yytext_ptr) = yy_bp;
! 1858: YY_G(yy_hold_char) = *yy_cp;
! 1859: YY_G(yy_c_buf_p) = yy_cp;
! 1860: }
! 1861: %if-c-only
! 1862: ]])
! 1863: %endif
1.1 deraadt 1864:
1.13 ! tedu 1865: %if-c-only
1.11 millert 1866: #ifndef YY_NO_INPUT
1.1 deraadt 1867: #ifdef __cplusplus
1.13 ! tedu 1868: static int yyinput YYFARGS0(void)
1.1 deraadt 1869: #else
1.13 ! tedu 1870: static int input YYFARGS0(void)
1.1 deraadt 1871: #endif
1.13 ! tedu 1872:
! 1873: %endif
! 1874: %if-c++-only
! 1875: int yyFlexLexer::yyinput()
! 1876: %endif
! 1877: {
1.1 deraadt 1878: int c;
1.13 ! tedu 1879: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 1880:
1.13 ! tedu 1881: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
1.1 deraadt 1882:
1.13 ! tedu 1883: if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1.1 deraadt 1884: {
1885: /* yy_c_buf_p now points to the character we want to return.
1886: * If this occurs *before* the EOB characters, then it's a
1887: * valid NUL; if not, then we've hit the end of the buffer.
1888: */
1.13 ! tedu 1889: if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
1.1 deraadt 1890: /* This was really a NUL. */
1.13 ! tedu 1891: *YY_G(yy_c_buf_p) = '\0';
1.1 deraadt 1892:
1893: else
1894: { /* need more input */
1.13 ! tedu 1895: yy_size_t offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
! 1896: ++YY_G(yy_c_buf_p);
1.1 deraadt 1897:
1.13 ! tedu 1898: switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1899: {
1.4 millert 1900: case EOB_ACT_LAST_MATCH:
1901: /* This happens because yy_g_n_b()
1902: * sees that we've accumulated a
1903: * token and flags that we need to
1904: * try matching the token before
1905: * proceeding. But for input(),
1906: * there's no matching to consider.
1907: * So convert the EOB_ACT_LAST_MATCH
1908: * to EOB_ACT_END_OF_FILE.
1909: */
1910:
1911: /* Reset buffer status. */
1.13 ! tedu 1912: yyrestart( yyin M4_YY_CALL_LAST_ARG);
1.4 millert 1913:
1.13 ! tedu 1914: /*FALLTHROUGH*/
1.4 millert 1915:
1.1 deraadt 1916: case EOB_ACT_END_OF_FILE:
1917: {
1.13 ! tedu 1918: if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
1.1 deraadt 1919: return EOF;
1920:
1.13 ! tedu 1921: if ( ! YY_G(yy_did_buffer_switch_on_eof) )
1.1 deraadt 1922: YY_NEW_FILE;
1923: #ifdef __cplusplus
1.13 ! tedu 1924: return yyinput(M4_YY_CALL_ONLY_ARG);
1.1 deraadt 1925: #else
1.13 ! tedu 1926: return input(M4_YY_CALL_ONLY_ARG);
1.1 deraadt 1927: #endif
1928: }
1929:
1930: case EOB_ACT_CONTINUE_SCAN:
1.13 ! tedu 1931: YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
1.1 deraadt 1932: break;
1933: }
1934: }
1935: }
1936:
1.13 ! tedu 1937: c = *(unsigned char *) YY_G(yy_c_buf_p); /* cast for 8-bit char's */
! 1938: *YY_G(yy_c_buf_p) = '\0'; /* preserve yytext */
! 1939: YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);
1.1 deraadt 1940:
1.13 ! tedu 1941: %% [19.0] update BOL and yylineno
1.1 deraadt 1942:
1943: return c;
1.13 ! tedu 1944: }
! 1945: %if-c-only
1.11 millert 1946: #endif /* ifndef YY_NO_INPUT */
1.13 ! tedu 1947: %endif
1.1 deraadt 1948:
1.13 ! tedu 1949: /** Immediately switch to a different input stream.
! 1950: * @param input_file A readable stream.
! 1951: * M4_YY_DOC_PARAM
! 1952: * @note This function does not reset the start condition to @c INITIAL .
! 1953: */
! 1954: %if-c-only
! 1955: void yyrestart YYFARGS1( FILE *,input_file)
! 1956: %endif
! 1957: %if-c++-only
! 1958: void yyFlexLexer::yyrestart( std::istream* input_file )
! 1959: %endif
! 1960: {
! 1961: M4_YY_DECL_GUTS_VAR();
! 1962:
! 1963: if ( ! YY_CURRENT_BUFFER ){
! 1964: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
! 1965: YY_CURRENT_BUFFER_LVALUE =
! 1966: yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
! 1967: }
! 1968:
! 1969: yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG);
! 1970: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
! 1971: }
! 1972:
! 1973: /** Switch to a different input buffer.
! 1974: * @param new_buffer The new input buffer.
! 1975: * M4_YY_DOC_PARAM
! 1976: */
! 1977: %if-c-only
! 1978: void yy_switch_to_buffer YYFARGS1( YY_BUFFER_STATE ,new_buffer)
! 1979: %endif
! 1980: %if-c++-only
! 1981: void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
! 1982: %endif
! 1983: {
! 1984: M4_YY_DECL_GUTS_VAR();
! 1985:
! 1986: /* TODO. We should be able to replace this entire function body
! 1987: * with
! 1988: * yypop_buffer_state();
! 1989: * yypush_buffer_state(new_buffer);
! 1990: */
! 1991: yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
! 1992: if ( YY_CURRENT_BUFFER == new_buffer )
1.1 deraadt 1993: return;
1994:
1.13 ! tedu 1995: if ( YY_CURRENT_BUFFER )
1.1 deraadt 1996: {
1997: /* Flush out information for old buffer. */
1.13 ! tedu 1998: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
! 1999: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
! 2000: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
1.1 deraadt 2001: }
2002:
1.13 ! tedu 2003: YY_CURRENT_BUFFER_LVALUE = new_buffer;
! 2004: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
1.1 deraadt 2005:
2006: /* We don't actually know whether we did this switch during
2007: * EOF (yywrap()) processing, but the only time this flag
2008: * is looked at is after yywrap() is called, so it's safe
2009: * to go ahead and always set it.
2010: */
1.13 ! tedu 2011: YY_G(yy_did_buffer_switch_on_eof) = 1;
! 2012: }
1.1 deraadt 2013:
2014:
1.13 ! tedu 2015: %if-c-only
! 2016: static void yy_load_buffer_state YYFARGS0(void)
! 2017: %endif
! 2018: %if-c++-only
! 2019: void yyFlexLexer::yy_load_buffer_state()
! 2020: %endif
! 2021: {
! 2022: M4_YY_DECL_GUTS_VAR();
! 2023: YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
! 2024: YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
! 2025: yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
! 2026: YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
! 2027: }
! 2028:
! 2029: /** Allocate and initialize an input buffer state.
! 2030: * @param file A readable stream.
! 2031: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
! 2032: * M4_YY_DOC_PARAM
! 2033: * @return the allocated buffer state.
! 2034: */
! 2035: %if-c-only
! 2036: YY_BUFFER_STATE yy_create_buffer YYFARGS2( FILE *,file, int ,size)
! 2037: %endif
! 2038: %if-c++-only
! 2039: YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
! 2040: %endif
! 2041: {
1.1 deraadt 2042: YY_BUFFER_STATE b;
1.13 ! tedu 2043: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2044:
1.13 ! tedu 2045: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
1.1 deraadt 2046: if ( ! b )
2047: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2048:
2049: b->yy_buf_size = size;
2050:
2051: /* yy_ch_buf has to be 2 characters longer than the size given because
2052: * we need to put in 2 end-of-buffer characters.
2053: */
1.13 ! tedu 2054: b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
1.1 deraadt 2055: if ( ! b->yy_ch_buf )
2056: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2057:
2058: b->yy_is_our_buffer = 1;
2059:
1.13 ! tedu 2060: yy_init_buffer( b, file M4_YY_CALL_LAST_ARG);
1.1 deraadt 2061:
2062: return b;
1.13 ! tedu 2063: }
1.1 deraadt 2064:
1.13 ! tedu 2065: /** Destroy the buffer.
! 2066: * @param b a buffer created with yy_create_buffer()
! 2067: * M4_YY_DOC_PARAM
! 2068: */
! 2069: %if-c-only
! 2070: void yy_delete_buffer YYFARGS1( YY_BUFFER_STATE ,b)
! 2071: %endif
! 2072: %if-c++-only
! 2073: void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
! 2074: %endif
! 2075: {
! 2076: M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2077:
2078: if ( ! b )
2079: return;
2080:
1.13 ! tedu 2081: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
! 2082: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1.1 deraadt 2083:
2084: if ( b->yy_is_our_buffer )
1.13 ! tedu 2085: yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG );
1.1 deraadt 2086:
1.13 ! tedu 2087: yyfree( (void *) b M4_YY_CALL_LAST_ARG );
! 2088: }
1.1 deraadt 2089:
2090:
1.13 ! tedu 2091: /* Initializes or reinitializes a buffer.
! 2092: * This function is sometimes called more than once on the same buffer,
! 2093: * such as during a yyrestart() or at EOF.
! 2094: */
! 2095: %if-c-only
! 2096: static void yy_init_buffer YYFARGS2( YY_BUFFER_STATE ,b, FILE *,file)
! 2097: %endif
! 2098: %if-c++-only
! 2099: void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
! 2100: %endif
1.1 deraadt 2101:
1.13 ! tedu 2102: {
1.6 millert 2103: int oerrno = errno;
1.13 ! tedu 2104: M4_YY_DECL_GUTS_VAR();
1.6 millert 2105:
1.13 ! tedu 2106: yy_flush_buffer( b M4_YY_CALL_LAST_ARG);
1.1 deraadt 2107:
2108: b->yy_input_file = file;
2109: b->yy_fill_buffer = 1;
2110:
1.13 ! tedu 2111: /* If b is the current buffer, then yy_init_buffer was _probably_
! 2112: * called from yyrestart() or through yy_get_next_buffer.
! 2113: * In that case, we don't want to reset the lineno or column.
! 2114: */
! 2115: if (b != YY_CURRENT_BUFFER){
! 2116: b->yy_bs_lineno = 1;
! 2117: b->yy_bs_column = 0;
! 2118: }
! 2119:
! 2120: %if-c-only
! 2121: m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]],
! 2122: [[
1.1 deraadt 2123: b->yy_is_interactive = 1;
1.13 ! tedu 2124: ]],
! 2125: [[
! 2126: m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],
! 2127: [[
! 2128: b->yy_is_interactive = 0;
! 2129: ]],
! 2130: [[
! 2131: b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
! 2132: ]])
! 2133: ]])
! 2134: %endif
! 2135: %if-c++-only
1.1 deraadt 2136: b->yy_is_interactive = 0;
1.13 ! tedu 2137: %endif
1.6 millert 2138: errno = oerrno;
1.13 ! tedu 2139: }
1.1 deraadt 2140:
1.13 ! tedu 2141: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
! 2142: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
! 2143: * M4_YY_DOC_PARAM
! 2144: */
! 2145: %if-c-only
! 2146: void yy_flush_buffer YYFARGS1( YY_BUFFER_STATE ,b)
! 2147: %endif
! 2148: %if-c++-only
! 2149: void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
! 2150: %endif
! 2151: {
! 2152: M4_YY_DECL_GUTS_VAR();
1.4 millert 2153: if ( ! b )
2154: return;
2155:
1.1 deraadt 2156: b->yy_n_chars = 0;
2157:
2158: /* We always need two end-of-buffer characters. The first causes
2159: * a transition to the end-of-buffer state. The second causes
2160: * a jam in that state.
2161: */
2162: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2163: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2164:
2165: b->yy_buf_pos = &b->yy_ch_buf[0];
2166:
2167: b->yy_at_bol = 1;
2168: b->yy_buffer_status = YY_BUFFER_NEW;
2169:
1.13 ! tedu 2170: if ( b == YY_CURRENT_BUFFER )
! 2171: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
! 2172: }
! 2173:
! 2174: %if-c-or-c++
! 2175: /** Pushes the new state onto the stack. The new state becomes
! 2176: * the current state. This function will allocate the stack
! 2177: * if necessary.
! 2178: * @param new_buffer The new state.
! 2179: * M4_YY_DOC_PARAM
! 2180: */
! 2181: %if-c-only
! 2182: void yypush_buffer_state YYFARGS1(YY_BUFFER_STATE,new_buffer)
! 2183: %endif
! 2184: %if-c++-only
! 2185: void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
! 2186: %endif
! 2187: {
! 2188: M4_YY_DECL_GUTS_VAR();
! 2189: if (new_buffer == NULL)
! 2190: return;
! 2191:
! 2192: yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG);
! 2193:
! 2194: /* This block is copied from yy_switch_to_buffer. */
! 2195: if ( YY_CURRENT_BUFFER )
! 2196: {
! 2197: /* Flush out information for old buffer. */
! 2198: *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
! 2199: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
! 2200: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
! 2201: }
! 2202:
! 2203: /* Only push if top exists. Otherwise, replace top. */
! 2204: if (YY_CURRENT_BUFFER)
! 2205: YY_G(yy_buffer_stack_top)++;
! 2206: YY_CURRENT_BUFFER_LVALUE = new_buffer;
! 2207:
! 2208: /* copied from yy_switch_to_buffer. */
! 2209: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
! 2210: YY_G(yy_did_buffer_switch_on_eof) = 1;
! 2211: }
! 2212: %endif
! 2213:
! 2214:
! 2215: %if-c-or-c++
! 2216: /** Removes and deletes the top of the stack, if present.
! 2217: * The next element becomes the new top.
! 2218: * M4_YY_DOC_PARAM
! 2219: */
! 2220: %if-c-only
! 2221: void yypop_buffer_state YYFARGS0(void)
! 2222: %endif
! 2223: %if-c++-only
! 2224: void yyFlexLexer::yypop_buffer_state (void)
! 2225: %endif
! 2226: {
! 2227: M4_YY_DECL_GUTS_VAR();
! 2228: if (!YY_CURRENT_BUFFER)
! 2229: return;
! 2230:
! 2231: yy_delete_buffer(YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
! 2232: YY_CURRENT_BUFFER_LVALUE = NULL;
! 2233: if (YY_G(yy_buffer_stack_top) > 0)
! 2234: --YY_G(yy_buffer_stack_top);
! 2235:
! 2236: if (YY_CURRENT_BUFFER) {
! 2237: yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
! 2238: YY_G(yy_did_buffer_switch_on_eof) = 1;
! 2239: }
! 2240: }
! 2241: %endif
! 2242:
! 2243:
! 2244: %if-c-or-c++
! 2245: /* Allocates the stack if it does not exist.
! 2246: * Guarantees space for at least one push.
! 2247: */
! 2248: %if-c-only
! 2249: static void yyensure_buffer_stack YYFARGS0(void)
! 2250: %endif
! 2251: %if-c++-only
! 2252: void yyFlexLexer::yyensure_buffer_stack(void)
! 2253: %endif
! 2254: {
! 2255: yy_size_t num_to_alloc;
! 2256: M4_YY_DECL_GUTS_VAR();
! 2257:
! 2258: if (!YY_G(yy_buffer_stack)) {
! 2259:
! 2260: /* First allocation is just for 2 elements, since we don't know if this
! 2261: * scanner will even need a stack. We use 2 instead of 1 to avoid an
! 2262: * immediate realloc on the next call.
! 2263: */
! 2264: num_to_alloc = 1;
! 2265: YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
! 2266: (num_to_alloc * sizeof(struct yy_buffer_state*)
! 2267: M4_YY_CALL_LAST_ARG);
! 2268: if ( ! YY_G(yy_buffer_stack) )
! 2269: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
! 2270:
! 2271:
! 2272: memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
! 2273:
! 2274: YY_G(yy_buffer_stack_max) = num_to_alloc;
! 2275: YY_G(yy_buffer_stack_top) = 0;
! 2276: return;
1.1 deraadt 2277: }
2278:
1.13 ! tedu 2279: if (YY_G(yy_buffer_stack_top) >= (YY_G(yy_buffer_stack_max)) - 1){
1.1 deraadt 2280:
1.13 ! tedu 2281: /* Increase the buffer to prepare for a possible push. */
! 2282: int grow_size = 8 /* arbitrary grow size */;
! 2283:
! 2284: num_to_alloc = YY_G(yy_buffer_stack_max) + grow_size;
! 2285: YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
! 2286: (YY_G(yy_buffer_stack),
! 2287: num_to_alloc * sizeof(struct yy_buffer_state*)
! 2288: M4_YY_CALL_LAST_ARG);
! 2289: if ( ! YY_G(yy_buffer_stack) )
! 2290: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
! 2291:
! 2292: /* zero only the new slots.*/
! 2293: memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
! 2294: YY_G(yy_buffer_stack_max) = num_to_alloc;
! 2295: }
! 2296: }
! 2297: %endif
! 2298:
! 2299:
! 2300:
! 2301:
! 2302: m4_ifdef( [[M4_YY_NO_SCAN_BUFFER]],,
! 2303: [[
! 2304: %if-c-only
! 2305: /** Setup the input buffer state to scan directly from a user-specified character buffer.
! 2306: * @param base the character buffer
! 2307: * @param size the size in bytes of the character buffer
! 2308: * M4_YY_DOC_PARAM
! 2309: * @return the newly allocated buffer state object.
! 2310: */
! 2311: YY_BUFFER_STATE yy_scan_buffer YYFARGS2( char *,base, yy_size_t ,size)
! 2312: {
1.1 deraadt 2313: YY_BUFFER_STATE b;
1.13 ! tedu 2314: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2315:
2316: if ( size < 2 ||
2317: base[size-2] != YY_END_OF_BUFFER_CHAR ||
2318: base[size-1] != YY_END_OF_BUFFER_CHAR )
2319: /* They forgot to leave room for the EOB's. */
2320: return 0;
2321:
1.13 ! tedu 2322: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
1.1 deraadt 2323: if ( ! b )
2324: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2325:
2326: b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2327: b->yy_buf_pos = b->yy_ch_buf = base;
2328: b->yy_is_our_buffer = 0;
2329: b->yy_input_file = 0;
2330: b->yy_n_chars = b->yy_buf_size;
2331: b->yy_is_interactive = 0;
2332: b->yy_at_bol = 1;
2333: b->yy_fill_buffer = 0;
2334: b->yy_buffer_status = YY_BUFFER_NEW;
2335:
1.13 ! tedu 2336: yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG );
1.1 deraadt 2337:
2338: return b;
1.13 ! tedu 2339: }
! 2340: %endif
! 2341: ]])
1.1 deraadt 2342:
2343:
1.13 ! tedu 2344: m4_ifdef( [[M4_YY_NO_SCAN_STRING]],,
! 2345: [[
! 2346: %if-c-only
! 2347: /** Setup the input buffer state to scan a string. The next call to yylex() will
! 2348: * scan from a @e copy of @a str.
! 2349: * @param yystr a NUL-terminated string to scan
! 2350: * M4_YY_DOC_PARAM
! 2351: * @return the newly allocated buffer state object.
! 2352: * @note If you want to scan bytes that may contain NUL values, then use
! 2353: * yy_scan_bytes() instead.
! 2354: */
! 2355: YY_BUFFER_STATE yy_scan_string YYFARGS1( yyconst char *, yystr)
! 2356: {
! 2357: m4_dnl M4_YY_DECL_GUTS_VAR();
! 2358:
! 2359: return yy_scan_bytes( yystr, strlen(yystr) M4_YY_CALL_LAST_ARG);
! 2360: }
! 2361: %endif
! 2362: ]])
! 2363:
! 2364:
! 2365: m4_ifdef( [[M4_YY_NO_SCAN_BYTES]],,
! 2366: [[
! 2367: %if-c-only
! 2368: /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
! 2369: * scan from a @e copy of @a bytes.
! 2370: * @param yybytes the byte buffer to scan
! 2371: * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
! 2372: * M4_YY_DOC_PARAM
! 2373: * @return the newly allocated buffer state object.
! 2374: */
! 2375: YY_BUFFER_STATE yy_scan_bytes YYFARGS2( yyconst char *,yybytes, yy_size_t ,_yybytes_len)
! 2376: {
1.1 deraadt 2377: YY_BUFFER_STATE b;
2378: char *buf;
2379: yy_size_t n;
1.13 ! tedu 2380: yy_size_t i;
! 2381: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2382:
2383: /* Get memory for full buffer, including space for trailing EOB's. */
1.13 ! tedu 2384: n = _yybytes_len + 2;
! 2385: buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG );
1.1 deraadt 2386: if ( ! buf )
2387: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2388:
1.13 ! tedu 2389: for ( i = 0; i < _yybytes_len; ++i )
! 2390: buf[i] = yybytes[i];
1.1 deraadt 2391:
1.13 ! tedu 2392: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1.1 deraadt 2393:
1.13 ! tedu 2394: b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG);
1.1 deraadt 2395: if ( ! b )
2396: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2397:
2398: /* It's okay to grow etc. this buffer, and we should throw it
2399: * away when we're done.
2400: */
2401: b->yy_is_our_buffer = 1;
2402:
2403: return b;
1.13 ! tedu 2404: }
! 2405: %endif
! 2406: ]])
! 2407:
! 2408:
! 2409: m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
! 2410: [[
! 2411: %if-c-only
! 2412: static void yy_push_state YYFARGS1( int ,new_state)
! 2413: %endif
! 2414: %if-c++-only
! 2415: void yyFlexLexer::yy_push_state( int new_state )
! 2416: %endif
! 2417: {
! 2418: M4_YY_DECL_GUTS_VAR();
! 2419: if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) )
1.1 deraadt 2420: {
2421: yy_size_t new_size;
2422:
1.13 ! tedu 2423: YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
! 2424: new_size = YY_G(yy_start_stack_depth) * sizeof( int );
1.1 deraadt 2425:
1.13 ! tedu 2426: if ( ! YY_G(yy_start_stack) )
! 2427: YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG );
1.1 deraadt 2428:
2429: else
1.13 ! tedu 2430: YY_G(yy_start_stack) = (int *) yyrealloc(
! 2431: (void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG );
1.1 deraadt 2432:
1.13 ! tedu 2433: if ( ! YY_G(yy_start_stack) )
! 2434: YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1.1 deraadt 2435: }
2436:
1.13 ! tedu 2437: YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START;
1.1 deraadt 2438:
2439: BEGIN(new_state);
1.13 ! tedu 2440: }
! 2441: ]])
1.1 deraadt 2442:
2443:
1.13 ! tedu 2444: m4_ifdef( [[M4_YY_NO_POP_STATE]],,
! 2445: [[
! 2446: %if-c-only
! 2447: static void yy_pop_state YYFARGS0(void)
! 2448: %endif
! 2449: %if-c++-only
! 2450: void yyFlexLexer::yy_pop_state()
! 2451: %endif
! 2452: {
! 2453: M4_YY_DECL_GUTS_VAR();
! 2454: if ( --YY_G(yy_start_stack_ptr) < 0 )
1.1 deraadt 2455: YY_FATAL_ERROR( "start-condition stack underflow" );
2456:
1.13 ! tedu 2457: BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
! 2458: }
! 2459: ]])
! 2460:
! 2461:
! 2462: m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
! 2463: [[
! 2464: %if-c-only
! 2465: static int yy_top_state YYFARGS0(void)
! 2466: %endif
! 2467: %if-c++-only
! 2468: int yyFlexLexer::yy_top_state()
! 2469: %endif
! 2470: {
! 2471: M4_YY_DECL_GUTS_VAR();
! 2472: return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1];
! 2473: }
! 2474: ]])
1.1 deraadt 2475:
2476: #ifndef YY_EXIT_FAILURE
2477: #define YY_EXIT_FAILURE 2
2478: #endif
2479:
1.13 ! tedu 2480: %if-c-only
! 2481: static void yy_fatal_error YYFARGS1(yyconst char*, msg)
! 2482: {
! 2483: m4_dnl M4_YY_DECL_GUTS_VAR();
1.1 deraadt 2484: (void) fprintf( stderr, "%s\n", msg );
2485: exit( YY_EXIT_FAILURE );
1.13 ! tedu 2486: }
! 2487: %endif
! 2488: %if-c++-only
1.1 deraadt 2489: void yyFlexLexer::LexerError( yyconst char msg[] )
1.13 ! tedu 2490: {
! 2491: M4_YY_DECL_GUTS_VAR();
! 2492: std::cerr << msg << std::endl;
1.1 deraadt 2493: exit( YY_EXIT_FAILURE );
1.13 ! tedu 2494: }
! 2495: %endif
1.1 deraadt 2496:
2497: /* Redefine yyless() so it works in section 3 code. */
2498:
2499: #undef yyless
2500: #define yyless(n) \
2501: do \
2502: { \
2503: /* Undo effects of setting up yytext. */ \
1.13 ! tedu 2504: int yyless_macro_arg = (n); \
! 2505: YY_LESS_LINENO(yyless_macro_arg);\
! 2506: yytext[yyleng] = YY_G(yy_hold_char); \
! 2507: YY_G(yy_c_buf_p) = yytext + yyless_macro_arg; \
! 2508: YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
! 2509: *YY_G(yy_c_buf_p) = '\0'; \
! 2510: yyleng = yyless_macro_arg; \
1.1 deraadt 2511: } \
2512: while ( 0 )
2513:
2514:
2515:
1.13 ! tedu 2516: /* Accessor methods (get/set functions) to struct members. */
! 2517:
! 2518: %if-c-only
! 2519: %if-reentrant
! 2520: m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
! 2521: [[
! 2522: /** Get the user-defined data for this scanner.
! 2523: * M4_YY_DOC_PARAM
! 2524: */
! 2525: YY_EXTRA_TYPE yyget_extra YYFARGS0(void)
! 2526: {
! 2527: M4_YY_DECL_GUTS_VAR();
! 2528: return yyextra;
! 2529: }
! 2530: ]])
! 2531: %endif
! 2532:
! 2533: m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
! 2534: [[
! 2535: /** Get the current line number.
! 2536: * M4_YY_DOC_PARAM
! 2537: */
! 2538: int yyget_lineno YYFARGS0(void)
! 2539: {
! 2540: M4_YY_DECL_GUTS_VAR();
! 2541:
! 2542: m4_ifdef( [[M4_YY_REENTRANT]],
! 2543: [[
! 2544: if (! YY_CURRENT_BUFFER)
! 2545: return 0;
! 2546: ]])
! 2547: return yylineno;
! 2548: }
! 2549: ]])
! 2550:
! 2551: m4_ifdef( [[M4_YY_REENTRANT]],
! 2552: [[
! 2553: m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
! 2554: [[
! 2555: /** Get the current column number.
! 2556: * M4_YY_DOC_PARAM
! 2557: */
! 2558: int yyget_column YYFARGS0(void)
! 2559: {
! 2560: M4_YY_DECL_GUTS_VAR();
! 2561:
! 2562: m4_ifdef( [[M4_YY_REENTRANT]],
! 2563: [[
! 2564: if (! YY_CURRENT_BUFFER)
! 2565: return 0;
! 2566: ]])
! 2567: return yycolumn;
! 2568: }
! 2569: ]])
! 2570: ]])
! 2571:
! 2572: m4_ifdef( [[M4_YY_NO_GET_IN]],,
! 2573: [[
! 2574: /** Get the input stream.
! 2575: * M4_YY_DOC_PARAM
! 2576: */
! 2577: FILE *yyget_in YYFARGS0(void)
! 2578: {
! 2579: M4_YY_DECL_GUTS_VAR();
! 2580: return yyin;
! 2581: }
! 2582: ]])
! 2583:
! 2584: m4_ifdef( [[M4_YY_NO_GET_OUT]],,
! 2585: [[
! 2586: /** Get the output stream.
! 2587: * M4_YY_DOC_PARAM
! 2588: */
! 2589: FILE *yyget_out YYFARGS0(void)
! 2590: {
! 2591: M4_YY_DECL_GUTS_VAR();
! 2592: return yyout;
! 2593: }
! 2594: ]])
! 2595:
! 2596: m4_ifdef( [[M4_YY_NO_GET_LENG]],,
! 2597: [[
! 2598: /** Get the length of the current token.
! 2599: * M4_YY_DOC_PARAM
! 2600: */
! 2601: yy_size_t yyget_leng YYFARGS0(void)
! 2602: {
! 2603: M4_YY_DECL_GUTS_VAR();
! 2604: return yyleng;
! 2605: }
! 2606: ]])
! 2607:
! 2608: /** Get the current token.
! 2609: * M4_YY_DOC_PARAM
! 2610: */
! 2611: m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
! 2612: [[
! 2613: char *yyget_text YYFARGS0(void)
! 2614: {
! 2615: M4_YY_DECL_GUTS_VAR();
! 2616: return yytext;
! 2617: }
! 2618: ]])
! 2619:
! 2620: %if-reentrant
! 2621: m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
! 2622: [[
! 2623: /** Set the user-defined data. This data is never touched by the scanner.
! 2624: * @param user_defined The data to be associated with this scanner.
! 2625: * M4_YY_DOC_PARAM
! 2626: */
! 2627: void yyset_extra YYFARGS1( YY_EXTRA_TYPE ,user_defined)
! 2628: {
! 2629: M4_YY_DECL_GUTS_VAR();
! 2630: yyextra = user_defined ;
! 2631: }
! 2632: ]])
! 2633: %endif
! 2634:
! 2635: m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
! 2636: [[
! 2637: /** Set the current line number.
! 2638: * @param line_number
! 2639: * M4_YY_DOC_PARAM
! 2640: */
! 2641: void yyset_lineno YYFARGS1( int ,line_number)
! 2642: {
! 2643: M4_YY_DECL_GUTS_VAR();
! 2644:
! 2645: m4_ifdef( [[M4_YY_REENTRANT]],
! 2646: [[
! 2647: /* lineno is only valid if an input buffer exists. */
! 2648: if (! YY_CURRENT_BUFFER )
! 2649: YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
! 2650: ]])
! 2651: yylineno = line_number;
! 2652: }
! 2653: ]])
! 2654:
! 2655: m4_ifdef( [[M4_YY_REENTRANT]],
! 2656: [[
! 2657: m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
! 2658: [[
! 2659: /** Set the current column.
! 2660: * @param line_number
! 2661: * M4_YY_DOC_PARAM
! 2662: */
! 2663: void yyset_column YYFARGS1( int , column_no)
! 2664: {
! 2665: M4_YY_DECL_GUTS_VAR();
! 2666:
! 2667: m4_ifdef( [[M4_YY_REENTRANT]],
! 2668: [[
! 2669: /* column is only valid if an input buffer exists. */
! 2670: if (! YY_CURRENT_BUFFER )
! 2671: YY_FATAL_ERROR( "yyset_column called with no buffer" );
! 2672: ]])
! 2673: yycolumn = column_no;
! 2674: }
! 2675: ]])
! 2676: ]])
! 2677:
! 2678:
! 2679: m4_ifdef( [[M4_YY_NO_SET_IN]],,
! 2680: [[
! 2681: /** Set the input stream. This does not discard the current
! 2682: * input buffer.
! 2683: * @param in_str A readable stream.
! 2684: * M4_YY_DOC_PARAM
! 2685: * @see yy_switch_to_buffer
! 2686: */
! 2687: void yyset_in YYFARGS1( FILE * ,in_str)
! 2688: {
! 2689: M4_YY_DECL_GUTS_VAR();
! 2690: yyin = in_str ;
! 2691: }
! 2692: ]])
! 2693:
! 2694: m4_ifdef( [[M4_YY_NO_SET_OUT]],,
! 2695: [[
! 2696: void yyset_out YYFARGS1( FILE * ,out_str)
! 2697: {
! 2698: M4_YY_DECL_GUTS_VAR();
! 2699: yyout = out_str ;
! 2700: }
! 2701: ]])
! 2702:
! 2703:
! 2704: m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
! 2705: [[
! 2706: int yyget_debug YYFARGS0(void)
! 2707: {
! 2708: M4_YY_DECL_GUTS_VAR();
! 2709: return yy_flex_debug;
! 2710: }
! 2711: ]])
! 2712:
! 2713: m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
! 2714: [[
! 2715: void yyset_debug YYFARGS1( int ,bdebug)
! 2716: {
! 2717: M4_YY_DECL_GUTS_VAR();
! 2718: yy_flex_debug = bdebug ;
! 2719: }
! 2720: ]])
! 2721: %endif
! 2722:
! 2723: %if-reentrant
! 2724: /* Accessor methods for yylval and yylloc */
! 2725:
! 2726: %if-bison-bridge
! 2727: m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
! 2728: [[
! 2729: YYSTYPE * yyget_lval YYFARGS0(void)
! 2730: {
! 2731: M4_YY_DECL_GUTS_VAR();
! 2732: return yylval;
! 2733: }
! 2734: ]])
! 2735:
! 2736: m4_ifdef( [[M4_YY_NO_SET_LVAL]],,
! 2737: [[
! 2738: void yyset_lval YYFARGS1( YYSTYPE * ,yylval_param)
! 2739: {
! 2740: M4_YY_DECL_GUTS_VAR();
! 2741: yylval = yylval_param;
! 2742: }
! 2743: ]])
! 2744:
! 2745: m4_ifdef( [[<M4_YY_BISON_LLOC>]],
! 2746: [[
! 2747: m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
! 2748: [[
! 2749: YYLTYPE *yyget_lloc YYFARGS0(void)
! 2750: {
! 2751: M4_YY_DECL_GUTS_VAR();
! 2752: return yylloc;
! 2753: }
! 2754: ]])
! 2755:
! 2756: m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
! 2757: [[
! 2758: void yyset_lloc YYFARGS1( YYLTYPE * ,yylloc_param)
! 2759: {
! 2760: M4_YY_DECL_GUTS_VAR();
! 2761: yylloc = yylloc_param;
! 2762: }
! 2763: ]])
! 2764: ]])
! 2765:
! 2766: %endif
! 2767:
! 2768:
! 2769: /* User-visible API */
! 2770:
! 2771: /* yylex_init is special because it creates the scanner itself, so it is
! 2772: * the ONLY reentrant function that doesn't take the scanner as the last argument.
! 2773: * That's why we explicitly handle the declaration, instead of using our macros.
! 2774: */
! 2775: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
! 2776: [[
! 2777: int yylex_init( ptr_yy_globals )
! 2778: yyscan_t* ptr_yy_globals;
! 2779: ]],
! 2780: [[
! 2781: int yylex_init(yyscan_t* ptr_yy_globals)
! 2782: ]])
! 2783: {
! 2784: if (ptr_yy_globals == NULL){
! 2785: errno = EINVAL;
! 2786: return 1;
! 2787: }
! 2788:
! 2789: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
! 2790:
! 2791: if (*ptr_yy_globals == NULL){
! 2792: errno = ENOMEM;
! 2793: return 1;
! 2794: }
! 2795:
! 2796: /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
! 2797: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
! 2798:
! 2799: return yy_init_globals ( *ptr_yy_globals );
! 2800: }
! 2801:
! 2802:
! 2803: /* yylex_init_extra has the same functionality as yylex_init, but follows the
! 2804: * convention of taking the scanner as the last argument. Note however, that
! 2805: * this is a *pointer* to a scanner, as it will be allocated by this call (and
! 2806: * is the reason, too, why this function also must handle its own declaration).
! 2807: * The user defined value in the first argument will be available to yyalloc in
! 2808: * the yyextra field.
! 2809: */
! 2810: m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
! 2811: [[
! 2812: int yylex_init_extra( yy_user_defined, ptr_yy_globals )
! 2813: YY_EXTRA_TYPE yy_user_defined;
! 2814: yyscan_t* ptr_yy_globals;
! 2815: ]],
! 2816: [[
! 2817: int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
! 2818: ]])
! 2819: {
! 2820: struct yyguts_t dummy_yyguts;
! 2821:
! 2822: yyset_extra (yy_user_defined, &dummy_yyguts);
! 2823:
! 2824: if (ptr_yy_globals == NULL){
! 2825: errno = EINVAL;
! 2826: return 1;
! 2827: }
! 2828:
! 2829: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
! 2830:
! 2831: if (*ptr_yy_globals == NULL){
! 2832: errno = ENOMEM;
! 2833: return 1;
! 2834: }
! 2835:
! 2836: /* By setting to 0xAA, we expose bugs in
! 2837: yy_init_globals. Leave at 0x00 for releases. */
! 2838: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
! 2839:
! 2840: yyset_extra (yy_user_defined, *ptr_yy_globals);
! 2841:
! 2842: return yy_init_globals ( *ptr_yy_globals );
! 2843: }
! 2844:
! 2845: %endif if-c-only
! 2846:
! 2847:
! 2848: %if-c-only
! 2849: static int yy_init_globals YYFARGS0(void)
! 2850: {
! 2851: M4_YY_DECL_GUTS_VAR();
! 2852: /* Initialization is the same as for the non-reentrant scanner.
! 2853: * This function is called from yylex_destroy(), so don't allocate here.
! 2854: */
! 2855:
! 2856: m4_ifdef( [[M4_YY_USE_LINENO]],
! 2857: [[
! 2858: m4_ifdef( [[M4_YY_NOT_REENTRANT]],
! 2859: [[
! 2860: /* We do not touch yylineno unless the option is enabled. */
! 2861: yylineno = 1;
! 2862: ]])
! 2863: ]])
! 2864: YY_G(yy_buffer_stack) = 0;
! 2865: YY_G(yy_buffer_stack_top) = 0;
! 2866: YY_G(yy_buffer_stack_max) = 0;
! 2867: YY_G(yy_c_buf_p) = (char *) 0;
! 2868: YY_G(yy_init) = 0;
! 2869: YY_G(yy_start) = 0;
! 2870:
! 2871: m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
! 2872: [[
! 2873: YY_G(yy_start_stack_ptr) = 0;
! 2874: YY_G(yy_start_stack_depth) = 0;
! 2875: YY_G(yy_start_stack) = NULL;
! 2876: ]])
! 2877:
! 2878: m4_ifdef( [[M4_YY_USES_REJECT]],
! 2879: [[
! 2880: YY_G(yy_state_buf) = 0;
! 2881: YY_G(yy_state_ptr) = 0;
! 2882: YY_G(yy_full_match) = 0;
! 2883: YY_G(yy_lp) = 0;
! 2884: ]])
! 2885:
! 2886: m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
! 2887: [[
! 2888: YY_G(yytext_ptr) = 0;
! 2889: YY_G(yy_more_offset) = 0;
! 2890: YY_G(yy_prev_more_offset) = 0;
! 2891: ]])
! 2892:
! 2893: /* Defined in main.c */
! 2894: #ifdef YY_STDINIT
! 2895: yyin = stdin;
! 2896: yyout = stdout;
! 2897: #else
! 2898: yyin = (FILE *) 0;
! 2899: yyout = (FILE *) 0;
! 2900: #endif
! 2901:
! 2902: /* For future reference: Set errno on error, since we are called by
! 2903: * yylex_init()
! 2904: */
! 2905: return 0;
! 2906: }
! 2907: %endif
! 2908:
! 2909:
! 2910: %if-c-only SNIP! this currently causes conflicts with the c++ scanner
! 2911: /* yylex_destroy is for both reentrant and non-reentrant scanners. */
! 2912: int yylex_destroy YYFARGS0(void)
! 2913: {
! 2914: M4_YY_DECL_GUTS_VAR();
! 2915:
! 2916: /* Pop the buffer stack, destroying each element. */
! 2917: while(YY_CURRENT_BUFFER){
! 2918: yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG );
! 2919: YY_CURRENT_BUFFER_LVALUE = NULL;
! 2920: yypop_buffer_state(M4_YY_CALL_ONLY_ARG);
! 2921: }
! 2922:
! 2923: /* Destroy the stack itself. */
! 2924: yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG);
! 2925: YY_G(yy_buffer_stack) = NULL;
! 2926:
! 2927: m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
! 2928: [[
! 2929: /* Destroy the start condition stack. */
! 2930: yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG );
! 2931: YY_G(yy_start_stack) = NULL;
! 2932: ]])
! 2933:
! 2934: m4_ifdef( [[M4_YY_USES_REJECT]],
! 2935: [[
! 2936: yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG);
! 2937: YY_G(yy_state_buf) = NULL;
! 2938: ]])
! 2939:
! 2940: /* Reset the globals. This is important in a non-reentrant scanner so the next time
! 2941: * yylex() is called, initialization will occur. */
! 2942: yy_init_globals( M4_YY_CALL_ONLY_ARG);
! 2943:
! 2944: %if-reentrant
! 2945: /* Destroy the main struct (reentrant only). */
! 2946: yyfree ( yyscanner M4_YY_CALL_LAST_ARG );
! 2947: yyscanner = NULL;
! 2948: %endif
! 2949: return 0;
! 2950: }
! 2951: %endif
! 2952:
! 2953:
! 2954: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
! 2955: [[
! 2956: /*
! 2957: * Internal utility routines.
! 2958: */
! 2959: ]])
! 2960:
! 2961: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
! 2962: [[
1.1 deraadt 2963: #ifndef yytext_ptr
1.13 ! tedu 2964: static void yy_flex_strncpy YYFARGS3( char*,s1, yyconst char *,s2, int,n)
! 2965: {
! 2966: int i;
1.1 deraadt 2967: for ( i = 0; i < n; ++i )
2968: s1[i] = s2[i];
1.13 ! tedu 2969: }
1.3 millert 2970: #endif
1.13 ! tedu 2971: ]])
1.3 millert 2972:
1.13 ! tedu 2973: m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
! 2974: [[
1.3 millert 2975: #ifdef YY_NEED_STRLEN
1.13 ! tedu 2976: static int yy_flex_strlen YYFARGS1( yyconst char *,s)
! 2977: {
! 2978: int n;
1.3 millert 2979: for ( n = 0; s[n]; ++n )
2980: ;
2981:
2982: return n;
1.13 ! tedu 2983: }
1.1 deraadt 2984: #endif
1.13 ! tedu 2985: ]])
1.1 deraadt 2986:
1.13 ! tedu 2987: m4_ifdef( [[M4_YY_NO_FLEX_ALLOC]],,
! 2988: [[
! 2989: void *yyalloc YYFARGS1( yy_size_t ,size)
! 2990: {
1.1 deraadt 2991: return (void *) malloc( size );
1.13 ! tedu 2992: }
! 2993: ]])
1.1 deraadt 2994:
1.13 ! tedu 2995: m4_ifdef( [[M4_YY_NO_FLEX_REALLOC]],,
! 2996: [[
! 2997: void *yyrealloc YYFARGS2( void *,ptr, yy_size_t ,size)
! 2998: {
1.1 deraadt 2999: /* The cast to (char *) in the following accommodates both
3000: * implementations that use char* generic pointers, and those
3001: * that use void* generic pointers. It works with the latter
3002: * because both ANSI C and C++ allow castless assignment from
3003: * any pointer type to void*, and deal with argument conversions
3004: * as though doing an assignment.
3005: */
3006: return (void *) realloc( (char *) ptr, size );
1.13 ! tedu 3007: }
! 3008: ]])
1.1 deraadt 3009:
1.13 ! tedu 3010: m4_ifdef( [[M4_YY_NO_FLEX_FREE]],,
! 3011: [[
! 3012: void yyfree YYFARGS1( void *,ptr)
! 3013: {
! 3014: free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
! 3015: }
! 3016: ]])
! 3017:
! 3018: %if-tables-serialization definitions
! 3019: m4preproc_include(`tables_shared.c')
! 3020:
! 3021: static int yytbl_read8 (void *v, struct yytbl_reader * rd)
! 3022: {
! 3023: errno = 0;
! 3024: if (fread (v, sizeof (flex_uint8_t), 1, rd->fp) != 1){
! 3025: errno = EIO;
! 3026: return -1;
! 3027: }
! 3028: rd->bread += sizeof(flex_uint8_t);
! 3029: return 0;
! 3030: }
! 3031:
! 3032: static int yytbl_read16 (void *v, struct yytbl_reader * rd)
! 3033: {
! 3034: errno = 0;
! 3035: if (fread (v, sizeof (flex_uint16_t), 1, rd->fp) != 1){
! 3036: errno = EIO;
! 3037: return -1;
! 3038: }
! 3039: *((flex_uint16_t *) v) = ntohs (*((flex_uint16_t *) v));
! 3040: rd->bread += sizeof(flex_uint16_t);
! 3041: return 0;
! 3042: }
! 3043:
! 3044: static int yytbl_read32 (void *v, struct yytbl_reader * rd)
! 3045: {
! 3046: errno = 0;
! 3047: if (fread (v, sizeof (flex_uint32_t), 1, rd->fp) != 1){
! 3048: errno = EIO;
! 3049: return -1;
! 3050: }
! 3051: *((flex_uint32_t *) v) = ntohl (*((flex_uint32_t *) v));
! 3052: rd->bread += sizeof(flex_uint32_t);
! 3053: return 0;
! 3054: }
! 3055:
! 3056: /** Read the header */
! 3057: static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader *, rd)
! 3058: {
! 3059: int bytes;
! 3060: memset (th, 0, sizeof (struct yytbl_hdr));
! 3061:
! 3062: if (yytbl_read32 (&(th->th_magic), rd) != 0)
! 3063: return -1;
! 3064:
! 3065: if (th->th_magic != YYTBL_MAGIC){
! 3066: YY_FATAL_ERROR( "bad magic number" ); /* TODO: not fatal. */
! 3067: return -1;
! 3068: }
! 3069:
! 3070: if (yytbl_read32 (&(th->th_hsize), rd) != 0
! 3071: || yytbl_read32 (&(th->th_ssize), rd) != 0
! 3072: || yytbl_read16 (&(th->th_flags), rd) != 0)
! 3073: return -1;
! 3074:
! 3075: /* Sanity check on header size. Greater than 1k suggests some funny business. */
! 3076: if (th->th_hsize < 16 || th->th_hsize > 1024){
! 3077: YY_FATAL_ERROR( "insane header size detected" ); /* TODO: not fatal. */
! 3078: return -1;
! 3079: }
! 3080:
! 3081: /* Allocate enough space for the version and name fields */
! 3082: bytes = th->th_hsize - 14;
! 3083: th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
! 3084: if ( ! th->th_version )
! 3085: YY_FATAL_ERROR( "out of dynamic memory in yytbl_hdr_read()" );
! 3086:
! 3087: /* we read it all into th_version, and point th_name into that data */
! 3088: if (fread (th->th_version, 1, bytes, rd->fp) != bytes){
! 3089: errno = EIO;
! 3090: yyfree(th->th_version M4_YY_CALL_LAST_ARG);
! 3091: th->th_version = NULL;
! 3092: return -1;
! 3093: }
! 3094: else
! 3095: rd->bread += bytes;
! 3096:
! 3097: th->th_name = th->th_version + strlen (th->th_version) + 1;
! 3098: return 0;
! 3099: }
! 3100:
! 3101: /** lookup id in the dmap list.
! 3102: * @param dmap pointer to first element in list
! 3103: * @return NULL if not found.
! 3104: */
! 3105: static struct yytbl_dmap *yytbl_dmap_lookup YYFARGS2(struct yytbl_dmap *, dmap,
! 3106: int, id)
! 3107: {
! 3108: while (dmap->dm_id)
! 3109: if (dmap->dm_id == id)
! 3110: return dmap;
! 3111: else
! 3112: dmap++;
! 3113: return NULL;
! 3114: }
! 3115:
! 3116: /** Read a table while mapping its contents to the local array.
! 3117: * @param dmap used to performing mapping
! 3118: * @return 0 on success
! 3119: */
! 3120: static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_reader*, rd)
! 3121: {
! 3122: struct yytbl_data td;
! 3123: struct yytbl_dmap *transdmap=0;
! 3124: int len, i, rv, inner_loop_count;
! 3125: void *p=0;
! 3126:
! 3127: memset (&td, 0, sizeof (struct yytbl_data));
! 3128:
! 3129: if (yytbl_read16 (&td.td_id, rd) != 0
! 3130: || yytbl_read16 (&td.td_flags, rd) != 0
! 3131: || yytbl_read32 (&td.td_hilen, rd) != 0
! 3132: || yytbl_read32 (&td.td_lolen, rd) != 0)
! 3133: return -1;
! 3134:
! 3135: /* Lookup the map for the transition table so we have it in case we need it
! 3136: * inside the loop below. This scanner might not even have a transition
! 3137: * table, which is ok.
! 3138: */
! 3139: transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG);
! 3140:
! 3141: if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL){
! 3142: YY_FATAL_ERROR( "table id not found in map." ); /* TODO: not fatal. */
! 3143: return -1;
! 3144: }
! 3145:
! 3146: /* Allocate space for table.
! 3147: * The --full yy_transition table is a special case, since we
! 3148: * need the dmap.dm_sz entry to tell us the sizeof the individual
! 3149: * struct members.
! 3150: */
! 3151: {
! 3152: size_t bytes;
! 3153:
! 3154: if ((td.td_flags & YYTD_STRUCT))
! 3155: bytes = sizeof(struct yy_trans_info) * td.td_lolen * (td.td_hilen ? td.td_hilen : 1);
! 3156: else
! 3157: bytes = td.td_lolen * (td.td_hilen ? td.td_hilen : 1) * dmap->dm_sz;
! 3158:
! 3159: if(M4_YY_TABLES_VERIFY)
! 3160: /* We point to the array itself */
! 3161: p = dmap->dm_arr;
! 3162: else
! 3163: /* We point to the address of a pointer. */
! 3164: *dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
! 3165: if ( ! p )
! 3166: YY_FATAL_ERROR( "out of dynamic memory in yytbl_data_load()" );
! 3167: }
! 3168:
! 3169: /* If it's a struct, we read 2 integers to get one element */
! 3170: if ((td.td_flags & YYTD_STRUCT) != 0)
! 3171: inner_loop_count = 2;
! 3172: else
! 3173: inner_loop_count = 1;
! 3174:
! 3175: /* read and map each element.
! 3176: * This loop iterates once for each element of the td_data array.
! 3177: * Notice that we increment 'i' in the inner loop.
! 3178: */
! 3179: len = yytbl_calc_total_len (&td);
! 3180: for (i = 0; i < len; ){
! 3181: int j;
! 3182:
! 3183:
! 3184: /* This loop really executes exactly 1 or 2 times.
! 3185: * The second time is to handle the second member of the
! 3186: * YYTD_STRUCT for the yy_transition array.
! 3187: */
! 3188: for (j = 0; j < inner_loop_count; j++, i++) {
! 3189: flex_int32_t t32;
! 3190:
! 3191: /* read into t32 no matter what the real size is. */
! 3192: {
! 3193: flex_int16_t t16;
! 3194: flex_int8_t t8;
! 3195:
! 3196: switch (YYTDFLAGS2BYTES (td.td_flags)) {
! 3197: case sizeof (flex_int32_t):
! 3198: rv = yytbl_read32 (&t32, rd);
! 3199: break;
! 3200: case sizeof (flex_int16_t):
! 3201: rv = yytbl_read16 (&t16, rd);
! 3202: t32 = t16;
! 3203: break;
! 3204: case sizeof (flex_int8_t):
! 3205: rv = yytbl_read8 (&t8, rd);
! 3206: t32 = t8;
! 3207: break;
! 3208: default:
! 3209: YY_FATAL_ERROR( "invalid td_flags" ); /* TODO: not fatal. */
! 3210: return -1;
! 3211: }
! 3212: }
! 3213: if (rv != 0)
! 3214: return -1;
! 3215:
! 3216: /* copy into the deserialized array... */
! 3217:
! 3218: if ((td.td_flags & YYTD_STRUCT)) {
! 3219: /* t32 is the j'th member of a two-element struct. */
! 3220: void *v;
! 3221:
! 3222: v = j == 0 ? &(((struct yy_trans_info *) p)->yy_verify)
! 3223: : &(((struct yy_trans_info *) p)->yy_nxt);
! 3224:
! 3225: switch (dmap->dm_sz) {
! 3226: case sizeof (flex_int32_t):
! 3227: if (M4_YY_TABLES_VERIFY){
! 3228: if( ((flex_int32_t *) v)[0] != (flex_int32_t) t32)
! 3229: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int32_t" );
! 3230: }else
! 3231: ((flex_int32_t *) v)[0] = (flex_int32_t) t32;
! 3232: break;
! 3233: case sizeof (flex_int16_t):
! 3234: if (M4_YY_TABLES_VERIFY ){
! 3235: if(((flex_int16_t *) v)[0] != (flex_int16_t) t32)
! 3236: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int16_t" );
! 3237: }else
! 3238: ((flex_int16_t *) v)[0] = (flex_int16_t) t32;
! 3239: break;
! 3240: case sizeof(flex_int8_t):
! 3241: if (M4_YY_TABLES_VERIFY ){
! 3242: if( ((flex_int8_t *) v)[0] != (flex_int8_t) t32)
! 3243: YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int8_t" );
! 3244: }else
! 3245: ((flex_int8_t *) v)[0] = (flex_int8_t) t32;
! 3246: break;
! 3247: default:
! 3248: YY_FATAL_ERROR( "invalid dmap->dm_sz for struct" ); /* TODO: not fatal. */
! 3249: return -1;
! 3250: }
! 3251:
! 3252: /* if we're done with j, increment p */
! 3253: if (j == 1)
! 3254: p = (struct yy_trans_info *) p + 1;
! 3255: }
! 3256: else if ((td.td_flags & YYTD_PTRANS)) {
! 3257: /* t32 is an index into the transition array. */
! 3258: struct yy_trans_info *v;
! 3259:
! 3260:
! 3261: if (!transdmap){
! 3262: YY_FATAL_ERROR( "transition table not found" ); /* TODO: not fatal. */
! 3263: return -1;
! 3264: }
! 3265:
! 3266: if( M4_YY_TABLES_VERIFY)
! 3267: v = &(((struct yy_trans_info *) (transdmap->dm_arr))[t32]);
! 3268: else
! 3269: v = &((*((struct yy_trans_info **) (transdmap->dm_arr)))[t32]);
! 3270:
! 3271: if(M4_YY_TABLES_VERIFY ){
! 3272: if( ((struct yy_trans_info **) p)[0] != v)
! 3273: YY_FATAL_ERROR( "tables verification failed at YYTD_PTRANS" );
! 3274: }else
! 3275: ((struct yy_trans_info **) p)[0] = v;
! 3276:
! 3277: /* increment p */
! 3278: p = (struct yy_trans_info **) p + 1;
! 3279: }
! 3280: else {
! 3281: /* t32 is a plain int. copy data, then incrememnt p. */
! 3282: switch (dmap->dm_sz) {
! 3283: case sizeof (flex_int32_t):
! 3284: if(M4_YY_TABLES_VERIFY ){
! 3285: if( ((flex_int32_t *) p)[0] != (flex_int32_t) t32)
! 3286: YY_FATAL_ERROR( "tables verification failed at flex_int32_t" );
! 3287: }else
! 3288: ((flex_int32_t *) p)[0] = (flex_int32_t) t32;
! 3289: p = ((flex_int32_t *) p) + 1;
! 3290: break;
! 3291: case sizeof (flex_int16_t):
! 3292: if(M4_YY_TABLES_VERIFY ){
! 3293: if( ((flex_int16_t *) p)[0] != (flex_int16_t) t32)
! 3294: YY_FATAL_ERROR( "tables verification failed at flex_int16_t" );
! 3295: }else
! 3296: ((flex_int16_t *) p)[0] = (flex_int16_t) t32;
! 3297: p = ((flex_int16_t *) p) + 1;
! 3298: break;
! 3299: case sizeof (flex_int8_t):
! 3300: if(M4_YY_TABLES_VERIFY ){
! 3301: if( ((flex_int8_t *) p)[0] != (flex_int8_t) t32)
! 3302: YY_FATAL_ERROR( "tables verification failed at flex_int8_t" );
! 3303: }else
! 3304: ((flex_int8_t *) p)[0] = (flex_int8_t) t32;
! 3305: p = ((flex_int8_t *) p) + 1;
! 3306: break;
! 3307: default:
! 3308: YY_FATAL_ERROR( "invalid dmap->dm_sz for plain int" ); /* TODO: not fatal. */
! 3309: return -1;
! 3310: }
! 3311: }
! 3312: }
! 3313:
! 3314: }
! 3315:
! 3316: /* Now eat padding. */
! 3317: {
! 3318: int pad;
! 3319: pad = yypad64(rd->bread);
! 3320: while(--pad >= 0){
! 3321: flex_int8_t t8;
! 3322: if(yytbl_read8(&t8,rd) != 0)
! 3323: return -1;
! 3324: }
! 3325: }
! 3326:
! 3327: return 0;
! 3328: }
! 3329:
! 3330: %define-yytables The name for this specific scanner's tables.
! 3331:
! 3332: /* Find the key and load the DFA tables from the given stream. */
! 3333: static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key)
! 3334: {
! 3335: int rv=0;
! 3336: struct yytbl_hdr th;
! 3337: struct yytbl_reader rd;
! 3338:
! 3339: rd.fp = fp;
! 3340: th.th_version = NULL;
! 3341:
! 3342: /* Keep trying until we find the right set of tables or end of file. */
! 3343: while (!feof(rd.fp)) {
! 3344: rd.bread = 0;
! 3345: if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0){
! 3346: rv = -1;
! 3347: goto return_rv;
! 3348: }
! 3349:
! 3350: /* A NULL key means choose the first set of tables. */
! 3351: if (key == NULL)
! 3352: break;
! 3353:
! 3354: if (strcmp(th.th_name,key) != 0){
! 3355: /* Skip ahead to next set */
! 3356: fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR);
! 3357: yyfree(th.th_version M4_YY_CALL_LAST_ARG);
! 3358: th.th_version = NULL;
! 3359: }
! 3360: else
! 3361: break;
! 3362: }
! 3363:
! 3364: while (rd.bread < th.th_ssize){
! 3365: /* Load the data tables */
! 3366: if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){
! 3367: rv = -1;
! 3368: goto return_rv;
! 3369: }
! 3370: }
! 3371:
! 3372: return_rv:
! 3373: if(th.th_version){
! 3374: yyfree(th.th_version M4_YY_CALL_LAST_ARG);
! 3375: th.th_version = NULL;
! 3376: }
! 3377:
! 3378: return rv;
! 3379: }
! 3380:
! 3381: /** Load the DFA tables for this scanner from the given stream. */
! 3382: int yytables_fload YYFARGS1(FILE *, fp)
! 3383: {
! 3384:
! 3385: if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0)
! 3386: return -1;
! 3387: return 0;
! 3388: }
! 3389:
! 3390: /** Destroy the loaded tables, freeing memory, etc.. */
! 3391: int yytables_destroy YYFARGS0(void)
! 3392: {
! 3393: struct yytbl_dmap *dmap=0;
! 3394:
! 3395: if(!M4_YY_TABLES_VERIFY){
! 3396: /* Walk the dmap, freeing the pointers */
! 3397: for(dmap=yydmap; dmap->dm_id; dmap++) {
! 3398: void * v;
! 3399: v = dmap->dm_arr;
! 3400: if(v && *(char**)v){
! 3401: yyfree(*(char**)v M4_YY_CALL_LAST_ARG);
! 3402: *(char**)v = NULL;
! 3403: }
! 3404: }
! 3405: }
! 3406:
! 3407: return 0;
! 3408: }
! 3409:
! 3410: /* end table serialization code definitions */
! 3411: %endif
! 3412:
! 3413:
! 3414: m4_ifdef([[M4_YY_MAIN]], [[
! 3415: int main M4_YY_PARAMS(void);
! 3416:
! 3417: int main ()
! 3418: {
! 3419:
! 3420: %if-reentrant
! 3421: yyscan_t lexer;
! 3422: yylex_init(&lexer);
! 3423: yylex( lexer );
! 3424: yylex_destroy( lexer);
1.1 deraadt 3425:
1.13 ! tedu 3426: %endif
! 3427: %if-not-reentrant
1.1 deraadt 3428: yylex();
1.13 ! tedu 3429: %endif
! 3430:
1.1 deraadt 3431: return 0;
1.13 ! tedu 3432: }
! 3433: ]])
! 3434:
! 3435: %ok-for-header
! 3436: m4_ifdef( [[M4_YY_IN_HEADER]],
! 3437: [[
! 3438: #undef YY_NEW_FILE
! 3439: #undef YY_FLUSH_BUFFER
! 3440: #undef yy_set_bol
! 3441: #undef yy_new_buffer
! 3442: #undef yy_set_interactive
! 3443: #undef YY_DO_BEFORE_ACTION
! 3444:
! 3445: #ifdef YY_DECL_IS_OURS
! 3446: #undef YY_DECL_IS_OURS
! 3447: #undef YY_DECL
1.1 deraadt 3448: #endif
1.13 ! tedu 3449: ]])
![[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