remove some gcc warnings

doc/Makefile.am

@@ -7,7 +7,7 @@ MAINTAINERCLEANFILES = flex.1
 CLEANFILES = *.aux *.cp *.cps *.fn *.fns *.hk *.hks *.ky *.log \
 	*.op *.ops *.pg *.toc *.tp *.tps *.vr *.vrs
 
-flex.1: $(top_srcdir)/configure.ac $(top_srcdir)/src/cpp-flex.skl $(top_srcdir)/src/options.c $(top_srcdir)/src/options.h | $(FLEX)
+flex.1: $(top_srcdir)/configure.ac $(top_srcdir)/src/flex.skl $(top_srcdir)/src/options.c $(top_srcdir)/src/options.h | $(FLEX)
 	$(HELP2MAN) --name='$(PACKAGE_NAME)' --section=1 \
 	--source='The Flex Project' --manual='Programming' \
 	--output=$@ $(FLEX) \

doc/flex.texi

@@ -192,7 +192,7 @@ FAQ
 * How can I build a two-pass scanner?::  
 * How do I match any string not matched in the preceding rules?::  
 * I am trying to port code from AT&T lex that uses yysptr and yysbuf.::  
-* Is there a way to make flex treat NUL like a regular character?::  
+* Is there a way to make flex treat NULL like a regular character?::  
 * Whenever flex can not match the input it says "flex scanner jammed".::  
 * Why doesn't flex have non-greedy operators like perl does?::  
 * Memory leak - 16386 bytes allocated by malloc.::  
@@ -269,7 +269,6 @@ Appendices
 * Bison Bridge::                
 * M4 Dependency::               
 * Common Patterns::               
-* Adding More Target Languages
 
 Indices
 
@@ -735,7 +734,7 @@ if X is @samp{a}, @samp{b}, @samp{f}, @samp{n}, @samp{r}, @samp{t}, or
 @samp{v}, then the ANSI-C interpretation of @samp{\x}.  Otherwise, a
 literal @samp{X} (used to escape operators such as @samp{*})
 
-@cindex NUL character in patterns, syntax of
+@cindex NULL character in patterns, syntax of
 @item \0
 a NUL character (ASCII code 0)
 
@@ -5149,10 +5148,10 @@ the version of flex that was used to create the serialized tables.
 
 @item th_name[]
 Contains the name of this table set. The default is @samp{yytables},
-and is prefixed accordingly, e.g., @samp{footables}. Must be NUL-terminated.
+and is prefixed accordingly, e.g., @samp{footables}. Must be NULL-terminated.
 
 @item th_pad64[]
-Zero or more NUL bytes, padding the entire header to the next 64-bit boundary
+Zero or more NULL bytes, padding the entire header to the next 64-bit boundary
 as calculated from the beginning of the header.
 @end table
 
@@ -5240,7 +5239,7 @@ The table data. This array may be a one- or two-dimensional array, of type
 @code{td_flags}, @code{td_hilen}, and @code{td_lolen} fields.
 
 @item td_pad64[]
-Zero or more NUL bytes, padding the entire table to the next 64-bit boundary as
+Zero or more NULL bytes, padding the entire table to the next 64-bit boundary as
 calculated from the beginning of this table.
 @end table
 
@@ -5448,7 +5447,7 @@ publish them here.
 * How can I build a two-pass scanner?::  
 * How do I match any string not matched in the preceding rules?::  
 * I am trying to port code from AT&T lex that uses yysptr and yysbuf.::  
-* Is there a way to make flex treat NUL like a regular character?::  
+* Is there a way to make flex treat NULL like a regular character?::  
 * Whenever flex can not match the input it says "flex scanner jammed".::  
 * Why doesn't flex have non-greedy operators like perl does?::  
 * Memory leak - 16386 bytes allocated by malloc.::  
@@ -6061,8 +6060,8 @@ what they're doing, and then replace @code{input()} with an appropriate definiti
 @code{YY_INPUT}.  You shouldn't need to (and must not) replace
 @code{flex}'s @code{unput()} function.
 
-@node Is there a way to make flex treat NUL like a regular character?
-@unnumberedsec Is there a way to make flex treat NUL like a regular character?
+@node Is there a way to make flex treat NULL like a regular character?
+@unnumberedsec Is there a way to make flex treat NULL like a regular character?
 
 Yes, @samp{\0} and @samp{\x00} should both do the trick.  Perhaps you have an ancient
 version of @code{flex}.  The latest release is version @value{VERSION}.
@@ -7698,7 +7697,6 @@ to declare local variables.
 @end example
 
 @c TODO: Evaluate this faq.
-@c Note that the file is now named cpp-flex.skl
 @node unnamed-faq-87
 @unnumberedsec unnamed-faq-87
 @example
@@ -8168,7 +8166,6 @@ See @ref{Top, , , bison, the GNU Bison Manual}.
 * Bison Bridge::                
 * M4 Dependency::               
 * Common Patterns::               
-* Retargeting Flex::
 @end menu
 
 @node Makefiles and Flex, Bison Bridge, Appendices, Appendices
@@ -8415,7 +8412,7 @@ removing such sequences from your code.
 @code{m4} is only required at the time you run @code{flex}. The generated
 scanner is ordinary C or C++, and does @emph{not} require @code{m4}.
 
-@node Common Patterns,Retargeting Flex,M4 Dependency, Appendices
+@node Common Patterns, ,M4 Dependency, Appendices
 @section Common Patterns
 @cindex patterns, common
 
