cpp-flex.skl

%# -*-C-*- vi: set ft=c:
%#
%# All generated macros for the m4 stage contain the text "m4" or "M4"
%# in them. This is to distinguish them from CPP macros.
%# The exception to this rule is YY_G, which is an m4 macro,
%# but it needs to be remain short because it is used everywhere.
%#
%# The m4 macros complicate reading this code enough that being
%# prescriptive about whitespace and braces is more than usually
%# important. So please set your C style to K&R, aka 1TBS with
%# tabs when editing this file. Braces around single-statement
%# if/while/for/do/switch/break bodies are mandatory.
%#

%#  Macros for preproc stage.
m4preproc_changecom

%# Macros for runtime processing stage.
m4_changecom
m4_changequote
m4_changequote([[, ]])

%# Properties not used in the skeleton - meant to be read by the Flex code
m4_define([[M4_PROPERTY_BACKEND_NAME]], [[C/C++]])
%#m4_define([[M4_PROPERTY_SOURCE_SUFFIX]], [[]])
m4_define([[M4_PROPERTY_TRACE_LINE_REGEXP]], [[^#line ([0-9]+) "(.*)"]])
m4_define([[M4_PROPERTY_TRACE_LINE_TEMPLATE]], [[#line %d "%s"]])

%# Macro hooks used by Flex code generators start here
m4_define([[M4_HOOK_INT32]], [[flex_int32_t]])
m4_define([[M4_HOOK_INT16]], [[flex_int16_t]])
m4_define([[M4_HOOK_COMMENT_OPEN]], [[/*]])
m4_define([[M4_HOOK_COMMENT_CLOSE]], [[*/]])
%# If this is not defined, no trace lines will be generated.
m4_define([[M4_HOOK_TRACE_LINE_FORMAT]], [[#line $1 "$2"
]])
m4_define([[M4_HOOK_TABLE_OPENER]], [[{]])
m4_define([[M4_HOOK_TABLE_CONTINUE]], [[},]])
m4_define([[M4_HOOK_TABLE_CLOSER]], [[};]])
m4_define([[M4_HOOK_RELATIVIZE]], [[$1]])
m4_define([[M4_HOOK_STATE_ENTRY_FORMAT]], [[	&yy_transition[$1],
]])
m4_define([[M4_HOOK_NORMAL_STATE_CASE_ARM]], [[	case $1:]])
m4_define([[M4_HOOK_EOF_STATE_CASE_ARM]], [[	case YY_STATE_EOF($1):]])
m4_define([[M4_HOOK_EOF_STATE_CASE_FALLTHROUGH]], [[		/* FALLTHROUGH */]])
m4_define([[M4_HOOK_EOF_STATE_CASE_TERMINATE]], [[		yyterminate();
]])
m4_define([[M4_HOOK_TAKE_YYTEXT]], [[YY_DO_BEFORE_ACTION; /* set up yytext */]])
m4_define([[M4_HOOK_RELEASE_YYTEXT]], [[*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */]])
m4_define([[M4_HOOK_CHAR_REWIND]], [[YY_G(yy_c_buf_p) = yy_cp -= $1;]])
m4_define([[M4_HOOK_LINE_REWIND]], [[YY_LINENO_REWIND_TO(yy_cp - $1);]])
m4_define([[M4_HOOK_CHAR_FORWARD]], [[YY_G(yy_c_buf_p) = yy_cp = yy_bp + $1;]])
m4_define([[M4_HOOK_LINE_FORWARD]], [[YY_LINENO_REWIND_TO(yy_bp + $1);]])
m4_define([[M4_HOOK_CONST_DEFINE_BYTE]], [[#define $1 $2
]])
m4_define([[M4_HOOK_CONST_DEFINE_STATE]], [[#define $1 $2
]])
m4_define([[M4_HOOK_CONST_DEFINE_UINT]], [[#define $1 $2
]])
m4_define([[M4_HOOK_CONST_DEFINE_BOOL]], [[#define $1 $2
]])
m4_define([[M4_HOOK_CONST_DEFINE_UNKNOWN]], [[#define $1 $2
]])
m4_define([[M4_HOOK_SET_OFFSET_TYPE]], [[#define YY_OFFSET_TYPE $1
]])
m4_define([[M4_HOOK_SET_YY_DECL]], [[#define YY_DECL $1
]])
m4_define([[M4_HOOK_SET_USERINIT]], [[#define YY_USER_INIT $1
]])
m4_define([[M4_HOOK_SET_RULE_SETUP]], [[YY_RULE_SETUP
]])
m4_define([[M4_HOOK_SET_PREACTION]], [[#define YY_USER_ACTION $1
]])
m4_define([[M4_HOOK_STATE_CASE_BREAK]], [[/*LINTED*/break;]])
m4_define([[M4_HOOK_SET_POSTACTION]], [[m4_define([[M4_HOOK_STATE_CASE_BREAK]], [[$1]])]])
m4_define([[M4_HOOK_FATAL_ERROR]], [[yypanic($1 M4_YY_CALL_LAST_ARG);]])
m4_define([[M4_HOOK_ECHO]], [[yyecho();]])

m4_ifdef([[M4_MODE_YYTERMINATE]], [[m4_define([[yyterminate]], [[M4_MODE_YYTERMINATE]])]])

m4_define([[M4_HOOK_REJECT]], [[yyreject()]])

%% [0.0] Make hook macros available to Flex

m4_ifdef( [[M4_YY_IN_HEADER]], [[m4_dnl
#ifndef M4_MODE_PREFIX[[HEADER_H]]
#define M4_MODE_PREFIX[[HEADER_H]]
#define M4_MODE_PREFIX[[IN_HEADER]] 1

]])				
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
m4_ifelse(M4_MODE_PREFIX,yy,,
#define yy_create_buffer M4_MODE_PREFIX[[_create_buffer]]
#define yy_delete_buffer M4_MODE_PREFIX[[_delete_buffer]]
#define yy_scan_buffer M4_MODE_PREFIX[[_scan_buffer]]
#define yy_scan_string M4_MODE_PREFIX[[_scan_string]]
#define yy_scan_bytes M4_MODE_PREFIX[[_scan_bytes]]
#define yy_init_buffer M4_MODE_PREFIX[[_init_buffer]]
#define yy_flush_buffer M4_MODE_PREFIX[[_flush_buffer]]
#define yy_load_buffer_state M4_MODE_PREFIX[[_load_buffer_state]]
#define yy_switch_to_buffer M4_MODE_PREFIX[[_switch_to_buffer]]
#define yypush_buffer_state M4_MODE_PREFIX[[push_buffer_state]]
#define yypop_buffer_state M4_MODE_PREFIX[[pop_buffer_state]]
#define yyensure_buffer_stack M4_MODE_PREFIX[[ensure_buffer_stack]]
#define yyflexdebug M4_MODE_PREFIX[[flexdebug]]
#define yyin M4_MODE_PREFIX[[in]]
#define yyleng M4_MODE_PREFIX[[leng]]
#define yylex M4_MODE_PREFIX[[lex]]
#define yylineno M4_MODE_PREFIX[[lineno]]
#define yyout M4_MODE_PREFIX[[out]]
#define yyrestart M4_MODE_PREFIX[[restart]]
#define yytext M4_MODE_PREFIX[[text]]
#define yywrap M4_MODE_PREFIX[[wrap]]
#define yyalloc M4_MODE_PREFIX[[alloc]]
#define yyrealloc M4_MODE_PREFIX[[realloc]]
#define yyfree M4_MODE_PREFIX[[free]]
#define yyread M4_MODE_PREFIX[[read]]
)
]])
]])
]])
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION FLEX_MAJOR_VERSION
#define YY_FLEX_MINOR_VERSION FLEX_MINOR_VERSION
#define YY_FLEX_SUBMINOR_VERSION FLEX_SUBMINOR_VERSION
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

%# Some negated symbols
m4_ifdef( [[M4_YY_IN_HEADER]], , [[m4_define([[M4_YY_NOT_IN_HEADER]], [[]])]])
m4_ifdef( [[M4_YY_REENTRANT]], , [[m4_define([[M4_YY_NOT_REENTRANT]], [[]])]])

%# This is the m4 way to say "(stack_used || is_reentrant)"
m4_ifdef( [[M4_YY_STACK_USED]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])
m4_ifdef( [[M4_YY_REENTRANT]],  [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])

%# Prefixes.
%# The complexity here is necessary so that m4 preserves
%# the argument lists to each C function.


m4_ifdef( [[M4_MODE_PREFIX]],, [[m4_define([[M4_MODE_PREFIX]], [[yy]])]])

m4preproc_define(`M4_GEN_PREFIX',``
[[#ifdef yy$1
#define ]]M4_MODE_PREFIX[[$1_ALREADY_DEFINED
#else
#define yy$1 ]]M4_MODE_PREFIX[[$1
#endif]]
'm4preproc_divert(1)`
[[#ifndef ]]M4_MODE_PREFIX[[$1_ALREADY_DEFINED
#undef yy$1
#endif]]'m4preproc_divert(0)')

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
    /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
     * following macro. This is required in order to pass the c++-multiple-scanners
     * test in the regression suite. We get reports that it breaks inheritance.
     * We will address this in a future release of flex, or omit the C++ scanner
     * altogether.
     */
    #define yyFlexLexer M4_MODE_PREFIX[[FlexLexer]]
]])

