Imported Upstream version 2.5.35upstream/2.5.35

1 files changed, 1857 insertions, 0 deletions

diff --git a/main.c b/main.c
new file mode 100644
index 0000000..cec2d77
--- /dev/null
+++ b/main.c
@@ -0,0 +1,1857 @@
+/* flex - tool to generate fast lexical analyzers */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+
+#include "flexdef.h"
+#include "version.h"
+#include "options.h"
+#include "tables.h"
+
+static char flex_version[] = FLEX_VERSION;
+
+/* declare functions that have forward references */
+
+void flexinit PROTO ((int, char **));
+void readin PROTO ((void));
+void set_up_initial_allocations PROTO ((void));
+static char *basename2 PROTO ((char *path, int should_strip_ext));
+
+
+/* these globals are all defined and commented in flexdef.h */
+int     printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
+int     interactive, lex_compat, posix_compat, do_yylineno,
+	useecs, fulltbl, usemecs;
+int     fullspd, gen_line_dirs, performance_report, backing_up_report;
+int     C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap,
+	csize;
+int     reentrant, bison_bridge_lval, bison_bridge_lloc;
+int     yymore_used, reject, real_reject, continued_action, in_rule;
+int     yymore_really_used, reject_really_used;
+int     datapos, dataline, linenum, out_linenum;
+FILE   *skelfile = NULL;
+int     skel_ind = 0;
+char   *action_array;
+int     action_size, defs1_offset, prolog_offset, action_offset,
+	action_index;
+char   *infilename = NULL, *outfilename = NULL, *headerfilename = NULL;
+int     did_outfilename;
+char   *prefix, *yyclass, *extra_type = NULL;
+int     do_stdinit, use_stdout;
+int     onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+int     onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+int     maximum_mns, current_mns, current_max_rules;
+int     num_rules, num_eof_rules, default_rule, lastnfa;
+int    *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
+int    *accptnum, *assoc_rule, *state_type;
+int    *rule_type, *rule_linenum, *rule_useful;
+int     current_state_type;
+int     variable_trailing_context_rules;
+int     numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
+int     protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
+int     numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs,
+	tecfwd[CSIZE + 1];
+int     tecbck[CSIZE + 1];
+int     lastsc, *scset, *scbol, *scxclu, *sceof;
+int     current_max_scs;
+char  **scname;
+int     current_max_dfa_size, current_max_xpairs;
+int     current_max_template_xpairs, current_max_dfas;
+int     lastdfa, *nxt, *chk, *tnxt;
+int    *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
+union dfaacc_union *dfaacc;
+int    *accsiz, *dhash, numas;
+int     numsnpairs, jambase, jamstate;
+int     lastccl, *cclmap, *ccllen, *cclng, cclreuse;
+int     current_maxccls, current_max_ccl_tbl_size;
+Char   *ccltbl;
+char    nmstr[MAXLINE];
+int     sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
+int     tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
+int     num_backing_up, bol_needed;
+FILE   *backing_up_file;
+int     end_of_buffer_state;
+char  **input_files;
+int     num_input_files;
+jmp_buf flex_main_jmp_buf;
+bool   *rule_has_nl, *ccl_has_nl;
+int     nlch = '\n';
+bool    ansi_func_defs, ansi_func_protos;
+
+bool    tablesext, tablesverify, gentables;
+char   *tablesfilename=0,*tablesname=0;
+struct yytbl_writer tableswr;
+
+/* Make sure program_name is initialized so we don't crash if writing
+ * out an error message before getting the program name from argv[0].
+ */
+char   *program_name = "flex";
+
+#ifndef SHORT_FILE_NAMES
+static char *outfile_template = "lex.%s.%s";
+static char *backing_name = "lex.backup";
+static char *tablesfile_template = "lex.%s.tables";
+#else
+static char *outfile_template = "lex%s.%s";
+static char *backing_name = "lex.bck";
+static char *tablesfile_template = "lex%s.tbl";
+#endif
+
+#ifdef MS_DOS
+extern unsigned _stklen = 16384;
+#endif
+
+/* From scan.l */
+extern FILE* yyout;
+
+static char outfile_path[MAXLINE];
+static int outfile_created = 0;
+static char *skelname = NULL;
+static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */
+const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]";
+const char *escaped_qend   = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
+
+/* For debugging. The max number of filters to apply to skeleton. */
+static int preproc_level = 1000;
+
+int flex_main PROTO ((int argc, char *argv[]));
+int main PROTO ((int argc, char *argv[]));
+
+int flex_main (argc, argv)
+     int argc;
+     char   *argv[];
+{
+	int     i, exit_status, child_status;
+
+	/* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The
+	 * return value of setjmp, if non-zero, is the desired exit code PLUS ONE.
+	 * For example, if you want 'main' to return with code '2', then call
+	 * longjmp() with an argument of 3. This is because it is invalid to
+	 * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of
+	 * exit(n);
+	 */
+	exit_status = setjmp (flex_main_jmp_buf);
+	if (exit_status){
+        if (stdout && !_stdout_closed && !ferror(stdout)){
+            fflush(stdout);
+            fclose(stdout);
+        }
+        while (wait(&child_status) > 0){
+            if (!WIFEXITED (child_status)
+                || WEXITSTATUS (child_status) != 0){
+                /* report an error of a child
+                 */
+                if( exit_status <= 1 )
+                    exit_status = 2;
+
+            }
+        }
+        return exit_status - 1;
+    }
+
+	flexinit (argc, argv);
+
+	readin ();
+
+	ntod ();
+
+	for (i = 1; i <= num_rules; ++i)
+		if (!rule_useful[i] && i != default_rule)
+			line_warning (_("rule cannot be matched"),
+				      rule_linenum[i]);
+
+	if (spprdflt && !reject && rule_useful[default_rule])
+		line_warning (_
+			      ("-s option given but default rule can be matched"),
+			      rule_linenum[default_rule]);
+
+	/* Generate the C state transition tables from the DFA. */
+	make_tables ();
+
+	/* Note, flexend does not return.  It exits with its argument
+	 * as status.
+	 */
+	flexend (0);
+
+	return 0;		/* keep compilers/lint happy */
+}
+
+/* Wrapper around flex_main, so flex_main can be built as a library. */
+int main (argc, argv)
+     int argc;
+     char   *argv[];
+{
+#if ENABLE_NLS
+#if HAVE_LOCALE_H
+	setlocale (LC_MESSAGES, "");
+        setlocale (LC_CTYPE, "");
+	textdomain (PACKAGE);
+	bindtextdomain (PACKAGE, LOCALEDIR);
+#endif
+#endif
+
+	return flex_main (argc, argv);
+}
+
+/* check_options - check user-specified options */
+
+void check_options ()
+{
+	int     i;
+    const char * m4 = NULL;
+
+	if (lex_compat) {
+		if (C_plus_plus)
+			flexerror (_("Can't use -+ with -l option"));
+
+		if (fulltbl || fullspd)
+			flexerror (_("Can't use -f or -F with -l option"));
+
+		if (reentrant || bison_bridge_lval)
+			flexerror (_
+				   ("Can't use --reentrant or --bison-bridge with -l option"));
+
+		/* Don't rely on detecting use of yymore() and REJECT,
+		 * just assume they'll be used.
+		 */
+		yymore_really_used = reject_really_used = true;
+
+		yytext_is_array = true;
+		do_yylineno = true;
+		use_read = false;
+	}
+
+
+#if 0
+	/* This makes no sense whatsoever. I'm removing it. */
+	if (do_yylineno)
+		/* This should really be "maintain_backup_tables = true" */
+		reject_really_used = true;
+#endif
+
+	if (csize == unspecified) {
+		if ((fulltbl || fullspd) && !useecs)
+			csize = DEFAULT_CSIZE;
+		else
+			csize = CSIZE;
+	}
+
+	if (interactive == unspecified) {
+		if (fulltbl || fullspd)
+			interactive = false;
+		else
+			interactive = true;
+	}
+
+	if (fulltbl || fullspd) {
+		if (usemecs)
+			flexerror (_
+				   ("-Cf/-CF and -Cm don't make sense together"));
+
+		if (interactive)
+			flexerror (_("-Cf/-CF and -I are incompatible"));
+
+		if (lex_compat)
+			flexerror (_
+				   ("-Cf/-CF are incompatible with lex-compatibility mode"));
+
+
+		if (fulltbl && fullspd)
+			flexerror (_
+				   ("-Cf and -CF are mutually exclusive"));
+	}
+
+	if (C_plus_plus && fullspd)
+		flexerror (_("Can't use -+ with -CF option"));
+
+	if (C_plus_plus && yytext_is_array) {
+		warn (_("%array incompatible with -+ option"));
+		yytext_is_array = false;
+	}
+
+	if (C_plus_plus && (reentrant))
+		flexerror (_("Options -+ and --reentrant are mutually exclusive."));
+
+	if (C_plus_plus && bison_bridge_lval)
+		flexerror (_("bison bridge not supported for the C++ scanner."));
+
+
+	if (useecs) {		/* Set up doubly-linked equivalence classes. */
+
+		/* We loop all the way up to csize, since ecgroup[csize] is
+		 * the position used for NUL characters.
+		 */
+		ecgroup[1] = NIL;
+
+		for (i = 2; i <= csize; ++i) {
+			ecgroup[i] = i - 1;
+			nextecm[i - 1] = i;
+		}
+
+		nextecm[csize] = NIL;
+	}
+
+	else {
+		/* Put everything in its own equivalence class. */
+		for (i = 1; i <= csize; ++i) {
+			ecgroup[i] = i;
+			nextecm[i] = BAD_SUBSCRIPT;	/* to catch errors */
+		}
+	}
+
+    if (!ansi_func_defs)
+        buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL);
+
+    if (!ansi_func_protos)
+        buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL);
+
+    if (extra_type)
+        buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
+
+	if (!use_stdout) {
+		FILE   *prev_stdout;
+
+		if (!did_outfilename) {
+			char   *suffix;
+
+			if (C_plus_plus)
+				suffix = "cc";
+			else
+				suffix = "c";
+
+			snprintf (outfile_path, sizeof(outfile_path), outfile_template,
+				 prefix, suffix);
+
+			outfilename = outfile_path;
+		}
+
+		prev_stdout = freopen (outfilename, "w+", stdout);
+
+		if (prev_stdout == NULL)
+			lerrsf (_("could not create %s"), outfilename);
+
+		outfile_created = 1;
+	}
+
+
+    /* Setup the filter chain. */
+    output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
+    if ( !(m4 = getenv("M4")))
+        m4 = M4;
+    filter_create_ext(output_chain, m4, "-P", 0);
+    filter_create_int(output_chain, filter_fix_linedirs, NULL);
+
+    /* For debugging, only run the requested number of filters. */
+    if (preproc_level > 0) {
+        filter_truncate(output_chain, preproc_level);
+        filter_apply_chain(output_chain);
+    }
+    yyout = stdout;
+
+
+	/* always generate the tablesverify flag. */
+	buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0");
+	if (tablesext)
+		gentables = false;
+
+	if (tablesverify)
+		/* force generation of C tables. */
+		gentables = true;
+
+
+	if (tablesext) {
+		FILE   *tablesout;
+		struct yytbl_hdr hdr;
+		char   *pname = 0;
+		int     nbytes = 0;
+
+		buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
+
+		if (!tablesfilename) {
+			nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
+			tablesfilename = pname = (char *) calloc (nbytes, 1);
+			snprintf (pname, nbytes, tablesfile_template, prefix);
+		}
+
+		if ((tablesout = fopen (tablesfilename, "w")) == NULL)
+			lerrsf (_("could not create %s"), tablesfilename);
+		if (pname)
+			free (pname);
+		tablesfilename = 0;
+
+		yytbl_writer_init (&tableswr, tablesout);
+
+		nbytes = strlen (prefix) + strlen ("tables") + 2;
+		tablesname = (char *) calloc (nbytes, 1);
+		snprintf (tablesname, nbytes, "%stables", prefix);
+		yytbl_hdr_init (&hdr, flex_version, tablesname);
+
+		if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0)
+			flexerror (_("could not write tables header"));
+	}
+
+	if (skelname && (skelfile = fopen (skelname, "r")) == NULL)
+		lerrsf (_("can't open skeleton file %s"), skelname);
+
+	if (reentrant) {
+        buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL);
+		if (yytext_is_array)
+			buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL);
+	}
+
+	if ( bison_bridge_lval)
+		buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL);
+
+	if ( bison_bridge_lloc)
+        buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
+
+    buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix);
+
+	if (did_outfilename)
+		line_directive_out (stdout, 0);
+
+	if (do_yylineno)
+		buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
+
+	/* Create the alignment type. */
+	buf_strdefine (&userdef_buf, "YY_INT_ALIGNED",
+		       long_align ? "long int" : "short int");
+
+    /* Define the start condition macros. */
+    {
+        struct Buf tmpbuf;
+        buf_init(&tmpbuf, sizeof(char));
+        for (i = 1; i <= lastsc; i++) {
+             char *str, *fmt = "#define %s %d\n";
+             size_t strsz;
+
+             str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2);
+             snprintf(str, strsz, fmt,      scname[i], i - 1);
+             buf_strappend(&tmpbuf, str);
+             free(str);
+        }
+        buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts);
+        buf_destroy(&tmpbuf);
+    }
+
+    /* This is where we begin writing to the file. */
+
+    /* Dump the %top code. */
+    if( top_buf.elts)
+        outn((char*) top_buf.elts);
+
+    /* Dump the m4 definitions. */
+    buf_print_strings(&m4defs_buf, stdout);
+    m4defs_buf.nelts = 0; /* memory leak here. */
+
+    /* Place a bogus line directive, it will be fixed in the filter. */
+    outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
+
+	/* Dump the user defined preproc directives. */
+	if (userdef_buf.elts)
+		outn ((char *) (userdef_buf.elts));
+
+	skelout ();
+	/* %% [1.0] */
+}
+
+/* flexend - terminate flex
+ *
+ * note
+ *    This routine does not return.
+ */
+
+void flexend (exit_status)
+     int exit_status;
+
+{
+	static int called_before = -1;	/* prevent infinite recursion. */
+	int     tblsiz;
+
+	if (++called_before)
+		FLEX_EXIT (exit_status);
+
+	if (skelfile != NULL) {
+		if (ferror (skelfile))
+			lerrsf (_("input error reading skeleton file %s"),
+				skelname);
+
+		else if (fclose (skelfile))
+			lerrsf (_("error closing skeleton file %s"),
+				skelname);
+	}
+
+#if 0
+		fprintf (header_out,
+			 "#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n");
+		fprintf (header_out,
+			 "/* Beware! Start conditions are not prefixed. */\n");
+
+		/* Special case for "INITIAL" */
+		fprintf (header_out,
+			 "#undef INITIAL\n#define INITIAL 0\n");
+		for (i = 2; i <= lastsc; i++)
+			fprintf (header_out, "#define %s %d\n", scname[i], i - 1);
+		fprintf (header_out,
+			 "#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n");
+
+		/* Kill ALL flex-related macros. This is so the user
+		 * can #include more than one generated header file. */
+		fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n");
+		fprintf (header_out,
+			 "/* Undefine all internal macros, etc., that do no belong in the header. */\n\n");
+
+        {
+            const char * undef_list[] = {
+
+                "BEGIN",
+                "ECHO",
+                "EOB_ACT_CONTINUE_SCAN",
+                "EOB_ACT_END_OF_FILE",
+                "EOB_ACT_LAST_MATCH",
+                "FLEX_SCANNER",
+                "FLEX_STD",
+                "REJECT",
+                "YYFARGS0",
+                "YYFARGS1",
+                "YYFARGS2",
+                "YYFARGS3",
+                "YYLMAX",
+                "YYSTATE",
+                "YY_AT_BOL",
+                "YY_BREAK",
+                "YY_BUFFER_EOF_PENDING",
+                "YY_BUFFER_NEW",
+                "YY_BUFFER_NORMAL",
+                "YY_BUF_SIZE",
+                "M4_YY_CALL_LAST_ARG",
+                "M4_YY_CALL_ONLY_ARG",
+                "YY_CURRENT_BUFFER",
+                "YY_DECL",
+                "M4_YY_DECL_LAST_ARG",
+                "M4_YY_DEF_LAST_ARG",
+                "M4_YY_DEF_ONLY_ARG",
+                "YY_DO_BEFORE_ACTION",
+                "YY_END_OF_BUFFER",
+                "YY_END_OF_BUFFER_CHAR",
+                "YY_EXIT_FAILURE",
+                "YY_EXTRA_TYPE",
+                "YY_FATAL_ERROR",
+                "YY_FLEX_DEFINED_ECHO",
+                "YY_FLEX_LEX_COMPAT",
+                "YY_FLEX_MAJOR_VERSION",
+                "YY_FLEX_MINOR_VERSION",
+                "YY_FLEX_SUBMINOR_VERSION",
+                "YY_FLUSH_BUFFER",
+                "YY_G",
+                "YY_INPUT",
+                "YY_INTERACTIVE",
+                "YY_INT_ALIGNED",
+                "YY_LAST_ARG",
+                "YY_LESS_LINENO",
+                "YY_LEX_ARGS",
+                "YY_LEX_DECLARATION",
+                "YY_LEX_PROTO",
+                "YY_MAIN",
+                "YY_MORE_ADJ",
+                "YY_NEED_STRLEN",
+                "YY_NEW_FILE",
+                "YY_NULL",
+                "YY_NUM_RULES",
+                "YY_ONLY_ARG",
+                "YY_PARAMS",
+                "YY_PROTO",
+                "M4_YY_PROTO_LAST_ARG",
+                "M4_YY_PROTO_ONLY_ARG void",
+                "YY_READ_BUF_SIZE",
+                "YY_REENTRANT",
+                "YY_RESTORE_YY_MORE_OFFSET",
+                "YY_RULE_SETUP",
+                "YY_SC_TO_UI",
+                "YY_SKIP_YYWRAP",
+                "YY_START",
+                "YY_START_STACK_INCR",
+                "YY_STATE_EOF",
+                "YY_STDINIT",
+                "YY_TRAILING_HEAD_MASK",
+                "YY_TRAILING_MASK",
+                "YY_USER_ACTION",
+                "YY_USE_CONST",
+                "YY_USE_PROTOS",
+                "unput",
+                "yyTABLES_NAME",
+                "yy_create_buffer",
+                "yy_delete_buffer",
+                "yy_flex_debug",
+                "yy_flush_buffer",
+                "yy_init_buffer",
+                "yy_load_buffer_state",
+                "yy_new_buffer",
+                "yy_scan_buffer",
+                "yy_scan_bytes",
+                "yy_scan_string",
+                "yy_set_bol",
+                "yy_set_interactive",
+                "yy_switch_to_buffer",
+				"yypush_buffer_state",
+				"yypop_buffer_state",
+				"yyensure_buffer_stack",
+                "yyalloc",
+                "yyconst",
+                "yyextra",
+                "yyfree",
+                "yyget_debug",
+                "yyget_extra",
+                "yyget_in",
+                "yyget_leng",
+                "yyget_lineno",
+                "yyget_lloc",
+                "yyget_lval",
+                "yyget_out",
+                "yyget_text",
+                "yyin",
+                "yyleng",
+                "yyless",
+                "yylex",
+                "yylex_destroy",
+                "yylex_init",
+                "yylex_init_extra",
+                "yylineno",
+                "yylloc",
+                "yylval",
+                "yymore",
+                "yyout",
+                "yyrealloc",
+                "yyrestart",
+                "yyset_debug",
+                "yyset_extra",
+                "yyset_in",
+                "yyset_lineno",
+                "yyset_lloc",
+                "yyset_lval",
+                "yyset_out",
+                "yytables_destroy",
+                "yytables_fload",
+                "yyterminate",
+                "yytext",
+                "yytext_ptr",
+                "yywrap",
+
+                /* must be null-terminated */
+                NULL};
+
+
+                for (i=0; undef_list[i] != NULL; i++)
+                    fprintf (header_out, "#undef %s\n", undef_list[i]);
+        }
+
+		/* undef any of the auto-generated symbols. */
+		for (i = 0; i < defs_buf.nelts; i++) {
+
+			/* don't undef start conditions */
+			if (sclookup (((char **) defs_buf.elts)[i]) > 0)
+				continue;
+			fprintf (header_out, "#undef %s\n",
+				 ((char **) defs_buf.elts)[i]);
+		}
+
+		fprintf (header_out,
+			 "#endif /* !YY_HEADER_NO_UNDEFS */\n");
+		fprintf (header_out, "\n");
+		fprintf (header_out, "#undef %sIN_HEADER\n", prefix);
+		fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
+
+		if (ferror (header_out))
+			lerrsf (_("error creating header file %s"),
+				headerfilename);
+		fflush (header_out);
+		fclose (header_out);
+#endif
+
+	if (exit_status != 0 && outfile_created) {
+		if (ferror (stdout))
+			lerrsf (_("error writing output file %s"),
+				outfilename);
+
+		else if ((_stdout_closed = 1) && fclose (stdout))
+			lerrsf (_("error closing output file %s"),
+				outfilename);
+
+		else if (unlink (outfilename))
+			lerrsf (_("error deleting output file %s"),
+				outfilename);
+	}
+
+
+	if (backing_up_report && backing_up_file) {
+		if (num_backing_up == 0)
+			fprintf (backing_up_file, _("No backing up.\n"));
+		else if (fullspd || fulltbl)
+			fprintf (backing_up_file,
+				 _
+				 ("%d backing up (non-accepting) states.\n"),
+				 num_backing_up);
+		else
+			fprintf (backing_up_file,
+				 _("Compressed tables always back up.\n"));
+
+		if (ferror (backing_up_file))
+			lerrsf (_("error writing backup file %s"),
+				backing_name);
+
+		else if (fclose (backing_up_file))
+			lerrsf (_("error closing backup file %s"),
+				backing_name);
+	}
+
+	if (printstats) {
+		fprintf (stderr, _("%s version %s usage statistics:\n"),
+			 program_name, flex_version);
+
+		fprintf (stderr, _("  scanner options: -"));
+
+		if (C_plus_plus)
+			putc ('+', stderr);
+		if (backing_up_report)
+			putc ('b', stderr);
+		if (ddebug)
+			putc ('d', stderr);
+		if (sf_case_ins())
+			putc ('i', stderr);
+		if (lex_compat)
+			putc ('l', stderr);
+		if (posix_compat)
+			putc ('X', stderr);
+		if (performance_report > 0)
+			putc ('p', stderr);
+		if (performance_report > 1)
+			putc ('p', stderr);
+		if (spprdflt)
+			putc ('s', stderr);
+		if (reentrant)
+			fputs ("--reentrant", stderr);
+        if (bison_bridge_lval)
+            fputs ("--bison-bridge", stderr);
+        if (bison_bridge_lloc)
+            fputs ("--bison-locations", stderr);
+		if (use_stdout)
+			putc ('t', stderr);
+		if (printstats)
+			putc ('v', stderr);	/* always true! */
+		if (nowarn)
+			putc ('w', stderr);
+		if (interactive == false)
+			putc ('B', stderr);
+		if (interactive == true)
+			putc ('I', stderr);
+		if (!gen_line_dirs)
+			putc ('L', stderr);
+		if (trace)
+			putc ('T', stderr);
+
+		if (csize == unspecified)
+			/* We encountered an error fairly early on, so csize
+			 * never got specified.  Define it now, to prevent
+			 * bogus table sizes being written out below.
+			 */
+			csize = 256;
+
+		if (csize == 128)
+			putc ('7', stderr);
+		else
+			putc ('8', stderr);
+
+		fprintf (stderr, " -C");
+
+		if (long_align)
+			putc ('a', stderr);
+		if (fulltbl)
+			putc ('f', stderr);
+		if (fullspd)
+			putc ('F', stderr);
+		if (useecs)
+			putc ('e', stderr);
+		if (usemecs)
+			putc ('m', stderr);
+		if (use_read)
+			putc ('r', stderr);
+
+		if (did_outfilename)
+			fprintf (stderr, " -o%s", outfilename);
+
+		if (skelname)
+			fprintf (stderr, " -S%s", skelname);
+
+		if (strcmp (prefix, "yy"))
+			fprintf (stderr, " -P%s", prefix);
+
+		putc ('\n', stderr);
+
+		fprintf (stderr, _("  %d/%d NFA states\n"),
+			 lastnfa, current_mns);
+		fprintf (stderr, _("  %d/%d DFA states (%d words)\n"),
+			 lastdfa, current_max_dfas, totnst);
+		fprintf (stderr, _("  %d rules\n"),
+			 num_rules + num_eof_rules -
+			 1 /* - 1 for def. rule */ );
+
+		if (num_backing_up == 0)
+			fprintf (stderr, _("  No backing up\n"));
+		else if (fullspd || fulltbl)
+			fprintf (stderr,
+				 _
+				 ("  %d backing-up (non-accepting) states\n"),
+				 num_backing_up);
+		else
+			fprintf (stderr,
+				 _
+				 ("  Compressed tables always back-up\n"));
+
+		if (bol_needed)
+			fprintf (stderr,
+				 _("  Beginning-of-line patterns used\n"));
+
+		fprintf (stderr, _("  %d/%d start conditions\n"), lastsc,
+			 current_max_scs);
+		fprintf (stderr,
+			 _
+			 ("  %d epsilon states, %d double epsilon states\n"),
+			 numeps, eps2);
+
+		if (lastccl == 0)
+			fprintf (stderr, _("  no character classes\n"));
+		else
+			fprintf (stderr,
+				 _
+				 ("  %d/%d character classes needed %d/%d words of storage, %d reused\n"),
+				 lastccl, current_maxccls,
+				 cclmap[lastccl] + ccllen[lastccl],
+				 current_max_ccl_tbl_size, cclreuse);
+
+		fprintf (stderr, _("  %d state/nextstate pairs created\n"),
+			 numsnpairs);
+		fprintf (stderr,
+			 _("  %d/%d unique/duplicate transitions\n"),
+			 numuniq, numdup);
+
+		if (fulltbl) {
+			tblsiz = lastdfa * numecs;
+			fprintf (stderr, _("  %d table entries\n"),
+				 tblsiz);
+		}
+
+		else {
+			tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
+
+			fprintf (stderr,
+				 _("  %d/%d base-def entries created\n"),
+				 lastdfa + numtemps, current_max_dfas);
+			fprintf (stderr,
+				 _
+				 ("  %d/%d (peak %d) nxt-chk entries created\n"),
+				 tblend, current_max_xpairs, peakpairs);
+			fprintf (stderr,
+				 _
+				 ("  %d/%d (peak %d) template nxt-chk entries created\n"),
+				 numtemps * nummecs,
+				 current_max_template_xpairs,
+				 numtemps * numecs);
+			fprintf (stderr, _("  %d empty table entries\n"),
+				 nummt);
+			fprintf (stderr, _("  %d protos created\n"),
+				 numprots);
+			fprintf (stderr,
+				 _("  %d templates created, %d uses\n"),
+				 numtemps, tmpuses);
+		}
+
+		if (useecs) {
+			tblsiz = tblsiz + csize;
+			fprintf (stderr,
+				 _
+				 ("  %d/%d equivalence classes created\n"),
+				 numecs, csize);
+		}
+
+		if (usemecs) {
+			tblsiz = tblsiz + numecs;
+			fprintf (stderr,
+				 _
+				 ("  %d/%d meta-equivalence classes created\n"),
+				 nummecs, csize);
+		}
+
+		fprintf (stderr,
+			 _
+			 ("  %d (%d saved) hash collisions, %d DFAs equal\n"),
+			 hshcol, hshsave, dfaeql);
+		fprintf (stderr, _("  %d sets of reallocations needed\n"),
+			 num_reallocs);
+		fprintf (stderr, _("  %d total table entries needed\n"),
+			 tblsiz);
+	}
+
+	FLEX_EXIT (exit_status);
+}
+
+
+/* flexinit - initialize flex */
+
+void flexinit (argc, argv)
+     int argc;
+     char  **argv;
+{
+	int     i, sawcmpflag, rv, optind;
+	char   *arg;
+	scanopt_t sopt;
+
+	printstats = syntaxerror = trace = spprdflt = false;
+	lex_compat = posix_compat = C_plus_plus = backing_up_report =
+		ddebug = fulltbl = false;
+	fullspd = long_align = nowarn = yymore_used = continued_action =
+		false;
+	do_yylineno = yytext_is_array = in_rule = reject = do_stdinit =
+		false;
+	yymore_really_used = reject_really_used = unspecified;
+	interactive = csize = unspecified;
+	do_yywrap = gen_line_dirs = usemecs = useecs = true;
+	reentrant = bison_bridge_lval = bison_bridge_lloc = false;
+	performance_report = 0;
+	did_outfilename = 0;
+	prefix = "yy";
+	yyclass = 0;
+	use_read = use_stdout = false;
+	tablesext = tablesverify = false;
+	gentables = true;
+	tablesfilename = tablesname = NULL;
+    ansi_func_defs = ansi_func_protos = true;
+
+	sawcmpflag = false;
+
+	/* Initialize dynamic array for holding the rule actions. */
+	action_size = 2048;	/* default size of action array in bytes */
+	action_array = allocate_character_array (action_size);
+	defs1_offset = prolog_offset = action_offset = action_index = 0;
+	action_array[0] = '\0';
+
+	/* Initialize any buffers. */
+	buf_init (&userdef_buf, sizeof (char));	/* one long string */
+	buf_init (&defs_buf, sizeof (char *));	/* list of strings */
+	buf_init (&yydmap_buf, sizeof (char));	/* one long string */
+	buf_init (&top_buf, sizeof (char));	    /* one long string */
+
+    {
+        const char * m4defs_init_str[] = {"m4_changequote\n",
+                                          "m4_changequote([[, ]])\n"};
+        buf_init (&m4defs_buf, sizeof (char *));
+        buf_append (&m4defs_buf, &m4defs_init_str, 2);
+    }
+
+    sf_init ();
+
+    /* initialize regex lib */
+    flex_init_regex();
+
+	/* Enable C++ if program name ends with '+'. */
+	program_name = basename2 (argv[0], 0);
+
+	if (program_name[0] != '\0' &&
+	    program_name[strlen (program_name) - 1] == '+')
+		C_plus_plus = true;
+
+	/* read flags */
+	sopt = scanopt_init (flexopts, argc, argv, 0);
+	if (!sopt) {
+		/* This will only happen when flexopts array is altered. */
+		fprintf (stderr,
+			 _("Internal error. flexopts are malformed.\n"));
+		FLEX_EXIT (1);
+	}
+
+	while ((rv = scanopt (sopt, &arg, &optind)) != 0) {
+
+		if (rv < 0) {
+			/* Scanopt has already printed an option-specific error message. */
+			fprintf (stderr,
+				 _
+				 ("Try `%s --help' for more information.\n"),
+				 program_name);
+			FLEX_EXIT (1);
+		}
+
+		switch ((enum flexopt_flag_t) rv) {
+		case OPT_CPLUSPLUS:
+			C_plus_plus = true;
+			break;
+
+		case OPT_BATCH:
+			interactive = false;
+			break;
+
+		case OPT_BACKUP:
+			backing_up_report = true;
+			break;
+
+		case OPT_DONOTHING:
+			break;
+
+		case OPT_COMPRESSION:
+			if (!sawcmpflag) {
+				useecs = false;
+				usemecs = false;
+				fulltbl = false;
+				sawcmpflag = true;
+			}
+
+			for (i = 0; arg && arg[i] != '\0'; i++)
+				switch (arg[i]) {
+				case 'a':
+					long_align = true;
+					break;
+
+				case 'e':
+					useecs = true;
+					break;
+
+				case 'F':
+					fullspd = true;
+					break;
+
+				case 'f':
+					fulltbl = true;
+					break;
+
+				case 'm':
+					usemecs = true;
+					break;
+
+				case 'r':
+					use_read = true;
+					break;
+
+				default:
+					lerrif (_
+						("unknown -C option '%c'"),
+						(int) arg[i]);
+					break;
+				}
+			break;
+
+		case OPT_DEBUG:
+			ddebug = true;
+			break;
+
+		case OPT_NO_DEBUG:
+			ddebug = false;
+			break;
+
+		case OPT_FULL:
+			useecs = usemecs = false;
+			use_read = fulltbl = true;
+			break;
+
+		case OPT_FAST:
+			useecs = usemecs = false;
+			use_read = fullspd = true;
+			break;
+
+		case OPT_HELP:
+			usage ();
+			FLEX_EXIT (0);
+
+		case OPT_INTERACTIVE:
+			interactive = true;
+			break;
+
+		case OPT_CASE_INSENSITIVE:
+			sf_set_case_ins(true);
+			break;
+
+		case OPT_LEX_COMPAT:
+			lex_compat = true;
+			break;
+
+		case OPT_POSIX_COMPAT:
+			posix_compat = true;
+			break;
+
+        case OPT_PREPROC_LEVEL:
+            preproc_level = strtol(arg,NULL,0);
+            break;
+
+		case OPT_MAIN:
+			buf_strdefine (&userdef_buf, "YY_MAIN", "1");
+			do_yywrap = false;
+			break;
+
+		case OPT_NO_MAIN:
+			buf_strdefine (&userdef_buf, "YY_MAIN", "0");
+			break;
+
+		case OPT_NO_LINE:
+			gen_line_dirs = false;
+			break;
+
+		case OPT_OUTFILE:
+			outfilename = arg;
+			did_outfilename = 1;
+			break;
+
+		case OPT_PREFIX:
+			prefix = arg;
+			break;
+
+		case OPT_PERF_REPORT:
+			++performance_report;
+			break;
+
+		case OPT_BISON_BRIDGE:
+			bison_bridge_lval = true;
+			break;
+
+		case OPT_BISON_BRIDGE_LOCATIONS:
+			bison_bridge_lval = bison_bridge_lloc = true;
+			break;
+
+		case OPT_REENTRANT:
+			reentrant = true;
+			break;
+
+		case OPT_NO_REENTRANT:
+			reentrant = false;
+			break;
+
+		case OPT_SKEL:
+			skelname = arg;
+			break;
+
+		case OPT_DEFAULT:
+			spprdflt = false;
+			break;
+
+		case OPT_NO_DEFAULT:
+			spprdflt = true;
+			break;
+
+		case OPT_STDOUT:
+			use_stdout = true;
+			break;
+
+		case OPT_NO_UNISTD_H:
+			//buf_strdefine (&userdef_buf, "YY_NO_UNISTD_H", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_UNISTD_H",0);
+			break;
+
+		case OPT_TABLES_FILE:
+			tablesext = true;
+			tablesfilename = arg;
+			break;
+
+		case OPT_TABLES_VERIFY:
+			tablesverify = true;
+			break;
+
+		case OPT_TRACE:
+			trace = true;
+			break;
+
+		case OPT_VERBOSE:
+			printstats = true;
+			break;
+
+		case OPT_VERSION:
+			printf (_("%s %s\n"), program_name, flex_version);
+			FLEX_EXIT (0);
+
+		case OPT_WARN:
+			nowarn = false;
+			break;
+
+		case OPT_NO_WARN:
+			nowarn = true;
+			break;
+
+		case OPT_7BIT:
+			csize = 128;
+			break;
+
+		case OPT_8BIT:
+			csize = CSIZE;
+			break;
+
+		case OPT_ALIGN:
+			long_align = true;
+			break;
+
+		case OPT_NO_ALIGN:
+			long_align = false;
+			break;
+
+		case OPT_ALWAYS_INTERACTIVE:
+			buf_m4_define (&m4defs_buf, "M4_YY_ALWAYS_INTERACTIVE", 0);
+			break;
+
+		case OPT_NEVER_INTERACTIVE:
+            buf_m4_define( &m4defs_buf, "M4_YY_NEVER_INTERACTIVE", 0);
+			break;
+
+		case OPT_ARRAY:
+			yytext_is_array = true;
+			break;
+
+		case OPT_POINTER:
+			yytext_is_array = false;
+			break;
+
+		case OPT_ECS:
+			useecs = true;
+			break;
+
+		case OPT_NO_ECS:
+			useecs = false;
+			break;
+
+		case OPT_HEADER_FILE:
+			headerfilename = arg;
+			break;
+
+		case OPT_META_ECS:
+			usemecs = true;
+			break;
+
+		case OPT_NO_META_ECS:
+			usemecs = false;
+			break;
+
+		case OPT_PREPROCDEFINE:
+			{
+				/* arg is "symbol" or "symbol=definition". */
+				char   *def;
+
+				for (def = arg;
+				     *def != '\0' && *def != '='; ++def) ;
+
+				buf_strappend (&userdef_buf, "#define ");
+				if (*def == '\0') {
+					buf_strappend (&userdef_buf, arg);
+					buf_strappend (&userdef_buf,
+						       " 1\n");
+				}
+				else {
+					buf_strnappend (&userdef_buf, arg,
+							def - arg);
+					buf_strappend (&userdef_buf, " ");
+					buf_strappend (&userdef_buf,
+						       def + 1);
+					buf_strappend (&userdef_buf, "\n");
+				}
+			}
+			break;
+
+		case OPT_READ:
+			use_read = true;
+			break;
+
+		case OPT_STACK:
+			//buf_strdefine (&userdef_buf, "YY_STACK_USED", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_STACK_USED",0);
+			break;
+
+		case OPT_STDINIT:
+			do_stdinit = true;
+			break;
+
+		case OPT_NO_STDINIT:
+			do_stdinit = false;
+			break;
+
+		case OPT_YYCLASS:
+			yyclass = arg;
+			break;
+
+		case OPT_YYLINENO:
+			do_yylineno = true;
+			break;
+
+		case OPT_NO_YYLINENO:
+			do_yylineno = false;
+			break;
+
+		case OPT_YYWRAP:
+			do_yywrap = true;
+			break;
+
+		case OPT_NO_YYWRAP:
+			do_yywrap = false;
+			break;
+
+		case OPT_YYMORE:
+			yymore_really_used = true;
+			break;
+
+		case OPT_NO_YYMORE:
+			yymore_really_used = false;
+			break;
+
+		case OPT_REJECT:
+			reject_really_used = true;
+			break;
+
+		case OPT_NO_REJECT:
+			reject_really_used = false;
+			break;
+
+        case OPT_NO_ANSI_FUNC_DEFS:
+            ansi_func_defs = false;
+            break;
+
+        case OPT_NO_ANSI_FUNC_PROTOS:
+            ansi_func_protos = false;
+            break;
+
+		case OPT_NO_YY_PUSH_STATE:
+			//buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0);
+			break;
+		case OPT_NO_YY_POP_STATE:
+			//buf_strdefine (&userdef_buf, "YY_NO_POP_STATE", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_POP_STATE",0);
+			break;
+		case OPT_NO_YY_TOP_STATE:
+			//buf_strdefine (&userdef_buf, "YY_NO_TOP_STATE", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_TOP_STATE",0);
+			break;
+		case OPT_NO_UNPUT:
+			//buf_strdefine (&userdef_buf, "YY_NO_UNPUT", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_UNPUT",0);
+			break;
+		case OPT_NO_YY_SCAN_BUFFER:
+			//buf_strdefine (&userdef_buf, "YY_NO_SCAN_BUFFER", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BUFFER",0);
+			break;
+		case OPT_NO_YY_SCAN_BYTES:
+			//buf_strdefine (&userdef_buf, "YY_NO_SCAN_BYTES", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BYTES",0);
+			break;
+		case OPT_NO_YY_SCAN_STRING:
+			//buf_strdefine (&userdef_buf, "YY_NO_SCAN_STRING", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_STRING",0);
+			break;
+		case OPT_NO_YYGET_EXTRA:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_EXTRA", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_EXTRA",0);
+			break;
+		case OPT_NO_YYSET_EXTRA:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_EXTRA", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_EXTRA",0);
+			break;
+		case OPT_NO_YYGET_LENG:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_LENG", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LENG",0);
+			break;
+		case OPT_NO_YYGET_TEXT:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_TEXT", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_TEXT",0);
+			break;
+		case OPT_NO_YYGET_LINENO:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_LINENO", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LINENO",0);
+			break;
+		case OPT_NO_YYSET_LINENO:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_LINENO", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LINENO",0);
+			break;
+		case OPT_NO_YYGET_IN:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_IN", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_IN",0);
+			break;
+		case OPT_NO_YYSET_IN:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_IN", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_IN",0);
+			break;
+		case OPT_NO_YYGET_OUT:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_OUT", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_OUT",0);
+			break;
+		case OPT_NO_YYSET_OUT:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_OUT", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_OUT",0);
+			break;
+		case OPT_NO_YYGET_LVAL:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_LVAL", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LVAL",0);
+			break;
+		case OPT_NO_YYSET_LVAL:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_LVAL", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LVAL",0);
+			break;
+		case OPT_NO_YYGET_LLOC:
+			//buf_strdefine (&userdef_buf, "YY_NO_GET_LLOC", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LLOC",0);
+			break;
+		case OPT_NO_YYSET_LLOC:
+			//buf_strdefine (&userdef_buf, "YY_NO_SET_LLOC", "1");
+            buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LLOC",0);
+			break;
+
+		}		/* switch */
+	}			/* while scanopt() */
+
+	scanopt_destroy (sopt);
+
+	num_input_files = argc - optind;
+	input_files = argv + optind;
+	set_input_file (num_input_files > 0 ? input_files[0] : NULL);
+
+	lastccl = lastsc = lastdfa = lastnfa = 0;
+	num_rules = num_eof_rules = default_rule = 0;
+	numas = numsnpairs = tmpuses = 0;
+	numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst =
+		0;
+	numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
+	num_backing_up = onesp = numprots = 0;
+	variable_trailing_context_rules = bol_needed = false;
+
+	out_linenum = linenum = sectnum = 1;
+	firstprot = NIL;
+
+	/* Used in mkprot() so that the first proto goes in slot 1
+	 * of the proto queue.
+	 */
+	lastprot = 1;
+
+	set_up_initial_allocations ();
+}
+
+
+/* readin - read in the rules section of the input file(s) */
+
+void readin ()
+{
+	static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
+	static char yy_nostdinit[] =
+		"FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
+
+	line_directive_out ((FILE *) 0, 1);
+
+	if (yyparse ()) {
+		pinpoint_message (_("fatal parse error"));
+		flexend (1);
+	}
+
+	if (syntaxerror)
+		flexend (1);
+
+	/* If the user explicitly requested posix compatibility by specifing the
+	 * posix-compat option, then we check for conflicting options. However, if
+	 * the POSIXLY_CORRECT variable is set, then we quietly make flex as
+	 * posix-compatible as possible.  This is the recommended behavior
+	 * according to the GNU Coding Standards.
+	 *
+	 * Note: The posix option was added to flex to provide the posix behavior
+	 * of the repeat operator in regular expressions, e.g., `ab{3}'
+	 */
+	if (posix_compat) {
+		/* TODO: This is where we try to make flex behave according to
+		 * posiz, AND check for conflicting options. How far should we go
+		 * with this? Should we disable all the neat-o flex features?
+		 */
+		/* Update: Estes says no, since other flex features don't violate posix. */
+	}
+
+	if (getenv ("POSIXLY_CORRECT")) {
+		posix_compat = true;
+	}
+
+	if (backing_up_report) {
+		backing_up_file = fopen (backing_name, "w");
+		if (backing_up_file == NULL)
+			lerrsf (_
+				("could not create backing-up info file %s"),
+				backing_name);
+	}
+
+	else
+		backing_up_file = NULL;
+
+	if (yymore_really_used == true)
+		yymore_used = true;
+	else if (yymore_really_used == false)
+		yymore_used = false;
+
+	if (reject_really_used == true)
+		reject = true;
+	else if (reject_really_used == false)
+		reject = false;
+
+	if (performance_report > 0) {
+		if (lex_compat) {
+			fprintf (stderr,
+				 _
+				 ("-l AT&T lex compatibility option entails a large performance penalty\n"));
+			fprintf (stderr,
+				 _
+				 (" and may be the actual source of other reported performance penalties\n"));
+		}
+
+		else if (do_yylineno) {
+			fprintf (stderr,
+				 _
+				 ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"));
+		}
+
+		if (performance_report > 1) {
+			if (interactive)
+				fprintf (stderr,
+					 _
+					 ("-I (interactive) entails a minor performance penalty\n"));
+
+			if (yymore_used)
+				fprintf (stderr,
+					 _
+					 ("yymore() entails a minor performance penalty\n"));
+		}
+
+		if (reject)
+			fprintf (stderr,
+				 _
+				 ("REJECT entails a large performance penalty\n"));
+
+		if (variable_trailing_context_rules)
+			fprintf (stderr,
+				 _
+				 ("Variable trailing context rules entail a large performance penalty\n"));
+	}
+
+	if (reject)
+		real_reject = true;
+
+	if (variable_trailing_context_rules)
+		reject = true;
+
+	if ((fulltbl || fullspd) && reject) {
+		if (real_reject)
+			flexerror (_
+				   ("REJECT cannot be used with -f or -F"));
+		else if (do_yylineno)
+			flexerror (_
+				   ("%option yylineno cannot be used with REJECT"));
+		else
+			flexerror (_
+				   ("variable trailing context rules cannot be used with -f or -F"));
+	}
+
+	if (reject){
+        out_m4_define( "M4_YY_USES_REJECT", NULL);
+		//outn ("\n#define YY_USES_REJECT");
+    }
+
+	if (!do_yywrap) {
+		if (!C_plus_plus) {
+			outn ("\n#define yywrap(n) 1");
+		}
+		outn ("#define YY_SKIP_YYWRAP");
+	}
+
+	if (ddebug)
+		outn ("\n#define FLEX_DEBUG");
+
+	OUT_BEGIN_CODE ();
+	if (csize == 256)
+		outn ("typedef unsigned char YY_CHAR;");
+	else
+		outn ("typedef char YY_CHAR;");
+	OUT_END_CODE ();
+
+	if (C_plus_plus) {
+		outn ("#define yytext_ptr yytext");
+
+		if (interactive)
+			outn ("#define YY_INTERACTIVE");
+	}
+
+	else {
+		OUT_BEGIN_CODE ();
+		/* In reentrant scanner, stdinit is handled in flex.skl. */
+		if (do_stdinit) {
+			if (reentrant){
+                outn ("#ifdef VMS");
+                outn ("#ifdef __VMS_POSIX");
+                outn ("#define YY_STDINIT");
+                outn ("#endif");
+                outn ("#else");
+                outn ("#define YY_STDINIT");
+                outn ("#endif");
+            }
+
+			outn ("#ifdef VMS");
+			outn ("#ifndef __VMS_POSIX");
+			outn (yy_nostdinit);
+			outn ("#else");
+			outn (yy_stdinit);
+			outn ("#endif");
+			outn ("#else");
+			outn (yy_stdinit);
+			outn ("#endif");
+		}
+
+		else {
+			if(!reentrant)
+                outn (yy_nostdinit);
+		}
+		OUT_END_CODE ();
+	}
+
+	OUT_BEGIN_CODE ();
+	if (fullspd)
+		outn ("typedef yyconst struct yy_trans_info *yy_state_type;");
+	else if (!C_plus_plus)
+		outn ("typedef int yy_state_type;");
+	OUT_END_CODE ();
+
+	if (lex_compat)
+		outn ("#define YY_FLEX_LEX_COMPAT");
+
+	if (!C_plus_plus && !reentrant) {
+		outn ("extern int yylineno;");
+		OUT_BEGIN_CODE ();
+		outn ("int yylineno = 1;");
+		OUT_END_CODE ();
+	}
+
+	if (C_plus_plus) {
+		outn ("\n#include <FlexLexer.h>");
+
+ 		if (!do_yywrap) {
+			outn("\nint yyFlexLexer::yywrap() { return 1; }");
+		}
+
+		if (yyclass) {
+			outn ("int yyFlexLexer::yylex()");
+			outn ("\t{");
+			outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
+			outn ("\treturn 0;");
+			outn ("\t}");
+
+			out_str ("\n#define YY_DECL int %s::yylex()\n",
+				 yyclass);
+		}
+	}
+
+	else {
+
+		/* Watch out: yytext_ptr is a variable when yytext is an array,
+		 * but it's a macro when yytext is a pointer.
+		 */
+		if (yytext_is_array) {
+			if (!reentrant)
+				outn ("extern char yytext[];\n");
+		}
+		else {
+			if (reentrant) {
+				outn ("#define yytext_ptr yytext_r");
+			}
+			else {
+				outn ("extern char *yytext;");
+				outn ("#define yytext_ptr yytext");
+			}
+		}
+
+		if (yyclass)
+			flexerror (_
+				   ("%option yyclass only meaningful for C++ scanners"));
+	}
+
+	if (useecs)
+		numecs = cre8ecs (nextecm, ecgroup, csize);
+	else
+		numecs = csize;
+
+	/* Now map the equivalence class for NUL to its expected place. */
+	ecgroup[0] = ecgroup[csize];
+	NUL_ec = ABS (ecgroup[0]);
+
+	if (useecs)
+		ccl2ecl ();
+}
+
+
+/* set_up_initial_allocations - allocate memory for internal tables */
+
+void set_up_initial_allocations ()
+{
+	maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
+	current_mns = INITIAL_MNS;
+	firstst = allocate_integer_array (current_mns);
+	lastst = allocate_integer_array (current_mns);
+	finalst = allocate_integer_array (current_mns);
+	transchar = allocate_integer_array (current_mns);
+	trans1 = allocate_integer_array (current_mns);
+	trans2 = allocate_integer_array (current_mns);
+	accptnum = allocate_integer_array (current_mns);
+	assoc_rule = allocate_integer_array (current_mns);
+	state_type = allocate_integer_array (current_mns);
+
+	current_max_rules = INITIAL_MAX_RULES;
+	rule_type = allocate_integer_array (current_max_rules);
+	rule_linenum = allocate_integer_array (current_max_rules);
+	rule_useful = allocate_integer_array (current_max_rules);
+	rule_has_nl = allocate_bool_array (current_max_rules);
+
+	current_max_scs = INITIAL_MAX_SCS;
+	scset = allocate_integer_array (current_max_scs);
+	scbol = allocate_integer_array (current_max_scs);
+	scxclu = allocate_integer_array (current_max_scs);
+	sceof = allocate_integer_array (current_max_scs);
+	scname = allocate_char_ptr_array (current_max_scs);
+
+	current_maxccls = INITIAL_MAX_CCLS;
+	cclmap = allocate_integer_array (current_maxccls);
+	ccllen = allocate_integer_array (current_maxccls);
+	cclng = allocate_integer_array (current_maxccls);
+	ccl_has_nl = allocate_bool_array (current_maxccls);
+
+	current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
+	ccltbl = allocate_Character_array (current_max_ccl_tbl_size);
+
+	current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
+
+	current_max_xpairs = INITIAL_MAX_XPAIRS;
+	nxt = allocate_integer_array (current_max_xpairs);
+	chk = allocate_integer_array (current_max_xpairs);
+
+	current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
+	tnxt = allocate_integer_array (current_max_template_xpairs);
+
+	current_max_dfas = INITIAL_MAX_DFAS;
+	base = allocate_integer_array (current_max_dfas);
+	def = allocate_integer_array (current_max_dfas);
+	dfasiz = allocate_integer_array (current_max_dfas);
+	accsiz = allocate_integer_array (current_max_dfas);
+	dhash = allocate_integer_array (current_max_dfas);
+	dss = allocate_int_ptr_array (current_max_dfas);
+	dfaacc = allocate_dfaacc_union (current_max_dfas);
+
+	nultrans = (int *) 0;
+}
+
+
+/* extracts basename from path, optionally stripping the extension "\.*"
+ * (same concept as /bin/sh `basename`, but different handling of extension). */
+static char *basename2 (path, strip_ext)
+     char   *path;
+     int strip_ext;		/* boolean */
+{
+	char   *b, *e = 0;
+
+	b = path;
+	for (b = path; *path; path++)
+		if (*path == '/')
+			b = path + 1;
+		else if (*path == '.')
+			e = path;
+
+	if (strip_ext && e && e > b)
+		*e = '\0';
+	return b;
+}
+
+void usage ()
+{
+	FILE   *f = stdout;
+
+	if (!did_outfilename) {
+		snprintf (outfile_path, sizeof(outfile_path), outfile_template,
+			 prefix, C_plus_plus ? "cc" : "c");
+		outfilename = outfile_path;
+	}
+
+	fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), program_name);
+	fprintf (f,
+		 _
+		 ("Generates programs that perform pattern-matching on text.\n"
+		  "\n" "Table Compression:\n"
+		  "  -Ca, --align      trade off larger tables for better memory alignment\n"
+		  "  -Ce, --ecs        construct equivalence classes\n"
+		  "  -Cf               do not compress tables; use -f representation\n"
+		  "  -CF               do not compress tables; use -F representation\n"
+		  "  -Cm, --meta-ecs   construct meta-equivalence classes\n"
+		  "  -Cr, --read       use read() instead of stdio for scanner input\n"
+		  "  -f, --full        generate fast, large scanner. Same as -Cfr\n"
+		  "  -F, --fast        use alternate table representation. Same as -CFr\n"
+		  "  -Cem              default compression (same as --ecs --meta-ecs)\n"
+		  "\n" "Debugging:\n"
+		  "  -d, --debug             enable debug mode in scanner\n"
+		  "  -b, --backup            write backing-up information to %s\n"
+		  "  -p, --perf-report       write performance report to stderr\n"
+		  "  -s, --nodefault         suppress default rule to ECHO unmatched text\n"
+		  "  -T, --trace             %s should run in trace mode\n"
+		  "  -w, --nowarn            do not generate warnings\n"
+		  "  -v, --verbose           write summary of scanner statistics to stdout\n"
+		  "\n" "Files:\n"
+		  "  -o, --outfile=FILE      specify output filename\n"
+		  "  -S, --skel=FILE         specify skeleton file\n"
+		  "  -t, --stdout            write scanner on stdout instead of %s\n"
+		  "      --yyclass=NAME      name of C++ class\n"
+		  "      --header-file=FILE   create a C header file in addition to the scanner\n"
+		  "      --tables-file[=FILE] write tables to FILE\n" "\n"
+		  "Scanner behavior:\n"
+		  "  -7, --7bit              generate 7-bit scanner\n"
+		  "  -8, --8bit              generate 8-bit scanner\n"
+		  "  -B, --batch             generate batch scanner (opposite of -I)\n"
+		  "  -i, --case-insensitive  ignore case in patterns\n"
+		  "  -l, --lex-compat        maximal compatibility with original lex\n"
+		  "  -X, --posix-compat      maximal compatibility with POSIX lex\n"
+		  "  -I, --interactive       generate interactive scanner (opposite of -B)\n"
+		  "      --yylineno          track line count in yylineno\n"
+		  "\n" "Generated code:\n"
+		  "  -+,  --c++               generate C++ scanner class\n"
+		  "  -Dmacro[=defn]           #define macro defn  (default defn is '1')\n"
+		  "  -L,  --noline            suppress #line directives in scanner\n"
+		  "  -P,  --prefix=STRING     use STRING as prefix instead of \"yy\"\n"
+		  "  -R,  --reentrant         generate a reentrant C scanner\n"
+		  "       --bison-bridge      scanner for bison pure parser.\n"
+		  "       --bison-locations   include yylloc support.\n"
+		  "       --stdinit           initialize yyin/yyout to stdin/stdout\n"
+          "       --noansi-definitions old-style function definitions\n"
+          "       --noansi-prototypes  empty parameter list in prototypes\n"
+		  "       --nounistd          do not include <unistd.h>\n"
+		  "       --noFUNCTION        do not generate a particular FUNCTION\n"
+		  "\n" "Miscellaneous:\n"
+		  "  -c                      do-nothing POSIX option\n"
+		  "  -n                      do-nothing POSIX option\n"
+		  "  -?\n"
+		  "  -h, --help              produce this help message\n"
+		  "  -V, --version           report %s version\n"),
+		 backing_name, program_name, outfile_path, program_name);
+
+}