@@ -8563,113 +8560,6 @@ to appear in a URI, including spaces and control characters.  See
 @end table
 
 
-@node Retargeting Flex, ,Common Patterns, Appendices
-@section Retargeting Flex
-@cindex retargeting
-@cindex language independence
-
-This appendix describes how to add support for a new target language
-to Flex.
-
-The flex code has been factored to isolate knowledge of the specifics
-of each target language from the logic for building the lexer state
-tables.
-
-The only assumption that is absolutely baked into all of Flex is that
-the bodies of initializers for arrays of integers consist of decimal
-numeric literals separated by commas (and optional whitespace).
-
-Otherwise, knowledge of each target langage's syntax lives in two
-places: (1) a table of language-specific syntax-generator methods,
-and (2) A language-specific skeleton file.
-
-For example: The methods for the C and C++ back end live in a source
-file named @file{cpp_backend.c} (so named because both languages use the C
-preprocessor), and in a skeleton file named @file{cpp-flex.skl}.
-
-All the code that accesses language-specific code generators goes
-through a global pointer named "backend" to a method table.  The
-results of these generators are used to fill in some parts of the
-language-specific skeleton file and conditionalize others.
-
-Read the definition of struct backend_t in @file{src/flexdefs.h}, and
-attached comments, to get a feel for the methods.  Don't worry
-about understandng table generator names at first.
-
-To write support for a language, you'll want to do the following
-steps:
-
-@enumerate
-@item
-Clone one of the existing back-end/skeleton pairs.  If the language
-you are supporting is named @var{foo}, you should create files named
-@file{foo_backend.c} and @file{foo-flex.skl}.
-
-@item
-Add @file{foo_backend.c} to COMMON_SOURCES in @file{src/Makefile.am}.  Add the
-name of your skeleton file to EXTRA_DIST.
-
-@item
-Add a production to @file{src/Makefile.am} parallel to the one that
-produces @file{cpp-skel.h}.  Your objective is to make a string list
-initializer from your skeleton file that can be linked with flex and
-is pointed at by the skel nember of your language back end.
-
-@item
-Add some logic to @file{main.c} that enables the new back end with a
-new command-line option.  Following this step you should be
-able to run Flex on a specification and get code out in the
-language of whatever back end you cloned.
-
-@item
-The interesting part: mutate your new back end and skeleton so they
-produce code in your desired target langage.
-
-@item
-Add a test suite for your back end.  You should be able to clone
-one of the existing sets of test loads to get good coverage.  Note
-that is highly unlikely your back end will be accepted into the
-flex distribution without a test suite.
-@end enumerate
-
-Syntactically C-like languages such as Go, Rust, and Java should be easy
-targets.  Almost anything generally descended from Algol shouldn't be
-much more difficult; this certainly includes the whole
-Pascal/Modula/Oberon family.
-
-A hint about the interesting part:
-
-@itemize
-@item
-Don't bother supporting non-reentrant parser generation.
-The interface of original Lex with all those globals hanging out
-needs to be supported in C for backwards compatibility, but
-there is no need to carry it forward.
-@end itemize
-
-The following assumptions in the code might trip you up and
-require fixes outside a back end.
-
-@enumerate
-@item
-The item separator in data initializers is a comma.
-
-@item
-The language has a case-arm syntax that looks like
-a (possibly empty) prefix, followed by a value
-expression, followed by a colon.
-
-@item
-Either case arms can be stacked as in C; that is, there is
-an implicit fallthrough if the case arm has no code. Or,
-there is an explicit fallthrough keyword that enables this,
-as in Go.
-@end enumerate
-
-By putting a @code{yyterminate()} call in the fallthrough member
-and a null pointer in the endcase member, you could handle
-languages like Pascal.
-
 @node Indices,  , Appendices, Top
 @unnumbered Indices
 

src/.gitignore

@@ -8,6 +8,6 @@ libfl.pc
 parse.c
 parse.h
 scan.c
-cpp-skel.h
+skel.c
 stage1scan.[cl]
 stage1flex

src/Makefile.am

@@ -46,7 +46,6 @@ flex_SOURCES = \
 	$(COMMON_SOURCES)
 
 nodist_flex_SOURCES = \
-	cpp-skel.h \
 	stage1scan.c
 
 flex_CFLAGS = $(AM_CFLAGS) $(WARNINGFLAGS)
@@ -54,7 +53,6 @@ flex_CFLAGS = $(AM_CFLAGS) $(WARNINGFLAGS)
 COMMON_SOURCES = \
 	buf.c \
 	ccl.c \
-	cpp_backend.c \
 	dfa.c \
 	ecs.c \
 	filter.c \
@@ -72,6 +70,7 @@ COMMON_SOURCES = \
 	scanflags.c \
 	scanopt.c \
 	scanopt.h \
+	skel.c \
 	sym.c \
 	tables.c \
 	tables.h \
@@ -89,18 +88,16 @@ include_HEADERS = \
 	FlexLexer.h
 
 EXTRA_DIST = \
-	cpp-flex.skl \
+	flex.skl \
 	mkskel.sh \
 	gettext.h
 
-CLEANFILES = stage1scan.c stage1flex$(EXEEXT) cpp-skel.h
+CLEANFILES = stage1scan.c stage1flex$(EXEEXT)
 
-MAINTAINERCLEANFILES = c9pp-skel.h
+MAINTAINERCLEANFILES = skel.c
 