m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifelse(M4_MODE_PREFIX,yy,,
    M4_GEN_PREFIX(`_create_buffer')
    M4_GEN_PREFIX(`_delete_buffer')
    M4_GEN_PREFIX(`_scan_buffer')
    M4_GEN_PREFIX(`_scan_string')
    M4_GEN_PREFIX(`_scan_bytes')
    M4_GEN_PREFIX(`_init_buffer')
    M4_GEN_PREFIX(`_flush_buffer')
    M4_GEN_PREFIX(`_load_buffer_state')
    M4_GEN_PREFIX(`_switch_to_buffer')
    M4_GEN_PREFIX(`push_buffer_state')
    M4_GEN_PREFIX(`pop_buffer_state')
    M4_GEN_PREFIX(`ensure_buffer_stack')
    M4_GEN_PREFIX(`lex')
    M4_GEN_PREFIX(`restart')
    M4_GEN_PREFIX(`lex_init')
    M4_GEN_PREFIX(`lex_init_extra')
    M4_GEN_PREFIX(`lex_destroy')
    M4_GEN_PREFIX(`get_debug')
    M4_GEN_PREFIX(`set_debug')
    M4_GEN_PREFIX(`get_extra')
    M4_GEN_PREFIX(`set_extra')
    M4_GEN_PREFIX(`get_in')
    M4_GEN_PREFIX(`set_in')
    M4_GEN_PREFIX(`get_out')
    M4_GEN_PREFIX(`set_out')
    M4_GEN_PREFIX(`get_leng')
    M4_GEN_PREFIX(`get_text')
    M4_GEN_PREFIX(`get_lineno')
    M4_GEN_PREFIX(`set_lineno')
    m4_ifdef( [[M4_YY_REENTRANT]],
    [[
        M4_GEN_PREFIX(`get_column')
        M4_GEN_PREFIX(`set_column')
    ]])
    M4_GEN_PREFIX(`wrap')
)
]])

m4_ifdef( [[M4_YY_BISON_LVAL]],
[[
    M4_GEN_PREFIX(`get_lval')
    M4_GEN_PREFIX(`set_lval')
]])

m4_ifdef( [[<M4_YY_BISON_LLOC>]],
[[
    M4_GEN_PREFIX(`get_lloc')
    M4_GEN_PREFIX(`set_lloc')
]])


m4_ifelse(M4_MODE_PREFIX,yy,,
    M4_GEN_PREFIX(`alloc')
    M4_GEN_PREFIX(`realloc')
    M4_GEN_PREFIX(`free')
)

m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifelse(M4_MODE_PREFIX,yy,,
m4_ifdef( [[M4_YY_NOT_REENTRANT]],
[[
    M4_GEN_PREFIX(`text')
    M4_GEN_PREFIX(`leng')
    M4_GEN_PREFIX(`in')
    M4_GEN_PREFIX(`out')
    M4_GEN_PREFIX(`flexdebug')
    M4_GEN_PREFIX(`lineno')
]])
)
]])


m4_ifdef( [[M4_MODE_TABLESEXT]],
[[
    M4_GEN_PREFIX(`tables_fload')
    M4_GEN_PREFIX(`tables_destroy')
    M4_GEN_PREFIX(`TABLES_NAME')
]])

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]], ,
[[m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]], ,
[[/* Feature test macros. Flex uses functions that require a minimum set of
 * macros defined. As defining some macros may hide function declarations that
 * user code might use, be conservative and respect user's definitions as much
 * as possible. In glibc, feature test macros may not be all set up until one
 * of the libc header (that includes <features.h>) is included. This creates
 * a circular dependency when we check the macros. <assert.h> is the safest
 * header we can include and does not declare too many functions we don't need.
 */
#if !defined(__GNU_LIBRARY__) && defined(__STDC__)
#include <assert.h>
#endif
#if !(defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE) || \
    defined(_POSIX_SOURCE))
# define _POSIX_C_SOURCE 1 /* Required for fileno() */
# define _POSIX_SOURCE 1
#endif]])]])
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
]])

m4_ifdef([[M4_MODE_TABLESEXT]], [[
#include <sys/types.h>
#include <netinet/in.h>
]])
/* end standard C headers. */

/* begin standard C++ headers. */
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
#include <iostream>
#include <errno.h>
#include <cstdlib>
#include <cstdio>
#include <cstring>
/* end standard C++ headers. */
]])

m4preproc_include(`flexint_shared.h')

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
/* Returned upon end-of-file. */
#define YY_NULL 0
]])

m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
]])



m4_ifdef([[M4_YY_REENTRANT]], [[

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

%# Declare yyguts variable
m4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*)yyscanner]])
%# Perform a noop access on yyguts to prevent unused variable complains
m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[(void)yyg]])
%# For use wherever a Global is accessed or assigned.
m4_define( [[YY_G]], [[yyg->$1]])

%# For use in function prototypes to append the additional argument.
m4_define( [[M4_YY_PROTO_LAST_ARG]],  [[, yyscan_t yyscanner]])
m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[yyscan_t yyscanner]])

m4_define( [[M4_YY_DEF_LAST_ARG]],  [[, yyscan_t yyscanner]])
m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[yyscan_t yyscanner]])
m4_define( [[M4_YY_DECL_LAST_ARG]],  [[yyscan_t yyscanner;]])

%# For use in function calls to pass the additional argument.
m4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]])
m4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]])

%# For use in function documentation to adjust for additional argument.
m4_define( [[M4_YY_DOC_PARAM]], [[@param yyscanner The scanner object.]])

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin YY_G(yyin_r)
#define yyout YY_G(yyout_r)
#define yyextra YY_G(yyextra_r)
#define yyleng YY_G(yyleng_r)
#define yytext YY_G(yytext_r)
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yyflexdebug YY_G(yyflexdebug_r)

m4_define( [[M4_YY_INCR_LINENO]],
[[
    do{ yylineno++;
        yycolumn=0;
    }while(0)
]])

]])



m4_ifdef([[M4_YY_NOT_REENTRANT]], [[

m4_define( [[M4_YY_INCR_LINENO]],
[[
    yylineno++;
]])

%# Define these macros to be no-ops.
m4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]])
m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[m4_dnl]])
m4_define( [[YY_G]], [[($1)]])
m4_define( [[M4_YY_PROTO_LAST_ARG]])
m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[void]])
m4_define( [[M4_YY_DEF_LAST_ARG]])

m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[void]])
m4_define([[M4_YY_DECL_LAST_ARG]])
m4_define([[M4_YY_CALL_LAST_ARG]])
m4_define([[M4_YY_CALL_ONLY_ARG]])
m4_define( [[M4_YY_DOC_PARAM]], )

]])


%# Generate C99 function defs.
m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]])
m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]])
m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define yybegin(s) YY_G(yy_start) = 1 + 2 * (s)
/* Legacy interface */
#define BEGIN YY_G(yy_start) = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define yystart() ((YY_G(yy_start) - 1) / 2)
/* Legacy interfaces */
#define YY_START ((YY_G(yy_start) - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG )
#define YY_END_OF_BUFFER_CHAR 0
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
]])


#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *yybuffer;
/* Legacy interface */
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
extern int yyleng;
]])

m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
extern FILE *yyin, *yyout;
]])
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    m4_ifdef( [[M4_MODE_YYLINENO]],
    [[
    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
     *       access to the local variable yy_act. Since yyless() is a macro, it would break
     *       existing scanners that call yyless() from OUTSIDE yylex.
     *       One obvious solution it to make yy_act a global. I tried that, and saw
     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
     *       normally declared as a register variable-- so it is not worth it.
     */
    #define  YY_LESS_LINENO(n) \
            do { \
                int yyl;\
                for ( yyl = n; yyl < yyleng; ++yyl ) { \
			if ( yytext[yyl] == '\n' ) { \
                        	--yylineno;\
			} \
		} \
            }while(0)
    #define YY_LINENO_REWIND_TO(dst) \
            do {\
                const char *p;\
                for ( p = yy_cp-1; p >= (dst); --p) { \
			if ( *p == '\n' ) { \
                		--yylineno;\
			} \
		} \
            }while(0)
    ]],
    [[
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    ]])
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = YY_G(yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
		YY_G(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define yyunput(c) yyunput_r( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG )
/* Legacy interface */
#define unput(c) yyunput_r( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG )
]])

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
m4_ifdef([[M4_MODE_C_ONLY]], [[
	FILE *yy_input_file;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
	std::streambuf* yy_input_file;
]])
	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yyatbol;

	int yy_bs_lineno; /**< The line count. */
	int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;
m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2
]])
	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Standard (non-C++) definition
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[

/* Stack of input buffers. */
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
static yybuffer * yy_buffer_stack = NULL; /**< Stack as an array. */
]])
]])
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define yy_current_buffer() ( YY_G(yy_buffer_stack)			\
                          ? YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] \
                          : NULL)
/* Legacy interface */
#define YY_CURRENT_BUFFER yy_current_buffer()
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]
]])

m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Standard (non-C++) definition

m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
/* yy_hold_char holds the character lost when yytext is formed. */
static char yy_hold_char;
static int yy_n_chars;		/* number of characters read into yy_ch_buf */
int yyleng;

/* Points to current character in buffer. */
static char *yy_c_buf_p = NULL;
static int yy_init = 0;		/* whether we need to initialize */
static int yy_start = 0;	/* start state number */

/* Flag which is used to allow yywrap()'s to do buffer switches
 * instead of setting up a fresh yyin.  A bit of a hack ...
 */
static int yy_did_buffer_switch_on_eof;
]])
]])

void yyrestart ( FILE *input_file M4_YY_PROTO_LAST_ARG );
void yy_switch_to_buffer ( yybuffer new_buffer M4_YY_PROTO_LAST_ARG );
yybuffer yy_create_buffer ( FILE *file, int size M4_YY_PROTO_LAST_ARG );
void yy_delete_buffer ( yybuffer b M4_YY_PROTO_LAST_ARG );
void yy_flush_buffer ( yybuffer b M4_YY_PROTO_LAST_ARG );
void yypush_buffer_state ( yybuffer new_buffer M4_YY_PROTO_LAST_ARG );
void yypop_buffer_state ( M4_YY_PROTO_ONLY_ARG );

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
static void yyensure_buffer_stack ( M4_YY_PROTO_ONLY_ARG );
static void yy_load_buffer_state ( M4_YY_PROTO_ONLY_ARG );
static void yy_init_buffer ( yybuffer b, FILE *file M4_YY_PROTO_LAST_ARG );
#define yy_flush_current_buffer() yy_flush_buffer( yy_current_buffer() M4_YY_CALL_LAST_ARG)
#define YY_FLUSH_BUFFER yy_flush_current_buffer()
]])

yybuffer yy_scan_buffer ( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG );
yybuffer yy_scan_string ( const char *yy_str M4_YY_PROTO_LAST_ARG );
yybuffer yy_scan_bytes ( const char *bytes, int len M4_YY_PROTO_LAST_ARG );

]])

void *yyalloc ( yy_size_t M4_YY_PROTO_LAST_ARG );
void *yyrealloc ( void *, yy_size_t M4_YY_PROTO_LAST_ARG );
void yyfree ( void * M4_YY_PROTO_LAST_ARG );

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) { \
	if ( yy_current_buffer() == NULL ) { \
		yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);	\
		YY_CURRENT_BUFFER_LVALUE =    \
			yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
#define yysetbol(at_bol) \
	{ \
	if ( yy_current_buffer() == NULL ) { \
		yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);	\
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yyatbol = at_bol; \
}
#define yyatbol() (YY_CURRENT_BUFFER_LVALUE->yyatbol)
/* Legacy interface */
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yyatbol)
#define yy_set_bol(at_bol) \
	{ \
	if ( yy_current_buffer() == NULL ) { \
		yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);	\
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yyatbol = at_bol; \
}
]])

/* Begin user sect3 */

m4_ifdef( [[M4_MODE_NO_YYWRAP]], [[
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef([[M4_YY_REENTRANT]], [[
#define M4_MODE_PREFIX[[wrap]](yyscanner) (/*CONSTCOND*/1)
]])
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
#define M4_MODE_PREFIX[[wrap]]() (/*CONSTCOND*/1)
]])m4_dnl
]])
#define YY_SKIP_YYWRAP
]])
m4_ifdef( [[M4_MODE_DEBUG]], [[
#define FLEX_DEBUG
]])
m4_ifdef( [[M4_YY_NOT_IN_HEADER]], [[m4_dnl
typedef flex_uint8_t YY_CHAR;
]])m4_dnl
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_define([[M4_TMP_STDINIT]], [[FILE *yyin = stdin, *yyout = stdout;]])
m4_define([[M4_TMP_NO_STDINIT]], [[FILE *yyin = NULL, *yyout = NULL;]])
m4_ifdef( [[M4_YY_NOT_IN_HEADER]], [[
m4_ifdef( [[M4_MODE_DO_STDINIT]], [[m4_dnl
m4_ifdef([[M4_YY_REENTRANT]], [[
#ifdef VMS
#ifdef __VMS_POSIX
#define YY_STDINIT
#endif
#else
#define YY_STDINIT
#endif
]])
#ifdef VMS");
#ifndef __VMS_POSIX
M4_TMP_NO_STDINIT
#else
M4_TMP_STDINIT
#endif
#else
M4_TMP_STDINIT
#endif
]])
m4_ifdef( [[M4_MODE_NO_DO_STDINIT]], [[
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
M4_TMP_NO_STDINIT
]])
]])
]])
m4_undefine([[M4_TMP_STDINIT]])
m4_undefine([[M4_TMP_NO_STDINIT]])
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
#define yytext_ptr yytext
m4_ifdef( [[M4_MODE_INTERACTIVE]], [[#define YY_INTERACTIVE]])
]])
m4_ifdef( [[M4_YY_NOT_IN_HEADER]], [[m4_dnl
m4_ifdef( [[M4_MODE_FULLSPD]], [[m4_dnl
typedef const struct yy_trans_info *yy_state_type;
]], [[
m4_ifdef([[M4_MODE_C_ONLY]], [[
typedef int yy_state_type;
]])
]])
]])
m4_ifdef([[M4_MODE_LEX_COMPAT]], [[#define YY_FLEX_LEX_COMPAT]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
extern int yylineno;
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
int yylineno = 1;
]])
]])
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[

#include <FlexLexer.h>
m4_ifdef([[M4_MODE_NO_YYWRAP]], [[
int yyFlexLexer::yywrap() { return 1;}
]])
m4_ifdef([[M4_MODE_YYCLASS]], [[
int yyFlexLexer::yylex()
	{
	LexerError( "yyFlexLexer::yylex invoked but %option yyclass used" );
	return 0;
	}

#define YY_DECL int M4_YY_CLASS_NAME::yylex()
]])
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
/* Watch out: yytext_ptr is a variable when yytext is an array,
 * but it's a macro when yytext is a pointer.
 */
m4_ifdef([[M4_MODE_YYTEXT_IS_ARRAY]], [[
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[extern char yytext[];]])
]])
m4_ifdef([[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[
m4_ifdef([[M4_YY_REENTRANT]], [[#define yytext_ptr yytext_r]],[[
extern char *yytext;

#ifdef yytext_ptr
#undef yytext_ptr
#endif
#define yytext_ptr yytext
]])
]])
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
%% [1.5] DFA
]])

m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Standard (non-C++) definition

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
static yy_state_type yy_get_previous_state ( M4_YY_PROTO_ONLY_ARG );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  M4_YY_PROTO_LAST_ARG);
static int yy_get_next_buffer ( M4_YY_PROTO_ONLY_ARG );
static void yynoreturn yypanic ( const char* msg M4_YY_PROTO_LAST_ARG );
]])

]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]], [[
struct yy_trans_info
	{
	/* We require that yy_verify and yy_nxt must be of the same size int. */
m4_ifdef([[M4_MODE_REAL_FULLSPD]], [[
	YY_OFFSET_TYPE yy_verify;

	/* In cases where its sister yy_verify *is* a "yes, there is
	 * a transition", yy_nxt is the offset (in records) to the
	 * next state.  In most cases where there is no transition,
	 * the value of yy_nxt is irrelevant.  If yy_nxt is the -1th
	 * record of a state, though, then yy_nxt is the action number
	 * for that state.
	 */
	 YY_OFFSET_TYPE yy_nxt;
]])
m4_ifdef([[M4_MODE_NO_REAL_FULLSPD]], [[
	/* We generate a bogus 'struct yy_trans_info' data type
	 * so we can guarantee that it is always declared in the skel.
	 * This is so we can compile "sizeof(struct yy_trans_info)"
	 * in any scanner.
	 */
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
]])
	};
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	YY_G(yytext_ptr) = yy_bp; \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[m4_ifdef([[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[YY_G(yytext_ptr) -= YY_G(yy_more_len); \
	yyleng = (int) (yy_cp - YY_G(yytext_ptr));]])]]) \
	m4_ifdef([[M4_MODE_NO_YYMORE_USED]], [[yyleng = (int) (yy_cp - yy_bp);]]) \
	m4_ifdef([[M4_MODE_YYTEXT_IS_ARRAY]], [[yyleng = (int) (yy_cp - yy_bp);]]) \
	YY_G(yy_hold_char) = *yy_cp; \
	*yy_cp = '\0'; \
m4_ifdef([[M4_MODE_YYTEXT_IS_ARRAY]], [[ \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[if ( yyleng + YY_G(yy_more_offset) >= YYLMAX ) \
		YY_FATAL_ERROR( "token too large, exceeds YYLMAX" );]]) \
	m4_ifdef([[M4_MODE_NO_YYMORE_USED]], [[if ( yyleng >= YYLMAX ) \
		YY_FATAL_ERROR( "token too large, exceeds YYLMAX" );]]) \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG);]]) \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[yyleng += YY_G(yy_more_offset);]]) \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[YY_G(yy_prev_more_offset) = YY_G(yy_more_offset);]]) \
	m4_ifdef([[M4_MODE_YYMORE_USED]], [[YY_G(yy_more_offset) = 0;]]) \
	m4_ifdef([[M4_MODE_NO_YYMORE_USED]], [[yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG);]]) \
]]) \
	YY_G(yy_c_buf_p) = yy_cp;

m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
m4_ifdef( [[M4_MODE_C_ONLY]],
[[
extern int yyflexdebug;
int yyflexdebug = m4_ifdef([[M4_MODE_DEBUG]],[[1]],[[0]]);
/* Legacy interface */
#ifndef yy_flex_debug
#define yy_flex_debug yyflexdebug
#endif
]])
]])

%% [2.0] data tables for the DFA are inserted here
m4_ifdef( [[M4_HOOK_NXT_ROWS]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_NXT_TYPE yy_nxt[][M4_HOOK_NXT_ROWS] =
M4_HOOK_NXT_BODY
]], [[
#undef YY_NXT_LOLEN
#define YY_NXT_LOLEN ([[]]M4_HOOK_NXT_ROWS[[]])
static const M4_HOOK_NXT_TYPE *yy_nxt =0;
]])

]])

m4_ifdef( [[M4_MODE_YYLINENO]],[[m4_dnl
/* Table of booleans, true if rule could match eol. */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_EOLTABLE_TYPE yy_rule_can_match_eol[M4_HOOK_EOLTABLE_SIZE] = { 0,
M4_HOOK_EOLTABLE_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_EOLTABLE_TYPE * yy_rule_can_match_eol = 0;
]])

]])

m4_ifdef( [[M4_HOOK_NEED_ACCEPT]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_ACCEPT_TYPE yy_accept[M4_HOOK_ACCEPT_SIZE] = { 0,
M4_HOOK_ACCEPT_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_ACCEPT_TYPE * yy_accept = 0;
]])

]])

m4_ifdef( [[M4_MODE_USEECS]],[[m4_dnl
/* Character equivalence-class mapping */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const YY_CHAR yy_ec[M4_HOOK_ECSTABLE_SIZE] = { 0,
M4_HOOK_ECSTABLE_BODY[[]]m4_dnl
};
]], [[
static const YY_CHAR * yy_ec = 0;
]])

]])
 
m4_ifdef( [[M4_MODE_USEMECS]],[[m4_dnl
/* Character meta-equivalence-class mappings */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const YY_CHAR yy_meta[M4_HOOK_MECSTABLE_SIZE] = { 0,
M4_HOOK_MECSTABLE_BODY[[]]m4_dnl
};
]], [[
static const YY_CHAR * yy_meta = 0;
]])

]])

m4_ifdef( [[M4_HOOK_TRANSTABLE_SIZE]],[[m4_dnl
/* The transition table */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const struct yy_trans_info yy_transition[M4_HOOK_TRANSTABLE_SIZE] = {
M4_HOOK_TRANSTABLE_BODY[[]]m4_dnl
};
]], [[
static const struct yy_trans_info *yy_transition = 0;
]])

]])

m4_ifdef( [[M4_HOOK_STARTTABLE_SIZE]],[[m4_dnl
/* Table of pointers to start states. */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const struct yy_trans_info *yy_start_state_list[M4_HOOK_STARTTABLE_SIZE] = {
M4_HOOK_STARTTABLE_BODY[[]]m4_dnl
};
]], [[
static const struct yy_trans_info **yy_start_state_list =0;
]])

]])

m4_ifdef( [[M4_HOOK_ACCLIST_TYPE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_ACCLIST_TYPE yy_acclist[M4_HOOK_ACCLIST_SIZE] = { 0,
M4_HOOK_ACCLIST_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_ACCLIST_TYPE * yy_acclist = 0;
]])

]])

m4_ifdef( [[M4_HOOK_BASE_TYPE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_BASE_TYPE yy_base[M4_HOOK_BASE_SIZE] = { 0,
M4_HOOK_BASE_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_BASE_TYPE * yy_base = 0;
]])

]])

m4_ifdef( [[M4_HOOK_DEF_TYPE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_DEF_TYPE yy_def[M4_HOOK_DEF_SIZE] = { 0,
M4_HOOK_DEF_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_DEF_TYPE * yy_def = 0;
]])

]])

m4_ifdef( [[M4_HOOK_YYNXT_TYPE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_YYNXT_TYPE yy_nxt[M4_HOOK_YYNXT_SIZE] = { 0,
M4_HOOK_YYNXT_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_YYNXT_TYPE * yy_nxt = 0;
]])

]])

m4_ifdef( [[M4_HOOK_CHK_TYPE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_CHK_TYPE yy_chk[M4_HOOK_CHK_SIZE] = { 0,
M4_HOOK_CHK_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_CHK_TYPE * yy_chk = 0;
]])

]])

m4_ifdef( [[M4_HOOK_NULTRANS_SIZE]],[[m4_dnl
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const yy_state_type yy_NUL_trans[M4_HOOK_NULTRANS_SIZE] = { 0,
M4_HOOK_NULTRANS_BODY[[]]m4_dnl
};
]], [[
static const yy_state_type * yy_NUL_trans = 0;
]])

]])

m4_ifdef( [[M4_MODE_DEBUG]],[[m4_dnl
/* Rule to line-number mapping */
m4_ifdef( [[M4_MODE_GENTABLES]],[[m4_dnl
static const M4_HOOK_DEBUGTABLE_TYPE yy_rule_linenum[M4_HOOK_DEBUGTABLE_SIZE] = { 0,
M4_HOOK_DEBUGTABLE_BODY[[]]m4_dnl
};
]], [[
static const M4_HOOK_DEBUGTABLE_TYPE * yy_rule_linenum = 0;
]])

]])

]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
m4_ifdef( [[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_MODE_NO_USES_REJECT]],[[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
/* Definitions for backing up.  We don't need them if yyreject()
 * is being used because then we use an alternative backing-up
 * technique instead.
 */
static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;

]])
]])
]])

m4_ifdef( [[M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES]], [[m4_dnl
%# These must match the values in the file flexdef.h
%# of the flex source code, otherwise havoc will ensue.
#define YY_TRAILING_MASK 0x2000
#define YY_TRAILING_HEAD_MASK 0x4000
]])
m4_ifdef( [[M4_MODE_USES_REJECT]],[[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
m4_ifdef( [[M4_MODE_C_ONLY]], [[
/* Declare state buffer variables. */
static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
static char *yy_full_match;
static int yy_lp;
m4_ifdef( [[M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES]], [[
static int yy_looking_for_trail_begin = 0;
static int yy_full_lp;
static int *yy_full_state;
]])
]])
]])
#define yyreject()				\
{ \
*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */ \
yy_cp = YY_G(yy_full_match); /* restore poss. backed-over text */ \
m4_ifdef( [[M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES]], [[ \
YY_G(yy_lp) = YY_G(yy_full_lp); /* restore orig. accepting pos. */ \
YY_G(yy_state_ptr) = YY_G(yy_full_state); /* restore orig. state */ \
yy_current_state = *YY_G(yy_state_ptr); /* restore curr. state */ \
]]) \
++YY_G(yy_lp); \
goto find_rule; \
}
#define REJECT	yyreject()
]])
m4_ifdef( [[M4_MODE_NO_USES_REJECT]],[[
/* The intent behind this definition is that it'll catch
 * any uses of yyreject() which flex missed.
 */
#define yyreject() reject_used_but_not_detected
#define REJECT reject_used_but_not_detected
]])

m4_ifdef([[M4_MODE_YYMORE_USED]], [[
m4_ifdef( [[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_MODE_YYTEXT_IS_ARRAY]], [[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
static int yy_more_offset = 0;
static int yy_prev_more_offset = 0;
]])
]])
m4_ifdef( [[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
static int yy_more_flag = 0;
static int yy_more_len = 0;
]])
]])
]])
m4_ifdef( [[M4_MODE_YYTEXT_IS_ARRAY]], [[
#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))
#define YY_NEED_STRLEN
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET \
{ \
YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \
yyleng -= YY_G(yy_more_offset); \
}
]])
m4_ifdef( [[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[
#define yymore() (YY_G(yy_more_flag) = 1)
#define YY_MORE_ADJ YY_G(yy_more_len)
#define YY_RESTORE_YY_MORE_OFFSET
]])
]])

m4_ifdef([[M4_MODE_NO_YYMORE_USED]], [[
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
]])

m4_ifdef( [[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_MODE_YYTEXT_IS_ARRAY]], [[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
char yytext[YYLMAX];
char *yytext_ptr;
]])
]])
m4_ifdef( [[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[
m4_ifdef( [[M4_YY_NOT_REENTRANT]], [[
char *yytext;
]])
]])
]])

%% [3.0] static declarations conditional on mode switches go here
]])

m4_ifdef( [[M4_YY_IN_HEADER]], [[#ifdef YY_HEADER_EXPORT_START_CONDITIONS]])
M4_YY_SC_DEFS
m4_ifdef( [[M4_YY_IN_HEADER]], [[#endif]])

m4_ifdef( [[M4_YY_NO_UNISTD_H]],,
[[
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
#include <unistd.h>
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
#include <unistd.h>
]])
#endif
]])

m4_ifdef( [[M4_EXTRA_TYPE_DEFS]],
[[
#define YY_EXTRA_TYPE M4_EXTRA_TYPE_DEFS
]],
[[
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
]]
)

m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Reentrant structure and macros (non-C++).
m4_ifdef([[M4_YY_REENTRANT]], [[

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* Holds the entire state of the reentrant scanner. */
struct yyguts_t {
	/* User-defined. Not touched by flex. */
	YY_EXTRA_TYPE yyextra_r;

	/* The rest are the same as the globals declared in the non-reentrant scanner. */
	FILE *yyin_r, *yyout_r;
	size_t yy_buffer_stack_top; /**< index of top of stack. */
	size_t yy_buffer_stack_max; /**< capacity of stack. */
	yybuffer * yy_buffer_stack; /**< Stack as an array. */
	char yy_hold_char;
	int yy_n_chars;
	int yyleng_r;
	char *yy_c_buf_p;
	int yy_init;
	int yy_start;
	int yy_did_buffer_switch_on_eof;
	int yy_start_stack_ptr;
	int yy_start_stack_depth;
	int *yy_start_stack;
	yy_state_type yy_last_accepting_state;
	char* yy_last_accepting_cpos;

	int yylineno_r;
	int yyflexdebug_r;

m4_ifdef( [[M4_MODE_USES_REJECT]], [[
	yy_state_type *yy_state_buf;
	yy_state_type *yy_state_ptr;
	char *yy_full_match;
	int yy_lp;

m4_ifdef( [[M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES]], [[m4_dnl
	/* These are only needed for trailing context rules */
	int yy_looking_for_trail_begin;
	int yy_full_lp;
	int *yy_full_state;
]])
]])
m4_ifdef( [[M4_MODE_REENTRANT_TEXT_IS_ARRAY]], [[
	char yytext_r[YYLMAX];
	char *yytext_ptr;
	int yy_more_offset;
	int yy_prev_more_offset;
]], [[
	char *yytext_r;
	int yy_more_flag;
	int yy_more_len;
]])
m4_ifdef( [[M4_YY_BISON_LVAL]], [[
	YYSTYPE * yylval_r;
]])

m4_ifdef( [[<M4_YY_BISON_LLOC>]], [[
	YYLTYPE * yylloc_r;
]])
}; /* end struct yyguts_t */
]])


m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
static int yy_init_globals ( M4_YY_PROTO_ONLY_ARG );
]])
]])

m4_ifdef([[M4_YY_REENTRANT]], [[

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
    m4_ifdef( [[M4_YY_BISON_LVAL]],
    [[
    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval YY_G(yylval_r)
    ]])

    m4_ifdef( [[<M4_YY_BISON_LLOC>]],
    [[
    #    define yylloc YY_G(yylloc_r)
    ]])
]])

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

]])

]])

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

m4_ifdef( [[M4_YY_NO_DESTROY]],,
[[
int yylex_destroy ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
[[
int yyget_debug ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
[[
void yyset_debug ( int debug_flag M4_YY_PROTO_LAST_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
[[
YY_EXTRA_TYPE yyget_extra ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
[[
void yyset_extra ( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_IN]],,
[[
FILE *yyget_in ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_SET_IN]],,
[[
void yyset_in  ( FILE * _in_str M4_YY_PROTO_LAST_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_OUT]],,
[[
FILE *yyget_out ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_SET_OUT]],,
[[
void yyset_out  ( FILE * _out_str M4_YY_PROTO_LAST_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_LENG]],,
[[
			int yyget_leng ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
[[
char *yyget_text ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
[[
int yyget_lineno ( M4_YY_PROTO_ONLY_ARG );
]])

m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
[[
void yyset_lineno ( int _line_number M4_YY_PROTO_LAST_ARG );
]])

m4_ifdef( [[M4_YY_REENTRANT]],
[[
m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
[[
int yyget_column  ( M4_YY_PROTO_ONLY_ARG );
]])
]])

m4_ifdef( [[M4_YY_REENTRANT]],
[[
m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
[[
void yyset_column ( int _column_no M4_YY_PROTO_LAST_ARG );
]])
]])

m4_ifdef([[M4_YY_BISON_LVAL]], [[
m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
[[
YYSTYPE * yyget_lval ( M4_YY_PROTO_ONLY_ARG );
]])

void yyset_lval ( YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG );

m4_ifdef( [[<M4_YY_BISON_LLOC>]],
[[
    m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
    [[
       YYLTYPE *yyget_lloc ( M4_YY_PROTO_ONLY_ARG );
    ]])

    m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
    [[
        void yyset_lloc ( YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG );
    ]])
]])
]])

/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( M4_YY_PROTO_ONLY_ARG );
#else
extern int yywrap ( M4_YY_PROTO_ONLY_ARG );
#endif
#endif

m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
#ifndef YY_NO_YYUNPUT
    m4_ifdef( [[M4_YY_NO_YYUNPUT]],,
    [[
    static void yyunput_r ( int c, char *buf_ptr  M4_YY_PROTO_LAST_ARG);
    ]])
#endif
]])
]])

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int M4_YY_PROTO_LAST_ARG);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * M4_YY_PROTO_LAST_ARG);
#endif

m4_ifdef([[M4_MODE_NO_YYINPUT]], [[#define YY_NO_YYINPUT 1]])

#ifndef YY_NO_YYINPUT
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
static int yyinput ( M4_YY_PROTO_ONLY_ARG );
#ifndef __cplusplus
#define input yyinput
#endif
]])
]])
#endif


m4_ifdef([[M4_MODE_C_ONLY]], [[
%# TODO: This is messy.
m4_ifdef( [[M4_YY_STACK_USED]],
[[

m4_ifdef( [[M4_YY_NOT_REENTRANT]],
[[
    m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
    [[
        static int yy_start_stack_ptr = 0;
        static int yy_start_stack_depth = 0;
        static int *yy_start_stack = NULL;
    ]])
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
    m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
    [[
    static void yy_push_state ( int _new_state M4_YY_PROTO_LAST_ARG);
    ]])
    m4_ifdef( [[M4_YY_NO_POP_STATE]],,
    [[
    static void yy_pop_state ( M4_YY_PROTO_ONLY_ARG );
    ]])
    m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
    [[
    static int yy_top_state ( M4_YY_PROTO_ONLY_ARG );
    ]])
]])

]],
[[
m4_define( [[M4_YY_NO_PUSH_STATE]])
m4_define( [[M4_YY_NO_POP_STATE]])
m4_define( [[M4_YY_NO_TOP_STATE]])
]])
]])

/*
 * Amount of stuff to slurp up with each read.
 * We assume the stdio library has already 
 * chosen a fit size foe whatever platform 
 * we're running on.
 */
#define YY_READ_BUF_SIZE BUFSIZ

/* Size of default input buffer. We want to be able to fit two
 * OS-level reads, but efficiency gains as the buffer size 
 * increases fall off after that
 */
#ifndef YY_BUF_SIZE
#define YY_BUF_SIZE	(m4_ifdef([[M4_MODE_YY_BUFSIZE]], [[M4_MODE_YY_BUFSIZE]], [[2 * YY_READ_BUF_SIZE]]))
#endif

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* Copy whatever the last rule matched to the standard output. */
#ifndef yyecho
m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Standard (non-C++) definition
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define yyecho() do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
%# C++ definition
#define yyecho() LexerOutput( yytext, yyleng )
]])
#endif
/* Legacy interface */
#define ECHO yyecho()
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

m4_ifdef([[M4_MODE_YY_NO_YYPANIC]],,[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yynoreturn yypanic YYFARGS1(const char*, msg) {
	M4_YY_DECL_GUTS_VAR();
	M4_YY_NOOP_GUTS_VAR();
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::LexerError( const char* msg ) {
	M4_YY_DECL_GUTS_VAR();
	std::cerr << msg << std::endl;
	exit( YY_EXIT_FAILURE );
}
]])
]])

/* Report a fatal error. Legacy interface. */
#ifndef YY_FATAL_ERROR
m4_ifdef([[M4_MODE_C_ONLY]], [[
#define YY_FATAL_ERROR(msg) yypanic( msg M4_YY_CALL_LAST_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
#define YY_FATAL_ERROR(msg) LexerError( msg )
]])
#endif

/* Legacy interface */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) do {result = yyread(buf, max_size M4_YY_CALL_LAST_ARG);} while (0)

m4_ifdef( [[M4_MODE_USER_YYREAD]], , [[
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
int yyFlexLexer::yyread(char *buf, size_t max_size) {
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
static int yyread(char *buf, size_t max_size M4_YY_PROTO_LAST_ARG) {
]])
	int result;
	M4_YY_DECL_GUTS_VAR();
m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_MODE_CPP_USE_READ]], [[
	errno=0;
	while ( (result = (int) read( fileno(yyin), buf, (yy_size_t) max_size )) < 0 ) {
		if( errno != EINTR) {
			YY_FATAL_ERROR( "input in flex scanner failed" );
			break;
		}
		errno=0;
		clearerr(yyin);
	}
]])
m4_ifdef( [[M4_MODE_NO_CPP_USE_READ]], [[
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) {
		int c = '*';
		int n;
		for ( n = 0; n < max_size &&
			      (c = getc( yyin )) != EOF && c != '\n'; ++n ) {
			buf[n] = (char) c;
		}
		if ( c == '\n' ) {
			buf[n++] = (char) c;
		}
		if ( c == EOF && ferror( yyin ) ) {
			YY_FATAL_ERROR( "input in flex scanner failed" );
		}
		result = n;
	} else {
		errno=0;
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) {
			if( errno != EINTR) {
				YY_FATAL_ERROR( "input in flex scanner failed" );
				break;
			}
			errno=0;
			clearerr(yyin);
		}
	}
]])
]])

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
%# C++ definition
	if ( (int)(result = LexerInput( (char *) buf, max_size )) < 0 ) {
		YY_FATAL_ERROR( "input in flex scanner failed" );
	}
]])
	 return result;
}
#endif
]])
]])

m4_ifdef( [[M4_MODE_YYTERMINATE]], , [[
m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif
]])
]])

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

m4_ifdef([[M4_MODE_TABLESEXT]], [[
%# structures and prototypes
m4preproc_include(`tables_shared.h')

/* Load the DFA tables from the given stream.  */
int yytables_fload (FILE * fp M4_YY_PROTO_LAST_ARG);

/* Unload the tables from memory. */
int yytables_destroy (M4_YY_PROTO_ONLY_ARG);
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl

/** Describes a mapping from a serialized table id to its deserialized state in
 * this scanner.  This is the bridge between our "generic" deserialization code
 * and the specifics of this scanner.
 */
struct yytbl_dmap {
	enum yytbl_id dm_id;/**< table identifier */
	void  **dm_arr;		/**< address of pointer to store the deserialized table. */
	size_t  dm_sz;		/**< local sizeof() each element in table. */
};

/** A {0,0,0}-terminated list of structs, forming the map */
static struct yytbl_dmap yydmap[] = {
m4_ifdef([[M4_HOOK_NXT_TYPE]], [[	{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(M4_HOOK_NXT_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_YYNXT_TYPE]], [[	{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(M4_HOOK_YYNXT_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_MODE_FULLSPD]], [[	{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(struct yy_trans_info*)},]],[[m4_dnl]])
m4_ifdef([[M4_MODE_YYLINENO]], [[	{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(M4_HOOK_EOLTABLE_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_MODE_USEECS]],  [[	{YYTD_ID_EC, (void**)&yy_ec, sizeof(YY_CHAR)},]],[[m4_dnl]])
m4_ifdef([[M4_MODE_USEMECS]], [[	{YYTD_ID_META, (void**)&yy_meta, sizeof(YY_CHAR)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_ACCLIST_TYPE]], [[	{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(M4_HOOK_ACCLIST_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_MKCTBL_TYPE]], [[	{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(M4_HOOK_MKCTBL_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_MKFTBL_TYPE]], [[	{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(M4_HOOK_MKFTBL_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_ACCEPT_TYPE]], [[	{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(M4_HOOK_ACCEPT_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_BASE_TYPE]], [[	{YYTD_ID_BASE, (void**)&yy_base, sizeof(M4_HOOK_BASE_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_DEF_TYPE]], [[	{YYTD_ID_DEF, (void**)&yy_def, sizeof(M4_HOOK_DEF_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_CHK_TYPE]], [[	{YYTD_ID_CHK, (void**)&yy_chk, sizeof(M4_HOOK_CHK_TYPE)},]],[[m4_dnl]])
m4_ifdef([[M4_HOOK_NULTRANS_TYPE]], [[	{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(M4_HOOK_NULTRANS_TYPE)},]],[[m4_dnl]])
    {0,0,0}
};

/** A tables-reader object to maintain some state in the read. */
struct yytbl_reader {
    FILE * fp; /**< input stream */
    flex_uint32_t bread; /**< bytes read since beginning of current tableset */
};

]])
/* end tables serialization structures and prototypes */

]])

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
m4_ifdef([[M4_MODE_C_ONLY]], [[
%# Standard (non-C++) definition


m4_define( [[M4_YY_LEX_PROTO]], [[(M4_YY_PROTO_ONLY_ARG)]])
m4_define( [[M4_YY_LEX_DECLARATION]], [[(M4_YY_DEF_ONLY_ARG)]])

m4_ifdef( [[M4_YY_BISON_LVAL]],
[[
    m4_dnl  The bison pure parser is used. Redefine yylex to
    m4_dnl  accept the lval parameter.

    m4_define( [[M4_YY_LEX_PROTO]], [[\]]
               [[(YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG)]])
    m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
               [[YYFARGS1(YYSTYPE *,yylval_param)]])
]])

m4_ifdef( [[<M4_YY_BISON_LLOC>]],
[[
    m4_dnl  Locations are used. yylex should also accept the ylloc parameter.

    m4_define( [[M4_YY_LEX_PROTO]], [[\]]
               [[(YYSTYPE * yylval_param, YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG)]])
    m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
               [[YYFARGS2(YYSTYPE *,yylval_param, YYLTYPE *,yylloc_param)]])
]])

extern int yylex M4_YY_LEX_PROTO;

#define YY_DECL int yylex M4_YY_LEX_DECLARATION
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
%# C++ definition
#define YY_DECL int yyFlexLexer::yylex()
]])
#endif /* !YY_DECL */

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#define YY_RULE_SETUP \
	m4_ifdef([[M4_MODE_BOL_NEEDED]], [[	if ( yyleng > 0 ) {  \
	YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \
	} \
]])	YY_USER_ACTION
]])

%# Code snippets used in various cases of code generation in the main scanner.

m4_define([[M4_GEN_BACKING_UP]], [[
m4_ifdef([[M4_MODE_NO_USES_REJECT]], [[
m4_ifdef([[M4_MODE_HAS_BACKING_UP]], [[
		/* Generate code to keep backing-up information. */
m4_ifdef([[M4_MODE_FULLSPD]], [[
		 if ( yy_current_state[-1].yy_nxt ) {
]])
m4_ifdef([[M4_MODE_NO_FULLSPD]], [[
		if ( yy_accept[yy_current_state] ) {
]])
			YY_G(yy_last_accepting_state) = yy_current_state;
			YY_G(yy_last_accepting_cpos) = yy_cp;
		}
]])
]])
]])

%# yy_c was formerly YY_CHAR, changed to int because table can now
%# have up to 0x101 entries, since we no longer generate a separate
%# NUL table.
%#
%# Note: on x86-64 architecture with gcc -O2, we save an instruction
%# in the main loop, since the character can now be zero-extended in
%# the process of retrieving it from the input stream or the yy_ec[]
%# or yy_meta[] arrays, whereas previously it was zero-extended by a
%# register-to-register move just prior to the yy_chk[] table lookup
m4_define([[M4_GEN_NEXT_COMPRESSED_STATE]], [[
	int yy_c = $1;
	/* Save the backing-up info \before/ computing the next state
	 * because we always compute one more state than needed - we
	 * always proceed until we reach a jam state
	 */
	M4_GEN_BACKING_UP

	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) {
		yy_current_state = (int) yy_def[yy_current_state];

m4_ifdef([[M4_MODE_USEMECS]], [[
		/* We've arranged it so that templates are never chained
		 * to one another.  This means we can afford to make a
		 * very simple test to see if we need to convert to
		 * yy_c's meta-equivalence class without worrying
		 * about erroneously looking up the meta-equivalence
		 * class twice
		 */

		/* lastdfa + 2 == YY_JAMSTATE + 1 is the beginning of the templates */
		if (yy_current_state >= YY_JAMSTATE + 1) {
			yy_c = yy_meta[yy_c];
		}
]])
	}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
]])

m4_define([[M4_GEN_START_STATE]], [[
	/* Generate the code to find the start state. */
m4_ifdef([[M4_MODE_FULLSPD]], [[
m4_ifdef([[M4_MODE_BOL_NEEDED]], [[yy_current_state", "yy_start_state_list[YY_G(yy_start) + yyatbol()];]])
m4_ifdef([[M4_MODE_NO_BOL_NEEDED]], [[yy_current_state = yy_start_state_list[YY_G(yy_start)];]])
]])
m4_ifdef([[M4_MODE_NO_FULLSPD]], [[
			yy_current_state = YY_G(yy_start);
m4_ifdef([[M4_MODE_BOL_NEEDED]], [[yy_current_state += yyatbol();]])
			/* Set up for storing up states. */
			m4_ifdef( [[M4_MODE_USES_REJECT]], [[
			YY_G(yy_state_ptr) = YY_G(yy_state_buf);
			*YY_G(yy_state_ptr)++ = yy_current_state;
]])
]])
]])

m4_define([[M4_GEN_NEXT_MATCH_FULLSPD]], [[
		{
			const struct yy_trans_info *yy_trans_info;
			YY_CHAR yy_c;

			for ( yy_c = $1;
			      (yy_trans_info = &yy_current_state[yy_c])->yy_verify == yy_c;
			      yy_c = $2 )
			{
				yy_current_state += yy_trans_info->yy_nxt;

				M4_GEN_BACKING_UP
			}
		}
]])

m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
/** The main scanner function which does all the work.
 */
YY_DECL {
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    M4_YY_DECL_GUTS_VAR();

m4_ifdef( [[M4_YY_NOT_REENTRANT]],
[[
    m4_ifdef( [[M4_YY_BISON_LVAL]],
    [[
        YYSTYPE * yylval;
    ]])
    m4_ifdef( [[<M4_YY_BISON_LLOC>]],
    [[
        YYLTYPE * yylloc;
    ]])
]])

m4_ifdef( [[M4_YY_BISON_LVAL]],
[[
    yylval = yylval_param;
]])

m4_ifdef( [[<M4_YY_BISON_LLOC>]],
[[
    yylloc = yylloc_param;
]])

	if ( !YY_G(yy_init) ) {
		YY_G(yy_init) = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

m4_ifdef( [[M4_MODE_USES_REJECT]],
[[
		/* Create the reject buffer large enough to save one state per allowed character. */
		if ( ! YY_G(yy_state_buf) ) {
			YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  M4_YY_CALL_LAST_ARG);
		}
		if ( ! YY_G(yy_state_buf) ) {
			YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
		}
]])

		if ( ! YY_G(yy_start) ) {
			YY_G(yy_start) = 1;	/* first start state */
		}
		if ( ! yyin ) {
m4_ifdef([[M4_MODE_C_ONLY]], [[
			yyin = stdin;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
			yyin.rdbuf(std::cin.rdbuf());
]])
		}
		if ( ! yyout ) {
m4_ifdef([[M4_MODE_C_ONLY]], [[
			yyout = stdout;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
			yyout.rdbuf(std::cout.rdbuf());
]])
		}
		if ( yy_current_buffer() == NULL ) {
			yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
		}

		yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
	}

	/* open scope of user declarationns */
	{
%% [4.0] user's declarations go here

		while ( /*CONSTCOND*/1 ) {		/* loops until end-of-file is reached */
m4_ifdef( [[M4_MODE_YYMORE_USED]], [[
m4_ifdef( [[M4_MODE_NO_YYTEXT_IS_ARRAY]], [[
			YY_G(yy_more_len) = 0;
			if ( YY_G(yy_more_flag) ) {
				YY_G(yy_more_len) = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr));
				YY_G(yy_more_flag) = 0;
			}
]])
]])
			yy_cp = YY_G(yy_c_buf_p);

			/* Support of yytext. */
			*yy_cp = YY_G(yy_hold_char);

			/* yy_bp points to the position in yy_ch_buf of the start of
			 * the current run.
			 */
			yy_bp = yy_cp;

M4_GEN_START_STATE

	yy_match:
			/* Generate the code to find the next match. */
%# Conditional indirection through an equivalence map
m4_ifdef([[M4_MODE_USEECS]], m4_define([[M4_EC]], [[*(yy_ec+$1)]]))
m4_ifdef([[M4_MODE_NO_USEECS]], [[m4_define([[M4_EC]], [[$1]])]])

m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[m4_dnl
m4_ifdef([[M4_MODE_GENTABLES]], [[m4_dnl
			while ((yy_current_state = yy_nxt[yy_current_state][ M4_EC(YY_SC_TO_UI(*yy_cp)) ]) > 0) {
]])
m4_ifdef([[M4_MODE_NO_GENTABLES]], [[
			while ((yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + M4_EC(YY_SC_TO_UI(*yy_cp)) ]) > 0) {
]])
M4_GEN_BACKING_UP
				yy_cp++;
			}
			yy_current_state = -yy_current_state;
]])
m4_ifdef([[M4_MODE_FULLSPD]], [[
			M4_GEN_NEXT_MATCH_FULLSPD(M4_EC(YY_SC_TO_UI(*yy_cp)), M4_EC(YY_SC_TO_UI(*++yy_cp)))
]])
m4_ifdef([[M4_MODE_NO_FULLSPD_OR_FULLTBL]], [[
			do {
				M4_GEN_NEXT_COMPRESSED_STATE(M4_EC(YY_SC_TO_UI(*yy_cp)))

				m4_ifdef([[M4_MODE_USES_REJECT]], [[*YY_G(yy_state_ptr)++ = yy_current_state;]])
				++yy_cp;

			}
			m4_ifdef([[M4_MODE_INTERACTIVE]], [[while ( yy_base[yy_current_state] != YY_JAMBASE );]])
			m4_ifdef([[M4_MODE_NO_INTERACTIVE]], [[while ( yy_current_state != YY_JAMSTATE );]])

m4_ifdef([[M4_MODE_NO_USES_REJECT]], [[
m4_ifdef([[M4_MODE_NO_INTERACTIVE]], [[
			/* Do the guaranteed-needed backing up to figure out
			 * the match.
			 */
			yy_cp = YY_G(yy_last_accepting_cpos);
			yy_current_state = YY_G(yy_last_accepting_state);
]])
]])
]])

	yy_find_action:
			/* code to find the action number goes here */
			m4_ifdef([[M4_MODE_FULLSPD]], [[yy_act = yy_current_state[-1].yy_nxt;]])
			m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[yy_act = yy_accept[yy_current_state];]])
m4_ifdef([[M4_MODE_FIND_ACTION_REJECT]], [[
			yy_current_state = *--YY_G(yy_state_ptr);
			YY_G(yy_lp) = yy_accept[yy_current_state];
m4_ifdef([[M4_MODE_FIND_ACTION_REJECT_REALLY_USED]], [[find_rule: /* we branch to this label when backing up */]])
			for ( ; ; ) {	/* loop until we find out what rule we matched */
				if (YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1]) {
					yy_act = yy_acclist[YY_G(yy_lp)];
m4_ifdef([[M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES]], [[
					if ((yy_act & YY_TRAILING_HEAD_MASK) != 0 || YY_G(yy_looking_for_trail_begin)) {
						if (yy_act == YY_G(yy_looking_for_trail_begin)) {
							YY_G(yy_looking_for_trail_begin) = 0;
							yy_act &= ~YY_TRAILING_HEAD_MASK;
							break;
						}
					} else if (( yy_act & YY_TRAILING_MASK) != 0) { 
						YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
						YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
m4_ifdef([[M4_MODE_REAL_REJECT]], [[
						/* Remember matched text in case we back up
						 * due to REJECT.
						 */
						YY_G(yy_full_match) = yy_cp;
						YY_G(yy_full_state) = YY_G(yy_state_ptr);
						YY_G(yy_full_lp) = YY_G(yy_lp);
]])
					} else {
						YY_G(yy_full_match) = yy_cp;
						YY_G(yy_full_state) = YY_G(yy_state_ptr);
						YY_G(yy_full_lp) = YY_G(yy_lp);
						break;
					}
					++YY_G(yy_lp);
				goto find_rule;
]])
m4_ifdef([[M4_MODE_NO_VARIABLE_TRAILING_CONTEXT_RULES]], [[
					/* Remember matched text in case we back up due to
					 * trailing context plus REJECT.
					 */
					YY_G(yy_full_match) = yy_cp;
					break;
]])
				}

				--yy_cp;

				/* We could consolidate the following two lines with those at
				 * the beginning, but at the cost of complaints that we're
				 * branching inside a loop.
				 */
				yy_current_state = *--YY_G(yy_state_ptr);
				YY_G(yy_lp) = yy_accept[yy_current_state];
			} /* close for */
]])
m4_ifdef([[M4_MODE_FIND_ACTION_COMPRESSED]], [[		yy_act = yy_accept[yy_current_state];
			if ( yy_act == 0 ) { /* have to back up */
				yy_cp = YY_G(yy_last_accepting_cpos);
				yy_current_state = YY_G(yy_last_accepting_state);
				yy_act = yy_accept[yy_current_state];
			}
]])

			YY_DO_BEFORE_ACTION;

m4_ifdef( [[M4_MODE_YYLINENO]],[[
m4_define([[M4_YYL_BASE]], [[m4_ifdef([[M4_MODE_YYMORE_USED]],
			    [[m4_ifdef([[M4_MODE_YYTEXT_IS_ARRAY]],
				       [[YY_G(yy_prev_more_offset)]], [[YY_G(yy_more_len)]])]], [[0]])]])
			if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) {
				int yyl;
				for ( yyl = M4_YYL_BASE; yyl < yyleng; ++yyl ) {
					if ( yytext[yyl] == '\n' ) {
						M4_YY_INCR_LINENO();

					}
				}
			}
]])

		do_action:	/* This label is used only to access EOF actions. */

m4_ifdef([[M4_MODE_DEBUG]], [[
			if ( yyflexdebug ) {
				if ( yy_act == 0 ) {
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					std::cerr << "--scanner backing up\n";
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
					fprintf( stderr, "--scanner backing up\n" );
]])
				} else if ( yy_act < YY_NUM_RULES ) {
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					std::cerr << "--accepting rule at line " << yy_rule_linenum[yy_act] <<
						"(\"" << yytext << "\")\n";
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
					fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
						(long)yy_rule_linenum[yy_act], yytext );
]])
				} else if ( yy_act == YY_NUM_RULES ) {
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					std::cerr << "--accepting default rule (\"" << yytext << "\")\n";
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
					fprintf( stderr, "--accepting default rule (\"%s\")\n",
					 yytext );
]])
     				} else if ( yy_act == YY_NUM_RULES + 1 ) {

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					std::cerr << "--(end of buffer or a NUL)\n";
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
					fprintf( stderr, "--(end of buffer or a NUL)\n" );
]])
				} else {
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					std::cerr << "--EOF (start condition " << yystart() << ")\n";
]])
m4_ifdef([[M4_MODE_C_ONLY]], [[
					fprintf( stderr, "--EOF (start condition %d)\n", yystart() );
]])
				}
			}
]])

			switch ( yy_act ) { /* beginning of action switch */
m4_ifdef([[M4_MODE_NO_USES_REJECT]], [[
m4_ifdef([[M4_MODE_HAS_BACKING_UP]], [[
			case 0: /* must back up */
				/* undo the effects of YY_DO_BEFORE_ACTION */
				*yy_cp = YY_G(yy_hold_char);

				/* Backing-up info for compressed tables is taken \after/ */
				/* yy_cp has been incremented for the next state. */
				yy_cp = YY_G(yy_last_accepting_cpos);
				m4_ifdef([[M4_MODE_FULLSPD]], [[yy_cp++;]])
				m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[yy_cp++;]])

				yy_current_state = YY_G(yy_last_accepting_state);
				goto yy_find_action;
]])
]])
%% [5.0] user actions get inserted here

			case YY_END_OF_BUFFER:
			{
				/* Amount of text matched not including the EOB char. */
				int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;

				/* Undo the effects of YY_DO_BEFORE_ACTION. */
				*yy_cp = YY_G(yy_hold_char);
				YY_RESTORE_YY_MORE_OFFSET

				if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) {
					/* We're scanning a new file or input source.  It's
					 * possible that this happened because the user
					 * just pointed yyin at a new source and called
					 * yylex().  If so, then we have to assure
					 * consistency between yy_current_buffer() and our
					 * globals.  Here is the right place to do so, because
					 * this is the first action (other than possibly a
					 * back-up) that will match for the new input source.
					 */
					YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
m4_ifdef([[M4_MODE_C_ONLY]], [[
					YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
					YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin.rdbuf();
]])
					YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
				}

				/* Note that here we test for yy_c_buf_p "<=" to the position
				 * of the first EOB in the buffer, since yy_c_buf_p will
				 * already have been incremented past the NUL character
				 * (since all states make transitions on EOB to the
				 * end-of-buffer state).  Contrast this with the test
				 * in input().
				 */
				if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] ) { /* This was really a NUL. */
					yy_state_type yy_next_state;

					YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;

					yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );

					/* Okay, we're now positioned to make the NUL
					 * transition.  We couldn't have
					 * yy_get_previous_state() go ahead and do it
					 * for us because it doesn't know how to deal
					 * with the possibility of jamming (and we don't
					 * want to build jamming into it because then it
					 * will run more slowly).
					 */

					yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG);

					yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;

					if ( yy_next_state ) {
						/* Consume the NUL. */
						yy_cp = ++YY_G(yy_c_buf_p);
						yy_current_state = yy_next_state;
						goto yy_match;
					} else {
%# Disguised case statement on table modes
						m4_ifdef([[M4_MODE_FULLSPD]], [[yy_cp = YY_G(yy_c_buf_p);]])
						m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[yy_cp = YY_G(yy_c_buf_p);]])
