===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/main.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -c -r1.17 -r1.18
*** src/usr.bin/lex/main.c	2015/11/19 22:35:19	1.17
--- src/usr.bin/lex/main.c	2015/11/19 22:52:40	1.18
***************
*** 1,4 ****
! /*	$OpenBSD: main.c,v 1.17 2015/11/19 22:35:19 tedu Exp $	*/
  
  /* flex - tool to generate fast lexical analyzers */
  
--- 1,4 ----
! /*	$OpenBSD: main.c,v 1.18 2015/11/19 22:52:40 tedu Exp $	*/
  
  /* flex - tool to generate fast lexical analyzers */
  
***************
*** 32,39 ****
  /*  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"
--- 32,40 ----
  /*  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"
***************
*** 43,122 ****
  
  /* 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;
! 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 const char *outfile_template = "lex.%s.%s";
--- 44,120 ----
  
  /* 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;
! 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 const char *outfile_template = "lex.%s.%s";
***************
*** 133,262 ****
  #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 ();
! 
! 	skelout ();
  	/* %% [1.5] DFA */
! 	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
  
! 	if (pledge("stdio rpath wpath cpath proc exec", NULL) == -1)
! 	{
! 		fprintf( stderr, _( "%s: pledge\n"),
! 			program_name);
  		exit(1);
  	}
! 
! 	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"));
  
  		yytext_is_array = true;
  		do_yylineno = true;
  		use_read = false;
  	}
- 
- 
  #if 0
  	/* This makes no sense whatsoever. I'm removing it. */
  	if (do_yylineno)
--- 131,261 ----
  #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();
  
! 	skelout();
  	/* %% [1.5] DFA */
! 	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
  
! 	if (pledge("stdio rpath wpath cpath proc exec", NULL) == -1) {
! 		fprintf(stderr, _("%s: pledge\n"),
! 		    program_name);
  		exit(1);
  	}
! 	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"));
  
  		yytext_is_array = true;
  		do_yylineno = true;
  		use_read = false;
  	}
  #if 0
  	/* This makes no sense whatsoever. I'm removing it. */
  	if (do_yylineno)
***************
*** 270,319 ****
  		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;
--- 269,315 ----
  		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;
***************
*** 324,332 ****
  		}
  
  		nextecm[csize] = NIL;
! 	}
! 
! 	else {
  		/* Put everything in its own equivalence class. */
  		for (i = 1; i <= csize; ++i) {
  			ecgroup[i] = i;
--- 320,326 ----
  		}
  
  		nextecm[csize] = NIL;
! 	} else {
  		/* Put everything in its own equivalence class. */
  		for (i = 1; i <= csize; ++i) {
  			ecgroup[i] = i;
***************
*** 334,391 ****
  		}
  	}
  
!     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;
  
--- 328,382 ----
  		}
  	}
  
! 	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;
  
***************
*** 395,494 ****
  
  
  	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);
!              if (!str)
!                flexfatal(_("allocation of macro definition failed"));
!              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] */
  }
  
--- 386,482 ----
  
  
  	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);
! 			if (!str)
! 				flexfatal(_("allocation of macro definition failed"));
! 			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] */
  }
  
***************
*** 498,954 ****
   *    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;
--- 486,938 ----
   *    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;
***************
*** 961,1021 ****
  	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;
--- 945,1006 ----
  	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;
***************
*** 1039,1045 ****
  				fulltbl = false;
  				sawcmpflag = true;
  			}
- 
  			for (i = 0; arg && arg[i] != '\0'; i++)
  				switch (arg[i]) {
  				case 'a':
--- 1024,1029 ----
***************
*** 1067,1075 ****
  					break;
  
  				default:
! 					lerrif (_
! 						("unknown -C option '%c'"),
! 						(int) arg[i]);
  					break;
  				}
  			break;
--- 1051,1059 ----
  					break;
  
  				default:
! 					lerrif(_
! 					    ("unknown -C option '%c'"),
! 					    (int) arg[i]);
  					break;
  				}
  			break;
***************
*** 1093,1100 ****
  			break;
  
  		case OPT_HELP:
! 			usage ();
! 			FLEX_EXIT (0);
  
  		case OPT_INTERACTIVE:
  			interactive = true;
--- 1077,1084 ----
  			break;
  
  		case OPT_HELP:
! 			usage();
! 			FLEX_EXIT(0);
  
  		case OPT_INTERACTIVE:
  			interactive = true;
***************
*** 1112,1128 ****
  			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:
--- 1096,1112 ----
  			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:
***************
*** 1175,1182 ****
  			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:
--- 1159,1166 ----
  			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:
***************
*** 1197,1204 ****
  			break;
  
  		case OPT_VERSION:
! 			printf (_("%s %s\n"), program_name, flex_version);
! 			FLEX_EXIT (0);
  
  		case OPT_WARN:
  			nowarn = false;
--- 1181,1188 ----
  			break;
  
  		case OPT_VERSION:
! 			printf(_("%s %s\n"), program_name, flex_version);
! 			FLEX_EXIT(0);
  
  		case OPT_WARN:
  			nowarn = false;
***************
*** 1225,1235 ****
  			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:
--- 1209,1219 ----
  			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:
***************
*** 1263,1287 ****
  		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;
  
--- 1247,1270 ----
  		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;
  
***************
*** 1290,1297 ****
  			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:
--- 1273,1280 ----
  			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:
***************
*** 1338,1450 ****
  			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;
--- 1321,1433 ----
  			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;
***************
*** 1452,1514 ****
  	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)
--- 1435,1501 ----
  	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)
***************
*** 1523,1565 ****
  
  	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;
  
--- 1510,1547 ----
  
  	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;
  
***************
*** 1568,1773 ****
  
  	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)
! 			 if (reentrant)
! 				outn ("\n#define yywrap(yyscanner) 1");
! 			 else
! 				outn ("\n#define yywrap() 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;
  }
--- 1550,1745 ----
  
  	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)
! 			if (reentrant)
! 				outn("\n#define yywrap(yyscanner) 1");
! 			else
! 				outn("\n#define yywrap() 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;
  }
***************
*** 1775,1785 ****
  
  /* 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++)
--- 1747,1758 ----
  
  /* 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++)
***************
*** 1793,1864 ****
  	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"
! 		  "  -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);
  
  }
--- 1766,1837 ----
  	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"
! 		"  -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);
  
  }