-flex-cpp_backend.$(OBJEXT): cpp-skel.h
-
-cpp-skel.h: cpp-flex.skl mkskel.sh flexint_shared.h tables_shared.h tables_shared.c
-	$(SHELL) $(srcdir)/mkskel.sh cpp $(srcdir) $(m4) $(VERSION) > $@.tmp
+skel.c: flex.skl mkskel.sh flexint_shared.h tables_shared.h tables_shared.c
+	$(SHELL) $(srcdir)/mkskel.sh $(srcdir) $(m4) $(VERSION) > $@.tmp
 	mv -f $@.tmp $@
 
 if ENABLE_BOOTSTRAP

src/cpp_backend.c

@@ -1,639 +0,0 @@
-/* flex - tool to generate fast lexical analyzers */
-
-/*  Copyright (c) 1990 The Regents of the University of California. */
-/*  All rights reserved. */
-
-/*  This code is derived from software contributed to Berkeley by */
-/*  Vern Paxson. */
-
-/*  The United States Government has rights in this work pursuant */
-/*  to contract no. DE-AC03-76SF00098 between the United States */
-/*  Department of Energy and the University of California. */
-
-/*  This file is part of flex. */
-
-/*  Redistribution and use in source and binary forms, with or without */
-/*  modification, are permitted provided that the following conditions */
-/*  are met: */
-
-/*  1. Redistributions of source code must retain the above copyright */
-/*     notice, this list of conditions and the following disclaimer. */
-/*  2. Redistributions in binary form must reproduce the above copyright */
-/*     notice, this list of conditions and the following disclaimer in the */
-/*     documentation and/or other materials provided with the distribution. */
-
-/*  Neither the name of the University nor the names of its contributors */
-/*  may be used to endorse or promote products derived from this software */
-/*  without specific prior written permission. */
-
-/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
-/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
-/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
-/*  PURPOSE. */
-
-
-#include "flexdef.h"
-
-/* Code specific to the C/C++ back end starts here */
-
-static const char *cpp_suffix (void)
-{
-	char   *suffix;
-
-	if (C_plus_plus)
-	    suffix = "cc";
-	else
-	    suffix = "c";
-
-	return suffix;
-}
-
-/* cpp_prolog - make rules prolog specific to cpp-using languages.
- *
- * If you don't ship this, you will effectively be assuming that your
- * parsers are always reentrant, always allow reject, always have a
- * yywrap() method, have a debug member in the wrapper class, and are
- * interactive.  This eliminates most of the boilerplate in the C/C++
- * scanner prolog.  It means such parsers will be a bit larger and
- * slower than C/C++ ones, but since we're not running on 1987's
- * hardware we officially do not care.
- *
- * A detail to beware of: If you're not issuing this prologue, you may
- * want to write your own definition of YY_CHAR in your skel
- * file. It's a typedef to an unsigned octet in C/C++, but if your
- * target language has a Unicode code-point type like Go's 'rune' is
- * may be appropriate.
- */
-
-static void cpp_prolog (void)
-{
-	static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
-	static char yy_nostdinit[] =
-		"FILE *yyin = NULL, *yyout = NULL;";
-
-	if (!do_yywrap) {
-		if (!C_plus_plus) {
-			 if (reentrant)
-				out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
-			 else
-				out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
-		}
-		outn ("#define YY_SKIP_YYWRAP");
-	}
-
-	if (ddebug)
-		outn ("\n#define FLEX_DEBUG");
-
-	OUT_BEGIN_CODE ();
-	outn ("typedef flex_uint8_t 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 const 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("#ifdef yytext_ptr");
-				outn("#undef yytext_ptr");
-				outn("#endif");
-				outn ("#define yytext_ptr yytext");
-			}
-		}
-
-		if (yyclass)
-			flexerror (_
-				   ("%option yyclass only meaningful for C++ scanners"));
-	}
-}
-
-static void cpp_epilog (void)
-{
-#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",
-                "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",
-                "const",
-                "yyextra",
-                "yyfree",
-                "yyget_debug",
-                "yyget_extra",
-                "yyget_in",
-                "yyget_leng",
-                "yyget_column",
-                "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_column",
-                "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))
-		lerr (_("error creating header file %s"),
-			headerfilename);
-	fflush (header_out);
-	fclose (header_out);
-#endif
-}
-
-static const char *cpp_yy_int_aligned(void)
-{
-	return long_align ? "long int" : "short int";
-}
-
-static void cpp_comment(const char *txt)
-{
-	out_str("/* [[%s]] */\n", txt);
-}
-
-static const char *cpp_get_int16_decl (void)
-{
-	return (gentables)
-		? "static const flex_int16_t %s[%d] =\n    {   0,\n"
-		: "static const flex_int16_t * %s = 0;\n";
-}
-
-
-static const char *cpp_get_int32_decl (void)
-{
-	return (gentables)
-		? "static const flex_int32_t %s[%d] =\n    {   0,\n"
-		: "static const flex_int32_t * %s = 0;\n";
-}
-
-static const char *cpp_get_state_decl (void)
-{
-	return (gentables)
-		? "static const yy_state_type %s[%d] =\n    {   0,\n"
-		: "static const yy_state_type * %s = 0;\n";
-}
-
-static const char *cpp_get_yy_char_decl (void)
-{
-	return (gentables)
-		? "static const YY_CHAR %s[%d] =\n    {   0,\n"
-		: "static const YY_CHAR * %s = 0;\n";
-}
-
-static void cpp_ntod(size_t num_full_table_rows)
-// Generate nxt table for ntod
-{
-	buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
-		    long_align ? "flex_int32_t" : "flex_int16_t");
-
-	/* Unless -Ca, declare it "short" because it's a real
-	 * long-shot that that won't be large enough.
-	 */
-	if (gentables)
-		out_str_dec
-			("static const %s yy_nxt[][%d] =\n    {\n",
-			 long_align ? "flex_int32_t" : "flex_int16_t",
-			 num_full_table_rows);
-	else {
-		out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
-		out_str ("static const %s *yy_nxt =0;\n",
-			 long_align ? "flex_int32_t" : "flex_int16_t");
-	}
-}
-
-static void cpp_mkeoltbl()
-// Make end-of-line-table - only used when yylinemo tracking is on
-{
-	buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n",
-		    "flex_int32_t");
-}
-
-static void cpp_geneoltbl(size_t sz)
-// Generate end-of-line-transitions - only used when yylineno tracking is on
-{
-	outn ("/* Table of booleans, true if rule could match eol. */");
-	out_str_dec (cpp_get_int32_decl (), "yy_rule_can_match_eol", sz);
-}
-
-static void cpp_mkctbl (size_t sz)
-// Make full-speed compressed transition table
-{
-	buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n",
-		    (sz >= INT16_MAX
-		     || long_align) ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_mkssltbl (void)
-// Make start_state_list table
-{
-	buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n",
-		    "struct yy_trans_info*");
-}
-
-static void cpp_gen_yy_trans(size_t sz)
-// Table of verify for transition and offset to next state. (sic)
-{
-	if (gentables)
-		out_dec ("static const struct yy_trans_info yy_transition[%d] =\n    {\n", sz);
-	else
-		outn ("static const struct yy_trans_info *yy_transition = 0;");
-}
-
-static void cpp_start_state_list(size_t sz)
-// Start initializer for table of pointers to start state
-{
-	/* Table of pointers to start states. */
-	if (gentables)
-		out_dec ("static const struct yy_trans_info *yy_start_state_list[%d] =\n", sz);
-	else
-		outn ("static const struct yy_trans_info **yy_start_state_list =0;");
-}
-
-static void cpp_mkecstbl(void)
-// Make equivalence-class tables
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n",
-		"YY_CHAR");
-}
-
-static void cpp_mkftbl(void)
-// Make full table
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
-		long_align ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_acclist(void)
-// Generate accept list initializer
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n",
-		long_align ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_accept(void)
-// Generate accept table initializer
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
-		long_align ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_yy_meta(void)
-// Generate yy_meta table initializer
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n",
-		"YY_CHAR");
-}
-
-static void cpp_gentabs_yy_base(void)
-// Generate yy_meta base initializer
-{
-    buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n",
-		    (tblend >= INT16_MAX
-		     || long_align) ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_yy_def(size_t total_states)
-// Generate yy_def initializer
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n",
-		(total_states >= INT16_MAX
-		 || long_align) ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_yy_nxt(size_t total_states)
-// Generate yy_nxt initializer
-{
-    buf_prints (&yydmap_buf,
-		    "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
-		    (total_states >= INT16_MAX
-		     || long_align) ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_gentabs_yy_chk(size_t total_states)
-// Generate yy_chk initializer
-{
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n",
-		(total_states >= INT16_MAX
-		 || long_align) ? "flex_int32_t" : "flex_int16_t");
-}
-
-static void cpp_nultrans(int fullspd)
-// Generate nulltrans initializer
-{
-    // Making this a backend method may be overzealous.
-    // How many other languages have to sprcial-case NUL
-    // because it's a string terminator?
-    buf_prints (&yydmap_buf,
-		"\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n",
-		(fullspd) ? "struct yy_trans_info*" :
-		"flex_int32_t");
-}
-
-static const char *cpp_trans_offset_type(int total_table_size)
-{
-	return (total_table_size >= INT16_MAX || long_align) ?
-			"flex_int32_t" : "flex_int16_t";
-}
-
-const char *cpp_skel[] = {
-#include "cpp-skel.h"
-    0,
-};
-
-/* This backend is only accessed through this method table */
-struct flex_backend_t cpp_backend = {
-	.suffix = cpp_suffix,
-	.prolog = cpp_prolog,
-	.skel = cpp_skel,
-	.epilog = cpp_epilog,
-	.yy_int_aligned = cpp_yy_int_aligned,
-	.trace_fmt = "#line %d \"%s\"\n",
-	.int_define_fmt = "#define %s %d\n",
-	.string_define_fmt = "#define %s %s\n",
-	.table_opener = "    {",
-	.table_continuation = "    },\n",
-	.table_closer = "    };\n",
-	.dyad = " {%4d,%4d },",
-	.comment = cpp_comment,
-	.get_int16_decl = cpp_get_int16_decl,
-	.get_int32_decl = cpp_get_int32_decl,
-	.get_state_decl = cpp_get_state_decl,
-	.get_yy_char_decl = cpp_get_yy_char_decl,
-	.ntod = cpp_ntod,
-	.mkeoltbl = cpp_mkeoltbl,
-	.geneoltbl = cpp_geneoltbl,
-	.mkctbl = cpp_mkctbl,
-	.mkssltbl = cpp_mkssltbl,
-	.gen_yy_trans = cpp_gen_yy_trans,
-	.start_state_list = cpp_start_state_list,
-	.state_entry_fmt = "    &yy_transition[%d],\n",
-	.mkecstbl = cpp_mkecstbl,
-	.mkftbl = cpp_mkftbl,
-	.gentabs_acclist = cpp_gentabs_acclist,
-	.gentabs_accept = cpp_gentabs_accept,
-	.gentabs_yy_meta = cpp_gentabs_yy_meta,
-	.gentabs_yy_base = cpp_gentabs_yy_base,
-	.gentabs_yy_def = cpp_gentabs_yy_def,
-	.gentabs_yy_nxt = cpp_gentabs_yy_nxt,
-	.gentabs_yy_chk = cpp_gentabs_yy_chk,
-	.nultrans = cpp_nultrans,
-	.trans_offset_type = cpp_trans_offset_type,
-	.caseprefix = "case ",
-	.fallthrough = NULL,
-	.endcase = "yyterminate();",
-	.c_like = 1,
-};

src/dfa.c

@@ -517,10 +517,27 @@ void ntod (void)
 					    sizeof (flex_int32_t));
 		yynxt_curr = 0;
 
-		backend->ntod(num_full_table_rows);
+		buf_prints (&yydmap_buf,
+			    "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
+			    long_align ? "flex_int32_t" : "flex_int16_t");
+
+		/* Unless -Ca, declare it "short" because it's a real
+		 * long-shot that that won't be large enough.
+		 */
+		if (gentables)
+			out_str_dec
+				("static const %s yy_nxt[][%d] =\n    {\n",
+				 long_align ? "flex_int32_t" : "flex_int16_t",
+				 num_full_table_rows);
+		else {
+			out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
+			out_str ("static const %s *yy_nxt =0;\n",
+				 long_align ? "flex_int32_t" : "flex_int16_t");
+		}
+
 
 		if (gentables)
-			outn (backend->table_opener);
+			outn ("    {");
 
 		/* Generate 0 entries for state #0. */
 		for (i = 0; i < num_full_table_rows; ++i) {
@@ -530,7 +547,7 @@ void ntod (void)
 
 		dataflush ();
 		if (gentables)
-			outn (backend->table_continuation);
+			outn ("    },\n");
 	}
 
 	/* Create the first states. */
@@ -683,8 +700,10 @@ void ntod (void)
 						     yynxt_tbl->td_hilen *
 						     yynxt_tbl->td_lolen *
 						     sizeof (flex_int32_t));