m4_ifdef([[M4_MODE_NO_FULLSPD_OR_FULLTBL]], [[
m4_ifdef([[M4_MODE_NO_USES_REJECT]], [[
m4_ifdef([[M4_NOT_MODE_INTERACTIVE]], [[
						/* Do the guaranteed-needed backing up to figure
						 * out the match.
						 */
						yy_cp = YY_G(yy_last_accepting_cpos);
						yy_current_state = YY_G(yy_last_accepting_state);
]])
]])
%# Disguised case statement on table modes ends
m4_ifdef([[M4_MODE_FIND_ACTION_REJECT_OR_INTERACTIVE]], [[
						/* Still need to initialize yy_cp, though
						 * yy_current_state was set up by
						 * yy_get_previous_state().
						 */
						yy_cp = YY_G(yy_c_buf_p);
]])
]])
						goto yy_find_action;
					}
				} else {	/* not a NUL */
					switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) {
					case EOB_ACT_END_OF_FILE:
						YY_G(yy_did_buffer_switch_on_eof) = 0;

						if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) {
							/* Note: because we've taken care in
							 * yy_get_next_buffer() to have set up
							 * yytext, we can now set up
							 * yy_c_buf_p so that if some total
							 * hoser (like flex itself) wants to
							 * call the scanner after we return the
							 * YY_NULL, it'll still work - another
							 * YY_NULL will get returned.
							 */
							YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;

							yy_act = YY_STATE_EOF(yystart());
							goto do_action;
						} else {
							if ( ! YY_G(yy_did_buffer_switch_on_eof) ) {
								YY_NEW_FILE;
							}
						}
						break;
					case EOB_ACT_CONTINUE_SCAN:
						YY_G(yy_c_buf_p) =
							YY_G(yytext_ptr) + yy_amount_of_matched_text;

						yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );

						yy_cp = YY_G(yy_c_buf_p);
						yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
						goto yy_match;

					case EOB_ACT_LAST_MATCH:
						YY_G(yy_c_buf_p) =
						&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];

						yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );

						yy_cp = YY_G(yy_c_buf_p);
						yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
						goto yy_find_action;
					} /* end EOB inner switch */
				} /* end if */
				break;
			} /* case YY_END_OF_BUFFER */
			default:
				YY_FATAL_ERROR("fatal flex scanner internal error--no action found" );
			} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */
]])

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
/* The contents of this function are C++ specific, so the YY_G macro is not used.
 * This constructor simply maintains backward compatibility.
 * DEPRECATED
 */
yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout ):
	yyin(arg_yyin ? arg_yyin->rdbuf() : std::cin.rdbuf()),
	yyout(arg_yyout ? arg_yyout->rdbuf() : std::cout.rdbuf())
{
	ctor_common();
}

/* The contents of this function are C++ specific, so the YY_G macro is not used.
 */
yyFlexLexer::yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout ):
	yyin(arg_yyin.rdbuf()),
	yyout(arg_yyout.rdbuf())
{
	ctor_common();
}

/* The contents of this function are C++ specific, so the YY_G macro is not used.
 */
void yyFlexLexer::ctor_common() {
	yy_c_buf_p = 0;
	yy_init = 0;
	yy_start = 0;
	yyflexdebug = 0;
	yylineno = 1;	// this will only get updated if %option yylineno

	yy_did_buffer_switch_on_eof = 0;

	yy_looking_for_trail_begin = 0;
	yy_more_flag = 0;
	yy_more_len = 0;
	yy_more_offset = yy_prev_more_offset = 0;

	yy_start_stack_ptr = yy_start_stack_depth = 0;
	yy_start_stack = NULL;

	yy_buffer_stack = NULL;
	yy_buffer_stack_top = 0;
	yy_buffer_stack_max = 0;


m4_ifdef( [[M4_MODE_USES_REJECT]],
[[
	yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE];
]],
[[
	yy_state_buf = 0;
]])
}

