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