+
+
 			if (gentables)
-				outn (backend->table_opener);
+				outn ("    {");
 
 			/* Supply array's 0-element. */
 			if (ds == end_of_buffer_state) {
@@ -709,7 +728,7 @@ void ntod (void)
 
 			dataflush ();
 			if (gentables)
-				out (backend->table_continuation);
+				outn ("    },\n");
 		}
 
 		else if (fullspd)

src/flexdef.h

@@ -303,56 +303,6 @@
  */
 #define MAX_SHORT 32700
 
-/* Method table describing a language-specific back end */
-
-struct flex_backend_t {
-	const char *(*suffix)(void);		// Generate suffix for lexer source code
-	void (*prolog)(void);
-	const char **skel;
-	void (*epilog)(void);
-	const char *(*yy_int_aligned)(void);	// Generate aligned type for this back end
-	char *trace_fmt;			// Trace message format
-	// Language syntax generation
-	char *int_define_fmt;			// Format for integer constant definitions
-	char *string_define_fmt;		// Format for string constant definitions
-	char *table_opener;			// Open an array initializer with this
-	char *table_continuation;		// Open an array initializer with this
-	char *table_closer;			// How to continue a two-level initializer
-	char *dyad;				// How to format and int[2] initializer 
-	void (*comment)(const char *);		// Wrap a comment line
-	const char *(*get_int16_decl)(void);	// Format for declaring array initializer of int16s
-	const char *(*get_int32_decl)(void);	// Format for declaring array initializer of int32s
-	const char *(*get_state_decl)(void);	// Format for declaring array initializer of state values
-	const char *(*get_yy_char_decl)(void);	// Format for declaring array initializer of input chars
-	// Flex table generation
-	void (*ntod)(size_t);			// Generate nxt table for ntod
-	void (*mkeoltbl)(void);			// Make end-of-line table
-	void (*geneoltbl)(size_t);		// Generate end-of-line transitions
-	void (*mkctbl)(size_t);			// Make full-speed compressed table
-	void (*mkssltbl)(void);			// Make start_state_list table
-	void (*gen_yy_trans)(size_t);		// Table of verify for transition and offset to next state. (sic)
-	void (*start_state_list)(size_t);	// Start initializer for table of pointers to start states
-	void (*mkftbl)();			// Make full table
-	const char *state_entry_fmt;		// Format of state table entry
-	void (*mkecstbl)(void);			// Make equivalence-class tables
-	void (*gentabs_acclist)(void);		// Generate accept list initializer
-	void (*gentabs_accept)(void);		// Generate accept table initializer
-	void (*gentabs_yy_meta)(void);		// Generate yy_meta table initializer
-	void (*gentabs_yy_base)(void);		// Generate yy_base table initializer
-	void (*gentabs_yy_def)(size_t);		// Generate yy_def initializer
-	void (*gentabs_yy_nxt)(size_t);		// Generate yy_nxt initializer
-	void (*gentabs_yy_chk)(size_t);		// Generate yy_chk initializer
-	void (*nultrans)(int);			// Generate nulltrans initializer
-	const char *(*trans_offset_type)(int);	// Compute an efficient type for transition tables
-	char *caseprefix;			// Prefix of an arm in the language's case construct
-	char *fallthrough;			// Finish a case arm with this to fall through
-	char *endcase;				// What to ship after all EOF-state case arms
-	int c_like;				// Will &yy_transition[%d]," produce a pointer table entry?
-};
-
-extern bool gentables;
-
-extern struct flex_backend_t cpp_backend;
 
 /* Declarations for global variables. */
 