/* The contents of this function are C++ specific, so the YY_G macro is not used.
 */
yyFlexLexer::~yyFlexLexer() {
	delete [] yy_state_buf;
	yyfree( yy_start_stack M4_YY_CALL_LAST_ARG );
	yy_delete_buffer( yy_current_buffer() M4_YY_CALL_LAST_ARG);
	yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG );
}

/* The contents of this function are C++ specific, so the YY_G macro is not used.
 */
void yyFlexLexer::switch_streams( std::istream& new_in, std::ostream& new_out ) {
	// was if( new_in )
	yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
	yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG);

	// was if( new_out )
	yyout.rdbuf(new_out.rdbuf());
}

/* The contents of this function are C++ specific, so the YY_G macro is not used.
 */
void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
{
	if( ! new_in ) {
		new_in = &yyin;
	}

	if ( ! new_out ) {
		new_out = &yyout;
	}

	switch_streams(*new_in, *new_out);
}

#ifdef YY_INTERACTIVE
int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
#else
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
	if ( yyin.eof() || yyin.fail() ) {
		return 0;
	}
#ifdef YY_INTERACTIVE
	yyin.get( buf[0] );

	if ( yyin.eof() ) {
		return 0;
	}
	if ( yyin.bad() ) {
		return -1;
	}
	return 1;

#else
	(void) yyin.read( buf, max_size );

	if ( yyin.bad() ) {
		return -1;
	} else {
		return yyin.gcount();
	}
#endif
}

void yyFlexLexer::LexerOutput( const char* buf, int size ) {
	(void) yyout.write( buf, size );
}
]])
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
static int yy_get_next_buffer (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
int yyFlexLexer::yy_get_next_buffer()
]])
{
	M4_YY_DECL_GUTS_VAR();
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = YY_G(yytext_ptr);
	int number_to_move, i;
	int ret_val;

	if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] ) {
		YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" );
	}
	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) {
		/* Don't try to fill the buffer, so this is an EOF. */
		if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 ) {
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
		} else {
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
		}
	}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - 1);

	for ( i = 0; i < number_to_move; ++i ) {
		*(dest++) = *(source++);
	}
	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) {
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0;
	} else {
		int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */
m4_ifdef( [[M4_MODE_USES_REJECT]],
[[
			YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses yyreject()" );
]],
[[
			/* just a shorter name for the current buffer */
			yybuffer b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);

			if ( b->yy_is_our_buffer ) {
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 ) {
					b->yy_buf_size += b->yy_buf_size / 8;
				} else {
					b->yy_buf_size *= 2;
				}
				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) M4_YY_CALL_LAST_ARG );
			} else {
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;
			}
			if ( ! b->yy_ch_buf ) {
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );
			}
			YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;
]])
		}

		if ( num_to_read > YY_READ_BUF_SIZE ) {
			num_to_read = YY_READ_BUF_SIZE;
		}
		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			YY_G(yy_n_chars), num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
	}

	if ( YY_G(yy_n_chars) == 0 ) {
		if ( number_to_move == YY_MORE_ADJ ) {
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  M4_YY_CALL_LAST_ARG);
		} else {
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
		}
	} else {
		ret_val = EOB_ACT_CONTINUE_SCAN;
	}
	if ((YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size M4_YY_CALL_LAST_ARG );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) {
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		}
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	YY_G(yy_n_chars) += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

	YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}
]])

