1228072Sbapt%# -*-C-*- vi: set ft=c: 2228072Sbapt%# This file is processed in several stages. 3228072Sbapt%# Here are the stages, as best as I can describe: 4228072Sbapt%# 5228072Sbapt%# 1. flex.skl is processed through GNU m4 during the 6228072Sbapt%# pre-compilation stage of flex. Only macros starting 7228072Sbapt%# with `m4preproc_' are processed, and quoting is normal. 8228072Sbapt%# 9228072Sbapt%# 2. The preprocessed skeleton is translated verbatim into a 10228072Sbapt%# C array, saved as "skel.c" and compiled into the flex binary. 11228072Sbapt%# 12228072Sbapt%# 3. At runtime, the skeleton is generated and filtered (again) 13228072Sbapt%# through m4. Macros beginning with `m4_' will be processed. 14228072Sbapt%# The quoting is "[[" and "]]" so we don't interfere with 15228072Sbapt%# user code. 16228072Sbapt%# 17228072Sbapt%# All generate macros for the m4 stage contain the text "m4" or "M4" 18228072Sbapt%# in them. This is to distinguish them from CPP macros. 19228072Sbapt%# The exception to this rule is YY_G, which is an m4 macro, 20228072Sbapt%# but it needs to be remain short because it is used everywhere. 21228072Sbapt%# 22228072Sbapt/* A lexical scanner generated by flex */ 23228072Sbapt 24228072Sbapt%# Macros for preproc stage. 25228072Sbaptm4preproc_changecom 26228072Sbapt 27228072Sbapt%# Macros for runtime processing stage. 28228072Sbaptm4_changecom 29228072Sbaptm4_changequote 30228072Sbaptm4_changequote([[, ]]) 31228072Sbapt 32228072Sbapt%# 33228072Sbapt%# Lines in this skeleton starting with a "%" character are "control lines" 34228072Sbapt%# and affect the generation of the scanner. The possible control codes are 35228072Sbapt%# listed and processed in misc.c. 36228072Sbapt%# 37228072Sbapt%# %# - A comment. The current line is omitted from the generated scanner. 38228072Sbapt%# %if-c++-only - The following lines are printed for C++ scanners ONLY. 39228072Sbapt%# %if-c-only - The following lines are NOT printed for C++ scanners. 40228072Sbapt%# %if-c-or-c++ - The following lines are printed in BOTH C and C++ scanners. 41228072Sbapt%# %if-reentrant - Print for reentrant scanners.(push) 42228072Sbapt%# %if-not-reentrant - Print for non-reentrant scanners. (push) 43228072Sbapt%# %if-bison-bridge - Print for bison-bridge. (push) 44228072Sbapt%# %if-not-bison-bridge - Print for non-bison-bridge. (push) 45228072Sbapt%# %endif - pop from the previous if code. 46228072Sbapt%# %% - A stop-point, where code is inserted by flex. 47228072Sbapt%# Each stop-point is numbered here and also in the code generator. 48228072Sbapt%# (See gen.c, etc. for details.) 49228072Sbapt%# %not-for-header - Begin code that should NOT appear in a ".h" file. 50228072Sbapt%# %ok-for-header - %c and %e are used for building a header file. 51228072Sbapt%# %if-tables-serialization 52228072Sbapt%# 53228072Sbapt%# All control-lines EXCEPT comment lines ("%#") will be inserted into 54228072Sbapt%# the generated scanner as a C-style comment. This is to aid those who 55228072Sbapt%# edit the skeleton. 56228072Sbapt%# 57228072Sbapt 58228072Sbapt%not-for-header 59228072Sbapt%if-c-only 60228072Sbapt%if-not-reentrant 61228072Sbaptm4_ifelse(M4_YY_PREFIX,yy,, 62228072Sbapt#define yy_create_buffer M4_YY_PREFIX[[_create_buffer]] 63228072Sbapt#define yy_delete_buffer M4_YY_PREFIX[[_delete_buffer]] 64228072Sbapt#define yy_flex_debug M4_YY_PREFIX[[_flex_debug]] 65228072Sbapt#define yy_init_buffer M4_YY_PREFIX[[_init_buffer]] 66228072Sbapt#define yy_flush_buffer M4_YY_PREFIX[[_flush_buffer]] 67228072Sbapt#define yy_load_buffer_state M4_YY_PREFIX[[_load_buffer_state]] 68228072Sbapt#define yy_switch_to_buffer M4_YY_PREFIX[[_switch_to_buffer]] 69228072Sbapt#define yyin M4_YY_PREFIX[[in]] 70228072Sbapt#define yyleng M4_YY_PREFIX[[leng]] 71228072Sbapt#define yylex M4_YY_PREFIX[[lex]] 72228072Sbapt#define yylineno M4_YY_PREFIX[[lineno]] 73228072Sbapt#define yyout M4_YY_PREFIX[[out]] 74228072Sbapt#define yyrestart M4_YY_PREFIX[[restart]] 75228072Sbapt#define yytext M4_YY_PREFIX[[text]] 76228072Sbapt#define yywrap M4_YY_PREFIX[[wrap]] 77228072Sbapt#define yyalloc M4_YY_PREFIX[[alloc]] 78228072Sbapt#define yyrealloc M4_YY_PREFIX[[realloc]] 79228072Sbapt#define yyfree M4_YY_PREFIX[[free]] 80228072Sbapt) 81228072Sbapt%endif 82228072Sbapt%endif 83228072Sbapt%ok-for-header 84228072Sbapt 85228072Sbapt#define FLEX_SCANNER 86228072Sbapt#define YY_FLEX_MAJOR_VERSION FLEX_MAJOR_VERSION 87228072Sbapt#define YY_FLEX_MINOR_VERSION FLEX_MINOR_VERSION 88228072Sbapt#define YY_FLEX_SUBMINOR_VERSION FLEX_SUBMINOR_VERSION 89228072Sbapt#if YY_FLEX_SUBMINOR_VERSION > 0 90228072Sbapt#define FLEX_BETA 91228072Sbapt#endif 92228072Sbapt 93228072Sbapt%# Some negated symbols 94228072Sbaptm4_ifdef( [[M4_YY_IN_HEADER]], , [[m4_define([[M4_YY_NOT_IN_HEADER]], [[]])]]) 95228072Sbaptm4_ifdef( [[M4_YY_REENTRANT]], , [[m4_define([[M4_YY_NOT_REENTRANT]], [[]])]]) 96228072Sbapt 97228072Sbapt%# This is the m4 way to say "(stack_used || is_reentrant) 98228072Sbaptm4_ifdef( [[M4_YY_STACK_USED]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]]) 99228072Sbaptm4_ifdef( [[M4_YY_REENTRANT]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]]) 100228072Sbapt 101228072Sbapt%# Prefixes. 102228072Sbapt%# The complexity here is necessary so that m4 preserves 103228072Sbapt%# the argument lists to each C function. 104228072Sbapt 105228072Sbapt 106228072Sbaptm4_ifdef( [[M4_YY_PREFIX]],, [[m4_define([[M4_YY_PREFIX]], [[yy]])]]) 107228072Sbapt 108228072Sbaptm4preproc_define(`M4_GEN_PREFIX', 109228072Sbapt ``m4_define(yy[[$1]], [[M4_YY_PREFIX[[$1]]m4_ifelse($'`#,0,,[[($'`@)]])]])'') 110228072Sbapt 111228072Sbapt%if-c++-only 112228072Sbapt /* The c++ scanner is a mess. The FlexLexer.h header file relies on the 113228072Sbapt * following macro. This is required in order to pass the c++-multiple-scanners 114228072Sbapt * test in the regression suite. We get reports that it breaks inheritance. 115228072Sbapt * We will address this in a future release of flex, or omit the C++ scanner 116228072Sbapt * altogether. 117228072Sbapt */ 118228072Sbapt #define yyFlexLexer M4_YY_PREFIX[[FlexLexer]] 119228072Sbapt%endif 120228072Sbapt 121228072Sbapt%if-c-only 122228072Sbapt M4_GEN_PREFIX(`_create_buffer') 123228072Sbapt M4_GEN_PREFIX(`_delete_buffer') 124228072Sbapt M4_GEN_PREFIX(`_scan_buffer') 125228072Sbapt M4_GEN_PREFIX(`_scan_string') 126228072Sbapt M4_GEN_PREFIX(`_scan_bytes') 127228072Sbapt M4_GEN_PREFIX(`_init_buffer') 128228072Sbapt M4_GEN_PREFIX(`_flush_buffer') 129228072Sbapt M4_GEN_PREFIX(`_load_buffer_state') 130228072Sbapt M4_GEN_PREFIX(`_switch_to_buffer') 131228072Sbapt M4_GEN_PREFIX(`push_buffer_state') 132228072Sbapt M4_GEN_PREFIX(`pop_buffer_state') 133228072Sbapt M4_GEN_PREFIX(`ensure_buffer_stack') 134228072Sbapt M4_GEN_PREFIX(`lex') 135228072Sbapt M4_GEN_PREFIX(`restart') 136228072Sbapt M4_GEN_PREFIX(`lex_init') 137228072Sbapt M4_GEN_PREFIX(`lex_init_extra') 138228072Sbapt M4_GEN_PREFIX(`lex_destroy') 139228072Sbapt M4_GEN_PREFIX(`get_debug') 140228072Sbapt M4_GEN_PREFIX(`set_debug') 141228072Sbapt M4_GEN_PREFIX(`get_extra') 142228072Sbapt M4_GEN_PREFIX(`set_extra') 143228072Sbapt M4_GEN_PREFIX(`get_in') 144228072Sbapt M4_GEN_PREFIX(`set_in') 145228072Sbapt M4_GEN_PREFIX(`get_out') 146228072Sbapt M4_GEN_PREFIX(`set_out') 147228072Sbapt M4_GEN_PREFIX(`get_leng') 148228072Sbapt M4_GEN_PREFIX(`get_text') 149228072Sbapt M4_GEN_PREFIX(`get_lineno') 150228072Sbapt M4_GEN_PREFIX(`set_lineno') 151228072Sbapt m4_ifdef( [[M4_YY_REENTRANT]], 152228072Sbapt [[ 153228072Sbapt M4_GEN_PREFIX(`get_column') 154228072Sbapt M4_GEN_PREFIX(`set_column') 155228072Sbapt ]]) 156228072Sbapt M4_GEN_PREFIX(`wrap') 157228072Sbapt%endif 158228072Sbapt 159228072Sbaptm4_ifdef( [[M4_YY_BISON_LVAL]], 160228072Sbapt[[ 161228072Sbapt M4_GEN_PREFIX(`get_lval') 162228072Sbapt M4_GEN_PREFIX(`set_lval') 163228072Sbapt]]) 164228072Sbapt 165228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 166228072Sbapt[[ 167228072Sbapt M4_GEN_PREFIX(`get_lloc') 168228072Sbapt M4_GEN_PREFIX(`set_lloc') 169228072Sbapt]]) 170228072Sbapt 171228072Sbapt 172228072Sbapt M4_GEN_PREFIX(`alloc') 173228072Sbapt M4_GEN_PREFIX(`realloc') 174228072Sbapt M4_GEN_PREFIX(`free') 175228072Sbapt 176228072Sbapt%if-c-only 177228072Sbaptm4_ifdef( [[M4_YY_NOT_REENTRANT]], 178228072Sbapt[[ 179228072Sbapt M4_GEN_PREFIX(`text') 180228072Sbapt M4_GEN_PREFIX(`leng') 181228072Sbapt M4_GEN_PREFIX(`in') 182228072Sbapt M4_GEN_PREFIX(`out') 183228072Sbapt M4_GEN_PREFIX(`_flex_debug') 184228072Sbapt M4_GEN_PREFIX(`lineno') 185228072Sbapt]]) 186228072Sbapt%endif 187228072Sbapt 188228072Sbapt 189228072Sbaptm4_ifdef( [[M4_YY_TABLES_EXTERNAL]], 190228072Sbapt[[ 191228072Sbapt M4_GEN_PREFIX(`tables_fload') 192228072Sbapt M4_GEN_PREFIX(`tables_destroy') 193228072Sbapt M4_GEN_PREFIX(`TABLES_NAME') 194228072Sbapt]]) 195228072Sbapt 196228072Sbapt/* First, we deal with platform-specific or compiler-specific issues. */ 197228072Sbapt 198250874Sjkim#if defined(__FreeBSD__) 199250875Sjkim#ifndef __STDC_LIMIT_MACROS 200250875Sjkim#define __STDC_LIMIT_MACROS 201250875Sjkim#endif 202250874Sjkim#include <sys/cdefs.h> 203250875Sjkim#include <stdint.h> 204250874Sjkim#else 205250874Sjkim#define __dead2 206250874Sjkim#endif 207250874Sjkim 208228072Sbapt/* begin standard C headers. */ 209228072Sbapt%if-c-only 210228072Sbapt#include <stdio.h> 211228072Sbapt#include <string.h> 212228072Sbapt#include <errno.h> 213228072Sbapt#include <stdlib.h> 214228072Sbapt%endif 215228072Sbapt 216228072Sbapt%if-tables-serialization 217228072Sbapt#include <sys/types.h> 218228072Sbapt#include <netinet/in.h> 219228072Sbapt%endif 220228072Sbapt/* end standard C headers. */ 221228072Sbapt 222228072Sbapt%if-c-or-c++ 223228072Sbaptm4preproc_include(`flexint.h') 224228072Sbapt%endif 225228072Sbapt 226228072Sbapt%if-c++-only 227228072Sbapt/* begin standard C++ headers. */ 228228072Sbapt#include <iostream> 229228072Sbapt#include <errno.h> 230228072Sbapt#include <cstdlib> 231250125Sjkim#include <cstdio> 232228072Sbapt#include <cstring> 233228072Sbapt/* end standard C++ headers. */ 234228072Sbapt%endif 235228072Sbapt 236228072Sbapt#ifdef __cplusplus 237228072Sbapt 238228072Sbapt/* The "const" storage-class-modifier is valid. */ 239228072Sbapt#define YY_USE_CONST 240228072Sbapt 241228072Sbapt#else /* ! __cplusplus */ 242228072Sbapt 243228072Sbapt/* C99 requires __STDC__ to be defined as 1. */ 244228072Sbapt#if defined (__STDC__) 245228072Sbapt 246228072Sbapt#define YY_USE_CONST 247228072Sbapt 248228072Sbapt#endif /* defined (__STDC__) */ 249228072Sbapt#endif /* ! __cplusplus */ 250228072Sbapt 251228072Sbapt#ifdef YY_USE_CONST 252228072Sbapt#define yyconst const 253228072Sbapt#else 254228072Sbapt#define yyconst 255228072Sbapt#endif 256228072Sbapt 257228072Sbapt%# For compilers that can not handle prototypes. 258228072Sbapt%# e.g., 259228072Sbapt%# The function prototype 260228072Sbapt%# int foo(int x, char* y); 261228072Sbapt%# 262228072Sbapt%# ...should be written as 263228072Sbapt%# int foo M4_YY_PARAMS(int x, char* y); 264228072Sbapt%# 265228072Sbapt%# ...which could possibly generate 266228072Sbapt%# int foo (); 267228072Sbapt%# 268228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_PROTOS]], 269228072Sbapt[[ 270228072Sbapt m4_define( [[M4_YY_PARAMS]], [[()]]) 271228072Sbapt]], 272228072Sbapt[[ 273228072Sbapt m4_define( [[M4_YY_PARAMS]], [[($*)]]) 274228072Sbapt]]) 275228072Sbapt 276228072Sbapt%not-for-header 277228072Sbapt/* Returned upon end-of-file. */ 278228072Sbapt#define YY_NULL 0 279228072Sbapt%ok-for-header 280228072Sbapt 281228072Sbapt%not-for-header 282228072Sbapt/* Promotes a possibly negative, possibly signed char to an unsigned 283228072Sbapt * integer for use as an array index. If the signed char is negative, 284228072Sbapt * we want to instead treat it as an 8-bit unsigned char, hence the 285228072Sbapt * double cast. 286228072Sbapt */ 287228072Sbapt#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 288228072Sbapt%ok-for-header 289228072Sbapt 290228072Sbapt 291228072Sbapt 292228072Sbapt%if-reentrant 293228072Sbapt 294228072Sbapt/* An opaque pointer. */ 295228072Sbapt#ifndef YY_TYPEDEF_YY_SCANNER_T 296228072Sbapt#define YY_TYPEDEF_YY_SCANNER_T 297228072Sbapttypedef void* yyscan_t; 298228072Sbapt#endif 299228072Sbapt 300228072Sbapt%# Declare yyguts variable 301228072Sbaptm4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*)yyscanner]]) 302250125Sjkim%# Perform a noop access on yyguts to prevent unused variable complains 303250125Sjkimm4_define( [[M4_YY_NOOP_GUTS_VAR]], [[(void)yyg]]) 304228072Sbapt%# For use wherever a Global is accessed or assigned. 305228072Sbaptm4_define( [[YY_G]], [[yyg->$1]]) 306228072Sbapt 307228072Sbapt%# For use in function prototypes to append the additional argument. 308228072Sbaptm4_define( [[M4_YY_PROTO_LAST_ARG]], [[, yyscan_t yyscanner]]) 309228072Sbaptm4_define( [[M4_YY_PROTO_ONLY_ARG]], [[yyscan_t yyscanner]]) 310228072Sbapt 311228072Sbapt%# For use in function definitions to append the additional argument. 312228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]], 313228072Sbapt[[ 314228072Sbapt m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscanner]]) 315228072Sbapt m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscanner]]) 316228072Sbapt]], 317228072Sbapt[[ 318228072Sbapt m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscan_t yyscanner]]) 319228072Sbapt m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscan_t yyscanner]]) 320228072Sbapt]]) 321228072Sbaptm4_define( [[M4_YY_DECL_LAST_ARG]], [[yyscan_t yyscanner;]]) 322228072Sbapt 323228072Sbapt%# For use in function calls to pass the additional argument. 324228072Sbaptm4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]]) 325228072Sbaptm4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]]) 326228072Sbapt 327228072Sbapt%# For use in function documentation to adjust for additional argument. 328228072Sbaptm4_define( [[M4_YY_DOC_PARAM]], [[@param yyscanner The scanner object.]]) 329228072Sbapt 330228072Sbapt/* For convenience, these vars (plus the bison vars far below) 331228072Sbapt are macros in the reentrant scanner. */ 332228072Sbapt#define yyin YY_G(yyin_r) 333228072Sbapt#define yyout YY_G(yyout_r) 334228072Sbapt#define yyextra YY_G(yyextra_r) 335228072Sbapt#define yyleng YY_G(yyleng_r) 336228072Sbapt#define yytext YY_G(yytext_r) 337228072Sbapt#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 338228072Sbapt#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 339228072Sbapt#define yy_flex_debug YY_G(yy_flex_debug_r) 340228072Sbapt 341228072Sbaptm4_define( [[M4_YY_INCR_LINENO]], 342228072Sbapt[[ 343228072Sbapt do{ yylineno++; 344228072Sbapt yycolumn=0; 345228072Sbapt }while(0) 346228072Sbapt]]) 347228072Sbapt 348228072Sbapt%endif 349228072Sbapt 350228072Sbapt 351228072Sbapt 352228072Sbapt%if-not-reentrant 353228072Sbapt 354228072Sbaptm4_define( [[M4_YY_INCR_LINENO]], 355228072Sbapt[[ 356228072Sbapt yylineno++; 357228072Sbapt]]) 358228072Sbapt 359228072Sbapt%# Define these macros to be no-ops. 360228072Sbaptm4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]]) 361250125Sjkimm4_define( [[M4_YY_NOOP_GUTS_VAR]], [[m4_dnl]]) 362228072Sbaptm4_define( [[YY_G]], [[($1)]]) 363228072Sbaptm4_define( [[M4_YY_PROTO_LAST_ARG]]) 364228072Sbaptm4_define( [[M4_YY_PROTO_ONLY_ARG]], [[void]]) 365228072Sbaptm4_define( [[M4_YY_DEF_LAST_ARG]]) 366228072Sbapt 367228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]], 368228072Sbapt[[ 369228072Sbapt m4_define( [[M4_YY_DEF_ONLY_ARG]]) 370228072Sbapt]], 371228072Sbapt[[ 372228072Sbapt m4_define( [[M4_YY_DEF_ONLY_ARG]], [[void]]) 373228072Sbapt]]) 374228072Sbaptm4_define([[M4_YY_DECL_LAST_ARG]]) 375228072Sbaptm4_define([[M4_YY_CALL_LAST_ARG]]) 376228072Sbaptm4_define([[M4_YY_CALL_ONLY_ARG]]) 377228072Sbaptm4_define( [[M4_YY_DOC_PARAM]], [[]]) 378228072Sbapt 379228072Sbapt%endif 380228072Sbapt 381228072Sbapt 382228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]], 383228072Sbapt[[ 384228072Sbapt%# For compilers that need traditional function definitions. 385228072Sbapt%# e.g., 386228072Sbapt%# The function prototype taking 2 arguments 387228072Sbapt%# int foo (int x, char* y) 388228072Sbapt%# 389228072Sbapt%# ...should be written as 390228072Sbapt%# int foo YYFARGS2(int,x, char*,y) 391228072Sbapt%# 392228072Sbapt%# ...which could possibly generate 393228072Sbapt%# int foo (x,y,yyscanner) 394228072Sbapt%# int x; 395228072Sbapt%# char * y; 396228072Sbapt%# yyscan_t yyscanner; 397228072Sbapt%# 398228072Sbapt%# Generate traditional function defs 399228072Sbapt m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG) [[\]] 400228072Sbapt M4_YY_DECL_LAST_ARG]]) 401228072Sbapt m4_define( [[YYFARGS1]], [[($2 M4_YY_DEF_LAST_ARG) [[\]] 402228072Sbapt $1 $2; [[\]] 403228072Sbapt M4_YY_DECL_LAST_ARG]]) 404228072Sbapt m4_define( [[YYFARGS2]], [[($2,$4 M4_YY_DEF_LAST_ARG) [[\]] 405228072Sbapt $1 $2; [[\]] 406228072Sbapt $3 $4; [[\]] 407228072Sbapt M4_YY_DECL_LAST_ARG]]) 408228072Sbapt m4_define( [[YYFARGS3]], [[($2,$4,$6 M4_YY_DEF_LAST_ARG) [[\]] 409228072Sbapt $1 $2; [[\]] 410228072Sbapt $3 $4; [[\]] 411228072Sbapt $5 $6; [[\]] 412228072Sbapt M4_YY_DECL_LAST_ARG]]) 413228072Sbapt]], 414228072Sbapt[[ 415228072Sbapt%# Generate C99 function defs. 416228072Sbapt m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG)]]) 417228072Sbapt m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]]) 418228072Sbapt m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]]) 419228072Sbapt m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]]) 420228072Sbapt]]) 421228072Sbapt 422228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 423228072Sbapt[[ 424228072Sbapt/* Enter a start condition. This macro really ought to take a parameter, 425228072Sbapt * but we do it the disgusting crufty way forced on us by the ()-less 426228072Sbapt * definition of BEGIN. 427228072Sbapt */ 428228072Sbapt#define BEGIN YY_G(yy_start) = 1 + 2 * 429228072Sbapt]]) 430228072Sbapt 431228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 432228072Sbapt[[ 433228072Sbapt/* Translate the current start state into a value that can be later handed 434228072Sbapt * to BEGIN to return to the state. The YYSTATE alias is for lex 435228072Sbapt * compatibility. 436228072Sbapt */ 437228072Sbapt#define YY_START ((YY_G(yy_start) - 1) / 2) 438228072Sbapt#define YYSTATE YY_START 439228072Sbapt]]) 440228072Sbapt 441228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 442228072Sbapt[[ 443228072Sbapt/* Action number for EOF rule of a given start state. */ 444228072Sbapt#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 445228072Sbapt]]) 446228072Sbapt 447228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 448228072Sbapt[[ 449228072Sbapt/* Special action meaning "start processing a new file". */ 450228072Sbapt#define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG ) 451228072Sbapt]]) 452228072Sbapt 453228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 454228072Sbapt[[ 455228072Sbapt#define YY_END_OF_BUFFER_CHAR 0 456228072Sbapt]]) 457228072Sbapt 458228072Sbapt/* Size of default input buffer. */ 459228072Sbapt#ifndef YY_BUF_SIZE 460228072Sbapt#define YY_BUF_SIZE 16384 461228072Sbapt#endif 462228072Sbapt 463228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 464228072Sbapt[[ 465228072Sbapt/* The state buf must be large enough to hold one state per character in the main buffer. 466228072Sbapt */ 467228072Sbapt#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 468228072Sbapt]]) 469228072Sbapt 470228072Sbapt 471228072Sbapt#ifndef YY_TYPEDEF_YY_BUFFER_STATE 472228072Sbapt#define YY_TYPEDEF_YY_BUFFER_STATE 473228072Sbapttypedef struct yy_buffer_state *YY_BUFFER_STATE; 474228072Sbapt#endif 475228072Sbapt 476250125Sjkim#ifndef YY_TYPEDEF_YY_SIZE_T 477250125Sjkim#define YY_TYPEDEF_YY_SIZE_T 478250125Sjkimtypedef size_t yy_size_t; 479250125Sjkim#endif 480250125Sjkim 481228072Sbapt%if-not-reentrant 482250125Sjkimextern yy_size_t yyleng; 483228072Sbapt%endif 484228072Sbapt 485228072Sbapt%if-c-only 486228072Sbapt%if-not-reentrant 487228072Sbaptextern FILE *yyin, *yyout; 488228072Sbapt%endif 489228072Sbapt%endif 490228072Sbapt 491228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 492228072Sbapt[[ 493228072Sbapt#define EOB_ACT_CONTINUE_SCAN 0 494228072Sbapt#define EOB_ACT_END_OF_FILE 1 495228072Sbapt#define EOB_ACT_LAST_MATCH 2 496228072Sbapt]]) 497228072Sbapt 498228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 499228072Sbapt[[ 500228072Sbapt m4_ifdef( [[M4_YY_USE_LINENO]], 501228072Sbapt [[ 502228072Sbapt /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires 503228072Sbapt * access to the local variable yy_act. Since yyless() is a macro, it would break 504228072Sbapt * existing scanners that call yyless() from OUTSIDE yylex. 505228072Sbapt * One obvious solution it to make yy_act a global. I tried that, and saw 506228072Sbapt * a 5% performance hit in a non-yylineno scanner, because yy_act is 507228072Sbapt * normally declared as a register variable-- so it is not worth it. 508228072Sbapt */ 509228072Sbapt #define YY_LESS_LINENO(n) \ 510228072Sbapt do { \ 511228072Sbapt int yyl;\ 512228072Sbapt for ( yyl = n; yyl < yyleng; ++yyl )\ 513228072Sbapt if ( yytext[yyl] == '\n' )\ 514228072Sbapt --yylineno;\ 515228072Sbapt }while(0) 516228072Sbapt ]], 517228072Sbapt [[ 518228072Sbapt #define YY_LESS_LINENO(n) 519228072Sbapt ]]) 520228072Sbapt]]) 521228072Sbapt 522228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 523228072Sbapt[[ 524228072Sbapt/* Return all but the first "n" matched characters back to the input stream. */ 525228072Sbapt#define yyless(n) \ 526228072Sbapt do \ 527228072Sbapt { \ 528228072Sbapt /* Undo effects of setting up yytext. */ \ 529228072Sbapt int yyless_macro_arg = (n); \ 530228072Sbapt YY_LESS_LINENO(yyless_macro_arg);\ 531228072Sbapt *yy_cp = YY_G(yy_hold_char); \ 532228072Sbapt YY_RESTORE_YY_MORE_OFFSET \ 533228072Sbapt YY_G(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 534228072Sbapt YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 535228072Sbapt } \ 536228072Sbapt while ( 0 ) 537228072Sbapt]]) 538228072Sbapt 539228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 540228072Sbapt[[ 541228072Sbapt#define unput(c) yyunput( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG ) 542228072Sbapt]]) 543228072Sbapt 544228072Sbapt#ifndef YY_STRUCT_YY_BUFFER_STATE 545228072Sbapt#define YY_STRUCT_YY_BUFFER_STATE 546228072Sbaptstruct yy_buffer_state 547228072Sbapt { 548228072Sbapt%if-c-only 549228072Sbapt FILE *yy_input_file; 550228072Sbapt%endif 551228072Sbapt 552228072Sbapt%if-c++-only 553228072Sbapt std::istream* yy_input_file; 554228072Sbapt%endif 555228072Sbapt 556228072Sbapt 557228072Sbapt char *yy_ch_buf; /* input buffer */ 558228072Sbapt char *yy_buf_pos; /* current position in input buffer */ 559228072Sbapt 560228072Sbapt /* Size of input buffer in bytes, not including room for EOB 561228072Sbapt * characters. 562228072Sbapt */ 563228072Sbapt yy_size_t yy_buf_size; 564228072Sbapt 565228072Sbapt /* Number of characters read into yy_ch_buf, not including EOB 566228072Sbapt * characters. 567228072Sbapt */ 568250125Sjkim yy_size_t yy_n_chars; 569228072Sbapt 570228072Sbapt /* Whether we "own" the buffer - i.e., we know we created it, 571228072Sbapt * and can realloc() it to grow it, and should free() it to 572228072Sbapt * delete it. 573228072Sbapt */ 574228072Sbapt int yy_is_our_buffer; 575228072Sbapt 576228072Sbapt /* Whether this is an "interactive" input source; if so, and 577228072Sbapt * if we're using stdio for input, then we want to use getc() 578228072Sbapt * instead of fread(), to make sure we stop fetching input after 579228072Sbapt * each newline. 580228072Sbapt */ 581228072Sbapt int yy_is_interactive; 582228072Sbapt 583228072Sbapt /* Whether we're considered to be at the beginning of a line. 584228072Sbapt * If so, '^' rules will be active on the next match, otherwise 585228072Sbapt * not. 586228072Sbapt */ 587228072Sbapt int yy_at_bol; 588228072Sbapt 589228072Sbapt int yy_bs_lineno; /**< The line count. */ 590228072Sbapt int yy_bs_column; /**< The column count. */ 591228072Sbapt 592228072Sbapt 593228072Sbapt /* Whether to try to fill the input buffer when we reach the 594228072Sbapt * end of it. 595228072Sbapt */ 596228072Sbapt int yy_fill_buffer; 597228072Sbapt 598228072Sbapt int yy_buffer_status; 599228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 600228072Sbapt[[ 601228072Sbapt#define YY_BUFFER_NEW 0 602228072Sbapt#define YY_BUFFER_NORMAL 1 603228072Sbapt /* When an EOF's been seen but there's still some text to process 604228072Sbapt * then we mark the buffer as YY_EOF_PENDING, to indicate that we 605228072Sbapt * shouldn't try reading from the input source any more. We might 606228072Sbapt * still have a bunch of tokens to match, though, because of 607228072Sbapt * possible backing-up. 608228072Sbapt * 609228072Sbapt * When we actually see the EOF, we change the status to "new" 610228072Sbapt * (via yyrestart()), so that the user can continue scanning by 611228072Sbapt * just pointing yyin at a new input file. 612228072Sbapt */ 613228072Sbapt#define YY_BUFFER_EOF_PENDING 2 614228072Sbapt]]) 615228072Sbapt }; 616228072Sbapt#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 617228072Sbapt 618228072Sbapt%if-c-only Standard (non-C++) definition 619228072Sbapt%not-for-header 620228072Sbapt%if-not-reentrant 621228072Sbapt 622228072Sbapt/* Stack of input buffers. */ 623228072Sbaptstatic size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 624228072Sbaptstatic size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 625228072Sbaptstatic YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 626228072Sbapt%endif 627228072Sbapt%ok-for-header 628228072Sbapt%endif 629228072Sbapt 630228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 631228072Sbapt[[ 632228072Sbapt/* We provide macros for accessing buffer states in case in the 633228072Sbapt * future we want to put the buffer states in a more general 634228072Sbapt * "scanner state". 635228072Sbapt * 636228072Sbapt * Returns the top of the stack, or NULL. 637228072Sbapt */ 638228072Sbapt#define YY_CURRENT_BUFFER ( YY_G(yy_buffer_stack) \ 639228072Sbapt ? YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] \ 640228072Sbapt : NULL) 641250877Sjkim#define yy_current_buffer YY_CURRENT_BUFFER 642228072Sbapt]]) 643228072Sbapt 644228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 645228072Sbapt[[ 646228072Sbapt/* Same as previous macro, but useful when we know that the buffer stack is not 647228072Sbapt * NULL or when we need an lvalue. For internal use only. 648228072Sbapt */ 649228072Sbapt#define YY_CURRENT_BUFFER_LVALUE YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] 650228072Sbapt]]) 651228072Sbapt 652228072Sbapt%if-c-only Standard (non-C++) definition 653228072Sbapt 654228072Sbapt%if-not-reentrant 655228072Sbapt%not-for-header 656228072Sbapt/* yy_hold_char holds the character lost when yytext is formed. */ 657228072Sbaptstatic char yy_hold_char; 658250125Sjkimstatic yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ 659250125Sjkimyy_size_t yyleng; 660228072Sbapt 661228072Sbapt/* Points to current character in buffer. */ 662228072Sbaptstatic char *yy_c_buf_p = (char *) 0; 663228072Sbaptstatic int yy_init = 0; /* whether we need to initialize */ 664228072Sbaptstatic int yy_start = 0; /* start state number */ 665228072Sbapt 666228072Sbapt/* Flag which is used to allow yywrap()'s to do buffer switches 667228072Sbapt * instead of setting up a fresh yyin. A bit of a hack ... 668228072Sbapt */ 669228072Sbaptstatic int yy_did_buffer_switch_on_eof; 670228072Sbapt%ok-for-header 671228072Sbapt%endif 672228072Sbapt 673228072Sbaptvoid yyrestart M4_YY_PARAMS( FILE *input_file M4_YY_PROTO_LAST_ARG ); 674228072Sbaptvoid yy_switch_to_buffer M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG ); 675228072SbaptYY_BUFFER_STATE yy_create_buffer M4_YY_PARAMS( FILE *file, int size M4_YY_PROTO_LAST_ARG ); 676228072Sbaptvoid yy_delete_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG ); 677228072Sbaptvoid yy_flush_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG ); 678228072Sbaptvoid yypush_buffer_state M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG ); 679228072Sbaptvoid yypop_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 680228072Sbapt 681228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 682228072Sbapt[[ 683228072Sbaptstatic void yyensure_buffer_stack M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 684228072Sbaptstatic void yy_load_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 685228072Sbaptstatic void yy_init_buffer M4_YY_PARAMS( YY_BUFFER_STATE b, FILE *file M4_YY_PROTO_LAST_ARG ); 686228072Sbapt]]) 687228072Sbapt 688228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 689228072Sbapt[[ 690228072Sbapt#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG) 691228072Sbapt]]) 692228072Sbapt 693228072SbaptYY_BUFFER_STATE yy_scan_buffer M4_YY_PARAMS( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG ); 694228072SbaptYY_BUFFER_STATE yy_scan_string M4_YY_PARAMS( yyconst char *yy_str M4_YY_PROTO_LAST_ARG ); 695250125SjkimYY_BUFFER_STATE yy_scan_bytes M4_YY_PARAMS( yyconst char *bytes, yy_size_t len M4_YY_PROTO_LAST_ARG ); 696228072Sbapt 697228072Sbapt%endif 698228072Sbapt 699228072Sbaptvoid *yyalloc M4_YY_PARAMS( yy_size_t M4_YY_PROTO_LAST_ARG ); 700228072Sbaptvoid *yyrealloc M4_YY_PARAMS( void *, yy_size_t M4_YY_PROTO_LAST_ARG ); 701228072Sbaptvoid yyfree M4_YY_PARAMS( void * M4_YY_PROTO_LAST_ARG ); 702228072Sbapt 703228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 704228072Sbapt[[ 705228072Sbapt#define yy_new_buffer yy_create_buffer 706228072Sbapt]]) 707228072Sbapt 708228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 709228072Sbapt[[ 710228072Sbapt#define yy_set_interactive(is_interactive) \ 711228072Sbapt { \ 712228072Sbapt if ( ! YY_CURRENT_BUFFER ){ \ 713228072Sbapt yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \ 714228072Sbapt YY_CURRENT_BUFFER_LVALUE = \ 715228072Sbapt yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \ 716228072Sbapt } \ 717228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 718228072Sbapt } 719228072Sbapt]]) 720228072Sbapt 721228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 722228072Sbapt[[ 723228072Sbapt#define yy_set_bol(at_bol) \ 724228072Sbapt { \ 725228072Sbapt if ( ! YY_CURRENT_BUFFER ){\ 726228072Sbapt yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \ 727228072Sbapt YY_CURRENT_BUFFER_LVALUE = \ 728228072Sbapt yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \ 729228072Sbapt } \ 730228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 731228072Sbapt } 732228072Sbapt]]) 733228072Sbapt 734228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 735228072Sbapt[[ 736228072Sbapt#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 737228072Sbapt]]) 738228072Sbapt 739228072Sbapt%% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here 740228072Sbapt 741250128Sjkimm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 742250128Sjkim[[ 743250128Sjkim%% [1.5] DFA 744250128Sjkim]]) 745250128Sjkim 746228072Sbapt%if-c-only Standard (non-C++) definition 747228072Sbapt 748228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 749228072Sbapt[[ 750228072Sbaptstatic yy_state_type yy_get_previous_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 751228072Sbaptstatic yy_state_type yy_try_NUL_trans M4_YY_PARAMS( yy_state_type current_state M4_YY_PROTO_LAST_ARG); 752228072Sbaptstatic int yy_get_next_buffer M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 753250874Sjkimstatic void yy_fatal_error M4_YY_PARAMS( yyconst char msg[] M4_YY_PROTO_LAST_ARG ) __dead2; 754228072Sbapt]]) 755228072Sbapt 756228072Sbapt%endif 757228072Sbapt 758228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 759228072Sbapt[[ 760228072Sbapt/* Done after the current pattern has been matched and before the 761228072Sbapt * corresponding action - sets up yytext. 762228072Sbapt */ 763228072Sbapt#define YY_DO_BEFORE_ACTION \ 764228072Sbapt YY_G(yytext_ptr) = yy_bp; \ 765228072Sbapt%% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ 766228072Sbapt YY_G(yy_hold_char) = *yy_cp; \ 767228072Sbapt *yy_cp = '\0'; \ 768228072Sbapt%% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ 769228072Sbapt YY_G(yy_c_buf_p) = yy_cp; 770228072Sbapt]]) 771228072Sbapt 772228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 773228072Sbapt[[ 774228072Sbapt%% [4.0] data tables for the DFA and the user's section 1 definitions go here 775228072Sbapt]]) 776228072Sbapt 777228072Sbaptm4_ifdef( [[M4_YY_IN_HEADER]], [[#ifdef YY_HEADER_EXPORT_START_CONDITIONS]]) 778228072SbaptM4_YY_SC_DEFS 779228072Sbaptm4_ifdef( [[M4_YY_IN_HEADER]], [[#endif]]) 780228072Sbapt 781228072Sbaptm4_ifdef( [[M4_YY_NO_UNISTD_H]],, 782228072Sbapt[[ 783228072Sbapt#ifndef YY_NO_UNISTD_H 784228072Sbapt/* Special case for "unistd.h", since it is non-ANSI. We include it way 785228072Sbapt * down here because we want the user's section 1 to have been scanned first. 786228072Sbapt * The user has a chance to override it with an option. 787228072Sbapt */ 788228072Sbapt%if-c-only 789228072Sbapt#include <unistd.h> 790228072Sbapt%endif 791228072Sbapt%if-c++-only 792228072Sbapt#include <unistd.h> 793228072Sbapt%endif 794228072Sbapt#endif 795228072Sbapt]]) 796228072Sbapt 797228072Sbaptm4_ifdef( [[M4_EXTRA_TYPE_DEFS]], 798228072Sbapt[[ 799228072Sbapt#define YY_EXTRA_TYPE M4_EXTRA_TYPE_DEFS 800228072Sbapt]], 801228072Sbapt[[ 802228072Sbapt#ifndef YY_EXTRA_TYPE 803228072Sbapt#define YY_EXTRA_TYPE void * 804228072Sbapt#endif 805228072Sbapt]] 806228072Sbapt) 807228072Sbapt 808228072Sbapt%if-c-only Reentrant structure and macros (non-C++). 809228072Sbapt%if-reentrant 810228072Sbapt 811228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 812228072Sbapt[[ 813228072Sbapt/* Holds the entire state of the reentrant scanner. */ 814228072Sbaptstruct yyguts_t 815228072Sbapt { 816228072Sbapt 817228072Sbapt /* User-defined. Not touched by flex. */ 818228072Sbapt YY_EXTRA_TYPE yyextra_r; 819228072Sbapt 820228072Sbapt /* The rest are the same as the globals declared in the non-reentrant scanner. */ 821228072Sbapt FILE *yyin_r, *yyout_r; 822228072Sbapt size_t yy_buffer_stack_top; /**< index of top of stack. */ 823228072Sbapt size_t yy_buffer_stack_max; /**< capacity of stack. */ 824228072Sbapt YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ 825228072Sbapt char yy_hold_char; 826250125Sjkim yy_size_t yy_n_chars; 827250125Sjkim yy_size_t yyleng_r; 828228072Sbapt char *yy_c_buf_p; 829228072Sbapt int yy_init; 830228072Sbapt int yy_start; 831228072Sbapt int yy_did_buffer_switch_on_eof; 832228072Sbapt int yy_start_stack_ptr; 833228072Sbapt int yy_start_stack_depth; 834228072Sbapt int *yy_start_stack; 835228072Sbapt yy_state_type yy_last_accepting_state; 836228072Sbapt char* yy_last_accepting_cpos; 837228072Sbapt 838228072Sbapt int yylineno_r; 839228072Sbapt int yy_flex_debug_r; 840228072Sbapt 841228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 842228072Sbapt[[ 843228072Sbapt yy_state_type *yy_state_buf; 844228072Sbapt yy_state_type *yy_state_ptr; 845228072Sbapt char *yy_full_match; 846228072Sbapt int yy_lp; 847228072Sbapt 848228072Sbapt /* These are only needed for trailing context rules, 849228072Sbapt * but there's no conditional variable for that yet. */ 850228072Sbapt int yy_looking_for_trail_begin; 851228072Sbapt int yy_full_lp; 852228072Sbapt int *yy_full_state; 853228072Sbapt]]) 854228072Sbapt 855228072Sbaptm4_ifdef( [[M4_YY_TEXT_IS_ARRAY]], 856228072Sbapt[[ 857228072Sbapt char yytext_r[YYLMAX]; 858228072Sbapt char *yytext_ptr; 859228072Sbapt int yy_more_offset; 860228072Sbapt int yy_prev_more_offset; 861228072Sbapt]], 862228072Sbapt[[ 863228072Sbapt char *yytext_r; 864228072Sbapt int yy_more_flag; 865228072Sbapt int yy_more_len; 866228072Sbapt]]) 867228072Sbapt 868228072Sbaptm4_ifdef( [[M4_YY_BISON_LVAL]], 869228072Sbapt[[ 870228072Sbapt YYSTYPE * yylval_r; 871228072Sbapt]]) 872228072Sbapt 873228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 874228072Sbapt[[ 875228072Sbapt YYLTYPE * yylloc_r; 876228072Sbapt]]) 877228072Sbapt 878228072Sbapt }; /* end struct yyguts_t */ 879228072Sbapt]]) 880228072Sbapt 881228072Sbapt 882228072Sbapt%if-c-only 883228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 884228072Sbapt[[ 885228072Sbaptstatic int yy_init_globals M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 886228072Sbapt]]) 887228072Sbapt%endif 888228072Sbapt 889228072Sbapt%if-reentrant 890228072Sbapt 891228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 892228072Sbapt[[ 893228072Sbapt m4_ifdef( [[M4_YY_BISON_LVAL]], 894228072Sbapt [[ 895228072Sbapt /* This must go here because YYSTYPE and YYLTYPE are included 896228072Sbapt * from bison output in section 1.*/ 897228072Sbapt # define yylval YY_G(yylval_r) 898228072Sbapt ]]) 899228072Sbapt 900228072Sbapt m4_ifdef( [[<M4_YY_BISON_LLOC>]], 901228072Sbapt [[ 902228072Sbapt # define yylloc YY_G(yylloc_r) 903228072Sbapt ]]) 904228072Sbapt]]) 905228072Sbapt 906228072Sbaptint yylex_init M4_YY_PARAMS(yyscan_t* scanner); 907228072Sbapt 908228072Sbaptint yylex_init_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); 909228072Sbapt 910228072Sbapt%endif 911228072Sbapt 912228072Sbapt%endif End reentrant structures and macros. 913228072Sbapt 914228072Sbapt/* Accessor methods to globals. 915228072Sbapt These are made visible to non-reentrant scanners for convenience. */ 916228072Sbapt 917228072Sbaptm4_ifdef( [[M4_YY_NO_DESTROY]],, 918228072Sbapt[[ 919228072Sbaptint yylex_destroy M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 920228072Sbapt]]) 921228072Sbapt 922228072Sbaptm4_ifdef( [[M4_YY_NO_GET_DEBUG]],, 923228072Sbapt[[ 924228072Sbaptint yyget_debug M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 925228072Sbapt]]) 926228072Sbapt 927228072Sbaptm4_ifdef( [[M4_YY_NO_SET_DEBUG]],, 928228072Sbapt[[ 929228072Sbaptvoid yyset_debug M4_YY_PARAMS( int debug_flag M4_YY_PROTO_LAST_ARG ); 930228072Sbapt]]) 931228072Sbapt 932228072Sbaptm4_ifdef( [[M4_YY_NO_GET_EXTRA]],, 933228072Sbapt[[ 934228072SbaptYY_EXTRA_TYPE yyget_extra M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 935228072Sbapt]]) 936228072Sbapt 937228072Sbaptm4_ifdef( [[M4_YY_NO_SET_EXTRA]],, 938228072Sbapt[[ 939228072Sbaptvoid yyset_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG ); 940228072Sbapt]]) 941228072Sbapt 942228072Sbaptm4_ifdef( [[M4_YY_NO_GET_IN]],, 943228072Sbapt[[ 944228072SbaptFILE *yyget_in M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 945228072Sbapt]]) 946228072Sbapt 947228072Sbaptm4_ifdef( [[M4_YY_NO_SET_IN]],, 948228072Sbapt[[ 949228072Sbaptvoid yyset_in M4_YY_PARAMS( FILE * in_str M4_YY_PROTO_LAST_ARG ); 950228072Sbapt]]) 951228072Sbapt 952228072Sbaptm4_ifdef( [[M4_YY_NO_GET_OUT]],, 953228072Sbapt[[ 954228072SbaptFILE *yyget_out M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 955228072Sbapt]]) 956228072Sbapt 957228072Sbaptm4_ifdef( [[M4_YY_NO_SET_OUT]],, 958228072Sbapt[[ 959228072Sbaptvoid yyset_out M4_YY_PARAMS( FILE * out_str M4_YY_PROTO_LAST_ARG ); 960228072Sbapt]]) 961228072Sbapt 962228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LENG]],, 963228072Sbapt[[ 964250125Sjkimyy_size_t yyget_leng M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 965228072Sbapt]]) 966228072Sbapt 967228072Sbaptm4_ifdef( [[M4_YY_NO_GET_TEXT]],, 968228072Sbapt[[ 969228072Sbaptchar *yyget_text M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 970228072Sbapt]]) 971228072Sbapt 972228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LINENO]],, 973228072Sbapt[[ 974228072Sbaptint yyget_lineno M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 975228072Sbapt]]) 976228072Sbapt 977228072Sbaptm4_ifdef( [[M4_YY_NO_SET_LINENO]],, 978228072Sbapt[[ 979228072Sbaptvoid yyset_lineno M4_YY_PARAMS( int line_number M4_YY_PROTO_LAST_ARG ); 980228072Sbapt]]) 981228072Sbapt 982250125Sjkimm4_ifdef( [[M4_YY_REENTRANT]], 983250125Sjkim[[ 984250125Sjkimm4_ifdef( [[M4_YY_NO_GET_COLUMN]],, 985250125Sjkim[[ 986250125Sjkimint yyget_column M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 987250125Sjkim]]) 988250125Sjkim]]) 989250125Sjkim 990250125Sjkimm4_ifdef( [[M4_YY_REENTRANT]], 991250125Sjkim[[ 992250125Sjkimm4_ifdef( [[M4_YY_NO_SET_COLUMN]],, 993250125Sjkim[[ 994250125Sjkimvoid yyset_column M4_YY_PARAMS( int column_no M4_YY_PROTO_LAST_ARG ); 995250125Sjkim]]) 996250125Sjkim]]) 997250125Sjkim 998228072Sbapt%if-bison-bridge 999228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LVAL]],, 1000228072Sbapt[[ 1001228072SbaptYYSTYPE * yyget_lval M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1002228072Sbapt]]) 1003228072Sbapt 1004228072Sbaptvoid yyset_lval M4_YY_PARAMS( YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG ); 1005228072Sbapt 1006228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 1007228072Sbapt[[ 1008228072Sbapt m4_ifdef( [[M4_YY_NO_GET_LLOC]],, 1009228072Sbapt [[ 1010228072Sbapt YYLTYPE *yyget_lloc M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1011228072Sbapt ]]) 1012228072Sbapt 1013228072Sbapt m4_ifdef( [[M4_YY_NO_SET_LLOC]],, 1014228072Sbapt [[ 1015228072Sbapt void yyset_lloc M4_YY_PARAMS( YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG ); 1016228072Sbapt ]]) 1017228072Sbapt]]) 1018228072Sbapt%endif 1019228072Sbapt 1020228072Sbapt/* Macros after this point can all be overridden by user definitions in 1021228072Sbapt * section 1. 1022228072Sbapt */ 1023228072Sbapt 1024228072Sbapt#ifndef YY_SKIP_YYWRAP 1025228072Sbapt#ifdef __cplusplus 1026228072Sbaptextern "C" int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1027228072Sbapt#else 1028228072Sbaptextern int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1029228072Sbapt#endif 1030228072Sbapt#endif 1031228072Sbapt 1032228072Sbapt%not-for-header 1033228072Sbapt m4_ifdef( [[M4_YY_NO_UNPUT]],, 1034228072Sbapt [[ 1035250878Sjkim#ifndef YY_NO_UNPUT 1036228072Sbapt static void yyunput M4_YY_PARAMS( int c, char *buf_ptr M4_YY_PROTO_LAST_ARG); 1037250878Sjkim#endif 1038228072Sbapt ]]) 1039228072Sbapt%ok-for-header 1040228072Sbapt%endif 1041228072Sbapt 1042228072Sbapt#ifndef yytext_ptr 1043228072Sbaptstatic void yy_flex_strncpy M4_YY_PARAMS( char *, yyconst char *, int M4_YY_PROTO_LAST_ARG); 1044228072Sbapt#endif 1045228072Sbapt 1046228072Sbapt#ifdef YY_NEED_STRLEN 1047228072Sbaptstatic int yy_flex_strlen M4_YY_PARAMS( yyconst char * M4_YY_PROTO_LAST_ARG); 1048228072Sbapt#endif 1049228072Sbapt 1050228072Sbapt#ifndef YY_NO_INPUT 1051228072Sbapt%if-c-only Standard (non-C++) definition 1052228072Sbapt%not-for-header 1053228072Sbapt#ifdef __cplusplus 1054228072Sbaptstatic int yyinput M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1055228072Sbapt#else 1056228072Sbaptstatic int input M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1057228072Sbapt#endif 1058228072Sbapt%ok-for-header 1059228072Sbapt%endif 1060228072Sbapt#endif 1061228072Sbapt 1062228072Sbapt 1063228072Sbapt%if-c-only 1064228072Sbapt%# TODO: This is messy. 1065228072Sbaptm4_ifdef( [[M4_YY_STACK_USED]], 1066228072Sbapt[[ 1067228072Sbapt 1068228072Sbaptm4_ifdef( [[M4_YY_NOT_REENTRANT]], 1069228072Sbapt[[ 1070228072Sbapt m4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1071228072Sbapt [[ 1072228072Sbapt static int yy_start_stack_ptr = 0; 1073228072Sbapt static int yy_start_stack_depth = 0; 1074228072Sbapt static int *yy_start_stack = NULL; 1075228072Sbapt ]]) 1076228072Sbapt]]) 1077228072Sbapt 1078228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1079228072Sbapt[[ 1080228072Sbapt m4_ifdef( [[M4_YY_NO_PUSH_STATE]],, 1081228072Sbapt [[ 1082228072Sbapt static void yy_push_state M4_YY_PARAMS( int new_state M4_YY_PROTO_LAST_ARG); 1083228072Sbapt ]]) 1084228072Sbapt m4_ifdef( [[M4_YY_NO_POP_STATE]],, 1085228072Sbapt [[ 1086228072Sbapt static void yy_pop_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1087228072Sbapt ]]) 1088228072Sbapt m4_ifdef( [[M4_YY_NO_TOP_STATE]],, 1089228072Sbapt [[ 1090228072Sbapt static int yy_top_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG ); 1091228072Sbapt ]]) 1092228072Sbapt]]) 1093228072Sbapt 1094228072Sbapt]], 1095228072Sbapt[[ 1096228072Sbaptm4_define( [[M4_YY_NO_PUSH_STATE]]) 1097228072Sbaptm4_define( [[M4_YY_NO_POP_STATE]]) 1098228072Sbaptm4_define( [[M4_YY_NO_TOP_STATE]]) 1099228072Sbapt]]) 1100228072Sbapt%endif 1101228072Sbapt 1102228072Sbapt/* Amount of stuff to slurp up with each read. */ 1103228072Sbapt#ifndef YY_READ_BUF_SIZE 1104228072Sbapt#define YY_READ_BUF_SIZE 8192 1105228072Sbapt#endif 1106228072Sbapt 1107228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1108228072Sbapt[[ 1109228072Sbapt/* Copy whatever the last rule matched to the standard output. */ 1110228072Sbapt#ifndef ECHO 1111228072Sbapt%if-c-only Standard (non-C++) definition 1112228072Sbapt/* This used to be an fputs(), but since the string might contain NUL's, 1113228072Sbapt * we now use fwrite(). 1114228072Sbapt */ 1115250125Sjkim#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 1116228072Sbapt%endif 1117228072Sbapt%if-c++-only C++ definition 1118228072Sbapt#define ECHO LexerOutput( yytext, yyleng ) 1119228072Sbapt%endif 1120228072Sbapt#endif 1121228072Sbapt]]) 1122228072Sbapt 1123228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1124228072Sbapt[[ 1125228072Sbapt/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 1126228072Sbapt * is returned in "result". 1127228072Sbapt */ 1128228072Sbapt#ifndef YY_INPUT 1129228072Sbapt#define YY_INPUT(buf,result,max_size) \ 1130228072Sbapt%% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ 1131228072Sbapt\ 1132228072Sbapt%if-c++-only C++ definition \ 1133228072Sbapt if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \ 1134228072Sbapt YY_FATAL_ERROR( "input in flex scanner failed" ); 1135228072Sbapt%endif 1136228072Sbapt 1137228072Sbapt#endif 1138228072Sbapt]]) 1139228072Sbapt 1140228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1141228072Sbapt[[ 1142228072Sbapt/* No semi-colon after return; correct usage is to write "yyterminate();" - 1143228072Sbapt * we don't want an extra ';' after the "return" because that will cause 1144228072Sbapt * some compilers to complain about unreachable statements. 1145228072Sbapt */ 1146228072Sbapt#ifndef yyterminate 1147228072Sbapt#define yyterminate() return YY_NULL 1148228072Sbapt#endif 1149228072Sbapt]]) 1150228072Sbapt 1151228072Sbapt/* Number of entries by which start-condition stack grows. */ 1152228072Sbapt#ifndef YY_START_STACK_INCR 1153228072Sbapt#define YY_START_STACK_INCR 25 1154228072Sbapt#endif 1155228072Sbapt 1156228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1157228072Sbapt[[ 1158228072Sbapt/* Report a fatal error. */ 1159228072Sbapt#ifndef YY_FATAL_ERROR 1160228072Sbapt%if-c-only 1161228072Sbapt#define YY_FATAL_ERROR(msg) yy_fatal_error( msg M4_YY_CALL_LAST_ARG) 1162228072Sbapt%endif 1163228072Sbapt%if-c++-only 1164228072Sbapt#define YY_FATAL_ERROR(msg) LexerError( msg ) 1165228072Sbapt%endif 1166228072Sbapt#endif 1167228072Sbapt]]) 1168228072Sbapt 1169228072Sbapt%if-tables-serialization structures and prototypes 1170228072Sbaptm4preproc_include(`tables_shared.h') 1171228072Sbapt 1172228072Sbapt/* Load the DFA tables from the given stream. */ 1173228072Sbaptint yytables_fload M4_YY_PARAMS(FILE * fp M4_YY_PROTO_LAST_ARG); 1174228072Sbapt 1175228072Sbapt/* Unload the tables from memory. */ 1176228072Sbaptint yytables_destroy M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG); 1177228072Sbapt%not-for-header 1178228072Sbapt 1179228072Sbapt/** Describes a mapping from a serialized table id to its deserialized state in 1180228072Sbapt * this scanner. This is the bridge between our "generic" deserialization code 1181228072Sbapt * and the specifics of this scanner. 1182228072Sbapt */ 1183228072Sbaptstruct yytbl_dmap { 1184228072Sbapt enum yytbl_id dm_id;/**< table identifier */ 1185228072Sbapt void **dm_arr; /**< address of pointer to store the deserialized table. */ 1186228072Sbapt size_t dm_sz; /**< local sizeof() each element in table. */ 1187228072Sbapt}; 1188228072Sbapt 1189228072Sbapt/** A {0,0,0}-terminated list of structs, forming the map */ 1190228072Sbaptstatic struct yytbl_dmap yydmap[] = 1191228072Sbapt{ 1192228072Sbapt%tables-yydmap generated elements 1193228072Sbapt {0,0,0} 1194228072Sbapt}; 1195228072Sbapt 1196228072Sbapt/** A tables-reader object to maintain some state in the read. */ 1197228072Sbaptstruct yytbl_reader { 1198228072Sbapt FILE * fp; /**< input stream */ 1199228072Sbapt flex_uint32_t bread; /**< bytes read since beginning of current tableset */ 1200228072Sbapt}; 1201228072Sbapt 1202228072Sbapt%endif 1203228072Sbapt/* end tables serialization structures and prototypes */ 1204228072Sbapt 1205228072Sbapt%ok-for-header 1206228072Sbapt 1207228072Sbapt/* Default declaration of generated scanner - a define so the user can 1208228072Sbapt * easily add parameters. 1209228072Sbapt */ 1210228072Sbapt#ifndef YY_DECL 1211228072Sbapt#define YY_DECL_IS_OURS 1 1212228072Sbapt%if-c-only Standard (non-C++) definition 1213228072Sbapt 1214228072Sbapt 1215228072Sbaptm4_define( [[M4_YY_LEX_PROTO]], [[M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG)]]) 1216228072Sbaptm4_define( [[M4_YY_LEX_DECLARATION]], [[YYFARGS0(void)]]) 1217228072Sbapt 1218228072Sbaptm4_ifdef( [[M4_YY_BISON_LVAL]], 1219228072Sbapt[[ 1220228072Sbapt m4_dnl The bison pure parser is used. Redefine yylex to 1221228072Sbapt m4_dnl accept the lval parameter. 1222228072Sbapt 1223228072Sbapt m4_define( [[M4_YY_LEX_PROTO]], [[\]] 1224228072Sbapt [[M4_YY_PARAMS(YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG)]]) 1225228072Sbapt m4_define( [[M4_YY_LEX_DECLARATION]], [[\]] 1226228072Sbapt [[YYFARGS1(YYSTYPE *,yylval_param)]]) 1227228072Sbapt]]) 1228228072Sbapt 1229228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 1230228072Sbapt[[ 1231228072Sbapt m4_dnl Locations are used. yylex should also accept the ylloc parameter. 1232228072Sbapt 1233228072Sbapt m4_define( [[M4_YY_LEX_PROTO]], [[\]] 1234228072Sbapt [[M4_YY_PARAMS(YYSTYPE * yylval_param, YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG)]]) 1235228072Sbapt m4_define( [[M4_YY_LEX_DECLARATION]], [[\]] 1236228072Sbapt [[YYFARGS2(YYSTYPE *,yylval_param, YYLTYPE *,yylloc_param)]]) 1237228072Sbapt]]) 1238228072Sbapt 1239228072Sbaptextern int yylex M4_YY_LEX_PROTO; 1240228072Sbapt 1241228072Sbapt#define YY_DECL int yylex M4_YY_LEX_DECLARATION 1242228072Sbapt%endif 1243228072Sbapt%if-c++-only C++ definition 1244228072Sbapt#define YY_DECL int yyFlexLexer::yylex() 1245228072Sbapt%endif 1246228072Sbapt#endif /* !YY_DECL */ 1247228072Sbapt 1248228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1249228072Sbapt[[ 1250228072Sbapt/* Code executed at the beginning of each rule, after yytext and yyleng 1251228072Sbapt * have been set up. 1252228072Sbapt */ 1253228072Sbapt#ifndef YY_USER_ACTION 1254228072Sbapt#define YY_USER_ACTION 1255228072Sbapt#endif 1256228072Sbapt]]) 1257228072Sbapt 1258228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1259228072Sbapt[[ 1260228072Sbapt/* Code executed at the end of each rule. */ 1261228072Sbapt#ifndef YY_BREAK 1262228072Sbapt#define YY_BREAK break; 1263228072Sbapt#endif 1264228072Sbapt]]) 1265228072Sbapt 1266228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1267228072Sbapt[[ 1268228072Sbapt%% [6.0] YY_RULE_SETUP definition goes here 1269228072Sbapt]]) 1270228072Sbapt 1271228072Sbapt%not-for-header 1272228072Sbapt/** The main scanner function which does all the work. 1273228072Sbapt */ 1274228072SbaptYY_DECL 1275228072Sbapt{ 1276250874Sjkim yy_state_type yy_current_state; 1277250874Sjkim char *yy_cp, *yy_bp; 1278250874Sjkim int yy_act; 1279228072Sbapt M4_YY_DECL_GUTS_VAR(); 1280228072Sbapt 1281228072Sbaptm4_ifdef( [[M4_YY_NOT_REENTRANT]], 1282228072Sbapt[[ 1283228072Sbapt m4_ifdef( [[M4_YY_BISON_LVAL]], 1284228072Sbapt [[ 1285228072Sbapt YYSTYPE * yylval; 1286228072Sbapt ]]) 1287228072Sbapt m4_ifdef( [[<M4_YY_BISON_LLOC>]], 1288228072Sbapt [[ 1289228072Sbapt YYLTYPE * yylloc; 1290228072Sbapt ]]) 1291228072Sbapt]]) 1292228072Sbapt 1293250620Sjkim%% [7.0] user's declarations go here 1294250620Sjkim 1295228072Sbaptm4_ifdef( [[M4_YY_BISON_LVAL]], 1296228072Sbapt[[ 1297228072Sbapt yylval = yylval_param; 1298228072Sbapt]]) 1299228072Sbapt 1300228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 1301228072Sbapt[[ 1302228072Sbapt yylloc = yylloc_param; 1303228072Sbapt]]) 1304228072Sbapt 1305228072Sbapt if ( !YY_G(yy_init) ) 1306228072Sbapt { 1307228072Sbapt YY_G(yy_init) = 1; 1308228072Sbapt 1309228072Sbapt#ifdef YY_USER_INIT 1310228072Sbapt YY_USER_INIT; 1311228072Sbapt#endif 1312228072Sbapt 1313228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 1314228072Sbapt[[ 1315228072Sbapt /* Create the reject buffer large enough to save one state per allowed character. */ 1316228072Sbapt if ( ! YY_G(yy_state_buf) ) 1317228072Sbapt YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE M4_YY_CALL_LAST_ARG); 1318228072Sbapt if ( ! YY_G(yy_state_buf) ) 1319228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yylex()" ); 1320228072Sbapt]]) 1321228072Sbapt 1322228072Sbapt if ( ! YY_G(yy_start) ) 1323228072Sbapt YY_G(yy_start) = 1; /* first start state */ 1324228072Sbapt 1325228072Sbapt if ( ! yyin ) 1326228072Sbapt%if-c-only 1327228072Sbapt yyin = stdin; 1328228072Sbapt%endif 1329228072Sbapt%if-c++-only 1330228072Sbapt yyin = & std::cin; 1331228072Sbapt%endif 1332228072Sbapt 1333228072Sbapt if ( ! yyout ) 1334228072Sbapt%if-c-only 1335228072Sbapt yyout = stdout; 1336228072Sbapt%endif 1337228072Sbapt%if-c++-only 1338228072Sbapt yyout = & std::cout; 1339228072Sbapt%endif 1340228072Sbapt 1341228072Sbapt if ( ! YY_CURRENT_BUFFER ) { 1342228072Sbapt yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); 1343228072Sbapt YY_CURRENT_BUFFER_LVALUE = 1344228072Sbapt yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); 1345228072Sbapt } 1346228072Sbapt 1347228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 1348228072Sbapt } 1349228072Sbapt 1350228072Sbapt while ( 1 ) /* loops until end-of-file is reached */ 1351228072Sbapt { 1352228072Sbapt%% [8.0] yymore()-related code goes here 1353228072Sbapt yy_cp = YY_G(yy_c_buf_p); 1354228072Sbapt 1355228072Sbapt /* Support of yytext. */ 1356228072Sbapt *yy_cp = YY_G(yy_hold_char); 1357228072Sbapt 1358228072Sbapt /* yy_bp points to the position in yy_ch_buf of the start of 1359228072Sbapt * the current run. 1360228072Sbapt */ 1361228072Sbapt yy_bp = yy_cp; 1362228072Sbapt 1363228072Sbapt%% [9.0] code to set up and find next match goes here 1364228072Sbapt 1365228072Sbaptyy_find_action: 1366228072Sbapt%% [10.0] code to find the action number goes here 1367228072Sbapt 1368228072Sbapt YY_DO_BEFORE_ACTION; 1369228072Sbapt 1370228072Sbapt%% [11.0] code for yylineno update goes here 1371228072Sbapt 1372228072Sbaptdo_action: /* This label is used only to access EOF actions. */ 1373228072Sbapt 1374228072Sbapt%% [12.0] debug code goes here 1375228072Sbapt 1376228072Sbapt switch ( yy_act ) 1377228072Sbapt { /* beginning of action switch */ 1378228072Sbapt%% [13.0] actions go here 1379228072Sbapt 1380228072Sbapt case YY_END_OF_BUFFER: 1381228072Sbapt { 1382228072Sbapt /* Amount of text matched not including the EOB char. */ 1383228072Sbapt int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1; 1384228072Sbapt 1385228072Sbapt /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1386228072Sbapt *yy_cp = YY_G(yy_hold_char); 1387228072Sbapt YY_RESTORE_YY_MORE_OFFSET 1388228072Sbapt 1389228072Sbapt if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1390228072Sbapt { 1391228072Sbapt /* We're scanning a new file or input source. It's 1392228072Sbapt * possible that this happened because the user 1393228072Sbapt * just pointed yyin at a new source and called 1394228072Sbapt * yylex(). If so, then we have to assure 1395228072Sbapt * consistency between YY_CURRENT_BUFFER and our 1396228072Sbapt * globals. Here is the right place to do so, because 1397228072Sbapt * this is the first action (other than possibly a 1398228072Sbapt * back-up) that will match for the new input source. 1399228072Sbapt */ 1400228072Sbapt YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1401228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1402228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1403228072Sbapt } 1404228072Sbapt 1405228072Sbapt /* Note that here we test for yy_c_buf_p "<=" to the position 1406228072Sbapt * of the first EOB in the buffer, since yy_c_buf_p will 1407228072Sbapt * already have been incremented past the NUL character 1408228072Sbapt * (since all states make transitions on EOB to the 1409228072Sbapt * end-of-buffer state). Contrast this with the test 1410228072Sbapt * in input(). 1411228072Sbapt */ 1412228072Sbapt if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] ) 1413228072Sbapt { /* This was really a NUL. */ 1414228072Sbapt yy_state_type yy_next_state; 1415228072Sbapt 1416228072Sbapt YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text; 1417228072Sbapt 1418228072Sbapt yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); 1419228072Sbapt 1420228072Sbapt /* Okay, we're now positioned to make the NUL 1421228072Sbapt * transition. We couldn't have 1422228072Sbapt * yy_get_previous_state() go ahead and do it 1423228072Sbapt * for us because it doesn't know how to deal 1424228072Sbapt * with the possibility of jamming (and we don't 1425228072Sbapt * want to build jamming into it because then it 1426228072Sbapt * will run more slowly). 1427228072Sbapt */ 1428228072Sbapt 1429228072Sbapt yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG); 1430228072Sbapt 1431228072Sbapt yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; 1432228072Sbapt 1433228072Sbapt if ( yy_next_state ) 1434228072Sbapt { 1435228072Sbapt /* Consume the NUL. */ 1436228072Sbapt yy_cp = ++YY_G(yy_c_buf_p); 1437228072Sbapt yy_current_state = yy_next_state; 1438228072Sbapt goto yy_match; 1439228072Sbapt } 1440228072Sbapt 1441228072Sbapt else 1442228072Sbapt { 1443228072Sbapt%% [14.0] code to do back-up for compressed tables and set up yy_cp goes here 1444228072Sbapt goto yy_find_action; 1445228072Sbapt } 1446228072Sbapt } 1447228072Sbapt 1448228072Sbapt else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) 1449228072Sbapt { 1450228072Sbapt case EOB_ACT_END_OF_FILE: 1451228072Sbapt { 1452228072Sbapt YY_G(yy_did_buffer_switch_on_eof) = 0; 1453228072Sbapt 1454228072Sbapt if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) 1455228072Sbapt { 1456228072Sbapt /* Note: because we've taken care in 1457228072Sbapt * yy_get_next_buffer() to have set up 1458228072Sbapt * yytext, we can now set up 1459228072Sbapt * yy_c_buf_p so that if some total 1460228072Sbapt * hoser (like flex itself) wants to 1461228072Sbapt * call the scanner after we return the 1462228072Sbapt * YY_NULL, it'll still work - another 1463228072Sbapt * YY_NULL will get returned. 1464228072Sbapt */ 1465228072Sbapt YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ; 1466228072Sbapt 1467228072Sbapt yy_act = YY_STATE_EOF(YY_START); 1468228072Sbapt goto do_action; 1469228072Sbapt } 1470228072Sbapt 1471228072Sbapt else 1472228072Sbapt { 1473228072Sbapt if ( ! YY_G(yy_did_buffer_switch_on_eof) ) 1474228072Sbapt YY_NEW_FILE; 1475228072Sbapt } 1476228072Sbapt break; 1477228072Sbapt } 1478228072Sbapt 1479228072Sbapt case EOB_ACT_CONTINUE_SCAN: 1480228072Sbapt YY_G(yy_c_buf_p) = 1481228072Sbapt YY_G(yytext_ptr) + yy_amount_of_matched_text; 1482228072Sbapt 1483228072Sbapt yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); 1484228072Sbapt 1485228072Sbapt yy_cp = YY_G(yy_c_buf_p); 1486228072Sbapt yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; 1487228072Sbapt goto yy_match; 1488228072Sbapt 1489228072Sbapt case EOB_ACT_LAST_MATCH: 1490228072Sbapt YY_G(yy_c_buf_p) = 1491228072Sbapt &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)]; 1492228072Sbapt 1493228072Sbapt yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); 1494228072Sbapt 1495228072Sbapt yy_cp = YY_G(yy_c_buf_p); 1496228072Sbapt yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; 1497228072Sbapt goto yy_find_action; 1498228072Sbapt } 1499228072Sbapt break; 1500228072Sbapt } 1501228072Sbapt 1502228072Sbapt default: 1503228072Sbapt YY_FATAL_ERROR( 1504228072Sbapt "fatal flex scanner internal error--no action found" ); 1505228072Sbapt } /* end of action switch */ 1506228072Sbapt } /* end of scanning one token */ 1507228072Sbapt} /* end of yylex */ 1508228072Sbapt%ok-for-header 1509228072Sbapt 1510228072Sbapt%if-c++-only 1511228072Sbapt%not-for-header 1512228072Sbapt/* The contents of this function are C++ specific, so the YY_G macro is not used. 1513228072Sbapt */ 1514228072SbaptyyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout ) 1515228072Sbapt{ 1516228072Sbapt yyin = arg_yyin; 1517228072Sbapt yyout = arg_yyout; 1518228072Sbapt yy_c_buf_p = 0; 1519228072Sbapt yy_init = 0; 1520228072Sbapt yy_start = 0; 1521228072Sbapt yy_flex_debug = 0; 1522228072Sbapt yylineno = 1; // this will only get updated if %option yylineno 1523228072Sbapt 1524228072Sbapt yy_did_buffer_switch_on_eof = 0; 1525228072Sbapt 1526228072Sbapt yy_looking_for_trail_begin = 0; 1527228072Sbapt yy_more_flag = 0; 1528228072Sbapt yy_more_len = 0; 1529228072Sbapt yy_more_offset = yy_prev_more_offset = 0; 1530228072Sbapt 1531228072Sbapt yy_start_stack_ptr = yy_start_stack_depth = 0; 1532228072Sbapt yy_start_stack = NULL; 1533228072Sbapt 1534228072Sbapt yy_buffer_stack = 0; 1535228072Sbapt yy_buffer_stack_top = 0; 1536228072Sbapt yy_buffer_stack_max = 0; 1537228072Sbapt 1538228072Sbapt 1539228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 1540228072Sbapt[[ 1541228072Sbapt yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE]; 1542228072Sbapt]], 1543228072Sbapt[[ 1544228072Sbapt yy_state_buf = 0; 1545228072Sbapt]]) 1546228072Sbapt} 1547228072Sbapt 1548228072Sbapt/* The contents of this function are C++ specific, so the YY_G macro is not used. 1549228072Sbapt */ 1550228072SbaptyyFlexLexer::~yyFlexLexer() 1551228072Sbapt{ 1552228072Sbapt delete [] yy_state_buf; 1553228072Sbapt yyfree( yy_start_stack M4_YY_CALL_LAST_ARG ); 1554228072Sbapt yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); 1555228072Sbapt yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG ); 1556228072Sbapt} 1557228072Sbapt 1558228072Sbapt/* The contents of this function are C++ specific, so the YY_G macro is not used. 1559228072Sbapt */ 1560228072Sbaptvoid yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out ) 1561228072Sbapt{ 1562228072Sbapt if ( new_in ) 1563228072Sbapt { 1564228072Sbapt yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); 1565228072Sbapt yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG); 1566228072Sbapt } 1567228072Sbapt 1568228072Sbapt if ( new_out ) 1569228072Sbapt yyout = new_out; 1570228072Sbapt} 1571228072Sbapt 1572228072Sbapt#ifdef YY_INTERACTIVE 1573228072Sbaptint yyFlexLexer::LexerInput( char* buf, int /* max_size */ ) 1574228072Sbapt#else 1575228072Sbaptint yyFlexLexer::LexerInput( char* buf, int max_size ) 1576228072Sbapt#endif 1577228072Sbapt{ 1578228072Sbapt if ( yyin->eof() || yyin->fail() ) 1579228072Sbapt return 0; 1580228072Sbapt 1581228072Sbapt#ifdef YY_INTERACTIVE 1582228072Sbapt yyin->get( buf[0] ); 1583228072Sbapt 1584228072Sbapt if ( yyin->eof() ) 1585228072Sbapt return 0; 1586228072Sbapt 1587228072Sbapt if ( yyin->bad() ) 1588228072Sbapt return -1; 1589228072Sbapt 1590228072Sbapt return 1; 1591228072Sbapt 1592228072Sbapt#else 1593228072Sbapt (void) yyin->read( buf, max_size ); 1594228072Sbapt 1595228072Sbapt if ( yyin->bad() ) 1596228072Sbapt return -1; 1597228072Sbapt else 1598228072Sbapt return yyin->gcount(); 1599228072Sbapt#endif 1600228072Sbapt} 1601228072Sbapt 1602228072Sbaptvoid yyFlexLexer::LexerOutput( const char* buf, int size ) 1603228072Sbapt{ 1604228072Sbapt (void) yyout->write( buf, size ); 1605228072Sbapt} 1606228072Sbapt%ok-for-header 1607228072Sbapt%endif 1608228072Sbapt 1609228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 1610228072Sbapt[[ 1611228072Sbapt/* yy_get_next_buffer - try to read in a new buffer 1612228072Sbapt * 1613228072Sbapt * Returns a code representing an action: 1614228072Sbapt * EOB_ACT_LAST_MATCH - 1615228072Sbapt * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1616228072Sbapt * EOB_ACT_END_OF_FILE - end of file 1617228072Sbapt */ 1618228072Sbapt%if-c-only 1619228072Sbaptstatic int yy_get_next_buffer YYFARGS0(void) 1620228072Sbapt%endif 1621228072Sbapt%if-c++-only 1622228072Sbaptint yyFlexLexer::yy_get_next_buffer() 1623228072Sbapt%endif 1624228072Sbapt{ 1625228072Sbapt M4_YY_DECL_GUTS_VAR(); 1626250874Sjkim char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1627250874Sjkim char *source = YY_G(yytext_ptr); 1628250874Sjkim int number_to_move, i; 1629228072Sbapt int ret_val; 1630228072Sbapt 1631228072Sbapt if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] ) 1632228072Sbapt YY_FATAL_ERROR( 1633228072Sbapt "fatal flex scanner internal error--end of buffer missed" ); 1634228072Sbapt 1635228072Sbapt if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1636228072Sbapt { /* Don't try to fill the buffer, so this is an EOF. */ 1637228072Sbapt if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 ) 1638228072Sbapt { 1639228072Sbapt /* We matched a single character, the EOB, so 1640228072Sbapt * treat this as a final EOF. 1641228072Sbapt */ 1642228072Sbapt return EOB_ACT_END_OF_FILE; 1643228072Sbapt } 1644228072Sbapt 1645228072Sbapt else 1646228072Sbapt { 1647228072Sbapt /* We matched some text prior to the EOB, first 1648228072Sbapt * process it. 1649228072Sbapt */ 1650228072Sbapt return EOB_ACT_LAST_MATCH; 1651228072Sbapt } 1652228072Sbapt } 1653228072Sbapt 1654228072Sbapt /* Try to read more data. */ 1655228072Sbapt 1656228072Sbapt /* First move last chars to start of buffer. */ 1657228072Sbapt number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1; 1658228072Sbapt 1659228072Sbapt for ( i = 0; i < number_to_move; ++i ) 1660228072Sbapt *(dest++) = *(source++); 1661228072Sbapt 1662228072Sbapt if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1663228072Sbapt /* don't do the read, it's not guaranteed to return an EOF, 1664228072Sbapt * just force an EOF 1665228072Sbapt */ 1666228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0; 1667228072Sbapt 1668228072Sbapt else 1669228072Sbapt { 1670250125Sjkim yy_size_t num_to_read = 1671228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1672228072Sbapt 1673228072Sbapt while ( num_to_read <= 0 ) 1674228072Sbapt { /* Not enough room in the buffer - grow it. */ 1675228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 1676228072Sbapt[[ 1677228072Sbapt YY_FATAL_ERROR( 1678228072Sbapt"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1679228072Sbapt]], 1680228072Sbapt[[ 1681228072Sbapt /* just a shorter name for the current buffer */ 1682250125Sjkim YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; 1683228072Sbapt 1684228072Sbapt int yy_c_buf_p_offset = 1685228072Sbapt (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf); 1686228072Sbapt 1687228072Sbapt if ( b->yy_is_our_buffer ) 1688228072Sbapt { 1689250125Sjkim yy_size_t new_size = b->yy_buf_size * 2; 1690228072Sbapt 1691228072Sbapt if ( new_size <= 0 ) 1692228072Sbapt b->yy_buf_size += b->yy_buf_size / 8; 1693228072Sbapt else 1694228072Sbapt b->yy_buf_size *= 2; 1695228072Sbapt 1696228072Sbapt b->yy_ch_buf = (char *) 1697228072Sbapt /* Include room in for 2 EOB chars. */ 1698228072Sbapt yyrealloc( (void *) b->yy_ch_buf, 1699228072Sbapt b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG ); 1700228072Sbapt } 1701228072Sbapt else 1702228072Sbapt /* Can't grow it, we don't own it. */ 1703228072Sbapt b->yy_ch_buf = 0; 1704228072Sbapt 1705228072Sbapt if ( ! b->yy_ch_buf ) 1706228072Sbapt YY_FATAL_ERROR( 1707228072Sbapt "fatal error - scanner input buffer overflow" ); 1708228072Sbapt 1709228072Sbapt YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 1710228072Sbapt 1711228072Sbapt num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1712228072Sbapt number_to_move - 1; 1713228072Sbapt]]) 1714228072Sbapt } 1715228072Sbapt 1716228072Sbapt if ( num_to_read > YY_READ_BUF_SIZE ) 1717228072Sbapt num_to_read = YY_READ_BUF_SIZE; 1718228072Sbapt 1719228072Sbapt /* Read in more data. */ 1720228072Sbapt YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1721250125Sjkim YY_G(yy_n_chars), num_to_read ); 1722228072Sbapt 1723228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars); 1724228072Sbapt } 1725228072Sbapt 1726228072Sbapt if ( YY_G(yy_n_chars) == 0 ) 1727228072Sbapt { 1728228072Sbapt if ( number_to_move == YY_MORE_ADJ ) 1729228072Sbapt { 1730228072Sbapt ret_val = EOB_ACT_END_OF_FILE; 1731228072Sbapt yyrestart( yyin M4_YY_CALL_LAST_ARG); 1732228072Sbapt } 1733228072Sbapt 1734228072Sbapt else 1735228072Sbapt { 1736228072Sbapt ret_val = EOB_ACT_LAST_MATCH; 1737228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1738228072Sbapt YY_BUFFER_EOF_PENDING; 1739228072Sbapt } 1740228072Sbapt } 1741228072Sbapt 1742228072Sbapt else 1743228072Sbapt ret_val = EOB_ACT_CONTINUE_SCAN; 1744228072Sbapt 1745228072Sbapt if ((yy_size_t) (YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1746228072Sbapt /* Extend the array by 50%, plus the number we really need. */ 1747228072Sbapt yy_size_t new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1); 1748228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( 1749228072Sbapt (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size M4_YY_CALL_LAST_ARG ); 1750228072Sbapt if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1751228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1752228072Sbapt } 1753228072Sbapt 1754228072Sbapt YY_G(yy_n_chars) += number_to_move; 1755228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1756228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1757228072Sbapt 1758228072Sbapt YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1759228072Sbapt 1760228072Sbapt return ret_val; 1761228072Sbapt} 1762228072Sbapt]]) 1763228072Sbapt 1764228072Sbapt/* yy_get_previous_state - get the state just before the EOB char was reached */ 1765228072Sbapt 1766228072Sbapt%if-c-only 1767228072Sbapt%not-for-header 1768228072Sbapt static yy_state_type yy_get_previous_state YYFARGS0(void) 1769228072Sbapt%endif 1770228072Sbapt%if-c++-only 1771228072Sbapt yy_state_type yyFlexLexer::yy_get_previous_state() 1772228072Sbapt%endif 1773228072Sbapt{ 1774250874Sjkim yy_state_type yy_current_state; 1775250874Sjkim char *yy_cp; 1776228072Sbapt M4_YY_DECL_GUTS_VAR(); 1777228072Sbapt 1778228072Sbapt%% [15.0] code to get the start state into yy_current_state goes here 1779228072Sbapt 1780228072Sbapt for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp ) 1781228072Sbapt { 1782228072Sbapt%% [16.0] code to find the next state goes here 1783228072Sbapt } 1784228072Sbapt 1785228072Sbapt return yy_current_state; 1786228072Sbapt} 1787228072Sbapt 1788228072Sbapt 1789228072Sbapt/* yy_try_NUL_trans - try to make a transition on the NUL character 1790228072Sbapt * 1791228072Sbapt * synopsis 1792228072Sbapt * next_state = yy_try_NUL_trans( current_state ); 1793228072Sbapt */ 1794228072Sbapt%if-c-only 1795228072Sbapt static yy_state_type yy_try_NUL_trans YYFARGS1( yy_state_type, yy_current_state) 1796228072Sbapt%endif 1797228072Sbapt%if-c++-only 1798228072Sbapt yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state ) 1799228072Sbapt%endif 1800228072Sbapt{ 1801250874Sjkim int yy_is_jam; 1802228072Sbapt M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */ 1803228072Sbapt%% [17.0] code to find the next state, and perhaps do backing up, goes here 1804228072Sbapt 1805250125Sjkim M4_YY_NOOP_GUTS_VAR(); 1806228072Sbapt return yy_is_jam ? 0 : yy_current_state; 1807228072Sbapt} 1808228072Sbapt 1809228072Sbapt 1810228072Sbapt%if-c-only 1811228072Sbaptm4_ifdef( [[M4_YY_NO_UNPUT]],, 1812228072Sbapt[[ 1813250878Sjkim#ifndef YY_NO_UNPUT 1814250874Sjkim static void yyunput YYFARGS2( int,c, char *,yy_bp) 1815228072Sbapt%endif 1816228072Sbapt%if-c++-only 1817250878Sjkim#ifndef YY_NO_UNPUT 1818250874Sjkim void yyFlexLexer::yyunput( int c, char* yy_bp) 1819228072Sbapt%endif 1820228072Sbapt{ 1821250874Sjkim char *yy_cp; 1822228072Sbapt M4_YY_DECL_GUTS_VAR(); 1823228072Sbapt 1824228072Sbapt yy_cp = YY_G(yy_c_buf_p); 1825228072Sbapt 1826228072Sbapt /* undo effects of setting up yytext */ 1827228072Sbapt *yy_cp = YY_G(yy_hold_char); 1828228072Sbapt 1829228072Sbapt if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1830228072Sbapt { /* need to shift things up to make room */ 1831228072Sbapt /* +2 for EOB chars. */ 1832250874Sjkim yy_size_t number_to_move = YY_G(yy_n_chars) + 2; 1833250874Sjkim char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 1834228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1835250874Sjkim char *source = 1836228072Sbapt &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 1837228072Sbapt 1838228072Sbapt while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1839228072Sbapt *--dest = *--source; 1840228072Sbapt 1841228072Sbapt yy_cp += (int) (dest - source); 1842228072Sbapt yy_bp += (int) (dest - source); 1843228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 1844228072Sbapt YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 1845228072Sbapt 1846228072Sbapt if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1847228072Sbapt YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1848228072Sbapt } 1849228072Sbapt 1850228072Sbapt *--yy_cp = (char) c; 1851228072Sbapt 1852228072Sbapt%% [18.0] update yylineno here 1853228072Sbaptm4_ifdef( [[M4_YY_USE_LINENO]], 1854228072Sbapt[[ 1855228072Sbapt if ( c == '\n' ){ 1856228072Sbapt --yylineno; 1857228072Sbapt } 1858228072Sbapt]]) 1859228072Sbapt 1860228072Sbapt YY_G(yytext_ptr) = yy_bp; 1861228072Sbapt YY_G(yy_hold_char) = *yy_cp; 1862228072Sbapt YY_G(yy_c_buf_p) = yy_cp; 1863228072Sbapt} 1864250878Sjkim#endif /* ifndef YY_NO_UNPUT */ 1865228072Sbapt%if-c-only 1866228072Sbapt]]) 1867228072Sbapt%endif 1868228072Sbapt 1869228072Sbapt%if-c-only 1870228072Sbapt#ifndef YY_NO_INPUT 1871228072Sbapt#ifdef __cplusplus 1872228072Sbapt static int yyinput YYFARGS0(void) 1873228072Sbapt#else 1874228072Sbapt static int input YYFARGS0(void) 1875228072Sbapt#endif 1876228072Sbapt 1877228072Sbapt%endif 1878228072Sbapt%if-c++-only 1879228072Sbapt int yyFlexLexer::yyinput() 1880228072Sbapt%endif 1881228072Sbapt{ 1882228072Sbapt int c; 1883228072Sbapt M4_YY_DECL_GUTS_VAR(); 1884228072Sbapt 1885228072Sbapt *YY_G(yy_c_buf_p) = YY_G(yy_hold_char); 1886228072Sbapt 1887228072Sbapt if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1888228072Sbapt { 1889228072Sbapt /* yy_c_buf_p now points to the character we want to return. 1890228072Sbapt * If this occurs *before* the EOB characters, then it's a 1891228072Sbapt * valid NUL; if not, then we've hit the end of the buffer. 1892228072Sbapt */ 1893228072Sbapt if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] ) 1894228072Sbapt /* This was really a NUL. */ 1895228072Sbapt *YY_G(yy_c_buf_p) = '\0'; 1896228072Sbapt 1897228072Sbapt else 1898228072Sbapt { /* need more input */ 1899250125Sjkim yy_size_t offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr); 1900228072Sbapt ++YY_G(yy_c_buf_p); 1901228072Sbapt 1902228072Sbapt switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) 1903228072Sbapt { 1904228072Sbapt case EOB_ACT_LAST_MATCH: 1905228072Sbapt /* This happens because yy_g_n_b() 1906228072Sbapt * sees that we've accumulated a 1907228072Sbapt * token and flags that we need to 1908228072Sbapt * try matching the token before 1909228072Sbapt * proceeding. But for input(), 1910228072Sbapt * there's no matching to consider. 1911228072Sbapt * So convert the EOB_ACT_LAST_MATCH 1912228072Sbapt * to EOB_ACT_END_OF_FILE. 1913228072Sbapt */ 1914228072Sbapt 1915228072Sbapt /* Reset buffer status. */ 1916228072Sbapt yyrestart( yyin M4_YY_CALL_LAST_ARG); 1917228072Sbapt 1918228072Sbapt /*FALLTHROUGH*/ 1919228072Sbapt 1920228072Sbapt case EOB_ACT_END_OF_FILE: 1921228072Sbapt { 1922228072Sbapt if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) 1923228072Sbapt return EOF; 1924228072Sbapt 1925228072Sbapt if ( ! YY_G(yy_did_buffer_switch_on_eof) ) 1926228072Sbapt YY_NEW_FILE; 1927228072Sbapt#ifdef __cplusplus 1928228072Sbapt return yyinput(M4_YY_CALL_ONLY_ARG); 1929228072Sbapt#else 1930228072Sbapt return input(M4_YY_CALL_ONLY_ARG); 1931228072Sbapt#endif 1932228072Sbapt } 1933228072Sbapt 1934228072Sbapt case EOB_ACT_CONTINUE_SCAN: 1935228072Sbapt YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset; 1936228072Sbapt break; 1937228072Sbapt } 1938228072Sbapt } 1939228072Sbapt } 1940228072Sbapt 1941228072Sbapt c = *(unsigned char *) YY_G(yy_c_buf_p); /* cast for 8-bit char's */ 1942228072Sbapt *YY_G(yy_c_buf_p) = '\0'; /* preserve yytext */ 1943228072Sbapt YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p); 1944228072Sbapt 1945228072Sbapt%% [19.0] update BOL and yylineno 1946228072Sbapt 1947228072Sbapt return c; 1948228072Sbapt} 1949228072Sbapt%if-c-only 1950228072Sbapt#endif /* ifndef YY_NO_INPUT */ 1951228072Sbapt%endif 1952228072Sbapt 1953228072Sbapt/** Immediately switch to a different input stream. 1954228072Sbapt * @param input_file A readable stream. 1955228072Sbapt * M4_YY_DOC_PARAM 1956228072Sbapt * @note This function does not reset the start condition to @c INITIAL . 1957228072Sbapt */ 1958228072Sbapt%if-c-only 1959228072Sbapt void yyrestart YYFARGS1( FILE *,input_file) 1960228072Sbapt%endif 1961228072Sbapt%if-c++-only 1962228072Sbapt void yyFlexLexer::yyrestart( std::istream* input_file ) 1963228072Sbapt%endif 1964228072Sbapt{ 1965228072Sbapt M4_YY_DECL_GUTS_VAR(); 1966228072Sbapt 1967228072Sbapt if ( ! YY_CURRENT_BUFFER ){ 1968228072Sbapt yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); 1969228072Sbapt YY_CURRENT_BUFFER_LVALUE = 1970228072Sbapt yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); 1971228072Sbapt } 1972228072Sbapt 1973228072Sbapt yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG); 1974228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 1975228072Sbapt} 1976228072Sbapt 1977228072Sbapt/** Switch to a different input buffer. 1978228072Sbapt * @param new_buffer The new input buffer. 1979228072Sbapt * M4_YY_DOC_PARAM 1980228072Sbapt */ 1981228072Sbapt%if-c-only 1982228072Sbapt void yy_switch_to_buffer YYFARGS1( YY_BUFFER_STATE ,new_buffer) 1983228072Sbapt%endif 1984228072Sbapt%if-c++-only 1985228072Sbapt void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1986228072Sbapt%endif 1987228072Sbapt{ 1988228072Sbapt M4_YY_DECL_GUTS_VAR(); 1989228072Sbapt 1990228072Sbapt /* TODO. We should be able to replace this entire function body 1991228072Sbapt * with 1992228072Sbapt * yypop_buffer_state(); 1993228072Sbapt * yypush_buffer_state(new_buffer); 1994228072Sbapt */ 1995228072Sbapt yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); 1996228072Sbapt if ( YY_CURRENT_BUFFER == new_buffer ) 1997228072Sbapt return; 1998228072Sbapt 1999228072Sbapt if ( YY_CURRENT_BUFFER ) 2000228072Sbapt { 2001228072Sbapt /* Flush out information for old buffer. */ 2002228072Sbapt *YY_G(yy_c_buf_p) = YY_G(yy_hold_char); 2003228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p); 2004228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars); 2005228072Sbapt } 2006228072Sbapt 2007228072Sbapt YY_CURRENT_BUFFER_LVALUE = new_buffer; 2008228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 2009228072Sbapt 2010228072Sbapt /* We don't actually know whether we did this switch during 2011228072Sbapt * EOF (yywrap()) processing, but the only time this flag 2012228072Sbapt * is looked at is after yywrap() is called, so it's safe 2013228072Sbapt * to go ahead and always set it. 2014228072Sbapt */ 2015228072Sbapt YY_G(yy_did_buffer_switch_on_eof) = 1; 2016228072Sbapt} 2017228072Sbapt 2018228072Sbapt 2019228072Sbapt%if-c-only 2020228072Sbaptstatic void yy_load_buffer_state YYFARGS0(void) 2021228072Sbapt%endif 2022228072Sbapt%if-c++-only 2023228072Sbapt void yyFlexLexer::yy_load_buffer_state() 2024228072Sbapt%endif 2025228072Sbapt{ 2026228072Sbapt M4_YY_DECL_GUTS_VAR(); 2027228072Sbapt YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 2028228072Sbapt YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 2029228072Sbapt yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 2030228072Sbapt YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); 2031228072Sbapt} 2032228072Sbapt 2033228072Sbapt/** Allocate and initialize an input buffer state. 2034228072Sbapt * @param file A readable stream. 2035228072Sbapt * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 2036228072Sbapt * M4_YY_DOC_PARAM 2037228072Sbapt * @return the allocated buffer state. 2038228072Sbapt */ 2039228072Sbapt%if-c-only 2040228072Sbapt YY_BUFFER_STATE yy_create_buffer YYFARGS2( FILE *,file, int ,size) 2041228072Sbapt%endif 2042228072Sbapt%if-c++-only 2043228072Sbapt YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size ) 2044228072Sbapt%endif 2045228072Sbapt{ 2046228072Sbapt YY_BUFFER_STATE b; 2047228072Sbapt m4_dnl M4_YY_DECL_GUTS_VAR(); 2048228072Sbapt 2049228072Sbapt b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG ); 2050228072Sbapt if ( ! b ) 2051228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2052228072Sbapt 2053228072Sbapt b->yy_buf_size = size; 2054228072Sbapt 2055228072Sbapt /* yy_ch_buf has to be 2 characters longer than the size given because 2056228072Sbapt * we need to put in 2 end-of-buffer characters. 2057228072Sbapt */ 2058228072Sbapt b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG ); 2059228072Sbapt if ( ! b->yy_ch_buf ) 2060228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2061228072Sbapt 2062228072Sbapt b->yy_is_our_buffer = 1; 2063228072Sbapt 2064228072Sbapt yy_init_buffer( b, file M4_YY_CALL_LAST_ARG); 2065228072Sbapt 2066228072Sbapt return b; 2067228072Sbapt} 2068228072Sbapt 2069228072Sbapt/** Destroy the buffer. 2070228072Sbapt * @param b a buffer created with yy_create_buffer() 2071228072Sbapt * M4_YY_DOC_PARAM 2072228072Sbapt */ 2073228072Sbapt%if-c-only 2074228072Sbapt void yy_delete_buffer YYFARGS1( YY_BUFFER_STATE ,b) 2075228072Sbapt%endif 2076228072Sbapt%if-c++-only 2077228072Sbapt void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b ) 2078228072Sbapt%endif 2079228072Sbapt{ 2080228072Sbapt M4_YY_DECL_GUTS_VAR(); 2081228072Sbapt 2082228072Sbapt if ( ! b ) 2083228072Sbapt return; 2084228072Sbapt 2085228072Sbapt if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 2086228072Sbapt YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 2087228072Sbapt 2088228072Sbapt if ( b->yy_is_our_buffer ) 2089228072Sbapt yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG ); 2090228072Sbapt 2091228072Sbapt yyfree( (void *) b M4_YY_CALL_LAST_ARG ); 2092228072Sbapt} 2093228072Sbapt 2094228072Sbapt 2095228072Sbapt/* Initializes or reinitializes a buffer. 2096228072Sbapt * This function is sometimes called more than once on the same buffer, 2097228072Sbapt * such as during a yyrestart() or at EOF. 2098228072Sbapt */ 2099228072Sbapt%if-c-only 2100228072Sbapt static void yy_init_buffer YYFARGS2( YY_BUFFER_STATE ,b, FILE *,file) 2101228072Sbapt%endif 2102228072Sbapt%if-c++-only 2103228072Sbapt void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file ) 2104228072Sbapt%endif 2105228072Sbapt 2106228072Sbapt{ 2107228072Sbapt int oerrno = errno; 2108228072Sbapt M4_YY_DECL_GUTS_VAR(); 2109228072Sbapt 2110228072Sbapt yy_flush_buffer( b M4_YY_CALL_LAST_ARG); 2111228072Sbapt 2112228072Sbapt b->yy_input_file = file; 2113228072Sbapt b->yy_fill_buffer = 1; 2114228072Sbapt 2115228072Sbapt /* If b is the current buffer, then yy_init_buffer was _probably_ 2116228072Sbapt * called from yyrestart() or through yy_get_next_buffer. 2117228072Sbapt * In that case, we don't want to reset the lineno or column. 2118228072Sbapt */ 2119228072Sbapt if (b != YY_CURRENT_BUFFER){ 2120228072Sbapt b->yy_bs_lineno = 1; 2121228072Sbapt b->yy_bs_column = 0; 2122228072Sbapt } 2123228072Sbapt 2124228072Sbapt%if-c-only 2125228072Sbaptm4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]], 2126228072Sbapt[[ 2127228072Sbapt b->yy_is_interactive = 1; 2128228072Sbapt]], 2129228072Sbapt[[ 2130228072Sbapt m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]], 2131228072Sbapt [[ 2132228072Sbapt b->yy_is_interactive = 0; 2133228072Sbapt ]], 2134228072Sbapt [[ 2135228072Sbapt b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 2136228072Sbapt ]]) 2137228072Sbapt]]) 2138228072Sbapt%endif 2139228072Sbapt%if-c++-only 2140228072Sbapt b->yy_is_interactive = 0; 2141228072Sbapt%endif 2142228072Sbapt errno = oerrno; 2143228072Sbapt} 2144228072Sbapt 2145228072Sbapt/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 2146228072Sbapt * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 2147228072Sbapt * M4_YY_DOC_PARAM 2148228072Sbapt */ 2149228072Sbapt%if-c-only 2150228072Sbapt void yy_flush_buffer YYFARGS1( YY_BUFFER_STATE ,b) 2151228072Sbapt%endif 2152228072Sbapt%if-c++-only 2153228072Sbapt void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b ) 2154228072Sbapt%endif 2155228072Sbapt{ 2156228072Sbapt M4_YY_DECL_GUTS_VAR(); 2157228072Sbapt if ( ! b ) 2158228072Sbapt return; 2159228072Sbapt 2160228072Sbapt b->yy_n_chars = 0; 2161228072Sbapt 2162228072Sbapt /* We always need two end-of-buffer characters. The first causes 2163228072Sbapt * a transition to the end-of-buffer state. The second causes 2164228072Sbapt * a jam in that state. 2165228072Sbapt */ 2166228072Sbapt b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 2167228072Sbapt b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 2168228072Sbapt 2169228072Sbapt b->yy_buf_pos = &b->yy_ch_buf[0]; 2170228072Sbapt 2171228072Sbapt b->yy_at_bol = 1; 2172228072Sbapt b->yy_buffer_status = YY_BUFFER_NEW; 2173228072Sbapt 2174228072Sbapt if ( b == YY_CURRENT_BUFFER ) 2175228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 2176228072Sbapt} 2177228072Sbapt 2178228072Sbapt%if-c-or-c++ 2179228072Sbapt/** Pushes the new state onto the stack. The new state becomes 2180228072Sbapt * the current state. This function will allocate the stack 2181228072Sbapt * if necessary. 2182228072Sbapt * @param new_buffer The new state. 2183228072Sbapt * M4_YY_DOC_PARAM 2184228072Sbapt */ 2185228072Sbapt%if-c-only 2186228072Sbaptvoid yypush_buffer_state YYFARGS1(YY_BUFFER_STATE,new_buffer) 2187228072Sbapt%endif 2188228072Sbapt%if-c++-only 2189228072Sbaptvoid yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer) 2190228072Sbapt%endif 2191228072Sbapt{ 2192228072Sbapt M4_YY_DECL_GUTS_VAR(); 2193228072Sbapt if (new_buffer == NULL) 2194228072Sbapt return; 2195228072Sbapt 2196228072Sbapt yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG); 2197228072Sbapt 2198228072Sbapt /* This block is copied from yy_switch_to_buffer. */ 2199228072Sbapt if ( YY_CURRENT_BUFFER ) 2200228072Sbapt { 2201228072Sbapt /* Flush out information for old buffer. */ 2202228072Sbapt *YY_G(yy_c_buf_p) = YY_G(yy_hold_char); 2203228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p); 2204228072Sbapt YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars); 2205228072Sbapt } 2206228072Sbapt 2207228072Sbapt /* Only push if top exists. Otherwise, replace top. */ 2208228072Sbapt if (YY_CURRENT_BUFFER) 2209228072Sbapt YY_G(yy_buffer_stack_top)++; 2210228072Sbapt YY_CURRENT_BUFFER_LVALUE = new_buffer; 2211228072Sbapt 2212228072Sbapt /* copied from yy_switch_to_buffer. */ 2213228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 2214228072Sbapt YY_G(yy_did_buffer_switch_on_eof) = 1; 2215228072Sbapt} 2216228072Sbapt%endif 2217228072Sbapt 2218228072Sbapt 2219228072Sbapt%if-c-or-c++ 2220228072Sbapt/** Removes and deletes the top of the stack, if present. 2221228072Sbapt * The next element becomes the new top. 2222228072Sbapt * M4_YY_DOC_PARAM 2223228072Sbapt */ 2224228072Sbapt%if-c-only 2225228072Sbaptvoid yypop_buffer_state YYFARGS0(void) 2226228072Sbapt%endif 2227228072Sbapt%if-c++-only 2228228072Sbaptvoid yyFlexLexer::yypop_buffer_state (void) 2229228072Sbapt%endif 2230228072Sbapt{ 2231228072Sbapt M4_YY_DECL_GUTS_VAR(); 2232228072Sbapt if (!YY_CURRENT_BUFFER) 2233228072Sbapt return; 2234228072Sbapt 2235228072Sbapt yy_delete_buffer(YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); 2236228072Sbapt YY_CURRENT_BUFFER_LVALUE = NULL; 2237228072Sbapt if (YY_G(yy_buffer_stack_top) > 0) 2238228072Sbapt --YY_G(yy_buffer_stack_top); 2239228072Sbapt 2240228072Sbapt if (YY_CURRENT_BUFFER) { 2241228072Sbapt yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); 2242228072Sbapt YY_G(yy_did_buffer_switch_on_eof) = 1; 2243228072Sbapt } 2244228072Sbapt} 2245228072Sbapt%endif 2246228072Sbapt 2247228072Sbapt 2248228072Sbapt%if-c-or-c++ 2249228072Sbapt/* Allocates the stack if it does not exist. 2250228072Sbapt * Guarantees space for at least one push. 2251228072Sbapt */ 2252228072Sbapt%if-c-only 2253228072Sbaptstatic void yyensure_buffer_stack YYFARGS0(void) 2254228072Sbapt%endif 2255228072Sbapt%if-c++-only 2256228072Sbaptvoid yyFlexLexer::yyensure_buffer_stack(void) 2257228072Sbapt%endif 2258228072Sbapt{ 2259250125Sjkim yy_size_t num_to_alloc; 2260228072Sbapt M4_YY_DECL_GUTS_VAR(); 2261228072Sbapt 2262228072Sbapt if (!YY_G(yy_buffer_stack)) { 2263228072Sbapt 2264228072Sbapt /* First allocation is just for 2 elements, since we don't know if this 2265228072Sbapt * scanner will even need a stack. We use 2 instead of 1 to avoid an 2266228072Sbapt * immediate realloc on the next call. 2267228072Sbapt */ 2268228072Sbapt num_to_alloc = 1; 2269228072Sbapt YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 2270228072Sbapt (num_to_alloc * sizeof(struct yy_buffer_state*) 2271228072Sbapt M4_YY_CALL_LAST_ARG); 2272228072Sbapt if ( ! YY_G(yy_buffer_stack) ) 2273228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 2274228072Sbapt 2275228072Sbapt 2276228072Sbapt memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2277228072Sbapt 2278228072Sbapt YY_G(yy_buffer_stack_max) = num_to_alloc; 2279228072Sbapt YY_G(yy_buffer_stack_top) = 0; 2280228072Sbapt return; 2281228072Sbapt } 2282228072Sbapt 2283228072Sbapt if (YY_G(yy_buffer_stack_top) >= (YY_G(yy_buffer_stack_max)) - 1){ 2284228072Sbapt 2285228072Sbapt /* Increase the buffer to prepare for a possible push. */ 2286228072Sbapt int grow_size = 8 /* arbitrary grow size */; 2287228072Sbapt 2288228072Sbapt num_to_alloc = YY_G(yy_buffer_stack_max) + grow_size; 2289228072Sbapt YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 2290228072Sbapt (YY_G(yy_buffer_stack), 2291228072Sbapt num_to_alloc * sizeof(struct yy_buffer_state*) 2292228072Sbapt M4_YY_CALL_LAST_ARG); 2293228072Sbapt if ( ! YY_G(yy_buffer_stack) ) 2294228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 2295228072Sbapt 2296228072Sbapt /* zero only the new slots.*/ 2297228072Sbapt memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 2298228072Sbapt YY_G(yy_buffer_stack_max) = num_to_alloc; 2299228072Sbapt } 2300228072Sbapt} 2301228072Sbapt%endif 2302228072Sbapt 2303228072Sbapt 2304228072Sbapt 2305228072Sbapt 2306228072Sbaptm4_ifdef( [[M4_YY_NO_SCAN_BUFFER]],, 2307228072Sbapt[[ 2308228072Sbapt%if-c-only 2309228072Sbapt/** Setup the input buffer state to scan directly from a user-specified character buffer. 2310228072Sbapt * @param base the character buffer 2311228072Sbapt * @param size the size in bytes of the character buffer 2312228072Sbapt * M4_YY_DOC_PARAM 2313228072Sbapt * @return the newly allocated buffer state object. 2314228072Sbapt */ 2315228072SbaptYY_BUFFER_STATE yy_scan_buffer YYFARGS2( char *,base, yy_size_t ,size) 2316228072Sbapt{ 2317228072Sbapt YY_BUFFER_STATE b; 2318228072Sbapt m4_dnl M4_YY_DECL_GUTS_VAR(); 2319228072Sbapt 2320228072Sbapt if ( size < 2 || 2321228072Sbapt base[size-2] != YY_END_OF_BUFFER_CHAR || 2322228072Sbapt base[size-1] != YY_END_OF_BUFFER_CHAR ) 2323228072Sbapt /* They forgot to leave room for the EOB's. */ 2324228072Sbapt return 0; 2325228072Sbapt 2326228072Sbapt b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG ); 2327228072Sbapt if ( ! b ) 2328228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 2329228072Sbapt 2330228072Sbapt b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 2331228072Sbapt b->yy_buf_pos = b->yy_ch_buf = base; 2332228072Sbapt b->yy_is_our_buffer = 0; 2333228072Sbapt b->yy_input_file = 0; 2334228072Sbapt b->yy_n_chars = b->yy_buf_size; 2335228072Sbapt b->yy_is_interactive = 0; 2336228072Sbapt b->yy_at_bol = 1; 2337228072Sbapt b->yy_fill_buffer = 0; 2338228072Sbapt b->yy_buffer_status = YY_BUFFER_NEW; 2339228072Sbapt 2340228072Sbapt yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG ); 2341228072Sbapt 2342228072Sbapt return b; 2343228072Sbapt} 2344228072Sbapt%endif 2345228072Sbapt]]) 2346228072Sbapt 2347228072Sbapt 2348228072Sbaptm4_ifdef( [[M4_YY_NO_SCAN_STRING]],, 2349228072Sbapt[[ 2350228072Sbapt%if-c-only 2351228072Sbapt/** Setup the input buffer state to scan a string. The next call to yylex() will 2352228072Sbapt * scan from a @e copy of @a str. 2353228072Sbapt * @param yystr a NUL-terminated string to scan 2354228072Sbapt * M4_YY_DOC_PARAM 2355228072Sbapt * @return the newly allocated buffer state object. 2356228072Sbapt * @note If you want to scan bytes that may contain NUL values, then use 2357228072Sbapt * yy_scan_bytes() instead. 2358228072Sbapt */ 2359228072SbaptYY_BUFFER_STATE yy_scan_string YYFARGS1( yyconst char *, yystr) 2360228072Sbapt{ 2361228072Sbapt m4_dnl M4_YY_DECL_GUTS_VAR(); 2362228072Sbapt 2363228072Sbapt return yy_scan_bytes( yystr, strlen(yystr) M4_YY_CALL_LAST_ARG); 2364228072Sbapt} 2365228072Sbapt%endif 2366228072Sbapt]]) 2367228072Sbapt 2368228072Sbapt 2369228072Sbaptm4_ifdef( [[M4_YY_NO_SCAN_BYTES]],, 2370228072Sbapt[[ 2371228072Sbapt%if-c-only 2372228072Sbapt/** Setup the input buffer state to scan the given bytes. The next call to yylex() will 2373228072Sbapt * scan from a @e copy of @a bytes. 2374250125Sjkim * @param yybytes the byte buffer to scan 2375250125Sjkim * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 2376228072Sbapt * M4_YY_DOC_PARAM 2377228072Sbapt * @return the newly allocated buffer state object. 2378228072Sbapt */ 2379250125SjkimYY_BUFFER_STATE yy_scan_bytes YYFARGS2( yyconst char *,yybytes, yy_size_t ,_yybytes_len) 2380228072Sbapt{ 2381228072Sbapt YY_BUFFER_STATE b; 2382228072Sbapt char *buf; 2383228072Sbapt yy_size_t n; 2384250128Sjkim yy_size_t i; 2385228072Sbapt m4_dnl M4_YY_DECL_GUTS_VAR(); 2386228072Sbapt 2387228072Sbapt /* Get memory for full buffer, including space for trailing EOB's. */ 2388228072Sbapt n = _yybytes_len + 2; 2389228072Sbapt buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG ); 2390228072Sbapt if ( ! buf ) 2391228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2392228072Sbapt 2393228072Sbapt for ( i = 0; i < _yybytes_len; ++i ) 2394228072Sbapt buf[i] = yybytes[i]; 2395228072Sbapt 2396228072Sbapt buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 2397228072Sbapt 2398228072Sbapt b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG); 2399228072Sbapt if ( ! b ) 2400228072Sbapt YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2401228072Sbapt 2402228072Sbapt /* It's okay to grow etc. this buffer, and we should throw it 2403228072Sbapt * away when we're done. 2404228072Sbapt */ 2405228072Sbapt b->yy_is_our_buffer = 1; 2406228072Sbapt 2407228072Sbapt return b; 2408228072Sbapt} 2409228072Sbapt%endif 2410228072Sbapt]]) 2411228072Sbapt 2412228072Sbapt 2413228072Sbaptm4_ifdef( [[M4_YY_NO_PUSH_STATE]],, 2414228072Sbapt[[ 2415228072Sbapt%if-c-only 2416228072Sbapt static void yy_push_state YYFARGS1( int ,new_state) 2417228072Sbapt%endif 2418228072Sbapt%if-c++-only 2419228072Sbapt void yyFlexLexer::yy_push_state( int new_state ) 2420228072Sbapt%endif 2421228072Sbapt{ 2422228072Sbapt M4_YY_DECL_GUTS_VAR(); 2423228072Sbapt if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) ) 2424228072Sbapt { 2425228072Sbapt yy_size_t new_size; 2426228072Sbapt 2427228072Sbapt YY_G(yy_start_stack_depth) += YY_START_STACK_INCR; 2428228072Sbapt new_size = YY_G(yy_start_stack_depth) * sizeof( int ); 2429228072Sbapt 2430228072Sbapt if ( ! YY_G(yy_start_stack) ) 2431228072Sbapt YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG ); 2432228072Sbapt 2433228072Sbapt else 2434228072Sbapt YY_G(yy_start_stack) = (int *) yyrealloc( 2435228072Sbapt (void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG ); 2436228072Sbapt 2437228072Sbapt if ( ! YY_G(yy_start_stack) ) 2438228072Sbapt YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); 2439228072Sbapt } 2440228072Sbapt 2441228072Sbapt YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START; 2442228072Sbapt 2443228072Sbapt BEGIN(new_state); 2444228072Sbapt} 2445228072Sbapt]]) 2446228072Sbapt 2447228072Sbapt 2448228072Sbaptm4_ifdef( [[M4_YY_NO_POP_STATE]],, 2449228072Sbapt[[ 2450228072Sbapt%if-c-only 2451228072Sbapt static void yy_pop_state YYFARGS0(void) 2452228072Sbapt%endif 2453228072Sbapt%if-c++-only 2454228072Sbapt void yyFlexLexer::yy_pop_state() 2455228072Sbapt%endif 2456228072Sbapt{ 2457228072Sbapt M4_YY_DECL_GUTS_VAR(); 2458228072Sbapt if ( --YY_G(yy_start_stack_ptr) < 0 ) 2459228072Sbapt YY_FATAL_ERROR( "start-condition stack underflow" ); 2460228072Sbapt 2461228072Sbapt BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]); 2462228072Sbapt} 2463228072Sbapt]]) 2464228072Sbapt 2465228072Sbapt 2466228072Sbaptm4_ifdef( [[M4_YY_NO_TOP_STATE]],, 2467228072Sbapt[[ 2468228072Sbapt%if-c-only 2469228072Sbapt static int yy_top_state YYFARGS0(void) 2470228072Sbapt%endif 2471228072Sbapt%if-c++-only 2472228072Sbapt int yyFlexLexer::yy_top_state() 2473228072Sbapt%endif 2474228072Sbapt{ 2475228072Sbapt M4_YY_DECL_GUTS_VAR(); 2476228072Sbapt return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1]; 2477228072Sbapt} 2478228072Sbapt]]) 2479228072Sbapt 2480228072Sbapt#ifndef YY_EXIT_FAILURE 2481228072Sbapt#define YY_EXIT_FAILURE 2 2482228072Sbapt#endif 2483228072Sbapt 2484228072Sbapt%if-c-only 2485228072Sbaptstatic void yy_fatal_error YYFARGS1(yyconst char*, msg) 2486228072Sbapt{ 2487228072Sbapt m4_dnl M4_YY_DECL_GUTS_VAR(); 2488228072Sbapt (void) fprintf( stderr, "%s\n", msg ); 2489228072Sbapt exit( YY_EXIT_FAILURE ); 2490228072Sbapt} 2491228072Sbapt%endif 2492228072Sbapt%if-c++-only 2493228072Sbaptvoid yyFlexLexer::LexerError( yyconst char msg[] ) 2494228072Sbapt{ 2495228072Sbapt M4_YY_DECL_GUTS_VAR(); 2496228072Sbapt std::cerr << msg << std::endl; 2497228072Sbapt exit( YY_EXIT_FAILURE ); 2498228072Sbapt} 2499228072Sbapt%endif 2500228072Sbapt 2501228072Sbapt/* Redefine yyless() so it works in section 3 code. */ 2502228072Sbapt 2503228072Sbapt#undef yyless 2504228072Sbapt#define yyless(n) \ 2505228072Sbapt do \ 2506228072Sbapt { \ 2507228072Sbapt /* Undo effects of setting up yytext. */ \ 2508228072Sbapt int yyless_macro_arg = (n); \ 2509228072Sbapt YY_LESS_LINENO(yyless_macro_arg);\ 2510228072Sbapt yytext[yyleng] = YY_G(yy_hold_char); \ 2511228072Sbapt YY_G(yy_c_buf_p) = yytext + yyless_macro_arg; \ 2512228072Sbapt YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \ 2513228072Sbapt *YY_G(yy_c_buf_p) = '\0'; \ 2514228072Sbapt yyleng = yyless_macro_arg; \ 2515228072Sbapt } \ 2516228072Sbapt while ( 0 ) 2517228072Sbapt 2518228072Sbapt 2519228072Sbapt 2520228072Sbapt/* Accessor methods (get/set functions) to struct members. */ 2521228072Sbapt 2522228072Sbapt%if-c-only 2523228072Sbapt%if-reentrant 2524228072Sbaptm4_ifdef( [[M4_YY_NO_GET_EXTRA]],, 2525228072Sbapt[[ 2526228072Sbapt/** Get the user-defined data for this scanner. 2527228072Sbapt * M4_YY_DOC_PARAM 2528228072Sbapt */ 2529228072SbaptYY_EXTRA_TYPE yyget_extra YYFARGS0(void) 2530228072Sbapt{ 2531228072Sbapt M4_YY_DECL_GUTS_VAR(); 2532228072Sbapt return yyextra; 2533228072Sbapt} 2534228072Sbapt]]) 2535228072Sbapt%endif 2536228072Sbapt 2537228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LINENO]],, 2538228072Sbapt[[ 2539228072Sbapt/** Get the current line number. 2540228072Sbapt * M4_YY_DOC_PARAM 2541228072Sbapt */ 2542228072Sbaptint yyget_lineno YYFARGS0(void) 2543228072Sbapt{ 2544228072Sbapt M4_YY_DECL_GUTS_VAR(); 2545228072Sbapt 2546228072Sbapt m4_ifdef( [[M4_YY_REENTRANT]], 2547228072Sbapt [[ 2548228072Sbapt if (! YY_CURRENT_BUFFER) 2549228072Sbapt return 0; 2550228072Sbapt ]]) 2551228072Sbapt return yylineno; 2552228072Sbapt} 2553228072Sbapt]]) 2554228072Sbapt 2555228072Sbaptm4_ifdef( [[M4_YY_REENTRANT]], 2556228072Sbapt[[ 2557228072Sbaptm4_ifdef( [[M4_YY_NO_GET_COLUMN]],, 2558228072Sbapt[[ 2559228072Sbapt/** Get the current column number. 2560228072Sbapt * M4_YY_DOC_PARAM 2561228072Sbapt */ 2562228072Sbaptint yyget_column YYFARGS0(void) 2563228072Sbapt{ 2564228072Sbapt M4_YY_DECL_GUTS_VAR(); 2565228072Sbapt 2566228072Sbapt m4_ifdef( [[M4_YY_REENTRANT]], 2567228072Sbapt [[ 2568228072Sbapt if (! YY_CURRENT_BUFFER) 2569228072Sbapt return 0; 2570228072Sbapt ]]) 2571228072Sbapt return yycolumn; 2572228072Sbapt} 2573228072Sbapt]]) 2574228072Sbapt]]) 2575228072Sbapt 2576228072Sbaptm4_ifdef( [[M4_YY_NO_GET_IN]],, 2577228072Sbapt[[ 2578228072Sbapt/** Get the input stream. 2579228072Sbapt * M4_YY_DOC_PARAM 2580228072Sbapt */ 2581228072SbaptFILE *yyget_in YYFARGS0(void) 2582228072Sbapt{ 2583228072Sbapt M4_YY_DECL_GUTS_VAR(); 2584228072Sbapt return yyin; 2585228072Sbapt} 2586228072Sbapt]]) 2587228072Sbapt 2588228072Sbaptm4_ifdef( [[M4_YY_NO_GET_OUT]],, 2589228072Sbapt[[ 2590228072Sbapt/** Get the output stream. 2591228072Sbapt * M4_YY_DOC_PARAM 2592228072Sbapt */ 2593228072SbaptFILE *yyget_out YYFARGS0(void) 2594228072Sbapt{ 2595228072Sbapt M4_YY_DECL_GUTS_VAR(); 2596228072Sbapt return yyout; 2597228072Sbapt} 2598228072Sbapt]]) 2599228072Sbapt 2600228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LENG]],, 2601228072Sbapt[[ 2602228072Sbapt/** Get the length of the current token. 2603228072Sbapt * M4_YY_DOC_PARAM 2604228072Sbapt */ 2605250125Sjkimyy_size_t yyget_leng YYFARGS0(void) 2606228072Sbapt{ 2607228072Sbapt M4_YY_DECL_GUTS_VAR(); 2608228072Sbapt return yyleng; 2609228072Sbapt} 2610228072Sbapt]]) 2611228072Sbapt 2612228072Sbapt/** Get the current token. 2613228072Sbapt * M4_YY_DOC_PARAM 2614228072Sbapt */ 2615228072Sbaptm4_ifdef( [[M4_YY_NO_GET_TEXT]],, 2616228072Sbapt[[ 2617228072Sbaptchar *yyget_text YYFARGS0(void) 2618228072Sbapt{ 2619228072Sbapt M4_YY_DECL_GUTS_VAR(); 2620228072Sbapt return yytext; 2621228072Sbapt} 2622228072Sbapt]]) 2623228072Sbapt 2624228072Sbapt%if-reentrant 2625228072Sbaptm4_ifdef( [[M4_YY_NO_SET_EXTRA]],, 2626228072Sbapt[[ 2627228072Sbapt/** Set the user-defined data. This data is never touched by the scanner. 2628228072Sbapt * @param user_defined The data to be associated with this scanner. 2629228072Sbapt * M4_YY_DOC_PARAM 2630228072Sbapt */ 2631228072Sbaptvoid yyset_extra YYFARGS1( YY_EXTRA_TYPE ,user_defined) 2632228072Sbapt{ 2633228072Sbapt M4_YY_DECL_GUTS_VAR(); 2634228072Sbapt yyextra = user_defined ; 2635228072Sbapt} 2636228072Sbapt]]) 2637228072Sbapt%endif 2638228072Sbapt 2639228072Sbaptm4_ifdef( [[M4_YY_NO_SET_LINENO]],, 2640228072Sbapt[[ 2641228072Sbapt/** Set the current line number. 2642228072Sbapt * @param line_number 2643228072Sbapt * M4_YY_DOC_PARAM 2644228072Sbapt */ 2645228072Sbaptvoid yyset_lineno YYFARGS1( int ,line_number) 2646228072Sbapt{ 2647228072Sbapt M4_YY_DECL_GUTS_VAR(); 2648228072Sbapt 2649228072Sbapt m4_ifdef( [[M4_YY_REENTRANT]], 2650228072Sbapt [[ 2651228072Sbapt /* lineno is only valid if an input buffer exists. */ 2652228072Sbapt if (! YY_CURRENT_BUFFER ) 2653250125Sjkim YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); 2654228072Sbapt ]]) 2655228072Sbapt yylineno = line_number; 2656228072Sbapt} 2657228072Sbapt]]) 2658228072Sbapt 2659228072Sbaptm4_ifdef( [[M4_YY_REENTRANT]], 2660228072Sbapt[[ 2661228072Sbaptm4_ifdef( [[M4_YY_NO_SET_COLUMN]],, 2662228072Sbapt[[ 2663228072Sbapt/** Set the current column. 2664228072Sbapt * @param line_number 2665228072Sbapt * M4_YY_DOC_PARAM 2666228072Sbapt */ 2667228072Sbaptvoid yyset_column YYFARGS1( int , column_no) 2668228072Sbapt{ 2669228072Sbapt M4_YY_DECL_GUTS_VAR(); 2670228072Sbapt 2671228072Sbapt m4_ifdef( [[M4_YY_REENTRANT]], 2672228072Sbapt [[ 2673228072Sbapt /* column is only valid if an input buffer exists. */ 2674228072Sbapt if (! YY_CURRENT_BUFFER ) 2675250125Sjkim YY_FATAL_ERROR( "yyset_column called with no buffer" ); 2676228072Sbapt ]]) 2677228072Sbapt yycolumn = column_no; 2678228072Sbapt} 2679228072Sbapt]]) 2680228072Sbapt]]) 2681228072Sbapt 2682228072Sbapt 2683228072Sbaptm4_ifdef( [[M4_YY_NO_SET_IN]],, 2684228072Sbapt[[ 2685228072Sbapt/** Set the input stream. This does not discard the current 2686228072Sbapt * input buffer. 2687228072Sbapt * @param in_str A readable stream. 2688228072Sbapt * M4_YY_DOC_PARAM 2689228072Sbapt * @see yy_switch_to_buffer 2690228072Sbapt */ 2691228072Sbaptvoid yyset_in YYFARGS1( FILE * ,in_str) 2692228072Sbapt{ 2693228072Sbapt M4_YY_DECL_GUTS_VAR(); 2694228072Sbapt yyin = in_str ; 2695228072Sbapt} 2696228072Sbapt]]) 2697228072Sbapt 2698228072Sbaptm4_ifdef( [[M4_YY_NO_SET_OUT]],, 2699228072Sbapt[[ 2700228072Sbaptvoid yyset_out YYFARGS1( FILE * ,out_str) 2701228072Sbapt{ 2702228072Sbapt M4_YY_DECL_GUTS_VAR(); 2703228072Sbapt yyout = out_str ; 2704228072Sbapt} 2705228072Sbapt]]) 2706228072Sbapt 2707228072Sbapt 2708228072Sbaptm4_ifdef( [[M4_YY_NO_GET_DEBUG]],, 2709228072Sbapt[[ 2710228072Sbaptint yyget_debug YYFARGS0(void) 2711228072Sbapt{ 2712228072Sbapt M4_YY_DECL_GUTS_VAR(); 2713228072Sbapt return yy_flex_debug; 2714228072Sbapt} 2715228072Sbapt]]) 2716228072Sbapt 2717228072Sbaptm4_ifdef( [[M4_YY_NO_SET_DEBUG]],, 2718228072Sbapt[[ 2719228072Sbaptvoid yyset_debug YYFARGS1( int ,bdebug) 2720228072Sbapt{ 2721228072Sbapt M4_YY_DECL_GUTS_VAR(); 2722228072Sbapt yy_flex_debug = bdebug ; 2723228072Sbapt} 2724228072Sbapt]]) 2725228072Sbapt%endif 2726228072Sbapt 2727228072Sbapt%if-reentrant 2728228072Sbapt/* Accessor methods for yylval and yylloc */ 2729228072Sbapt 2730228072Sbapt%if-bison-bridge 2731228072Sbaptm4_ifdef( [[M4_YY_NO_GET_LVAL]],, 2732228072Sbapt[[ 2733228072SbaptYYSTYPE * yyget_lval YYFARGS0(void) 2734228072Sbapt{ 2735228072Sbapt M4_YY_DECL_GUTS_VAR(); 2736228072Sbapt return yylval; 2737228072Sbapt} 2738228072Sbapt]]) 2739228072Sbapt 2740228072Sbaptm4_ifdef( [[M4_YY_NO_SET_LVAL]],, 2741228072Sbapt[[ 2742228072Sbaptvoid yyset_lval YYFARGS1( YYSTYPE * ,yylval_param) 2743228072Sbapt{ 2744228072Sbapt M4_YY_DECL_GUTS_VAR(); 2745228072Sbapt yylval = yylval_param; 2746228072Sbapt} 2747228072Sbapt]]) 2748228072Sbapt 2749228072Sbaptm4_ifdef( [[<M4_YY_BISON_LLOC>]], 2750228072Sbapt[[ 2751228072Sbapt m4_ifdef( [[M4_YY_NO_GET_LLOC]],, 2752228072Sbapt [[ 2753228072SbaptYYLTYPE *yyget_lloc YYFARGS0(void) 2754228072Sbapt{ 2755228072Sbapt M4_YY_DECL_GUTS_VAR(); 2756228072Sbapt return yylloc; 2757228072Sbapt} 2758228072Sbapt ]]) 2759228072Sbapt 2760228072Sbapt m4_ifdef( [[M4_YY_NO_SET_LLOC]],, 2761228072Sbapt [[ 2762228072Sbaptvoid yyset_lloc YYFARGS1( YYLTYPE * ,yylloc_param) 2763228072Sbapt{ 2764228072Sbapt M4_YY_DECL_GUTS_VAR(); 2765228072Sbapt yylloc = yylloc_param; 2766228072Sbapt} 2767228072Sbapt ]]) 2768228072Sbapt]]) 2769228072Sbapt 2770228072Sbapt%endif 2771228072Sbapt 2772228072Sbapt 2773228072Sbapt/* User-visible API */ 2774228072Sbapt 2775228072Sbapt/* yylex_init is special because it creates the scanner itself, so it is 2776228072Sbapt * the ONLY reentrant function that doesn't take the scanner as the last argument. 2777228072Sbapt * That's why we explicitly handle the declaration, instead of using our macros. 2778228072Sbapt */ 2779228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]], 2780228072Sbapt[[ 2781228072Sbaptint yylex_init( ptr_yy_globals ) 2782228072Sbapt yyscan_t* ptr_yy_globals; 2783228072Sbapt]], 2784228072Sbapt[[ 2785228072Sbaptint yylex_init(yyscan_t* ptr_yy_globals) 2786228072Sbapt]]) 2787228072Sbapt{ 2788228072Sbapt if (ptr_yy_globals == NULL){ 2789228072Sbapt errno = EINVAL; 2790228072Sbapt return 1; 2791228072Sbapt } 2792228072Sbapt 2793228072Sbapt *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); 2794228072Sbapt 2795228072Sbapt if (*ptr_yy_globals == NULL){ 2796228072Sbapt errno = ENOMEM; 2797228072Sbapt return 1; 2798228072Sbapt } 2799228072Sbapt 2800228072Sbapt /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2801228072Sbapt memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2802228072Sbapt 2803228072Sbapt return yy_init_globals ( *ptr_yy_globals ); 2804228072Sbapt} 2805228072Sbapt 2806228072Sbapt 2807228072Sbapt/* yylex_init_extra has the same functionality as yylex_init, but follows the 2808228072Sbapt * convention of taking the scanner as the last argument. Note however, that 2809228072Sbapt * this is a *pointer* to a scanner, as it will be allocated by this call (and 2810228072Sbapt * is the reason, too, why this function also must handle its own declaration). 2811228072Sbapt * The user defined value in the first argument will be available to yyalloc in 2812228072Sbapt * the yyextra field. 2813228072Sbapt */ 2814228072Sbaptm4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]], 2815228072Sbapt[[ 2816228072Sbaptint yylex_init_extra( yy_user_defined, ptr_yy_globals ) 2817228072Sbapt YY_EXTRA_TYPE yy_user_defined; 2818228072Sbapt yyscan_t* ptr_yy_globals; 2819228072Sbapt]], 2820228072Sbapt[[ 2821228072Sbaptint yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) 2822228072Sbapt]]) 2823228072Sbapt{ 2824228072Sbapt struct yyguts_t dummy_yyguts; 2825228072Sbapt 2826228072Sbapt yyset_extra (yy_user_defined, &dummy_yyguts); 2827228072Sbapt 2828228072Sbapt if (ptr_yy_globals == NULL){ 2829228072Sbapt errno = EINVAL; 2830228072Sbapt return 1; 2831228072Sbapt } 2832228072Sbapt 2833228072Sbapt *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); 2834228072Sbapt 2835228072Sbapt if (*ptr_yy_globals == NULL){ 2836228072Sbapt errno = ENOMEM; 2837228072Sbapt return 1; 2838228072Sbapt } 2839228072Sbapt 2840228072Sbapt /* By setting to 0xAA, we expose bugs in 2841228072Sbapt yy_init_globals. Leave at 0x00 for releases. */ 2842228072Sbapt memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2843228072Sbapt 2844228072Sbapt yyset_extra (yy_user_defined, *ptr_yy_globals); 2845228072Sbapt 2846228072Sbapt return yy_init_globals ( *ptr_yy_globals ); 2847228072Sbapt} 2848228072Sbapt 2849228072Sbapt%endif if-c-only 2850228072Sbapt 2851228072Sbapt 2852228072Sbapt%if-c-only 2853228072Sbaptstatic int yy_init_globals YYFARGS0(void) 2854228072Sbapt{ 2855228072Sbapt M4_YY_DECL_GUTS_VAR(); 2856228072Sbapt /* Initialization is the same as for the non-reentrant scanner. 2857228072Sbapt * This function is called from yylex_destroy(), so don't allocate here. 2858228072Sbapt */ 2859228072Sbapt 2860228072Sbaptm4_ifdef( [[M4_YY_USE_LINENO]], 2861228072Sbapt[[ 2862228072Sbapt m4_ifdef( [[M4_YY_NOT_REENTRANT]], 2863228072Sbapt [[ 2864228072Sbapt /* We do not touch yylineno unless the option is enabled. */ 2865228072Sbapt yylineno = 1; 2866228072Sbapt ]]) 2867228072Sbapt]]) 2868228072Sbapt YY_G(yy_buffer_stack) = 0; 2869228072Sbapt YY_G(yy_buffer_stack_top) = 0; 2870228072Sbapt YY_G(yy_buffer_stack_max) = 0; 2871228072Sbapt YY_G(yy_c_buf_p) = (char *) 0; 2872228072Sbapt YY_G(yy_init) = 0; 2873228072Sbapt YY_G(yy_start) = 0; 2874228072Sbapt 2875228072Sbaptm4_ifdef( [[M4_YY_HAS_START_STACK_VARS]], 2876228072Sbapt[[ 2877228072Sbapt YY_G(yy_start_stack_ptr) = 0; 2878228072Sbapt YY_G(yy_start_stack_depth) = 0; 2879228072Sbapt YY_G(yy_start_stack) = NULL; 2880228072Sbapt]]) 2881228072Sbapt 2882228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 2883228072Sbapt[[ 2884228072Sbapt YY_G(yy_state_buf) = 0; 2885228072Sbapt YY_G(yy_state_ptr) = 0; 2886228072Sbapt YY_G(yy_full_match) = 0; 2887228072Sbapt YY_G(yy_lp) = 0; 2888228072Sbapt]]) 2889228072Sbapt 2890228072Sbaptm4_ifdef( [[M4_YY_TEXT_IS_ARRAY]], 2891228072Sbapt[[ 2892228072Sbapt YY_G(yytext_ptr) = 0; 2893228072Sbapt YY_G(yy_more_offset) = 0; 2894228072Sbapt YY_G(yy_prev_more_offset) = 0; 2895228072Sbapt]]) 2896228072Sbapt 2897228072Sbapt/* Defined in main.c */ 2898228072Sbapt#ifdef YY_STDINIT 2899228072Sbapt yyin = stdin; 2900228072Sbapt yyout = stdout; 2901228072Sbapt#else 2902228072Sbapt yyin = (FILE *) 0; 2903228072Sbapt yyout = (FILE *) 0; 2904228072Sbapt#endif 2905228072Sbapt 2906228072Sbapt /* For future reference: Set errno on error, since we are called by 2907228072Sbapt * yylex_init() 2908228072Sbapt */ 2909228072Sbapt return 0; 2910228072Sbapt} 2911228072Sbapt%endif 2912228072Sbapt 2913228072Sbapt 2914228072Sbapt%if-c-only SNIP! this currently causes conflicts with the c++ scanner 2915228072Sbapt/* yylex_destroy is for both reentrant and non-reentrant scanners. */ 2916228072Sbaptint yylex_destroy YYFARGS0(void) 2917228072Sbapt{ 2918228072Sbapt M4_YY_DECL_GUTS_VAR(); 2919228072Sbapt 2920228072Sbapt /* Pop the buffer stack, destroying each element. */ 2921228072Sbapt while(YY_CURRENT_BUFFER){ 2922228072Sbapt yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG ); 2923228072Sbapt YY_CURRENT_BUFFER_LVALUE = NULL; 2924228072Sbapt yypop_buffer_state(M4_YY_CALL_ONLY_ARG); 2925228072Sbapt } 2926228072Sbapt 2927228072Sbapt /* Destroy the stack itself. */ 2928228072Sbapt yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG); 2929228072Sbapt YY_G(yy_buffer_stack) = NULL; 2930228072Sbapt 2931228072Sbaptm4_ifdef( [[M4_YY_HAS_START_STACK_VARS]], 2932228072Sbapt[[ 2933228072Sbapt /* Destroy the start condition stack. */ 2934228072Sbapt yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG ); 2935228072Sbapt YY_G(yy_start_stack) = NULL; 2936228072Sbapt]]) 2937228072Sbapt 2938228072Sbaptm4_ifdef( [[M4_YY_USES_REJECT]], 2939228072Sbapt[[ 2940228072Sbapt yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG); 2941228072Sbapt YY_G(yy_state_buf) = NULL; 2942228072Sbapt]]) 2943228072Sbapt 2944228072Sbapt /* Reset the globals. This is important in a non-reentrant scanner so the next time 2945228072Sbapt * yylex() is called, initialization will occur. */ 2946228072Sbapt yy_init_globals( M4_YY_CALL_ONLY_ARG); 2947228072Sbapt 2948228072Sbapt%if-reentrant 2949228072Sbapt /* Destroy the main struct (reentrant only). */ 2950228072Sbapt yyfree ( yyscanner M4_YY_CALL_LAST_ARG ); 2951228072Sbapt yyscanner = NULL; 2952228072Sbapt%endif 2953228072Sbapt return 0; 2954228072Sbapt} 2955228072Sbapt%endif 2956228072Sbapt 2957228072Sbapt 2958228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 2959228072Sbapt[[ 2960228072Sbapt/* 2961228072Sbapt * Internal utility routines. 2962228072Sbapt */ 2963228072Sbapt]]) 2964228072Sbapt 2965228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 2966228072Sbapt[[ 2967228072Sbapt#ifndef yytext_ptr 2968228072Sbaptstatic void yy_flex_strncpy YYFARGS3( char*,s1, yyconst char *,s2, int,n) 2969228072Sbapt{ 2970250874Sjkim int i; 2971228072Sbapt for ( i = 0; i < n; ++i ) 2972228072Sbapt s1[i] = s2[i]; 2973228072Sbapt} 2974228072Sbapt#endif 2975228072Sbapt]]) 2976228072Sbapt 2977228072Sbaptm4_ifdef( [[M4_YY_NOT_IN_HEADER]], 2978228072Sbapt[[ 2979228072Sbapt#ifdef YY_NEED_STRLEN 2980228072Sbaptstatic int yy_flex_strlen YYFARGS1( yyconst char *,s) 2981228072Sbapt{ 2982250874Sjkim int n; 2983228072Sbapt for ( n = 0; s[n]; ++n ) 2984228072Sbapt ; 2985228072Sbapt 2986228072Sbapt return n; 2987228072Sbapt} 2988228072Sbapt#endif 2989228072Sbapt]]) 2990228072Sbapt 2991228072Sbaptm4_ifdef( [[M4_YY_NO_FLEX_ALLOC]],, 2992228072Sbapt[[ 2993228072Sbaptvoid *yyalloc YYFARGS1( yy_size_t ,size) 2994228072Sbapt{ 2995228072Sbapt return (void *) malloc( size ); 2996228072Sbapt} 2997228072Sbapt]]) 2998228072Sbapt 2999228072Sbaptm4_ifdef( [[M4_YY_NO_FLEX_REALLOC]],, 3000228072Sbapt[[ 3001228072Sbaptvoid *yyrealloc YYFARGS2( void *,ptr, yy_size_t ,size) 3002228072Sbapt{ 3003228072Sbapt /* The cast to (char *) in the following accommodates both 3004228072Sbapt * implementations that use char* generic pointers, and those 3005228072Sbapt * that use void* generic pointers. It works with the latter 3006228072Sbapt * because both ANSI C and C++ allow castless assignment from 3007228072Sbapt * any pointer type to void*, and deal with argument conversions 3008228072Sbapt * as though doing an assignment. 3009228072Sbapt */ 3010228072Sbapt return (void *) realloc( (char *) ptr, size ); 3011228072Sbapt} 3012228072Sbapt]]) 3013228072Sbapt 3014228072Sbaptm4_ifdef( [[M4_YY_NO_FLEX_FREE]],, 3015228072Sbapt[[ 3016228072Sbaptvoid yyfree YYFARGS1( void *,ptr) 3017228072Sbapt{ 3018228072Sbapt free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3019228072Sbapt} 3020228072Sbapt]]) 3021228072Sbapt 3022228072Sbapt%if-tables-serialization definitions 3023228072Sbaptm4preproc_include(`tables_shared.c') 3024228072Sbapt 3025228072Sbaptstatic int yytbl_read8 (void *v, struct yytbl_reader * rd) 3026228072Sbapt{ 3027228072Sbapt errno = 0; 3028228072Sbapt if (fread (v, sizeof (flex_uint8_t), 1, rd->fp) != 1){ 3029228072Sbapt errno = EIO; 3030228072Sbapt return -1; 3031228072Sbapt } 3032228072Sbapt rd->bread += sizeof(flex_uint8_t); 3033228072Sbapt return 0; 3034228072Sbapt} 3035228072Sbapt 3036228072Sbaptstatic int yytbl_read16 (void *v, struct yytbl_reader * rd) 3037228072Sbapt{ 3038228072Sbapt errno = 0; 3039228072Sbapt if (fread (v, sizeof (flex_uint16_t), 1, rd->fp) != 1){ 3040228072Sbapt errno = EIO; 3041228072Sbapt return -1; 3042228072Sbapt } 3043228072Sbapt *((flex_uint16_t *) v) = ntohs (*((flex_uint16_t *) v)); 3044228072Sbapt rd->bread += sizeof(flex_uint16_t); 3045228072Sbapt return 0; 3046228072Sbapt} 3047228072Sbapt 3048228072Sbaptstatic int yytbl_read32 (void *v, struct yytbl_reader * rd) 3049228072Sbapt{ 3050228072Sbapt errno = 0; 3051228072Sbapt if (fread (v, sizeof (flex_uint32_t), 1, rd->fp) != 1){ 3052228072Sbapt errno = EIO; 3053228072Sbapt return -1; 3054228072Sbapt } 3055228072Sbapt *((flex_uint32_t *) v) = ntohl (*((flex_uint32_t *) v)); 3056228072Sbapt rd->bread += sizeof(flex_uint32_t); 3057228072Sbapt return 0; 3058228072Sbapt} 3059228072Sbapt 3060228072Sbapt/** Read the header */ 3061228072Sbaptstatic int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader *, rd) 3062228072Sbapt{ 3063228072Sbapt int bytes; 3064228072Sbapt memset (th, 0, sizeof (struct yytbl_hdr)); 3065228072Sbapt 3066228072Sbapt if (yytbl_read32 (&(th->th_magic), rd) != 0) 3067228072Sbapt return -1; 3068228072Sbapt 3069228072Sbapt if (th->th_magic != YYTBL_MAGIC){ 3070250125Sjkim YY_FATAL_ERROR( "bad magic number" ); /* TODO: not fatal. */ 3071228072Sbapt return -1; 3072228072Sbapt } 3073228072Sbapt 3074228072Sbapt if (yytbl_read32 (&(th->th_hsize), rd) != 0 3075228072Sbapt || yytbl_read32 (&(th->th_ssize), rd) != 0 3076228072Sbapt || yytbl_read16 (&(th->th_flags), rd) != 0) 3077228072Sbapt return -1; 3078228072Sbapt 3079228072Sbapt /* Sanity check on header size. Greater than 1k suggests some funny business. */ 3080228072Sbapt if (th->th_hsize < 16 || th->th_hsize > 1024){ 3081250125Sjkim YY_FATAL_ERROR( "insane header size detected" ); /* TODO: not fatal. */ 3082228072Sbapt return -1; 3083228072Sbapt } 3084228072Sbapt 3085228072Sbapt /* Allocate enough space for the version and name fields */ 3086228072Sbapt bytes = th->th_hsize - 14; 3087228072Sbapt th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG); 3088228072Sbapt if ( ! th->th_version ) 3089228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yytbl_hdr_read()" ); 3090228072Sbapt 3091228072Sbapt /* we read it all into th_version, and point th_name into that data */ 3092228072Sbapt if (fread (th->th_version, 1, bytes, rd->fp) != bytes){ 3093228072Sbapt errno = EIO; 3094228072Sbapt yyfree(th->th_version M4_YY_CALL_LAST_ARG); 3095228072Sbapt th->th_version = NULL; 3096228072Sbapt return -1; 3097228072Sbapt } 3098228072Sbapt else 3099228072Sbapt rd->bread += bytes; 3100228072Sbapt 3101228072Sbapt th->th_name = th->th_version + strlen (th->th_version) + 1; 3102228072Sbapt return 0; 3103228072Sbapt} 3104228072Sbapt 3105228072Sbapt/** lookup id in the dmap list. 3106228072Sbapt * @param dmap pointer to first element in list 3107228072Sbapt * @return NULL if not found. 3108228072Sbapt */ 3109228072Sbaptstatic struct yytbl_dmap *yytbl_dmap_lookup YYFARGS2(struct yytbl_dmap *, dmap, 3110228072Sbapt int, id) 3111228072Sbapt{ 3112228072Sbapt while (dmap->dm_id) 3113228072Sbapt if (dmap->dm_id == id) 3114228072Sbapt return dmap; 3115228072Sbapt else 3116228072Sbapt dmap++; 3117228072Sbapt return NULL; 3118228072Sbapt} 3119228072Sbapt 3120228072Sbapt/** Read a table while mapping its contents to the local array. 3121228072Sbapt * @param dmap used to performing mapping 3122228072Sbapt * @return 0 on success 3123228072Sbapt */ 3124228072Sbaptstatic int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_reader*, rd) 3125228072Sbapt{ 3126228072Sbapt struct yytbl_data td; 3127228072Sbapt struct yytbl_dmap *transdmap=0; 3128228072Sbapt int len, i, rv, inner_loop_count; 3129228072Sbapt void *p=0; 3130228072Sbapt 3131228072Sbapt memset (&td, 0, sizeof (struct yytbl_data)); 3132228072Sbapt 3133228072Sbapt if (yytbl_read16 (&td.td_id, rd) != 0 3134228072Sbapt || yytbl_read16 (&td.td_flags, rd) != 0 3135228072Sbapt || yytbl_read32 (&td.td_hilen, rd) != 0 3136228072Sbapt || yytbl_read32 (&td.td_lolen, rd) != 0) 3137228072Sbapt return -1; 3138228072Sbapt 3139228072Sbapt /* Lookup the map for the transition table so we have it in case we need it 3140228072Sbapt * inside the loop below. This scanner might not even have a transition 3141228072Sbapt * table, which is ok. 3142228072Sbapt */ 3143228072Sbapt transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG); 3144228072Sbapt 3145228072Sbapt if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL){ 3146250125Sjkim YY_FATAL_ERROR( "table id not found in map." ); /* TODO: not fatal. */ 3147228072Sbapt return -1; 3148228072Sbapt } 3149228072Sbapt 3150228072Sbapt /* Allocate space for table. 3151228072Sbapt * The --full yy_transition table is a special case, since we 3152228072Sbapt * need the dmap.dm_sz entry to tell us the sizeof the individual 3153228072Sbapt * struct members. 3154228072Sbapt */ 3155228072Sbapt { 3156228072Sbapt size_t bytes; 3157228072Sbapt 3158228072Sbapt if ((td.td_flags & YYTD_STRUCT)) 3159228072Sbapt bytes = sizeof(struct yy_trans_info) * td.td_lolen * (td.td_hilen ? td.td_hilen : 1); 3160228072Sbapt else 3161228072Sbapt bytes = td.td_lolen * (td.td_hilen ? td.td_hilen : 1) * dmap->dm_sz; 3162228072Sbapt 3163228072Sbapt if(M4_YY_TABLES_VERIFY) 3164228072Sbapt /* We point to the array itself */ 3165228072Sbapt p = dmap->dm_arr; 3166228072Sbapt else 3167228072Sbapt /* We point to the address of a pointer. */ 3168228072Sbapt *dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG); 3169228072Sbapt if ( ! p ) 3170228072Sbapt YY_FATAL_ERROR( "out of dynamic memory in yytbl_data_load()" ); 3171228072Sbapt } 3172228072Sbapt 3173228072Sbapt /* If it's a struct, we read 2 integers to get one element */ 3174228072Sbapt if ((td.td_flags & YYTD_STRUCT) != 0) 3175228072Sbapt inner_loop_count = 2; 3176228072Sbapt else 3177228072Sbapt inner_loop_count = 1; 3178228072Sbapt 3179228072Sbapt /* read and map each element. 3180228072Sbapt * This loop iterates once for each element of the td_data array. 3181228072Sbapt * Notice that we increment 'i' in the inner loop. 3182228072Sbapt */ 3183228072Sbapt len = yytbl_calc_total_len (&td); 3184228072Sbapt for (i = 0; i < len; ){ 3185228072Sbapt int j; 3186228072Sbapt 3187228072Sbapt 3188228072Sbapt /* This loop really executes exactly 1 or 2 times. 3189228072Sbapt * The second time is to handle the second member of the 3190228072Sbapt * YYTD_STRUCT for the yy_transition array. 3191228072Sbapt */ 3192228072Sbapt for (j = 0; j < inner_loop_count; j++, i++) { 3193228072Sbapt flex_int32_t t32; 3194228072Sbapt 3195228072Sbapt /* read into t32 no matter what the real size is. */ 3196228072Sbapt { 3197228072Sbapt flex_int16_t t16; 3198228072Sbapt flex_int8_t t8; 3199228072Sbapt 3200228072Sbapt switch (YYTDFLAGS2BYTES (td.td_flags)) { 3201228072Sbapt case sizeof (flex_int32_t): 3202228072Sbapt rv = yytbl_read32 (&t32, rd); 3203228072Sbapt break; 3204228072Sbapt case sizeof (flex_int16_t): 3205228072Sbapt rv = yytbl_read16 (&t16, rd); 3206228072Sbapt t32 = t16; 3207228072Sbapt break; 3208228072Sbapt case sizeof (flex_int8_t): 3209228072Sbapt rv = yytbl_read8 (&t8, rd); 3210228072Sbapt t32 = t8; 3211228072Sbapt break; 3212228072Sbapt default: 3213250125Sjkim YY_FATAL_ERROR( "invalid td_flags" ); /* TODO: not fatal. */ 3214228072Sbapt return -1; 3215228072Sbapt } 3216228072Sbapt } 3217228072Sbapt if (rv != 0) 3218228072Sbapt return -1; 3219228072Sbapt 3220228072Sbapt /* copy into the deserialized array... */ 3221228072Sbapt 3222228072Sbapt if ((td.td_flags & YYTD_STRUCT)) { 3223228072Sbapt /* t32 is the j'th member of a two-element struct. */ 3224228072Sbapt void *v; 3225228072Sbapt 3226228072Sbapt v = j == 0 ? &(((struct yy_trans_info *) p)->yy_verify) 3227228072Sbapt : &(((struct yy_trans_info *) p)->yy_nxt); 3228228072Sbapt 3229228072Sbapt switch (dmap->dm_sz) { 3230228072Sbapt case sizeof (flex_int32_t): 3231228072Sbapt if (M4_YY_TABLES_VERIFY){ 3232228072Sbapt if( ((flex_int32_t *) v)[0] != (flex_int32_t) t32) 3233250125Sjkim YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int32_t" ); 3234228072Sbapt }else 3235228072Sbapt ((flex_int32_t *) v)[0] = (flex_int32_t) t32; 3236228072Sbapt break; 3237228072Sbapt case sizeof (flex_int16_t): 3238228072Sbapt if (M4_YY_TABLES_VERIFY ){ 3239228072Sbapt if(((flex_int16_t *) v)[0] != (flex_int16_t) t32) 3240250125Sjkim YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int16_t" ); 3241228072Sbapt }else 3242228072Sbapt ((flex_int16_t *) v)[0] = (flex_int16_t) t32; 3243228072Sbapt break; 3244228072Sbapt case sizeof(flex_int8_t): 3245228072Sbapt if (M4_YY_TABLES_VERIFY ){ 3246228072Sbapt if( ((flex_int8_t *) v)[0] != (flex_int8_t) t32) 3247250125Sjkim YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int8_t" ); 3248228072Sbapt }else 3249228072Sbapt ((flex_int8_t *) v)[0] = (flex_int8_t) t32; 3250228072Sbapt break; 3251228072Sbapt default: 3252250125Sjkim YY_FATAL_ERROR( "invalid dmap->dm_sz for struct" ); /* TODO: not fatal. */ 3253228072Sbapt return -1; 3254228072Sbapt } 3255228072Sbapt 3256228072Sbapt /* if we're done with j, increment p */ 3257228072Sbapt if (j == 1) 3258228072Sbapt p = (struct yy_trans_info *) p + 1; 3259228072Sbapt } 3260228072Sbapt else if ((td.td_flags & YYTD_PTRANS)) { 3261228072Sbapt /* t32 is an index into the transition array. */ 3262228072Sbapt struct yy_trans_info *v; 3263228072Sbapt 3264228072Sbapt 3265228072Sbapt if (!transdmap){ 3266250125Sjkim YY_FATAL_ERROR( "transition table not found" ); /* TODO: not fatal. */ 3267228072Sbapt return -1; 3268228072Sbapt } 3269228072Sbapt 3270228072Sbapt if( M4_YY_TABLES_VERIFY) 3271228072Sbapt v = &(((struct yy_trans_info *) (transdmap->dm_arr))[t32]); 3272228072Sbapt else 3273228072Sbapt v = &((*((struct yy_trans_info **) (transdmap->dm_arr)))[t32]); 3274228072Sbapt 3275228072Sbapt if(M4_YY_TABLES_VERIFY ){ 3276228072Sbapt if( ((struct yy_trans_info **) p)[0] != v) 3277250125Sjkim YY_FATAL_ERROR( "tables verification failed at YYTD_PTRANS" ); 3278228072Sbapt }else 3279228072Sbapt ((struct yy_trans_info **) p)[0] = v; 3280228072Sbapt 3281228072Sbapt /* increment p */ 3282228072Sbapt p = (struct yy_trans_info **) p + 1; 3283228072Sbapt } 3284228072Sbapt else { 3285228072Sbapt /* t32 is a plain int. copy data, then incrememnt p. */ 3286228072Sbapt switch (dmap->dm_sz) { 3287228072Sbapt case sizeof (flex_int32_t): 3288228072Sbapt if(M4_YY_TABLES_VERIFY ){ 3289228072Sbapt if( ((flex_int32_t *) p)[0] != (flex_int32_t) t32) 3290250125Sjkim YY_FATAL_ERROR( "tables verification failed at flex_int32_t" ); 3291228072Sbapt }else 3292228072Sbapt ((flex_int32_t *) p)[0] = (flex_int32_t) t32; 3293228072Sbapt p = ((flex_int32_t *) p) + 1; 3294228072Sbapt break; 3295228072Sbapt case sizeof (flex_int16_t): 3296228072Sbapt if(M4_YY_TABLES_VERIFY ){ 3297228072Sbapt if( ((flex_int16_t *) p)[0] != (flex_int16_t) t32) 3298250125Sjkim YY_FATAL_ERROR( "tables verification failed at flex_int16_t" ); 3299228072Sbapt }else 3300228072Sbapt ((flex_int16_t *) p)[0] = (flex_int16_t) t32; 3301228072Sbapt p = ((flex_int16_t *) p) + 1; 3302228072Sbapt break; 3303228072Sbapt case sizeof (flex_int8_t): 3304228072Sbapt if(M4_YY_TABLES_VERIFY ){ 3305228072Sbapt if( ((flex_int8_t *) p)[0] != (flex_int8_t) t32) 3306250125Sjkim YY_FATAL_ERROR( "tables verification failed at flex_int8_t" ); 3307228072Sbapt }else 3308228072Sbapt ((flex_int8_t *) p)[0] = (flex_int8_t) t32; 3309228072Sbapt p = ((flex_int8_t *) p) + 1; 3310228072Sbapt break; 3311228072Sbapt default: 3312250125Sjkim YY_FATAL_ERROR( "invalid dmap->dm_sz for plain int" ); /* TODO: not fatal. */ 3313228072Sbapt return -1; 3314228072Sbapt } 3315228072Sbapt } 3316228072Sbapt } 3317228072Sbapt 3318228072Sbapt } 3319228072Sbapt 3320228072Sbapt /* Now eat padding. */ 3321228072Sbapt { 3322228072Sbapt int pad; 3323228072Sbapt pad = yypad64(rd->bread); 3324228072Sbapt while(--pad >= 0){ 3325228072Sbapt flex_int8_t t8; 3326228072Sbapt if(yytbl_read8(&t8,rd) != 0) 3327228072Sbapt return -1; 3328228072Sbapt } 3329228072Sbapt } 3330228072Sbapt 3331228072Sbapt return 0; 3332228072Sbapt} 3333228072Sbapt 3334228072Sbapt%define-yytables The name for this specific scanner's tables. 3335228072Sbapt 3336228072Sbapt/* Find the key and load the DFA tables from the given stream. */ 3337228072Sbaptstatic int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) 3338228072Sbapt{ 3339228072Sbapt int rv=0; 3340228072Sbapt struct yytbl_hdr th; 3341228072Sbapt struct yytbl_reader rd; 3342228072Sbapt 3343228072Sbapt rd.fp = fp; 3344228072Sbapt th.th_version = NULL; 3345228072Sbapt 3346228072Sbapt /* Keep trying until we find the right set of tables or end of file. */ 3347228072Sbapt while (!feof(rd.fp)) { 3348228072Sbapt rd.bread = 0; 3349228072Sbapt if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0){ 3350228072Sbapt rv = -1; 3351228072Sbapt goto return_rv; 3352228072Sbapt } 3353228072Sbapt 3354228072Sbapt /* A NULL key means choose the first set of tables. */ 3355228072Sbapt if (key == NULL) 3356228072Sbapt break; 3357228072Sbapt 3358228072Sbapt if (strcmp(th.th_name,key) != 0){ 3359228072Sbapt /* Skip ahead to next set */ 3360228072Sbapt fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR); 3361228072Sbapt yyfree(th.th_version M4_YY_CALL_LAST_ARG); 3362228072Sbapt th.th_version = NULL; 3363228072Sbapt } 3364228072Sbapt else 3365228072Sbapt break; 3366228072Sbapt } 3367228072Sbapt 3368228072Sbapt while (rd.bread < th.th_ssize){ 3369228072Sbapt /* Load the data tables */ 3370228072Sbapt if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){ 3371228072Sbapt rv = -1; 3372228072Sbapt goto return_rv; 3373228072Sbapt } 3374228072Sbapt } 3375228072Sbapt 3376228072Sbaptreturn_rv: 3377228072Sbapt if(th.th_version){ 3378228072Sbapt yyfree(th.th_version M4_YY_CALL_LAST_ARG); 3379228072Sbapt th.th_version = NULL; 3380228072Sbapt } 3381228072Sbapt 3382228072Sbapt return rv; 3383228072Sbapt} 3384228072Sbapt 3385228072Sbapt/** Load the DFA tables for this scanner from the given stream. */ 3386228072Sbaptint yytables_fload YYFARGS1(FILE *, fp) 3387228072Sbapt{ 3388228072Sbapt 3389228072Sbapt if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0) 3390228072Sbapt return -1; 3391228072Sbapt return 0; 3392228072Sbapt} 3393228072Sbapt 3394228072Sbapt/** Destroy the loaded tables, freeing memory, etc.. */ 3395228072Sbaptint yytables_destroy YYFARGS0(void) 3396228072Sbapt{ 3397228072Sbapt struct yytbl_dmap *dmap=0; 3398228072Sbapt 3399228072Sbapt if(!M4_YY_TABLES_VERIFY){ 3400228072Sbapt /* Walk the dmap, freeing the pointers */ 3401228072Sbapt for(dmap=yydmap; dmap->dm_id; dmap++) { 3402228072Sbapt void * v; 3403228072Sbapt v = dmap->dm_arr; 3404228072Sbapt if(v && *(char**)v){ 3405228072Sbapt yyfree(*(char**)v M4_YY_CALL_LAST_ARG); 3406228072Sbapt *(char**)v = NULL; 3407228072Sbapt } 3408228072Sbapt } 3409228072Sbapt } 3410228072Sbapt 3411228072Sbapt return 0; 3412228072Sbapt} 3413228072Sbapt 3414228072Sbapt/* end table serialization code definitions */ 3415228072Sbapt%endif 3416228072Sbapt 3417228072Sbapt 3418228072Sbaptm4_ifdef([[M4_YY_MAIN]], [[ 3419228072Sbaptint main M4_YY_PARAMS(void); 3420228072Sbapt 3421228072Sbaptint main () 3422228072Sbapt{ 3423228072Sbapt 3424228072Sbapt%if-reentrant 3425228072Sbapt yyscan_t lexer; 3426228072Sbapt yylex_init(&lexer); 3427228072Sbapt yylex( lexer ); 3428228072Sbapt yylex_destroy( lexer); 3429228072Sbapt 3430228072Sbapt%endif 3431228072Sbapt%if-not-reentrant 3432228072Sbapt yylex(); 3433228072Sbapt%endif 3434228072Sbapt 3435228072Sbapt return 0; 3436228072Sbapt} 3437228072Sbapt]]) 3438228072Sbapt 3439228072Sbapt%ok-for-header 3440228072Sbaptm4_ifdef( [[M4_YY_IN_HEADER]], 3441228072Sbapt[[ 3442228072Sbapt#undef YY_NEW_FILE 3443228072Sbapt#undef YY_FLUSH_BUFFER 3444228072Sbapt#undef yy_set_bol 3445228072Sbapt#undef yy_new_buffer 3446228072Sbapt#undef yy_set_interactive 3447228072Sbapt#undef YY_DO_BEFORE_ACTION 3448228072Sbapt 3449228072Sbapt#ifdef YY_DECL_IS_OURS 3450228072Sbapt#undef YY_DECL_IS_OURS 3451228072Sbapt#undef YY_DECL 3452228072Sbapt#endif 3453228072Sbapt]]) 3454