@@ -419,8 +369,6 @@ extern int yymore_used, reject, real_reject, continued_action, in_rule;
 extern int yymore_really_used, reject_really_used;
 extern int trace_hex;
 
-extern struct flex_backend_t *backend;
-
 /* Variables used in the flex input routines:
  * datapos - characters on current output line
  * dataline - number of contiguous lines of data in current data
@@ -784,11 +732,34 @@ extern void mkechar(int, int[], int[]);
 
 extern void do_indent(void);	/* indent to the current level */
 
+/* Generate the code to keep backing-up information. */
+extern void gen_backing_up(void);
+
+/* Generate the code to perform the backing up. */
+extern void gen_bu_action(void);
+
 /* Generate full speed compressed transition table. */
 extern void genctbl(void);
 
-/* generate full transition table */
-extern void genftbl(void);
+/* Generate the code to find the action number. */
+extern void gen_find_action(void);
+
+extern void genftbl(void);	/* generate full transition table */
+
+/* Generate the code to find the next compressed-table state. */
+extern void gen_next_compressed_state(char *);
+
+/* Generate the code to find the next match. */
+extern void gen_next_match(void);
+
+/* Generate the code to find the next state. */
+extern void gen_next_state(int);
+
+/* Generate the code to make a NUL transition. */
+extern void gen_NUL_trans(void);
+
+/* Generate the code to find the start state. */
+extern void gen_start_state(void);
 
 /* Generate data statements for the transition tables. */
 extern void gentabs(void);

src/main.c

@@ -46,6 +46,7 @@ void flexinit(int, char **);
 void readin(void);
 void set_up_initial_allocations(void);
 
+
 /* 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,
@@ -106,8 +107,6 @@ jmp_buf flex_main_jmp_buf;
 bool   *rule_has_nl, *ccl_has_nl;
 int     nlch = '\n';
 
-struct flex_backend_t *backend;
-
 bool    tablesext, tablesverify, gentables;
 char   *tablesfilename=0,*tablesname=0;
 struct yytbl_writer tableswr;
@@ -170,9 +169,6 @@ int flex_main (int argc, char *argv[])
 
 	readin ();
 
-	if (backend->prolog)
-		backend->prolog ();
-
 	skelout ();
 	/* %% [1.5] DFA */
 	ntod ();
@@ -321,8 +317,15 @@ void check_options (void)
 		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, backend->suffix());
+				 prefix, suffix);
 
 			outfilename = outfile_path;
 		}
@@ -454,44 +457,42 @@ void check_options (void)
 		buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
 
 	/* Create the alignment type. */
-	buf_strdefine (&userdef_buf, "YY_INT_ALIGNED", backend->yy_int_aligned());
+	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 = backend->int_define_fmt;
-		 size_t strsz;
+    /* 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;
 
-		 strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2;
-		 str = malloc(strsz);
-		 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);
-	}
+             strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2;
+             str = malloc(strsz);
+             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. */
+    /* This is where we begin writing to the file. */
 
-	/* Dump the %top code. */
-	if( top_buf.elts)
-	    outn((char*) top_buf.elts);
+    /* 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. */
+    /* 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. */
-	if (gen_line_dirs && backend->trace_fmt) {
-		char buf2[4096];
-		snprintf(buf2, sizeof(buf2), backend->trace_fmt, 0, "M4_YY_OUTFILE_NAME");
-		outn(buf2);
-	}
+    /* Place a bogus line directive, it will be fixed in the filter. */
+    if (gen_line_dirs)
+        outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
 
 	/* Dump the user defined preproc directives. */
 	if (userdef_buf.elts)
@@ -525,8 +526,193 @@ void flexend (int exit_status)
 				skelname);
 	}
 
-	if (backend->epilog)
-		backend->epilog();
+#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",
+                "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",
+                "const",
+                "yyextra",
+                "yyfree",
+                "yyget_debug",
+                "yyget_extra",
+                "yyget_in",
+                "yyget_leng",
+                "yyget_column",
+                "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_column",
+                "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))
+			lerr (_("error creating header file %s"),
+				headerfilename);
+		fflush (header_out);
+		fclose (header_out);
+#endif
 
 	if (exit_status != 0 && outfile_created) {
 		if (ferror (stdout))
@@ -1089,16 +1275,24 @@ void flexinit (int argc, char **argv)
 			{
 				/* arg is "symbol" or "symbol=definition". */
 				char   *def;
-				char buf2[4096];
 
 				for (def = arg;
-				     *def != '\0' && *def != '='; ++def)
-				    continue;
-				if (*def == '\0')
-				    def = "1";
+				     *def != '\0' && *def != '='; ++def) ;
 
-				snprintf(buf2, sizeof(buf2), backend->string_define_fmt, arg, def);
-				buf_strappend (&userdef_buf, buf2);
+				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,
+							(int) (def - arg));
+					buf_strappend (&userdef_buf, " ");
+					buf_strappend (&userdef_buf,
+						       def + 1);
+					buf_strappend (&userdef_buf, "\n");
+				}
 			}
 			break;
 
@@ -1280,8 +1474,6 @@ void flexinit (int argc, char **argv)
 	lastprot = 1;
 
 	set_up_initial_allocations ();
-
-	backend = &cpp_backend;
 }
 
 
@@ -1289,6 +1481,10 @@ void flexinit (int argc, char **argv)
 
 void readin (void)
 {
+	static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
+	static char yy_nostdinit[] =
+		"FILE *yyin = NULL, *yyout = NULL;";
+
 	line_directive_out(NULL, 1);
 
 	if (yyparse ()) {
@@ -1398,6 +1594,131 @@ void readin (void)
 				   ("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)
+				out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
+			 else
+				out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
+		}
+		outn ("#define YY_SKIP_YYWRAP");
+	}
+
+	if (ddebug)
+		outn ("\n#define FLEX_DEBUG");
+
+	OUT_BEGIN_CODE ();
+	outn ("typedef flex_uint8_t 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 const 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("#ifdef yytext_ptr");
+				outn("#undef yytext_ptr");
+				outn("#endif");
+				outn ("#define yytext_ptr yytext");
+			}
+		}
+
+		if (yyclass)
+			flexerror (_
+				   ("%option yyclass only meaningful for C++ scanners"));
+	}
+
 	if (useecs)
 		numecs = cre8ecs (nextecm, ecgroup, csize);
 	else
@@ -1411,6 +1732,7 @@ void readin (void)
 		ccl2ecl ();
 }
 
+
 /* set_up_initial_allocations - allocate memory for internal tables */
 
 void set_up_initial_allocations (void)
@@ -1541,4 +1863,3 @@ void usage (void)
 		 backing_name, "flex", outfile_path, "flex");
 
 }
-

src/misc.c

@@ -260,7 +260,7 @@ void dataend (void)
 			dataflush ();
 
 		/* add terminator for initialization; { for vi */
-		outn (backend->table_closer);
+		outn ("    } ;\n");
 	}
 	dataline = 0;
 	datapos = 0;
@@ -343,6 +343,7 @@ void line_directive_out (FILE *output_file, int do_infile)
 {
 	char    directive[MAXLINE*2], filename[MAXLINE];
 	char   *s1, *s2, *s3;
+	static const char line_fmt[] = "#line %d \"%s\"\n";
 
 	if (!gen_line_dirs)
 		return;
@@ -365,12 +366,11 @@ void line_directive_out (FILE *output_file, int do_infile)
 
 	*s2 = '\0';
 
-	if (backend->trace_fmt)
-		if (do_infile)
-			snprintf (directive, sizeof(directive), backend->trace_fmt, linenum, filename);
-		else {
-			snprintf (directive, sizeof(directive), backend->trace_fmt, 0, filename);
-		}
+	if (do_infile)
+		snprintf (directive, sizeof(directive), line_fmt, linenum, filename);
+	else {
+		snprintf (directive, sizeof(directive), line_fmt, 0, filename);
+	}
 
 	/* If output_file is nil then we should put the directive in
 	 * the accumulated actions.
@@ -702,11 +702,11 @@ void skelout (void)
 
 
 	/* Loop pulling lines either from the skelfile, if we're using
-	 * one, or from the selected back end's skel[] array.
+	 * one, or from the skel[] array.
 	 */
 	while (skelfile ?
 	       (fgets (buf, MAXLINE, skelfile) != NULL) :
-	       ((buf = (char *) backend->skel[skel_ind++]) != 0)) {
+	       ((buf = (char *) skel[skel_ind++]) != 0)) {
 
 		if (skelfile)
 			chomp (buf);
@@ -827,7 +827,7 @@ void transition_struct_out (int element_v, int element_n)
 	if (!gentables)
 		return;
 
-	out_dec2 (backend->dyad, element_v, element_n);
+	out_dec2 (" {%4d,%4d },", element_v, element_n);
 
 	datapos += TRANS_STRUCT_PRINT_LENGTH;
 

src/mkskel.sh

@@ -21,14 +21,18 @@
 #  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 #  PURPOSE.
 
-if test ! $# = 4; then
-   echo 'Usage: mkskel.sh lang srcdir m4 version' >&2
+if test ! $# = 3; then
+   echo 'Usage: mkskel.sh srcdir m4 version' >&2
    exit 1
 fi
-lang=$1
-srcdir=$2
-m4=$3
-VERSION=$4
+echo '/* File created from flex.skl via mkskel.sh */
+
+#include "flexdef.h"
+
+const char *skel[] = {'
+srcdir=$1
+m4=$2
+VERSION=$3
 case $VERSION in
    *[!0-9.]*) echo 'Invalid version number' >&2; exit 1;;
 esac
@@ -36,7 +40,7 @@ IFS=.
 set $VERSION
 sed 's/4_/a4_/g
 s/m4preproc_/m4_/g
-' "$srcdir/${lang}-flex.skl" |
+' "$srcdir/flex.skl" |
 "$m4" -P -I "$srcdir" "-DFLEX_MAJOR_VERSION=$1" \
    "-DFLEX_MINOR_VERSION=$2" \
    "-DFLEX_SUBMINOR_VERSION=$3" |
@@ -45,3 +49,6 @@ s/m4_/m4preproc_/g
 s/a4_/4_/g
 s/[\\"]/\\&/g
 s/[^\r]*/  "&",/'
+
+echo '  0
+};'

tests/Makefile.am

@@ -334,15 +334,13 @@ pthread_pthread_LDADD = @LIBPTHREAD@
 
 # specify how to process .l files in order to test the flex built by make all
 
-TESTOPTS = -L
-
 FLEX = $(top_builddir)/src/flex
 
 .l.c: $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) -o $@ $<
+	$(AM_V_LEX)$(FLEX) -o $@ $<
 
 .ll.cc: $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) -+ -o $@ $<