/* yy_get_previous_state - get the state just before the EOB char was reached */

m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl
m4_ifdef([[M4_MODE_C_ONLY]], [[
static yy_state_type yy_get_previous_state (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
yy_state_type yyFlexLexer::yy_get_previous_state()
]])
{
	yy_state_type yy_current_state;
	char *yy_cp;
	M4_YY_DECL_GUTS_VAR();

	M4_GEN_START_STATE
	for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp ) {
		/* Generate the code to find the next state. */
		m4_ifdef([[M4_MODE_NO_NULTRANS]], [[m4_define([[CHAR_MAP_3]], [[(*yy_cp ? M4_EC(YY_SC_TO_UI(*yy_cp)) : YY_NUL_EC)]])]])
		m4_ifdef([[M4_MODE_NULTRANS]], [[m4_define([[CHAR_MAP_3]], [[M4_EC(YY_SC_TO_UI(*yy_cp))]])]])

		m4_ifdef([[M4_MODE_NULTRANS]], [[
			/* Compressed tables back up *before* they match. */
			m4_ifdef([[M4_MODE_NO_FULLSPD_OR_FULLTBL]], [[M4_GEN_BACKING_UP]])
			if ( *yy_cp ) {
		]])

		m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[
			m4_ifdef([[M4_MODE_GENTABLES]], [[yy_current_state = yy_nxt[yy_current_state][CHAR_MAP_3];]])
			m4_ifdef([[M4_MODE_NO_GENTABLES]], [[yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + CHAR_MAP_3];]])
		]])

		m4_ifdef([[M4_MODE_FULLSPD]], [[yy_current_state += yy_current_state[CHAR_MAP_3].yy_nxt;]])
		m4_ifdef([[M4_MODE_NO_FULLSPD_OR_FULLTBL]], [[M4_GEN_NEXT_COMPRESSED_STATE(CHAR_MAP_3)]])

m4_ifdef([[M4_MODE_NULTRANS]], [[
		} else {
			yy_current_state = yy_NUL_trans[yy_current_state];
		}
]])

		m4_ifdef([[M4_MODE_FIND_ACTION_FULLTBL]], [[M4_GEN_BACKING_UP]])
		m4_ifdef([[M4_MODE_FULLSPD]], [[M4_GEN_BACKING_UP]])
		m4_ifdef([[M4_MODE_USES_REJECT]], [[*YY_G(yy_state_ptr)++ = yy_current_state;]])
	}

	return yy_current_state;
}


/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
static yy_state_type yy_try_NUL_trans  YYFARGS1( yy_state_type, yy_current_state)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
]])
{
	int yy_is_jam;
	M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */
	/* Generate code for handling NUL's, if needed. */

	/* First, deal with backing up and setting up yy_cp if the scanner
	 * finds that it should JAM on the NUL.
	 *
	 * Only generate a definition for "yy_cp" if we'll generate code
	 * that uses it.  Otherwise lint and the like complain.
	 */
	m4_ifdef([[M4_MODE_NEED_YY_CP]], [[char *yy_cp = YY_G(yy_c_buf_p);]])

%# Note that this statement block and the following three are
%# not executed serially but are an if-then-else cascade
%# for different table modes.
m4_ifdef([[M4_MODE_NULTRANS]], [[
	yy_current_state = yy_NUL_trans[yy_current_state];
       	yy_is_jam = (yy_current_state == 0);
]])

m4_ifdef([[M4_MODE_NO_NULTRANS]], [[
m4_ifdef([[M4_MODE_NULTRANS_FULLTBL]], [[
m4_ifdef([[M4_MODE_GENTABLES]], [[yy_current_state = yy_nxt[yy_current_state][YY_NUL_EC];]])
m4_ifdef([[M4_MODE_NO_GENTABLES]], [[yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + YY_NUL_EC];]])
	yy_is_jam = (yy_current_state <= 0);
]])

m4_ifdef([[M4_MODE_NO_NULTRANS_FULLTBL]], [[
m4_ifdef([[M4_MODE_NULTRANS_FULLSPD]], [[
	int yy_c = YY_NUL_EC;

	const struct yy_trans_info *yy_trans_info;

	yy_trans_info = &yy_current_state[(unsigned int) yy_c];
	yy_current_state += yy_trans_info->yy_nxt;
	yy_is_jam = (yy_trans_info->yy_verify != yy_c);
]])

m4_ifdef([[M4_MODE_NO_NULTRANS_FULLSPD]], [[
M4_GEN_NEXT_COMPRESSED_STATE(YY_NUL_EC)
yy_is_jam = (yy_current_state == YY_JAMSTATE);
m4_ifdef([[M4_MODE_USES_REJECT]], [[
	/* Only stack this state if it's a transition we
	 * actually make.  If we stack it on a jam, then
	 * the state stack and yy_c_buf_p get out of sync.
	 */
	if ( ! yy_is_jam ) {
		*YY_G(yy_state_ptr)++ = yy_current_state;
	}
	]])
]])
]])
]])
%# End of if-else cascade

m4_ifdef([[M4_MODE_NULTRANS_WRAP]], [[
	/* If we've entered an accepting state, back up; note that
	 * compressed tables have *already* done such backing up, so
	 * we needn't bother with it again.
	 */
	if ( ! yy_is_jam ) {
		M4_GEN_BACKING_UP
	}
]])

	M4_YY_NOOP_GUTS_VAR();
	return yy_is_jam ? 0 : yy_current_state;
}

m4_ifdef([[M4_MODE_CXX_ONLY]], [[m4_undefine([[M4_YY_NO_YYUNPUT]])]])
m4_ifdef( [[M4_YY_NO_YYUNPUT]], , [[
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yyunput_r YYFARGS2( int,c, char *,yy_bp)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yyunput_r( int c, char* yy_bp)
]])
{
	char *yy_cp;
	M4_YY_DECL_GUTS_VAR();

	yy_cp = YY_G(yy_c_buf_p);

	/* undo effects of setting up yytext */
	*yy_cp = YY_G(yy_hold_char);

	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) {
		/* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = YY_G(yy_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) {
			*--dest = *--source;
		}
		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
			YY_G(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) {
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}
	}

	*--yy_cp = (char) c;

m4_ifdef( [[M4_MODE_YYLINENO]],
[[
	if ( c == '\n' ){
	--yylineno;
	}
]])

	YY_G(yytext_ptr) = yy_bp;
	YY_G(yy_hold_char) = *yy_cp;
	YY_G(yy_c_buf_p) = yy_cp;
}
]])

m4_ifdef([[M4_MODE_C_ONLY]], [[
#ifndef YY_NO_YYINPUT
int yyinput (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
int yyFlexLexer::yyinput()
]])
{
	int c;
	M4_YY_DECL_GUTS_VAR();

	*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);

	if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) {
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] ) {
			/* This was really a NUL. */
			*YY_G(yy_c_buf_p) = '\0';
		} else {
			/* need more input */
			int offset = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr));
			++YY_G(yy_c_buf_p);

			switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) {
			case EOB_ACT_LAST_MATCH:
				/* This happens because yy_g_n_b()
				 * sees that we've accumulated a
				 * token and flags that we need to
				 * try matching the token before
				 * proceeding.  But for input(),
				 * there's no matching to consider.
				 * So convert the EOB_ACT_LAST_MATCH
				 * to EOB_ACT_END_OF_FILE.
				 */

				/* Reset buffer status. */
				yyrestart( yyin M4_YY_CALL_LAST_ARG);

				/*FALLTHROUGH*/

			case EOB_ACT_END_OF_FILE:
				if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) {
					return 0;
				}
				if ( ! YY_G(yy_did_buffer_switch_on_eof) ) {
					YY_NEW_FILE;
				}
				return yyinput(M4_YY_CALL_ONLY_ARG);

			case EOB_ACT_CONTINUE_SCAN:
				YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
				break;
			}
		}
	}

	c = *(unsigned char *) YY_G(yy_c_buf_p);	/* cast for 8-bit char's */
	*YY_G(yy_c_buf_p) = '\0';	/* preserve yytext */
	YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);

m4_ifdef([[M4_MODE_BOL_NEEDED]], [[
	YY_CURRENT_BUFFER_LVALUE->yyatbol = (c == '\n');
m4_ifdef([[M4_MODE_YYLINENO]], [[
	if ( YY_CURRENT_BUFFER_LVALUE->yyatbol ) {
		M4_YY_INCR_LINENO();
	}
]])
]])
m4_ifdef([[M4_MODE_NO_BOL_NEEDED]], [[
m4_ifdef([[M4_MODE_YYLINENO]], [[
	if ( c == '\n' ) {
		M4_YY_INCR_LINENO();
	}
	]])
]])

	return c;
}
m4_ifdef([[M4_MODE_C_ONLY]], [[
#endif	/* ifndef YY_NO_YYINPUT */
]])

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * M4_YY_DOC_PARAM
 * @note This function does not reset the start condition to @c INITIAL .
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yyrestart  YYFARGS1( FILE *,input_file)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yyrestart( std::istream& input_file )
]])
{
	M4_YY_DECL_GUTS_VAR();

	if ( yy_current_buffer() == NULL ) {
		yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
		YY_CURRENT_BUFFER_LVALUE =
	        	yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
	}

	yy_init_buffer( YY_CURRENT_BUFFER_LVALUE, input_file M4_YY_CALL_LAST_ARG);
	yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
}

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
/** Delegate to the new version that takes an istream reference.
 * @param input_file A readable stream.
 * M4_YY_DOC_PARAM
 * @note This function does not reset the start condition to @c INITIAL .
 */
void yyFlexLexer::yyrestart( std::istream* input_file )
{
	if( ! input_file ) {
		input_file = &yyin;
	}
	yyrestart( *input_file );
}
]])

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * M4_YY_DOC_PARAM
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yy_switch_to_buffer  YYFARGS1( yybuffer ,new_buffer)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_switch_to_buffer( yybuffer new_buffer )
]])
{
	M4_YY_DECL_GUTS_VAR();

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
	 */
	yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
	if ( yy_current_buffer() == new_buffer ) {
		return;
	}
	if ( yy_current_buffer() ) {
		/* Flush out information for old buffer. */
		*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
	}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	YY_G(yy_did_buffer_switch_on_eof) = 1;
}


m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yy_load_buffer_state  (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_load_buffer_state()
]])
{
	M4_YY_DECL_GUTS_VAR();
	YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
m4_ifdef([[M4_MODE_C_ONLY]], [[
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
	yyin.rdbuf(YY_CURRENT_BUFFER_LVALUE->yy_input_file);
]])
	YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * M4_YY_DOC_PARAM
 * @return the allocated buffer state.
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
yybuffer yy_create_buffer  YYFARGS2( FILE *,file, int ,size)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
yybuffer yyFlexLexer::yy_create_buffer( std::istream& file, int size )
]])
{
	yybuffer b;
	M4_YY_DECL_GUTS_VAR();

	b = (yybuffer) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
	if (  b == NULL ) {
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
	}
	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) M4_YY_CALL_LAST_ARG );
	if ( b->yy_ch_buf == NULL ) {
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
	}
	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file M4_YY_CALL_LAST_ARG);

	return b;
}

m4_ifdef([[M4_MODE_CXX_ONLY]], [[
/** Delegate creation of buffers to the new version that takes an istream reference.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * M4_YY_DOC_PARAM
 * @return the allocated buffer state.
 */
yybuffer yyFlexLexer::yy_create_buffer( std::istream* file, int size )
{
	return yy_create_buffer( *file, size );
}
]])

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * M4_YY_DOC_PARAM
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yy_delete_buffer YYFARGS1( yybuffer ,b)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_delete_buffer( yybuffer b )
]])
{
	M4_YY_DECL_GUTS_VAR();

	if ( b == NULL ) {
		return;
	}
	if ( b == yy_current_buffer() ) {	/* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (yybuffer) 0;
	}
	if ( b->yy_is_our_buffer ) {
		yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG );
	}
	yyfree( (void *) b M4_YY_CALL_LAST_ARG );
}


/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yy_init_buffer  YYFARGS2( yybuffer ,b, FILE *,file)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_init_buffer( yybuffer b, std::istream& file )
]])
{
	int oerrno = errno;
	M4_YY_DECL_GUTS_VAR();

	yy_flush_buffer( b M4_YY_CALL_LAST_ARG);

m4_ifdef([[M4_MODE_C_ONLY]], [[
	b->yy_input_file = file;
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
	b->yy_input_file = file.rdbuf();
]])
	b->yy_fill_buffer = 1;

	/* If b is the current buffer, then yy_init_buffer was _probably_
	 * called from yyrestart() or through yy_get_next_buffer.
	 * In that case, we don't want to reset the lineno or column.
	 */
	if (b != yy_current_buffer()) {
		b->yy_bs_lineno = 1;
		b->yy_bs_column = 0;
	}

m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]],
[[
	b->yy_is_interactive = 1;
]],
[[
    m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],
    [[
        b->yy_is_interactive = 0;
    ]],
    [[
        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    ]])
]])
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
	b->yy_is_interactive = 0;
]])
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c yy_current_buffer().
 * M4_YY_DOC_PARAM
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yy_flush_buffer YYFARGS1( yybuffer ,b)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_flush_buffer( yybuffer b )
]])
{
	M4_YY_DECL_GUTS_VAR();
	if ( b == NULL ) {
		return;
	}
	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yyatbol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == yy_current_buffer() ) {
		yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
	}
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  M4_YY_DOC_PARAM
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yypush_buffer_state YYFARGS1(yybuffer,new_buffer)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yypush_buffer_state (yybuffer new_buffer)
]])
{
	M4_YY_DECL_GUTS_VAR();
	if (new_buffer == NULL) {
		return;
	}
	yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG);

	/* This block is copied from yy_switch_to_buffer. */
	if ( yy_current_buffer() != NULL ) {
		/* Flush out information for old buffer. */
		*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
	}

	/* Only push if top exists. Otherwise, replace top. */
	if (yy_current_buffer()) {
		YY_G(yy_buffer_stack_top)++;
	}
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
	YY_G(yy_did_buffer_switch_on_eof) = 1;
}


/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  M4_YY_DOC_PARAM
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
void yypop_buffer_state (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yypop_buffer_state (void)
]])
{
	M4_YY_DECL_GUTS_VAR();
	if (yy_current_buffer() == NULL) {
		return;
	}
	yy_delete_buffer(yy_current_buffer() M4_YY_CALL_LAST_ARG);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (YY_G(yy_buffer_stack_top) > 0) {
		--YY_G(yy_buffer_stack_top);
	}
	if (yy_current_buffer() != NULL) {
		yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
		YY_G(yy_did_buffer_switch_on_eof) = 1;
	}
}


/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yyensure_buffer_stack (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yyensure_buffer_stack(void)
]])
{
	yy_size_t num_to_alloc;
	M4_YY_DECL_GUTS_VAR();

	if (YY_G(yy_buffer_stack) == NULL) {
		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
		 */
		num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								M4_YY_CALL_LAST_ARG);
		if ( YY_G(yy_buffer_stack == NULL) ) {
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
		}

		memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		YY_G(yy_buffer_stack_max) = num_to_alloc;
		YY_G(yy_buffer_stack_top) = 0;
		return;
	}

	if (YY_G(yy_buffer_stack_top) >= (YY_G(yy_buffer_stack_max)) - 1) {
		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = YY_G(yy_buffer_stack_max) + grow_size;
		YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								(YY_G(yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								M4_YY_CALL_LAST_ARG);
		if (YY_G(yy_buffer_stack) == NULL) {
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
		}
		/* zero only the new slots.*/
		memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		YY_G(yy_buffer_stack_max) = num_to_alloc;
	}
}




m4_ifdef( [[M4_YY_NO_SCAN_BUFFER]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * M4_YY_DOC_PARAM
 * @return the newly allocated buffer state object.
 */
yybuffer yy_scan_buffer  YYFARGS2( char *,base, yy_size_t ,size)
{
	yybuffer b;
	m4_dnl M4_YY_DECL_GUTS_VAR();

	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR ) {
		/* They forgot to leave room for the EOB's. */
		return NULL;
	}
	b = (yybuffer) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
	if ( b == NULL ) {
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
	}
	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yyatbol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG );

	return b;
}
]])
]])


m4_ifdef( [[M4_YY_NO_SCAN_STRING]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * M4_YY_DOC_PARAM
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
yybuffer yy_scan_string YYFARGS1( const char *, yystr)
{
	m4_dnl M4_YY_DECL_GUTS_VAR();

	return yy_scan_bytes( yystr, (int) strlen(yystr) M4_YY_CALL_LAST_ARG);
}
]])
]])


m4_ifdef( [[M4_YY_NO_SCAN_BYTES]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * M4_YY_DOC_PARAM
 * @return the newly allocated buffer state object.
 */
yybuffer yy_scan_bytes  YYFARGS2( const char *,yybytes, int ,_yybytes_len) {
	yybuffer b;
	char *buf;
	yy_size_t n;
	int i;
	m4_dnl M4_YY_DECL_GUTS_VAR();

	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG );
	if ( buf == 0 ) {
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
	}
	for ( i = 0; i < _yybytes_len; ++i ) {
		buf[i] = yybytes[i];
	}
	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG);
	if ( b == NULL ) {
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
	}
	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}
]])
]])


m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yy_push_state YYFARGS1( int ,_new_state)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_push_state( int _new_state )
]])
{
	M4_YY_DECL_GUTS_VAR();
	if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) ) {
		yy_size_t new_size;

		YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
		new_size = (yy_size_t) YY_G(yy_start_stack_depth) * sizeof( int );

		if ( ! YY_G(yy_start_stack) ) {
			YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG );

		} else {
			YY_G(yy_start_stack) = (int *) yyrealloc(
					(void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG );
		}
		if ( ! YY_G(yy_start_stack) ) {
			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
		}
	}
	YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = yystart();

	yybegin(_new_state);
}
]])


m4_ifdef( [[M4_YY_NO_POP_STATE]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
static void yy_pop_state  (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
void yyFlexLexer::yy_pop_state()
]])
{
	M4_YY_DECL_GUTS_VAR();
	if ( --YY_G(yy_start_stack_ptr) < 0 ) {
		YY_FATAL_ERROR( "start-condition stack underflow" );
	}
	yybegin(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
}
]])


m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
[[
m4_ifdef([[M4_MODE_C_ONLY]], [[
static int yy_top_state  (M4_YY_DEF_ONLY_ARG)
]])
m4_ifdef([[M4_MODE_CXX_ONLY]], [[
int yyFlexLexer::yy_top_state()
]])
{
	M4_YY_DECL_GUTS_VAR();
	return YY_G(yy_start_stack_ptr) > 0 ? YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1] : yystart();
}
]])

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do { \
		/* Undo effects of setting up yytext. */ \
		int yyless_macro_arg = (n); \
		YY_LESS_LINENO(yyless_macro_arg);\
			yytext[yyleng] = YY_G(yy_hold_char); \
			YY_G(yy_c_buf_p) = yytext + yyless_macro_arg; \
			YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
			*YY_G(yy_c_buf_p) = '\0'; \
			yyleng = yyless_macro_arg; \
	} while ( 0 )



/* Accessor  methods (get/set functions) to struct members. */

m4_ifdef([[M4_MODE_C_ONLY]], [[
m4_ifdef([[M4_YY_REENTRANT]], [[
m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
[[
/** Get the user-defined data for this scanner.
 * M4_YY_DOC_PARAM
 */
YY_EXTRA_TYPE yyget_extra  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yyextra;
}
]])
]])

m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
[[
/** Get the current line number.
 * M4_YY_DOC_PARAM
 */
int yyget_lineno  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();

	m4_ifdef( [[M4_YY_REENTRANT]],
	[[
		if (yy_current_buffer() == NULL) {
			return 0;
		}
	]])
	return yylineno;
}
]])

m4_ifdef( [[M4_YY_REENTRANT]],
[[
m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
[[
/** Get the current column number.
 * M4_YY_DOC_PARAM
 */
int yyget_column  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();

m4_ifdef( [[M4_YY_REENTRANT]], [[
	if (yy_current_buffer() == NULL) {
		return 0;
	}
]])
	return yycolumn;
}
]])
]])

m4_ifdef( [[M4_YY_NO_GET_IN]],,
[[
/** Get the input stream.
 * M4_YY_DOC_PARAM
 */
FILE *yyget_in  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yyin;
}
]])

m4_ifdef( [[M4_YY_NO_GET_OUT]],,
[[
/** Get the output stream.
 * M4_YY_DOC_PARAM
 */
FILE *yyget_out  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yyout;
}
]])

m4_ifdef( [[M4_YY_NO_GET_LENG]],,
[[
/** Get the length of the current token.
 * M4_YY_DOC_PARAM
 */
int yyget_leng  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yyleng;
}
]])

/** Get the current token.
 * M4_YY_DOC_PARAM
 */
m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
[[
char *yyget_text  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yytext;
}
]])

m4_ifdef([[M4_YY_REENTRANT]], [[
m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
[[
/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * M4_YY_DOC_PARAM
 */
void yyset_extra YYFARGS1( YY_EXTRA_TYPE ,user_defined) {
	M4_YY_DECL_GUTS_VAR();
	yyextra = user_defined ;
}
]])
]])

m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
[[
/** Set the current line number.
 * @param _line_number line number
 * M4_YY_DOC_PARAM
 */
void yyset_lineno YYFARGS1( int ,_line_number) {
	M4_YY_DECL_GUTS_VAR();

	m4_ifdef( [[M4_YY_REENTRANT]],
	[[
	    /* lineno is only valid if an input buffer exists. */
		if (yy_current_buffer() == NULL ) {
			YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
		}
	]])
	yylineno = _line_number;
}
]])

m4_ifdef( [[M4_YY_REENTRANT]],
[[
m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
[[
/** Set the current column.
 * @param _column_no column number
 * M4_YY_DOC_PARAM
 */
void yyset_column YYFARGS1( int , _column_no) {
	M4_YY_DECL_GUTS_VAR();

m4_ifdef( [[M4_YY_REENTRANT]], [[
	/* column is only valid if an input buffer exists. */
	if (yy_current_buffer() == NULL ) {
	       YY_FATAL_ERROR( "yyset_column called with no buffer" );
	}
]])
	yycolumn = _column_no;
}
]])
]])


m4_ifdef( [[M4_YY_NO_SET_IN]],,
[[
/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * M4_YY_DOC_PARAM
 * @see yy_switch_to_buffer
 */
void yyset_in YYFARGS1( FILE * ,_in_str) {
	M4_YY_DECL_GUTS_VAR();
	yyin = _in_str ;
}
]])

m4_ifdef( [[M4_YY_NO_SET_OUT]],,
[[
void yyset_out YYFARGS1( FILE * ,_out_str) {
	M4_YY_DECL_GUTS_VAR();
	yyout = _out_str ;
}
]])


m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
[[
int yyget_debug  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yyflexdebug;
}
]])

m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
[[
void yyset_debug YYFARGS1( int ,_bdebug) {
	M4_YY_DECL_GUTS_VAR();
	yyflexdebug = _bdebug ;
}
]])
]])

m4_ifdef([[M4_YY_REENTRANT]], [[
/* Accessor methods for yylval and yylloc */

m4_ifdef([[M4_YY_BISON_LVAL]], [[
m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
[[
YYSTYPE * yyget_lval  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yylval;
}
]])

m4_ifdef( [[M4_YY_NO_SET_LVAL]],,
[[
void yyset_lval YYFARGS1( YYSTYPE * ,yylval_param) {
	M4_YY_DECL_GUTS_VAR();
	yylval = yylval_param;
}
]])

m4_ifdef( [[<M4_YY_BISON_LLOC>]],
[[
m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
[[
YYLTYPE *yyget_lloc  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	return yylloc;
}
]])

m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
[[
void yyset_lloc YYFARGS1( YYLTYPE * ,yylloc_param) {
	M4_YY_DECL_GUTS_VAR();
	yylloc = yylloc_param;
}
]])
]])

]])


/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals) {
	if (ptr_yy_globals == NULL) {
		errno = EINVAL;
		return 1;
	}

	*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

	if (*ptr_yy_globals == NULL) {
		errno = ENOMEM;
		return 1;
	}

	/* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
	memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

	return yy_init_globals ( *ptr_yy_globals );
}


/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) {
	struct yyguts_t dummy_yyguts;

	yyset_extra (yy_user_defined, &dummy_yyguts);

	if (ptr_yy_globals == NULL) {
		errno = EINVAL;
		return 1;
	}

	*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

	if (*ptr_yy_globals == NULL) {
		errno = ENOMEM;
		return 1;
	}

	/* By setting to 0xAA, we expose bugs in
	   yy_init_globals. Leave at 0x00 for releases. */
	memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

	yyset_extra (yy_user_defined, *ptr_yy_globals);

	return yy_init_globals ( *ptr_yy_globals );
}

]])
%# Actually, that ended an if-rentrant section

m4_ifdef([[M4_MODE_C_ONLY]], [[
static int yy_init_globals (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();
	/* Initialization is the same as for the non-reentrant scanner.
	 * This function is called from yylex_destroy(), so don't allocate here.
	 */

m4_ifdef( [[M4_MODE_YYLINENO]],
[[
    m4_ifdef( [[M4_YY_NOT_REENTRANT]],
    [[
	/* We do not touch yylineno unless the option is enabled. */
	yylineno =  1;
    ]])
]])
	YY_G(yy_buffer_stack) = NULL;
	YY_G(yy_buffer_stack_top) = 0;
	YY_G(yy_buffer_stack_max) = 0;
	YY_G(yy_c_buf_p) = NULL;
	YY_G(yy_init) = 0;
	YY_G(yy_start) = 0;

m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
[[
	YY_G(yy_start_stack_ptr) = 0;
	YY_G(yy_start_stack_depth) = 0;
	YY_G(yy_start_stack) =  NULL;
]])

m4_ifdef( [[M4_MODE_USES_REJECT]],
[[
	YY_G(yy_state_buf) = 0;
	YY_G(yy_state_ptr) = 0;
	YY_G(yy_full_match) = 0;
	YY_G(yy_lp) = 0;
]])

m4_ifdef( [[M4_MODE_REENTRANT_TEXT_IS_ARRAY]],
[[
	YY_G(yytext_ptr) = 0;
	YY_G(yy_more_offset) = 0;
	YY_G(yy_prev_more_offset) = 0;
]])

/* Defined in main.c */
#ifdef YY_STDINIT
	yyin = stdin;
	yyout = stdout;
#else
	yyin = NULL;
	yyout = NULL;
#endif

	/* For future reference: Set errno on error, since we are called by
	 * yylex_init()
	 */
	return 0;
}
]])


m4_ifdef([[M4_MODE_C_ONLY]], [[
%# SNIP! this currently causes conflicts with the c++ scanner
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (M4_YY_DEF_ONLY_ARG) {
	M4_YY_DECL_GUTS_VAR();

	/* Pop the buffer stack, destroying each element. */
	while(yy_current_buffer()) {
		yy_delete_buffer( yy_current_buffer() M4_YY_CALL_LAST_ARG );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(M4_YY_CALL_ONLY_ARG);
	}

	/* Destroy the stack itself. */
	yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG);
	YY_G(yy_buffer_stack) = NULL;

m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
[[
	/* Destroy the start condition stack. */
        yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG );
        YY_G(yy_start_stack) = NULL;
]])

m4_ifdef( [[M4_MODE_USES_REJECT]],
[[
	yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG);
	YY_G(yy_state_buf)  = NULL;
]])

	/* Reset the globals. This is important in a non-reentrant scanner so the next time
	 * yylex() is called, initialization will occur. */
	yy_init_globals( M4_YY_CALL_ONLY_ARG);

m4_ifdef([[M4_YY_REENTRANT]], [[
	/* Destroy the main struct (reentrant only). */
	yyfree ( yyscanner M4_YY_CALL_LAST_ARG );
	yyscanner = NULL;
]])
	return 0;
}
]])


m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
/*
 * Internal utility routines.
 */
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#ifndef yytext_ptr
static void yy_flex_strncpy YYFARGS3( char*,s1, const char *,s2, int,n) {
	M4_YY_DECL_GUTS_VAR();
	M4_YY_NOOP_GUTS_VAR();

	int i;
	for ( i = 0; i < n; ++i ) {
		s1[i] = s2[i];
	}
}
#endif
]])