+	$(AM_V_LEX)$(FLEX) -+ -o $@ $<
 
 bison_nr_main.$(OBJEXT): bison_nr_parser.h bison_nr_scanner.h
 bison_nr_scanner.$(OBJEXT): bison_nr_parser.h
@@ -369,7 +367,7 @@ bison_yylval_scanner.h: bison_yylval_scanner.c
 # so we explicitly sayhow, using the .lll suffix for the lex input file
 
 .lll.cc: $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) -o $@ $<
+	$(AM_V_LEX)$(FLEX) -o $@ $<
 
 header_nr_main.$(OBJEXT): header_nr_scanner.h
 
@@ -404,16 +402,16 @@ multiple_scanners_r_2.h: multiple_scanners_r_2.c
 	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
 
 posixly_correct.c: posixly_correct.l $(FLEX)
-	$(AM_V_LEX)POSIXLY_CORRECT=1 $(FLEX) $(TESTOPTS) -o $@ $<
+	$(AM_V_LEX)POSIXLY_CORRECT=1 $(FLEX) -o $@ $<
 
 reject_nr.reject.c: reject.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -o $@ $<
 
 reject_nr.reject$(EXEEXT): reject_nr.reject.$(OBJEXT)
 	$(AM_V_CCLD)$(LINK) $^
 
 reject_r.reject.c: reject.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape --reentrant -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape --reentrant -o $@ $<
 
 reject_r.reject.$(OBJEXT): reject_r.reject.c
 	$(AM_V_CC)$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
@@ -422,7 +420,7 @@ reject_r.reject$(EXEEXT): reject_r.reject.$(OBJEXT)
 	$(AM_V_CCLD)$(LINK) $^
 
 reject_ver.table.c: reject.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -o $@ --tables-verify --tables-file=$(basename $@).tables $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -o $@ --tables-verify --tables-file=$(basename $@).tables $<
 
 reject_ver.table.$(OBJEXT): reject_ver.table.c
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
@@ -431,7 +429,7 @@ reject_ver.table$(EXEEXT): reject_ver.table.$(OBJEXT)
 	$(AM_V_CCLD)$(LINK) $^
 
 reject_ser.table.c: reject.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) -o $@ --unsafe-no-m4-sect3-escape --tables-file=$(basename $@).tables $<
+	$(AM_V_LEX)$(FLEX) -o $@ --unsafe-no-m4-sect3-escape --tables-file=$(basename $@).tables $<
 
 reject_ser.table.$(OBJEXT): reject_ser.table.c
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
@@ -465,13 +463,13 @@ OPT_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
 AM_OPT_LOG_FLAGS = -d $(srcdir) -i $(srcdir)/tableopts.txt -r
 
 tableopts_opt_nr%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) $(*:_F=F) -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) $(*:_F=F) -o $@ $<
 
 tableopts_opt_nr%.$(OBJEXT): tableopts_opt_nr%.c 
 	$(AM_V_CC)$(COMPILE) -c -o $@ $<
 
 tableopts_opt_r%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --reentrant $(subst _F,F,$*)  -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --reentrant $(subst _F,F,$*)  -o $@ $<
 
 tableopts_opt_r%.$(OBJEXT):  tableopts_opt_r%.c 
 	$(AM_V_CC)$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
@@ -480,13 +478,13 @@ SER_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
 AM_SER_LOG_FLAGS = -d $(builddir) -i $(srcdir)/tableopts.txt -r -t
 
 tableopts_ser_nr%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables"  $(subst _F,F,$*) -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables"  $(subst _F,F,$*) -o $@ $<
 
 tableopts_ser_nr%.$(OBJEXT): tableopts_ser_nr%.c 
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
 
 tableopts_ser_r%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $(subst _F,F,$*)  -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $(subst _F,F,$*)  -o $@ $<
 
 tableopts_ser_r%.$(OBJEXT):  tableopts_ser_r%.c
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<
@@ -495,7 +493,7 @@ VER_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
 AM_VER_LOG_FLAGS = -d $(builddir) -i $(srcdir)/tableopts.txt -r -t
 
 tableopts_ver_nr%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $(subst _F,F,$*) -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $(subst _F,F,$*) -o $@ $<
 
 tableopts_ver_nr%.$(OBJEXT): tableopts_ver_nr%.c 
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
@@ -504,7 +502,7 @@ tableopts_ver_nr%.ver$(EXEEXT): tableopts_ver_nr%.$(OBJEXT)
 	$(AM_V_CCLD)$(LINK) -o $@ $^
 
 tableopts_ver_r%.c: tableopts.l4 $(FLEX)
-	$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $(subst _F,F,$*)  -o $@ $<
+	$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $(subst _F,F,$*)  -o $@ $<
 
 tableopts_ver_r%.$(OBJEXT):  tableopts_ver_r%.c  
 	$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<