m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
[[
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen YYFARGS1( const char *,s)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif
]])

m4_ifdef( [[M4_YY_NO_FLEX_ALLOC]],,
[[
void *yyalloc YYFARGS1( yy_size_t ,size) {
	M4_YY_DECL_GUTS_VAR();
	M4_YY_NOOP_GUTS_VAR();
	return malloc(size);
}
]])

m4_ifdef( [[M4_YY_NO_FLEX_REALLOC]],,
[[
void *yyrealloc  YYFARGS2( void *,ptr, yy_size_t ,size) {
	M4_YY_DECL_GUTS_VAR();
	M4_YY_NOOP_GUTS_VAR();

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}
]])

m4_ifdef( [[M4_YY_NO_FLEX_FREE]],,
[[
void yyfree YYFARGS1( void *,ptr) {
	M4_YY_DECL_GUTS_VAR();
	M4_YY_NOOP_GUTS_VAR();
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}
]])

m4_ifdef([[M4_MODE_TABLESEXT]], [[
%# definitions
m4preproc_include(`tables_shared.c')

static int yytbl_read8 (void *v, struct yytbl_reader * rd) {
	errno = 0;
	if (fread (v, sizeof (flex_uint8_t), 1, rd->fp) != 1) {
	    errno = EIO;
	    return -1;
	}
	rd->bread += (flex_uint32_t) sizeof(flex_uint8_t);
	return 0;
}

static int yytbl_read16 (void *v, struct yytbl_reader * rd) {
	errno = 0;
	if (fread (v, sizeof (flex_uint16_t), 1, rd->fp) != 1) {
	    errno = EIO;
	    return -1;
	}
	*((flex_uint16_t *) v) = ntohs (*((flex_uint16_t *) v));
	rd->bread += (flex_uint32_t) sizeof(flex_uint16_t);
	return 0;
}

static int yytbl_read32 (void *v, struct yytbl_reader * rd) {
	errno = 0;
	if (fread (v, sizeof (flex_uint32_t), 1, rd->fp) != 1) {
	    errno = EIO;
	    return -1;
	}
	*((flex_uint32_t *) v) = ntohl (*((flex_uint32_t *) v));
	rd->bread += (flex_uint32_t) sizeof(flex_uint32_t);
	return 0;
}

/** Read the header */
static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader *, rd) {
	size_t  bytes;
	memset (th, 0, sizeof (struct yytbl_hdr));

	if (yytbl_read32 (&(th->th_magic), rd) != 0) {
		return -1;
	}
	if (th->th_magic != YYTBL_MAGIC) {
		YY_FATAL_ERROR( "bad magic number" );   /* TODO: not fatal. */
		return -1;
	}

	if (yytbl_read32 (&(th->th_hsize), rd) != 0
	    || yytbl_read32 (&(th->th_ssize), rd) != 0
	    || yytbl_read16 (&(th->th_flags), rd) != 0) {
		return -1;
	}
	/* Sanity check on header size. Greater than 1k suggests some funny business. */
	if (th->th_hsize < 16 || th->th_hsize > 1024) {
		YY_FATAL_ERROR( "insane header size detected" );   /* TODO: not fatal. */
		return -1;
	}

	/* Allocate enough space for the version and name fields */
	bytes = th->th_hsize - 14;
	th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
	if ( ! th->th_version ) {
		YY_FATAL_ERROR( "out of dynamic memory in yytbl_hdr_read()" );
	}
	/* we read it all into th_version, and point th_name into that data */
	if (fread (th->th_version, 1, bytes, rd->fp) != bytes) {
		errno = EIO;
		yyfree(th->th_version M4_YY_CALL_LAST_ARG);
		th->th_version = NULL;
		return -1;
	} else {
		rd->bread += (flex_uint32_t) bytes;
	}
	th->th_name = th->th_version + strlen (th->th_version) + 1;
	return 0;
}

/** lookup id in the dmap list.
 *  @param dmap pointer to first element in list
 *  @return NULL if not found.
 */
static struct yytbl_dmap *yytbl_dmap_lookup YYFARGS2(struct yytbl_dmap *, dmap, int, id) {
     M4_YY_DECL_GUTS_VAR();
     M4_YY_NOOP_GUTS_VAR();

     while (dmap->dm_id) {
	  if ((int)(dmap->dm_id) == id) {
	       return dmap;
	  } else {
	       dmap++;
	  }
     }
     return NULL;
}

/** Read a table while mapping its contents to the local array.
 *  @param dmap used to performing mapping
 *  @return 0 on success
 */
static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_reader*, rd) {
	struct yytbl_data td;
	struct yytbl_dmap *transdmap=0;
	int     len, i, rv, inner_loop_count;
	void   *p=0;

	memset (&td, 0, sizeof (struct yytbl_data));

	if (yytbl_read16 (&td.td_id, rd) != 0
	    || yytbl_read16 (&td.td_flags, rd) != 0
	    || yytbl_read32 (&td.td_hilen, rd) != 0
	    || yytbl_read32 (&td.td_lolen, rd) != 0) {
		return -1;
	}
	/* Lookup the map for the transition table so we have it in case we need it
	 * inside the loop below. This scanner might not even have a transition
	 * table, which is ok.
	 */
	transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG);

	if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL) {
		YY_FATAL_ERROR( "table id not found in map." );   /* TODO: not fatal. */
		return -1;
	}

	/* Allocate space for table.
	 * The --full yy_transition table is a special case, since we
	 * need the dmap.dm_sz entry to tell us the sizeof the individual
	 * struct members.
	 */
	{
		size_t  bytes;

		if ((td.td_flags & YYTD_STRUCT)) {
			bytes = sizeof(struct yy_trans_info) * td.td_lolen * (td.td_hilen ? td.td_hilen : 1);
		} else {
			bytes = td.td_lolen * (td.td_hilen ? td.td_hilen : 1) * dmap->dm_sz;
		}
		if (M4_YY_TABLES_VERIFY) {
			/* We point to the array itself */
			p = dmap->dm_arr;
		} else {
			/* We point to the address of a pointer. */
			*dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
		}
		if ( ! p ) {
			YY_FATAL_ERROR( "out of dynamic memory in yytbl_data_load()" );
		}
	}

	/* If it's a struct, we read 2 integers to get one element */
	if ((td.td_flags & YYTD_STRUCT) != 0) {
		inner_loop_count = 2;
	} else {
		inner_loop_count = 1;
	}
	/* read and map each element.
	 * This loop iterates once for each element of the td_data array.
	 * Notice that we increment 'i' in the inner loop.
	 */
	len = yytbl_calc_total_len (&td);
	for (i = 0; i < len; ) {
		int    j;

		/* This loop really executes exactly 1 or 2 times.
		 * The second time is to handle the second member of the
		 * YYTD_STRUCT for the yy_transition array.
		 */
		for (j = 0; j < inner_loop_count; j++, i++) {
			flex_int32_t t32;

			/* read into t32 no matter what the real size is. */
			{
				flex_int16_t t16;
				flex_int8_t  t8;

				switch (YYTDFLAGS2BYTES (td.td_flags)) {
				case sizeof (flex_int32_t):
					rv = yytbl_read32 (&t32, rd);
					break;
				case sizeof (flex_int16_t):
					rv = yytbl_read16 (&t16, rd);
					t32 = t16;
					break;
				case sizeof (flex_int8_t):
					rv = yytbl_read8 (&t8, rd);
					t32 = t8;
					break;
				default:
					YY_FATAL_ERROR( "invalid td_flags" );   /* TODO: not fatal. */
					return -1;
				}
			}
			if (rv != 0) {
				return -1;
			}
			/* copy into the deserialized array... */

			if ((td.td_flags & YYTD_STRUCT)) {
				/* t32 is the j'th member of a two-element struct. */
				void   *v;

				v = j == 0 ? &(((struct yy_trans_info *) p)->yy_verify)
					: &(((struct yy_trans_info *) p)->yy_nxt);

				switch (dmap->dm_sz) {
				case sizeof (flex_int32_t):
					if (M4_YY_TABLES_VERIFY) {
						if( ((flex_int32_t *) v)[0] != (flex_int32_t) t32)
							YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int32_t" );
					} else {
						((flex_int32_t *) v)[0] = (flex_int32_t) t32;
					}
					break;
				case sizeof (flex_int16_t):
					if (M4_YY_TABLES_VERIFY ) {
						if(((flex_int16_t *) v)[0] != (flex_int16_t) t32)
							YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int16_t" );
					} else {
						((flex_int16_t *) v)[0] = (flex_int16_t) t32;
					}
					break;
				case sizeof(flex_int8_t):
					if (M4_YY_TABLES_VERIFY ) {
						if( ((flex_int8_t *) v)[0] != (flex_int8_t) t32)
							YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int8_t" );
					} else {
						((flex_int8_t *) v)[0] = (flex_int8_t) t32;
					}
					break;
				default:
					YY_FATAL_ERROR( "invalid dmap->dm_sz for struct" );   /* TODO: not fatal. */
					return -1;
				}

				/* if we're done with j, increment p */
				if (j == 1) {
					p = (struct yy_trans_info *) p + 1;
				}
			}
			else if ((td.td_flags & YYTD_PTRANS)) {
				/* t32 is an index into the transition array. */
				struct yy_trans_info *v;

				if (!transdmap) {
					YY_FATAL_ERROR( "transition table not found" );   /* TODO: not fatal. */
					return -1;
				}

				if( M4_YY_TABLES_VERIFY) {
					v = &(((struct yy_trans_info *) (transdmap->dm_arr))[t32]);
				} else {
					v = &((*((struct yy_trans_info **) (transdmap->dm_arr)))[t32]);
				}
				if(M4_YY_TABLES_VERIFY ) {
					if( ((struct yy_trans_info **) p)[0] != v)
						YY_FATAL_ERROR( "tables verification failed at YYTD_PTRANS" );
				} else {
					((struct yy_trans_info **) p)[0] = v;
				}
				/* increment p */
				p = (struct yy_trans_info **) p + 1;
			}
			else {
				/* t32 is a plain int. copy data, then incrememnt p. */
				switch (dmap->dm_sz) {
				case sizeof (flex_int32_t):
					if(M4_YY_TABLES_VERIFY ) {
						if( ((flex_int32_t *) p)[0] != (flex_int32_t) t32) {
							YY_FATAL_ERROR( "tables verification failed at flex_int32_t" );
						}
					} else {
						((flex_int32_t *) p)[0] = (flex_int32_t) t32;
					}
					p = ((flex_int32_t *) p) + 1;
					break;
				case sizeof (flex_int16_t):
					if(M4_YY_TABLES_VERIFY ) {
						if( ((flex_int16_t *) p)[0] != (flex_int16_t) t32) {
							YY_FATAL_ERROR( "tables verification failed at flex_int16_t" );
						}
					} else {
						((flex_int16_t *) p)[0] = (flex_int16_t) t32;
					}
					p = ((flex_int16_t *) p) + 1;
					break;
				case sizeof (flex_int8_t):
					if(M4_YY_TABLES_VERIFY ){
						if( ((flex_int8_t *) p)[0] != (flex_int8_t) t32) {
							YY_FATAL_ERROR( "tables verification failed at flex_int8_t" );
						}
					} else {
						((flex_int8_t *) p)[0] = (flex_int8_t) t32;
					}
					p = ((flex_int8_t *) p) + 1;
					break;
				default:
					YY_FATAL_ERROR( "invalid dmap->dm_sz for plain int" );   /* TODO: not fatal. */
					return -1;
				}
			}
		}

	}

	/* Now eat padding. */
	{
		while (rd->bread % (8 * sizeof(flex_uint8_t)) > 0) {
			flex_int8_t t8;
			if(yytbl_read8(&t8,rd) != 0)
				return -1;
		}
	}

	return 0;
}

/* The name for this specific scanner's tables. */
#define YYTABLES_NAME "m4_ifdef([[M4_MODE_PREFIX]], M4_MODE_PREFIX, [[yy]])tables"

/* Find the key and load the DFA tables from the given stream.  */
static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) {
	int rv=0;
	struct yytbl_hdr th;
	struct yytbl_reader rd;

	rd.fp = fp;
	th.th_version = NULL;

	/* Keep trying until we find the right set of tables or end of file. */
	while (!feof(rd.fp)) {
		rd.bread = 0;
		if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0) {
			rv = -1;
			goto return_rv;
		}

		/* A NULL key means choose the first set of tables. */
		if (key == NULL) {
			break;
		}

		if (strcmp(th.th_name,key) != 0) {
			/* Skip ahead to next set */
			fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR);
			yyfree(th.th_version M4_YY_CALL_LAST_ARG);
			th.th_version = NULL;
		}
		else {
			break;
		}
	}

	while (rd.bread < th.th_ssize) {
		/* Load the data tables */
		if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){
			rv = -1;
			goto return_rv;
		}
	}

return_rv:
	if(th.th_version) {
		yyfree(th.th_version M4_YY_CALL_LAST_ARG);
		th.th_version = NULL;
	}

	return rv;
}

/** Load the DFA tables for this scanner from the given stream.  */
int yytables_fload YYFARGS1(FILE *, fp) {
	if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0) {
		return -1;
	}
	return 0;
}

/** Destroy the loaded tables, freeing memory, etc.. */
int yytables_destroy (M4_YY_DEF_ONLY_ARG) {
	struct yytbl_dmap *dmap=0;

	if(!M4_YY_TABLES_VERIFY){
		/* Walk the dmap, freeing the pointers */
		for(dmap=yydmap; dmap->dm_id; dmap++) {
			void * v;
			v = dmap->dm_arr;
			if(v && *(char**)v){
				yyfree(*(char**)v M4_YY_CALL_LAST_ARG);
				*(char**)v = NULL;
			}
		}
	}

	return 0;
}

/* end table serialization code definitions */
]])


m4_ifdef([[M4_YY_MAIN]], [[
int main (void);

int main () {
m4_ifdef([[M4_YY_REENTRANT]], [[
	yyscan_t lexer;
	yylex_init(&lexer);
	yylex( lexer );
	yylex_destroy( lexer);

]])
m4_ifdef([[M4_YY_NOT_REENTRANT]], [[
	yylex();
]])

	return 0;
}
]])

]])
m4_ifdef( [[M4_YY_IN_HEADER]],
[[
#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yysetbol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif
m4preproc_undivert(1)
#undef M4_MODE_PREFIX[[IN_HEADER]]
#endif /* M4_MODE_PREFIX[[HEADER_H]] */
m4_undefine([[M4_YY_IN_HEADER]])m4_dnl
]])

%# Local Variables:
%# mode:c
%# c-file-style:"k&r"
%# c-basic-offset:8
%# End: