Flex version 2.4.7 from LBLvendor/flex/2.4.7

Reviewed by:	Geoff.

28 files changed, 19354 insertions, 0 deletions

diff --git a/usr.bin/lex/COPYING b/usr.bin/lex/COPYING
new file mode 100644
index 000000000000..dcb775e7c606
--- /dev/null
+++ b/usr.bin/lex/COPYING
@@ -0,0 +1,38 @@
+Flex carries the copyright used for BSD software, slightly modified
+because it originated at the Lawrence Berkeley (not Livermore!) Laboratory,
+which operates under a contract with the Department of Energy:
+
+	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.
+
+	Redistribution and use in source and binary forms are permitted
+	provided that: (1) source distributions retain this entire
+	copyright notice and comment, and (2) distributions including
+	binaries display the following acknowledgement:  ``This product
+	includes software developed by the University of California,
+	Berkeley and its contributors'' in the documentation or other
+	materials provided with the distribution and in all advertising
+	materials mentioning features or use of this software.  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.
+
+This basically says "do whatever you please with this software except
+remove this notice or take advantage of the University's (or the flex
+authors') name".
+
+Note that the "flex.skl" scanner skeleton carries no copyright notice.
+You are free to do whatever you please with scanners generated using flex;
+for them, you are not even bound by the above copyright.
diff --git a/usr.bin/lex/FlexLexer.h b/usr.bin/lex/FlexLexer.h
new file mode 100644
index 000000000000..feb40b66265d
--- /dev/null
+++ b/usr.bin/lex/FlexLexer.h
@@ -0,0 +1,175 @@
+// $Header: FlexLexer.h,v 1.2 94/01/04 14:57:26 vern Exp $
+
+// FlexLexer.h -- define classes for lexical analyzers generated by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+// Redistribution and use in source and binary forms are permitted provided
+// that: (1) source distributions retain this entire copyright notice and
+// comment, and (2) distributions including binaries display the following
+// acknowledgement:  ``This product includes software developed by the
+// University of California, Berkeley and its contributors'' in the
+// documentation or other materials provided with the distribution and in
+// all advertising materials mentioning features or use of this software.
+// 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.
+
+#ifndef __FLEX_LEXER_H
+#define __FLEX_LEXER_H
+
+
+// This file defines two classes.  The first, FlexLexer, is an abstract
+// class which specifies the external interface provided to flex C++
+// lexer objects.  The second, yyFlexLexer, fills out most of the meat
+// of the lexer class; its internals may vary from lexer to lexer
+// depending on things like whether REJECT is used.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.
+
+#include <iostream.h>
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+	virtual ~FlexLexer()	{ }
+
+	const char* YYText()	{ return yytext; }
+	int YYLeng()		{ return yyleng; }
+
+	virtual void
+		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( istream* s, int size ) = 0;
+	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+	virtual void yyrestart( istream* s ) = 0;
+
+	virtual int yylex() = 0;
+
+protected:
+	char* yytext;
+	int yyleng;
+};
+
+
+class yyFlexLexer : public FlexLexer {
+public:
+	// arg_yyin and arg_yyout default to the cin and cout, but we
+	// only make that assignment when initializing in yylex().
+	yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
+		{
+		yyin = arg_yyin;
+		yyout = arg_yyout;
+		yy_c_buf_p = 0;
+		yy_init = 1;
+		yy_start = 0;
+
+		yy_did_buffer_switch_on_eof = 0;
+
+		yy_looking_for_trail_begin = 0;
+		yy_more_flag = 0;
+		yy_more_len = 0;
+
+		yy_start_stack_ptr = yy_start_stack_depth = 0;
+		yy_start_stack = 0;
+
+		yy_current_buffer = 0;
+
+#ifdef YY_USES_REJECT
+		yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
+#else
+		yy_state_buf = 0;
+#endif
+		}
+
+	virtual ~yyFlexLexer()
+		{
+		delete yy_state_buf;
+		}
+
+	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+	struct yy_buffer_state* yy_create_buffer( istream* s, int size );
+	void yy_delete_buffer( struct yy_buffer_state* b );
+	void yyrestart( istream* s );
+
+	virtual int yylex();
+
+protected:
+	virtual int LexerInput( char* buf, int max_size );
+	virtual void LexerOutput( const char* buf, int size );
+	virtual void LexerError( const char* msg );
+
+	void yyunput( int c, char* buf_ptr );
+	int yyinput();
+
+	void yy_load_buffer_state();
+	void yy_init_buffer( struct yy_buffer_state* b, istream* s );
+
+	int yy_start_stack_ptr;
+	int yy_start_stack_depth;
+	int* yy_start_stack;
+
+	void yy_push_state( int new_state );
+	void yy_pop_state();
+	int yy_top_state();
+
+	yy_state_type yy_get_previous_state();
+	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+	int yy_get_next_buffer();
+
+	istream* yyin;	// input source for default LexerInput
+	ostream* yyout;	// output sink for default LexerOutput
+
+	struct yy_buffer_state* yy_current_buffer;
+
+	// yy_hold_char holds the character lost when yytext is formed.
+	char yy_hold_char;
+
+	// Number of characters read into yy_ch_buf.
+	int yy_n_chars;
+
+	// Points to current character in buffer.
+	char* yy_c_buf_p;
+
+	int yy_init;		// whether we need to initialize
+	int yy_start;		// start state number
+
+	// Flag which is used to allow yywrap()'s to do buffer switches
+	// instead of setting up a fresh yyin.  A bit of a hack ...
+	int yy_did_buffer_switch_on_eof;
+
+	// The following are not always needed, but may be depending
+	// on use of certain flex features (like REJECT or yymore()).
+
+	yy_state_type yy_last_accepting_state;
+	char* yy_last_accepting_cpos;
+
+	yy_state_type* yy_state_buf;
+	yy_state_type* yy_state_ptr;
+
+	char* yy_full_match;
+	int* yy_full_state;
+	int yy_full_lp;
+
+	int yy_lp;
+	int yy_looking_for_trail_begin;
+
+	int yy_more_flag;
+	int yy_more_len;
+};
+
+}
+
+#endif
diff --git a/usr.bin/lex/Makefile b/usr.bin/lex/Makefile
new file mode 100644
index 000000000000..7f88e6eea4de
--- /dev/null
+++ b/usr.bin/lex/Makefile
@@ -0,0 +1,57 @@
+# $Id$
+#
+# By default, flex will be configured to generate 8-bit scanners only if the
+# -8 flag is given.  If you want it to always generate 8-bit scanners, add
+# "-DDEFAULT_CSIZE=256" to CFLAGS.  Note that doing so will double the size
+# of all uncompressed scanners.
+#
+# Bootstrapping of lex is handled automatically.
+# ALso note that flex.skel no longer gets installed.
+#
+# XXX Todo:
+#	Install as lex++, and install FlexLexer.h
+
+PROG=		lex
+LINKS=		${BINDIR}/lex ${BINDIR}/flex 
+#LINKS+=	${BINDIR}/lex ${BINDIR}/lex++ ${BINDIR}/flex ${BINDIR}/flex++
+
+SRCS=		ccl.c dfa.c ecs.c gen.c main.c misc.c nfa.c parse.y \
+		skel.c sym.c tblcmp.c yylex.c
+OBJS+=		scan.o
+LFLAGS+=	-is
+CFLAGS+=	-I. -I${.CURDIR}
+MAN1=		flex.1 flexdoc.1
+MLINKS=		flex.1 lex.1 flexdoc.1 lexdoc.1
+
+CLEANFILES+=	parse.c parse.h scan.c y.tab.h
+
+
+SUBDIR=		lib
+
+.depend: parse.h
+
+parse.c parse.h: parse.y
+	$(YACC) -d $(.CURDIR)/parse.y
+	mv y.tab.c parse.c
+	mv y.tab.h parse.h
+
+.if exists(/usr/bin/lex)
+scan.o:	parse.c
+.else
+# We must bootstrap
+scan.o: scan.c parse.h
+
+scan.c:
+	@echo "Bootstrapping flex"
+	@rm -f scan.c
+	@cp -pf ${.CURDIR}/initscan.c scan.c
+.endif
+
+test: check
+check: $(PROG)
+	./$(PROG) $(LFLAGS) -t $(COMPRESSION) $(.CURDIR)/scan.l \
+	| sed s,\"$(.CURDIR)/scan.l",\"scan.l", \
+	| diff $(.CURDIR)/initscan.c -
+	@echo "Check successful"
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/lex/NEWS b/usr.bin/lex/NEWS
new file mode 100644
index 000000000000..aff90a392a55
--- /dev/null
+++ b/usr.bin/lex/NEWS
@@ -0,0 +1,703 @@
+Changes between release 2.4.7 (03Aug94) and release 2.4.6:
+
+	- Fixed serious bug in reading multiple files.
+
+	- Fixed bug in scanning NUL's.
+
+	- Fixed bug in input() returning 8-bit characters.
+
+	- Fixed bug in matching text with embedded NUL's when
+	  using %array or lex compatibility.
+
+	- Fixed multiple invocations of YY_USER_ACTION when using '|'
+	  continuation action.
+
+	- Minor prototyping fixes.
+
+Changes between release 2.4.6 (04Jan94) and release 2.4.5:
+
+	- Linking with -lfl no longer required if your program includes
+	  its own yywrap() and main() functions.  (This change will cause
+	  problems if you have a non-ANSI compiler on a system for which
+	  sizeof(int) != sizeof(void*) or sizeof(int) != sizeof(size_t).)
+
+	- The use of 'extern "C++"' in FlexLexer.h has been modified to
+	  get around an incompatibility with g++'s header files.
+
+
+Changes between release 2.4.5 (11Dec93) and release 2.4.4:
+
+	- Fixed bug breaking C++ scanners that use REJECT or variable
+	  trailing context.
+
+	- Fixed serious input problem for interactive scanners on
+	  systems for which char is unsigned.
+
+	- Fixed bug in incorrectly treating '$' operator as variable
+	  trailing context.
+
+	- Fixed bug in -CF table representation that could lead to
+	  corrupt tables.
+
+	- Fixed fairly benign memory leak.
+
+	- Added `extern "C++"' wrapper to FlexLexer.h header.  This
+	  should overcome the g++ 2.5.X problems mentioned in the
+	  NEWS for release 2.4.3.
+
+	- Changed #include of FlexLexer.h to use <> instead of "".
+
+	- Added feature to control whether the scanner attempts to
+	  refill the input buffer once it's exhausted.  This feature
+	  will be documented in the 2.5 release.
+
+
+Changes between release 2.4.4 (07Dec93) and release 2.4.3:
+
+	- Fixed two serious bugs in scanning 8-bit characters.
+
+	- Fixed bug in YY_USER_ACTION that caused it to be executed
+	  inappropriately (on the scanner's own internal actions, and
+	  with incorrect yytext/yyleng values).
+
+	- Fixed bug in pointing yyin at a new file and resuming scanning.
+
+	- Portability fix regarding min/max/abs macros conflicting with
+	  function definitions in standard header files.
+
+	- Added a virtual LexerError() method to the C++ yyFlexLexer class
+	  for reporting error messages instead of always using cerr.
+
+	- Added warning in flexdoc that the C++ scanning class is presently
+	  experimental and subject to considerable change between major
+	  releases.
+
+
+Changes between release 2.4.3 (03Dec93) and release 2.4.2:
+
+	- Fixed bug causing fatal scanner messages to fail to print.
+
+	- Fixed things so FlexLexer.h can be included in other C++
+	  sources.  One side-effect of this change is that -+ and -CF
+	  are now incompatible.
+
+	- libfl.a now supplies private versions of the the <string.h>/
+	  <strings.h> string routines needed by flex and the scanners
+	  it generates, to enhance portability to some BSD systems.
+
+	- More robust solution to 2.4.2's flexfatal() bug fix.
+
+	- Added ranlib of installed libfl.a.
+
+	- Some lint tweaks.
+
+	- NOTE: problems have been encountered attempting to build flex
+	  C++ scanners using g++ version 2.5.X.  The problem is due to an
+	  unfortunate heuristic in g++ 2.5.X that attempts to discern between
+	  C and C++ headers.  Because FlexLexer.h is installed (by default)
+	  in /usr/local/include and not /usr/local/lib/g++-include, g++ 2.5.X
+	  decides that it's a C header :-(.  So if you have problems, install
+	  the header in /usr/local/lib/g++-include instead.
+
+
+Changes between release 2.4.2 (01Dec93) and release 2.4.1:
+
+	- Fixed bug in libfl.a referring to non-existent "flexfatal" function.
+
+	- Modified to produce both compress'd and gzip'd tar files for
+	  distributions (you probably don't care about this change!).
+
+
+Changes between release 2.4.1 (30Nov93) and release 2.3.8:
+
+	- The new '-+' flag instructs flex to generate a C++ scanner class
+	  (thanks to Kent Williams).  flex writes an implementation of the
+	  class defined in FlexLexer.h to lex.yy.cc.  You may include
+	  multiple scanner classes in your program using the -P flag.  Note
+	  that the scanner class also provides a mechanism for creating
+	  reentrant scanners.  The scanner class uses C++ streams for I/O
+	  instead of FILE*'s (thanks to Tom Epperly).  If the flex executable's
+	  name ends in '+' then the '-+' flag is automatically on, so creating
+	  a symlink or copy of "flex" to "flex++" results in a version of
+	  flex that can be used exclusively for C++ scanners.
+
+	  Note that without the '-+' flag, flex-generated scanners can still
+	  be compiled using C++ compilers, though they use FILE*'s for I/O
+	  instead of streams.
+
+	  See the "GENERATING C++ SCANNERS" section of flexdoc for details.
+
+	- The new '-l' flag turns on maximum AT&T lex compatibility.  In
+	  particular, -l includes support for "yylineno" and makes yytext
+	  be an array instead of a pointer.  It does not, however, do away
+	  with all incompatibilities.  See the "INCOMPATIBILITIES WITH LEX
+	  AND POSIX" section of flexdoc for details.
+
+	- The new '-P' option specifies a prefix to use other than "yy"
+	  for the scanner's globally-visible variables, and for the
+	  "lex.yy.c" filename.  Using -P you can link together multiple
+	  flex scanners in the same executable.
+
+	- The distribution includes a "texinfo" version of flexdoc.1,
+	  contributed by Roland Pesch (thanks also to Marq Kole, who
+	  contributed another version).  It has not been brought up to
+	  date, but reflects version 2.3.  See MISC/flex.texinfo.
+
+	  The flex distribution will soon include G.T. Nicol's flex
+	  manual; he is presently bringing it up-to-date for version 2.4.
+
+	- yywrap() is now a function, and you now *must* link flex scanners
+	  with libfl.a.
+
+	- Site-configuration is now done via an autoconf-generated
+	  "configure" script contributed by Francois Pinard.
+
+	- Scanners now use fread() (or getc(), if interactive) and not
+	  read() for input.  A new "table compression" option, -Cr,
+	  overrides this change and causes the scanner to use read()
+	  (because read() is a bit faster than fread()).  -f and -F
+	  are now equivalent to -Cfr and -CFr; i.e., they imply the
+	  -Cr option.
+
+	- In the blessed name of POSIX compliance, flex supports "%array"
+	  and "%pointer" directives in the definitions (first) section of
+	  the scanner specification.  The former specifies that yytext
+	  should be an array (of size YYLMAX), the latter, that it should
+	  be a pointer.  The array version of yytext is universally slower
+	  than the pointer version, but has the advantage that its contents
+	  remain unmodified across calls to input() and unput() (the pointer
+	  version of yytext is, still, trashed by such calls).
+
+	  "%array" cannot be used with the '-+' C++ scanner class option.
+
+	- The new '-Ca' option directs flex to trade off memory for
+	  natural alignment when generating a scanner's tables.  In
+	  particular, table entries that would otherwise be "short"
+	  become "long".
+
+	- The new '-h' option produces a summary of the flex flags.
+
+	- The new '-V' option reports the flex version number and exits.
+
+	- The new scanner macro YY_START returns an integer value
+	  corresponding to the current start condition.  You can return
+	  to that start condition by passing the value to a subsequent
+	  "BEGIN" action.  You also can implement "start condition stacks"
+	  by storing the values in an integer stack.
+
+	- You can now redefine macros such as YY_INPUT by just #define'ing
+	  them to some other value in the first section of the flex input;
+	  no need to first #undef them.
+
+	- flex now generates warnings for rules that can't be matched.
+	  These warnings can be turned off using the new '-w' flag.  If
+	  your scanner uses REJECT then you will not get these warnings.
+
+	- If you specify the '-s' flag but the default rule can be matched,
+	  flex now generates a warning.
+
+	- "yyleng" is now a global, and may be modified by the user (though
+	  doing so and then using yymore() will yield weird results).
+
+	- Name definitions in the first section of a scanner specification
+	  can now include a leading '^' or trailing '$' operator.  In this
+	  case, the definition is *not* pushed back inside of parentheses.
+
+	- Scanners with compressed tables are now "interactive" (-I option)
+	  by default.  You can suppress this attribute (which makes them
+	  run slightly slower) using the new '-B' flag.
+
+	- Flex now generates 8-bit scanners by default, unless you use the
+	  -Cf or -CF compression options (-Cfe  and -CFe result in 8-bit
+	  scanners).  You can force it to generate a 7-bit scanner using
+	  the new '-7' flag.  You can build flex to generate 8-bit scanners
+	  for -Cf and -CF, too, by adding -DDEFAULT_CSIZE=256 to CFLAGS
+	  in the Makefile.
+
+	- You no longer need to call the scanner routine yyrestart() to
+	  inform the scanner that you have switched to a new file after
+	  having seen an EOF on the current input file.  Instead, just
+	  point yyin at the new file and continue scanning.
+
+	- You no longer need to invoke YY_NEW_FILE in an <<EOF>> action
+	  to indicate you wish to continue scanning.  Simply point yyin
+	  at a new file.
+
+	- A leading '#' no longer introduces a comment in a flex input.
+
+	- flex no longer considers formfeed ('\f') a whitespace character.
+
+	- %t, I'm happy to report, has been nuked.
+
+	- The '-p' option may be given twice ('-pp') to instruct flex to
+	  report minor performance problems as well as major ones.
+
+	- The '-v' verbose output no longer includes start/finish time
+	  information.
+
+	- Newlines in flex inputs can optionally include leading or
+	  trailing carriage-returns ('\r'), in support of several PC/Mac
+	  run-time libraries that automatically include these.
+
+	- A start condition of the form "<*>" makes the following rule
+	  active in every start condition, whether exclusive or inclusive.
+
+	- The following items have been corrected in the flex documentation:
+
+		- '-C' table compression options *are* cumulative.
+
+		- You may modify yytext but not lengthen it by appending
+		  characters to the end.  Modifying its final character
+		  will affect '^' anchoring for the next rule matched
+		  if the character is changed to or from a newline.
+
+		- The term "backtracking" has been renamed "backing up",
+		  since it is a one-time repositioning and not a repeated
+		  search.  What used to be the "lex.backtrack" file is now
+		  "lex.backup".
+
+		- Unindented "/* ... */" comments are allowed in the first
+		  flex input section, but not in the second.
+
+		- yyless() can only be used in the flex input source, not
+		  externally.
+
+		- You can use "yyrestart(yyin)" to throw away the
+		  current contents of the input buffer.
+
+		- To write high-speed scanners, attempt to match as much
+		  text as possible with each rule.  See MISC/fastwc/README
+		  for more information.
+
+		- Using the beginning-of-line operator ('^') is fairly
+		  cheap.  Using unput() is expensive.  Using yyless() is
+		  cheap.
+
+		- An example of scanning strings with embedded escape
+		  sequences has been added.
+
+		- The example of backing-up in flexdoc was erroneous; it
+		  has been corrected.
+
+	- A flex scanner's internal buffer now dynamically grows if needed
+	  to match large tokens.  Note that growing the buffer presently
+	  requires rescanning the (large) token, so consuming a lot of
+	  text this way is a slow process.  Also note that presently the
+	  buffer does *not* grow if you unput() more text than can fit
+	  into the buffer.
+
+	- The MISC/ directory has been reorganized; see MISC/README for
+	  details.
+
+	- yyless() can now be used in the third (user action) section
+	  of a scanner specification, thanks to Ceriel Jacobs.  yyless()
+	  remains a macro and cannot be used outside of the scanner source.
+
+	- The skeleton file is no longer opened at run-time, but instead
+	  compiled into a large string array (thanks to John Gilmore and
+	  friends at Cygnus).  You can still use the -S flag to point flex
+	  at a different skeleton file, though if you use this option let
+	  me know, as I plan to otherwise do away with -S in the near
+	  future.
+
+	- flex no longer uses a temporary file to store the scanner's
+	  actions.
+
+	- A number of changes have been made to decrease porting headaches.
+	  In particular, flex no longer uses memset() or ctime(), and
+	  provides a single simple mechanism for dealing with C compilers
+	  that still define malloc() as returning char* instead of void*.
+
+	- Flex now detects if the scanner specification requires the -8 flag
+	  but the flag was not given or on by default.
+
+	- A number of table-expansion fencepost bugs have been fixed,
+	  making flex more robust for generating large scanners.
+
+	- flex more consistently identifies the location of errors in
+	  its input.
+
+	- YY_USER_ACTION is now invoked only for "real" actions, not for
+	  internal actions used by the scanner for things like filling
+	  the buffer or handling EOF.
+
+	- The rule "[^]]" now matches any character other than a ']';
+	  formerly it matched any character at all followed by a ']'.
+	  This change was made for compatibility with AT&T lex.
+
+	- A large number of miscellaneous bugs have been found and fixed
+	  thanks to Gerhard Wilhelms.
+
+	- The source code has been heavily reformatted, making patches
+	  relative to previous flex releases no longer accurate.
+
+
+Changes between 2.3 Patch #8 (21Feb93) and 2.3 Patch #7:
+
+	- Fixed bugs in dynamic memory allocation leading to grievous
+	  fencepost problems when generating large scanners.
+	- Fixed bug causing infinite loops on character classes with 8-bit
+	  characters in them.
+	- Fixed bug in matching repetitions with a lower bound of 0.
+	- Fixed bug in scanning NUL characters using an "interactive" scanner.
+	- Fixed bug in using yymore() at the end of a file.
+	- Fixed bug in misrecognizing rules with variable trailing context.
+	- Fixed bug compiling flex on Suns using gcc 2.
+	- Fixed bug in not recognizing that input files with the character
+	  ASCII 128 in them require the -8 flag.
+	- Fixed bug that could cause an infinite loop writing out
+	  error messages.
+	- Fixed bug in not recognizing old-style lex % declarations if
+	  followed by a tab instead of a space.
+	- Fixed potential crash when flex terminated early (usually due
+	  to a bad flag) and the -v flag had been given.
+	- Added some missing declarations of void functions.
+	- Changed to only use '\a' for __STDC__ compilers.
+	- Updated mailing addresses.
+
+
+Changes between 2.3 Patch #7 (28Mar91) and 2.3 Patch #6:
+
+	- Fixed out-of-bounds array access that caused bad tables
+	  to be produced on machines where the bad reference happened
+	  to yield a 1.  This caused problems installing or running
+	  flex on some Suns, in particular.
+
+
+Changes between 2.3 Patch #6 (29Aug90) and 2.3 Patch #5:
+
+	- Fixed a serious bug in yymore() which basically made it
+	  completely broken.  Thanks goes to Jean Christophe of
+	  the Nethack development team for finding the problem
+	  and passing along the fix.
+
+
+Changes between 2.3 Patch #5 (16Aug90) and 2.3 Patch #4:
+
+	- An up-to-date version of initscan.c so "make test" will
+	  work after applying the previous patches
+
+
+Changes between 2.3 Patch #4 (14Aug90) and 2.3 Patch #3:
+
+	- Fixed bug in hexadecimal escapes which allowed only digits,
+	  not letters, in escapes
+	- Fixed bug in previous "Changes" file!
+
+
+Changes between 2.3 Patch #3 (03Aug90) and 2.3 Patch #2:
+
+	- Correction to patch #2 for gcc compilation; thanks goes to
+	  Paul Eggert for catching this.
+
+
+Changes between 2.3 Patch #2 (02Aug90) and original 2.3 release:
+
+	- Fixed (hopefully) headaches involving declaring malloc()
+	  and free() for gcc, which defines __STDC__ but (often) doesn't
+	  come with the standard include files such as <stdlib.h>.
+	  Reordered #ifdef maze in the scanner skeleton in the hope of
+	  getting the declarations right for cfront and g++, too.
+
+	- Note that this patch supercedes patch #1 for release 2.3,
+	  which was never announced but was available briefly for
+	  anonymous ftp.
+
+
+Changes between 2.3 (full) release of 28Jun90 and 2.2 (alpha) release:
+
+    User-visible:
+
+	- A lone <<EOF>> rule (that is, one which is not qualified with
+	  a list of start conditions) now specifies the EOF action for
+	  *all* start conditions which haven't already had <<EOF>> actions
+	  given.  To specify an end-of-file action for just the initial
+	  state, use <INITIAL><<EOF>>.
+
+	- -d debug output is now contigent on the global yy_flex_debug
+	  being set to a non-zero value, which it is by default.
+
+	- A new macro, YY_USER_INIT, is provided for the user to specify
+	  initialization action to be taken on the first call to the
+	  scanner.  This action is done before the scanner does its
+	  own initialization.
+
+	- yy_new_buffer() has been added as an alias for yy_create_buffer()
+
+	- Comments beginning with '#' and extending to the end of the line
+	  now work, but have been deprecated (in anticipation of making
+	  flex recognize #line directives).
+
+	- The funky restrictions on when semi-colons could follow the
+	  YY_NEW_FILE and yyless macros have been removed.  They now
+	  behave identically to functions.
+
+	- A bug in the sample redefinition of YY_INPUT in the documentation
+	  has been corrected.
+
+	- A bug in the sample simple tokener in the documentation has
+	  been corrected.
+
+	- The documentation on the incompatibilities between flex and
+	  lex has been reordered so that the discussion of yylineno
+	  and input() come first, as it's anticipated that these will
+	  be the most common source of headaches.
+
+
+    Things which didn't used to be documented but now are:
+
+	- flex interprets "^foo|bar" differently from lex.  flex interprets
+	  it as "match either a 'foo' or a 'bar', providing it comes at the
+	  beginning of a line", whereas lex interprets it as "match either
+	  a 'foo' at the beginning of a line, or a 'bar' anywhere".
+
+	- flex initializes the global "yyin" on the first call to the
+	  scanner, while lex initializes it at compile-time.
+
+	- yy_switch_to_buffer() can be used in the yywrap() macro/routine.
+
+	- flex scanners do not use stdio for their input, and hence when
+	  writing an interactive scanner one must explictly call fflush()
+	  after writing out a prompt.
+
+	- flex scanner can be made reentrant (after a fashion) by using
+	  "yyrestart( yyin );".  This is useful for interactive scanners
+	  which have interrupt handlers that long-jump out of the scanner.
+
+	- a defense of why yylineno is not supported is included, along
+	  with a suggestion on how to convert scanners which rely on it.
+
+
+    Other changes:
+
+	- Prototypes and proper declarations of void routines have
+	  been added to the flex source code, courtesy of Kevin B. Kenny.
+
+	- Routines dealing with memory allocation now use void* pointers
+	  instead of char* - see Makefile for porting implications.
+
+	- Error-checking is now done when flex closes a file.
+
+	- Various lint tweaks were added to reduce the number of gripes.
+
+	- Makefile has been further parameterized to aid in porting.
+
+	- Support for SCO Unix added.
+
+	- Flex now sports the latest & greatest UC copyright notice
+	  (which is only slightly different from the previous one).
+
+	- A note has been added to flexdoc.1 mentioning work in progress
+	  on modifying flex to generate straight C code rather than a
+	  table-driven automaton, with an email address of whom to contact
+	  if you are working along similar lines.
+
+
+Changes between 2.2 Patch #3 (30Mar90) and 2.2 Patch #2:
+
+	- fixed bug which caused -I scanners to bomb
+
+
+Changes between 2.2 Patch #2 (27Mar90) and 2.2 Patch #1:
+
+	- fixed bug writing past end of input buffer in yyunput()
+	- fixed bug detecting NUL's at the end of a buffer
+
+
+Changes between 2.2 Patch #1 (23Mar90) and 2.2 (alpha) release:
+
+	- Makefile fixes: definition of MAKE variable for systems
+	  which don't have it; installation of flexdoc.1 along with
+	  flex.1; fixed two bugs which could cause "bigtest" to fail.
+
+	- flex.skel fix for compiling with g++.
+
+	- README and flexdoc.1 no longer list an out-of-date BITNET address
+	  for contacting me.
+
+	- minor typos and formatting changes to flex.1 and flexdoc.1.
+
+
+Changes between 2.2 (alpha) release of March '90 and previous release:
+
+    User-visible:
+
+	- Full user documentation now available.
+
+	- Support for 8-bit scanners.
+
+	- Scanners now accept NUL's.
+
+	- A facility has been added for dealing with multiple
+	  input buffers.
+
+	- Two manual entries now.  One which fully describes flex
+	  (rather than just its differences from lex), and the
+	  other for quick(er) reference.
+
+	- A number of changes to bring flex closer into compliance
+	  with the latest POSIX lex draft:
+
+		%t support
+		flex now accepts multiple input files and concatenates
+		    them together to form its input
+		previous -c (compress) flag renamed -C
+		do-nothing -c and -n flags added
+		Any indented code or code within %{}'s in section 2 is
+		    now copied to the output
+
+	- yyleng is now a bona fide global integer.
+
+	- -d debug information now gives the line number of the
+	  matched rule instead of which number rule it was from
+	  the beginning of the file.
+
+	- -v output now includes a summary of the flags used to generate
+	  the scanner.
+
+	- unput() and yyrestart() are now globally callable.
+
+	- yyrestart() no longer closes the previous value of yyin.
+
+	- C++ support; generated scanners can be compiled with C++ compiler.
+
+	- Primitive -lfl library added, containing default main()
+	  which calls yylex().  A number of routines currently living
+	  in the scanner skeleton will probably migrate to here
+	  in the future (in particular, yywrap() will probably cease
+	  to be a macro and instead be a function in the -lfl library).
+
+	- Hexadecimal (\x) escape sequences added.
+
+	- Support for MS-DOS, VMS, and Turbo-C integrated.
+
+	- The %used/%unused operators have been deprecated.  They
+	  may go away soon.
+
+
+    Other changes:
+
+	- Makefile enhanced for easier testing and installation.
+	- The parser has been tweaked to detect some erroneous
+	  constructions which previously were missed.
+	- Scanner input buffer overflow is now detected.
+	- Bugs with missing "const" declarations fixed.
+	- Out-of-date Minix/Atari patches provided.
+	- Scanners no longer require printf() unless FLEX_DEBUG is being used.
+	- A subtle input() bug has been fixed.
+	- Line numbers for "continued action" rules (those following
+	  the special '|' action) are now correct.
+	- unput() bug fixed; had been causing problems porting flex to VMS.
+	- yymore() handling rewritten to fix bug with interaction
+	  between yymore() and trailing context.
+	- EOF in actions now generates an error message.
+	- Bug involving -CFe and generating equivalence classes fixed.
+	- Bug which made -CF be treated as -Cf fixed.
+	- Support for SysV tmpnam() added.
+	- Unused #define's for scanner no longer generated.
+	- Error messages which are associated with a particular input
+	  line are now all identified with their input line in standard
+	  format.
+	- % directives which are valid to lex but not to flex are
+	  now ignored instead of generating warnings.
+	- -DSYS_V flag can now also be specified -DUSG for System V
+	  compilation.
+
+
+Changes between 2.1 beta-test release of June '89 and previous release:
+
+    User-visible:
+
+	- -p flag generates a performance report to stderr.  The report
+	  consists of comments regarding features of the scanner rules
+	  which result in slower scanners.
+
+	- -b flag generates backtracking information to lex.backtrack.
+	  This is a list of scanner states which require backtracking
+	  and the characters on which they do so.  By adding rules
+	  one can remove backtracking states.  If all backtracking states
+	  are eliminated, the generated scanner will run faster.
+	  Backtracking is not yet documented in the manual entry.
+
+	- Variable trailing context now works, i.e., one can have
+	  rules like "(foo)*/[ \t]*bletch".  Some trailing context
+	  patterns still cannot be properly matched and generate
+	  error messages.  These are patterns where the ending of the
+	  first part of the rule matches the beginning of the second
+	  part, such as "zx*/xy*", where the 'x*' matches the 'x' at
+	  the beginning of the trailing context.  Lex won't get these
+	  patterns right either.
+
+	- Faster scanners.
+
+	- End-of-file rules.  The special rule "<<EOF>>" indicates
+	  actions which are to be taken when an end-of-file is
+	  encountered and yywrap() returns non-zero (i.e., indicates
+	  no further files to process).  See manual entry for example.
+
+	- The -r (reject used) flag is gone.  flex now scans the input
+	  for occurrences of the string "REJECT" to determine if the
+	  action is needed.  It tries to be intelligent about this but
+	  can be fooled.  One can force the presence or absence of
+	  REJECT by adding a line in the first section of the form
+	  "%used REJECT" or "%unused REJECT".
+
+	- yymore() has been implemented.  Similarly to REJECT, flex
+	  detects the use of yymore(), which can be overridden using
+	  "%used" or "%unused".
+
+	- Patterns like "x{0,3}" now work (i.e., with lower-limit == 0).
+
+	- Removed '\^x' for ctrl-x misfeature.
+
+	- Added '\a' and '\v' escape sequences.
+
+	- \<digits> now works for octal escape sequences; previously
+	  \0<digits> was required.
+
+	- Better error reporting; line numbers are associated with rules.
+
+	- yyleng is a macro; it cannot be accessed outside of the
+	  scanner source file.
+
+	- yytext and yyleng should not be modified within a flex action.
+
+	- Generated scanners #define the name FLEX_SCANNER.
+
+	- Rules are internally separated by YY_BREAK in lex.yy.c rather
+	  than break, to allow redefinition.
+
+	- The macro YY_USER_ACTION can be redefined to provide an action
+	  which is always executed prior to the matched rule's action.
+	
+	- yyrestart() is a new action which can be used to restart
+	  the scanner after it has seen an end-of-file (a "real" one,
+	  that is, one for which yywrap() returned non-zero).  It takes
+	  a FILE* argument indicating a new file to scan and sets
+	  things up so that a subsequent call to yylex() will start
+	  scanning that file.
+
+	- Internal scanner names all preceded by "yy_"
+
+	- lex.yy.c is deleted if errors are encountered during processing.
+
+	- Comments may be put in the first section of the input by preceding
+	  them with '#'.
+
+
+
+    Other changes:
+
+	- Some portability-related bugs fixed, in particular for machines
+	  with unsigned characters or sizeof( int* ) != sizeof( int ).
+	  Also, tweaks for VMS and Microsoft C (MS-DOS), and identifiers all
+	  trimmed to be 31 or fewer characters.  Shortened file names
+	  for dinosaur OS's.  Checks for allocating > 64K memory
+	  on 16 bit'ers.  Amiga tweaks.  Compiles using gcc on a Sun-3.
+	- Compressed and fast scanner skeletons merged.
+	- Skeleton header files done away with.
+	- Generated scanner uses prototypes and "const" for __STDC__.
+	- -DSV flag is now -DSYS_V for System V compilation.
+	- Removed all references to FTL language.
+	- Software now covered by BSD Copyright.
+	- flex will replace lex in subsequent BSD releases.
diff --git a/usr.bin/lex/README b/usr.bin/lex/README
new file mode 100644
index 000000000000..339e9bbbd51e
--- /dev/null
+++ b/usr.bin/lex/README
@@ -0,0 +1,67 @@
+This is release 2.4 of flex.  See "version.h" for the exact patch-level.
+
+See the file "NEWS" to find out what is new in this Flex release.
+
+Read the file "INSTALL" for general installation directives.  Peek near
+the beginning of the file "Makefile.in" for special DEFS values.  On most
+systems, you can just run the "configure" script and type "make" to build
+flex; then "make check" to test whether it built correctly; and if it did,
+then "make install" to install it.
+
+If you're feeling adventurous, you can also issue "make bigcheck" (be
+prepared to wait a while).
+
+Note that flex is distributed under a copyright very similar to that of
+BSD Unix, and not under the GNU General Public License (GPL), except for
+the "configure" script, which is covered by the GPL.
+
+Many thanks to the 2.4 pre-testers for finding a bunch of bugs and helping
+increase/test portability: Francois Pinard, Nathan Zelle, Gavin Nicol,
+Chris Thewalt, and Matthew Jacob.
+
+Please send bug reports and feedback to:
+
+	Vern Paxson
+	ICSD, 46A/1123
+	Lawrence Berkeley Laboratory
+	1 Cyclotron Rd.
+	Berkeley, CA 94720
+
+	vern@ee.lbl.gov
+
+
+The flex distribution consists of the following files:
+
+	README		This message
+
+	NEWS		Differences between the various releases
+
+	INSTALL		General installation information
+
+	COPYING		flex's copyright
+
+	configure.in, configure, Makefile.in, install.sh, mkinstalldirs
+			elements of the "autoconf" auto-configuration process
+
+	flexdef.h, parse.y, scan.l, ccl.c, dfa.c, ecs.c, gen.c, main.c,
+	misc.c, nfa.c, sym.c, tblcmp.c, yylex.c	 
+			source files
+
+	version.h	version of this flex release
+
+	flex.skl	flex scanner skeleton
+	mkskel.sh	script for converting flex.skl to C source file skel.c
+
+	liballoc.c
+	libmain.c	flex library (-lfl) sources
+	libyywrap.c
+
+	initscan.c	pre-flex'd version of scan.l
+
+	FlexLexer.h	header file for C++ lexer class
+
+	flexdoc.1	full user documentation
+	flex.1		reference documentation
+
+	MISC/		a directory containing miscellaneous contributions.
+			See MISC/README for details.
diff --git a/usr.bin/lex/ccl.c b/usr.bin/lex/ccl.c
new file mode 100644
index 000000000000..fe28463923e0
--- /dev/null
+++ b/usr.bin/lex/ccl.c
@@ -0,0 +1,149 @@
+/* ccl - routines for character classes */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/ccl.c,v 2.9 93/09/16 20:32:14 vern Exp $ */
+
+#include "flexdef.h"
+
+/* ccladd - add a single character to a ccl */
+
+void ccladd( cclp, ch )
+int cclp;
+int ch;
+	{
+	int ind, len, newpos, i;
+
+	check_char( ch );
+
+	len = ccllen[cclp];
+	ind = cclmap[cclp];
+
+	/* check to see if the character is already in the ccl */
+
+	for ( i = 0; i < len; ++i )
+		if ( ccltbl[ind + i] == ch )
+			return;
+
+	newpos = ind + len;
+
+	if ( newpos >= current_max_ccl_tbl_size )
+		{
+		current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
+
+		++num_reallocs;
+
+		ccltbl = reallocate_Character_array( ccltbl,
+						current_max_ccl_tbl_size );
+		}
+
+	ccllen[cclp] = len + 1;
+	ccltbl[newpos] = ch;
+	}
+
+
+/* cclinit - return an empty ccl */
+
+int cclinit()
+	{
+	if ( ++lastccl >= current_maxccls )
+		{
+		current_maxccls += MAX_CCLS_INCREMENT;
+
+		++num_reallocs;
+
+		cclmap = reallocate_integer_array( cclmap, current_maxccls );
+		ccllen = reallocate_integer_array( ccllen, current_maxccls );
+		cclng = reallocate_integer_array( cclng, current_maxccls );
+		}
+
+	if ( lastccl == 1 )
+		/* we're making the first ccl */
+		cclmap[lastccl] = 0;
+
+	else
+		/* The new pointer is just past the end of the last ccl.
+		 * Since the cclmap points to the \first/ character of a
+		 * ccl, adding the length of the ccl to the cclmap pointer
+		 * will produce a cursor to the first free space.
+		 */
+		cclmap[lastccl] = cclmap[lastccl - 1] + ccllen[lastccl - 1];
+
+	ccllen[lastccl] = 0;
+	cclng[lastccl] = 0;	/* ccl's start out life un-negated */
+
+	return lastccl;
+	}
+
+
+/* cclnegate - negate the given ccl */
+
+void cclnegate( cclp )
+int cclp;
+	{
+	cclng[cclp] = 1;
+	}
+
+
+/* list_character_set - list the members of a set of characters in CCL form
+ *
+ * Writes to the given file a character-class representation of those
+ * characters present in the given CCL.  A character is present if it
+ * has a non-zero value in the cset array.
+ */
+
+void list_character_set( file, cset )
+FILE *file;
+int cset[];
+	{
+	register int i;
+
+	putc( '[', file );
+
+	for ( i = 0; i < csize; ++i )
+		{
+		if ( cset[i] )
+			{
+			register int start_char = i;
+
+			putc( ' ', file );
+
+			fputs( readable_form( i ), file );
+
+			while ( ++i < csize && cset[i] )
+				;
+
+			if ( i - 1 > start_char )
+				/* this was a run */
+				fprintf( file, "-%s", readable_form( i - 1 ) );
+
+			putc( ' ', file );
+			}
+		}
+
+	putc( ']', file );
+	}
diff --git a/usr.bin/lex/dfa.c b/usr.bin/lex/dfa.c
new file mode 100644
index 000000000000..f8fceb975acd
--- /dev/null
+++ b/usr.bin/lex/dfa.c
@@ -0,0 +1,1085 @@
+/* dfa - DFA construction routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: dfa.c,v 1.2 94/01/04 14:33:16 vern Exp $ */
+
+#include "flexdef.h"
+
+
+/* declare functions that have forward references */
+
+void dump_associated_rules PROTO((FILE*, int));
+void dump_transitions PROTO((FILE*, int[]));
+void sympartition PROTO((int[], int, int[], int[]));
+int symfollowset PROTO((int[], int, int, int[]));
+
+
+/* check_for_backing_up - check a DFA state for backing up
+ *
+ * synopsis
+ *     void check_for_backing_up( int ds, int state[numecs] );
+ *
+ * ds is the number of the state to check and state[] is its out-transitions,
+ * indexed by equivalence class.
+ */
+
+void check_for_backing_up( ds, state )
+int ds;
+int state[];
+	{
+	if ( (reject && ! dfaacc[ds].dfaacc_set) ||
+	     (! reject && ! dfaacc[ds].dfaacc_state) )
+		{ /* state is non-accepting */
+		++num_backing_up;
+
+		if ( backing_up_report )
+			{
+			fprintf( backing_up_file,
+				"State #%d is non-accepting -\n", ds );
+
+			/* identify the state */
+			dump_associated_rules( backing_up_file, ds );
+
+			/* Now identify it further using the out- and
+			 * jam-transitions.
+			 */
+			dump_transitions( backing_up_file, state );
+
+			putc( '\n', backing_up_file );
+			}
+		}
+	}
+
+
+/* check_trailing_context - check to see if NFA state set constitutes
+ *                          "dangerous" trailing context
+ *
+ * synopsis
+ *    void check_trailing_context( int nfa_states[num_states+1], int num_states,
+ *				int accset[nacc+1], int nacc );
+ *
+ * NOTES
+ *  Trailing context is "dangerous" if both the head and the trailing
+ *  part are of variable size \and/ there's a DFA state which contains
+ *  both an accepting state for the head part of the rule and NFA states
+ *  which occur after the beginning of the trailing context.
+ *
+ *  When such a rule is matched, it's impossible to tell if having been
+ *  in the DFA state indicates the beginning of the trailing context or
+ *  further-along scanning of the pattern.  In these cases, a warning
+ *  message is issued.
+ *
+ *    nfa_states[1 .. num_states] is the list of NFA states in the DFA.
+ *    accset[1 .. nacc] is the list of accepting numbers for the DFA state.
+ */
+
+void check_trailing_context( nfa_states, num_states, accset, nacc )
+int *nfa_states, num_states;
+int *accset;
+register int nacc;
+	{
+	register int i, j;
+
+	for ( i = 1; i <= num_states; ++i )
+		{
+		int ns = nfa_states[i];
+		register int type = state_type[ns];
+		register int ar = assoc_rule[ns];
+
+		if ( type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE )
+			{ /* do nothing */
+			}
+
+		else if ( type == STATE_TRAILING_CONTEXT )
+			{
+			/* Potential trouble.  Scan set of accepting numbers
+			 * for the one marking the end of the "head".  We
+			 * assume that this looping will be fairly cheap
+			 * since it's rare that an accepting number set
+			 * is large.
+			 */
+			for ( j = 1; j <= nacc; ++j )
+				if ( accset[j] & YY_TRAILING_HEAD_MASK )
+					{
+					line_warning(
+						"dangerous trailing context",
+						rule_linenum[ar] );
+					return;
+					}
+			}
+		}
+	}
+
+
+/* dump_associated_rules - list the rules associated with a DFA state
+ *
+ * Goes through the set of NFA states associated with the DFA and
+ * extracts the first MAX_ASSOC_RULES unique rules, sorts them,
+ * and writes a report to the given file.
+ */
+
+void dump_associated_rules( file, ds )
+FILE *file;
+int ds;
+	{
+	register int i, j;
+	register int num_associated_rules = 0;
+	int rule_set[MAX_ASSOC_RULES + 1];
+	int *dset = dss[ds];
+	int size = dfasiz[ds];
+
+	for ( i = 1; i <= size; ++i )
+		{
+		register int rule_num = rule_linenum[assoc_rule[dset[i]]];
+
+		for ( j = 1; j <= num_associated_rules; ++j )
+			if ( rule_num == rule_set[j] )
+				break;
+
+		if ( j > num_associated_rules )
+			{ /* new rule */
+			if ( num_associated_rules < MAX_ASSOC_RULES )
+				rule_set[++num_associated_rules] = rule_num;
+			}
+		}
+
+	bubble( rule_set, num_associated_rules );
+
+	fprintf( file, " associated rule line numbers:" );
+
+	for ( i = 1; i <= num_associated_rules; ++i )
+		{
+		if ( i % 8 == 1 )
+			putc( '\n', file );
+
+		fprintf( file, "\t%d", rule_set[i] );
+		}
+
+	putc( '\n', file );
+	}
+
+
+/* dump_transitions - list the transitions associated with a DFA state
+ *
+ * synopsis
+ *     dump_transitions( FILE *file, int state[numecs] );
+ *
+ * Goes through the set of out-transitions and lists them in human-readable
+ * form (i.e., not as equivalence classes); also lists jam transitions
+ * (i.e., all those which are not out-transitions, plus EOF).  The dump
+ * is done to the given file.
+ */
+
+void dump_transitions( file, state )
+FILE *file;
+int state[];
+	{
+	register int i, ec;
+	int out_char_set[CSIZE];
+
+	for ( i = 0; i < csize; ++i )
+		{
+		ec = ABS( ecgroup[i] );
+		out_char_set[i] = state[ec];
+		}
+
+	fprintf( file, " out-transitions: " );
+
+	list_character_set( file, out_char_set );
+
+	/* now invert the members of the set to get the jam transitions */
+	for ( i = 0; i < csize; ++i )
+		out_char_set[i] = ! out_char_set[i];
+
+	fprintf( file, "\n jam-transitions: EOF " );
+
+	list_character_set( file, out_char_set );
+
+	putc( '\n', file );
+	}
+
+
+/* epsclosure - construct the epsilon closure of a set of ndfa states
+ *
+ * synopsis
+ *    int *epsclosure( int t[num_states], int *numstates_addr,
+ *			int accset[num_rules+1], int *nacc_addr,
+ *			int *hashval_addr );
+ *
+ * NOTES
+ *  The epsilon closure is the set of all states reachable by an arbitrary
+ *  number of epsilon transitions, which themselves do not have epsilon
+ *  transitions going out, unioned with the set of states which have non-null
+ *  accepting numbers.  t is an array of size numstates of nfa state numbers.
+ *  Upon return, t holds the epsilon closure and *numstates_addr is updated.
+ *  accset holds a list of the accepting numbers, and the size of accset is
+ *  given by *nacc_addr.  t may be subjected to reallocation if it is not
+ *  large enough to hold the epsilon closure.
+ *
+ *  hashval is the hash value for the dfa corresponding to the state set.
+ */
+
+int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr )
+int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
+	{
+	register int stkpos, ns, tsp;
+	int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
+	int stkend, nstate;
+	static int did_stk_init = false, *stk; 
+
+#define MARK_STATE(state) \
+trans1[state] = trans1[state] - MARKER_DIFFERENCE;
+
+#define IS_MARKED(state) (trans1[state] < 0)
+
+#define UNMARK_STATE(state) \
+trans1[state] = trans1[state] + MARKER_DIFFERENCE;
+
+#define CHECK_ACCEPT(state) \
+{ \
+nfaccnum = accptnum[state]; \
+if ( nfaccnum != NIL ) \
+accset[++nacc] = nfaccnum; \
+}
+
+#define DO_REALLOCATION \
+{ \
+current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
+++num_reallocs; \
+t = reallocate_integer_array( t, current_max_dfa_size ); \
+stk = reallocate_integer_array( stk, current_max_dfa_size ); \
+} \
+
+#define PUT_ON_STACK(state) \
+{ \
+if ( ++stkend >= current_max_dfa_size ) \
+DO_REALLOCATION \
+stk[stkend] = state; \
+MARK_STATE(state) \
+}
+
+#define ADD_STATE(state) \
+{ \
+if ( ++numstates >= current_max_dfa_size ) \
+DO_REALLOCATION \
+t[numstates] = state; \
+hashval += state; \
+}
+
+#define STACK_STATE(state) \
+{ \
+PUT_ON_STACK(state) \
+CHECK_ACCEPT(state) \
+if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
+ADD_STATE(state) \
+}
+
+
+	if ( ! did_stk_init )
+		{
+		stk = allocate_integer_array( current_max_dfa_size );
+		did_stk_init = true;
+		}
+
+	nacc = stkend = hashval = 0;
+
+	for ( nstate = 1; nstate <= numstates; ++nstate )
+		{
+		ns = t[nstate];
+
+		/* The state could be marked if we've already pushed it onto
+		 * the stack.
+		 */
+		if ( ! IS_MARKED(ns) )
+			{
+			PUT_ON_STACK(ns)
+			CHECK_ACCEPT(ns)
+			hashval += ns;
+			}
+		}
+
+	for ( stkpos = 1; stkpos <= stkend; ++stkpos )
+		{
+		ns = stk[stkpos];
+		transsym = transchar[ns];
+
+		if ( transsym == SYM_EPSILON )
+			{
+			tsp = trans1[ns] + MARKER_DIFFERENCE;
+
+			if ( tsp != NO_TRANSITION )
+				{
+				if ( ! IS_MARKED(tsp) )
+					STACK_STATE(tsp)
+
+				tsp = trans2[ns];
+
+				if ( tsp != NO_TRANSITION && ! IS_MARKED(tsp) )
+					STACK_STATE(tsp)
+				}
+			}
+		}
+
+	/* Clear out "visit" markers. */
+
+	for ( stkpos = 1; stkpos <= stkend; ++stkpos )
+		{
+		if ( IS_MARKED(stk[stkpos]) )
+			UNMARK_STATE(stk[stkpos])
+		else
+			flexfatal( "consistency check failed in epsclosure()" );
+		}
+
+	*ns_addr = numstates;
+	*hv_addr = hashval;
+	*nacc_addr = nacc;
+
+	return t;
+	}
+
+
+/* increase_max_dfas - increase the maximum number of DFAs */
+
+void increase_max_dfas()
+	{
+	current_max_dfas += MAX_DFAS_INCREMENT;
+
+	++num_reallocs;
+
+	base = reallocate_integer_array( base, current_max_dfas );
+	def = reallocate_integer_array( def, current_max_dfas );
+	dfasiz = reallocate_integer_array( dfasiz, current_max_dfas );
+	accsiz = reallocate_integer_array( accsiz, current_max_dfas );
+	dhash = reallocate_integer_array( dhash, current_max_dfas );
+	dss = reallocate_int_ptr_array( dss, current_max_dfas );
+	dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas );
+
+	if ( nultrans )
+		nultrans =
+			reallocate_integer_array( nultrans, current_max_dfas );
+	}
+
+
+/* ntod - convert an ndfa to a dfa
+ *
+ * Creates the dfa corresponding to the ndfa we've constructed.  The
+ * dfa starts out in state #1.
+ */
+
+void ntod()
+	{
+	int *accset, ds, nacc, newds;
+	int sym, hashval, numstates, dsize;
+	int num_full_table_rows;	/* used only for -f */
+	int *nset, *dset;
+	int targptr, totaltrans, i, comstate, comfreq, targ;
+	int *epsclosure(), snstods(), symlist[CSIZE + 1];
+	int num_start_states;
+	int todo_head, todo_next;
+
+	/* Note that the following are indexed by *equivalence classes*
+	 * and not by characters.  Since equivalence classes are indexed
+	 * beginning with 1, even if the scanner accepts NUL's, this
+	 * means that (since every character is potentially in its own
+	 * equivalence class) these arrays must have room for indices
+	 * from 1 to CSIZE, so their size must be CSIZE + 1.
+	 */
+	int duplist[CSIZE + 1], state[CSIZE + 1];
+	int targfreq[CSIZE + 1], targstate[CSIZE + 1];
+
+	accset = allocate_integer_array( num_rules + 1 );
+	nset = allocate_integer_array( current_max_dfa_size );
+
+	/* The "todo" queue is represented by the head, which is the DFA
+	 * state currently being processed, and the "next", which is the
+	 * next DFA state number available (not in use).  We depend on the
+	 * fact that snstods() returns DFA's \in increasing order/, and thus
+	 * need only know the bounds of the dfas to be processed.
+	 */
+	todo_head = todo_next = 0;
+
+	for ( i = 0; i <= csize; ++i )
+		{
+		duplist[i] = NIL;
+		symlist[i] = false;
+		}
+
+	for ( i = 0; i <= num_rules; ++i )
+		accset[i] = NIL;
+
+	if ( trace )
+		{
+		dumpnfa( scset[1] );
+		fputs( "\n\nDFA Dump:\n\n", stderr );
+		}
+
+	inittbl();
+
+	/* Check to see whether we should build a separate table for
+	 * transitions on NUL characters.  We don't do this for full-speed
+	 * (-F) scanners, since for them we don't have a simple state
+	 * number lying around with which to index the table.  We also
+	 * don't bother doing it for scanners unless (1) NUL is in its own
+	 * equivalence class (indicated by a positive value of
+	 * ecgroup[NUL]), (2) NUL's equivalence class is the last
+	 * equivalence class, and (3) the number of equivalence classes is
+	 * the same as the number of characters.  This latter case comes
+	 * about when useecs is false or when it's true but every character
+	 * still manages to land in its own class (unlikely, but it's
+	 * cheap to check for).  If all these things are true then the
+	 * character code needed to represent NUL's equivalence class for
+	 * indexing the tables is going to take one more bit than the
+	 * number of characters, and therefore we won't be assured of
+	 * being able to fit it into a YY_CHAR variable.  This rules out
+	 * storing the transitions in a compressed table, since the code
+	 * for interpreting them uses a YY_CHAR variable (perhaps it
+	 * should just use an integer, though; this is worth pondering ...
+	 * ###).
+	 *
+	 * Finally, for full tables, we want the number of entries in the
+	 * table to be a power of two so the array references go fast (it
+	 * will just take a shift to compute the major index).  If
+	 * encoding NUL's transitions in the table will spoil this, we
+	 * give it its own table (note that this will be the case if we're
+	 * not using equivalence classes).
+	 */
+
+	/* Note that the test for ecgroup[0] == numecs below accomplishes
+	 * both (1) and (2) above
+	 */
+	if ( ! fullspd && ecgroup[0] == numecs )
+		{
+		/* NUL is alone in its equivalence class, which is the
+		 * last one.
+		 */
+		int use_NUL_table = (numecs == csize);
+
+		if ( fulltbl && ! use_NUL_table )
+			{
+			/* We still may want to use the table if numecs
+			 * is a power of 2.
+			 */
+			int power_of_two;
+
+			for ( power_of_two = 1; power_of_two <= csize;
+			      power_of_two *= 2 )
+				if ( numecs == power_of_two )
+					{
+					use_NUL_table = true;
+					break;
+					}
+			}
+
+		if ( use_NUL_table )
+			nultrans = allocate_integer_array( current_max_dfas );
+
+		/* From now on, nultrans != nil indicates that we're
+		 * saving null transitions for later, separate encoding.
+		 */
+		}
+
+
+	if ( fullspd )
+		{
+		for ( i = 0; i <= numecs; ++i )
+			state[i] = 0;
+
+		place_state( state, 0, 0 );
+		dfaacc[i].dfaacc_state = 0;
+		}
+
+	else if ( fulltbl )
+		{
+		if ( nultrans )
+			/* We won't be including NUL's transitions in the
+			 * table, so build it for entries from 0 .. numecs - 1.
+			 */
+			num_full_table_rows = numecs;
+
+		else
+			/* Take into account the fact that we'll be including
+			 * the NUL entries in the transition table.  Build it
+			 * from 0 .. numecs.
+			 */
+			num_full_table_rows = numecs + 1;
+
+		/* Unless -Ca, declare it "short" because it's a real
+		 * long-shot that that won't be large enough.
+		 */
+		printf( "static const %s yy_nxt[][%d] =\n    {\n",
+			/* '}' so vi doesn't get too confused */
+			long_align ? "long" : "short", num_full_table_rows );
+
+		/* Generate 0 entries for state #0. */
+		for ( i = 0; i < num_full_table_rows; ++i )
+			mk2data( 0 );
+
+		/* Force ',' and dataflush() next call to mk2data().*/
+		datapos = NUMDATAITEMS;
+
+		/* Force extra blank line next dataflush(). */
+		dataline = NUMDATALINES;
+		}
+
+	/* Create the first states. */
+
+	num_start_states = lastsc * 2;
+
+	for ( i = 1; i <= num_start_states; ++i )
+		{
+		numstates = 1;
+
+		/* For each start condition, make one state for the case when
+		 * we're at the beginning of the line (the '^' operator) and
+		 * one for the case when we're not.
+		 */
+		if ( i % 2 == 1 )
+			nset[numstates] = scset[(i / 2) + 1];
+		else
+			nset[numstates] =
+				mkbranch( scbol[i / 2], scset[i / 2] );
+
+		nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );
+
+		if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
+			{
+			numas += nacc;
+			totnst += numstates;
+			++todo_next;
+
+			if ( variable_trailing_context_rules && nacc > 0 )
+				check_trailing_context( nset, numstates,
+							accset, nacc );
+			}
+		}
+
+	if ( ! fullspd )
+		{
+		if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
+			flexfatal(
+				"could not create unique end-of-buffer state" );
+
+		++numas;
+		++num_start_states;
+		++todo_next;
+		}
+
+	while ( todo_head < todo_next )
+		{
+		targptr = 0;
+		totaltrans = 0;
+
+		for ( i = 1; i <= numecs; ++i )
+			state[i] = 0;
+
+		ds = ++todo_head;
+
+		dset = dss[ds];
+		dsize = dfasiz[ds];
+
+		if ( trace )
+			fprintf( stderr, "state # %d:\n", ds );
+
+		sympartition( dset, dsize, symlist, duplist );
+
+		for ( sym = 1; sym <= numecs; ++sym )
+			{
+			if ( symlist[sym] )
+				{
+				symlist[sym] = 0;
+
+				if ( duplist[sym] == NIL )
+					{
+					/* Symbol has unique out-transitions. */
+					numstates = symfollowset( dset, dsize,
+								sym, nset );
+					nset = epsclosure( nset, &numstates,
+						accset, &nacc, &hashval );
+
+					if ( snstods( nset, numstates, accset,
+						nacc, hashval, &newds ) )
+						{
+						totnst = totnst + numstates;
+						++todo_next;
+						numas += nacc;
+
+						if (
+					variable_trailing_context_rules &&
+							nacc > 0 )
+							check_trailing_context(
+								nset, numstates,
+								accset, nacc );
+						}
+
+					state[sym] = newds;
+
+					if ( trace )
+						fprintf( stderr, "\t%d\t%d\n",
+							sym, newds );
+
+					targfreq[++targptr] = 1;
+					targstate[targptr] = newds;
+					++numuniq;
+					}
+
+				else
+					{
+					/* sym's equivalence class has the same
+					 * transitions as duplist(sym)'s
+					 * equivalence class.
+					 */
+					targ = state[duplist[sym]];
+					state[sym] = targ;
+
+					if ( trace )
+						fprintf( stderr, "\t%d\t%d\n",
+							sym, targ );
+
+					/* Update frequency count for
+					 * destination state.
+					 */
+
+					i = 0;
+					while ( targstate[++i] != targ )
+						;
+
+					++targfreq[i];
+					++numdup;
+					}
+
+				++totaltrans;
+				duplist[sym] = NIL;
+				}
+			}
+
+		numsnpairs = numsnpairs + totaltrans;
+
+		if ( caseins && ! useecs )
+			{
+			register int j;
+
+			for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
+				state[i] = state[j];
+			}
+
+		if ( ds > num_start_states )
+			check_for_backing_up( ds, state );
+
+		if ( nultrans )
+			{
+			nultrans[ds] = state[NUL_ec];
+			state[NUL_ec] = 0;	/* remove transition */
+			}
+
+		if ( fulltbl )
+			{
+			/* Supply array's 0-element. */
+			if ( ds == end_of_buffer_state )
+				mk2data( -end_of_buffer_state );
+			else
+				mk2data( end_of_buffer_state );
+
+			for ( i = 1; i < num_full_table_rows; ++i )
+				/* Jams are marked by negative of state
+				 * number.
+				 */
+				mk2data( state[i] ? state[i] : -ds );
+
+			/* Force ',' and dataflush() next call to mk2data().*/
+			datapos = NUMDATAITEMS;
+
+			/* Force extra blank line next dataflush(). */
+			dataline = NUMDATALINES;
+			}
+
+		else if ( fullspd )
+			place_state( state, ds, totaltrans );
+
+		else if ( ds == end_of_buffer_state )
+			/* Special case this state to make sure it does what
+			 * it's supposed to, i.e., jam on end-of-buffer.
+			 */
+			stack1( ds, 0, 0, JAMSTATE );
+
+		else /* normal, compressed state */
+			{
+			/* Determine which destination state is the most
+			 * common, and how many transitions to it there are.
+			 */
+
+			comfreq = 0;
+			comstate = 0;
+
+			for ( i = 1; i <= targptr; ++i )
+				if ( targfreq[i] > comfreq )
+					{
+					comfreq = targfreq[i];
+					comstate = targstate[i];
+					}
+
+			bldtbl( state, ds, totaltrans, comstate, comfreq );
+			}
+		}
+
+	if ( fulltbl )
+		dataend();
+
+	else if ( ! fullspd )
+		{
+		cmptmps();  /* create compressed template entries */
+
+		/* Create tables for all the states with only one
+		 * out-transition.
+		 */
+		while ( onesp > 0 )
+			{
+			mk1tbl( onestate[onesp], onesym[onesp], onenext[onesp],
+			onedef[onesp] );
+			--onesp;
+			}
+
+		mkdeftbl();
+		}
+
+	flex_free( (void *) accset );
+	flex_free( (void *) nset );
+	}
+
+
+/* snstods - converts a set of ndfa states into a dfa state
+ *
+ * synopsis
+ *    is_new_state = snstods( int sns[numstates], int numstates,
+ *				int accset[num_rules+1], int nacc,
+ *				int hashval, int *newds_addr );
+ *
+ * On return, the dfa state number is in newds.
+ */
+
+int snstods( sns, numstates, accset, nacc, hashval, newds_addr )
+int sns[], numstates, accset[], nacc, hashval, *newds_addr;
+	{
+	int didsort = 0;
+	register int i, j;
+	int newds, *oldsns;
+
+	for ( i = 1; i <= lastdfa; ++i )
+		if ( hashval == dhash[i] )
+			{
+			if ( numstates == dfasiz[i] )
+				{
+				oldsns = dss[i];
+
+				if ( ! didsort )
+					{
+					/* We sort the states in sns so we
+					 * can compare it to oldsns quickly.
+					 * We use bubble because there probably
+					 * aren't very many states.
+					 */
+					bubble( sns, numstates );
+					didsort = 1;
+					}
+
+				for ( j = 1; j <= numstates; ++j )
+					if ( sns[j] != oldsns[j] )
+						break;
+
+				if ( j > numstates )
+					{
+					++dfaeql;
+					*newds_addr = i;
+					return 0;
+					}
+
+				++hshcol;
+				}
+
+			else
+				++hshsave;
+			}
+
+	/* Make a new dfa. */
+
+	if ( ++lastdfa >= current_max_dfas )
+		increase_max_dfas();
+
+	newds = lastdfa;
+
+	dss[newds] = allocate_integer_array( numstates + 1 );
+
+	/* If we haven't already sorted the states in sns, we do so now,
+	 * so that future comparisons with it can be made quickly.
+	 */
+
+	if ( ! didsort )
+		bubble( sns, numstates );
+
+	for ( i = 1; i <= numstates; ++i )
+		dss[newds][i] = sns[i];
+
+	dfasiz[newds] = numstates;
+	dhash[newds] = hashval;
+
+	if ( nacc == 0 )
+		{
+		if ( reject )
+			dfaacc[newds].dfaacc_set = (int *) 0;
+		else
+			dfaacc[newds].dfaacc_state = 0;
+
+		accsiz[newds] = 0;
+		}
+
+	else if ( reject )
+		{
+		/* We sort the accepting set in increasing order so the
+		 * disambiguating rule that the first rule listed is considered
+		 * match in the event of ties will work.  We use a bubble
+		 * sort since the list is probably quite small.
+		 */
+
+		bubble( accset, nacc );
+
+		dfaacc[newds].dfaacc_set = allocate_integer_array( nacc + 1 );
+
+		/* Save the accepting set for later */
+		for ( i = 1; i <= nacc; ++i )
+			{
+			dfaacc[newds].dfaacc_set[i] = accset[i];
+
+			if ( accset[i] <= num_rules )
+				/* Who knows, perhaps a REJECT can yield
+				 * this rule.
+				 */
+				rule_useful[accset[i]] = true;
+			}
+
+		accsiz[newds] = nacc;
+		}
+
+	else
+		{
+		/* Find lowest numbered rule so the disambiguating rule
+		 * will work.
+		 */
+		j = num_rules + 1;
+
+		for ( i = 1; i <= nacc; ++i )
+			if ( accset[i] < j )
+				j = accset[i];
+
+		dfaacc[newds].dfaacc_state = j;
+
+		if ( j <= num_rules )
+			rule_useful[j] = true;
+		}
+
+	*newds_addr = newds;
+
+	return 1;
+	}
+
+
+/* symfollowset - follow the symbol transitions one step
+ *
+ * synopsis
+ *    numstates = symfollowset( int ds[current_max_dfa_size], int dsize,
+ *				int transsym, int nset[current_max_dfa_size] );
+ */
+
+int symfollowset( ds, dsize, transsym, nset )
+int ds[], dsize, transsym, nset[];
+	{
+	int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
+
+	numstates = 0;
+
+	for ( i = 1; i <= dsize; ++i )
+		{ /* for each nfa state ns in the state set of ds */
+		ns = ds[i];
+		sym = transchar[ns];
+		tsp = trans1[ns];
+
+		if ( sym < 0 )
+			{ /* it's a character class */
+			sym = -sym;
+			ccllist = cclmap[sym];
+			lenccl = ccllen[sym];
+
+			if ( cclng[sym] )
+				{
+				for ( j = 0; j < lenccl; ++j )
+					{
+					/* Loop through negated character
+					 * class.
+					 */
+					ch = ccltbl[ccllist + j];
+
+					if ( ch == 0 )
+						ch = NUL_ec;
+
+					if ( ch > transsym )
+						/* Transsym isn't in negated
+						 * ccl.
+						 */
+						break;
+
+					else if ( ch == transsym )
+						/* next 2 */ goto bottom;
+					}
+
+				/* Didn't find transsym in ccl. */
+				nset[++numstates] = tsp;
+				}
+
+			else
+				for ( j = 0; j < lenccl; ++j )
+					{
+					ch = ccltbl[ccllist + j];
+
+					if ( ch == 0 )
+						ch = NUL_ec;
+
+					if ( ch > transsym )
+						break;
+					else if ( ch == transsym )
+						{
+						nset[++numstates] = tsp;
+						break;
+						}
+					}
+			}
+
+		else if ( sym >= 'A' && sym <= 'Z' && caseins )
+			flexfatal( "consistency check failed in symfollowset" );
+
+		else if ( sym == SYM_EPSILON )
+			{ /* do nothing */
+			}
+
+		else if ( ABS( ecgroup[sym] ) == transsym )
+			nset[++numstates] = tsp;
+
+		bottom: ;
+		}
+
+	return numstates;
+	}
+
+
+/* sympartition - partition characters with same out-transitions
+ *
+ * synopsis
+ *    sympartition( int ds[current_max_dfa_size], int numstates,
+ *			int symlist[numecs], int duplist[numecs] );
+ */
+
+void sympartition( ds, numstates, symlist, duplist )
+int ds[], numstates;
+int symlist[], duplist[];
+	{
+	int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
+
+	/* Partitioning is done by creating equivalence classes for those
+	 * characters which have out-transitions from the given state.  Thus
+	 * we are really creating equivalence classes of equivalence classes.
+	 */
+
+	for ( i = 1; i <= numecs; ++i )
+		{ /* initialize equivalence class list */
+		duplist[i] = i - 1;
+		dupfwd[i] = i + 1;
+		}
+
+	duplist[1] = NIL;
+	dupfwd[numecs] = NIL;
+
+	for ( i = 1; i <= numstates; ++i )
+		{
+		ns = ds[i];
+		tch = transchar[ns];
+
+		if ( tch != SYM_EPSILON )
+			{
+			if ( tch < -lastccl || tch >= csize )
+				{
+				flexfatal(
+			"bad transition character detected in sympartition()" );
+				}
+
+			if ( tch >= 0 )
+				{ /* character transition */
+				int ec = ecgroup[tch];
+
+				mkechar( ec, dupfwd, duplist );
+				symlist[ec] = 1;
+				}
+
+			else
+				{ /* character class */
+				tch = -tch;
+
+				lenccl = ccllen[tch];
+				cclp = cclmap[tch];
+				mkeccl( ccltbl + cclp, lenccl, dupfwd,
+					duplist, numecs, NUL_ec );
+
+				if ( cclng[tch] )
+					{
+					j = 0;
+
+					for ( k = 0; k < lenccl; ++k )
+						{
+						ich = ccltbl[cclp + k];
+
+						if ( ich == 0 )
+							ich = NUL_ec;
+
+						for ( ++j; j < ich; ++j )
+							symlist[j] = 1;
+						}
+
+					for ( ++j; j <= numecs; ++j )
+						symlist[j] = 1;
+					}
+
+				else
+					for ( k = 0; k < lenccl; ++k )
+						{
+						ich = ccltbl[cclp + k];
+
+						if ( ich == 0 )
+							ich = NUL_ec;
+
+						symlist[ich] = 1;
+						}
+				}
+			}
+		}
+	}
diff --git a/usr.bin/lex/ecs.c b/usr.bin/lex/ecs.c
new file mode 100644
index 000000000000..10b167c5898c
--- /dev/null
+++ b/usr.bin/lex/ecs.c
@@ -0,0 +1,225 @@
+/* ecs - equivalence class routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/ecs.c,v 2.9 93/12/07 10:18:20 vern Exp $ */
+
+#include "flexdef.h"
+
+/* ccl2ecl - convert character classes to set of equivalence classes */
+
+void ccl2ecl()
+	{
+	int i, ich, newlen, cclp, ccls, cclmec;
+
+	for ( i = 1; i <= lastccl; ++i )
+		{
+		/* We loop through each character class, and for each character
+		 * in the class, add the character's equivalence class to the
+		 * new "character" class we are creating.  Thus when we are all
+		 * done, character classes will really consist of collections
+		 * of equivalence classes
+		 */
+
+		newlen = 0;
+		cclp = cclmap[i];
+
+		for ( ccls = 0; ccls < ccllen[i]; ++ccls )
+			{
+			ich = ccltbl[cclp + ccls];
+			cclmec = ecgroup[ich];
+
+			if ( cclmec > 0 )
+				{
+				ccltbl[cclp + newlen] = cclmec;
+				++newlen;
+				}
+			}
+
+		ccllen[i] = newlen;
+		}
+	}
+
+
+/* cre8ecs - associate equivalence class numbers with class members
+ *
+ * fwd is the forward linked-list of equivalence class members.  bck
+ * is the backward linked-list, and num is the number of class members.
+ *
+ * Returned is the number of classes.
+ */
+
+int cre8ecs( fwd, bck, num )
+int fwd[], bck[], num;
+	{
+	int i, j, numcl;
+
+	numcl = 0;
+
+	/* Create equivalence class numbers.  From now on, ABS( bck(x) )
+	 * is the equivalence class number for object x.  If bck(x)
+	 * is positive, then x is the representative of its equivalence
+	 * class.
+	 */
+	for ( i = 1; i <= num; ++i )
+		if ( bck[i] == NIL )
+			{
+			bck[i] = ++numcl;
+			for ( j = fwd[i]; j != NIL; j = fwd[j] )
+				bck[j] = -numcl;
+			}
+
+	return numcl;
+	}
+
+
+/* mkeccl - update equivalence classes based on character class xtions
+ *
+ * synopsis
+ *    Char ccls[];
+ *    int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
+ *    void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
+ *			int llsiz, int NUL_mapping );
+ *
+ * ccls contains the elements of the character class, lenccl is the
+ * number of elements in the ccl, fwd is the forward link-list of equivalent
+ * characters, bck is the backward link-list, and llsiz size of the link-list.
+ *
+ * NUL_mapping is the value which NUL (0) should be mapped to.
+ */
+
+void mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping )
+Char ccls[];
+int lenccl, fwd[], bck[], llsiz, NUL_mapping;
+	{
+	int cclp, oldec, newec;
+	int cclm, i, j;
+	static unsigned char cclflags[CSIZE];	/* initialized to all '\0' */
+
+	/* Note that it doesn't matter whether or not the character class is
+	 * negated.  The same results will be obtained in either case.
+	 */
+
+	cclp = 0;
+
+	while ( cclp < lenccl )
+		{
+		cclm = ccls[cclp];
+
+		if ( NUL_mapping && cclm == 0 )
+			cclm = NUL_mapping;
+
+		oldec = bck[cclm];
+		newec = cclm;
+
+		j = cclp + 1;
+
+		for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
+			{ /* look for the symbol in the character class */
+			for ( ; j < lenccl; ++j )
+				{
+				register int ccl_char;
+
+				if ( NUL_mapping && ccls[j] == 0 )
+					ccl_char = NUL_mapping;
+				else
+					ccl_char = ccls[j];
+
+				if ( ccl_char > i )
+					break;
+
+				if ( ccl_char == i && ! cclflags[j] )
+					{
+					/* We found an old companion of cclm
+					 * in the ccl.  Link it into the new
+					 * equivalence class and flag it as
+					 * having been processed.
+					 */
+
+					bck[i] = newec;
+					fwd[newec] = i;
+					newec = i;
+					/* Set flag so we don't reprocess. */
+					cclflags[j] = 1;
+
+					/* Get next equivalence class member. */
+					/* continue 2 */
+					goto next_pt;
+					}
+				}
+
+			/* Symbol isn't in character class.  Put it in the old
+			 * equivalence class.
+			 */
+
+			bck[i] = oldec;
+
+			if ( oldec != NIL )
+				fwd[oldec] = i;
+
+			oldec = i;
+
+			next_pt: ;
+			}
+
+		if ( bck[cclm] != NIL || oldec != bck[cclm] )
+			{
+			bck[cclm] = NIL;
+			fwd[oldec] = NIL;
+			}
+
+		fwd[newec] = NIL;
+
+		/* Find next ccl member to process. */
+
+		for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
+			{
+			/* Reset "doesn't need processing" flag. */
+			cclflags[cclp] = 0;
+			}
+		}
+	}
+
+
+/* mkechar - create equivalence class for single character */
+
+void mkechar( tch, fwd, bck )
+int tch, fwd[], bck[];
+	{
+	/* If until now the character has been a proper subset of
+	 * an equivalence class, break it away to create a new ec
+	 */
+
+	if ( fwd[tch] != NIL )
+		bck[fwd[tch]] = bck[tch];
+
+	if ( bck[tch] != NIL )
+		fwd[bck[tch]] = fwd[tch];
+
+	fwd[tch] = NIL;
+	bck[tch] = NIL;
+	}
diff --git a/usr.bin/lex/flex.skl b/usr.bin/lex/flex.skl
new file mode 100644
index 000000000000..01ff7a1262b4
--- /dev/null
+++ b/usr.bin/lex/flex.skl
@@ -0,0 +1,1225 @@
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/flex.skl,v 1.2 94/08/03 11:13:24 vern Exp $
+ */
+
+#define FLEX_SCANNER
+
+%-
+#include <stdio.h>
+%*
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+%+
+class istream;
+%*
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#ifdef __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+
+#ifdef __TURBOC__
+#define YY_USE_CONST
+#endif
+
+
+#ifndef YY_USE_CONST
+#ifndef const
+#define const
+#endif
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.
+ */
+#define YY_START ((yy_start - 1) / 2)
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file".  Now included
+ * only for backward compatibility with previous versions of flex.
+ */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+%-
+extern FILE *yyin, *yyout;
+%*
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	extern int yywrap YY_PROTO(( void ));
+#ifdef __cplusplus
+	}
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		*yy_cp = yy_hold_char; \
+		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+
+struct yy_buffer_state
+	{
+%-
+	FILE *yy_input_file;
+%+
+	istream* yy_input_file;
+%*
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+	};
+
+%- Standard (non-C++) definition
+static YY_BUFFER_STATE yy_current_buffer = 0;
+%*
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+%- Standard (non-C++) definition
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+void yyrestart YY_PROTO(( FILE *input_file ));
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+static void yy_push_state YY_PROTO(( int new_state ));
+static void yy_pop_state YY_PROTO(( void ));
+static int yy_top_state YY_PROTO(( void ));
+%*
+
+static void *yy_flex_alloc YY_PROTO(( unsigned int ));
+static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));
+#endif
+
+%- Standard (non-C++) definition
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+%*
+
+%- Standard (non-C++) definition
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( const char msg[] ));
+%*
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext_ptr = yy_bp; \
+%% code to fiddle yytext and yyleng for yymore() goes here
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+%% code to copy yytext_ptr to yytext[] goes here, if %array
+	yy_c_buf_p = yy_cp;
+
+%% data tables for the DFA and the user's section 1 definitions go here
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+%- Standard (non-C++) definition
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+%+ C++ definition
+#define ECHO LexerOutput( yytext, yyleng )
+%*
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+%% fread()/read() definition of YY_INPUT goes here unless we're doing C++
+%+ C++ definition
+	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
+%*
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+%-
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+%+
+#define YY_FATAL_ERROR(msg) LexerError( msg )
+%*
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+%- Standard (non-C++) definition
+#define YY_DECL int yylex YY_PROTO(( void ))
+%+ C++ definition
+#define YY_DECL int yyFlexLexer::yylex()
+%*
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+
+%% user's declarations go here
+
+	if ( yy_init )
+		{
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+%-
+			yyin = stdin;
+%+
+			yyin = &cin;
+%*
+
+		if ( ! yyout )
+%-
+			yyout = stdout;
+%+
+			yyout = &cout;
+%*
+
+		if ( yy_current_buffer )
+			yy_init_buffer( yy_current_buffer, yyin );
+		else
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+
+		yy_load_buffer_state();
+
+		yy_init = 0;
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+%% yymore()-related code goes here
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+%% code to set up and find next match goes here
+
+yy_find_action:
+%% code to find the action number goes here
+
+		YY_DO_BEFORE_ACTION;
+
+%% code for yylineno update goes here, if -l option
+
+do_action:	/* This label is used only to access EOF actions. */
+
+%% debug code goes here
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+%% actions go here
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yy_hold_char;
+
+		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between yy_current_buffer and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+%% code to do back-up for compressed tables and set up yy_cp goes here
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap() )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of yylex */
+
+%+
+#ifdef YY_INTERACTIVE
+int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
+#else
+int yyFlexLexer::LexerInput( char* buf, int max_size )
+#endif
+	{
+	if ( yyin->eof() || yyin->fail() )
+		return 0;
+
+#ifdef YY_INTERACTIVE
+	yyin->get( buf[0] );
+
+	if ( yyin->eof() )
+		return 0;
+
+	if ( yyin->bad() )
+		return -1;
+
+	return 1;
+
+#else
+	(void) yyin->read( buf, max_size );
+
+	if ( yyin->bad() )
+		return -1;
+	else
+		return yyin->gcount();
+#endif
+	}
+
+void yyFlexLexer::LexerOutput( const char* buf, int size )
+	{
+	(void) yyout->write( buf, size );
+	}
+%*
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+
+%-
+static int yy_get_next_buffer()
+%+
+int yyFlexLexer::yy_get_next_buffer()
+%*
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr - 1; /* copy prev. char, too */
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a singled characater, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = yy_c_buf_p - yytext_ptr;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		yy_n_chars = 0;
+
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
+
+			int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
+
+			b->yy_buf_size *= 2;
+			b->yy_ch_buf = (char *)
+				yy_flex_realloc( (void *) b->yy_ch_buf,
+						 b->yy_buf_size );
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
+#endif
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+		}
+
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move - YY_MORE_ADJ == 1 )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	/* yytext begins at the second character in yy_ch_buf; the first
+	 * character is the one which preceded it before reading in the latest
+	 * buffer; it needs to be kept around in case it's a newline, so
+	 * yy_get_previous_state() will have with '^' rules active.
+	 */
+
+	yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
+
+	return ret_val;
+	}
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+%-
+static yy_state_type yy_get_previous_state()
+%+
+yy_state_type yyFlexLexer::yy_get_previous_state()
+%*
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+
+%% code to get the start state into yy_current_state goes here
+
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+%% code to find the next state goes here
+		}
+
+	return yy_current_state;
+	}
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+
+%-
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+%+
+yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
+%*
+	{
+	register int yy_is_jam;
+%% code to find the next state, and perhaps do backing up, goes here
+
+	return yy_is_jam ? 0 : yy_current_state;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+%+
+void yyFlexLexer::yyunput( int c, register char* yy_bp )
+%*
+	{
+	register char *yy_cp = yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
+
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += dest - source;
+		yy_bp += dest - source;
+		yy_n_chars = yy_current_buffer->yy_buf_size;
+
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
+		yy_cp[-2] = '\n';
+
+	*--yy_cp = (char) c;
+
+%% update yylineno here, if doing -l
+
+	/* Note: the formal parameter *must* be called "yy_bp" for this
+	 * macro to now work correctly.
+	 */
+	YY_DO_BEFORE_ACTION; /* set up yytext again */
+	}
+
+
+%-
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+%+
+int yyFlexLexer::yyinput()
+%*
+	{
+	int c;
+
+	*yy_c_buf_p = yy_hold_char;
+
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			yytext_ptr = yy_c_buf_p;
+			++yy_c_buf_p;
+
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						{
+						yy_c_buf_p =
+						yytext_ptr + YY_MORE_ADJ;
+						return EOF;
+						}
+
+					YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					break;
+
+				case EOB_ACT_LAST_MATCH:
+#ifdef __cplusplus
+					YY_FATAL_ERROR(
+					"unexpected last match in yyinput()" );
+#else
+					YY_FATAL_ERROR(
+					"unexpected last match in input()" );
+#endif
+				}
+			}
+		}
+
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
+
+	return c;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+%+
+void yyFlexLexer::yyrestart( istream* input_file )
+%*
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+%+
+void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+%*
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
+
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+%+
+void yyFlexLexer::yy_load_buffer_state()
+%*
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+%+
+YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
+%*
+	{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	yy_init_buffer( b, file );
+
+	return b;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+%+
+void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
+%*
+	{
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+	yy_flex_free( (void *) b->yy_ch_buf );
+	yy_flex_free( (void *) b );
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+%+
+void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
+%*
+	{
+	b->yy_input_file = file;
+
+	/* We put in the '\n' and start reading from [1] so that an
+	 * initial match-at-newline will be true.
+	 */
+
+	b->yy_ch_buf[0] = '\n';
+	b->yy_n_chars = 1;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[1];
+
+%-
+	b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
+%+
+	b->yy_is_interactive = 0;
+%*
+
+	b->yy_fill_buffer = 1;
+
+	b->yy_buffer_status = YY_BUFFER_NEW;
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+%+
+void yyFlexLexer::yy_push_state( int new_state )
+%*
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		int new_size;
+
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
+
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
+
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
+
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+	}
+
+
+%-
+static void yy_pop_state()
+%+
+void yyFlexLexer::yy_pop_state()
+%*
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
+
+
+%-
+static int yy_top_state()
+%+
+int yyFlexLexer::yy_top_state()
+%*
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
+
+
+%-
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( const char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+	{
+	(void) fprintf( stderr, "%s\n", msg );
+	exit( 1 );
+	}
+
+%+
+
+void yyFlexLexer::LexerError( const char msg[] )
+	{
+	cerr << msg << '\n';
+	exit( 1 );
+	}
+%*
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		yytext[yyleng] = yy_hold_char; \
+		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
+		yy_hold_char = *yy_c_buf_p; \
+		*yy_c_buf_p = '\0'; \
+		yyleng = n; \
+		} \
+	while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, const char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+const char *s2;
+int n;
+#endif
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( unsigned int size )
+#else
+static void *yy_flex_alloc( size )
+unsigned int size;
+#endif
+	{
+	return (void *) malloc( size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, unsigned int size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+unsigned int size;
+#endif
+	{
+	return (void *) realloc( ptr, size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+	{
+	free( ptr );
+	}
diff --git a/usr.bin/lex/flexdef.h b/usr.bin/lex/flexdef.h
new file mode 100644
index 000000000000..c8d4825a0e44
--- /dev/null
+++ b/usr.bin/lex/flexdef.h
@@ -0,0 +1,902 @@
+/* flexdef - definitions file for flex */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* @(#) $Header: flexdef.h,v 1.2 94/01/04 14:33:14 vern Exp $ (LBL) */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+#if __STDC__
+#include <stdlib.h>
+#endif
+
+/* Always be prepared to generate an 8-bit scanner. */
+#define CSIZE 256
+#define Char unsigned char
+
+/* Size of input alphabet - should be size of ASCII set. */
+#ifndef DEFAULT_CSIZE
+#define DEFAULT_CSIZE 128
+#endif
+
+#ifndef PROTO
+#ifdef __STDC__
+#define PROTO(proto) proto
+#else
+#define PROTO(proto) ()
+#endif
+#endif
+
+#ifdef VMS
+#define unlink delete
+#define SHORT_FILE_NAMES
+#endif
+
+#ifdef MS_DOS
+#define SHORT_FILE_NAMES
+#endif
+
+
+/* Maximum line length we'll have to deal with. */
+#define MAXLINE 2048
+
+#ifndef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
+#ifndef MAX
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#endif
+#ifndef ABS
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+#endif
+
+
+/* ANSI C does not guarantee that isascii() is defined */
+#ifndef isascii
+#define isascii(c) ((c) <= 0177)
+#endif
+
+
+#define true 1
+#define false 0
+
+
+/* Special chk[] values marking the slots taking by end-of-buffer and action
+ * numbers.
+ */
+#define EOB_POSITION -1
+#define ACTION_POSITION -2
+
+/* Number of data items per line for -f output. */
+#define NUMDATAITEMS 10
+
+/* Number of lines of data in -f output before inserting a blank line for
+ * readability.
+ */
+#define NUMDATALINES 10
+
+/* Transition_struct_out() definitions. */
+#define TRANS_STRUCT_PRINT_LENGTH 15
+
+/* Returns true if an nfa state has an epsilon out-transition slot
+ * that can be used.  This definition is currently not used.
+ */
+#define FREE_EPSILON(state) \
+	(transchar[state] == SYM_EPSILON && \
+	 trans2[state] == NO_TRANSITION && \
+	 finalst[state] != state)
+
+/* Returns true if an nfa state has an epsilon out-transition character
+ * and both slots are free
+ */
+#define SUPER_FREE_EPSILON(state) \
+	(transchar[state] == SYM_EPSILON && \
+	 trans1[state] == NO_TRANSITION) \
+
+/* Maximum number of NFA states that can comprise a DFA state.  It's real
+ * big because if there's a lot of rules, the initial state will have a
+ * huge epsilon closure.
+ */
+#define INITIAL_MAX_DFA_SIZE 750
+#define MAX_DFA_SIZE_INCREMENT 750
+
+
+/* A note on the following masks.  They are used to mark accepting numbers
+ * as being special.  As such, they implicitly limit the number of accepting
+ * numbers (i.e., rules) because if there are too many rules the rule numbers
+ * will overload the mask bits.  Fortunately, this limit is \large/ (0x2000 ==
+ * 8192) so unlikely to actually cause any problems.  A check is made in
+ * new_rule() to ensure that this limit is not reached.
+ */
+
+/* Mask to mark a trailing context accepting number. */
+#define YY_TRAILING_MASK 0x2000
+
+/* Mask to mark the accepting number of the "head" of a trailing context
+ * rule.
+ */
+#define YY_TRAILING_HEAD_MASK 0x4000
+
+/* Maximum number of rules, as outlined in the above note. */
+#define MAX_RULE (YY_TRAILING_MASK - 1)
+
+
+/* NIL must be 0.  If not, its special meaning when making equivalence classes
+ * (it marks the representative of a given e.c.) will be unidentifiable.
+ */
+#define NIL 0
+
+#define JAM -1	/* to mark a missing DFA transition */
+#define NO_TRANSITION NIL
+#define UNIQUE -1	/* marks a symbol as an e.c. representative */
+#define INFINITY -1	/* for x{5,} constructions */
+
+#define INITIAL_MAX_CCLS 100	/* max number of unique character classes */
+#define MAX_CCLS_INCREMENT 100
+
+/* Size of table holding members of character classes. */
+#define INITIAL_MAX_CCL_TBL_SIZE 500
+#define MAX_CCL_TBL_SIZE_INCREMENT 250
+
+#define INITIAL_MAX_RULES 100	/* default maximum number of rules */
+#define MAX_RULES_INCREMENT 100
+
+#define INITIAL_MNS 2000	/* default maximum number of nfa states */
+#define MNS_INCREMENT 1000	/* amount to bump above by if it's not enough */
+
+#define INITIAL_MAX_DFAS 1000	/* default maximum number of dfa states */
+#define MAX_DFAS_INCREMENT 1000
+
+#define JAMSTATE -32766	/* marks a reference to the state that always jams */
+
+/* Enough so that if it's subtracted from an NFA state number, the result
+ * is guaranteed to be negative.
+ */
+#define MARKER_DIFFERENCE 32000
+#define MAXIMUM_MNS 31999
+
+/* Maximum number of nxt/chk pairs for non-templates. */
+#define INITIAL_MAX_XPAIRS 2000
+#define MAX_XPAIRS_INCREMENT 2000
+
+/* Maximum number of nxt/chk pairs needed for templates. */
+#define INITIAL_MAX_TEMPLATE_XPAIRS 2500
+#define MAX_TEMPLATE_XPAIRS_INCREMENT 2500
+
+#define SYM_EPSILON (CSIZE + 1)	/* to mark transitions on the symbol epsilon */
+
+#define INITIAL_MAX_SCS 40	/* maximum number of start conditions */
+#define MAX_SCS_INCREMENT 40	/* amount to bump by if it's not enough */
+
+#define ONE_STACK_SIZE 500	/* stack of states with only one out-transition */
+#define SAME_TRANS -1	/* transition is the same as "default" entry for state */
+
+/* The following percentages are used to tune table compression:
+
+ * The percentage the number of out-transitions a state must be of the
+ * number of equivalence classes in order to be considered for table
+ * compaction by using protos.
+ */
+#define PROTO_SIZE_PERCENTAGE 15
+
+/* The percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * that the state's transition table is first compared with a potential 
+ * template of the most common out-transition instead of with the first
+ * proto in the proto queue.
+ */
+#define CHECK_COM_PERCENTAGE 50
+
+/* The percentage the number of differences between a state's transition
+ * table and the proto it was first compared with must be of the total
+ * number of out-transitions of the state in order to keep the first
+ * proto as a good match and not search any further.
+ */
+#define FIRST_MATCH_DIFF_PERCENTAGE 10
+
+/* The percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to use the proto as an acceptable close match.
+ */
+#define ACCEPTABLE_DIFF_PERCENTAGE 50
+
+/* The percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * to consider making a template from the state.
+ */
+#define TEMPLATE_SAME_PERCENTAGE 60
+
+/* The percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to create a new proto from the state.
+ */
+#define NEW_PROTO_DIFF_PERCENTAGE 20
+
+/* The percentage the total number of out-transitions of a state must be
+ * of the number of equivalence classes in order to consider trying to
+ * fit the transition table into "holes" inside the nxt/chk table.
+ */
+#define INTERIOR_FIT_PERCENTAGE 15
+
+/* Size of region set aside to cache the complete transition table of
+ * protos on the proto queue to enable quick comparisons.
+ */
+#define PROT_SAVE_SIZE 2000
+
+#define MSP 50	/* maximum number of saved protos (protos on the proto queue) */
+
+/* Maximum number of out-transitions a state can have that we'll rummage
+ * around through the interior of the internal fast table looking for a
+ * spot for it.
+ */
+#define MAX_XTIONS_FULL_INTERIOR_FIT 4
+
+/* Maximum number of rules which will be reported as being associated
+ * with a DFA state.
+ */
+#define MAX_ASSOC_RULES 100
+
+/* Number that, if used to subscript an array, has a good chance of producing
+ * an error; should be small enough to fit into a short.
+ */
+#define BAD_SUBSCRIPT -32767
+
+/* Absolute value of largest number that can be stored in a short, with a
+ * bit of slop thrown in for general paranoia.
+ */
+#define MAX_SHORT 32700
+
+
+/* Declarations for global variables. */
+
+/* Variables for symbol tables:
+ * sctbl - start-condition symbol table
+ * ndtbl - name-definition symbol table
+ * ccltab - character class text symbol table
+ */
+
+struct hash_entry
+	{
+	struct hash_entry *prev, *next;
+	char *name;
+	char *str_val;
+	int int_val;
+	} ;
+
+typedef struct hash_entry **hash_table;
+
+#define NAME_TABLE_HASH_SIZE 101
+#define START_COND_HASH_SIZE 101
+#define CCL_HASH_SIZE 101
+
+extern struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE]; 
+extern struct hash_entry *sctbl[START_COND_HASH_SIZE];
+extern struct hash_entry *ccltab[CCL_HASH_SIZE];
+
+
+/* Variables for flags:
+ * printstats - if true (-v), dump statistics
+ * syntaxerror - true if a syntax error has been found
+ * eofseen - true if we've seen an eof in the input file
+ * ddebug - if true (-d), make a "debug" scanner
+ * trace - if true (-T), trace processing
+ * nowarn - if true (-w), do not generate warnings
+ * spprdflt - if true (-s), suppress the default rule
+ * interactive - if true (-I), generate an interactive scanner
+ * caseins - if true (-i), generate a case-insensitive scanner
+ * lex_compat - if true (-l), maximize compatibility with AT&T lex
+ * useecs - if true (-Ce flag), use equivalence classes
+ * fulltbl - if true (-Cf flag), don't compress the DFA state table
+ * usemecs - if true (-Cm flag), use meta-equivalence classes
+ * fullspd - if true (-F flag), use Jacobson method of table representation
+ * gen_line_dirs - if true (i.e., no -L flag), generate #line directives
+ * performance_report - if > 0 (i.e., -p flag), generate a report relating
+ *   to scanner performance; if > 1 (-p -p), report on minor performance
+ *   problems, too
+ * backing_up_report - if true (i.e., -b flag), generate "lex.backup" file
+ *   listing backing-up states
+ * C_plus_plus - if true (i.e., -+ flag), generate a C++ scanner class;
+ *   otherwise, a standard C scanner
+ * long_align - if true (-Ca flag), favor long-word alignment.
+ * use_read - if true (-f, -F, or -Cr) then use read() for scanner input;
+ *   otherwise, use fread().
+ * yytext_is_array - if true (i.e., %array directive), then declare
+ *   yytext as a array instead of a character pointer.  Nice and inefficient.
+ * csize - size of character set for the scanner we're generating;
+ *   128 for 7-bit chars and 256 for 8-bit
+ * yymore_used - if true, yymore() is used in input rules
+ * reject - if true, generate back-up tables for REJECT macro
+ * real_reject - if true, scanner really uses REJECT (as opposed to just
+ *   having "reject" set for variable trailing context)
+ * continued_action - true if this rule's action is to "fall through" to
+ *   the next rule's action (i.e., the '|' action)
+ * yymore_really_used - has a REALLY_xxx value indicating whether a
+ *   %used or %notused was used with yymore()
+ * reject_really_used - same for REJECT
+ */
+
+extern int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
+extern int interactive, caseins, lex_compat, useecs, fulltbl, usemecs;
+extern int fullspd, gen_line_dirs, performance_report, backing_up_report;
+extern int C_plus_plus, long_align, use_read, yytext_is_array, csize;
+extern int yymore_used, reject, real_reject, continued_action;
+
+#define REALLY_NOT_DETERMINED 0
+#define REALLY_USED 1
+#define REALLY_NOT_USED 2
+extern int yymore_really_used, reject_really_used;
+
+
+/* Variables used in the flex input routines:
+ * datapos - characters on current output line
+ * dataline - number of contiguous lines of data in current data
+ * 	statement.  Used to generate readable -f output
+ * linenum - current input line number
+ * skelfile - the skeleton file
+ * skel - compiled-in skeleton array
+ * skel_ind - index into "skel" array, if skelfile is nil
+ * yyin - input file
+ * backing_up_file - file to summarize backing-up states to
+ * infilename - name of input file
+ * input_files - array holding names of input files
+ * num_input_files - size of input_files array
+ * program_name - name with which program was invoked 
+ *
+ * action_array - array to hold the rule actions
+ * action_size - size of action_array
+ * defs1_offset - index where the user's section 1 definitions start
+ *	in action_array
+ * prolog_offset - index where the prolog starts in action_array
+ * action_offset - index where the non-prolog starts in action_array
+ * action_index - index where the next action should go, with respect
+ * 	to "action_array"
+ */
+
+extern int datapos, dataline, linenum;
+extern FILE *skelfile, *yyin, *backing_up_file;
+extern char *skel[];
+extern int skel_ind;
+extern char *infilename;
+extern char **input_files;
+extern int num_input_files;
+extern char *program_name;
+
+extern char *action_array;
+extern int action_size;
+extern int defs1_offset, prolog_offset, action_offset, action_index;
+
+
+/* Variables for stack of states having only one out-transition:
+ * onestate - state number
+ * onesym - transition symbol
+ * onenext - target state
+ * onedef - default base entry
+ * onesp - stack pointer
+ */
+
+extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+
+
+/* Variables for nfa machine data:
+ * current_mns - current maximum on number of NFA states
+ * num_rules - number of the last accepting state; also is number of
+ * 	rules created so far
+ * num_eof_rules - number of <<EOF>> rules
+ * default_rule - number of the default rule
+ * current_max_rules - current maximum number of rules
+ * lastnfa - last nfa state number created
+ * firstst - physically the first state of a fragment
+ * lastst - last physical state of fragment
+ * finalst - last logical state of fragment
+ * transchar - transition character
+ * trans1 - transition state
+ * trans2 - 2nd transition state for epsilons
+ * accptnum - accepting number
+ * assoc_rule - rule associated with this NFA state (or 0 if none)
+ * state_type - a STATE_xxx type identifying whether the state is part
+ * 	of a normal rule, the leading state in a trailing context
+ * 	rule (i.e., the state which marks the transition from
+ * 	recognizing the text-to-be-matched to the beginning of
+ * 	the trailing context), or a subsequent state in a trailing
+ * 	context rule
+ * rule_type - a RULE_xxx type identifying whether this a ho-hum
+ * 	normal rule or one which has variable head & trailing
+ * 	context
+ * rule_linenum - line number associated with rule
+ * rule_useful - true if we've determined that the rule can be matched
+ */
+
+extern int current_mns, num_rules, num_eof_rules, default_rule;
+extern int current_max_rules, lastnfa;
+extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
+extern int *accptnum, *assoc_rule, *state_type;
+extern int *rule_type, *rule_linenum, *rule_useful;
+
+/* Different types of states; values are useful as masks, as well, for
+ * routines like check_trailing_context().
+ */
+#define STATE_NORMAL 0x1
+#define STATE_TRAILING_CONTEXT 0x2
+
+/* Global holding current type of state we're making. */
+
+extern int current_state_type;
+
+/* Different types of rules. */
+#define RULE_NORMAL 0
+#define RULE_VARIABLE 1
+
+/* True if the input rules include a rule with both variable-length head
+ * and trailing context, false otherwise.
+ */
+extern int variable_trailing_context_rules;
+
+
+/* Variables for protos:
+ * numtemps - number of templates created
+ * numprots - number of protos created
+ * protprev - backlink to a more-recently used proto
+ * protnext - forward link to a less-recently used proto
+ * prottbl - base/def table entry for proto
+ * protcomst - common state of proto
+ * firstprot - number of the most recently used proto
+ * lastprot - number of the least recently used proto
+ * protsave contains the entire state array for protos
+ */
+
+extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
+extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
+
+
+/* Variables for managing equivalence classes:
+ * numecs - number of equivalence classes
+ * nextecm - forward link of Equivalence Class members
+ * ecgroup - class number or backward link of EC members
+ * nummecs - number of meta-equivalence classes (used to compress
+ *   templates)
+ * tecfwd - forward link of meta-equivalence classes members
+ * tecbck - backward link of MEC's
+ */
+
+/* Reserve enough room in the equivalence class arrays so that we
+ * can use the CSIZE'th element to hold equivalence class information
+ * for the NUL character.  Later we'll move this information into
+ * the 0th element.
+ */
+extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs;
+
+/* Meta-equivalence classes are indexed starting at 1, so it's possible
+ * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1
+ * slots total (since the arrays are 0-based).  nextecm[] and ecgroup[]
+ * don't require the extra position since they're indexed from 1 .. CSIZE - 1.
+ */
+extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1];
+
+
+/* Variables for start conditions:
+ * lastsc - last start condition created
+ * current_max_scs - current limit on number of start conditions
+ * scset - set of rules active in start condition
+ * scbol - set of rules active only at the beginning of line in a s.c.
+ * scxclu - true if start condition is exclusive
+ * sceof - true if start condition has EOF rule
+ * scname - start condition name
+ * actvsc - stack of active start conditions for the current rule;
+ * 	a negative entry means that the start condition is *not*
+ *	active for the current rule.  Start conditions may appear
+ *	multiple times on the stack; the entry for it closest
+ *	to the top of the stack (i.e., actvsc[actvp]) is the
+ *	one to use.  Others are present from "<sc>{" scoping
+ *	constructs.
+ */
+
+extern int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
+extern char **scname;
+
+
+/* Variables for dfa machine data:
+ * current_max_dfa_size - current maximum number of NFA states in DFA
+ * current_max_xpairs - current maximum number of non-template xtion pairs
+ * current_max_template_xpairs - current maximum number of template pairs
+ * current_max_dfas - current maximum number DFA states
+ * lastdfa - last dfa state number created
+ * nxt - state to enter upon reading character
+ * chk - check value to see if "nxt" applies
+ * tnxt - internal nxt table for templates
+ * base - offset into "nxt" for given state
+ * def - where to go if "chk" disallows "nxt" entry
+ * nultrans - NUL transition for each state
+ * NUL_ec - equivalence class of the NUL character
+ * tblend - last "nxt/chk" table entry being used
+ * firstfree - first empty entry in "nxt/chk" table
+ * dss - nfa state set for each dfa
+ * dfasiz - size of nfa state set for each dfa
+ * dfaacc - accepting set for each dfa state (if using REJECT), or accepting
+ *	number, if not
+ * accsiz - size of accepting set for each dfa state
+ * dhash - dfa state hash value
+ * numas - number of DFA accepting states created; note that this
+ *	is not necessarily the same value as num_rules, which is the analogous
+ *	value for the NFA
+ * numsnpairs - number of state/nextstate transition pairs
+ * jambase - position in base/def where the default jam table starts
+ * jamstate - state number corresponding to "jam" state
+ * end_of_buffer_state - end-of-buffer dfa state number
+ */
+
+extern int current_max_dfa_size, current_max_xpairs;
+extern int current_max_template_xpairs, current_max_dfas;
+extern int lastdfa, *nxt, *chk, *tnxt;
+extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
+extern union dfaacc_union
+	{
+	int *dfaacc_set;
+	int dfaacc_state;
+	} *dfaacc;
+extern int *accsiz, *dhash, numas;
+extern int numsnpairs, jambase, jamstate;
+extern int end_of_buffer_state;
+
+/* Variables for ccl information:
+ * lastccl - ccl index of the last created ccl
+ * current_maxccls - current limit on the maximum number of unique ccl's
+ * cclmap - maps a ccl index to its set pointer
+ * ccllen - gives the length of a ccl
+ * cclng - true for a given ccl if the ccl is negated
+ * cclreuse - counts how many times a ccl is re-used
+ * current_max_ccl_tbl_size - current limit on number of characters needed
+ *	to represent the unique ccl's
+ * ccltbl - holds the characters in each ccl - indexed by cclmap
+ */
+
+extern int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
+extern int current_max_ccl_tbl_size;
+extern Char *ccltbl;
+
+
+/* Variables for miscellaneous information:
+ * nmstr - last NAME scanned by the scanner
+ * sectnum - section number currently being parsed
+ * nummt - number of empty nxt/chk table entries
+ * hshcol - number of hash collisions detected by snstods
+ * dfaeql - number of times a newly created dfa was equal to an old one
+ * numeps - number of epsilon NFA states created
+ * eps2 - number of epsilon states which have 2 out-transitions
+ * num_reallocs - number of times it was necessary to realloc() a group
+ *	  of arrays
+ * tmpuses - number of DFA states that chain to templates
+ * totnst - total number of NFA states used to make DFA states
+ * peakpairs - peak number of transition pairs we had to store internally
+ * numuniq - number of unique transitions
+ * numdup - number of duplicate transitions
+ * hshsave - number of hash collisions saved by checking number of states
+ * num_backing_up - number of DFA states requiring backing up
+ * bol_needed - whether scanner needs beginning-of-line recognition
+ */
+
+extern char nmstr[MAXLINE];
+extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
+extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
+extern int num_backing_up, bol_needed;
+
+void *allocate_array PROTO((int, int));
+void *reallocate_array PROTO((void*, int, int));
+
+void *flex_alloc PROTO((unsigned int));
+void *flex_realloc PROTO((void*, unsigned int));
+void flex_free PROTO((void*));
+
+#define allocate_integer_array(size) \
+	(int *) allocate_array( size, sizeof( int ) )
+
+#define reallocate_integer_array(array,size) \
+	(int *) reallocate_array( (void *) array, size, sizeof( int ) )
+
+#define allocate_int_ptr_array(size) \
+	(int **) allocate_array( size, sizeof( int * ) )
+
+#define allocate_char_ptr_array(size) \
+	(char **) allocate_array( size, sizeof( char * ) )
+
+#define allocate_dfaacc_union(size) \
+	(union dfaacc_union *) \
+		allocate_array( size, sizeof( union dfaacc_union ) )
+
+#define reallocate_int_ptr_array(array,size) \
+	(int **) reallocate_array( (void *) array, size, sizeof( int * ) )
+
+#define reallocate_char_ptr_array(array,size) \
+	(char **) reallocate_array( (void *) array, size, sizeof( char * ) )
+
+#define reallocate_dfaacc_union(array, size) \
+	(union dfaacc_union *) \
+	reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) )
+
+#define allocate_character_array(size) \
+	(char *) allocate_array( size, sizeof( char ) )
+
+#define reallocate_character_array(array,size) \
+	(char *) reallocate_array( (void *) array, size, sizeof( char ) )
+
+#define allocate_Character_array(size) \
+	(Char *) allocate_array( size, sizeof( Char ) )
+
+#define reallocate_Character_array(array,size) \
+	(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
+
+
+/* Used to communicate between scanner and parser.  The type should really
+ * be YYSTYPE, but we can't easily get our hands on it.
+ */
+extern int yylval;
+
+
+/* External functions that are cross-referenced among the flex source files. */
+
+
+/* from file ccl.c */
+
+extern void ccladd PROTO((int, int));	/* add a single character to a ccl */
+extern int cclinit PROTO((void));	/* make an empty ccl */
+extern void cclnegate PROTO((int));	/* negate a ccl */
+
+/* List the members of a set of characters in CCL form. */
+extern void list_character_set PROTO((FILE*, int[]));
+
+
+/* from file dfa.c */
+
+/* Increase the maximum number of dfas. */
+extern void increase_max_dfas PROTO((void));
+
+extern void ntod PROTO((void));	/* convert a ndfa to a dfa */
+
+
+/* from file ecs.c */
+
+/* Convert character classes to set of equivalence classes. */
+extern void ccl2ecl PROTO((void));
+
+/* Associate equivalence class numbers with class members. */
+extern int cre8ecs PROTO((int[], int[], int));
+
+/* Update equivalence classes based on character class transitions. */
+extern void mkeccl PROTO((Char[], int, int[], int[], int, int));
+
+/* Create equivalence class for single character. */
+extern void mkechar PROTO((int, int[], int[]));
+
+
+/* from file gen.c */
+
+extern void make_tables PROTO((void));	/* generate transition tables */
+
+
+/* from file main.c */
+
+extern void flexend PROTO((int));
+extern void usage PROTO((void));
+
+
+/* from file misc.c */
+
+/* Add the given text to the stored actions. */
+extern void add_action PROTO(( char *new_text ));
+
+/* True if a string is all lower case. */
+extern int all_lower PROTO((register char *));
+
+/* True if a string is all upper case. */
+extern int all_upper PROTO((register char *));
+
+/* Bubble sort an integer array. */
+extern void bubble PROTO((int [], int));
+
+/* Check a character to make sure it's in the expected range. */
+extern void check_char PROTO((int c));
+
+/* Shell sort a character array. */
+extern void cshell PROTO((Char [], int, int));
+
+/* Finish up a block of data declarations. */
+extern void dataend PROTO((void));
+
+/* Report an error message and terminate. */
+extern void flexerror PROTO((char[]));
+
+/* Report a fatal error message and terminate. */
+extern void flexfatal PROTO((char[]));
+
+/* Report an error message formatted with one integer argument. */
+extern void lerrif PROTO((char[], int));
+
+/* Report an error message formatted with one string argument. */
+extern void lerrsf PROTO((char[], char[]));
+
+/* Spit out a "# line" statement. */
+extern void line_directive_out PROTO((FILE*));
+
+/* Mark the current position in the action array as the end of the section 1
+ * user defs.
+ */
+extern void mark_defs1 PROTO((void));
+
+/* Mark the current position in the action array as the end of the prolog. */
+extern void mark_prolog PROTO((void));
+
+/* Generate a data statment for a two-dimensional array. */
+extern void mk2data PROTO((int));
+
+extern void mkdata PROTO((int));	/* generate a data statement */
+
+/* Return the integer represented by a string of digits. */
+extern int myctoi PROTO((char []));
+
+/* Return a printable version of the given character, which might be
+ * 8-bit.
+ */
+extern char *readable_form PROTO((int));
+
+/* Write out one section of the skeleton file. */
+extern void skelout PROTO((void));
+
+/* Output a yy_trans_info structure. */
+extern void transition_struct_out PROTO((int, int));
+
+/* Only needed when using certain broken versions of bison to build parse.c. */
+extern void *yy_flex_xmalloc PROTO(( int ));
+
+/* Set a region of memory to 0. */
+extern void zero_out PROTO((char *, int));
+
+
+/* from file nfa.c */
+
+/* Add an accepting state to a machine. */
+extern void add_accept PROTO((int, int));
+
+/* Make a given number of copies of a singleton machine. */
+extern int copysingl PROTO((int, int));
+
+/* Debugging routine to write out an nfa. */
+extern void dumpnfa PROTO((int));
+
+/* Finish up the processing for a rule. */
+extern void finish_rule PROTO((int, int, int, int));
+
+/* Connect two machines together. */
+extern int link_machines PROTO((int, int));
+
+/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
+ * not trailing context associated) state.
+ */
+extern void mark_beginning_as_normal PROTO((register int));
+
+/* Make a machine that branches to two machines. */
+extern int mkbranch PROTO((int, int));
+
+extern int mkclos PROTO((int));	/* convert a machine into a closure */
+extern int mkopt PROTO((int));	/* make a machine optional */
+
+/* Make a machine that matches either one of two machines. */
+extern int mkor PROTO((int, int));
+
+/* Convert a machine into a positive closure. */
+extern int mkposcl PROTO((int));
+
+extern int mkrep PROTO((int, int, int));	/* make a replicated machine */
+
+/* Create a state with a transition on a given symbol. */
+extern int mkstate PROTO((int));
+
+extern void new_rule PROTO((void));	/* initialize for a new rule */
+
+
+/* from file parse.y */
+
+/* Write out a message formatted with one string, pinpointing its location. */
+extern void format_pinpoint_message PROTO((char[], char[]));
+
+/* Write out a message, pinpointing its location. */
+extern void pinpoint_message PROTO((char[]));
+
+/* Write out a warning, pinpointing it at the given line. */
+void line_warning PROTO(( char[], int ));
+
+/* Write out a message, pinpointing it at the given line. */
+void line_pinpoint PROTO(( char[], int ));
+
+/* Report a formatted syntax error. */
+extern void format_synerr PROTO((char [], char[]));
+extern void synerr PROTO((char []));	/* report a syntax error */
+extern void warn PROTO((char []));	/* report a warning */
+extern int yyparse PROTO((void));	/* the YACC parser */
+
+
+/* from file scan.l */
+
+/* The Flex-generated scanner for flex. */
+extern int flexscan PROTO((void));
+
+/* Open the given file (if NULL, stdin) for scanning. */
+extern void set_input_file PROTO((char*));
+
+/* Wrapup a file in the lexical analyzer. */
+extern int yywrap PROTO((void));
+
+
+/* from file sym.c */
+
+/* Save the text of a character class. */
+extern void cclinstal PROTO ((Char [], int));
+
+/* Lookup the number associated with character class. */
+extern int ccllookup PROTO((Char []));
+
+extern void ndinstal PROTO((char[], Char[]));	/* install a name definition */
+/* Increase maximum number of SC's. */
+extern void scextend PROTO((void));
+extern void scinstal PROTO((char[], int));	/* make a start condition */
+
+/* Lookup the number associated with a start condition. */
+extern int sclookup PROTO((char[]));
+
+
+/* from file tblcmp.c */
+
+/* Build table entries for dfa state. */
+extern void bldtbl PROTO((int[], int, int, int, int));
+
+extern void cmptmps PROTO((void));	/* compress template table entries */
+extern void expand_nxt_chk PROTO((void));	/* increase nxt/chk arrays */
+extern void inittbl PROTO((void));	/* initialize transition tables */
+/* Make the default, "jam" table entries. */
+extern void mkdeftbl PROTO((void));
+
+/* Create table entries for a state (or state fragment) which has
+ * only one out-transition.
+ */
+extern void mk1tbl PROTO((int, int, int, int));
+
+/* Place a state into full speed transition table. */
+extern void place_state PROTO((int*, int, int));
+
+/* Save states with only one out-transition to be processed later. */
+extern void stack1 PROTO((int, int, int, int));
+
+
+/* from file yylex.c */
+
+extern int yylex PROTO((void));
diff --git a/usr.bin/lex/flexdoc.1 b/usr.bin/lex/flexdoc.1
new file mode 100644
index 000000000000..b80d5699abca
--- /dev/null
+++ b/usr.bin/lex/flexdoc.1
@@ -0,0 +1,3045 @@
+.TH FLEXDOC 1 "November 1993" "Version 2.4"
+.SH NAME
+flexdoc \- documentation for flex, fast lexical analyzer generator
+.SH SYNOPSIS
+.B flex
+.B [\-bcdfhilnpstvwBFILTV78+ \-C[aefFmr] \-Pprefix \-Sskeleton]
+.I [filename ...]
+.SH DESCRIPTION
+.I flex
+is a tool for generating
+.I scanners:
+programs which recognized lexical patterns in text.
+.I flex
+reads
+the given input files, or its standard input if no file names are given,
+for a description of a scanner to generate.  The description is in
+the form of pairs
+of regular expressions and C code, called
+.I rules.  flex
+generates as output a C source file,
+.B lex.yy.c,
+which defines a routine
+.B yylex().
+This file is compiled and linked with the
+.B \-lfl
+library to produce an executable.  When the executable is run,
+it analyzes its input for occurrences
+of the regular expressions.  Whenever it finds one, it executes
+the corresponding C code.
+.SH SOME SIMPLE EXAMPLES
+.PP
+First some simple examples to get the flavor of how one uses
+.I flex.
+The following
+.I flex
+input specifies a scanner which whenever it encounters the string
+"username" will replace it with the user's login name:
+.nf
+
+    %%
+    username    printf( "%s", getlogin() );
+
+.fi
+By default, any text not matched by a
+.I flex
+scanner
+is copied to the output, so the net effect of this scanner is
+to copy its input file to its output with each occurrence
+of "username" expanded.
+In this input, there is just one rule.  "username" is the
+.I pattern
+and the "printf" is the
+.I action.
+The "%%" marks the beginning of the rules.
+.PP
+Here's another simple example:
+.nf
+
+            int num_lines = 0, num_chars = 0;
+
+    %%
+    \\n      ++num_lines; ++num_chars;
+    .       ++num_chars;
+
+    %%
+    main()
+            {
+            yylex();
+            printf( "# of lines = %d, # of chars = %d\\n",
+                    num_lines, num_chars );
+            }
+
+.fi
+This scanner counts the number of characters and the number
+of lines in its input (it produces no output other than the
+final report on the counts).  The first line
+declares two globals, "num_lines" and "num_chars", which are accessible
+both inside
+.B yylex()
+and in the
+.B main()
+routine declared after the second "%%".  There are two rules, one
+which matches a newline ("\\n") and increments both the line count and
+the character count, and one which matches any character other than
+a newline (indicated by the "." regular expression).
+.PP
+A somewhat more complicated example:
+.nf
+
+    /* scanner for a toy Pascal-like language */
+
+    %{
+    /* need this for the call to atof() below */
+    #include <math.h>
+    %}
+
+    DIGIT    [0-9]
+    ID       [a-z][a-z0-9]*
+
+    %%
+
+    {DIGIT}+    {
+                printf( "An integer: %s (%d)\\n", yytext,
+                        atoi( yytext ) );
+                }
+
+    {DIGIT}+"."{DIGIT}*        {
+                printf( "A float: %s (%g)\\n", yytext,
+                        atof( yytext ) );
+                }
+
+    if|then|begin|end|procedure|function        {
+                printf( "A keyword: %s\\n", yytext );
+                }
+
+    {ID}        printf( "An identifier: %s\\n", yytext );
+
+    "+"|"-"|"*"|"/"   printf( "An operator: %s\\n", yytext );
+
+    "{"[^}\\n]*"}"     /* eat up one-line comments */
+
+    [ \\t\\n]+          /* eat up whitespace */
+
+    .           printf( "Unrecognized character: %s\\n", yytext );
+
+    %%
+
+    main( argc, argv )
+    int argc;
+    char **argv;
+        {
+        ++argv, --argc;  /* skip over program name */
+        if ( argc > 0 )
+                yyin = fopen( argv[0], "r" );
+        else
+                yyin = stdin;
+        
+        yylex();
+        }
+
+.fi
+This is the beginnings of a simple scanner for a language like
+Pascal.  It identifies different types of
+.I tokens
+and reports on what it has seen.
+.PP
+The details of this example will be explained in the following
+sections.
+.SH FORMAT OF THE INPUT FILE
+The
+.I flex
+input file consists of three sections, separated by a line with just
+.B %%
+in it:
+.nf
+
+    definitions
+    %%
+    rules
+    %%
+    user code
+
+.fi
+The
+.I definitions
+section contains declarations of simple
+.I name
+definitions to simplify the scanner specification, and declarations of
+.I start conditions,
+which are explained in a later section.
+.PP
+Name definitions have the form:
+.nf
+
+    name definition
+
+.fi
+The "name" is a word beginning with a letter or an underscore ('_')
+followed by zero or more letters, digits, '_', or '-' (dash).
+The definition is taken to begin at the first non-white-space character
+following the name and continuing to the end of the line.
+The definition can subsequently be referred to using "{name}", which
+will expand to "(definition)".  For example,
+.nf
+
+    DIGIT    [0-9]
+    ID       [a-z][a-z0-9]*
+
+.fi
+defines "DIGIT" to be a regular expression which matches a
+single digit, and
+"ID" to be a regular expression which matches a letter
+followed by zero-or-more letters-or-digits.
+A subsequent reference to
+.nf
+
+    {DIGIT}+"."{DIGIT}*
+
+.fi
+is identical to
+.nf
+
+    ([0-9])+"."([0-9])*
+
+.fi
+and matches one-or-more digits followed by a '.' followed
+by zero-or-more digits.
+.PP
+The
+.I rules
+section of the
+.I flex
+input contains a series of rules of the form:
+.nf
+
+    pattern   action
+
+.fi
+where the pattern must be unindented and the action must begin
+on the same line.
+.PP
+See below for a further description of patterns and actions.
+.PP
+Finally, the user code section is simply copied to
+.B lex.yy.c
+verbatim.
+It is used for companion routines which call or are called
+by the scanner.  The presence of this section is optional;
+if it is missing, the second
+.B %%
+in the input file may be skipped, too.
+.PP
+In the definitions and rules sections, any
+.I indented
+text or text enclosed in
+.B %{
+and
+.B %}
+is copied verbatim to the output (with the %{}'s removed).
+The %{}'s must appear unindented on lines by themselves.
+.PP
+In the rules section,
+any indented or %{} text appearing before the
+first rule may be used to declare variables
+which are local to the scanning routine and (after the declarations)
+code which is to be executed whenever the scanning routine is entered.
+Other indented or %{} text in the rule section is still copied to the output,
+but its meaning is not well-defined and it may well cause compile-time
+errors (this feature is present for
+.I POSIX
+compliance; see below for other such features).
+.PP
+In the definitions section (but not in the rules section),
+an unindented comment (i.e., a line
+beginning with "/*") is also copied verbatim to the output up
+to the next "*/".
+.SH PATTERNS
+The patterns in the input are written using an extended set of regular
+expressions.  These are:
+.nf
+
+    x          match the character 'x'
+    .          any character except newline
+    [xyz]      a "character class"; in this case, the pattern
+                 matches either an 'x', a 'y', or a 'z'
+    [abj-oZ]   a "character class" with a range in it; matches
+                 an 'a', a 'b', any letter from 'j' through 'o',
+                 or a 'Z'
+    [^A-Z]     a "negated character class", i.e., any character
+                 but those in the class.  In this case, any
+                 character EXCEPT an uppercase letter.
+    [^A-Z\\n]   any character EXCEPT an uppercase letter or
+                 a newline
+    r*         zero or more r's, where r is any regular expression
+    r+         one or more r's
+    r?         zero or one r's (that is, "an optional r")
+    r{2,5}     anywhere from two to five r's
+    r{2,}      two or more r's
+    r{4}       exactly 4 r's
+    {name}     the expansion of the "name" definition
+               (see above)
+    "[xyz]\\"foo"
+               the literal string: [xyz]"foo
+    \\X         if X is an 'a', 'b', 'f', 'n', 'r', 't', or 'v',
+                 then the ANSI-C interpretation of \\x.
+                 Otherwise, a literal 'X' (used to escape
+                 operators such as '*')
+    \\123       the character with octal value 123
+    \\x2a       the character with hexadecimal value 2a
+    (r)        match an r; parentheses are used to override
+                 precedence (see below)
+
+
+    rs         the regular expression r followed by the
+                 regular expression s; called "concatenation"
+
+
+    r|s        either an r or an s
+
+
+    r/s        an r but only if it is followed by an s.  The
+                 s is not part of the matched text.  This type
+                 of pattern is called as "trailing context".
+    ^r         an r, but only at the beginning of a line
+    r$         an r, but only at the end of a line.  Equivalent
+                 to "r/\\n".
+
+
+    <s>r       an r, but only in start condition s (see
+               below for discussion of start conditions)
+    <s1,s2,s3>r
+               same, but in any of start conditions s1,
+               s2, or s3
+    <*>r       an r in any start condition, even an exclusive one.
+
+
+    <<EOF>>    an end-of-file
+    <s1,s2><<EOF>>
+               an end-of-file when in start condition s1 or s2
+
+.fi
+Note that inside of a character class, all regular expression operators
+lose their special meaning except escape ('\\') and the character class
+operators, '-', ']', and, at the beginning of the class, '^'.
+.PP
+The regular expressions listed above are grouped according to
+precedence, from highest precedence at the top to lowest at the bottom.
+Those grouped together have equal precedence.  For example,
+.nf
+
+    foo|bar*
+
+.fi
+is the same as
+.nf
+
+    (foo)|(ba(r*))
+
+.fi
+since the '*' operator has higher precedence than concatenation,
+and concatenation higher than alternation ('|').  This pattern
+therefore matches
+.I either
+the string "foo"
+.I or
+the string "ba" followed by zero-or-more r's.
+To match "foo" or zero-or-more "bar"'s, use:
+.nf
+
+    foo|(bar)*
+
+.fi
+and to match zero-or-more "foo"'s-or-"bar"'s:
+.nf
+
+    (foo|bar)*
+
+.fi
+.PP
+Some notes on patterns:
+.IP -
+A negated character class such as the example "[^A-Z]"
+above
+.I will match a newline
+unless "\\n" (or an equivalent escape sequence) is one of the
+characters explicitly present in the negated character class
+(e.g., "[^A-Z\\n]").  This is unlike how many other regular
+expression tools treat negated character classes, but unfortunately
+the inconsistency is historically entrenched.
+Matching newlines means that a pattern like [^"]* can match the entire
+input unless there's another quote in the input.
+.IP -
+A rule can have at most one instance of trailing context (the '/' operator
+or the '$' operator).  The start condition, '^', and "<<EOF>>" patterns
+can only occur at the beginning of a pattern, and, as well as with '/' and '$',
+cannot be grouped inside parentheses.  A '^' which does not occur at
+the beginning of a rule or a '$' which does not occur at the end of
+a rule loses its special properties and is treated as a normal character.
+.IP
+The following are illegal:
+.nf
+
+    foo/bar$
+    <sc1>foo<sc2>bar
+
+.fi
+Note that the first of these, can be written "foo/bar\\n".
+.IP
+The following will result in '$' or '^' being treated as a normal character:
+.nf
+
+    foo|(bar$)
+    foo|^bar
+
+.fi
+If what's wanted is a "foo" or a bar-followed-by-a-newline, the following
+could be used (the special '|' action is explained below):
+.nf
+
+    foo      |
+    bar$     /* action goes here */
+
+.fi
+A similar trick will work for matching a foo or a
+bar-at-the-beginning-of-a-line.
+.SH HOW THE INPUT IS MATCHED
+When the generated scanner is run, it analyzes its input looking
+for strings which match any of its patterns.  If it finds more than
+one match, it takes the one matching the most text (for trailing
+context rules, this includes the length of the trailing part, even
+though it will then be returned to the input).  If it finds two
+or more matches of the same length, the
+rule listed first in the
+.I flex
+input file is chosen.
+.PP
+Once the match is determined, the text corresponding to the match
+(called the
+.I token)
+is made available in the global character pointer
+.B yytext,
+and its length in the global integer
+.B yyleng.
+The
+.I action
+corresponding to the matched pattern is then executed (a more
+detailed description of actions follows), and then the remaining
+input is scanned for another match.
+.PP
+If no match is found, then the
+.I default rule
+is executed: the next character in the input is considered matched and
+copied to the standard output.  Thus, the simplest legal
+.I flex
+input is:
+.nf
+
+    %%
+
+.fi
+which generates a scanner that simply copies its input (one character
+at a time) to its output.
+.PP
+Note that
+.B yytext
+can be defined in two different ways: either as a character
+.I pointer
+or as a character
+.I array.
+You can control which definition
+.I flex
+uses by including one of the special directives
+.B %pointer
+or
+.B %array
+in the first (definitions) section of your flex input.  The default is
+.B %pointer,
+unless you use the
+.B -l
+lex compatibility option, in which case
+.B yytext
+will be an array.
+The advantage of using
+.B %pointer
+is substantially faster scanning and no buffer overflow when matching
+very large tokens (unless you run out of dynamic memory).  The disadvantage
+is that you are restricted in how your actions can modify
+.B yytext
+(see the next section), and calls to the
+.B input()
+and
+.B unput()
+functions destroy the present contents of
+.B yytext,
+which can be a considerable porting headache when moving between different
+.I lex
+versions.
+.PP
+The advantage of
+.B %array
+is that you can then modify
+.B yytext
+to your heart's content, and calls to
+.B input()
+and
+.B unput()
+do not destroy
+.B yytext
+(see below).  Furthermore, existing
+.I lex
+programs sometimes access
+.B yytext
+externally using declarations of the form:
+.nf
+    extern char yytext[];
+.fi
+This definition is erroneous when used with
+.B %pointer,
+but correct for
+.B %array.
+.PP
+.B %array
+defines
+.B yytext
+to be an array of
+.B YYLMAX
+characters, which defaults to a fairly large value.  You can change
+the size by simply #define'ing
+.B YYLMAX
+to a different value in the first section of your
+.I flex
+input.  As mentioned above, with
+.B %pointer
+yytext grows dynamically to accomodate large tokens.  While this means your
+.B %pointer
+scanner can accomodate very large tokens (such as matching entire blocks
+of comments), bear in mind that each time the scanner must resize
+.B yytext
+it also must rescan the entire token from the beginning, so matching such
+tokens can prove slow.
+.B yytext
+presently does
+.I not
+dynamically grow if a call to
+.B unput()
+results in too much text being pushed back; instead, a run-time error results.
+.PP
+Also note that you cannot use
+.B %array
+with C++ scanner classes
+(the
+.B \-+
+option; see below).
+.SH ACTIONS
+Each pattern in a rule has a corresponding action, which can be any
+arbitrary C statement.  The pattern ends at the first non-escaped
+whitespace character; the remainder of the line is its action.  If the
+action is empty, then when the pattern is matched the input token
+is simply discarded.  For example, here is the specification for a program
+which deletes all occurrences of "zap me" from its input:
+.nf
+
+    %%
+    "zap me"
+
+.fi
+(It will copy all other characters in the input to the output since
+they will be matched by the default rule.)
+.PP
+Here is a program which compresses multiple blanks and tabs down to
+a single blank, and throws away whitespace found at the end of a line:
+.nf
+
+    %%
+    [ \\t]+        putchar( ' ' );
+    [ \\t]+$       /* ignore this token */
+
+.fi
+.PP
+If the action contains a '{', then the action spans till the balancing '}'
+is found, and the action may cross multiple lines.
+.I flex 
+knows about C strings and comments and won't be fooled by braces found
+within them, but also allows actions to begin with
+.B %{
+and will consider the action to be all the text up to the next
+.B %}
+(regardless of ordinary braces inside the action).
+.PP
+An action consisting solely of a vertical bar ('|') means "same as
+the action for the next rule."  See below for an illustration.
+.PP
+Actions can include arbitrary C code, including
+.B return
+statements to return a value to whatever routine called
+.B yylex().
+Each time
+.B yylex()
+is called it continues processing tokens from where it last left
+off until it either reaches
+the end of the file or executes a return.
+.PP
+Actions are free to modify
+.B yytext
+except for lengthening it (adding
+characters to its end--these will overwrite later characters in the
+input stream).  Modifying the final character of yytext may alter
+whether when scanning resumes rules anchored with '^' are active.
+Specifically, changing the final character of yytext to a newline will
+activate such rules on the next scan, and changing it to anything else
+will deactivate the rules.  Users should not rely on this behavior being
+present in future releases.  Finally, note that none of this paragraph
+applies when using
+.B %array
+(see above).
+.PP
+Actions are free to modify
+.B yyleng
+except they should not do so if the action also includes use of
+.B yymore()
+(see below).
+.PP
+There are a number of special directives which can be included within
+an action:
+.IP -
+.B ECHO
+copies yytext to the scanner's output.
+.IP -
+.B BEGIN
+followed by the name of a start condition places the scanner in the
+corresponding start condition (see below).
+.IP -
+.B REJECT
+directs the scanner to proceed on to the "second best" rule which matched the
+input (or a prefix of the input).  The rule is chosen as described
+above in "How the Input is Matched", and
+.B yytext
+and
+.B yyleng
+set up appropriately.
+It may either be one which matched as much text
+as the originally chosen rule but came later in the
+.I flex
+input file, or one which matched less text.
+For example, the following will both count the
+words in the input and call the routine special() whenever "frob" is seen:
+.nf
+
+            int word_count = 0;
+    %%
+
+    frob        special(); REJECT;
+    [^ \\t\\n]+   ++word_count;
+
+.fi
+Without the
+.B REJECT,
+any "frob"'s in the input would not be counted as words, since the
+scanner normally executes only one action per token.
+Multiple
+.B REJECT's
+are allowed, each one finding the next best choice to the currently
+active rule.  For example, when the following scanner scans the token
+"abcd", it will write "abcdabcaba" to the output:
+.nf
+
+    %%
+    a        |
+    ab       |
+    abc      |
+    abcd     ECHO; REJECT;
+    .|\\n     /* eat up any unmatched character */
+
+.fi
+(The first three rules share the fourth's action since they use
+the special '|' action.)
+.B REJECT
+is a particularly expensive feature in terms scanner performance;
+if it is used in
+.I any
+of the scanner's actions it will slow down
+.I all
+of the scanner's matching.  Furthermore,
+.B REJECT
+cannot be used with the
+.I -Cf
+or
+.I -CF
+options (see below).
+.IP
+Note also that unlike the other special actions,
+.B REJECT
+is a
+.I branch;
+code immediately following it in the action will
+.I not
+be executed.
+.IP -
+.B yymore()
+tells the scanner that the next time it matches a rule, the corresponding
+token should be
+.I appended
+onto the current value of
+.B yytext
+rather than replacing it.  For example, given the input "mega-kludge"
+the following will write "mega-mega-kludge" to the output:
+.nf
+
+    %%
+    mega-    ECHO; yymore();
+    kludge   ECHO;
+
+.fi
+First "mega-" is matched and echoed to the output.  Then "kludge"
+is matched, but the previous "mega-" is still hanging around at the
+beginning of
+.B yytext
+so the
+.B ECHO
+for the "kludge" rule will actually write "mega-kludge".
+The presence of
+.B yymore()
+in the scanner's action entails a minor performance penalty in the
+scanner's matching speed.
+.IP -
+.B yyless(n)
+returns all but the first
+.I n
+characters of the current token back to the input stream, where they
+will be rescanned when the scanner looks for the next match.
+.B yytext
+and
+.B yyleng
+are adjusted appropriately (e.g.,
+.B yyleng
+will now be equal to
+.I n
+).  For example, on the input "foobar" the following will write out
+"foobarbar":
+.nf
+
+    %%
+    foobar    ECHO; yyless(3);
+    [a-z]+    ECHO;
+
+.fi
+An argument of 0 to
+.B yyless
+will cause the entire current input string to be scanned again.  Unless you've
+changed how the scanner will subsequently process its input (using
+.B BEGIN,
+for example), this will result in an endless loop.
+.PP
+Note that
+.B yyless
+is a macro and can only be used in the flex input file, not from
+other source files.
+.IP -
+.B unput(c)
+puts the character
+.I c
+back onto the input stream.  It will be the next character scanned.
+The following action will take the current token and cause it
+to be rescanned enclosed in parentheses.
+.nf
+
+    {
+    int i;
+    unput( ')' );
+    for ( i = yyleng - 1; i >= 0; --i )
+        unput( yytext[i] );
+    unput( '(' );
+    }
+
+.fi
+Note that since each
+.B unput()
+puts the given character back at the
+.I beginning
+of the input stream, pushing back strings must be done back-to-front.
+Also note that you cannot put back
+.B EOF
+to attempt to mark the input stream with an end-of-file.
+.IP -
+.B input()
+reads the next character from the input stream.  For example,
+the following is one way to eat up C comments:
+.nf
+
+    %%
+    "/*"        {
+                register int c;
+
+                for ( ; ; )
+                    {
+                    while ( (c = input()) != '*' &&
+                            c != EOF )
+                        ;    /* eat up text of comment */
+
+                    if ( c == '*' )
+                        {
+                        while ( (c = input()) == '*' )
+                            ;
+                        if ( c == '/' )
+                            break;    /* found the end */
+                        }
+
+                    if ( c == EOF )
+                        {
+                        error( "EOF in comment" );
+                        break;
+                        }
+                    }
+                }
+
+.fi
+(Note that if the scanner is compiled using
+.B C++,
+then
+.B input()
+is instead referred to as
+.B yyinput(),
+in order to avoid a name clash with the
+.B C++
+stream by the name of
+.I input.)
+.IP -
+.B yyterminate()
+can be used in lieu of a return statement in an action.  It terminates
+the scanner and returns a 0 to the scanner's caller, indicating "all done".
+By default,
+.B yyterminate()
+is also called when an end-of-file is encountered.  It is a macro and
+may be redefined.
+.SH THE GENERATED SCANNER
+The output of
+.I flex
+is the file
+.B lex.yy.c,
+which contains the scanning routine
+.B yylex(),
+a number of tables used by it for matching tokens, and a number
+of auxiliary routines and macros.  By default,
+.B yylex()
+is declared as follows:
+.nf
+
+    int yylex()
+        {
+        ... various definitions and the actions in here ...
+        }
+
+.fi
+(If your environment supports function prototypes, then it will
+be "int yylex( void )".)  This definition may be changed by defining
+the "YY_DECL" macro.  For example, you could use:
+.nf
+
+    #define YY_DECL float lexscan( a, b ) float a, b;
+
+.fi
+to give the scanning routine the name
+.I lexscan,
+returning a float, and taking two floats as arguments.  Note that
+if you give arguments to the scanning routine using a
+K&R-style/non-prototyped function declaration, you must terminate
+the definition with a semi-colon (;).
+.PP
+Whenever
+.B yylex()
+is called, it scans tokens from the global input file
+.I yyin
+(which defaults to stdin).  It continues until it either reaches
+an end-of-file (at which point it returns the value 0) or
+one of its actions executes a
+.I return
+statement.
+.PP
+If the scanner reaches an end-of-file, subsequent calls are undefined
+unless either
+.I yyin
+is pointed at a new input file (in which case scanning continues from
+that file), or
+.B yyrestart()
+is called.
+.B yyrestart()
+takes one argument, a
+.B FILE *
+pointer, and initializes
+.I yyin
+for scanning from that file.  Essentially there is no difference between
+just assigning
+.I yyin
+to a new input file or using
+.B yyrestart()
+to do so; the latter is available for compatibility with previous versions
+of
+.I flex,
+and because it can be used to switch input files in the middle of scanning.
+It can also be used to throw away the current input buffer, by calling
+it with an argument of
+.I yyin.
+.PP
+If
+.B yylex()
+stops scanning due to executing a
+.I return
+statement in one of the actions, the scanner may then be called again and it
+will resume scanning where it left off.
+.PP
+By default (and for purposes of efficiency), the scanner uses
+block-reads rather than simple
+.I getc()
+calls to read characters from
+.I yyin.
+The nature of how it gets its input can be controlled by defining the
+.B YY_INPUT
+macro.
+YY_INPUT's calling sequence is "YY_INPUT(buf,result,max_size)".  Its
+action is to place up to
+.I max_size
+characters in the character array
+.I buf
+and return in the integer variable
+.I result
+either the
+number of characters read or the constant YY_NULL (0 on Unix systems)
+to indicate EOF.  The default YY_INPUT reads from the
+global file-pointer "yyin".
+.PP
+A sample definition of YY_INPUT (in the definitions
+section of the input file):
+.nf
+
+    %{
+    #define YY_INPUT(buf,result,max_size) \\
+        { \\
+        int c = getchar(); \\
+        result = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \\
+        }
+    %}
+
+.fi
+This definition will change the input processing to occur
+one character at a time.
+.PP
+You also can add in things like keeping track of the
+input line number this way; but don't expect your scanner to
+go very fast.
+.PP
+When the scanner receives an end-of-file indication from YY_INPUT,
+it then checks the
+.B yywrap()
+function.  If
+.B yywrap()
+returns false (zero), then it is assumed that the
+function has gone ahead and set up
+.I yyin
+to point to another input file, and scanning continues.  If it returns
+true (non-zero), then the scanner terminates, returning 0 to its
+caller.
+.PP
+The default
+.B yywrap()
+always returns 1.
+.PP
+The scanner writes its
+.B ECHO
+output to the
+.I yyout
+global (default, stdout), which may be redefined by the user simply
+by assigning it to some other
+.B FILE
+pointer.
+.SH START CONDITIONS
+.I flex
+provides a mechanism for conditionally activating rules.  Any rule
+whose pattern is prefixed with "<sc>" will only be active when
+the scanner is in the start condition named "sc".  For example,
+.nf
+
+    <STRING>[^"]*        { /* eat up the string body ... */
+                ...
+                }
+
+.fi
+will be active only when the scanner is in the "STRING" start
+condition, and
+.nf
+
+    <INITIAL,STRING,QUOTE>\\.        { /* handle an escape ... */
+                ...
+                }
+
+.fi
+will be active only when the current start condition is
+either "INITIAL", "STRING", or "QUOTE".
+.PP
+Start conditions
+are declared in the definitions (first) section of the input
+using unindented lines beginning with either
+.B %s
+or
+.B %x
+followed by a list of names.
+The former declares
+.I inclusive
+start conditions, the latter
+.I exclusive
+start conditions.  A start condition is activated using the
+.B BEGIN
+action.  Until the next
+.B BEGIN
+action is executed, rules with the given start
+condition will be active and
+rules with other start conditions will be inactive.
+If the start condition is
+.I inclusive,
+then rules with no start conditions at all will also be active.
+If it is
+.I exclusive,
+then
+.I only
+rules qualified with the start condition will be active.
+A set of rules contingent on the same exclusive start condition
+describe a scanner which is independent of any of the other rules in the
+.I flex
+input.  Because of this,
+exclusive start conditions make it easy to specify "mini-scanners"
+which scan portions of the input that are syntactically different
+from the rest (e.g., comments).
+.PP
+If the distinction between inclusive and exclusive start conditions
+is still a little vague, here's a simple example illustrating the
+connection between the two.  The set of rules:
+.nf
+
+    %s example
+    %%
+    <example>foo           /* do something */
+
+.fi
+is equivalent to
+.nf
+
+    %x example
+    %%
+    <INITIAL,example>foo   /* do something */
+
+.fi
+.PP
+Also note that the special start-condition specifier
+.B <*>
+matches every start condition.  Thus, the above example could also
+have been written;
+.nf
+
+    %x example
+    %%
+    <*>foo   /* do something */
+
+.fi
+.PP
+The default rule (to
+.B ECHO
+any unmatched character) remains active in start conditions.
+.PP
+.B BEGIN(0)
+returns to the original state where only the rules with
+no start conditions are active.  This state can also be
+referred to as the start-condition "INITIAL", so
+.B BEGIN(INITIAL)
+is equivalent to
+.B BEGIN(0).
+(The parentheses around the start condition name are not required but
+are considered good style.)
+.PP
+.B BEGIN
+actions can also be given as indented code at the beginning
+of the rules section.  For example, the following will cause
+the scanner to enter the "SPECIAL" start condition whenever
+.I yylex()
+is called and the global variable
+.I enter_special
+is true:
+.nf
+
+            int enter_special;
+
+    %x SPECIAL
+    %%
+            if ( enter_special )
+                BEGIN(SPECIAL);
+
+    <SPECIAL>blahblahblah
+    ...more rules follow...
+
+.fi
+.PP
+To illustrate the uses of start conditions,
+here is a scanner which provides two different interpretations
+of a string like "123.456".  By default it will treat it as
+as three tokens, the integer "123", a dot ('.'), and the integer "456".
+But if the string is preceded earlier in the line by the string
+"expect-floats"
+it will treat it as a single token, the floating-point number
+123.456:
+.nf
+
+    %{
+    #include <math.h>
+    %}
+    %s expect
+
+    %%
+    expect-floats        BEGIN(expect);
+
+    <expect>[0-9]+"."[0-9]+      {
+                printf( "found a float, = %f\\n",
+                        atof( yytext ) );
+                }
+    <expect>\\n           {
+                /* that's the end of the line, so
+                 * we need another "expect-number"
+                 * before we'll recognize any more
+                 * numbers
+                 */
+                BEGIN(INITIAL);
+                }
+
+    [0-9]+      {
+                printf( "found an integer, = %d\\n",
+                        atoi( yytext ) );
+                }
+
+    "."         printf( "found a dot\\n" );
+
+.fi
+Here is a scanner which recognizes (and discards) C comments while
+maintaining a count of the current input line.
+.nf
+
+    %x comment
+    %%
+            int line_num = 1;
+
+    "/*"         BEGIN(comment);
+
+    <comment>[^*\\n]*        /* eat anything that's not a '*' */
+    <comment>"*"+[^*/\\n]*   /* eat up '*'s not followed by '/'s */
+    <comment>\\n             ++line_num;
+    <comment>"*"+"/"        BEGIN(INITIAL);
+
+.fi
+This scanner goes to a bit of trouble to match as much
+text as possible with each rule.  In general, when attempting to write
+a high-speed scanner try to match as much possible in each rule, as
+it's a big win.
+.PP
+Note that start-conditions names are really integer values and
+can be stored as such.  Thus, the above could be extended in the
+following fashion:
+.nf
+
+    %x comment foo
+    %%
+            int line_num = 1;
+            int comment_caller;
+
+    "/*"         {
+                 comment_caller = INITIAL;
+                 BEGIN(comment);
+                 }
+
+    ...
+
+    <foo>"/*"    {
+                 comment_caller = foo;
+                 BEGIN(comment);
+                 }
+
+    <comment>[^*\\n]*        /* eat anything that's not a '*' */
+    <comment>"*"+[^*/\\n]*   /* eat up '*'s not followed by '/'s */
+    <comment>\\n             ++line_num;
+    <comment>"*"+"/"        BEGIN(comment_caller);
+
+.fi
+Furthermore, you can access the current start condition using
+the integer-valued
+.B YY_START
+macro.  For example, the above assignments to
+.I comment_caller
+could instead be written
+.nf
+
+    comment_caller = YY_START;
+.fi
+.PP
+Note that start conditions do not have their own name-space; %s's and %x's
+declare names in the same fashion as #define's.
+.PP
+Finally, here's an example of how to match C-style quoted strings using
+exclusive start conditions, including expanded escape sequences (but
+not including checking for a string that's too long):
+.nf
+
+    %x str
+
+    %%
+            char string_buf[MAX_STR_CONST];
+            char *string_buf_ptr;
+
+
+    \\"      string_buf_ptr = string_buf; BEGIN(str);
+
+    <str>\\"        { /* saw closing quote - all done */
+            BEGIN(INITIAL);
+            *string_buf_ptr = '\\0';
+            /* return string constant token type and
+             * value to parser
+             */
+            }
+
+    <str>\\n        {
+            /* error - unterminated string constant */
+            /* generate error message */
+            }
+
+    <str>\\\\[0-7]{1,3} {
+            /* octal escape sequence */
+            int result;
+
+            (void) sscanf( yytext + 1, "%o", &result );
+
+            if ( result > 0xff )
+                    /* error, constant is out-of-bounds */
+
+            *string_buf_ptr++ = result;
+            }
+
+    <str>\\\\[0-9]+ {
+            /* generate error - bad escape sequence; something
+             * like '\\48' or '\\0777777'
+             */
+            }
+
+    <str>\\\\n  *string_buf_ptr++ = '\\n';
+    <str>\\\\t  *string_buf_ptr++ = '\\t';
+    <str>\\\\r  *string_buf_ptr++ = '\\r';
+    <str>\\\\b  *string_buf_ptr++ = '\\b';
+    <str>\\\\f  *string_buf_ptr++ = '\\f';
+
+    <str>\\\\(.|\\n)  *string_buf_ptr++ = yytext[1];
+
+    <str>[^\\\\\\n\\"]+        {
+            char *yytext_ptr = yytext;
+
+            while ( *yytext_ptr )
+                    *string_buf_ptr++ = *yytext_ptr++;
+            }
+
+.fi
+.SH MULTIPLE INPUT BUFFERS
+Some scanners (such as those which support "include" files)
+require reading from several input streams.  As
+.I flex
+scanners do a large amount of buffering, one cannot control
+where the next input will be read from by simply writing a
+.B YY_INPUT
+which is sensitive to the scanning context.
+.B YY_INPUT
+is only called when the scanner reaches the end of its buffer, which
+may be a long time after scanning a statement such as an "include"
+which requires switching the input source.
+.PP
+To negotiate these sorts of problems,
+.I flex
+provides a mechanism for creating and switching between multiple
+input buffers.  An input buffer is created by using:
+.nf
+
+    YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+
+.fi
+which takes a
+.I FILE
+pointer and a size and creates a buffer associated with the given
+file and large enough to hold
+.I size
+characters (when in doubt, use
+.B YY_BUF_SIZE
+for the size).  It returns a
+.B YY_BUFFER_STATE
+handle, which may then be passed to other routines:
+.nf
+
+    void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+
+.fi
+switches the scanner's input buffer so subsequent tokens will
+come from
+.I new_buffer.
+Note that
+.B yy_switch_to_buffer()
+may be used by yywrap() to set things up for continued scanning, instead
+of opening a new file and pointing
+.I yyin
+at it.
+.nf
+
+    void yy_delete_buffer( YY_BUFFER_STATE buffer )
+
+.fi
+is used to reclaim the storage associated with a buffer.
+.PP
+.B yy_new_buffer()
+is an alias for
+.B yy_create_buffer(),
+provided for compatibility with the C++ use of
+.I new
+and
+.I delete
+for creating and destroying dynamic objects.
+.PP
+Finally, the
+.B YY_CURRENT_BUFFER
+macro returns a
+.B YY_BUFFER_STATE
+handle to the current buffer.
+.PP
+Here is an example of using these features for writing a scanner
+which expands include files (the
+.B <<EOF>>
+feature is discussed below):
+.nf
+
+    /* the "incl" state is used for picking up the name
+     * of an include file
+     */
+    %x incl
+
+    %{
+    #define MAX_INCLUDE_DEPTH 10
+    YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
+    int include_stack_ptr = 0;
+    %}
+
+    %%
+    include             BEGIN(incl);
+
+    [a-z]+              ECHO;
+    [^a-z\\n]*\\n?        ECHO;
+
+    <incl>[ \\t]*      /* eat the whitespace */
+    <incl>[^ \\t\\n]+   { /* got the include file name */
+            if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
+                {
+                fprintf( stderr, "Includes nested too deeply" );
+                exit( 1 );
+                }
+
+            include_stack[include_stack_ptr++] =
+                YY_CURRENT_BUFFER;
+
+            yyin = fopen( yytext, "r" );
+
+            if ( ! yyin )
+                error( ... );
+
+            yy_switch_to_buffer(
+                yy_create_buffer( yyin, YY_BUF_SIZE ) );
+
+            BEGIN(INITIAL);
+            }
+
+    <<EOF>> {
+            if ( --include_stack_ptr < 0 )
+                {
+                yyterminate();
+                }
+
+            else
+                {
+                yy_delete_buffer( YY_CURRENT_BUFFER );
+                yy_switch_to_buffer(
+                     include_stack[include_stack_ptr] );
+                }
+            }
+
+.fi
+.SH END-OF-FILE RULES
+The special rule "<<EOF>>" indicates
+actions which are to be taken when an end-of-file is
+encountered and yywrap() returns non-zero (i.e., indicates
+no further files to process).  The action must finish
+by doing one of four things:
+.IP -
+assigning
+.I yyin
+to a new input file (in previous versions of flex, after doing the
+assignment you had to call the special action
+.B YY_NEW_FILE;
+this is no longer necessary);
+.IP -
+executing a
+.I return
+statement;
+.IP -
+executing the special
+.B yyterminate()
+action;
+.IP -
+or, switching to a new buffer using
+.B yy_switch_to_buffer()
+as shown in the example above.
+.PP
+<<EOF>> rules may not be used with other
+patterns; they may only be qualified with a list of start
+conditions.  If an unqualified <<EOF>> rule is given, it
+applies to
+.I all
+start conditions which do not already have <<EOF>> actions.  To
+specify an <<EOF>> rule for only the initial start condition, use
+.nf
+
+    <INITIAL><<EOF>>
+
+.fi
+.PP
+These rules are useful for catching things like unclosed comments.
+An example:
+.nf
+
+    %x quote
+    %%
+
+    ...other rules for dealing with quotes...
+
+    <quote><<EOF>>   {
+             error( "unterminated quote" );
+             yyterminate();
+             }
+    <<EOF>>  {
+             if ( *++filelist )
+                 yyin = fopen( *filelist, "r" );
+             else
+                yyterminate();
+             }
+
+.fi
+.SH MISCELLANEOUS MACROS
+The macro
+.bd
+YY_USER_ACTION
+can be defined to provide an action
+which is always executed prior to the matched rule's action.  For example,
+it could be #define'd to call a routine to convert yytext to lower-case.
+.PP
+The macro
+.B YY_USER_INIT
+may be defined to provide an action which is always executed before
+the first scan (and before the scanner's internal initializations are done).
+For example, it could be used to call a routine to read
+in a data table or open a logging file.
+.PP
+In the generated scanner, the actions are all gathered in one large
+switch statement and separated using
+.B YY_BREAK,
+which may be redefined.  By default, it is simply a "break", to separate
+each rule's action from the following rule's.
+Redefining
+.B YY_BREAK
+allows, for example, C++ users to
+#define YY_BREAK to do nothing (while being very careful that every
+rule ends with a "break" or a "return"!) to avoid suffering from
+unreachable statement warnings where because a rule's action ends with
+"return", the
+.B YY_BREAK
+is inaccessible.
+.SH INTERFACING WITH YACC
+One of the main uses of
+.I flex
+is as a companion to the
+.I yacc
+parser-generator.
+.I yacc
+parsers expect to call a routine named
+.B yylex()
+to find the next input token.  The routine is supposed to
+return the type of the next token as well as putting any associated
+value in the global
+.B yylval.
+To use
+.I flex
+with
+.I yacc,
+one specifies the
+.B \-d
+option to
+.I yacc
+to instruct it to generate the file
+.B y.tab.h
+containing definitions of all the
+.B %tokens
+appearing in the
+.I yacc
+input.  This file is then included in the
+.I flex
+scanner.  For example, if one of the tokens is "TOK_NUMBER",
+part of the scanner might look like:
+.nf
+
+    %{
+    #include "y.tab.h"
+    %}
+
+    %%
+
+    [0-9]+        yylval = atoi( yytext ); return TOK_NUMBER;
+
+.fi
+.SH OPTIONS
+.I flex
+has the following options:
+.TP
+.B \-b
+Generate backing-up information to
+.I lex.backup.
+This is a list of scanner states which require backing up
+and the input characters on which they do so.  By adding rules one
+can remove backing-up states.  If all backing-up states
+are eliminated and
+.B \-Cf
+or
+.B \-CF
+is used, the generated scanner will run faster (see the
+.B \-p
+flag).  Only users who wish to squeeze every last cycle out of their
+scanners need worry about this option.  (See the section on Performance
+Considerations below.)
+.TP
+.B \-c
+is a do-nothing, deprecated option included for POSIX compliance.
+.IP
+.B NOTE:
+in previous releases of
+.I flex
+.B \-c
+specified table-compression options.  This functionality is
+now given by the
+.B \-C
+flag.  To ease the the impact of this change, when
+.I flex
+encounters
+.B \-c,
+it currently issues a warning message and assumes that
+.B \-C
+was desired instead.  In the future this "promotion" of
+.B \-c
+to
+.B \-C
+will go away in the name of full POSIX compliance (unless
+the POSIX meaning is removed first).
+.TP
+.B \-d
+makes the generated scanner run in
+.I debug
+mode.  Whenever a pattern is recognized and the global
+.B yy_flex_debug
+is non-zero (which is the default),
+the scanner will write to
+.I stderr
+a line of the form:
+.nf
+
+    --accepting rule at line 53 ("the matched text")
+
+.fi
+The line number refers to the location of the rule in the file
+defining the scanner (i.e., the file that was fed to flex).  Messages
+are also generated when the scanner backs up, accepts the
+default rule, reaches the end of its input buffer (or encounters
+a NUL; at this point, the two look the same as far as the scanner's concerned),
+or reaches an end-of-file.
+.TP
+.B \-f
+specifies
+.I fast scanner.
+No table compression is done and stdio is bypassed.
+The result is large but fast.  This option is equivalent to
+.B \-Cfr
+(see below).
+.TP
+.B \-h
+generates a "help" summary of
+.I flex's
+options to
+.I stderr 
+and then exits.
+.TP
+.B \-i
+instructs
+.I flex
+to generate a
+.I case-insensitive
+scanner.  The case of letters given in the
+.I flex
+input patterns will
+be ignored, and tokens in the input will be matched regardless of case.  The
+matched text given in
+.I yytext
+will have the preserved case (i.e., it will not be folded).
+.TP
+.B \-l
+turns on maximum compatibility with the original AT&T
+.I lex
+implementation.  Note that this does not mean
+.I full
+compatibility.  Use of this option costs a considerable amount of
+performance, and it cannot be used with the
+.B \-+, -f, -F, -Cf,
+or
+.B -CF
+options.  For details on the compatibilities it provides, see the section
+"Incompatibilities With Lex And POSIX" below.
+.TP
+.B \-n
+is another do-nothing, deprecated option included only for
+POSIX compliance.
+.TP
+.B \-p
+generates a performance report to stderr.  The report
+consists of comments regarding features of the
+.I flex
+input file which will cause a serious loss of performance in the resulting
+scanner.  If you give the flag twice, you will also get comments regarding
+features that lead to minor performance losses.
+.IP
+Note that the use of
+.B REJECT
+and variable trailing context (see the Bugs section in flex(1))
+entails a substantial performance penalty; use of
+.I yymore(),
+the
+.B ^
+operator,
+and the
+.B \-I
+flag entail minor performance penalties.
+.TP
+.B \-s
+causes the
+.I default rule
+(that unmatched scanner input is echoed to
+.I stdout)
+to be suppressed.  If the scanner encounters input that does not
+match any of its rules, it aborts with an error.  This option is
+useful for finding holes in a scanner's rule set.
+.TP
+.B \-t
+instructs
+.I flex
+to write the scanner it generates to standard output instead
+of
+.B lex.yy.c.
+.TP
+.B \-v
+specifies that
+.I flex
+should write to
+.I stderr
+a summary of statistics regarding the scanner it generates.
+Most of the statistics are meaningless to the casual
+.I flex
+user, but the first line identifies the version of
+.I flex
+(same as reported by
+.B \-V),
+and the next line the flags used when generating the scanner, including
+those that are on by default.
+.TP
+.B \-w
+suppresses warning messages.
+.TP
+.B \-B
+instructs
+.I flex
+to generate a
+.I batch
+scanner, the opposite of
+.I interactive
+scanners generated by
+.B \-I
+(see below).  In general, you use
+.B \-B
+when you are
+.I certain
+that your scanner will never be used interactively, and you want to
+squeeze a
+.I little
+more performance out of it.  If your goal is instead to squeeze out a
+.I lot
+more performance, you should  be using the
+.B \-Cf
+or
+.B \-CF
+options (discussed below), which turn on
+.B \-B
+automatically anyway.
+.TP
+.B \-F
+specifies that the
+.ul
+fast
+scanner table representation should be used (and stdio
+bypassed).  This representation is
+about as fast as the full table representation
+.B (-f),
+and for some sets of patterns will be considerably smaller (and for
+others, larger).  In general, if the pattern set contains both "keywords"
+and a catch-all, "identifier" rule, such as in the set:
+.nf
+
+    "case"    return TOK_CASE;
+    "switch"  return TOK_SWITCH;
+    ...
+    "default" return TOK_DEFAULT;
+    [a-z]+    return TOK_ID;
+
+.fi
+then you're better off using the full table representation.  If only
+the "identifier" rule is present and you then use a hash table or some such
+to detect the keywords, you're better off using
+.B -F.
+.IP
+This option is equivalent to
+.B \-CFr
+(see below).  It cannot be used with
+.B \-+.
+.TP
+.B \-I
+instructs
+.I flex
+to generate an
+.I interactive
+scanner.  An interactive scanner is one that only looks ahead to decide
+what token has been matched if it absolutely must.  It turns out that
+always looking one extra character ahead, even if the scanner has already
+seen enough text to disambiguate the current token, is a bit faster than
+only looking ahead when necessary.  But scanners that always look ahead
+give dreadful interactive performance; for example, when a user types
+a newline, it is not recognized as a newline token until they enter
+.I another
+token, which often means typing in another whole line.
+.IP
+.I Flex
+scanners default to
+.I interactive
+unless you use the
+.B \-Cf
+or
+.B \-CF
+table-compression options (see below).  That's because if you're looking
+for high-performance you should be using one of these options, so if you
+didn't,
+.I flex
+assumes you'd rather trade off a bit of run-time performance for intuitive
+interactive behavior.  Note also that you
+.I cannot
+use
+.B \-I
+in conjunction with
+.B \-Cf
+or
+.B \-CF.
+Thus, this option is not really needed; it is on by default for all those
+cases in which it is allowed.
+.IP
+You can force a scanner to
+.I not
+be interactive by using
+.B \-B
+(see above).
+.TP
+.B \-L
+instructs
+.I flex
+not to generate
+.B #line
+directives.  Without this option,
+.I flex
+peppers the generated scanner
+with #line directives so error messages in the actions will be correctly
+located with respect to the original
+.I flex
+input file, and not to
+the fairly meaningless line numbers of
+.B lex.yy.c.
+(Unfortunately
+.I flex
+does not presently generate the necessary directives
+to "retarget" the line numbers for those parts of
+.B lex.yy.c
+which it generated.  So if there is an error in the generated code,
+a meaningless line number is reported.)
+.TP
+.B \-T
+makes
+.I flex
+run in
+.I trace
+mode.  It will generate a lot of messages to
+.I stderr
+concerning
+the form of the input and the resultant non-deterministic and deterministic
+finite automata.  This option is mostly for use in maintaining
+.I flex.
+.TP
+.B \-V
+prints the version number to
+.I stderr
+and exits.
+.TP
+.B \-7
+instructs
+.I flex
+to generate a 7-bit scanner, i.e., one which can only recognized 7-bit
+characters in its input.  The advantage of using
+.B \-7
+is that the scanner's tables can be up to half the size of those generated
+using the
+.B \-8
+option (see below).  The disadvantage is that such scanners often hang
+or crash if their input contains an 8-bit character.
+.IP
+Note, however, that unless you generate your scanner using the
+.B \-Cf
+or
+.B \-CF
+table compression options, use of
+.B \-7
+will save only a small amount of table space, and make your scanner
+considerably less portable.
+.I Flex's
+default behavior is to generate an 8-bit scanner unless you use the
+.B \-Cf
+or
+.B \-CF,
+in which case
+.I flex
+defaults to generating 7-bit scanners unless your site was always
+configured to generate 8-bit scanners (as will often be the case
+with non-USA sites).  You can tell whether flex generated a 7-bit
+or an 8-bit scanner by inspecting the flag summary in the
+.B \-v
+output as described above.
+.IP
+Note that if you use
+.B \-Cfe
+or
+.B \-CFe
+(those table compression options, but also using equivalence classes as
+discussed see below), flex still defaults to generating an 8-bit
+scanner, since usually with these compression options full 8-bit tables
+are not much more expensive than 7-bit tables.
+.TP
+.B \-8
+instructs
+.I flex
+to generate an 8-bit scanner, i.e., one which can recognize 8-bit
+characters.  This flag is only needed for scanners generated using
+.B \-Cf
+or
+.B \-CF,
+as otherwise flex defaults to generating an 8-bit scanner anyway.
+.IP
+See the discussion of
+.B \-7
+above for flex's default behavior and the tradeoffs between 7-bit
+and 8-bit scanners.
+.TP
+.B \-+
+specifies that you want flex to generate a C++
+scanner class.  See the section on Generating C++ Scanners below for
+details.
+.TP 
+.B \-C[aefFmr]
+controls the degree of table compression and, more generally, trade-offs
+between small scanners and fast scanners.
+.IP
+.B \-Ca
+("align") instructs flex to trade off larger tables in the
+generated scanner for faster performance because the elements of
+the tables are better aligned for memory access and computation.  On some
+RISC architectures, fetching and manipulating longwords is more efficient
+than with smaller-sized datums such as shortwords.  This option can
+double the size of the tables used by your scanner.
+.IP
+.B \-Ce
+directs
+.I flex
+to construct
+.I equivalence classes,
+i.e., sets of characters
+which have identical lexical properties (for example, if the only
+appearance of digits in the
+.I flex
+input is in the character class
+"[0-9]" then the digits '0', '1', ..., '9' will all be put
+in the same equivalence class).  Equivalence classes usually give
+dramatic reductions in the final table/object file sizes (typically
+a factor of 2-5) and are pretty cheap performance-wise (one array
+look-up per character scanned).
+.IP
+.B \-Cf
+specifies that the
+.I full
+scanner tables should be generated -
+.I flex
+should not compress the
+tables by taking advantages of similar transition functions for
+different states.
+.IP
+.B \-CF
+specifies that the alternate fast scanner representation (described
+above under the
+.B \-F
+flag)
+should be used.  This option cannot be used with
+.B \-+.
+.IP
+.B \-Cm
+directs
+.I flex
+to construct
+.I meta-equivalence classes,
+which are sets of equivalence classes (or characters, if equivalence
+classes are not being used) that are commonly used together.  Meta-equivalence
+classes are often a big win when using compressed tables, but they
+have a moderate performance impact (one or two "if" tests and one
+array look-up per character scanned).
+.IP
+.B \-Cr
+causes the generated scanner to
+.I bypass
+use of the standard I/O library (stdio) for input.  Instead of calling
+.B fread()
+or
+.B getc(),
+the scanner will use the
+.B read()
+system call, resulting in a performance gain which varies from system
+to system, but in general is probably negligible unless you are also using
+.B \-Cf
+or
+.B \-CF.
+Using
+.B \-Cr
+can cause strange behavior if, for example, you read from
+.I yyin
+using stdio prior to calling the scanner (because the scanner will miss
+whatever text your previous reads left in the stdio input buffer).
+.IP
+.B \-Cr
+has no effect if you define
+.B YY_INPUT
+(see The Generated Scanner above).
+.IP
+A lone
+.B \-C
+specifies that the scanner tables should be compressed but neither
+equivalence classes nor meta-equivalence classes should be used.
+.IP
+The options
+.B \-Cf
+or
+.B \-CF
+and
+.B \-Cm
+do not make sense together - there is no opportunity for meta-equivalence
+classes if the table is not being compressed.  Otherwise the options
+may be freely mixed, and are cumulative.
+.IP
+The default setting is
+.B \-Cem,
+which specifies that
+.I flex
+should generate equivalence classes
+and meta-equivalence classes.  This setting provides the highest
+degree of table compression.  You can trade off
+faster-executing scanners at the cost of larger tables with
+the following generally being true:
+.nf
+
+    slowest & smallest
+          -Cem
+          -Cm
+          -Ce
+          -C
+          -C{f,F}e
+          -C{f,F}
+          -C{f,F}a
+    fastest & largest
+
+.fi
+Note that scanners with the smallest tables are usually generated and
+compiled the quickest, so
+during development you will usually want to use the default, maximal
+compression.
+.IP
+.B \-Cfe
+is often a good compromise between speed and size for production
+scanners.
+.TP
+.B \-Pprefix
+changes the default
+.I "yy"
+prefix used by
+.I flex
+for all globally-visible variable and function names to instead be
+.I prefix.
+For example,
+.B \-Pfoo
+changes the name of
+.B yytext
+to
+.B footext.
+It also changes the name of the default output file from
+.B lex.yy.c
+to
+.B lex.foo.c.
+Here are all of the names affected:
+.nf
+
+    yyFlexLexer
+    yy_create_buffer
+    yy_delete_buffer
+    yy_flex_debug
+    yy_init_buffer
+    yy_load_buffer_state
+    yy_switch_to_buffer
+    yyin
+    yyleng
+    yylex
+    yyout
+    yyrestart
+    yytext
+    yywrap
+
+.fi
+Within your scanner itself, you can still refer to the global variables
+and functions using either version of their name; but eternally, they
+have the modified name.
+.IP
+This option lets you easily link together multiple
+.I flex
+programs into the same executable.  Note, though, that using this
+option also renames
+.B yywrap(),
+so you now
+.I must
+provide your own (appropriately-named) version of the routine for your
+scanner, as linking with
+.B \-lfl
+no longer provides one for you by default.
+.TP
+.B \-Sskeleton_file
+overrides the default skeleton file from which
+.I flex
+constructs its scanners.  You'll never need this option unless you are doing
+.I flex
+maintenance or development.
+.SH PERFORMANCE CONSIDERATIONS
+The main design goal of
+.I flex
+is that it generate high-performance scanners.  It has been optimized
+for dealing well with large sets of rules.  Aside from the effects on
+scanner speed of the table compression
+.B \-C
+options outlined above,
+there are a number of options/actions which degrade performance.  These
+are, from most expensive to least:
+.nf
+
+    REJECT
+
+    pattern sets that require backing up
+    arbitrary trailing context
+
+    yymore()
+    '^' beginning-of-line operator
+
+.fi
+with the first three all being quite expensive and the last two
+being quite cheap.  Note also that
+.B unput()
+is implemented as a routine call that potentially does quite a bit of
+work, while
+.B yyless()
+is a quite-cheap macro; so if just putting back some excess text you
+scanned, use
+.B yyless().
+.PP
+.B REJECT
+should be avoided at all costs when performance is important.
+It is a particularly expensive option.
+.PP
+Getting rid of backing up is messy and often may be an enormous
+amount of work for a complicated scanner.  In principal, one begins
+by using the
+.B \-b 
+flag to generate a
+.I lex.backup
+file.  For example, on the input
+.nf
+
+    %%
+    foo        return TOK_KEYWORD;
+    foobar     return TOK_KEYWORD;
+
+.fi
+the file looks like:
+.nf
+
+    State #6 is non-accepting -
+     associated rule line numbers:
+           2       3
+     out-transitions: [ o ]
+     jam-transitions: EOF [ \\001-n  p-\\177 ]
+
+    State #8 is non-accepting -
+     associated rule line numbers:
+           3
+     out-transitions: [ a ]
+     jam-transitions: EOF [ \\001-`  b-\\177 ]
+
+    State #9 is non-accepting -
+     associated rule line numbers:
+           3
+     out-transitions: [ r ]
+     jam-transitions: EOF [ \\001-q  s-\\177 ]
+
+    Compressed tables always back up.
+
+.fi
+The first few lines tell us that there's a scanner state in
+which it can make a transition on an 'o' but not on any other
+character, and that in that state the currently scanned text does not match
+any rule.  The state occurs when trying to match the rules found
+at lines 2 and 3 in the input file.
+If the scanner is in that state and then reads
+something other than an 'o', it will have to back up to find
+a rule which is matched.  With
+a bit of headscratching one can see that this must be the
+state it's in when it has seen "fo".  When this has happened,
+if anything other than another 'o' is seen, the scanner will
+have to back up to simply match the 'f' (by the default rule).
+.PP
+The comment regarding State #8 indicates there's a problem
+when "foob" has been scanned.  Indeed, on any character other
+than an 'a', the scanner will have to back up to accept "foo".
+Similarly, the comment for State #9 concerns when "fooba" has
+been scanned and an 'r' does not follow.
+.PP
+The final comment reminds us that there's no point going to
+all the trouble of removing backing up from the rules unless
+we're using
+.B \-Cf
+or
+.B \-CF,
+since there's no performance gain doing so with compressed scanners.
+.PP
+The way to remove the backing up is to add "error" rules:
+.nf
+
+    %%
+    foo         return TOK_KEYWORD;
+    foobar      return TOK_KEYWORD;
+
+    fooba       |
+    foob        |
+    fo          {
+                /* false alarm, not really a keyword */
+                return TOK_ID;
+                }
+
+.fi
+.PP
+Eliminating backing up among a list of keywords can also be
+done using a "catch-all" rule:
+.nf
+
+    %%
+    foo         return TOK_KEYWORD;
+    foobar      return TOK_KEYWORD;
+
+    [a-z]+      return TOK_ID;
+
+.fi
+This is usually the best solution when appropriate.
+.PP
+Backing up messages tend to cascade.
+With a complicated set of rules it's not uncommon to get hundreds
+of messages.  If one can decipher them, though, it often
+only takes a dozen or so rules to eliminate the backing up (though
+it's easy to make a mistake and have an error rule accidentally match
+a valid token.  A possible future
+.I flex
+feature will be to automatically add rules to eliminate backing up).
+.PP
+.I Variable
+trailing context (where both the leading and trailing parts do not have
+a fixed length) entails almost the same performance loss as
+.B REJECT
+(i.e., substantial).  So when possible a rule like:
+.nf
+
+    %%
+    mouse|rat/(cat|dog)   run();
+
+.fi
+is better written:
+.nf
+
+    %%
+    mouse/cat|dog         run();
+    rat/cat|dog           run();
+
+.fi
+or as
+.nf
+
+    %%
+    mouse|rat/cat         run();
+    mouse|rat/dog         run();
+
+.fi
+Note that here the special '|' action does
+.I not
+provide any savings, and can even make things worse (see
+.PP
+A final note regarding performance: as mentioned above in the section
+How the Input is Matched, dynamically resizing
+.B yytext
+to accomodate huge tokens is a slow process because it presently requires that
+the (huge) token be rescanned from the beginning.  Thus if performance is
+vital, you should attempt to match "large" quantities of text but not
+"huge" quantities, where the cutoff between the two is at about 8K
+characters/token.
+.PP
+Another area where the user can increase a scanner's performance
+(and one that's easier to implement) arises from the fact that
+the longer the tokens matched, the faster the scanner will run.
+This is because with long tokens the processing of most input
+characters takes place in the (short) inner scanning loop, and
+does not often have to go through the additional work of setting up
+the scanning environment (e.g.,
+.B yytext)
+for the action.  Recall the scanner for C comments:
+.nf
+
+    %x comment
+    %%
+            int line_num = 1;
+
+    "/*"         BEGIN(comment);
+
+    <comment>[^*\\n]*
+    <comment>"*"+[^*/\\n]*
+    <comment>\\n             ++line_num;
+    <comment>"*"+"/"        BEGIN(INITIAL);
+
+.fi
+This could be sped up by writing it as:
+.nf
+
+    %x comment
+    %%
+            int line_num = 1;
+
+    "/*"         BEGIN(comment);
+
+    <comment>[^*\\n]*
+    <comment>[^*\\n]*\\n      ++line_num;
+    <comment>"*"+[^*/\\n]*
+    <comment>"*"+[^*/\\n]*\\n ++line_num;
+    <comment>"*"+"/"        BEGIN(INITIAL);
+
+.fi
+Now instead of each newline requiring the processing of another
+action, recognizing the newlines is "distributed" over the other rules
+to keep the matched text as long as possible.  Note that
+.I adding
+rules does
+.I not
+slow down the scanner!  The speed of the scanner is independent
+of the number of rules or (modulo the considerations given at the
+beginning of this section) how complicated the rules are with
+regard to operators such as '*' and '|'.
+.PP
+A final example in speeding up a scanner: suppose you want to scan
+through a file containing identifiers and keywords, one per line
+and with no other extraneous characters, and recognize all the
+keywords.  A natural first approach is:
+.nf
+
+    %%
+    asm      |
+    auto     |
+    break    |
+    ... etc ...
+    volatile |
+    while    /* it's a keyword */
+
+    .|\\n     /* it's not a keyword */
+
+.fi
+To eliminate the back-tracking, introduce a catch-all rule:
+.nf
+
+    %%
+    asm      |
+    auto     |
+    break    |
+    ... etc ...
+    volatile |
+    while    /* it's a keyword */
+
+    [a-z]+   |
+    .|\\n     /* it's not a keyword */
+
+.fi
+Now, if it's guaranteed that there's exactly one word per line,
+then we can reduce the total number of matches by a half by
+merging in the recognition of newlines with that of the other
+tokens:
+.nf
+
+    %%
+    asm\\n    |
+    auto\\n   |
+    break\\n  |
+    ... etc ...
+    volatile\\n |
+    while\\n  /* it's a keyword */
+
+    [a-z]+\\n |
+    .|\\n     /* it's not a keyword */
+
+.fi
+One has to be careful here, as we have now reintroduced backing up
+into the scanner.  In particular, while
+.I we
+know that there will never be any characters in the input stream
+other than letters or newlines,
+.I flex
+can't figure this out, and it will plan for possibly needing to back up
+when it has scanned a token like "auto" and then the next character
+is something other than a newline or a letter.  Previously it would
+then just match the "auto" rule and be done, but now it has no "auto"
+rule, only a "auto\\n" rule.  To eliminate the possibility of backing up,
+we could either duplicate all rules but without final newlines, or,
+since we never expect to encounter such an input and therefore don't
+how it's classified, we can introduce one more catch-all rule, this
+one which doesn't include a newline:
+.nf
+
+    %%
+    asm\\n    |
+    auto\\n   |
+    break\\n  |
+    ... etc ...
+    volatile\\n |
+    while\\n  /* it's a keyword */
+
+    [a-z]+\\n |
+    [a-z]+   |
+    .|\\n     /* it's not a keyword */
+
+.fi
+Compiled with
+.B \-Cf,
+this is about as fast as one can get a
+.I flex 
+scanner to go for this particular problem.
+.PP
+A final note:
+.I flex
+is slow when matching NUL's, particularly when a token contains
+multiple NUL's.
+It's best to write rules which match
+.I short
+amounts of text if it's anticipated that the text will often include NUL's.
+.SH GENERATING C++ SCANNERS
+.I flex
+provides two different ways to generate scanners for use with C++.  The
+first way is to simply compile a scanner generated by
+.I flex
+using a C++ compiler instead of a C compiler.  You should not encounter
+any compilations errors (please report any you find to the email address
+given in the Author section below).  You can then use C++ code in your
+rule actions instead of C code.  Note that the default input source for
+your scanner remains
+.I yyin,
+and default echoing is still done to
+.I yyout.
+Both of these remain
+.I FILE *
+variables and not C++
+.I streams.
+.PP
+You can also use
+.I flex
+to generate a C++ scanner class, using the
+.B \-+
+option, which is automatically specified if the name of the flex
+executable ends in a '+', such as
+.I flex++.
+When using this option, flex defaults to generating the scanner to the file
+.B lex.yy.cc
+instead of
+.B lex.yy.c.
+The generated scanner includes the header file
+.I FlexLexer.h,
+which defines the interface to two C++ classes.
+.PP
+The first class,
+.B FlexLexer,
+provides an abstract base class defining the general scanner class
+interface.  It provides the following member functions:
+.TP
+.B const char* YYText()
+returns the text of the most recently matched token, the equivalent of
+.B yytext.
+.TP
+.B int YYLeng()
+returns the length of the most recently matched token, the equivalent of
+.B yyleng.
+.PP
+Also provided are member functions equivalent to
+.B yy_switch_to_buffer(),
+.B yy_create_buffer()
+(though the first argument is an
+.B istream*
+object pointer and not a
+.B FILE*),
+.B yy_delete_buffer(),
+and
+.B yyrestart()
+(again, the first argument is a
+.B istream*
+object pointer).
+.PP
+The second class defined in
+.I FlexLexer.h
+is
+.B yyFlexLexer,
+which is derived from
+.B FlexLexer.
+It defines the following additional member functions:
+.TP
+.B
+yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
+constructs a
+.B yyFlexLexer
+object using the given streams for input and output.  If not specified,
+the streams default to
+.B cin
+and
+.B cout,
+respectively.
+.TP
+.B virtual int yylex()
+performs the same role is
+.B yylex()
+does for ordinary flex scanners: it scans the input stream, consuming
+tokens, until a rule's action returns a value.
+.PP
+In addition,
+.B yyFlexLexer
+defines the following protected virtual functions which you can redefine
+in derived classes to tailor the scanner:
+.TP
+.B
+virtual int LexerInput( char* buf, int max_size )
+reads up to
+.B max_size
+characters into
+.B buf
+and returns the number of characters read.  To indicate end-of-input,
+return 0 characters.  Note that "interactive" scanners (see the
+.B \-B
+and
+.B \-I
+flags) define the macro
+.B YY_INTERACTIVE.
+If you redefine
+.B LexerInput()
+and need to take different actions depending on whether or not
+the scanner might be scanning an interactive input source, you can
+test for the presence of this name via
+.B #ifdef.
+.TP
+.B
+virtual void LexerOutput( const char* buf, int size )
+writes out
+.B size
+characters from the buffer
+.B buf,
+which, while NUL-terminated, may also contain "internal" NUL's if
+the scanner's rules can match text with NUL's in them.
+.TP
+.B
+virtual void LexerError( const char* msg )
+reports a fatal error message.  The default version of this function
+writes the message to the stream
+.B cerr
+and exits.
+.PP
+Note that a
+.B yyFlexLexer
+object contains its
+.I entire
+scanning state.  Thus you can use such objects to create reentrant
+scanners.  You can instantiate multiple instances of the same
+.B yyFlexLexer
+class, and you can also combine multiple C++ scanner classes together
+in the same program using the
+.B \-P
+option discussed above.
+.PP
+Finally, note that the
+.B %array
+feature is not available to C++ scanner classes; you must use
+.B %pointer
+(the default).
+.PP
+Here is an example of a simple C++ scanner:
+.nf
+
+        // An example of using the flex C++ scanner class.
+
+    %{
+    int mylineno = 0;
+    %}
+
+    string  \\"[^\\n"]+\\"
+
+    ws      [ \\t]+
+
+    alpha   [A-Za-z]
+    dig     [0-9]
+    name    ({alpha}|{dig}|\\$)({alpha}|{dig}|[_.\\-/$])*
+    num1    [-+]?{dig}+\\.?([eE][-+]?{dig}+)?
+    num2    [-+]?{dig}*\\.{dig}+([eE][-+]?{dig}+)?
+    number  {num1}|{num2}
+
+    %%
+
+    {ws}    /* skip blanks and tabs */
+
+    "/*"    {
+            int c;
+
+            while((c = yyinput()) != 0)
+                {
+                if(c == '\\n')
+                    ++mylineno;
+
+                else if(c == '*')
+                    {
+                    if((c = yyinput()) == '/')
+                        break;
+                    else
+                        unput(c);
+                    }
+                }
+            }
+
+    {number}  cout << "number " << YYText() << '\\n';
+
+    \\n        mylineno++;
+
+    {name}    cout << "name " << YYText() << '\\n';
+
+    {string}  cout << "string " << YYText() << '\\n';
+
+    %%
+
+    int main( int /* argc */, char** /* argv */ )
+        {
+        FlexLexer* lexer = new yyFlexLexer;
+        while(lexer->yylex() != 0)
+            ;
+        return 0;
+        }
+.fi
+IMPORTANT: the present form of the scanning class is
+.I experimental
+and may change considerably between major releases.
+.SH INCOMPATIBILITIES WITH LEX AND POSIX
+.I flex
+is a rewrite of the AT&T Unix
+.I lex
+tool (the two implementations do not share any code, though),
+with some extensions and incompatibilities, both of which
+are of concern to those who wish to write scanners acceptable
+to either implementation.  The POSIX
+.I lex
+specification is closer to
+.I flex's
+behavior than that of the original
+.I lex
+implementation, but there also remain some incompatibilities between
+.I flex
+and POSIX.  The intent is that ultimately
+.I flex
+will be fully POSIX-conformant.  In this section we discuss all of
+the known areas of incompatibility.
+.PP
+.I flex's
+.B \-l
+option turns on maximum compatibility with the original AT&T
+.I lex
+implementation, at the cost of a major loss in the generated scanner's
+performance.  We note below which incompatibilities can be overcome
+using the
+.B \-l
+option.
+.PP
+.I flex
+is fully compatible with
+.I lex
+with the following exceptions:
+.IP -
+The undocumented
+.I lex
+scanner internal variable
+.B yylineno
+is not supported unless
+.B \-l
+is used.
+.IP
+yylineno is not part of the POSIX specification.
+.IP -
+The
+.B input()
+routine is not redefinable, though it may be called to read characters
+following whatever has been matched by a rule.  If
+.B input()
+encounters an end-of-file the normal
+.B yywrap()
+processing is done.  A ``real'' end-of-file is returned by
+.B input()
+as
+.I EOF.
+.IP
+Input is instead controlled by defining the
+.B YY_INPUT
+macro.
+.IP
+The
+.I flex
+restriction that
+.B input()
+cannot be redefined is in accordance with the POSIX specification,
+which simply does not specify any way of controlling the
+scanner's input other than by making an initial assignment to
+.I yyin.
+.IP -
+.I flex
+scanners are not as reentrant as
+.I lex
+scanners.  In particular, if you have an interactive scanner and
+an interrupt handler which long-jumps out of the scanner, and
+the scanner is subsequently called again, you may get the following
+message:
+.nf
+
+    fatal flex scanner internal error--end of buffer missed
+
+.fi
+To reenter the scanner, first use
+.nf
+
+    yyrestart( yyin );
+
+.fi
+Note that this call will throw away any buffered input; usually this
+isn't a problem with an interactive scanner.
+.IP
+Also note that flex C++ scanner classes
+.I are
+reentrant, so if using C++ is an option for you, you should use
+them instead.  See "Generating C++ Scanners" above for details.
+.IP -
+.B output()
+is not supported.
+Output from the
+.B ECHO
+macro is done to the file-pointer
+.I yyout
+(default
+.I stdout).
+.IP
+.B output()
+is not part of the POSIX specification.
+.IP -
+.I lex
+does not support exclusive start conditions (%x), though they
+are in the POSIX specification.
+.IP -
+When definitions are expanded,
+.I flex
+encloses them in parentheses.
+With lex, the following:
+.nf
+
+    NAME    [A-Z][A-Z0-9]*
+    %%
+    foo{NAME}?      printf( "Found it\\n" );
+    %%
+
+.fi
+will not match the string "foo" because when the macro
+is expanded the rule is equivalent to "foo[A-Z][A-Z0-9]*?"
+and the precedence is such that the '?' is associated with
+"[A-Z0-9]*".  With
+.I flex,
+the rule will be expanded to
+"foo([A-Z][A-Z0-9]*)?" and so the string "foo" will match.
+.IP
+Note that if the definition begins with
+.B ^
+or ends with
+.B $
+then it is
+.I not
+expanded with parentheses, to allow these operators to appear in
+definitions without losing their special meanings.  But the
+.B <s>, /,
+and
+.B <<EOF>>
+operators cannot be used in a
+.I flex
+definition.
+.IP
+Using
+.B \-l
+results in the
+.I lex
+behavior of no parentheses around the definition.
+.IP
+The POSIX specification is that the definition be enclosed in parentheses.
+.IP -
+The
+.I lex
+.B %r
+(generate a Ratfor scanner) option is not supported.  It is not part
+of the POSIX specification.
+.IP -
+After a call to
+.B unput(),
+.I yytext
+and
+.I yyleng
+are undefined until the next token is matched, unless the scanner
+was built using
+.B %array.
+This is not the case with
+.I lex
+or the POSIX specification.  The
+.B \-l
+option does away with this incompatibility.
+.IP -
+The precedence of the
+.B {}
+(numeric range) operator is different.
+.I lex
+interprets "abc{1,3}" as "match one, two, or
+three occurrences of 'abc'", whereas
+.I flex
+interprets it as "match 'ab'
+followed by one, two, or three occurrences of 'c'".  The latter is
+in agreement with the POSIX specification.
+.IP -
+The precedence of the
+.B ^
+operator is different.
+.I lex
+interprets "^foo|bar" as "match either 'foo' at the beginning of a line,
+or 'bar' anywhere", whereas
+.I flex
+interprets it as "match either 'foo' or 'bar' if they come at the beginning
+of a line".  The latter is in agreement with the POSIX specification.
+.IP -
+.I yyin
+is
+.I initialized
+by
+.I lex
+to be
+.I stdin;
+.I flex,
+on the other hand,
+initializes
+.I yyin
+to NULL
+and then
+.I assigns
+it to
+.I stdin
+the first time the scanner is called, providing
+.I yyin
+has not already been assigned to a non-NULL value.  The difference is
+subtle, but the net effect is that with
+.I flex
+scanners,
+.I yyin
+does not have a valid value until the scanner has been called.
+.IP
+The
+.B \-l
+option does away with this incompatibility.
+.IP -
+The special table-size declarations such as
+.B %a
+supported by
+.I lex
+are not required by
+.I flex
+scanners;
+.I flex
+ignores them.
+.IP -
+The name
+.bd
+FLEX_SCANNER
+is #define'd so scanners may be written for use with either
+.I flex
+or
+.I lex.
+.PP
+The following
+.I flex
+features are not included in
+.I lex
+or the POSIX specification:
+.nf
+
+    yyterminate()
+    <<EOF>>
+    <*>
+    YY_DECL
+    YY_START
+    YY_USER_ACTION
+    #line directives
+    %{}'s around actions
+    multiple actions on a line
+
+.fi
+plus almost all of the flex flags.
+The last feature in the list refers to the fact that with
+.I flex
+you can put multiple actions on the same line, separated with
+semi-colons, while with
+.I lex,
+the following
+.nf
+
+    foo    handle_foo(); ++num_foos_seen;
+
+.fi
+is (rather surprisingly) truncated to
+.nf
+
+    foo    handle_foo();
+
+.fi
+.I flex
+does not truncate the action.  Actions that are not enclosed in
+braces are simply terminated at the end of the line.
+.SH DIAGNOSTICS
+.PP
+.I warning, rule cannot be matched
+indicates that the given rule
+cannot be matched because it follows other rules that will
+always match the same text as it.  For
+example, in the following "foo" cannot be matched because it comes after
+an identifier "catch-all" rule:
+.nf
+
+    [a-z]+    got_identifier();
+    foo       got_foo();
+
+.fi
+Using
+.B REJECT
+in a scanner suppresses this warning.
+.PP
+.I warning,
+.B \-s
+.I
+option given but default rule can be matched
+means that it is possible (perhaps only in a particular start condition)
+that the default rule (match any single character) is the only one
+that will match a particular input.  Since
+.B \-s
+was given, presumably this is not intended.
+.PP
+.I reject_used_but_not_detected undefined
+or
+.I yymore_used_but_not_detected undefined -
+These errors can occur at compile time.  They indicate that the
+scanner uses
+.B REJECT
+or
+.B yymore()
+but that
+.I flex
+failed to notice the fact, meaning that
+.I flex
+scanned the first two sections looking for occurrences of these actions
+and failed to find any, but somehow you snuck some in (via a #include
+file, for example).  Make an explicit reference to the action in your
+.I flex
+input file.  (Note that previously
+.I flex
+supported a
+.B %used/%unused
+mechanism for dealing with this problem; this feature is still supported
+but now deprecated, and will go away soon unless the author hears from
+people who can argue compellingly that they need it.)
+.PP
+.I flex scanner jammed -
+a scanner compiled with
+.B \-s
+has encountered an input string which wasn't matched by
+any of its rules.  This error can also occur due to internal problems.
+.PP
+.I token too large, exceeds YYLMAX -
+your scanner uses
+.B %array
+and one of its rules matched a string longer than the
+.B YYLMAX
+constant (8K bytes by default).  You can increase the value by
+#define'ing
+.B YYLMAX
+in the definitions section of your
+.I flex
+input.
+.PP
+.I scanner requires \-8 flag to
+.I use the character 'x' -
+Your scanner specification includes recognizing the 8-bit character
+.I 'x'
+and you did not specify the \-8 flag, and your scanner defaulted to 7-bit
+because you used the
+.B \-Cf
+or
+.B \-CF
+table compression options.  See the discussion of the
+.B \-7
+flag for details.
+.PP
+.I flex scanner push-back overflow -
+you used
+.B unput()
+to push back so much text that the scanner's buffer could not hold
+both the pushed-back text and the current token in
+.B yytext.
+Ideally the scanner should dynamically resize the buffer in this case, but at
+present it does not.
+.PP
+.I
+input buffer overflow, can't enlarge buffer because scanner uses REJECT -
+the scanner was working on matching an extremely large token and needed
+to expand the input buffer.  This doesn't work with scanners that use
+.B
+REJECT.
+.PP
+.I
+fatal flex scanner internal error--end of buffer missed -
+This can occur in an scanner which is reentered after a long-jump
+has jumped out (or over) the scanner's activation frame.  Before
+reentering the scanner, use:
+.nf
+
+    yyrestart( yyin );
+
+.fi
+or, as noted above, switch to using the C++ scanner class.
+.PP
+.I too many start conditions in <> construct! -
+you listed more start conditions in a <> construct than exist (so
+you must have listed at least one of them twice).
+.SH FILES
+See flex(1).
+.SH DEFICIENCIES / BUGS
+Again, see flex(1).
+.SH "SEE ALSO"
+.PP
+flex(1), lex(1), yacc(1), sed(1), awk(1).
+.PP
+M. E. Lesk and E. Schmidt,
+.I LEX \- Lexical Analyzer Generator
+.SH AUTHOR
+Vern Paxson, with the help of many ideas and much inspiration from
+Van Jacobson.  Original version by Jef Poskanzer.  The fast table
+representation is a partial implementation of a design done by Van
+Jacobson.  The implementation was done by Kevin Gong and Vern Paxson.
+.PP
+Thanks to the many
+.I flex
+beta-testers, feedbackers, and contributors, especially Francois Pinard,
+Casey Leedom,
+Nelson H.F. Beebe, benson@odi.com, Peter A. Bigot, Keith Bostic, Frederic
+Brehm, Nick Christopher, Jason Coughlin, Bill Cox, Dave Curtis, Scott David
+Daniels, Chris G. Demetriou, Mike Donahue, Chuck Doucette, Tom Epperly, Leo
+Eskin, Chris Faylor, Jon Forrest, Kaveh R. Ghazi,
+Eric Goldman, Ulrich Grepel, Jan Hajic,
+Jarkko Hietaniemi, Eric Hughes, John Interrante,
+Ceriel Jacobs, Jeffrey R. Jones, Henry
+Juengst, Amir Katz, ken@ken.hilco.com, Kevin B. Kenny, Marq Kole, Ronald
+Lamprecht, Greg Lee, Craig Leres, John Levine, Steve Liddle,
+Mohamed el Lozy, Brian Madsen, Chris
+Metcalf, Luke Mewburn, Jim Meyering, G.T. Nicol, Landon Noll, Marc Nozell,
+Richard Ohnemus, Sven Panne, Roland Pesch, Walter Pelissero, Gaumond
+Pierre, Esmond Pitt, Jef Poskanzer, Joe Rahmeh, Frederic Raimbault,
+Rick Richardson,
+Kevin Rodgers, Jim Roskind,
+Doug Schmidt, Philippe Schnoebelen, Andreas Schwab,
+Alex Siegel, Mike Stump, Paul Stuart, Dave Tallman, Chris Thewalt,
+Paul Tuinenga, Gary Weik, Frank Whaley, Gerhard Wilhelms, Kent Williams, Ken
+Yap, Nathan Zelle, David Zuhn, and those whose names have slipped my marginal
+mail-archiving skills but whose contributions are appreciated all the
+same.
+.PP
+Thanks to Keith Bostic, Jon Forrest, Noah Friedman,
+John Gilmore, Craig Leres, John Levine, Bob Mulcahy, G.T.
+Nicol, Francois Pinard, Rich Salz, and Richard Stallman for help with various
+distribution headaches.
+.PP
+Thanks to Esmond Pitt and Earle Horton for 8-bit character support; to
+Benson Margulies and Fred Burke for C++ support; to Kent Williams and Tom
+Epperly for C++ class support; to Ove Ewerlid for support of NUL's; and to
+Eric Hughes for support of multiple buffers.
+.PP
+This work was primarily done when I was with the Real Time Systems Group
+at the Lawrence Berkeley Laboratory in Berkeley, CA.  Many thanks to all there
+for the support I received.
+.PP
+Send comments to:
+.nf
+
+     Vern Paxson
+     Systems Engineering
+     Bldg. 46A, Room 1123
+     Lawrence Berkeley Laboratory
+     University of California
+     Berkeley, CA 94720
+
+     vern@ee.lbl.gov
+
+.fi
diff --git a/usr.bin/lex/gen.c b/usr.bin/lex/gen.c
new file mode 100644
index 000000000000..e2096f2548a8
--- /dev/null
+++ b/usr.bin/lex/gen.c
@@ -0,0 +1,1461 @@
+/* gen - actual generation (writing) of flex scanners */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/gen.c,v 1.3 94/08/03 11:37:45 vern Exp $ */
+
+#include "flexdef.h"
+
+
+/* declare functions that have forward references */
+
+void gen_next_state PROTO((int));
+void genecs PROTO((void));
+void indent_put2s PROTO((char [], char []));
+void indent_puts PROTO((char []));
+
+
+static int indent_level = 0; /* each level is 8 spaces */
+
+#define indent_up() (++indent_level)
+#define indent_down() (--indent_level)
+#define set_indent(indent_val) indent_level = indent_val
+
+/* Almost everything is done in terms of arrays starting at 1, so provide
+ * a null entry for the zero element of all C arrays.  (The exception
+ * to this is that the fast table representation generally uses the
+ * 0 elements of its arrays, too.)
+ */
+static char C_int_decl[] = "static const int %s[%d] =\n    {   0,\n";
+static char C_short_decl[] = "static const short int %s[%d] =\n    {   0,\n";
+static char C_long_decl[] = "static const long int %s[%d] =\n    {   0,\n";
+static char C_state_decl[] =
+	"static const yy_state_type %s[%d] =\n    {   0,\n";
+
+
+/* Indent to the current level. */
+
+void do_indent()
+	{
+	register int i = indent_level * 8;
+
+	while ( i >= 8 )
+		{
+		putchar( '\t' );
+		i -= 8;
+		}
+
+	while ( i > 0 )
+		{
+		putchar( ' ' );
+		--i;
+		}
+	}
+
+
+/* Generate the code to keep backing-up information. */
+
+void gen_backing_up()
+	{
+	if ( reject || num_backing_up == 0 )
+		return;
+
+	if ( fullspd )
+		indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
+	else
+		indent_puts( "if ( yy_accept[yy_current_state] )" );
+
+	indent_up();
+	indent_puts( "{" );
+	indent_puts( "yy_last_accepting_state = yy_current_state;" );
+	indent_puts( "yy_last_accepting_cpos = yy_cp;" );
+	indent_puts( "}" );
+	indent_down();
+	}
+
+
+/* Generate the code to perform the backing up. */
+
+void gen_bu_action()
+	{
+	if ( reject || num_backing_up == 0 )
+		return;
+
+	set_indent( 3 );
+
+	indent_puts( "case 0: /* must back up */" );
+	indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
+	indent_puts( "*yy_cp = yy_hold_char;" );
+
+	if ( fullspd || fulltbl )
+		indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
+	else
+		/* Backing-up info for compressed tables is taken \after/
+		 * yy_cp has been incremented for the next state.
+		 */
+		indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+
+	indent_puts( "yy_current_state = yy_last_accepting_state;" );
+	indent_puts( "goto yy_find_action;" );
+	putchar( '\n' );
+
+	set_indent( 0 );
+	}
+
+
+/* genctbl - generates full speed compressed transition table */
+
+void genctbl()
+	{
+	register int i;
+	int end_of_buffer_action = num_rules + 1;
+
+	/* Table of verify for transition and offset to next state. */
+	printf( "static const struct yy_trans_info yy_transition[%d] =\n",
+		tblend + numecs + 1 );
+	printf( "    {\n" );
+
+	/* We want the transition to be represented as the offset to the
+	 * next state, not the actual state number, which is what it currently
+	 * is.  The offset is base[nxt[i]] - (base of current state)].  That's
+	 * just the difference between the starting points of the two involved
+	 * states (to - from).
+	 *
+	 * First, though, we need to find some way to put in our end-of-buffer
+	 * flags and states.  We do this by making a state with absolutely no
+	 * transitions.  We put it at the end of the table.
+	 */
+
+	/* We need to have room in nxt/chk for two more slots: One for the
+	 * action and one for the end-of-buffer transition.  We now *assume*
+	 * that we're guaranteed the only character we'll try to index this
+	 * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
+	 * there's room for jam entries for other characters.
+	 */
+
+	while ( tblend + 2 >= current_max_xpairs )
+		expand_nxt_chk();
+
+	while ( lastdfa + 1 >= current_max_dfas )
+		increase_max_dfas();
+
+	base[lastdfa + 1] = tblend + 2;
+	nxt[tblend + 1] = end_of_buffer_action;
+	chk[tblend + 1] = numecs + 1;
+	chk[tblend + 2] = 1; /* anything but EOB */
+
+	/* So that "make test" won't show arb. differences. */
+	nxt[tblend + 2] = 0;
+
+	/* Make sure every state has an end-of-buffer transition and an
+	 * action #.
+	 */
+	for ( i = 0; i <= lastdfa; ++i )
+		{
+		int anum = dfaacc[i].dfaacc_state;
+		int offset = base[i];
+
+		chk[offset] = EOB_POSITION;
+		chk[offset - 1] = ACTION_POSITION;
+		nxt[offset - 1] = anum;	/* action number */
+		}
+
+	for ( i = 0; i <= tblend; ++i )
+		{
+		if ( chk[i] == EOB_POSITION )
+			transition_struct_out( 0, base[lastdfa + 1] - i );
+
+		else if ( chk[i] == ACTION_POSITION )
+			transition_struct_out( 0, nxt[i] );
+
+		else if ( chk[i] > numecs || chk[i] == 0 )
+			transition_struct_out( 0, 0 );	/* unused slot */
+
+		else	/* verify, transition */
+			transition_struct_out( chk[i],
+						base[nxt[i]] - (i - chk[i]) );
+		}
+
+
+	/* Here's the final, end-of-buffer state. */
+	transition_struct_out( chk[tblend + 1], nxt[tblend + 1] );
+	transition_struct_out( chk[tblend + 2], nxt[tblend + 2] );
+
+	printf( "    };\n" );
+	printf( "\n" );
+
+	/* Table of pointers to start states. */
+	printf(
+	"static const struct yy_trans_info *yy_start_state_list[%d] =\n",
+		lastsc * 2 + 1 );
+	printf( "    {\n" );	/* } so vi doesn't get confused */
+
+	for ( i = 0; i <= lastsc * 2; ++i )
+		printf( "    &yy_transition[%d],\n", base[i] );
+
+	dataend();
+
+	if ( useecs )
+		genecs();
+	}
+
+
+/* Generate equivalence-class tables. */
+
+void genecs()
+	{
+	Char clower();
+	register int i, j;
+	int numrows;
+
+	printf( C_int_decl, "yy_ec", csize );
+
+	for ( i = 1; i < csize; ++i )
+		{
+		if ( caseins && (i >= 'A') && (i <= 'Z') )
+			ecgroup[i] = ecgroup[clower( i )];
+
+		ecgroup[i] = ABS( ecgroup[i] );
+		mkdata( ecgroup[i] );
+		}
+
+	dataend();
+
+	if ( trace )
+		{
+		fputs( "\n\nEquivalence Classes:\n\n", stderr );
+
+		numrows = csize / 8;
+
+		for ( j = 0; j < numrows; ++j )
+			{
+			for ( i = j; i < csize; i = i + numrows )
+				{
+				fprintf( stderr, "%4s = %-2d",
+					readable_form( i ), ecgroup[i] );
+
+				putc( ' ', stderr );
+				}
+
+			putc( '\n', stderr );
+			}
+		}
+	}
+
+
+/* Generate the code to find the action number. */
+
+void gen_find_action()
+	{
+	if ( fullspd )
+		indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
+
+	else if ( fulltbl )
+		indent_puts( "yy_act = yy_accept[yy_current_state];" );
+
+	else if ( reject )
+		{
+		indent_puts( "yy_current_state = *--yy_state_ptr;" );
+		indent_puts( "yy_lp = yy_accept[yy_current_state];" );
+
+		puts(
+		"find_rule: /* we branch to this label when backing up */" );
+
+		indent_puts(
+		"for ( ; ; ) /* until we find what rule we matched */" );
+
+		indent_up();
+
+		indent_puts( "{" );
+
+		indent_puts(
+		"if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
+		indent_up();
+		indent_puts( "{" );
+		indent_puts( "yy_act = yy_acclist[yy_lp];" );
+
+		if ( variable_trailing_context_rules )
+			{
+			indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
+			indent_puts( "     yy_looking_for_trail_begin )" );
+			indent_up();
+			indent_puts( "{" );
+
+			indent_puts(
+				"if ( yy_act == yy_looking_for_trail_begin )" );
+			indent_up();
+			indent_puts( "{" );
+			indent_puts( "yy_looking_for_trail_begin = 0;" );
+			indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
+			indent_puts( "break;" );
+			indent_puts( "}" );
+			indent_down();
+
+			indent_puts( "}" );
+			indent_down();
+
+			indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
+			indent_up();
+			indent_puts( "{" );
+			indent_puts(
+		"yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" );
+			indent_puts(
+		"yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" );
+
+			if ( real_reject )
+				{
+				/* Remember matched text in case we back up
+				 * due to REJECT.
+				 */
+				indent_puts( "yy_full_match = yy_cp;" );
+				indent_puts( "yy_full_state = yy_state_ptr;" );
+				indent_puts( "yy_full_lp = yy_lp;" );
+				}
+
+			indent_puts( "}" );
+			indent_down();
+
+			indent_puts( "else" );
+			indent_up();
+			indent_puts( "{" );
+			indent_puts( "yy_full_match = yy_cp;" );
+			indent_puts( "yy_full_state = yy_state_ptr;" );
+			indent_puts( "yy_full_lp = yy_lp;" );
+			indent_puts( "break;" );
+			indent_puts( "}" );
+			indent_down();
+
+			indent_puts( "++yy_lp;" );
+			indent_puts( "goto find_rule;" );
+			}
+
+		else
+		{
+		/* Remember matched text in case we back up due to trailing
+		 * context plus REJECT.
+		 */
+		indent_up();
+		indent_puts( "{" );
+		indent_puts( "yy_full_match = yy_cp;" );
+		indent_puts( "break;" );
+		indent_puts( "}" );
+		indent_down();
+		}
+
+		indent_puts( "}" );
+		indent_down();
+
+		indent_puts( "--yy_cp;" );
+
+		/* We could consolidate the following two lines with those at
+		 * the beginning, but at the cost of complaints that we're
+		 * branching inside a loop.
+		 */
+		indent_puts( "yy_current_state = *--yy_state_ptr;" );
+		indent_puts( "yy_lp = yy_accept[yy_current_state];" );
+
+		indent_puts( "}" );
+
+		indent_down();
+		}
+
+	else
+		/* compressed */
+		indent_puts( "yy_act = yy_accept[yy_current_state];" );
+	}
+
+
+/* genftbl - generates full transition table */
+
+void genftbl()
+	{
+	register int i;
+	int end_of_buffer_action = num_rules + 1;
+
+	printf( long_align ? C_long_decl : C_short_decl,
+		"yy_accept", lastdfa + 1 );
+
+	dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
+
+	for ( i = 1; i <= lastdfa; ++i )
+		{
+		register int anum = dfaacc[i].dfaacc_state;
+
+		mkdata( anum );
+
+		if ( trace && anum )
+			fprintf( stderr, "state # %d accepts: [%d]\n",
+				i, anum );
+		}
+
+	dataend();
+
+	if ( useecs )
+		genecs();
+
+	/* Don't have to dump the actual full table entries - they were
+	 * created on-the-fly.
+	 */
+	}
+
+
+/* Generate the code to find the next compressed-table state. */
+
+void gen_next_compressed_state( char_map )
+char *char_map;
+	{
+	indent_put2s( "register YY_CHAR yy_c = %s;", char_map );
+
+	/* Save the backing-up info \before/ computing the next state
+	 * because we always compute one more state than needed - we
+	 * always proceed until we reach a jam state
+	 */
+	gen_backing_up();
+
+	indent_puts(
+"while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
+	indent_up();
+	indent_puts( "{" );
+	indent_puts( "yy_current_state = (int) yy_def[yy_current_state];" );
+
+	if ( usemecs )
+		{
+		/* We've arrange it so that templates are never chained
+		 * to one another.  This means we can afford to make a
+		 * very simple test to see if we need to convert to
+		 * yy_c's meta-equivalence class without worrying
+		 * about erroneously looking up the meta-equivalence
+		 * class twice
+		 */
+		do_indent();
+
+		/* lastdfa + 2 is the beginning of the templates */
+		printf( "if ( yy_current_state >= %d )\n", lastdfa + 2 );
+
+		indent_up();
+		indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" );
+		indent_down();
+		}
+
+	indent_puts( "}" );
+	indent_down();
+
+	indent_puts(
+"yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];" );
+	}
+
+
+/* Generate the code to find the next match. */
+
+void gen_next_match()
+	{
+	/* NOTE - changes in here should be reflected in gen_next_state() and
+	 * gen_NUL_trans().
+	 */
+	char *char_map = useecs ?
+				"yy_ec[YY_SC_TO_UI(*yy_cp)]" :
+				"YY_SC_TO_UI(*yy_cp)";
+
+	char *char_map_2 = useecs ?
+				"yy_ec[YY_SC_TO_UI(*++yy_cp)]" :
+				"YY_SC_TO_UI(*++yy_cp)";
+
+	if ( fulltbl )
+		{
+		indent_put2s(
+	"while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
+				char_map );
+
+		indent_up();
+
+		if ( num_backing_up > 0 )
+			{
+			indent_puts( "{" );	/* } for vi */
+			gen_backing_up();
+			putchar( '\n' );
+			}
+
+		indent_puts( "++yy_cp;" );
+
+		if ( num_backing_up > 0 )
+			/* { for vi */
+			indent_puts( "}" );
+
+		indent_down();
+
+		putchar( '\n' );
+		indent_puts( "yy_current_state = -yy_current_state;" );
+		}
+
+	else if ( fullspd )
+		{
+		indent_puts( "{" );	/* } for vi */
+		indent_puts(
+		"register const struct yy_trans_info *yy_trans_info;\n" );
+		indent_puts( "register YY_CHAR yy_c;\n" );
+		indent_put2s( "for ( yy_c = %s;", char_map );
+		indent_puts(
+	"      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->" );
+		indent_puts( "yy_verify == yy_c;" );
+		indent_put2s( "      yy_c = %s )", char_map_2 );
+
+		indent_up();
+
+		if ( num_backing_up > 0 )
+			indent_puts( "{" );	/* } for vi */
+
+		indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
+
+		if ( num_backing_up > 0 )
+			{
+			putchar( '\n' );
+			gen_backing_up();	/* { for vi */
+			indent_puts( "}" );
+			}
+
+		indent_down();	/* { for vi */
+		indent_puts( "}" );
+		}
+
+	else
+		{ /* compressed */
+		indent_puts( "do" );
+
+		indent_up();
+		indent_puts( "{" );	/* } for vi */
+
+		gen_next_state( false );
+
+		indent_puts( "++yy_cp;" );
+
+		/* { for vi */
+		indent_puts( "}" );
+		indent_down();
+
+		do_indent();
+
+		if ( interactive )
+			printf( "while ( yy_base[yy_current_state] != %d );\n",
+				jambase );
+		else
+			printf( "while ( yy_current_state != %d );\n",
+				jamstate );
+
+		if ( ! reject && ! interactive )
+			{
+			/* Do the guaranteed-needed backing up to figure out
+			 * the match.
+			 */
+			indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+			indent_puts(
+				"yy_current_state = yy_last_accepting_state;" );
+			}
+		}
+	}
+
+
+/* Generate the code to find the next state. */
+
+void gen_next_state( worry_about_NULs )
+int worry_about_NULs;
+	{ /* NOTE - changes in here should be reflected in get_next_match() */
+	char char_map[256];
+
+	if ( worry_about_NULs && ! nultrans )
+		{
+		if ( useecs )
+			(void) sprintf( char_map,
+				"(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)",
+					NUL_ec );
+		else
+			(void) sprintf( char_map,
+				"(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", NUL_ec );
+		}
+
+	else
+		strcpy( char_map, useecs ? "yy_ec[YY_SC_TO_UI(*yy_cp)]" :
+					   "YY_SC_TO_UI(*yy_cp)" );
+
+	if ( worry_about_NULs && nultrans )
+		{
+		if ( ! fulltbl && ! fullspd )
+			/* Compressed tables back up *before* they match. */
+			gen_backing_up();
+
+		indent_puts( "if ( *yy_cp )" );
+		indent_up();
+		indent_puts( "{" );	/* } for vi */
+		}
+
+	if ( fulltbl )
+		indent_put2s(
+			"yy_current_state = yy_nxt[yy_current_state][%s];", 
+				char_map );
+
+	else if ( fullspd )
+		indent_put2s(
+			"yy_current_state += yy_current_state[%s].yy_nxt;",
+				char_map );
+
+	else
+		gen_next_compressed_state( char_map );
+
+	if ( worry_about_NULs && nultrans )
+		{
+		/* { for vi */
+		indent_puts( "}" );
+		indent_down();
+		indent_puts( "else" );
+		indent_up();
+		indent_puts(
+			"yy_current_state = yy_NUL_trans[yy_current_state];" );
+		indent_down();
+		}
+
+	if ( fullspd || fulltbl )
+		gen_backing_up();
+
+	if ( reject )
+		indent_puts( "*yy_state_ptr++ = yy_current_state;" );
+	}
+
+
+/* Generate the code to make a NUL transition. */
+
+void gen_NUL_trans()
+	{ /* NOTE - changes in here should be reflected in get_next_match() */
+	int need_backing_up = (num_backing_up > 0 && ! reject);
+
+	if ( need_backing_up )
+		/* We'll need yy_cp lying around for the gen_backing_up(). */
+		indent_puts( "register char *yy_cp = yy_c_buf_p;" );
+
+	putchar( '\n' );
+
+	if ( nultrans )
+		{
+		indent_puts(
+			"yy_current_state = yy_NUL_trans[yy_current_state];" );
+		indent_puts( "yy_is_jam = (yy_current_state == 0);" );
+		}
+
+	else if ( fulltbl )
+		{
+		do_indent();
+		printf( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
+			NUL_ec );
+		indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
+		}
+
+	else if ( fullspd )
+		{
+		do_indent();
+		printf( "register int yy_c = %d;\n", NUL_ec );
+
+		indent_puts(
+		"register const struct yy_trans_info *yy_trans_info;\n" );
+		indent_puts(
+		"yy_trans_info = &yy_current_state[(unsigned int) yy_c];" );
+		indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
+
+		indent_puts(
+			"yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
+		}
+
+	else
+		{
+		char NUL_ec_str[20];
+
+		(void) sprintf( NUL_ec_str, "%d", NUL_ec );
+		gen_next_compressed_state( NUL_ec_str );
+
+		if ( reject )
+			indent_puts( "*yy_state_ptr++ = yy_current_state;" );
+
+		do_indent();
+
+		printf( "yy_is_jam = (yy_current_state == %d);\n", jamstate );
+		}
+
+	/* If we've entered an accepting state, back up; note that
+	 * compressed tables have *already* done such backing up, so
+	 * we needn't bother with it again.
+	 */
+	if ( need_backing_up && (fullspd || fulltbl) )
+		{
+		putchar( '\n' );
+		indent_puts( "if ( ! yy_is_jam )" );
+		indent_up();
+		indent_puts( "{" );
+		gen_backing_up();
+		indent_puts( "}" );
+		indent_down();
+		}
+	}
+
+
+/* Generate the code to find the start state. */
+
+void gen_start_state()
+	{
+	if ( fullspd )
+		indent_put2s(
+			"yy_current_state = yy_start_state_list[yy_start%s];",
+			bol_needed ? " + (yy_bp[-1] == '\\n' ? 1 : 0)" : "" );
+
+	else
+		{
+		indent_puts( "yy_current_state = yy_start;" );
+
+		if ( bol_needed )
+			{
+			indent_puts( "if ( yy_bp[-1] == '\\n' )" );
+			indent_up();
+			indent_puts( "++yy_current_state;" );
+			indent_down();
+			}
+
+		if ( reject )
+			{
+			/* Set up for storing up states. */
+			indent_puts( "yy_state_ptr = yy_state_buf;" );
+			indent_puts( "*yy_state_ptr++ = yy_current_state;" );
+			}
+		}
+	}
+
+
+/* gentabs - generate data statements for the transition tables */
+
+void gentabs()
+	{
+	int i, j, k, *accset, nacc, *acc_array, total_states;
+	int end_of_buffer_action = num_rules + 1;
+
+	/* *Everything* is done in terms of arrays starting at 1, so provide
+	 * a null entry for the zero element of all C arrays.
+	 */
+	static char C_char_decl[] =
+		"static const YY_CHAR %s[%d] =\n    {   0,\n";	/* } for vi */
+
+	acc_array = allocate_integer_array( current_max_dfas );
+	nummt = 0;
+
+	/* The compressed table format jams by entering the "jam state",
+	 * losing information about the previous state in the process.
+	 * In order to recover the previous state, we effectively need
+	 * to keep backing-up information.
+	 */
+	++num_backing_up;
+
+	if ( reject )
+		{
+		/* Write out accepting list and pointer list.
+		 *
+		 * First we generate the "yy_acclist" array.  In the process,
+		 * we compute the indices that will go into the "yy_accept"
+		 * array, and save the indices in the dfaacc array.
+		 */
+		int EOB_accepting_list[2];
+
+		/* Set up accepting structures for the End Of Buffer state. */
+		EOB_accepting_list[0] = 0;
+		EOB_accepting_list[1] = end_of_buffer_action;
+		accsiz[end_of_buffer_state] = 1;
+		dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list;
+
+		printf( long_align ? C_long_decl : C_short_decl,
+			"yy_acclist", MAX( numas, 1 ) + 1 );
+
+		j = 1;	/* index into "yy_acclist" array */
+
+		for ( i = 1; i <= lastdfa; ++i )
+			{
+			acc_array[i] = j;
+
+			if ( accsiz[i] != 0 )
+				{
+				accset = dfaacc[i].dfaacc_set;
+				nacc = accsiz[i];
+
+				if ( trace )
+					fprintf( stderr,
+						"state # %d accepts: ", i );
+
+				for ( k = 1; k <= nacc; ++k )
+					{
+					int accnum = accset[k];
+
+					++j;
+
+					if ( variable_trailing_context_rules &&
+					  ! (accnum & YY_TRAILING_HEAD_MASK) &&
+					   accnum > 0 && accnum <= num_rules &&
+					  rule_type[accnum] == RULE_VARIABLE )
+						{
+						/* Special hack to flag
+						 * accepting number as part
+						 * of trailing context rule.
+						 */
+						accnum |= YY_TRAILING_MASK;
+						}
+
+					mkdata( accnum );
+
+					if ( trace )
+						{
+						fprintf( stderr, "[%d]",
+							accset[k] );
+
+						if ( k < nacc )
+							fputs( ", ", stderr );
+						else
+							putc( '\n', stderr );
+						}
+					}
+				}
+			}
+
+		/* add accepting number for the "jam" state */
+		acc_array[i] = j;
+
+		dataend();
+		}
+
+	else
+		{
+		dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
+
+		for ( i = 1; i <= lastdfa; ++i )
+			acc_array[i] = dfaacc[i].dfaacc_state;
+
+		/* add accepting number for jam state */
+		acc_array[i] = 0;
+		}
+
+	/* Spit out "yy_accept" array.  If we're doing "reject", it'll be
+	 * pointers into the "yy_acclist" array.  Otherwise it's actual
+	 * accepting numbers.  In either case, we just dump the numbers.
+	 */
+
+	/* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
+	 * beginning at 0 and for "jam" state.
+	 */
+	k = lastdfa + 2;
+
+	if ( reject )
+		/* We put a "cap" on the table associating lists of accepting
+		 * numbers with state numbers.  This is needed because we tell
+		 * where the end of an accepting list is by looking at where
+		 * the list for the next state starts.
+		 */
+		++k;
+
+	printf( long_align ? C_long_decl : C_short_decl, "yy_accept", k );
+
+	for ( i = 1; i <= lastdfa; ++i )
+		{
+		mkdata( acc_array[i] );
+
+		if ( ! reject && trace && acc_array[i] )
+			fprintf( stderr, "state # %d accepts: [%d]\n",
+				i, acc_array[i] );
+		}
+
+	/* Add entry for "jam" state. */
+	mkdata( acc_array[i] );
+
+	if ( reject )
+		/* Add "cap" for the list. */
+		mkdata( acc_array[i] );
+
+	dataend();
+
+	if ( useecs )
+		genecs();
+
+	if ( usemecs )
+		{
+		/* Write out meta-equivalence classes (used to index
+		 * templates with).
+		 */
+
+		if ( trace )
+			fputs( "\n\nMeta-Equivalence Classes:\n", stderr );
+
+		printf( C_int_decl, "yy_meta", numecs + 1 );
+
+		for ( i = 1; i <= numecs; ++i )
+			{
+			if ( trace )
+				fprintf( stderr, "%d = %d\n",
+					i, ABS( tecbck[i] ) );
+
+			mkdata( ABS( tecbck[i] ) );
+			}
+
+		dataend();
+		}
+
+	total_states = lastdfa + numtemps;
+
+	printf( (tblend >= MAX_SHORT || long_align) ?
+			C_long_decl : C_short_decl,
+		"yy_base", total_states + 1 );
+
+	for ( i = 1; i <= lastdfa; ++i )
+		{
+		register int d = def[i];
+
+		if ( base[i] == JAMSTATE )
+			base[i] = jambase;
+
+		if ( d == JAMSTATE )
+			def[i] = jamstate;
+
+		else if ( d < 0 )
+			{
+			/* Template reference. */
+			++tmpuses;
+			def[i] = lastdfa - d + 1;
+			}
+
+		mkdata( base[i] );
+		}
+
+	/* Generate jam state's base index. */
+	mkdata( base[i] );
+
+	for ( ++i /* skip jam state */; i <= total_states; ++i )
+		{
+		mkdata( base[i] );
+		def[i] = jamstate;
+		}
+
+	dataend();
+
+	printf( (total_states >= MAX_SHORT || long_align) ?
+			C_long_decl : C_short_decl,
+		"yy_def", total_states + 1 );
+
+	for ( i = 1; i <= total_states; ++i )
+		mkdata( def[i] );
+
+	dataend();
+
+	printf( (total_states >= MAX_SHORT || long_align) ?
+			C_long_decl : C_short_decl,
+		"yy_nxt", tblend + 1 );
+
+	for ( i = 1; i <= tblend; ++i )
+		{
+		if ( nxt[i] == 0 || chk[i] == 0 )
+			nxt[i] = jamstate;	/* new state is the JAM state */
+
+		mkdata( nxt[i] );
+		}
+
+	dataend();
+
+	printf( (total_states >= MAX_SHORT || long_align) ?
+			C_long_decl : C_short_decl,
+		"yy_chk", tblend + 1 );
+
+	for ( i = 1; i <= tblend; ++i )
+		{
+		if ( chk[i] == 0 )
+			++nummt;
+
+		mkdata( chk[i] );
+		}
+
+	dataend();
+	}
+
+
+/* Write out a formatted string (with a secondary string argument) at the
+ * current indentation level, adding a final newline.
+ */
+
+void indent_put2s( fmt, arg )
+char fmt[], arg[];
+	{
+	do_indent();
+	printf( fmt, arg );
+	putchar( '\n' );
+	}
+
+
+/* Write out a string at the current indentation level, adding a final
+ * newline.
+ */
+
+void indent_puts( str )
+char str[];
+	{
+	do_indent();
+	puts( str );
+	}
+
+
+/* make_tables - generate transition tables and finishes generating output file
+ */
+
+void make_tables()
+	{
+	register int i;
+	int did_eof_rule = false;
+
+	skelout();
+
+	/* First, take care of YY_DO_BEFORE_ACTION depending on yymore
+	 * being used.
+	 */
+	set_indent( 1 );
+
+	if ( yymore_used )
+		{
+		indent_puts( "yytext_ptr -= yy_more_len; \\" );
+		indent_puts( "yyleng = yy_cp - yytext_ptr; \\" );
+		}
+
+	else
+		indent_puts( "yyleng = yy_cp - yy_bp; \\" );
+
+	/* Now also deal with copying yytext_ptr to yytext if needed. */
+	skelout();
+	if ( yytext_is_array )
+		{
+		indent_puts( "if ( yyleng >= YYLMAX ) \\" );
+		indent_up();
+		indent_puts(
+		"YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
+		indent_down();
+		indent_puts(
+		"yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" );
+		}
+
+	set_indent( 0 );
+
+	skelout();
+
+
+	printf( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
+
+	if ( fullspd )
+		{
+		/* Need to define the transet type as a size large
+		 * enough to hold the biggest offset.
+		 */
+		int total_table_size = tblend + numecs + 1;
+		char *trans_offset_type =
+			(total_table_size >= MAX_SHORT || long_align) ?
+				"long" : "short";
+
+		set_indent( 0 );
+		indent_puts( "struct yy_trans_info" );
+		indent_up();
+		indent_puts( "{" ); 	/* } for vi */
+
+		if ( long_align )
+			indent_puts( "long yy_verify;" );
+		else
+			indent_puts( "short yy_verify;" );
+
+		/* In cases where its sister yy_verify *is* a "yes, there is
+		 * a transition", yy_nxt is the offset (in records) to the
+		 * next state.  In most cases where there is no transition,
+		 * the value of yy_nxt is irrelevant.  If yy_nxt is the -1th
+		 * record of a state, though, then yy_nxt is the action number
+		 * for that state.
+		 */
+
+		indent_put2s( "%s yy_nxt;", trans_offset_type );
+		indent_puts( "};" );
+		indent_down();
+		}
+
+	if ( fullspd )
+		genctbl();
+	else if ( fulltbl )
+		genftbl();
+	else
+		gentabs();
+
+	/* Definitions for backing up.  We don't need them if REJECT
+	 * is being used because then we use an alternative backin-up
+	 * technique instead.
+	 */
+	if ( num_backing_up > 0 && ! reject )
+		{
+		if ( ! C_plus_plus )
+			{
+			indent_puts(
+			"static yy_state_type yy_last_accepting_state;" );
+			indent_puts(
+				"static char *yy_last_accepting_cpos;\n" );
+			}
+		}
+
+	if ( nultrans )
+		{
+		printf( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
+
+		for ( i = 1; i <= lastdfa; ++i )
+			{
+			if ( fullspd )
+				printf( "    &yy_transition[%d],\n", base[i] );
+			else
+				mkdata( nultrans[i] );
+			}
+
+		dataend();
+		}
+
+	if ( ddebug )
+		{ /* Spit out table mapping rules to line numbers. */
+		indent_puts( "extern int yy_flex_debug;" );
+		indent_puts( "int yy_flex_debug = 1;\n" );
+
+		printf( long_align ? C_long_decl : C_short_decl,
+			"yy_rule_linenum", num_rules );
+		for ( i = 1; i < num_rules; ++i )
+			mkdata( rule_linenum[i] );
+		dataend();
+		}
+
+	if ( reject )
+		{
+		/* Declare state buffer variables. */
+		if ( ! C_plus_plus )
+			{
+			puts(
+	"static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
+			puts( "static char *yy_full_match;" );
+			puts( "static int yy_lp;" );
+			}
+
+		if ( variable_trailing_context_rules )
+			{
+			if ( ! C_plus_plus )
+				{
+				puts(
+				"static int yy_looking_for_trail_begin = 0;" );
+				puts( "static int yy_full_lp;" );
+				puts( "static int *yy_full_state;" );
+				}
+
+			printf( "#define YY_TRAILING_MASK 0x%x\n",
+				(unsigned int) YY_TRAILING_MASK );
+			printf( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
+				(unsigned int) YY_TRAILING_HEAD_MASK );
+			}
+
+		puts( "#define REJECT \\" );
+		puts( "{ \\" );		/* } for vi */
+		puts(
+	"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
+		puts(
+	"yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
+
+		if ( variable_trailing_context_rules )
+			{
+			puts(
+		"yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
+			puts(
+		"yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
+			puts(
+	"yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
+			}
+
+		puts( "++yy_lp; \\" );
+		puts( "goto find_rule; \\" );
+		/* { for vi */
+		puts( "}" );
+		}
+
+	else
+		{
+		puts(
+		"/* The intent behind this definition is that it'll catch" );
+		puts( " * any uses of REJECT which flex missed." );
+		puts( " */" );
+		puts( "#define REJECT reject_used_but_not_detected" );
+		}
+
+	if ( yymore_used )
+		{
+		if ( ! C_plus_plus )
+			{
+			indent_puts( "static int yy_more_flag = 0;" );
+			indent_puts( "static int yy_more_len = 0;" );
+			}
+
+		indent_puts( "#define yymore() (yy_more_flag = 1)" );
+		indent_puts( "#define YY_MORE_ADJ yy_more_len" );
+		}
+
+	else
+		{
+		indent_puts( "#define yymore() yymore_used_but_not_detected" );
+		indent_puts( "#define YY_MORE_ADJ 0" );
+		}
+
+	if ( ! C_plus_plus )
+		{
+		if ( yytext_is_array )
+			{
+			puts( "#ifndef YYLMAX" );
+			puts( "#define YYLMAX 8192" );
+			puts( "#endif\n" );
+			puts( "char yytext[YYLMAX];" );
+			puts( "char *yytext_ptr;" );
+			}
+
+		else
+			puts( "char *yytext;" );
+		}
+
+	fputs( &action_array[defs1_offset], stdout );
+
+	skelout();
+
+	if ( ! C_plus_plus )
+		{
+		if ( use_read )
+			{
+			printf(
+"\tif ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\\n" );
+			printf(
+		"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );\n" );
+			}
+
+		else
+			{
+			printf(
+			"\tif ( yy_current_buffer->yy_is_interactive ) \\\n" );
+			printf( "\t\t{ \\\n" );
+			printf( "\t\tint c = getc( yyin ); \\\n" );
+			printf( "\t\tresult = c == EOF ? 0 : 1; \\\n" );
+			printf( "\t\tbuf[0] = (char) c; \\\n" );
+			printf( "\t\t} \\\n" );
+			printf(
+	"\telse if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\\n" );
+			printf( "\t\t  && ferror( yyin ) ) \\\n" );
+			printf(
+		"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );\n" );
+			}
+		}
+
+	skelout();
+
+	/* Copy prolog to output file. */
+	fputs( &action_array[prolog_offset], stdout );
+
+	skelout();
+
+	set_indent( 2 );
+
+	if ( yymore_used )
+		{
+		indent_puts( "yy_more_len = 0;" );
+		indent_puts( "if ( yy_more_flag )" );
+		indent_up();
+		indent_puts( "{" );
+		indent_puts( "yy_more_len = yyleng;" );
+		indent_puts( "yy_more_flag = 0;" );
+		indent_puts( "}" );
+		indent_down();
+		}
+
+	skelout();
+
+	gen_start_state();
+
+	/* Note, don't use any indentation. */
+	puts( "yy_match:" );
+	gen_next_match();
+
+	skelout();
+	set_indent( 2 );
+	gen_find_action();
+
+	skelout();
+	if ( lex_compat )
+		{
+		indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" );
+		indent_up();
+		indent_puts( "{" );
+		indent_puts( "int yyl;" );
+		indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" );
+		indent_up();
+		indent_puts( "if ( yytext[yyl] == '\\n' )" );
+		indent_up();
+		indent_puts( "++yylineno;" );
+		indent_down();
+		indent_down();
+		indent_puts( "}" );
+		indent_down();
+		}
+
+	skelout();
+	if ( ddebug )
+		{
+		indent_puts( "if ( yy_flex_debug )" );
+		indent_up();
+
+		indent_puts( "{" );
+		indent_puts( "if ( yy_act == 0 )" );
+		indent_up();
+		indent_puts(
+			"fprintf( stderr, \"--scanner backing up\\n\" );" );
+		indent_down();
+
+		do_indent();
+		printf( "else if ( yy_act < %d )\n", num_rules );
+		indent_up();
+		indent_puts(
+	"fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
+		indent_puts( "         yy_rule_linenum[yy_act], yytext );" );
+		indent_down();
+
+		do_indent();
+		printf( "else if ( yy_act == %d )\n", num_rules );
+		indent_up();
+		indent_puts(
+	"fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
+		indent_puts( "         yytext );" );
+		indent_down();
+
+		do_indent();
+		printf( "else if ( yy_act == %d )\n", num_rules + 1 );
+		indent_up();
+		indent_puts(
+	"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
+		indent_down();
+
+		do_indent();
+		printf( "else\n" );
+		indent_up();
+		indent_puts(
+	"fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" );
+		indent_down();
+
+		indent_puts( "}" );
+		indent_down();
+		}
+
+	/* Copy actions to output file. */
+	skelout();
+	indent_up();
+	gen_bu_action();
+	fputs( &action_array[action_offset], stdout );
+
+	/* generate cases for any missing EOF rules */
+	for ( i = 1; i <= lastsc; ++i )
+		if ( ! sceof[i] )
+			{
+			do_indent();
+			printf( "case YY_STATE_EOF(%s):\n", scname[i] );
+			did_eof_rule = true;
+			}
+
+	if ( did_eof_rule )
+		{
+		indent_up();
+		indent_puts( "yyterminate();" );
+		indent_down();
+		}
+
+
+	/* Generate code for handling NUL's, if needed. */
+
+	/* First, deal with backing up and setting up yy_cp if the scanner
+	 * finds that it should JAM on the NUL.
+	 */
+	skelout();
+	set_indent( 7 );
+
+	if ( fullspd || fulltbl )
+		indent_puts( "yy_cp = yy_c_buf_p;" );
+
+	else
+		{ /* compressed table */
+		if ( ! reject && ! interactive )
+			{
+			/* Do the guaranteed-needed backing up to figure
+			 * out the match.
+			 */
+			indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+			indent_puts(
+				"yy_current_state = yy_last_accepting_state;" );
+			}
+
+		else
+			/* Still need to initialize yy_cp, though
+			 * yy_current_state was set up by
+			 * yy_get_previous_state().
+			 */
+			indent_puts( "yy_cp = yy_c_buf_p;" );
+		}
+
+
+	/* Generate code for yy_get_previous_state(). */
+	set_indent( 1 );
+	skelout();
+
+	if ( bol_needed )
+		indent_puts( "register char *yy_bp = yytext_ptr;\n" );
+
+	gen_start_state();
+
+	set_indent( 2 );
+	skelout();
+	gen_next_state( true );
+
+	set_indent( 1 );
+	skelout();
+	gen_NUL_trans();
+
+	skelout();
+	if ( lex_compat )
+		{ /* update yylineno inside of unput() */
+		indent_puts( "if ( c == '\\n' )" );
+		indent_up();
+		indent_puts( "--yylineno;" );
+		indent_down();
+		}
+
+	skelout();
+
+	/* Copy remainder of input to output. */
+
+	line_directive_out( stdout );
+
+	if ( sectnum == 3 )
+		(void) flexscan(); /* copy remainder of input to output */
+	}
diff --git a/usr.bin/lex/initscan.c b/usr.bin/lex/initscan.c
new file mode 100644
index 000000000000..7daaef23826a
--- /dev/null
+++ b/usr.bin/lex/initscan.c
@@ -0,0 +1,2723 @@
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/flex.skl,v 1.2 94/08/03 11:13:24 vern Exp $
+ */
+
+#define FLEX_SCANNER
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#ifdef __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+
+#ifdef __TURBOC__
+#define YY_USE_CONST
+#endif
+
+
+#ifndef YY_USE_CONST
+#ifndef const
+#define const
+#endif
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.
+ */
+#define YY_START ((yy_start - 1) / 2)
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file".  Now included
+ * only for backward compatibility with previous versions of flex.
+ */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	extern int yywrap YY_PROTO(( void ));
+#ifdef __cplusplus
+	}
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		*yy_cp = yy_hold_char; \
+		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+	};
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+void yyrestart YY_PROTO(( FILE *input_file ));
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+static void yy_push_state YY_PROTO(( int new_state ));
+static void yy_pop_state YY_PROTO(( void ));
+static int yy_top_state YY_PROTO(( void ));
+
+static void *yy_flex_alloc YY_PROTO(( unsigned int ));
+static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define INITIAL 0
+#define SECT2 1
+#define SECT2PROLOG 2
+#define SECT3 3
+#define CODEBLOCK 4
+#define PICKUPDEF 5
+#define SC 6
+#define CARETISBOL 7
+#define NUM 8
+#define QUOTE 9
+#define FIRSTCCL 10
+#define CCL 11
+#define ACTION 12
+#define RECOVER 13
+#define BRACEERROR 14
+#define C_COMMENT 15
+#define ACTION_COMMENT 16
+#define ACTION_STRING 17
+#define PERCENT_BRACE_ACTION 18
+#define USED_LIST 19
+#define CODEBLOCK_2 20
+typedef unsigned char YY_CHAR;
+typedef int yy_state_type;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+extern char *yytext;
+#define yytext_ptr yytext
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));
+#endif
+
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( const char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext_ptr = yy_bp; \
+	yyleng = yy_cp - yy_bp; \
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yy_c_buf_p = yy_cp;
+
+#define YY_END_OF_BUFFER 113
+static const short int yy_accept[408] =
+    {   0,
+        0,    0,    0,    0,   41,   41,  110,  110,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,  113,  111,    6,   17,  111,   15,    1,   16,
+      111,  111,  111,   14,   60,   53,   54,   60,   47,   60,
+       59,   60,   60,   60,   60,   44,   43,   60,   60,   45,
+       46,   41,   42,   41,   40,   39,   40,   40,  110,  110,
+       26,   27,   26,   26,   26,   26,   26,   26,   29,   28,
+       30,   29,   65,   61,   62,   64,   66,   80,   81,   80,
+
+       78,   77,   79,   67,   69,   67,   68,   67,   72,   72,
+       72,   74,   76,   74,   74,   74,   75,   92,   97,   92,
+       96,   98,   98,   93,   93,   93,   90,   91,  111,   31,
+      111,   83,  111,   82,   20,   22,   20,   21,  101,  102,
+      101,  100,  103,  105,  103,  106,  107,   88,   88,   89,
+       88,   88,   88,   88,   88,   88,   36,   33,   32,   36,
+       36,   36,   88,    6,   17,    0,   17,   15,    1,   16,
+        0,   16,   13,    7,    0,    0,    0,    3,    0,    4,
+        0,    2,   14,   53,   54,    0,    0,    0,   54,   50,
+       50,    0,    0,   57,    0,  108,  108,  108,   49,   48,
+
+       49,   44,   43,    0,   43,   56,   44,   41,   42,   40,
+       39,   39,   37,   38,  110,  110,   26,   27,   26,   26,
+       26,   26,   29,   28,   30,   63,   64,   81,   77,   69,
+      109,  109,  109,   70,   71,   76,   73,   92,   97,    0,
+       95,    0,   94,   93,   93,   93,    0,   31,    0,   31,
+       31,   83,   20,   22,   18,  101,  102,  101,  102,  102,
+       99,  103,  105,  104,   88,   88,   88,   89,   85,   88,
+       88,   88,   36,   33,   32,   36,   36,   84,   13,    7,
+        0,   12,    0,    0,    0,    0,    3,    0,    0,    4,
+        0,    5,    0,   51,    0,   52,    0,    0,   57,    0,
+
+       57,   57,  108,  108,   49,   49,   58,   56,   37,   38,
+       26,   26,   26,   23,   26,    0,  109,  109,   93,   93,
+        0,   19,    0,   85,   85,   88,   88,   36,   36,   12,
+        0,    0,    0,    3,    0,    0,    4,    5,    5,   52,
+       52,    0,   57,   57,   57,   57,  108,   26,   26,   23,
+       23,    0,  109,   93,   93,   19,   19,   88,   88,   36,
+       36,    0,    0,    0,   10,    0,   57,   57,   57,   57,
+       26,   26,   93,   93,   88,   88,   36,   36,    0,    0,
+        0,    0,   57,   57,   24,   25,   86,   87,   86,   87,
+       34,   35,    0,    9,    0,    0,   11,   55,    9,    9,
+
+        0,    0,    8,    0,    8,    8,    0
+    } ;
+
+static const int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    5,    1,    6,    7,    1,    8,    9,
+        9,   10,    9,   11,   12,    9,   13,   14,   14,   14,
+       14,   14,   14,   14,   14,   14,   14,    1,    1,   15,
+        1,   16,    9,    1,   22,   23,   24,   25,   26,   27,
+       21,   21,   28,   29,   30,   21,   31,   32,   33,   34,
+       21,   35,   36,   37,   38,   21,   21,   39,   40,   21,
+       17,   18,   19,   20,   21,    1,   22,   23,   24,   25,
+
+       26,   27,   21,   21,   28,   29,   30,   21,   31,   32,
+       33,   34,   21,   35,   36,   37,   38,   21,   21,   39,
+       40,   21,   41,   42,   43,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const int yy_meta[44] =
+    {   0,
+        1,    2,    3,    1,    4,    1,    1,    5,    1,    6,
+        1,    7,    5,    8,    1,    1,    1,    9,   10,    1,
+       11,   12,   12,   12,   12,   12,   12,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   13,   11,   11,   11,
+        5,    1,   14
+    } ;
+
+static const short int yy_base[470] =
+    {   0,
+        0,   43,   85,  126,   89,  102, 1611, 1610,  168, 1605,
+      108,  111,  211,    0, 1591, 1590,  252,  254,  116,  119,
+       98,  122,  144,  146,  297,    0,   93,  104,  338,  340,
+      149,  151,  257,  266,  268,  274,  383,    0,  425,  428,
+     1596, 1595, 1607, 1615,  278, 1602, 1602,    0,  281, 1600,
+     1600,  462, 1592,    0, 1615,  431, 1597, 1597, 1615,  285,
+     1615, 1584, 1580,  331,  503,  437, 1593, 1593,  110, 1580,
+     1615,    0, 1590, 1590,    0, 1590, 1588,  221, 1587, 1615,
+        0, 1585, 1585, 1615,    0, 1561, 1546, 1511,    0, 1551,
+     1543, 1543, 1615, 1615, 1498,    0, 1615, 1615, 1500, 1487,
+
+     1615, 1463, 1615, 1615, 1466, 1460, 1615,  332, 1615,  333,
+      126, 1615, 1411, 1398,    0,  334, 1615,    0, 1383, 1383,
+     1615,  341, 1371,    0, 1354, 1336, 1615, 1615,  271, 1371,
+      287, 1370, 1366, 1615,    0, 1362, 1349, 1331,  290, 1335,
+      347, 1325,    0, 1323, 1310, 1615,    0,    0,  350, 1306,
+     1287, 1246, 1615,    0, 1249, 1227,    0, 1264, 1261, 1255,
+     1225, 1197, 1213,  351, 1213, 1213, 1615,    0,  358, 1198,
+     1193, 1615,    0,    0,  443,  361,  447,    0,  342,    0,
+      363, 1615,    0,  451, 1191, 1188, 1149,  365, 1615, 1615,
+     1185, 1181, 1155, 1135,  423, 1615, 1125,    0,    0, 1615,
+
+      546,  588, 1121, 1108, 1615,    0, 1615,    0, 1615,    0,
+        0, 1095,    0,    0, 1088, 1615,    0, 1615,    0, 1061,
+     1041,  630,    0, 1069, 1615, 1615,    0, 1615,  838, 1615,
+     1615,  837,    0, 1615, 1615, 1615, 1615,    0, 1615,  434,
+     1615,    0, 1615,    0,  821,  817,  373,  843,  376, 1615,
+      842, 1615,    0, 1615,  463,  467,  834,  471, 1615,  833,
+     1615,    0, 1615, 1615,    0,  441,  793, 1615,  673,    0,
+      805,  802,    0,  830, 1615,  795,  792, 1615,    0,    0,
+      594,  818,  817,  597,  784,  790,    0,  775,  786,    0,
+      473,  807,  478, 1615,  486,  806,  590,  776,  790,  588,
+
+      469,  703,  793,    0,    0,    0, 1615,    0,    0,    0,
+      780,  772,    0,  800,  800,  730,  788,    0,  775,  767,
+      600,  795,  602,    0,  773,  772,  764,  770,  762, 1615,
+      610,  772,  751,    0,  740,  745,    0, 1615,  765, 1615,
+      764,  740,  488,  803,  601,  817, 1615,  742,  730, 1615,
+      760,  760, 1615,  738,  726, 1615,  756,  735,  723,  733,
+      721,  714,  716,  726, 1615,  724,  602,  831,  715,  658,
+      512,  473,  454,  459,  435,  438,  422,  430,  606,  410,
+      357,  342,  338,  278,    0,    0,    0,    0,    0,    0,
+        0,    0,  614,  255,  618,  131, 1615, 1615, 1615,  156,
+
+      620,  622,  153,  625, 1615,   95, 1615,  858,  872,  886,
+      900,  914,  928,  942,  956,  970,  984,  998, 1012, 1026,
+     1040, 1054, 1062, 1075, 1081, 1094, 1108, 1122, 1136, 1150,
+     1164, 1178, 1186, 1199, 1207, 1220, 1234, 1248, 1262, 1272,
+     1280, 1293, 1307, 1321, 1335, 1349, 1363, 1371, 1384, 1398,
+     1412, 1416, 1419, 1432, 1446, 1460,  710, 1474, 1487, 1501,
+     1515,  711, 1529, 1537, 1544,  712,  743, 1557, 1571
+    } ;
+
+static const short int yy_def[470] =
+    {   0,
+      407,  407,  408,  408,  409,  410,  411,  411,  407,    9,
+      412,  412,  407,   13,  413,  413,  414,  414,  415,  415,
+      416,  416,  417,  417,  407,   25,  418,  418,  413,  413,
+      419,  419,  420,  420,  421,  421,  407,   37,  422,  422,
+       37,   37,  407,  407,  407,  407,  407,  423,  407,  407,
+      407,  424,  407,  425,  407,  407,  407,  407,  407,  407,
+      407,  407,  426,  427,  407,  407,  407,  407,  407,  407,
+      407,  428,  407,  428,  429,  430,  429,  429,  431,  407,
+      432,  407,  432,  407,  433,  433,  433,  432,  434,  407,
+      407,  434,  407,  407,  407,  435,  407,  407,  407,  407,
+
+      407,  407,  407,  407,  407,  407,  407,  427,  407,  436,
+      437,  407,  407,  407,  438,  427,  407,  439,  407,  439,
+      407,  440,  407,  441,  441,  441,  407,  407,  442,  407,
+      442,  407,  407,  407,  443,  407,  443,  407,  444,  407,
+      444,  407,  445,  407,  445,  407,  446,  447,  447,  407,
+      447,  447,  407,  448,  448,  448,  449,  407,  407,  449,
+      449,  449,  447,  407,  407,  407,  407,  423,  407,  407,
+      407,  407,  450,  451,  407,  407,  407,  452,  407,  453,
+      454,  407,  425,  407,  407,  407,  407,  455,  407,  407,
+      407,  407,  407,  456,  426,  407,  407,  457,  458,  407,
+
+      407,  407,  407,  407,  407,  459,  407,  428,  407,  429,
+      430,  430,  460,  461,  431,  407,  432,  407,  433,  433,
+      433,  407,  434,  407,  407,  407,  435,  407,  407,  407,
+      407,  407,  462,  407,  407,  407,  407,  439,  407,  440,
+      407,  440,  407,  441,  441,  441,  442,  407,  442,  407,
+      407,  407,  443,  407,  463,  444,  407,  444,  407,  407,
+      407,  445,  407,  407,  447,  447,  447,  407,  407,  448,
+      448,  448,  449,  407,  407,  449,  449,  407,  450,  451,
+      407,  407,  407,  407,  407,  407,  464,  407,  407,  465,
+      454,  407,  454,  407,  455,  407,  455,  407,  456,  456,
+
+      456,  456,  407,  466,  458,  201,  407,  459,  460,  461,
+      433,  433,  222,  407,  222,  222,  407,  467,  441,  441,
+      463,  407,  463,  269,  269,  448,  448,  449,  449,  407,
+      407,  407,  407,  464,  407,  407,  465,  407,  407,  407,
+      407,  407,  456,  456,  456,  456,  407,  433,  433,  407,
+      407,  316,  407,  441,  441,  407,  407,  448,  448,  449,
+      449,  407,  407,  407,  407,  407,  456,  456,  456,  456,
+      433,  433,  441,  441,  448,  448,  449,  449,  468,  407,
+      407,  407,  456,  456,  433,  433,  441,  441,  448,  448,
+      449,  449,  468,  407,  468,  407,  407,  407,  407,  407,
+
+      469,  469,  407,  469,  407,  407,    0,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407
+    } ;
+
+static const short int yy_nxt[1659] =
+    {   0,
+       44,   45,   46,   47,   44,   44,   44,   44,   44,   44,
+       44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       44,   44,   44,   44,   49,   50,   51,   44,   44,   52,
+       44,   44,   44,   44,   44,   53,   44,   44,   44,   44,
+       44,   44,   44,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   54,   44,   44,   44,   56,   57,   58,   59,
+       60,   73,   74,   61,   61,  130,  131,   61,  405,   62,
+
+       44,   63,   64,   76,   73,   77,  130,  131,   78,   90,
+       91,   92,   90,   91,   92,  110,  206,  111,  105,  106,
+      107,  105,  106,  107,   44,   65,   61,   66,   67,   68,
+       59,   60,   69,  108,   61,   61,  108,  235,   61,  110,
+       70,  111,   63,   64,  235,   71,  113,  114,  113,  114,
+      207,  136,  137,  136,  137,  115,  405,  115,  138,  399,
+      138,  116,  117,  116,  117,  401,   65,   61,   81,   81,
+       82,   83,   81,   81,   81,   81,   81,   84,   81,   81,
+       81,   81,   81,   81,   81,   81,   81,   81,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+
+       85,   85,   86,   85,   85,   85,   85,   87,   81,   81,
+       81,   93,   93,   44,   93,   93,   93,   93,   93,   93,
+       94,   94,   93,   93,   93,   93,   95,   93,   93,   93,
+       93,   96,   96,   96,   96,   96,   96,   96,   96,   96,
+       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
+       96,   93,   93,   93,   99,  100,   99,  100,  399,  140,
+      141,  213,  101,  214,  101,  102,  142,  102,  140,  141,
+      144,  145,  146,  248,  249,  142,  144,  145,  146,  164,
+      165,  166,  169,  170,  171,  147,  190,  191,  192,  251,
+      249,  147,  257,  258,  103,  300,  103,  118,  118,  119,
+
+      120,  121,  118,  118,  122,  118,  118,  118,  118,  123,
+      118,  118,  118,  118,  118,  118,  118,  124,  124,  124,
+      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
+      124,  125,  124,  124,  124,  124,  126,  127,  118,  128,
+      132,  133,  132,  133,  197,  197,  232,  197,  241,  260,
+      258,  266,  164,  165,  166,  300,  267,  398,  242,  169,
+      170,  171,  281,  282,  283,  292,  293,  296,  297,  198,
+      198,  233,  198,  288,  284,  248,  249,  289,  251,  249,
+      134,  397,  134,  148,  149,  150,  151,  148,  148,  152,
+      148,  148,  153,  148,  148,  148,  148,  148,  148,  148,
+
+      148,  148,  148,  154,  154,  154,  154,  154,  154,  154,
+      154,  154,  154,  154,  154,  154,  154,  155,  154,  154,
+      154,  154,  156,  148,  148,  148,  158,  159,  160,  158,
+      159,  160,  184,  185,  186,  396,  301,  187,  202,  203,
+      204,  241,  266,  187,  281,  282,  283,  267,  281,  282,
+      283,  242,  184,  185,  186,  392,  284,  187,  391,  161,
+      284,  302,  161,  390,  162,  322,  323,  162,  174,  257,
+      258,  389,  188,  260,  258,  292,  293,  285,  188,  286,
+      339,  293,  345,  175,  388,  176,  300,  176,  296,  297,
+      387,  176,  188,  176,  176,  177,  176,  178,  386,  179,
+
+      180,  367,  181,  199,  199,  300,  199,  199,  199,  199,
+      199,  199,  199,  199,  199,  199,  200,  199,  199,  199,
+      199,  199,  199,  201,  201,  201,  201,  201,  201,  201,
+      201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
+      201,  201,  201,  199,  199,  199,  305,  305,  385,  305,
+      305,  305,  305,  305,  305,  305,  305,  306,  305,  306,
+      305,  305,  305,  305,  305,  305,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  305,  305,  307,  202,
+      203,  204,  341,  297,  187,  281,  282,  283,  331,  282,
+
+      283,  343,  322,  323,  357,  323,  299,  284,  394,  395,
+      284,  331,  282,  283,  369,  383,  394,  395,  300,  300,
+      400,  395,  403,  404,  403,  404,  344,  406,  404,  188,
+      313,  313,  314,  315,  313,  313,  313,  313,  313,  316,
+      313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
+      316,  316,  316,  316,  316,  316,  316,  316,  316,  316,
+      316,  316,  316,  316,  316,  316,  316,  316,  316,  316,
+      313,  313,  313,  324,  324,  300,  324,  324,  324,  324,
+      324,  324,  325,  324,  324,  324,  324,  324,  324,  324,
+      324,  324,  324,  325,  325,  325,  325,  325,  325,  325,
+
+      325,  325,  325,  325,  325,  325,  325,  325,  325,  325,
+      325,  325,  325,  324,  324,  324,  346,  304,  318,  347,
+      300,  304,  318,  347,  346,  346,  346,  346,  346,  346,
+      316,  316,  300,  352,  316,  316,  316,  316,  316,  382,
+      316,  316,  316,  316,  316,  316,  316,  316,  316,  316,
+      353,  381,  380,  379,  353,  378,  377,  376,  375,  356,
+      374,  373,  351,  350,  372,  371,  366,  340,  338,  365,
+      316,  316,  316,  325,  325,  364,  325,  325,  325,  325,
+      325,  325,  363,  325,  325,  325,  325,  325,  325,  325,
+      325,  325,  325,  362,  361,  360,  359,  358,  356,  355,
+
+      354,  231,  351,  350,  349,  348,  196,  300,  342,  340,
+      338,  336,  335,  325,  325,  325,  368,  333,  332,  330,
+      300,  330,  329,  328,  368,  368,  368,  368,  368,  368,
+      370,  274,  327,  326,  300,  269,  259,  259,  370,  370,
+      370,  370,  370,  370,  384,  250,  250,  320,  300,  319,
+      317,  229,  384,  384,  384,  384,  384,  384,   55,   55,
+       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
+       55,   55,   72,   72,   72,   72,   72,   72,   72,   72,
+       72,   72,   72,   72,   72,   72,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+
+       79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
+       79,   79,   79,   79,   89,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   89,   89,   89,   89,   44,   44,
+       44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
+       44,   44,   98,   98,   98,   98,   98,   98,   98,   98,
+       98,   98,   98,   98,   98,   98,  104,  104,  104,  104,
+      104,  104,  104,  104,  104,  104,  104,  104,  104,  104,
+      109,  109,  109,  109,  109,  109,  109,  109,  109,  109,
+      109,  109,  109,  109,  112,  112,  112,  112,  112,  112,
+      112,  112,  112,  112,  112,  112,  112,  112,  129,  129,
+
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  135,  135,  135,  135,  135,  135,  135,  135,
+      135,  135,  135,  135,  135,  135,  139,  139,  139,  139,
+      139,  139,  139,  139,  139,  139,  139,  139,  139,  139,
+      143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+      143,  143,  143,  143,  157,  157,  157,  157,  157,  157,
+      157,  157,  157,  157,  157,  157,  157,  157,  168,  168,
+      224,  312,  168,  168,  168,  173,  173,  173,  173,  173,
+      173,  173,  173,  173,  173,  173,  173,  183,  183,  311,
+      216,  183,  183,  183,  194,  194,  212,  194,  194,  194,
+
+      194,  194,  194,  194,  194,  194,  194,  194,  196,  196,
+      205,  196,  196,  196,  196,  196,  196,  196,  196,  196,
+      196,  196,  208,  208,  205,  208,  208,  208,  208,  208,
+      208,  208,  208,  208,  208,  208,  210,  210,  303,  210,
+      210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
+      211,  211,  300,  211,  211,  211,  211,  211,  211,  211,
+      211,  211,  211,  211,  215,  215,  215,  215,  215,  215,
+      215,  215,  215,  215,  215,  215,  215,  215,  217,  217,
+      298,  217,  217,  190,  217,  217,  217,  217,  190,  294,
+      189,  217,  219,  219,  189,  172,  219,  219,  219,  223,
+
+      223,  172,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  227,  227,  167,  167,  227,  227,  227,
+      231,  231,  278,  231,  231,  231,  231,  231,  231,  231,
+      231,  231,  231,  231,  234,  234,  277,  234,  234,  234,
+      234,  234,  234,  234,  234,  234,  234,  234,  237,  237,
+      276,  237,  237,  237,  237,  237,  237,  275,  237,  237,
+      237,  237,  238,  238,  275,  274,  272,  238,  238,  238,
+      238,  238,  240,  240,  271,  240,  240,  240,  240,  240,
+      240,  240,  240,  240,  240,  240,  244,  244,  269,  268,
+      244,  244,  244,  247,  247,  247,  247,  247,  247,  247,
+
+      247,  247,  247,  247,  247,  247,  247,  253,  253,  268,
+      253,  253,  263,  253,  253,  253,  253,  253,  253,  253,
+      253,  256,  256,  256,  256,  256,  263,  256,  256,  256,
+      256,  256,  256,  256,  256,  262,  262,  261,  259,  262,
+      262,  262,  262,  255,  262,  262,  262,  262,  262,  264,
+      264,  254,  264,  264,  264,  264,  264,  264,  264,  264,
+      264,  264,  264,  265,  265,  254,  265,  265,  252,  265,
+      265,  265,  265,  252,  250,  246,  265,  270,  270,  245,
+      243,  270,  270,  270,  273,  239,  239,  273,  273,  273,
+      273,  273,  273,  273,  273,  273,  273,  273,  279,  279,
+
+      236,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+      279,  279,  280,  280,  236,  280,  280,  280,  280,  280,
+      280,  280,  280,  280,  280,  280,  287,  287,  287,  290,
+      290,  290,  291,  291,  291,  291,  291,  291,  291,  291,
+      291,  291,  291,  291,  291,  291,  295,  295,  295,  295,
+      295,  295,  295,  295,  295,  295,  295,  295,  295,  295,
+      299,  299,  230,  299,  299,  299,  299,  299,  299,  230,
+      299,  299,  299,  299,  305,  305,  229,  305,  305,  305,
+      305,  305,  305,  305,  305,  305,  305,  308,  308,  228,
+      308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
+
+      308,  309,  309,  228,  309,  309,  309,  309,  309,  309,
+      309,  309,  309,  309,  309,  310,  310,  226,  310,  310,
+      310,  310,  310,  310,  310,  310,  310,  310,  310,  321,
+      321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
+      321,  321,  321,  334,  334,  225,  225,  334,  334,  334,
+      337,  337,  224,  222,  337,  337,  337,  393,  393,  393,
+      393,  393,  393,  393,  393,  393,  393,  393,  393,  393,
+      393,  402,  402,  402,  402,  402,  402,  402,  402,  402,
+      402,  402,  402,  402,  402,  221,  220,  218,  218,  216,
+      209,  212,  209,  209,  193,  205,  205,  195,  193,  189,
+
+      189,  182,  172,  172,  167,  167,  407,  163,  163,   97,
+       97,   88,   80,   80,   43,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407
+    } ;
+
+static const short int yy_chk[1659] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2,    2,    3,    3,    3,    3,
+        3,    5,    5,    3,    3,   27,   27,    3,  406,    3,
+
+       21,    3,    3,    6,    6,    6,   28,   28,    6,   11,
+       11,   11,   12,   12,   12,   21,   69,   21,   19,   19,
+       19,   20,   20,   20,   22,    3,    3,    4,    4,    4,
+        4,    4,    4,   19,    4,    4,   20,  111,    4,   22,
+        4,   22,    4,    4,  111,    4,   23,   23,   24,   24,
+       69,   31,   31,   32,   32,   23,  403,   24,   31,  400,
+       32,   23,   23,   24,   24,  396,    4,    4,    9,    9,
+        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
+        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
+        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
+
+        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
+        9,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   17,   17,   18,   18,  394,   33,
+       33,   78,   17,   78,   18,   17,   33,   18,   34,   34,
+       35,   35,   35,  129,  129,   34,   36,   36,   36,   45,
+       45,   45,   49,   49,   49,   35,   60,   60,   60,  131,
+      131,   36,  139,  139,   17,  384,   18,   25,   25,   25,
+
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       29,   29,   30,   30,   64,  108,  110,  116,  122,  141,
+      141,  149,  164,  164,  164,  383,  149,  382,  122,  169,
+      169,  169,  176,  176,  176,  181,  181,  188,  188,   64,
+      108,  110,  116,  179,  176,  247,  247,  179,  249,  249,
+       29,  381,   30,   37,   37,   37,   37,   37,   37,   37,
+       37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
+
+       37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
+       37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
+       37,   37,   37,   37,   37,   37,   39,   39,   39,   40,
+       40,   40,   56,   56,   56,  380,  195,   56,   66,   66,
+       66,  240,  266,   66,  175,  175,  175,  266,  177,  177,
+      177,  240,  184,  184,  184,  378,  175,  184,  377,   39,
+      177,  195,   40,  376,   39,  255,  255,   40,   52,  256,
+      256,  375,   56,  258,  258,  291,  291,  175,   66,  177,
+      293,  293,  301,   52,  374,   52,  301,   52,  295,  295,
+      373,   52,  184,   52,   52,   52,   52,   52,  372,   52,
+
+       52,  343,   52,   65,   65,  343,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,  201,  201,  371,  201,
+      201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
+      201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
+      201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
+      201,  201,  201,  201,  201,  201,  201,  201,  201,  202,
+      202,  202,  297,  297,  202,  281,  281,  281,  284,  284,
+
+      284,  300,  321,  321,  323,  323,  300,  281,  379,  379,
+      284,  331,  331,  331,  345,  367,  393,  393,  345,  367,
+      395,  395,  401,  401,  402,  402,  300,  404,  404,  202,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  269,  269,  370,  269,  269,  269,  269,
+      269,  269,  269,  269,  269,  269,  269,  269,  269,  269,
+      269,  269,  269,  269,  269,  269,  269,  269,  269,  269,
+
+      269,  269,  269,  269,  269,  269,  269,  269,  269,  269,
+      269,  269,  269,  269,  269,  269,  302,  457,  462,  466,
+      302,  457,  462,  466,  302,  302,  302,  302,  302,  302,
+      316,  316,  369,  316,  316,  316,  316,  316,  316,  366,
+      316,  316,  316,  316,  316,  316,  316,  316,  316,  316,
+      467,  364,  363,  362,  467,  361,  360,  359,  358,  357,
+      355,  354,  352,  351,  349,  348,  342,  341,  339,  336,
+      316,  316,  316,  325,  325,  335,  325,  325,  325,  325,
+      325,  325,  333,  325,  325,  325,  325,  325,  325,  325,
+      325,  325,  325,  332,  329,  328,  327,  326,  322,  320,
+
+      319,  317,  315,  314,  312,  311,  303,  299,  298,  296,
+      292,  289,  288,  325,  325,  325,  344,  286,  285,  283,
+      344,  282,  277,  276,  344,  344,  344,  344,  344,  344,
+      346,  274,  272,  271,  346,  267,  260,  257,  346,  346,
+      346,  346,  346,  346,  368,  251,  248,  246,  368,  245,
+      232,  229,  368,  368,  368,  368,  368,  368,  408,  408,
+      408,  408,  408,  408,  408,  408,  408,  408,  408,  408,
+      408,  408,  409,  409,  409,  409,  409,  409,  409,  409,
+      409,  409,  409,  409,  409,  409,  410,  410,  410,  410,
+      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
+
+      411,  411,  411,  411,  411,  411,  411,  411,  411,  411,
+      411,  411,  411,  411,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  413,  413,
+      413,  413,  413,  413,  413,  413,  413,  413,  413,  413,
+      413,  413,  414,  414,  414,  414,  414,  414,  414,  414,
+      414,  414,  414,  414,  414,  414,  415,  415,  415,  415,
+      415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
+      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
+      416,  416,  416,  416,  417,  417,  417,  417,  417,  417,
+      417,  417,  417,  417,  417,  417,  417,  417,  418,  418,
+
+      418,  418,  418,  418,  418,  418,  418,  418,  418,  418,
+      418,  418,  419,  419,  419,  419,  419,  419,  419,  419,
+      419,  419,  419,  419,  419,  419,  420,  420,  420,  420,
+      420,  420,  420,  420,  420,  420,  420,  420,  420,  420,
+      421,  421,  421,  421,  421,  421,  421,  421,  421,  421,
+      421,  421,  421,  421,  422,  422,  422,  422,  422,  422,
+      422,  422,  422,  422,  422,  422,  422,  422,  423,  423,
+      224,  221,  423,  423,  423,  424,  424,  424,  424,  424,
+      424,  424,  424,  424,  424,  424,  424,  425,  425,  220,
+      215,  425,  425,  425,  426,  426,  212,  426,  426,  426,
+
+      426,  426,  426,  426,  426,  426,  426,  426,  427,  427,
+      204,  427,  427,  427,  427,  427,  427,  427,  427,  427,
+      427,  427,  428,  428,  203,  428,  428,  428,  428,  428,
+      428,  428,  428,  428,  428,  428,  429,  429,  197,  429,
+      429,  429,  429,  429,  429,  429,  429,  429,  429,  429,
+      430,  430,  194,  430,  430,  430,  430,  430,  430,  430,
+      430,  430,  430,  430,  431,  431,  431,  431,  431,  431,
+      431,  431,  431,  431,  431,  431,  431,  431,  432,  432,
+      193,  432,  432,  192,  432,  432,  432,  432,  191,  187,
+      186,  432,  433,  433,  185,  171,  433,  433,  433,  434,
+
+      434,  170,  434,  434,  434,  434,  434,  434,  434,  434,
+      434,  434,  434,  435,  435,  166,  165,  435,  435,  435,
+      436,  436,  163,  436,  436,  436,  436,  436,  436,  436,
+      436,  436,  436,  436,  437,  437,  162,  437,  437,  437,
+      437,  437,  437,  437,  437,  437,  437,  437,  438,  438,
+      161,  438,  438,  438,  438,  438,  438,  160,  438,  438,
+      438,  438,  439,  439,  159,  158,  156,  439,  439,  439,
+      439,  439,  440,  440,  155,  440,  440,  440,  440,  440,
+      440,  440,  440,  440,  440,  440,  441,  441,  152,  151,
+      441,  441,  441,  442,  442,  442,  442,  442,  442,  442,
+
+      442,  442,  442,  442,  442,  442,  442,  443,  443,  150,
+      443,  443,  145,  443,  443,  443,  443,  443,  443,  443,
+      443,  444,  444,  444,  444,  444,  144,  444,  444,  444,
+      444,  444,  444,  444,  444,  445,  445,  142,  140,  445,
+      445,  445,  445,  138,  445,  445,  445,  445,  445,  446,
+      446,  137,  446,  446,  446,  446,  446,  446,  446,  446,
+      446,  446,  446,  447,  447,  136,  447,  447,  133,  447,
+      447,  447,  447,  132,  130,  126,  447,  448,  448,  125,
+      123,  448,  448,  448,  449,  120,  119,  449,  449,  449,
+      449,  449,  449,  449,  449,  449,  449,  449,  450,  450,
+
+      114,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  451,  451,  113,  451,  451,  451,  451,  451,
+      451,  451,  451,  451,  451,  451,  452,  452,  452,  453,
+      453,  453,  454,  454,  454,  454,  454,  454,  454,  454,
+      454,  454,  454,  454,  454,  454,  455,  455,  455,  455,
+      455,  455,  455,  455,  455,  455,  455,  455,  455,  455,
+      456,  456,  106,  456,  456,  456,  456,  456,  456,  105,
+      456,  456,  456,  456,  458,  458,  102,  458,  458,  458,
+      458,  458,  458,  458,  458,  458,  458,  459,  459,  100,
+      459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
+
+      459,  460,  460,   99,  460,  460,  460,  460,  460,  460,
+      460,  460,  460,  460,  460,  461,  461,   95,  461,  461,
+      461,  461,  461,  461,  461,  461,  461,  461,  461,  463,
+      463,  463,  463,  463,  463,  463,  463,  463,  463,  463,
+      463,  463,  463,  464,  464,   92,   91,  464,  464,  464,
+      465,  465,   90,   88,  465,  465,  465,  468,  468,  468,
+      468,  468,  468,  468,  468,  468,  468,  468,  468,  468,
+      468,  469,  469,  469,  469,  469,  469,  469,  469,  469,
+      469,  469,  469,  469,  469,   87,   86,   83,   82,   79,
+       77,   76,   74,   73,   70,   68,   67,   63,   62,   58,
+
+       57,   53,   51,   50,   47,   46,   43,   42,   41,   16,
+       15,   10,    8,    7,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
+      407,  407,  407,  407,  407,  407,  407,  407
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+char *yytext;
+# line 1 "scan.l"
+/* scan.l - scanner for flex input */
+# line 4 "scan.l"
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: scan.l,v 1.2 94/01/04 14:33:09 vern Exp $ */
+
+#include "flexdef.h"
+#include "parse.h"
+
+#define ACTION_ECHO add_action( yytext )
+#define MARK_END_OF_PROLOG mark_prolog();
+
+#define YY_DECL \
+	int flexscan()
+
+#define RETURNCHAR \
+	yylval = (unsigned char) yytext[0]; \
+	return CHAR;
+
+#define RETURNNAME \
+	strcpy( nmstr, yytext ); \
+	return NAME;
+
+#define PUT_BACK_STRING(str, start) \
+	for ( i = strlen( str ) - 1; i >= start; --i ) \
+		unput((str)[i])
+
+#define CHECK_REJECT(str) \
+	if ( all_upper( str ) ) \
+		reject = true;
+
+#define CHECK_YYMORE(str) \
+	if ( all_lower( str ) ) \
+		yymore_used = true;
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( yy_current_buffer->yy_is_interactive ) \
+		{ \
+		int c = getc( yyin ); \
+		result = c == EOF ? 0 : 1; \
+		buf[0] = (char) c; \
+		} \
+	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+		  && ferror( yyin ) ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+
+# line 82 "scan.l"
+
+	static int bracelevel, didadef, indented_code, checking_used;
+
+	int doing_codeblock = false;
+	int i;
+	Char nmdef[MAXLINE], myesc();
+
+
+
+	if ( yy_init )
+		{
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( yy_current_buffer )
+			yy_init_buffer( yy_current_buffer, yyin );
+		else
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+
+		yy_load_buffer_state();
+
+		yy_init = 0;
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yy_start;
+		if ( yy_bp[-1] == '\n' )
+			++yy_current_state;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yy_last_accepting_state = yy_current_state;
+				yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 408 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 1615 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+
+		YY_DO_BEFORE_ACTION;
+
+
+do_action:	/* This label is used only to access EOF actions. */
+
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yy_hold_char;
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_USER_ACTION
+# line 90 "scan.l"
+indented_code = true; BEGIN(CODEBLOCK);
+	YY_BREAK
+case 2:
+YY_USER_ACTION
+# line 91 "scan.l"
+ACTION_ECHO; BEGIN(C_COMMENT);
+	YY_BREAK
+case 3:
+YY_USER_ACTION
+# line 92 "scan.l"
+return SCDECL;
+	YY_BREAK
+case 4:
+YY_USER_ACTION
+# line 93 "scan.l"
+return XSCDECL;
+	YY_BREAK
+case 5:
+YY_USER_ACTION
+# line 94 "scan.l"
+{
+			++linenum;
+			line_directive_out( (FILE *) 0 );
+			indented_code = false;
+			BEGIN(CODEBLOCK);
+			}
+	YY_BREAK
+case 6:
+YY_USER_ACTION
+# line 101 "scan.l"
+return WHITESPACE;
+	YY_BREAK
+case 7:
+YY_USER_ACTION
+# line 103 "scan.l"
+{
+			sectnum = 2;
+			bracelevel = 0;
+			mark_defs1();
+			line_directive_out( (FILE *) 0 );
+			BEGIN(SECT2PROLOG);
+			return SECTEND;
+			}
+	YY_BREAK
+case 8:
+YY_USER_ACTION
+# line 112 "scan.l"
+{
+			if ( lex_compat )
+				warn( "%pointer incompatible with -l option" );
+			else
+				yytext_is_array = false;
+			++linenum;
+			}
+	YY_BREAK
+case 9:
+YY_USER_ACTION
+# line 119 "scan.l"
+{
+			if ( C_plus_plus )
+				warn( "%array incompatible with -+ option" );
+			else
+				yytext_is_array = true;
+			++linenum;
+			}
+	YY_BREAK
+case 10:
+YY_USER_ACTION
+# line 127 "scan.l"
+{
+			warn( "%used/%unused have been deprecated" );
+			checking_used = REALLY_USED; BEGIN(USED_LIST);
+			}
+	YY_BREAK
+case 11:
+YY_USER_ACTION
+# line 131 "scan.l"
+{
+			warn( "%used/%unused have been deprecated" );
+			checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
+			}
+	YY_BREAK
+case 12:
+YY_USER_ACTION
+# line 137 "scan.l"
+++linenum;	/* ignore */
+	YY_BREAK
+case 13:
+YY_USER_ACTION
+# line 139 "scan.l"
+synerr( "unrecognized '%' directive" );
+	YY_BREAK
+case 14:
+YY_USER_ACTION
+# line 141 "scan.l"
+{
+			strcpy( nmstr, yytext );
+			didadef = false;
+			BEGIN(PICKUPDEF);
+			}
+	YY_BREAK
+case 15:
+YY_USER_ACTION
+# line 147 "scan.l"
+RETURNNAME;
+	YY_BREAK
+case 16:
+YY_USER_ACTION
+# line 148 "scan.l"
+++linenum; /* allows blank lines in section 1 */
+	YY_BREAK
+case 17:
+YY_USER_ACTION
+# line 149 "scan.l"
+++linenum; return '\n';
+	YY_BREAK
+case 18:
+YY_USER_ACTION
+# line 152 "scan.l"
+ACTION_ECHO; BEGIN(INITIAL);
+	YY_BREAK
+case 19:
+YY_USER_ACTION
+# line 153 "scan.l"
+++linenum; ACTION_ECHO; BEGIN(INITIAL);
+	YY_BREAK
+case 20:
+YY_USER_ACTION
+# line 154 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 21:
+YY_USER_ACTION
+# line 155 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 22:
+YY_USER_ACTION
+# line 156 "scan.l"
+++linenum; ACTION_ECHO;
+	YY_BREAK
+case 23:
+YY_USER_ACTION
+# line 159 "scan.l"
+++linenum; BEGIN(INITIAL);
+	YY_BREAK
+case 24:
+YY_USER_ACTION
+# line 160 "scan.l"
+ACTION_ECHO; CHECK_REJECT(yytext);
+	YY_BREAK
+case 25:
+YY_USER_ACTION
+# line 161 "scan.l"
+ACTION_ECHO; CHECK_YYMORE(yytext);
+	YY_BREAK
+case 26:
+YY_USER_ACTION
+# line 162 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 27:
+YY_USER_ACTION
+# line 163 "scan.l"
+{
+			++linenum;
+			ACTION_ECHO;
+			if ( indented_code )
+				BEGIN(INITIAL);
+			}
+	YY_BREAK
+case 28:
+YY_USER_ACTION
+# line 171 "scan.l"
+/* separates name and definition */
+	YY_BREAK
+case 29:
+YY_USER_ACTION
+# line 173 "scan.l"
+{
+			strcpy( (char *) nmdef, yytext );
+
+			/* Skip trailing whitespace. */
+			for ( i = strlen( (char *) nmdef ) - 1;
+			      i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
+			      --i )
+				;
+
+			nmdef[i + 1] = '\0';
+
+			ndinstal( nmstr, nmdef );
+			didadef = true;
+			}
+	YY_BREAK
+case 30:
+YY_USER_ACTION
+# line 188 "scan.l"
+{
+			if ( ! didadef )
+				synerr( "incomplete name definition" );
+			BEGIN(INITIAL);
+			++linenum;
+			}
+	YY_BREAK
+case 31:
+YY_USER_ACTION
+# line 195 "scan.l"
+++linenum; BEGIN(INITIAL); RETURNNAME;
+	YY_BREAK
+case 32:
+YY_USER_ACTION
+# line 198 "scan.l"
+++linenum; BEGIN(INITIAL);
+	YY_BREAK
+case 33:
+YY_USER_ACTION
+# line 199 "scan.l"
+
+	YY_BREAK
+case 34:
+YY_USER_ACTION
+# line 200 "scan.l"
+{
+			if ( all_upper( yytext ) )
+				reject_really_used = checking_used;
+			else
+				synerr(
+				"unrecognized %used/%unused construct" );
+			}
+	YY_BREAK
+case 35:
+YY_USER_ACTION
+# line 207 "scan.l"
+{
+			if ( all_lower( yytext ) )
+				yymore_really_used = checking_used;
+			else
+				synerr(
+				"unrecognized %used/%unused construct" );
+			}
+	YY_BREAK
+case 36:
+YY_USER_ACTION
+# line 214 "scan.l"
+synerr( "unrecognized %used/%unused construct" );
+	YY_BREAK
+case 37:
+YY_USER_ACTION
+# line 217 "scan.l"
+++bracelevel; yyless( 2 );	/* eat only %{ */
+	YY_BREAK
+case 38:
+YY_USER_ACTION
+# line 218 "scan.l"
+--bracelevel; yyless( 2 );	/* eat only %} */
+	YY_BREAK
+case 39:
+YY_USER_ACTION
+# line 220 "scan.l"
+ACTION_ECHO;	/* indented code in prolog */
+	YY_BREAK
+case 40:
+YY_USER_ACTION
+# line 222 "scan.l"
+{	/* non-indented code */
+			if ( bracelevel <= 0 )
+				{ /* not in %{ ... %} */
+				yyless( 0 );	/* put it all back */
+				mark_prolog();
+				BEGIN(SECT2);
+				}
+			else
+				ACTION_ECHO;
+			}
+	YY_BREAK
+case 41:
+YY_USER_ACTION
+# line 233 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 42:
+YY_USER_ACTION
+# line 234 "scan.l"
+++linenum; ACTION_ECHO;
+	YY_BREAK
+case YY_STATE_EOF(SECT2PROLOG):
+# line 236 "scan.l"
+{
+			mark_prolog();
+			sectnum = 0;
+			yyterminate(); /* to stop the parser */
+			}
+	YY_BREAK
+case 43:
+YY_USER_ACTION
+# line 242 "scan.l"
+++linenum; /* allow blank lines in section 2 */
+	YY_BREAK
+case 44:
+YY_USER_ACTION
+# line 244 "scan.l"
+{
+			indented_code = (yytext[0] != '%');
+			doing_codeblock = true;
+			bracelevel = 1;
+
+			if ( indented_code )
+				ACTION_ECHO;
+
+			BEGIN(CODEBLOCK_2);
+			}
+	YY_BREAK
+case 45:
+YY_USER_ACTION
+# line 255 "scan.l"
+BEGIN(SC); return '<';
+	YY_BREAK
+case 46:
+YY_USER_ACTION
+# line 256 "scan.l"
+return '^';
+	YY_BREAK
+case 47:
+YY_USER_ACTION
+# line 257 "scan.l"
+BEGIN(QUOTE); return '"';
+	YY_BREAK
+case 48:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 258 "scan.l"
+BEGIN(NUM); return '{';
+	YY_BREAK
+case 49:
+YY_USER_ACTION
+# line 259 "scan.l"
+BEGIN(BRACEERROR);
+	YY_BREAK
+case 50:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 260 "scan.l"
+return '$';
+	YY_BREAK
+case 51:
+YY_USER_ACTION
+# line 262 "scan.l"
+{
+			bracelevel = 1;
+			BEGIN(PERCENT_BRACE_ACTION);
+			return '\n';
+			}
+	YY_BREAK
+case 52:
+YY_USER_ACTION
+# line 267 "scan.l"
+continued_action = true; ++linenum; return '\n';
+	YY_BREAK
+case 53:
+YY_USER_ACTION
+# line 269 "scan.l"
+{
+			/* This rule is separate from the one below because
+			 * otherwise we get variable trailing context, so
+			 * we can't build the scanner using -{f,F}.
+			 */
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			return '\n';
+			}
+	YY_BREAK
+case 54:
+YY_USER_ACTION
+# line 280 "scan.l"
+{
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			unput( '\n' );	/* so <ACTION> sees it */
+			return '\n';
+			}
+	YY_BREAK
+case 55:
+YY_USER_ACTION
+# line 288 "scan.l"
+return EOF_OP;
+	YY_BREAK
+case 56:
+YY_USER_ACTION
+# line 290 "scan.l"
+{
+			sectnum = 3;
+			BEGIN(SECT3);
+			yyterminate(); /* to stop the parser */
+			}
+	YY_BREAK
+case 57:
+YY_USER_ACTION
+# line 296 "scan.l"
+{
+			int cclval;
+
+			strcpy( nmstr, yytext );
+
+			/* Check to see if we've already encountered this
+			 * ccl.
+			 */
+			if ( (cclval = ccllookup( (Char *) nmstr )) )
+				{
+				if ( input() != ']' )
+					synerr( "bad character class" );
+
+				yylval = cclval;
+				++cclreuse;
+				return PREVCCL;
+				}
+			else
+				{
+				/* We fudge a bit.  We know that this ccl will
+				 * soon be numbered as lastccl + 1 by cclinit.
+				 */
+				cclinstal( (Char *) nmstr, lastccl + 1 );
+
+				/* Push back everything but the leading bracket
+				 * so the ccl can be rescanned.
+				 */
+				yyless( 1 );
+
+				BEGIN(FIRSTCCL);
+				return '[';
+				}
+			}
+	YY_BREAK
+case 58:
+YY_USER_ACTION
+# line 330 "scan.l"
+{
+			register Char *nmdefptr;
+			Char *ndlookup();
+
+			strcpy( nmstr, yytext + 1 );
+			nmstr[yyleng - 2] = '\0';  /* chop trailing brace */
+
+			if ( ! (nmdefptr = ndlookup( nmstr )) )
+				format_synerr( "undefined definition {%s}",
+						nmstr );
+
+			else
+				{ /* push back name surrounded by ()'s */
+				int len = strlen( (char *) nmdefptr );
+
+				if ( lex_compat || nmdefptr[0] == '^' ||
+				     (len > 0 && nmdefptr[len - 1] == '$') )
+					{ /* don't use ()'s after all */
+					PUT_BACK_STRING((char *) nmdefptr, 0);
+
+					if ( nmdefptr[0] == '^' )
+						BEGIN(CARETISBOL);
+					}
+
+				else
+					{
+					unput(')');
+					PUT_BACK_STRING((char *) nmdefptr, 0);
+					unput('(');
+					}
+				}
+			}
+	YY_BREAK
+case 59:
+YY_USER_ACTION
+# line 363 "scan.l"
+return (unsigned char) yytext[0];
+	YY_BREAK
+case 60:
+YY_USER_ACTION
+# line 364 "scan.l"
+RETURNCHAR;
+	YY_BREAK
+case 61:
+YY_USER_ACTION
+# line 367 "scan.l"
+return (unsigned char) yytext[0];
+	YY_BREAK
+case 62:
+YY_USER_ACTION
+# line 368 "scan.l"
+BEGIN(SECT2); return '>';
+	YY_BREAK
+case 63:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 369 "scan.l"
+BEGIN(CARETISBOL); return '>';
+	YY_BREAK
+case 64:
+YY_USER_ACTION
+# line 370 "scan.l"
+RETURNNAME;
+	YY_BREAK
+case 65:
+YY_USER_ACTION
+# line 371 "scan.l"
+{
+			format_synerr( "bad <start condition>: %s", yytext );
+			}
+	YY_BREAK
+case 66:
+YY_USER_ACTION
+# line 375 "scan.l"
+BEGIN(SECT2); return '^';
+	YY_BREAK
+case 67:
+YY_USER_ACTION
+# line 378 "scan.l"
+RETURNCHAR;
+	YY_BREAK
+case 68:
+YY_USER_ACTION
+# line 379 "scan.l"
+BEGIN(SECT2); return '"';
+	YY_BREAK
+case 69:
+YY_USER_ACTION
+# line 381 "scan.l"
+{
+			synerr( "missing quote" );
+			BEGIN(SECT2);
+			++linenum;
+			return '"';
+			}
+	YY_BREAK
+case 70:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 389 "scan.l"
+BEGIN(CCL); return '^';
+	YY_BREAK
+case 71:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 390 "scan.l"
+return '^';
+	YY_BREAK
+case 72:
+YY_USER_ACTION
+# line 391 "scan.l"
+BEGIN(CCL); RETURNCHAR;
+	YY_BREAK
+case 73:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_USER_ACTION
+# line 393 "scan.l"
+return '-';
+	YY_BREAK
+case 74:
+YY_USER_ACTION
+# line 394 "scan.l"
+RETURNCHAR;
+	YY_BREAK
+case 75:
+YY_USER_ACTION
+# line 395 "scan.l"
+BEGIN(SECT2); return ']';
+	YY_BREAK
+case 76:
+YY_USER_ACTION
+# line 396 "scan.l"
+{
+			synerr( "bad character class" );
+			BEGIN(SECT2);
+			return ']';
+			}
+	YY_BREAK
+case 77:
+YY_USER_ACTION
+# line 403 "scan.l"
+{
+			yylval = myctoi( yytext );
+			return NUMBER;
+			}
+	YY_BREAK
+case 78:
+YY_USER_ACTION
+# line 408 "scan.l"
+return ',';
+	YY_BREAK
+case 79:
+YY_USER_ACTION
+# line 409 "scan.l"
+BEGIN(SECT2); return '}';
+	YY_BREAK
+case 80:
+YY_USER_ACTION
+# line 411 "scan.l"
+{
+			synerr( "bad character inside {}'s" );
+			BEGIN(SECT2);
+			return '}';
+			}
+	YY_BREAK
+case 81:
+YY_USER_ACTION
+# line 417 "scan.l"
+{
+			synerr( "missing }" );
+			BEGIN(SECT2);
+			++linenum;
+			return '}';
+			}
+	YY_BREAK
+case 82:
+YY_USER_ACTION
+# line 425 "scan.l"
+synerr( "bad name in {}'s" ); BEGIN(SECT2);
+	YY_BREAK
+case 83:
+YY_USER_ACTION
+# line 426 "scan.l"
+synerr( "missing }" ); ++linenum; BEGIN(SECT2);
+	YY_BREAK
+case 84:
+YY_USER_ACTION
+# line 429 "scan.l"
+ACTION_ECHO; BEGIN(ACTION_COMMENT);
+	YY_BREAK
+case 85:
+YY_USER_ACTION
+# line 430 "scan.l"
+bracelevel = 0;
+	YY_BREAK
+case 86:
+YY_USER_ACTION
+# line 431 "scan.l"
+{
+			ACTION_ECHO;
+			CHECK_REJECT(yytext);
+			}
+	YY_BREAK
+case 87:
+YY_USER_ACTION
+# line 435 "scan.l"
+{
+			ACTION_ECHO;
+			CHECK_YYMORE(yytext);
+			}
+	YY_BREAK
+case 88:
+YY_USER_ACTION
+# line 439 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 89:
+YY_USER_ACTION
+# line 440 "scan.l"
+{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 ||
+			     (doing_codeblock && indented_code) )
+				{
+				if ( ! doing_codeblock )
+					add_action( "\tYY_BREAK\n" );
+				
+				doing_codeblock = false;
+				BEGIN(SECT2);
+				}
+			}
+	YY_BREAK
+	/* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
+case 90:
+YY_USER_ACTION
+# line 456 "scan.l"
+ACTION_ECHO; ++bracelevel;
+	YY_BREAK
+case 91:
+YY_USER_ACTION
+# line 457 "scan.l"
+ACTION_ECHO; --bracelevel;
+	YY_BREAK
+case 92:
+YY_USER_ACTION
+# line 458 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 93:
+YY_USER_ACTION
+# line 459 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 94:
+YY_USER_ACTION
+# line 460 "scan.l"
+ACTION_ECHO; BEGIN(ACTION_COMMENT);
+	YY_BREAK
+case 95:
+YY_USER_ACTION
+# line 461 "scan.l"
+ACTION_ECHO; /* character constant */
+	YY_BREAK
+case 96:
+YY_USER_ACTION
+# line 462 "scan.l"
+ACTION_ECHO; BEGIN(ACTION_STRING);
+	YY_BREAK
+case 97:
+YY_USER_ACTION
+# line 463 "scan.l"
+{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 )
+				{
+				add_action( "\tYY_BREAK\n" );
+				BEGIN(SECT2);
+				}
+			}
+	YY_BREAK
+case 98:
+YY_USER_ACTION
+# line 472 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 99:
+YY_USER_ACTION
+# line 474 "scan.l"
+{
+			ACTION_ECHO;
+			if ( doing_codeblock )
+				BEGIN(CODEBLOCK_2);
+			else
+				BEGIN(ACTION);
+			}
+	YY_BREAK
+case 100:
+YY_USER_ACTION
+# line 482 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 101:
+YY_USER_ACTION
+# line 483 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 102:
+YY_USER_ACTION
+# line 484 "scan.l"
+++linenum; ACTION_ECHO;
+	YY_BREAK
+case 103:
+YY_USER_ACTION
+# line 486 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 104:
+YY_USER_ACTION
+# line 487 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 105:
+YY_USER_ACTION
+# line 488 "scan.l"
+++linenum; ACTION_ECHO;
+	YY_BREAK
+case 106:
+YY_USER_ACTION
+# line 489 "scan.l"
+ACTION_ECHO; BEGIN(ACTION);
+	YY_BREAK
+case 107:
+YY_USER_ACTION
+# line 490 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case YY_STATE_EOF(ACTION):
+case YY_STATE_EOF(ACTION_COMMENT):
+case YY_STATE_EOF(ACTION_STRING):
+# line 492 "scan.l"
+{
+			synerr( "EOF encountered inside an action" );
+			yyterminate();
+			}
+	YY_BREAK
+case 108:
+YY_USER_ACTION
+# line 498 "scan.l"
+{
+			yylval = myesc( (Char *) yytext );
+			return CHAR;
+			}
+	YY_BREAK
+case 109:
+YY_USER_ACTION
+# line 503 "scan.l"
+{
+			yylval = myesc( (Char *) yytext );
+			BEGIN(CCL);
+			return CHAR;
+			}
+	YY_BREAK
+case 110:
+YY_USER_ACTION
+# line 510 "scan.l"
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(SECT3):
+# line 511 "scan.l"
+sectnum = 0; yyterminate();
+	YY_BREAK
+case 111:
+YY_USER_ACTION
+# line 513 "scan.l"
+format_synerr( "bad character: %s", yytext );
+	YY_BREAK
+case 112:
+YY_USER_ACTION
+# line 515 "scan.l"
+YY_FATAL_ERROR( "flex scanner jammed" );
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(SECT2):
+case YY_STATE_EOF(CODEBLOCK):
+case YY_STATE_EOF(PICKUPDEF):
+case YY_STATE_EOF(SC):
+case YY_STATE_EOF(CARETISBOL):
+case YY_STATE_EOF(NUM):
+case YY_STATE_EOF(QUOTE):
+case YY_STATE_EOF(FIRSTCCL):
+case YY_STATE_EOF(CCL):
+case YY_STATE_EOF(RECOVER):
+case YY_STATE_EOF(BRACEERROR):
+case YY_STATE_EOF(C_COMMENT):
+case YY_STATE_EOF(PERCENT_BRACE_ACTION):
+case YY_STATE_EOF(USED_LIST):
+case YY_STATE_EOF(CODEBLOCK_2):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yy_hold_char;
+
+		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between yy_current_buffer and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+							yy_cp = yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap() )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr - 1; /* copy prev. char, too */
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a singled characater, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = yy_c_buf_p - yytext_ptr;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		yy_n_chars = 0;
+
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
+
+			int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
+
+			b->yy_buf_size *= 2;
+			b->yy_ch_buf = (char *)
+				yy_flex_realloc( (void *) b->yy_ch_buf,
+						 b->yy_buf_size );
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
+#endif
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+		}
+
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move - YY_MORE_ADJ == 1 )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	/* yytext begins at the second character in yy_ch_buf; the first
+	 * character is the one which preceded it before reading in the latest
+	 * buffer; it needs to be kept around in case it's a newline, so
+	 * yy_get_previous_state() will have with '^' rules active.
+	 */
+
+	yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
+
+	return ret_val;
+	}
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+
+	register char *yy_bp = yytext_ptr;
+
+	yy_current_state = yy_start;
+	if ( yy_bp[-1] == '\n' )
+		++yy_current_state;
+
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yy_last_accepting_state = yy_current_state;
+			yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 408 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
+
+	return yy_current_state;
+	}
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+	{
+	register int yy_is_jam;
+	register char *yy_cp = yy_c_buf_p;
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yy_last_accepting_state = yy_current_state;
+		yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 408 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 407);
+
+	return yy_is_jam ? 0 : yy_current_state;
+	}
+
+
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+	{
+	register char *yy_cp = yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
+
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += dest - source;
+		yy_bp += dest - source;
+		yy_n_chars = yy_current_buffer->yy_buf_size;
+
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
+		yy_cp[-2] = '\n';
+
+	*--yy_cp = (char) c;
+
+
+	/* Note: the formal parameter *must* be called "yy_bp" for this
+	 * macro to now work correctly.
+	 */
+	YY_DO_BEFORE_ACTION; /* set up yytext again */
+	}
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+	{
+	int c;
+
+	*yy_c_buf_p = yy_hold_char;
+
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			yytext_ptr = yy_c_buf_p;
+			++yy_c_buf_p;
+
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						{
+						yy_c_buf_p =
+						yytext_ptr + YY_MORE_ADJ;
+						return EOF;
+						}
+
+					YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					break;
+
+				case EOB_ACT_LAST_MATCH:
+#ifdef __cplusplus
+					YY_FATAL_ERROR(
+					"unexpected last match in yyinput()" );
+#else
+					YY_FATAL_ERROR(
+					"unexpected last match in input()" );
+#endif
+				}
+			}
+		}
+
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
+
+	return c;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
+
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+	{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	yy_init_buffer( b, file );
+
+	return b;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+	{
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+	yy_flex_free( (void *) b->yy_ch_buf );
+	yy_flex_free( (void *) b );
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+	{
+	b->yy_input_file = file;
+
+	/* We put in the '\n' and start reading from [1] so that an
+	 * initial match-at-newline will be true.
+	 */
+
+	b->yy_ch_buf[0] = '\n';
+	b->yy_n_chars = 1;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[1];
+
+	b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
+
+	b->yy_fill_buffer = 1;
+
+	b->yy_buffer_status = YY_BUFFER_NEW;
+	}
+
+
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		int new_size;
+
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
+
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
+
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
+
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+	}
+
+
+static void yy_pop_state()
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
+
+
+static int yy_top_state()
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
+
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( const char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+	{
+	(void) fprintf( stderr, "%s\n", msg );
+	exit( 1 );
+	}
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		yytext[yyleng] = yy_hold_char; \
+		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
+		yy_hold_char = *yy_c_buf_p; \
+		*yy_c_buf_p = '\0'; \
+		yyleng = n; \
+		} \
+	while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, const char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+const char *s2;
+int n;
+#endif
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( unsigned int size )
+#else
+static void *yy_flex_alloc( size )
+unsigned int size;
+#endif
+	{
+	return (void *) malloc( size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, unsigned int size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+unsigned int size;
+#endif
+	{
+	return (void *) realloc( ptr, size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+	{
+	free( ptr );
+	}
+# line 515 "scan.l"
+
+
+
+int yywrap()
+	{
+	if ( --num_input_files > 0 )
+		{
+		set_input_file( *++input_files );
+		return 0;
+		}
+
+	else
+		return 1;
+	}
+
+
+/* set_input_file - open the given file (if NULL, stdin) for scanning */
+
+void set_input_file( file )
+char *file;
+	{
+	if ( file )
+		{
+		infilename = file;
+		yyin = fopen( infilename, "r" );
+
+		if ( yyin == NULL )
+			lerrsf( "can't open %s", file );
+		}
+
+	else
+		{
+		yyin = stdin;
+		infilename = "<stdin>";
+		}
+	}
+
+
+/* Wrapper routines for accessing the scanner's malloc routines. */
+
+void *flex_alloc( size )
+unsigned int size;
+	{
+	return yy_flex_alloc( size );
+	}
+
+void *flex_realloc( ptr, size )
+void *ptr;
+unsigned int size;
+	{
+	return yy_flex_realloc( ptr, size );
+	}
+
+void flex_free( ptr )
+void *ptr;
+	{
+	yy_flex_free( ptr );
+	}
diff --git a/usr.bin/lex/lex.1 b/usr.bin/lex/lex.1
new file mode 100644
index 000000000000..6aba4d6977ac
--- /dev/null
+++ b/usr.bin/lex/lex.1
@@ -0,0 +1,1001 @@
+.TH FLEX 1 "November 1993" "Version 2.4"
+.SH NAME
+flex \- fast lexical analyzer generator
+.SH SYNOPSIS
+.B flex
+.B [\-bcdfhilnpstvwBFILTV78+ \-C[aefFmr] \-Pprefix \-Sskeleton]
+.I [filename ...]
+.SH DESCRIPTION
+.I flex
+is a tool for generating
+.I scanners:
+programs which recognized lexical patterns in text.
+.I flex
+reads
+the given input files, or its standard input if no file names are given,
+for a description of a scanner to generate.  The description is in
+the form of pairs
+of regular expressions and C code, called
+.I rules.  flex
+generates as output a C source file,
+.B lex.yy.c,
+which defines a routine
+.B yylex().
+This file is compiled and linked with the
+.B \-lfl
+library to produce an executable.  When the executable is run,
+it analyzes its input for occurrences
+of the regular expressions.  Whenever it finds one, it executes
+the corresponding C code.
+.PP
+For full documentation, see
+.B flexdoc(1).
+This manual entry is intended for use as a quick reference.
+.SH OPTIONS
+.I flex
+has the following options:
+.TP
+.B \-b
+generate backing-up information to
+.I lex.backup.
+This is a list of scanner states which require backing up and the input
+characters on which they do so.  By adding rules one can remove
+backing-up states.  If all backing-up states are eliminated and
+.B \-Cf
+or
+.B \-CF
+is used, the generated scanner will run faster.
+.TP
+.B \-c
+is a do-nothing, deprecated option included for POSIX compliance.
+.IP
+.B NOTE:
+in previous releases of
+.I flex
+.B \-c
+specified table-compression options.  This functionality is
+now given by the
+.B \-C
+flag.  To ease the the impact of this change, when
+.I flex
+encounters
+.B \-c,
+it currently issues a warning message and assumes that
+.B \-C
+was desired instead.  In the future this "promotion" of
+.B \-c
+to
+.B \-C
+will go away in the name of full POSIX compliance (unless
+the POSIX meaning is removed first).
+.TP
+.B \-d
+makes the generated scanner run in
+.I debug
+mode.  Whenever a pattern is recognized and the global
+.B yy_flex_debug
+is non-zero (which is the default), the scanner will
+write to
+.I stderr
+a line of the form:
+.nf
+
+    --accepting rule at line 53 ("the matched text")
+
+.fi
+The line number refers to the location of the rule in the file
+defining the scanner (i.e., the file that was fed to flex).  Messages
+are also generated when the scanner backs up, accepts the
+default rule, reaches the end of its input buffer (or encounters
+a NUL; the two look the same as far as the scanner's concerned),
+or reaches an end-of-file.
+.TP
+.B \-f
+specifies
+.I fast scanner.
+No table compression is done and stdio is bypassed.
+The result is large but fast.  This option is equivalent to
+.B \-Cfr
+(see below).
+.TP
+.B \-h
+generates a "help" summary of
+.I flex's
+options to
+.I stderr 
+and then exits.
+.TP
+.B \-i
+instructs
+.I flex
+to generate a
+.I case-insensitive
+scanner.  The case of letters given in the
+.I flex
+input patterns will
+be ignored, and tokens in the input will be matched regardless of case.  The
+matched text given in
+.I yytext
+will have the preserved case (i.e., it will not be folded).
+.TP
+.B \-l
+turns on maximum compatibility with the original AT&T lex implementation,
+at a considerable performance cost.  This option is incompatible with
+.B \-+, \-f, \-F, \-Cf,
+or
+.B \-CF.
+See
+.I flexdoc(1)
+for details.
+.TP
+.B \-n
+is another do-nothing, deprecated option included only for
+POSIX compliance.
+.TP
+.B \-p
+generates a performance report to stderr.  The report
+consists of comments regarding features of the
+.I flex
+input file which will cause a loss of performance in the resulting scanner.
+If you give the flag twice, you will also get comments regarding
+features that lead to minor performance losses.
+.TP
+.B \-s
+causes the
+.I default rule
+(that unmatched scanner input is echoed to
+.I stdout)
+to be suppressed.  If the scanner encounters input that does not
+match any of its rules, it aborts with an error.
+.TP
+.B \-t
+instructs
+.I flex
+to write the scanner it generates to standard output instead
+of
+.B lex.yy.c.
+.TP
+.B \-v
+specifies that
+.I flex
+should write to
+.I stderr
+a summary of statistics regarding the scanner it generates.
+.TP
+.B \-w
+suppresses warning messages.
+.TP
+.B \-B
+instructs
+.I flex
+to generate a
+.I batch
+scanner instead of an
+.I interactive
+scanner (see
+.B \-I
+below).  See
+.I flexdoc(1)
+for details.  Scanners using
+.B \-Cf
+or
+.B \-CF
+compression options automatically specify this option, too.
+.TP
+.B \-F
+specifies that the
+.ul
+fast
+scanner table representation should be used (and stdio bypassed).
+This representation is about as fast as the full table representation
+.B (-f),
+and for some sets of patterns will be considerably smaller (and for
+others, larger).  It cannot be used with the
+.B \-+
+option.  See
+.B flexdoc(1)
+for more details.
+.IP
+This option is equivalent to
+.B \-CFr
+(see below).
+.TP
+.B \-I
+instructs
+.I flex
+to generate an
+.I interactive
+scanner, that is, a scanner which stops immediately rather than
+looking ahead if it knows
+that the currently scanned text cannot be part of a longer rule's match.
+This is the opposite of
+.I batch
+scanners (see
+.B \-B
+above).  See
+.B flexdoc(1)
+for details.
+.IP
+Note,
+.B \-I
+cannot be used in conjunction with
+.I full
+or
+.I fast tables,
+i.e., the
+.B \-f, \-F, \-Cf,
+or
+.B \-CF
+flags.  For other table compression options,
+.B \-I
+is the default.
+.TP
+.B \-L
+instructs
+.I flex
+not to generate
+.B #line
+directives in
+.B lex.yy.c.
+The default is to generate such directives so error
+messages in the actions will be correctly
+located with respect to the original
+.I flex
+input file, and not to
+the fairly meaningless line numbers of
+.B lex.yy.c.
+.TP
+.B \-T
+makes
+.I flex
+run in
+.I trace
+mode.  It will generate a lot of messages to
+.I stderr
+concerning
+the form of the input and the resultant non-deterministic and deterministic
+finite automata.  This option is mostly for use in maintaining
+.I flex.
+.TP
+.B \-V
+prints the version number to
+.I stderr
+and exits.
+.TP
+.B \-7
+instructs
+.I flex
+to generate a 7-bit scanner, which can save considerable table space,
+especially when using
+.B \-Cf
+or
+.B \-CF
+(and, at most sites,
+.B \-7
+is on by default for these options.  To see if this is the case, use the
+.B -v
+verbose flag and check the flag summary it reports).
+.TP
+.B \-8
+instructs
+.I flex
+to generate an 8-bit scanner.  This is the default except for the
+.B \-Cf
+and
+.B \-CF
+compression options, for which the default is site-dependent, and
+can be checked by inspecting the flag summary generated by the
+.B \-v
+option.
+.TP
+.B \-+
+specifies that you want flex to generate a C++
+scanner class.  See the section on Generating C++ Scanners in
+.I flexdoc(1)
+for details.
+.TP 
+.B \-C[aefFmr]
+controls the degree of table compression and scanner optimization.
+.IP
+.B \-Ca
+trade off larger tables in the generated scanner for faster performance
+because the elements of the tables are better aligned for memory access
+and computation.  This option can double the size of the tables used by
+your scanner.
+.IP
+.B \-Ce
+directs
+.I flex
+to construct
+.I equivalence classes,
+i.e., sets of characters
+which have identical lexical properties.
+Equivalence classes usually give
+dramatic reductions in the final table/object file sizes (typically
+a factor of 2-5) and are pretty cheap performance-wise (one array
+look-up per character scanned).
+.IP
+.B \-Cf
+specifies that the
+.I full
+scanner tables should be generated -
+.I flex
+should not compress the
+tables by taking advantages of similar transition functions for
+different states.
+.IP
+.B \-CF
+specifies that the alternate fast scanner representation (described in
+.B flexdoc(1))
+should be used.  This option cannot be used with
+.B \-+.
+.IP
+.B \-Cm
+directs
+.I flex
+to construct
+.I meta-equivalence classes,
+which are sets of equivalence classes (or characters, if equivalence
+classes are not being used) that are commonly used together.  Meta-equivalence
+classes are often a big win when using compressed tables, but they
+have a moderate performance impact (one or two "if" tests and one
+array look-up per character scanned).
+.IP
+.B \-Cr
+causes the generated scanner to
+.I bypass
+using stdio for input.  In general this option results in a minor
+performance gain only worthwhile if used in conjunction with
+.B \-Cf
+or
+.B \-CF.
+It can cause surprising behavior if you use stdio yourself to
+read from
+.I yyin
+prior to calling the scanner.
+.IP
+A lone
+.B \-C
+specifies that the scanner tables should be compressed but neither
+equivalence classes nor meta-equivalence classes should be used.
+.IP
+The options
+.B \-Cf
+or
+.B \-CF
+and
+.B \-Cm
+do not make sense together - there is no opportunity for meta-equivalence
+classes if the table is not being compressed.  Otherwise the options
+may be freely mixed.
+.IP
+The default setting is
+.B \-Cem,
+which specifies that
+.I flex
+should generate equivalence classes
+and meta-equivalence classes.  This setting provides the highest
+degree of table compression.  You can trade off
+faster-executing scanners at the cost of larger tables with
+the following generally being true:
+.nf
+
+    slowest & smallest
+          -Cem
+          -Cm
+          -Ce
+          -C
+          -C{f,F}e
+          -C{f,F}
+          -C{f,F}a
+    fastest & largest
+
+.fi
+.IP
+.B \-C
+options are cumulative.
+.TP
+.B \-Pprefix
+changes the default
+.I "yy"
+prefix used by
+.I flex
+to be
+.I prefix
+instead.  See
+.I flexdoc(1)
+for a description of all the global variables and file names that
+this affects.
+.TP
+.B \-Sskeleton_file
+overrides the default skeleton file from which
+.I flex
+constructs its scanners.  You'll never need this option unless you are doing
+.I flex
+maintenance or development.
+.SH SUMMARY OF FLEX REGULAR EXPRESSIONS
+The patterns in the input are written using an extended set of regular
+expressions.  These are:
+.nf
+
+    x          match the character 'x'
+    .          any character except newline
+    [xyz]      a "character class"; in this case, the pattern
+                 matches either an 'x', a 'y', or a 'z'
+    [abj-oZ]   a "character class" with a range in it; matches
+                 an 'a', a 'b', any letter from 'j' through 'o',
+                 or a 'Z'
+    [^A-Z]     a "negated character class", i.e., any character
+                 but those in the class.  In this case, any
+                 character EXCEPT an uppercase letter.
+    [^A-Z\\n]   any character EXCEPT an uppercase letter or
+                 a newline
+    r*         zero or more r's, where r is any regular expression
+    r+         one or more r's
+    r?         zero or one r's (that is, "an optional r")
+    r{2,5}     anywhere from two to five r's
+    r{2,}      two or more r's
+    r{4}       exactly 4 r's
+    {name}     the expansion of the "name" definition
+               (see above)
+    "[xyz]\\"foo"
+               the literal string: [xyz]"foo
+    \\X         if X is an 'a', 'b', 'f', 'n', 'r', 't', or 'v',
+                 then the ANSI-C interpretation of \\x.
+                 Otherwise, a literal 'X' (used to escape
+                 operators such as '*')
+    \\123       the character with octal value 123
+    \\x2a       the character with hexadecimal value 2a
+    (r)        match an r; parentheses are used to override
+                 precedence (see below)
+
+
+    rs         the regular expression r followed by the
+                 regular expression s; called "concatenation"
+
+
+    r|s        either an r or an s
+
+
+    r/s        an r but only if it is followed by an s.  The
+                 s is not part of the matched text.  This type
+                 of pattern is called as "trailing context".
+    ^r         an r, but only at the beginning of a line
+    r$         an r, but only at the end of a line.  Equivalent
+                 to "r/\\n".
+
+
+    <s>r       an r, but only in start condition s (see
+               below for discussion of start conditions)
+    <s1,s2,s3>r
+               same, but in any of start conditions s1,
+               s2, or s3
+    <*>r       an r in any start condition, even an exclusive one.
+
+
+    <<EOF>>    an end-of-file
+    <s1,s2><<EOF>>
+               an end-of-file when in start condition s1 or s2
+
+.fi
+The regular expressions listed above are grouped according to
+precedence, from highest precedence at the top to lowest at the bottom.
+Those grouped together have equal precedence.
+.PP
+Some notes on patterns:
+.IP -
+Negated character classes
+.I match newlines
+unless "\\n" (or an equivalent escape sequence) is one of the
+characters explicitly present in the negated character class
+(e.g., "[^A-Z\\n]").
+.IP -
+A rule can have at most one instance of trailing context (the '/' operator
+or the '$' operator).  The start condition, '^', and "<<EOF>>" patterns
+can only occur at the beginning of a pattern, and, as well as with '/' and '$',
+cannot be grouped inside parentheses.  The following are all illegal:
+.nf
+
+    foo/bar$
+    foo|(bar$)
+    foo|^bar
+    <sc1>foo<sc2>bar
+
+.fi
+.SH SUMMARY OF SPECIAL ACTIONS
+In addition to arbitrary C code, the following can appear in actions:
+.IP -
+.B ECHO
+copies yytext to the scanner's output.
+.IP -
+.B BEGIN
+followed by the name of a start condition places the scanner in the
+corresponding start condition.
+.IP -
+.B REJECT
+directs the scanner to proceed on to the "second best" rule which matched the
+input (or a prefix of the input).
+.B yytext
+and
+.B yyleng
+are set up appropriately.  Note that
+.B REJECT
+is a particularly expensive feature in terms scanner performance;
+if it is used in
+.I any
+of the scanner's actions it will slow down
+.I all
+of the scanner's matching.  Furthermore,
+.B REJECT
+cannot be used with the
+.B \-f
+or
+.B \-F
+options.
+.IP
+Note also that unlike the other special actions,
+.B REJECT
+is a
+.I branch;
+code immediately following it in the action will
+.I not
+be executed.
+.IP -
+.B yymore()
+tells the scanner that the next time it matches a rule, the corresponding
+token should be
+.I appended
+onto the current value of
+.B yytext
+rather than replacing it.
+.IP -
+.B yyless(n)
+returns all but the first
+.I n
+characters of the current token back to the input stream, where they
+will be rescanned when the scanner looks for the next match.
+.B yytext
+and
+.B yyleng
+are adjusted appropriately (e.g.,
+.B yyleng
+will now be equal to
+.I n
+).
+.IP -
+.B unput(c)
+puts the character
+.I c
+back onto the input stream.  It will be the next character scanned.
+.IP -
+.B input()
+reads the next character from the input stream (this routine is called
+.B yyinput()
+if the scanner is compiled using
+.B C++).
+.IP -
+.B yyterminate()
+can be used in lieu of a return statement in an action.  It terminates
+the scanner and returns a 0 to the scanner's caller, indicating "all done".
+.IP
+By default,
+.B yyterminate()
+is also called when an end-of-file is encountered.  It is a macro and
+may be redefined.
+.IP -
+.B YY_NEW_FILE
+is an action available only in <<EOF>> rules.  It means "Okay, I've
+set up a new input file, continue scanning".  It is no longer required;
+you can just assign
+.I yyin
+to point to a new file in the <<EOF>> action.
+.IP -
+.B yy_create_buffer( file, size )
+takes a
+.I FILE
+pointer and an integer
+.I size.
+It returns a YY_BUFFER_STATE
+handle to a new input buffer large enough to accomodate
+.I size
+characters and associated with the given file.  When in doubt, use
+.B YY_BUF_SIZE
+for the size.
+.IP -
+.B yy_switch_to_buffer( new_buffer )
+switches the scanner's processing to scan for tokens from
+the given buffer, which must be a YY_BUFFER_STATE.
+.IP -
+.B yy_delete_buffer( buffer )
+deletes the given buffer.
+.SH VALUES AVAILABLE TO THE USER
+.IP -
+.B char *yytext
+holds the text of the current token.  It may be modified but not lengthened
+(you cannot append characters to the end).  Modifying the last character
+may affect the activity of rules anchored using '^' during the next scan;
+see
+.B flexdoc(1)
+for details.
+.IP
+If the special directive
+.B %array
+appears in the first section of the scanner description, then
+.B yytext
+is instead declared
+.B char yytext[YYLMAX],
+where
+.B YYLMAX
+is a macro definition that you can redefine in the first section
+if you don't like the default value (generally 8KB).  Using
+.B %array
+results in somewhat slower scanners, but the value of
+.B yytext
+becomes immune to calls to
+.I input()
+and
+.I unput(),
+which potentially destroy its value when
+.B yytext
+is a character pointer.  The opposite of
+.B %array
+is
+.B %pointer,
+which is the default.
+.IP
+You cannot use
+.B %array
+when generating C++ scanner classes
+(the
+.B \-+
+flag).
+.IP -
+.B int yyleng
+holds the length of the current token.
+.IP -
+.B FILE *yyin
+is the file which by default
+.I flex
+reads from.  It may be redefined but doing so only makes sense before
+scanning begins or after an EOF has been encountered.  Changing it in
+the midst of scanning will have unexpected results since
+.I flex
+buffers its input; use
+.B yyrestart()
+instead.
+Once scanning terminates because an end-of-file
+has been seen,
+.B
+you can assign
+.I yyin
+at the new input file and then call the scanner again to continue scanning.
+.IP -
+.B void yyrestart( FILE *new_file )
+may be called to point
+.I yyin
+at the new input file.  The switch-over to the new file is immediate
+(any previously buffered-up input is lost).  Note that calling
+.B yyrestart()
+with
+.I yyin
+as an argument thus throws away the current input buffer and continues
+scanning the same input file.
+.IP -
+.B FILE *yyout
+is the file to which
+.B ECHO
+actions are done.  It can be reassigned by the user.
+.IP -
+.B YY_CURRENT_BUFFER
+returns a
+.B YY_BUFFER_STATE
+handle to the current buffer.
+.IP -
+.B YY_START
+returns an integer value corresponding to the current start
+condition.  You can subsequently use this value with
+.B BEGIN
+to return to that start condition.
+.SH MACROS AND FUNCTIONS YOU CAN REDEFINE
+.IP -
+.B YY_DECL
+controls how the scanning routine is declared.
+By default, it is "int yylex()", or, if prototypes are being
+used, "int yylex(void)".  This definition may be changed by redefining
+the "YY_DECL" macro.  Note that
+if you give arguments to the scanning routine using a
+K&R-style/non-prototyped function declaration, you must terminate
+the definition with a semi-colon (;).
+.IP -
+The nature of how the scanner
+gets its input can be controlled by redefining the
+.B YY_INPUT
+macro.
+YY_INPUT's calling sequence is "YY_INPUT(buf,result,max_size)".  Its
+action is to place up to
+.I max_size
+characters in the character array
+.I buf
+and return in the integer variable
+.I result
+either the
+number of characters read or the constant YY_NULL (0 on Unix systems)
+to indicate EOF.  The default YY_INPUT reads from the
+global file-pointer "yyin".
+A sample redefinition of YY_INPUT (in the definitions
+section of the input file):
+.nf
+
+    %{
+    #undef YY_INPUT
+    #define YY_INPUT(buf,result,max_size) \\
+        { \\
+        int c = getchar(); \\
+        result = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \\
+        }
+    %}
+
+.fi
+.IP -
+When the scanner receives an end-of-file indication from YY_INPUT,
+it then checks the function
+.B yywrap()
+function.  If
+.B yywrap()
+returns false (zero), then it is assumed that the
+function has gone ahead and set up
+.I yyin
+to point to another input file, and scanning continues.  If it returns
+true (non-zero), then the scanner terminates, returning 0 to its
+caller.
+.IP
+The default
+.B yywrap()
+always returns 1.
+.IP -
+YY_USER_ACTION
+can be redefined to provide an action
+which is always executed prior to the matched rule's action.
+.IP -
+The macro
+.B YY_USER_INIT
+may be redefined to provide an action which is always executed before
+the first scan.
+.IP -
+In the generated scanner, the actions are all gathered in one large
+switch statement and separated using
+.B YY_BREAK,
+which may be redefined.  By default, it is simply a "break", to separate
+each rule's action from the following rule's.
+.SH FILES
+.TP
+.B \-lfl
+library with which to link scanners to obtain the default versions
+of
+.I yywrap()
+and/or
+.I main().
+.TP
+.I lex.yy.c
+generated scanner (called
+.I lexyy.c
+on some systems).
+.TP
+.I lex.yy.cc
+generated C++ scanner class, when using
+.B -+.
+.TP
+.I <FlexLexer.h>
+header file defining the C++ scanner base class,
+.B FlexLexer,
+and its derived class,
+.B yyFlexLexer.
+.TP
+.I flex.skl
+skeleton scanner.  This file is only used when building flex, not when
+flex executes.
+.TP
+.I lex.backup
+backing-up information for
+.B \-b
+flag (called
+.I lex.bck
+on some systems).
+.SH "SEE ALSO"
+.PP
+flexdoc(1), lex(1), yacc(1), sed(1), awk(1).
+.PP
+M. E. Lesk and E. Schmidt,
+.I LEX \- Lexical Analyzer Generator
+.SH DIAGNOSTICS
+.PP
+.I reject_used_but_not_detected undefined
+or
+.PP
+.I yymore_used_but_not_detected undefined -
+These errors can occur at compile time.  They indicate that the
+scanner uses
+.B REJECT
+or
+.B yymore()
+but that
+.I flex
+failed to notice the fact, meaning that
+.I flex
+scanned the first two sections looking for occurrences of these actions
+and failed to find any, but somehow you snuck some in (via a #include
+file, for example).  Make an explicit reference to the action in your
+.I flex
+input file.  (Note that previously
+.I flex
+supported a
+.B %used/%unused
+mechanism for dealing with this problem; this feature is still supported
+but now deprecated, and will go away soon unless the author hears from
+people who can argue compellingly that they need it.)
+.PP
+.I flex scanner jammed -
+a scanner compiled with
+.B \-s
+has encountered an input string which wasn't matched by
+any of its rules.
+.PP
+.I warning, rule cannot be matched
+indicates that the given rule
+cannot be matched because it follows other rules that will
+always match the same text as it.  See
+.I flexdoc(1)
+for an example.
+.PP
+.I warning,
+.B \-s
+.I
+option given but default rule can be matched
+means that it is possible (perhaps only in a particular start condition)
+that the default rule (match any single character) is the only one
+that will match a particular input.  Since
+.PP
+.I scanner input buffer overflowed -
+a scanner rule matched more text than the available dynamic memory.
+.PP
+.I token too large, exceeds YYLMAX -
+your scanner uses
+.B %array
+and one of its rules matched a string longer than the
+.B YYLMAX
+constant (8K bytes by default).  You can increase the value by
+#define'ing
+.B YYLMAX
+in the definitions section of your
+.I flex
+input.
+.PP
+.I scanner requires \-8 flag to
+.I use the character 'x' -
+Your scanner specification includes recognizing the 8-bit character
+.I 'x'
+and you did not specify the \-8 flag, and your scanner defaulted to 7-bit
+because you used the
+.B \-Cf
+or
+.B \-CF
+table compression options.
+.PP
+.I flex scanner push-back overflow -
+you used
+.B unput()
+to push back so much text that the scanner's buffer could not hold
+both the pushed-back text and the current token in
+.B yytext.
+Ideally the scanner should dynamically resize the buffer in this case, but at
+present it does not.
+.PP
+.I
+input buffer overflow, can't enlarge buffer because scanner uses REJECT -
+the scanner was working on matching an extremely large token and needed
+to expand the input buffer.  This doesn't work with scanners that use
+.B
+REJECT.
+.PP
+.I
+fatal flex scanner internal error--end of buffer missed -
+This can occur in an scanner which is reentered after a long-jump
+has jumped out (or over) the scanner's activation frame.  Before
+reentering the scanner, use:
+.nf
+
+    yyrestart( yyin );
+
+.fi
+or use C++ scanner classes (the
+.B \-+
+option), which are fully reentrant.
+.SH AUTHOR
+Vern Paxson, with the help of many ideas and much inspiration from
+Van Jacobson.  Original version by Jef Poskanzer.
+.PP
+See flexdoc(1) for additional credits and the address to send comments to.
+.SH DEFICIENCIES / BUGS
+.PP
+Some trailing context
+patterns cannot be properly matched and generate
+warning messages ("dangerous trailing context").  These are
+patterns where the ending of the
+first part of the rule matches the beginning of the second
+part, such as "zx*/xy*", where the 'x*' matches the 'x' at
+the beginning of the trailing context.  (Note that the POSIX draft
+states that the text matched by such patterns is undefined.)
+.PP
+For some trailing context rules, parts which are actually fixed-length are
+not recognized as such, leading to the abovementioned performance loss.
+In particular, parts using '|' or {n} (such as "foo{3}") are always
+considered variable-length.
+.PP
+Combining trailing context with the special '|' action can result in
+.I fixed
+trailing context being turned into the more expensive
+.I variable
+trailing context.  For example, in the following:
+.nf
+
+    %%
+    abc      |
+    xyz/def
+
+.fi
+.PP
+Use of
+.B unput()
+or
+.B input()
+invalidates yytext and yyleng, unless the
+.B %array
+directive
+or the
+.B \-l
+option has been used.
+.PP
+Use of unput() to push back more text than was matched can
+result in the pushed-back text matching a beginning-of-line ('^')
+rule even though it didn't come at the beginning of the line
+(though this is rare!).
+.PP
+Pattern-matching of NUL's is substantially slower than matching other
+characters.
+.PP
+Dynamic resizing of the input buffer is slow, as it entails rescanning
+all the text matched so far by the current (generally huge) token.
+.PP
+.I flex
+does not generate correct #line directives for code internal
+to the scanner; thus, bugs in
+.I flex.skl
+yield bogus line numbers.
+.PP
+Due to both buffering of input and read-ahead, you cannot intermix
+calls to <stdio.h> routines, such as, for example,
+.B getchar(),
+with
+.I flex
+rules and expect it to work.  Call
+.B input()
+instead.
+.PP
+The total table entries listed by the
+.B \-v
+flag excludes the number of table entries needed to determine
+what rule has been matched.  The number of entries is equal
+to the number of DFA states if the scanner does not use
+.B REJECT,
+and somewhat greater than the number of states if it does.
+.PP
+.B REJECT
+cannot be used with the
+.B \-f
+or
+.B \-F
+options.
+.PP
+The
+.I flex
+internal algorithms need documentation.
diff --git a/usr.bin/lex/lib/Makefile b/usr.bin/lex/lib/Makefile
new file mode 100644
index 000000000000..406e542a9149
--- /dev/null
+++ b/usr.bin/lex/lib/Makefile
@@ -0,0 +1,20 @@
+# $Id$
+
+LIB=    ln
+SRCS=   libmain.c libyywrap.c
+LINKS=  ${LIBDIR}/libln.a ${LIBDIR}/libl.a \
+
+.if !defined(NOPROFILE)
+LINKS+= ${LIBDIR}/libln_p.a ${LIBDIR}/libl_p.a
+.endif
+
+.if !defined(NOSHARED) 
+LINKS+= ${LIBDIR}/libln.so.$(SHLIB_MAJOR).$(SHLIB_MINOR) \
+		${LIBDIR}/libl.so.$(SHLIB_MAJOR).$(SHLIB_MINOR)
+.endif
+
+#This is where we get our SHLIB_MAJOR and SHLIB_MINOR
+.include "${.CURDIR}/../../../lib/Makefile.inc"
+
+.include <bsd.lib.mk>
+
diff --git a/usr.bin/lex/lib/libmain.c b/usr.bin/lex/lib/libmain.c
new file mode 100644
index 000000000000..a893c7abd3d2
--- /dev/null
+++ b/usr.bin/lex/lib/libmain.c
@@ -0,0 +1,12 @@
+/* libmain - flex run-time support library "main" function */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/libmain.c,v 1.3 93/04/14 22:41:55 vern Exp $ */
+
+extern int yylex();
+
+int main( argc, argv )
+int argc;
+char *argv[];
+	{
+	return yylex();
+	}
diff --git a/usr.bin/lex/lib/libyywrap.c b/usr.bin/lex/lib/libyywrap.c
new file mode 100644
index 000000000000..b18f54e6e8f9
--- /dev/null
+++ b/usr.bin/lex/lib/libyywrap.c
@@ -0,0 +1,8 @@
+/* libyywrap - flex run-time support library "yywrap" function */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/libyywrap.c,v 1.1 93/10/02 15:23:09 vern Exp $ */
+
+int yywrap()
+	{
+	return 1;
+	}
diff --git a/usr.bin/lex/main.c b/usr.bin/lex/main.c
new file mode 100644
index 000000000000..a90027add059
--- /dev/null
+++ b/usr.bin/lex/main.c
@@ -0,0 +1,989 @@
+/* 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1990 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+/* $Header: main.c,v 1.2 94/01/04 14:33:11 vern Exp $ */
+
+
+#include "flexdef.h"
+#include "version.h"
+
+static char flex_version[] = FLEX_VERSION;
+
+
+/* declare functions that have forward references */
+
+void flexinit PROTO((int, char**));
+void readin PROTO((void));
+void set_up_initial_allocations PROTO((void));
+
+
+/* these globals are all defined and commented in flexdef.h */
+int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
+int interactive, caseins, lex_compat, useecs, fulltbl, usemecs;
+int fullspd, gen_line_dirs, performance_report, backing_up_report;
+int C_plus_plus, long_align, use_read, yytext_is_array, csize;
+int yymore_used, reject, real_reject, continued_action;
+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;
+int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+int current_mns, num_rules, num_eof_rules, default_rule;
+int current_max_rules, 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, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
+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, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
+int 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;
+char *program_name;
+
+#ifndef SHORT_FILE_NAMES
+static char *outfile_template = "lex.%s.%s";
+#else
+static char *outfile_template = "lex%s.%s";
+#endif
+static char outfile_path[64];
+
+static int outfile_created = 0;
+static int use_stdout;
+static char *skelname = NULL;
+static char *prefix = "yy";
+
+
+int main( argc, argv )
+int argc;
+char **argv;
+	{
+	int i;
+
+	flexinit( argc, argv );
+
+	readin();
+
+	ntod();
+
+	for ( i = 1; i <= num_rules; ++i )
+		if ( ! rule_useful[i] && i != default_rule )
+			line_warning( "rule cannot be matched",
+					rule_linenum[i] );
+
+	if ( spprdflt && ! reject && rule_useful[default_rule] )
+		line_warning( "-s option given but default rule can be matched",
+			rule_linenum[default_rule] );
+
+	/* Generate the C state transition tables from the DFA. */
+	make_tables();
+
+	/* Note, flexend does not return.  It exits with its argument
+	 * as status.
+	 */
+	flexend( 0 );
+
+	return 0;	/* keep compilers/lint happy */
+	}
+
+
+/* flexend - terminate flex
+ *
+ * note
+ *    This routine does not return.
+ */
+
+void flexend( exit_status )
+int exit_status;
+
+	{
+	int tblsiz;
+	int unlink();
+
+	if ( skelfile != NULL )
+		{
+		if ( ferror( skelfile ) )
+			flexfatal(
+				"error occurred when reading skeleton file" );
+
+		else if ( fclose( skelfile ) )
+			flexfatal(
+				"error occurred when closing skeleton file" );
+		}
+
+	if ( exit_status != 0 && outfile_created )
+		{
+		if ( ferror( stdout ) )
+			flexfatal( "error occurred when writing output file" );
+
+		else if ( fclose( stdout ) )
+			flexfatal( "error occurred when closing output file" );
+
+		else if ( unlink( outfile_path ) )
+			flexfatal( "error occurred when deleting output file" );
+		}
+
+	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 ) )
+			flexfatal( "error occurred when writing backup file" );
+
+		else if ( fclose( backing_up_file ) )
+			flexfatal( "error occurred when closing backup file" );
+		}
+
+	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 ( caseins )
+			putc( 'i', stderr );
+		if ( lex_compat )
+			putc( 'l', stderr );
+		if ( performance_report > 0 )
+			putc( 'p', stderr );
+		if ( performance_report > 1 )
+			putc( 'p', stderr );
+		if ( spprdflt )
+			putc( 's', stderr );
+		if ( use_stdout )
+			putc( 't', stderr );
+		if ( printstats )
+			putc( 'v', stderr );	/* always true! */
+		if ( nowarn )
+			putc( 'w', stderr );
+		if ( ! interactive )
+			putc( 'B', stderr );
+		if ( interactive )
+			putc( 'I', stderr );
+		if ( ! gen_line_dirs )
+			putc( 'L', stderr );
+		if ( trace )
+			putc( 'T', stderr );
+		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 ( 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 );
+		}
+
+#ifndef VMS
+	exit( exit_status );
+#else
+	exit( exit_status + 1 );
+#endif
+	}
+
+
+/* flexinit - initialize flex */
+
+void flexinit( argc, argv )
+int argc;
+char **argv;
+	{
+	int i, sawcmpflag;
+	int csize_given, interactive_given;
+	char *arg, *mktemp();
+
+	printstats = syntaxerror = trace = spprdflt = caseins = false;
+	lex_compat = false;
+	C_plus_plus = backing_up_report = ddebug = fulltbl = fullspd = false;
+	long_align = nowarn = yymore_used = continued_action = reject = false;
+	yytext_is_array = yymore_really_used = reject_really_used = false;
+	gen_line_dirs = usemecs = useecs = true;
+	performance_report = 0;
+
+	sawcmpflag = false;
+	use_read = use_stdout = false;
+	csize_given = false;
+	interactive_given = 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';
+
+	program_name = argv[0];
+
+	if ( program_name[0] != '\0' &&
+	     program_name[strlen( program_name ) - 1] == '+' )
+		C_plus_plus = true;
+
+	/* read flags */
+	for ( --argc, ++argv; argc ; --argc, ++argv )
+		{
+		if ( argv[0][0] != '-' || argv[0][1] == '\0' )
+			break;
+
+		arg = argv[0];
+
+		for ( i = 1; arg[i] != '\0'; ++i )
+			switch ( arg[i] )
+				{
+				case '+':
+					C_plus_plus = true;
+					break;
+
+				case 'B':
+					interactive = false;
+					interactive_given = true;
+					break;
+
+				case 'b':
+					backing_up_report = true;
+					break;
+
+				case 'c':
+					fprintf( stderr,
+	"%s: Assuming use of deprecated -c flag is really intended to be -C\n",
+					program_name );
+
+					/* fall through */
+
+				case 'C':
+					if ( i != 1 )
+						flexerror(
+					"-C flag must be given separately" );
+
+					if ( ! sawcmpflag )
+						{
+						useecs = false;
+						usemecs = false;
+						fulltbl = false;
+						sawcmpflag = true;
+						}
+
+					for ( ++i; arg[i] != '\0'; ++i )
+						switch ( arg[i] )
+							{
+							case 'a':
+								long_align =
+									true;
+								break;
+
+							case 'e':
+								useecs = true;
+								break;
+
+							case 'F':
+								fullspd = true;
+								break;
+
+							case 'f':
+								fulltbl = true;
+								break;
+
+							case 'm':
+								usemecs = true;
+								break;
+
+							case 'r':
+								use_read = true;
+								break;
+
+							default:
+								lerrif(
+						"unknown -C option '%c'",
+								(int) arg[i] );
+								break;
+							}
+
+					goto get_next_arg;
+
+				case 'd':
+					ddebug = true;
+					break;
+
+				case 'f':
+					useecs = usemecs = false;
+					use_read = fulltbl = true;
+					break;
+
+				case 'F':
+					useecs = usemecs = false;
+					use_read = fullspd = true;
+					break;
+
+				case 'h':
+					usage();
+					exit( 0 );
+
+				case 'I':
+					interactive = true;
+					interactive_given = true;
+					break;
+
+				case 'i':
+					caseins = true;
+					break;
+
+				case 'l':
+					lex_compat = true;
+					break;
+
+				case 'L':
+					gen_line_dirs = false;
+					break;
+
+				case 'n':
+					/* Stupid do-nothing deprecated
+					 * option.
+					 */
+					break;
+
+				case 'P':
+					if ( i != 1 )
+						flexerror(
+					"-P flag must be given separately" );
+
+					prefix = arg + i + 1;
+					goto get_next_arg;
+
+				case 'p':
+					++performance_report;
+					break;
+
+				case 'S':
+					if ( i != 1 )
+						flexerror(
+					"-S flag must be given separately" );
+
+					skelname = arg + i + 1;
+					goto get_next_arg;
+
+				case 's':
+					spprdflt = true;
+					break;
+
+				case 't':
+					use_stdout = true;
+					break;
+
+				case 'T':
+					trace = true;
+					break;
+
+				case 'v':
+					printstats = true;
+					break;
+
+				case 'V':
+					fprintf( stderr, "%s version %s\n",
+						program_name, flex_version );
+					exit( 0 );
+
+				case 'w':
+					nowarn = true;
+					break;
+
+				case '7':
+					csize = 128;
+					csize_given = true;
+					break;
+
+				case '8':
+					csize = CSIZE;
+					csize_given = true;
+					break;
+
+				default:
+					fprintf( stderr,
+						"%s: unknown flag '%c'\n",
+						program_name, (int) arg[i] );
+					usage();
+					exit( 1 );
+				}
+
+		/* Used by -C, -S and -P flags in lieu of a "continue 2"
+		 * control.
+		 */
+		get_next_arg: ;
+		}
+
+	if ( ! csize_given )
+		{
+		if ( (fulltbl || fullspd) && ! useecs )
+			csize = DEFAULT_CSIZE;
+		else
+			csize = CSIZE;
+		}
+
+	if ( ! interactive_given )
+		{
+		if ( fulltbl || fullspd )
+			interactive = false;
+		else
+			interactive = true;
+		}
+
+	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" );
+
+		/* Don't rely on detecting use of yymore() and REJECT,
+		 * just assume they'll be used.
+		 */
+		yymore_really_used = reject_really_used = true;
+
+		yytext_is_array = true;
+		use_read = false;
+		}
+
+	if ( (fulltbl || fullspd) && usemecs )
+		flexerror( "-Cf/-CF and -Cm don't make sense together" );
+
+	if ( (fulltbl || fullspd) && interactive )
+		flexerror( "-Cf/-CF and -I are incompatible" );
+
+	if ( fulltbl && fullspd )
+		flexerror( "-Cf and -CF are mutually exclusive" );
+
+	if ( C_plus_plus && fullspd )
+		flexerror( "Can't use -+ with -CF option" );
+
+	if ( ! use_stdout )
+		{
+		FILE *prev_stdout;
+		char *suffix;
+
+		if ( C_plus_plus )
+			suffix = "cc";
+		else
+			suffix = "c";
+
+		sprintf( outfile_path, outfile_template, prefix, suffix );
+
+		prev_stdout = freopen( outfile_path, "w", stdout );
+
+		if ( prev_stdout == NULL )
+			lerrsf( "could not create %s", outfile_path );
+
+		outfile_created = 1;
+		}
+
+	num_input_files = argc;
+	input_files = argv;
+	set_input_file( num_input_files > 0 ? input_files[0] : NULL );
+
+	if ( backing_up_report )
+		{
+#ifndef SHORT_FILE_NAMES
+		backing_up_file = fopen( "lex.backup", "w" );
+#else
+		backing_up_file = fopen( "lex.bck", "w" );
+#endif
+
+		if ( backing_up_file == NULL )
+			flexerror( "could not create lex.backup" );
+		}
+
+	else
+		backing_up_file = NULL;
+
+
+	lastccl = 0;
+	lastsc = 0;
+
+	if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
+		lerrsf( "can't open skeleton file %s", skelname );
+
+	if ( strcmp( prefix, "yy" ) )
+		{
+#define GEN_PREFIX(name) printf( "#define yy%s %s%s\n", name, prefix, name );
+		GEN_PREFIX( "FlexLexer" );
+		GEN_PREFIX( "_create_buffer" );
+		GEN_PREFIX( "_delete_buffer" );
+		GEN_PREFIX( "_flex_debug" );
+		GEN_PREFIX( "_init_buffer" );
+		GEN_PREFIX( "_load_buffer_state" );
+		GEN_PREFIX( "_switch_to_buffer" );
+		GEN_PREFIX( "in" );
+		GEN_PREFIX( "leng" );
+		GEN_PREFIX( "lex" );
+		GEN_PREFIX( "out" );
+		GEN_PREFIX( "restart" );
+		GEN_PREFIX( "text" );
+		GEN_PREFIX( "wrap" );
+		printf( "\n" );
+		}
+
+
+	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;
+
+	linenum = sectnum = 1;
+	firstprot = NIL;
+
+	/* Used in mkprot() so that the first proto goes in slot 1
+	 * of the proto queue.
+	 */
+	lastprot = 1;
+
+	if ( useecs )
+		{
+		/* Set up doubly-linked equivalence classes. */
+
+		/* We loop all the way up to csize, since ecgroup[csize] is
+		 * the position used for NUL characters.
+		 */
+		ecgroup[1] = NIL;
+
+		for ( i = 2; i <= csize; ++i )
+			{
+			ecgroup[i] = i - 1;
+			nextecm[i - 1] = i;
+			}
+
+		nextecm[csize] = NIL;
+		}
+
+	else
+		{
+		/* Put everything in its own equivalence class. */
+		for ( i = 1; i <= csize; ++i )
+			{
+			ecgroup[i] = i;
+			nextecm[i] = BAD_SUBSCRIPT;	/* to catch errors */
+			}
+		}
+
+	set_up_initial_allocations();
+	}
+
+
+/* readin - read in the rules section of the input file(s) */
+
+void readin()
+	{
+	skelout();
+
+	line_directive_out( (FILE *) 0 );
+
+	if ( yyparse() )
+		{
+		pinpoint_message( "fatal parse error" );
+		flexend( 1 );
+		}
+
+	if ( syntaxerror )
+		flexend( 1 );
+
+	if ( yymore_really_used == REALLY_USED )
+		yymore_used = true;
+	else if ( yymore_really_used == REALLY_NOT_USED )
+		yymore_used = false;
+
+	if ( reject_really_used == REALLY_USED )
+		reject = true;
+	else if ( reject_really_used == REALLY_NOT_USED )
+		reject = false;
+
+	if ( performance_report > 0 )
+		{
+		if ( lex_compat )
+			{
+			fprintf( stderr,
+"-l AT&T lex compatibility option entails a large performance penalty\n" );
+			fprintf( stderr,
+" and may be the actual source of other reported performance penalties\n" );
+			}
+
+		if ( performance_report > 1 )
+			{
+			if ( interactive )
+				fprintf( stderr,
+		"-I (interactive) entails a minor performance penalty\n" );
+
+			if ( yymore_used )
+				fprintf( stderr,
+			"yymore() entails a minor performance penalty\n" );
+			}
+
+		if ( reject )
+			fprintf( stderr,
+			"REJECT entails a large performance penalty\n" );
+
+		if ( variable_trailing_context_rules )
+			fprintf( stderr,
+"Variable trailing context rules entail a large performance penalty\n" );
+		}
+
+	if ( reject )
+		real_reject = true;
+
+	if ( variable_trailing_context_rules )
+		reject = true;
+
+	if ( (fulltbl || fullspd) && reject )
+		{
+		if ( real_reject )
+			flexerror( "REJECT cannot be used with -f or -F" );
+		else
+			flexerror(
+	"variable trailing context rules cannot be used with -f or -F" );
+		}
+
+	if ( csize == 256 )
+		puts( "typedef unsigned char YY_CHAR;" );
+	else
+		puts( "typedef char YY_CHAR;" );
+
+	if ( C_plus_plus )
+		{
+		puts( "#define yytext_ptr yytext" );
+
+		if ( interactive )
+			puts( "#define YY_INTERACTIVE" );
+		}
+
+	if ( fullspd )
+		printf(
+		"typedef const struct yy_trans_info *yy_state_type;\n" );
+	else if ( ! C_plus_plus )
+		printf( "typedef int yy_state_type;\n" );
+
+	if ( reject )
+		printf( "\n#define YY_USES_REJECT\n" );
+
+	if ( ddebug )
+		puts( "\n#define FLEX_DEBUG" );
+
+	if ( lex_compat )
+		{
+		printf( "FILE *yyin = stdin, *yyout = stdout;\n" );
+		printf( "extern int yylineno;\n" );
+		printf( "int yylineno = 1;\n" );
+		}
+	else if ( ! C_plus_plus )
+		printf( "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;\n" );
+
+	if ( C_plus_plus )
+		printf( "\n#include <FlexLexer.h>\n" );
+
+	else
+		{
+		if ( yytext_is_array )
+			puts( "extern char yytext[];\n" );
+
+		else
+			{
+			puts( "extern char *yytext;" );
+			puts( "#define yytext_ptr yytext" );
+			}
+		}
+
+	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()
+	{
+	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 );
+
+	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 );
+	actvsc = allocate_integer_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 );
+
+	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;
+	}
+
+
+void usage()
+	{
+	fprintf( stderr,
+"%s [-bcdfhilnpstvwBFILTV78+ -C[aefFmr] -Pprefix -Sskeleton] [file ...]\n",
+		program_name );
+
+	fprintf( stderr,
+		"\t-b  generate backing-up information to lex.backup\n" );
+	fprintf( stderr, "\t-c  do-nothing POSIX option\n" );
+	fprintf( stderr, "\t-d  turn on debug mode in generated scanner\n" );
+	fprintf( stderr, "\t-f  generate fast, large scanner\n" );
+	fprintf( stderr, "\t-h  produce this help message\n" );
+	fprintf( stderr, "\t-i  generate case-insensitive scanner\n" );
+	fprintf( stderr, "\t-l  maximal compatibility with original lex\n" );
+	fprintf( stderr, "\t-n  do-nothing POSIX option\n" );
+	fprintf( stderr, "\t-p  generate performance report to stderr\n" );
+	fprintf( stderr,
+		"\t-s  suppress default rule to ECHO unmatched text\n" );
+	fprintf( stderr,
+	"\t-t  write generated scanner on stdout instead of lex.yy.c\n" );
+	fprintf( stderr,
+		"\t-v  write summary of scanner statistics to stderr\n" );
+	fprintf( stderr, "\t-w  do not generate warnings\n" );
+	fprintf( stderr, "\t-B  generate batch scanner (opposite of -I)\n" );
+	fprintf( stderr,
+		"\t-F  use alternative fast scanner representation\n" );
+	fprintf( stderr,
+		"\t-I  generate interactive scanner (opposite of -B)\n" );
+	fprintf( stderr, "\t-L  suppress #line directives in scanner\n" );
+	fprintf( stderr, "\t-T  %s should run in trace mode\n", program_name );
+	fprintf( stderr, "\t-V  report %s version\n", program_name );
+	fprintf( stderr, "\t-7  generate 7-bit scanner\n" );
+	fprintf( stderr, "\t-8  generate 8-bit scanner\n" );
+	fprintf( stderr, "\t-+  generate C++ scanner class\n" );
+	fprintf( stderr,
+	"\t-C  specify degree of table compression (default is -Cem):\n" );
+	fprintf( stderr,
+	"\t\t-Ca  trade off larger tables for better memory alignment\n" );
+	fprintf( stderr, "\t\t-Ce  construct equivalence classes\n" );
+	fprintf( stderr,
+	"\t\t-Cf  do not compress scanner tables; use -f representation\n" );
+	fprintf( stderr,
+	"\t\t-CF  do not compress scanner tables; use -F representation\n" );
+	fprintf( stderr, "\t\t-Cm  construct meta-equivalence classes\n" );
+	fprintf( stderr,
+		"\t\t-Cr  use read() instead of stdio for scanner input\n" );
+	fprintf( stderr, "\t-P  specify scanner prefix other than \"yy\"\n" );
+	fprintf( stderr, "\t-S  specify skeleton file\n" );
+	}
diff --git a/usr.bin/lex/misc.c b/usr.bin/lex/misc.c
new file mode 100644
index 000000000000..006f5fcde026
--- /dev/null
+++ b/usr.bin/lex/misc.c
@@ -0,0 +1,773 @@
+/* misc - miscellaneous flex routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: misc.c,v 1.2 94/01/04 14:33:10 vern Exp $ */
+
+#include "flexdef.h"
+
+
+
+/* declare functions that have forward references */
+
+void dataflush PROTO((void));
+int otoi PROTO((Char []));
+
+
+void add_action( new_text )
+char *new_text;
+	{
+	int len = strlen( new_text );
+
+	while ( len + action_index >= action_size - 10 /* slop */ )
+		{
+		action_size *= 2;
+		action_array =
+			reallocate_character_array( action_array, action_size );
+		}
+
+	strcpy( &action_array[action_index], new_text );
+
+	action_index += len;
+	}
+
+
+/* allocate_array - allocate memory for an integer array of the given size */
+
+void *allocate_array( size, element_size )
+int size, element_size;
+	{
+	register void *mem;
+
+	/* On 16-bit int machines (e.g., 80286) we might be trying to
+	 * allocate more than a signed int can hold, and that won't
+	 * work.  Cheap test:
+	 */
+	if ( element_size * size <= 0 )
+		flexfatal( "request for < 1 byte in allocate_array()" );
+
+	mem = flex_alloc( element_size * size );
+
+	if ( mem == NULL )
+		flexfatal( "memory allocation failed in allocate_array()" );
+
+	return mem;
+	}
+
+
+/* all_lower - true if a string is all lower-case */
+
+int all_lower( str )
+register char *str;
+	{
+	while ( *str )
+		{
+		if ( ! isascii( (Char) *str ) || ! islower( *str ) )
+			return 0;
+		++str;
+		}
+
+	return 1;
+	}
+
+
+/* all_upper - true if a string is all upper-case */
+
+int all_upper( str )
+register char *str;
+	{
+	while ( *str )
+		{
+		if ( ! isascii( (Char) *str ) || ! isupper( *str ) )
+			return 0;
+		++str;
+		}
+
+	return 1;
+	}
+
+
+/* bubble - bubble sort an integer array in increasing order
+ *
+ * synopsis
+ *   int v[n], n;
+ *   void bubble( v, n );
+ *
+ * description
+ *   sorts the first n elements of array v and replaces them in
+ *   increasing order.
+ *
+ * passed
+ *   v - the array to be sorted
+ *   n - the number of elements of 'v' to be sorted
+ */
+
+void bubble( v, n )
+int v[], n;
+	{
+	register int i, j, k;
+
+	for ( i = n; i > 1; --i )
+		for ( j = 1; j < i; ++j )
+			if ( v[j] > v[j + 1] )	/* compare */
+				{
+				k = v[j];	/* exchange */
+				v[j] = v[j + 1];
+				v[j + 1] = k;
+				}
+	}
+
+
+/* check_char - checks a character to make sure it's within the range
+ *		we're expecting.  If not, generates fatal error message
+ *		and exits.
+ */
+
+void check_char( c )
+int c;
+	{
+	if ( c >= CSIZE )
+		lerrsf( "bad character '%s' detected in check_char()",
+			readable_form( c ) );
+
+	if ( c >= csize )
+		lerrsf( "scanner requires -8 flag to use the character '%s'",
+			readable_form( c ) );
+	}
+
+
+
+/* clower - replace upper-case letter to lower-case */
+
+Char clower( c )
+register int c;
+	{
+	return (Char) ((isascii( c ) && isupper( c )) ? tolower( c ) : c);
+	}
+
+
+/* copy_string - returns a dynamically allocated copy of a string */
+
+char *copy_string( str )
+register char *str;
+	{
+	register char *c;
+	char *copy;
+
+	/* find length */
+	for ( c = str; *c; ++c )
+		;
+
+	copy = (char *) flex_alloc( (c - str + 1) * sizeof( char ) );
+
+	if ( copy == NULL )
+		flexfatal( "dynamic memory failure in copy_string()" );
+
+	for ( c = copy; (*c++ = *str++); )
+		;
+
+	return copy;
+	}
+
+
+/* copy_unsigned_string -
+ *    returns a dynamically allocated copy of a (potentially) unsigned string
+ */
+
+Char *copy_unsigned_string( str )
+register Char *str;
+	{
+	register Char *c;
+	Char *copy;
+
+	/* find length */
+	for ( c = str; *c; ++c )
+		;
+
+	copy = allocate_Character_array( c - str + 1 );
+
+	for ( c = copy; (*c++ = *str++); )
+		;
+
+	return copy;
+	}
+
+
+/* cshell - shell sort a character array in increasing order
+ *
+ * synopsis
+ *
+ *   Char v[n];
+ *   int n, special_case_0;
+ *   cshell( v, n, special_case_0 );
+ *
+ * description
+ *   Does a shell sort of the first n elements of array v.
+ *   If special_case_0 is true, then any element equal to 0
+ *   is instead assumed to have infinite weight.
+ *
+ * passed
+ *   v - array to be sorted
+ *   n - number of elements of v to be sorted
+ */
+
+void cshell( v, n, special_case_0 )
+Char v[];
+int n, special_case_0;
+	{
+	int gap, i, j, jg;
+	Char k;
+
+	for ( gap = n / 2; gap > 0; gap = gap / 2 )
+		for ( i = gap; i < n; ++i )
+			for ( j = i - gap; j >= 0; j = j - gap )
+				{
+				jg = j + gap;
+
+				if ( special_case_0 )
+					{
+					if ( v[jg] == 0 )
+						break;
+
+					else if ( v[j] != 0 && v[j] <= v[jg] )
+						break;
+					}
+
+				else if ( v[j] <= v[jg] )
+					break;
+
+				k = v[j];
+				v[j] = v[jg];
+				v[jg] = k;
+				}
+	}
+
+
+/* dataend - finish up a block of data declarations */
+
+void dataend()
+	{
+	if ( datapos > 0 )
+		dataflush();
+
+	/* add terminator for initialization; { for vi */
+	puts( "    } ;\n" );
+
+	dataline = 0;
+	datapos = 0;
+	}
+
+
+/* dataflush - flush generated data statements */
+
+void dataflush()
+	{
+	putchar( '\n' );
+
+	if ( ++dataline >= NUMDATALINES )
+		{
+		/* Put out a blank line so that the table is grouped into
+		 * large blocks that enable the user to find elements easily.
+		 */
+		putchar( '\n' );
+		dataline = 0;
+		}
+
+	/* Reset the number of characters written on the current line. */
+	datapos = 0;
+	}
+
+
+/* flexerror - report an error message and terminate */
+
+void flexerror( msg )
+char msg[];
+	{
+	fprintf( stderr, "%s: %s\n", program_name, msg );
+	flexend( 1 );
+	}
+
+
+/* flexfatal - report a fatal error message and terminate */
+
+void flexfatal( msg )
+char msg[];
+	{
+	fprintf( stderr, "%s: fatal internal error, %s\n", program_name, msg );
+	exit( 1 );
+	}
+
+
+/* lerrif - report an error message formatted with one integer argument */
+
+void lerrif( msg, arg )
+char msg[];
+int arg;
+	{
+	char errmsg[MAXLINE];
+	(void) sprintf( errmsg, msg, arg );
+	flexerror( errmsg );
+	}
+
+
+/* lerrsf - report an error message formatted with one string argument */
+
+void lerrsf( msg, arg )
+char msg[], arg[];
+	{
+	char errmsg[MAXLINE];
+
+	(void) sprintf( errmsg, msg, arg );
+	flexerror( errmsg );
+	}
+
+
+/* htoi - convert a hexadecimal digit string to an integer value */
+
+int htoi( str )
+Char str[];
+	{
+	unsigned int result;
+
+	(void) sscanf( (char *) str, "%x", &result );
+
+	return result;
+	}
+
+
+/* is_hex_digit - returns true if a character is a valid hex digit, false
+ *		  otherwise
+ */
+
+int is_hex_digit( ch )
+int ch;
+	{
+	if ( isdigit( ch ) )
+		return 1;
+
+	switch ( clower( ch ) )
+		{
+		case 'a':
+		case 'b':
+		case 'c':
+		case 'd':
+		case 'e':
+		case 'f':
+			return 1;
+
+		default:
+			return 0;
+		}
+	}
+
+
+/* line_directive_out - spit out a "# line" statement */
+
+void line_directive_out( output_file )
+FILE *output_file;
+	{
+	if ( infilename && gen_line_dirs )
+		{
+		char directive[MAXLINE];
+		sprintf( directive, "# line %d \"%s\"\n", linenum, infilename );
+
+		/* If output_file is nil then we should put the directive in
+		 * the accumulated actions.
+		 */
+		if ( output_file )
+			fputs( directive, output_file );
+		else
+			add_action( directive );
+		}
+	}
+
+
+/* mark_defs1 - mark the current position in the action array as
+ *               representing where the user's section 1 definitions end
+ *		 and the prolog begins
+ */
+void mark_defs1()
+	{
+	defs1_offset = 0;
+	action_array[action_index++] = '\0';
+	action_offset = prolog_offset = action_index;
+	action_array[action_index] = '\0';
+	}
+
+
+/* mark_prolog - mark the current position in the action array as
+ *               representing the end of the action prolog
+ */
+void mark_prolog()
+	{
+	action_array[action_index++] = '\0';
+	action_offset = action_index;
+	action_array[action_index] = '\0';
+	}
+
+
+/* mk2data - generate a data statement for a two-dimensional array
+ *
+ * Generates a data statement initializing the current 2-D array to "value".
+ */
+void mk2data( value )
+int value;
+	{
+	if ( datapos >= NUMDATAITEMS )
+		{
+		putchar( ',' );
+		dataflush();
+		}
+
+	if ( datapos == 0 )
+		/* Indent. */
+		fputs( "    ", stdout );
+
+	else
+		putchar( ',' );
+
+	++datapos;
+
+	printf( "%5d", value );
+	}
+
+
+/* mkdata - generate a data statement
+ *
+ * Generates a data statement initializing the current array element to
+ * "value".
+ */
+void mkdata( value )
+int value;
+	{
+	if ( datapos >= NUMDATAITEMS )
+		{
+		putchar( ',' );
+		dataflush();
+		}
+
+	if ( datapos == 0 )
+		/* Indent. */
+		fputs( "    ", stdout );
+	else
+		putchar( ',' );
+
+	++datapos;
+
+	printf( "%5d", value );
+	}
+
+
+/* myctoi - return the integer represented by a string of digits */
+
+int myctoi( array )
+char array[];
+	{
+	int val = 0;
+
+	(void) sscanf( array, "%d", &val );
+
+	return val;
+	}
+
+
+/* myesc - return character corresponding to escape sequence */
+
+Char myesc( array )
+Char array[];
+	{
+	Char c, esc_char;
+
+	switch ( array[1] )
+		{
+		case 'b': return '\b';
+		case 'f': return '\f';
+		case 'n': return '\n';
+		case 'r': return '\r';
+		case 't': return '\t';
+
+#ifdef __STDC__
+		case 'a': return '\a';
+		case 'v': return '\v';
+#else
+		case 'a': return '\007';
+		case 'v': return '\013';
+#endif
+
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			{ /* \<octal> */
+			int sptr = 1;
+
+			while ( isascii( array[sptr] ) &&
+				isdigit( array[sptr] ) )
+				/* Don't increment inside loop control
+				 * because if isdigit() is a macro it might
+				 * expand into multiple increments ...
+				 */
+				++sptr;
+
+			c = array[sptr];
+			array[sptr] = '\0';
+
+			esc_char = otoi( array + 1 );
+
+			array[sptr] = c;
+
+			return esc_char;
+			}
+
+		case 'x':
+			{ /* \x<hex> */
+			int sptr = 2;
+
+			while ( isascii( array[sptr] ) &&
+				is_hex_digit( (char) array[sptr] ) )
+				/* Don't increment inside loop control
+				 * because if isdigit() is a macro it might
+				 * expand into multiple increments ...
+				 */
+				++sptr;
+
+			c = array[sptr];
+			array[sptr] = '\0';
+
+			esc_char = htoi( array + 2 );
+
+			array[sptr] = c;
+
+			return esc_char;
+			}
+
+		default:
+			return array[1];
+		}
+	}
+
+
+/* otoi - convert an octal digit string to an integer value */
+
+int otoi( str )
+Char str[];
+	{
+	unsigned int result;
+
+	(void) sscanf( (char *) str, "%o", &result );
+	return result;
+	}
+
+
+/* readable_form - return the the human-readable form of a character
+ *
+ * The returned string is in static storage.
+ */
+
+char *readable_form( c )
+register int c;
+	{
+	static char rform[10];
+
+	if ( (c >= 0 && c < 32) || c >= 127 )
+		{
+		switch ( c )
+			{
+			case '\b': return "\\b";
+			case '\f': return "\\f";
+			case '\n': return "\\n";
+			case '\r': return "\\r";
+			case '\t': return "\\t";
+
+#ifdef __STDC__
+			case '\a': return "\\a";
+			case '\v': return "\\v";
+#endif
+
+			default:
+				(void) sprintf( rform, "\\%.3o",
+						(unsigned int) c );
+				return rform;
+			}
+		}
+
+	else if ( c == ' ' )
+		return "' '";
+
+	else
+		{
+		rform[0] = c;
+		rform[1] = '\0';
+
+		return rform;
+		}
+	}
+
+
+/* reallocate_array - increase the size of a dynamic array */
+
+void *reallocate_array( array, size, element_size )
+void *array;
+int size, element_size;
+	{
+	register void *new_array;
+
+	/* Same worry as in allocate_array(): */
+	if ( size * element_size <= 0 )
+		flexfatal(
+			"attempt to increase array size by less than 1 byte" );
+
+	new_array = flex_realloc( array, size * element_size );
+
+	if ( new_array == NULL )
+		flexfatal( "attempt to increase array size failed" );
+
+	return new_array;
+	}
+
+
+/* skelout - write out one section of the skeleton file
+ *
+ * Description
+ *    Copies skelfile or skel array to stdout until a line beginning with
+ *    "%%" or EOF is found.
+ */
+void skelout()
+	{
+	char buf_storage[MAXLINE];
+	char *buf = buf_storage;
+	int do_copy = 1;
+
+	/* Loop pulling lines either from the skelfile, if we're using
+	 * one, or from the skel[] array.
+	 */
+	while ( skelfile ?
+		(fgets( buf, MAXLINE, skelfile ) != NULL) :
+		((buf = skel[skel_ind++]) != 0) )
+		{ /* copy from skel array */
+		if ( buf[0] == '%' )
+			{ /* control line */
+			switch ( buf[1] )
+				{
+				case '%':
+					return;
+
+				case '+':
+					do_copy = C_plus_plus;
+					break;
+
+				case '-':
+					do_copy = ! C_plus_plus;
+					break;
+
+				case '*':
+					do_copy = 1;
+					break;
+
+				default:
+					flexfatal(
+						"bad line in skeleton file" );
+				}
+			}
+
+		else if ( do_copy )
+			{
+			if ( skelfile )
+				/* Skeleton file reads include final
+				 * newline, skel[] array does not.
+				 */
+				fputs( buf, stdout );
+			else
+				printf( "%s\n", buf );
+			}
+		}
+	}
+
+
+/* transition_struct_out - output a yy_trans_info structure
+ *
+ * outputs the yy_trans_info structure with the two elements, element_v and
+ * element_n.  Formats the output with spaces and carriage returns.
+ */
+
+void transition_struct_out( element_v, element_n )
+int element_v, element_n;
+	{
+	printf( "%7d, %5d,", element_v, element_n );
+
+	datapos += TRANS_STRUCT_PRINT_LENGTH;
+
+	if ( datapos >= 75 )
+		{
+		putchar( '\n' );
+
+		if ( ++dataline % 10 == 0 )
+			putchar( '\n' );
+
+		datapos = 0;
+		}
+	}
+
+
+/* The following is only needed when building flex's parser using certain
+ * broken versions of bison.
+ */
+void *yy_flex_xmalloc( size )
+int size;
+	{
+	void *result = flex_alloc( size );
+
+	if ( ! result  )
+		flexfatal( "memory allocation failed in yy_flex_xmalloc()" );
+
+	return result;
+	}
+
+
+/* zero_out - set a region of memory to 0
+ *
+ * Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
+ */
+
+void zero_out( region_ptr, size_in_bytes )
+char *region_ptr;
+int size_in_bytes;
+	{
+	register char *rp, *rp_end;
+
+	rp = region_ptr;
+	rp_end = region_ptr + size_in_bytes;
+
+	while ( rp < rp_end )
+		*rp++ = 0;
+	}
diff --git a/usr.bin/lex/mkskel.sh b/usr.bin/lex/mkskel.sh
new file mode 100755
index 000000000000..ffc7c7fe9aab
--- /dev/null
+++ b/usr.bin/lex/mkskel.sh
@@ -0,0 +1,16 @@
+#! /bin/sh
+
+cat <<!
+/* File created from flex.skel via mkskel.sh */
+
+#include "flexdef.h"
+
+char *skel[] = {
+!
+
+sed 's/\\/&&/g' $* | sed 's/"/\\"/g' | sed 's/.*/  "&",/'
+
+cat <<!
+  0
+};
+!
diff --git a/usr.bin/lex/nfa.c b/usr.bin/lex/nfa.c
new file mode 100644
index 000000000000..be041fd4032c
--- /dev/null
+++ b/usr.bin/lex/nfa.c
@@ -0,0 +1,709 @@
+/* nfa - NFA construction routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/nfa.c,v 1.2 94/08/03 11:13:29 vern Exp $ */
+
+#include "flexdef.h"
+
+
+/* declare functions that have forward references */
+
+int dupmachine PROTO((int));
+void mkxtion PROTO((int, int));
+
+
+/* add_accept - add an accepting state to a machine
+ *
+ * accepting_number becomes mach's accepting number.
+ */
+
+void add_accept( mach, accepting_number )
+int mach, accepting_number;
+	{
+	/* Hang the accepting number off an epsilon state.  if it is associated
+	 * with a state that has a non-epsilon out-transition, then the state
+	 * will accept BEFORE it makes that transition, i.e., one character
+	 * too soon.
+	 */
+
+	if ( transchar[finalst[mach]] == SYM_EPSILON )
+		accptnum[finalst[mach]] = accepting_number;
+
+	else
+		{
+		int astate = mkstate( SYM_EPSILON );
+		accptnum[astate] = accepting_number;
+		(void) link_machines( mach, astate );
+		}
+	}
+
+
+/* copysingl - make a given number of copies of a singleton machine
+ *
+ * synopsis
+ *
+ *   newsng = copysingl( singl, num );
+ *
+ *     newsng - a new singleton composed of num copies of singl
+ *     singl  - a singleton machine
+ *     num    - the number of copies of singl to be present in newsng
+ */
+
+int copysingl( singl, num )
+int singl, num;
+	{
+	int copy, i;
+
+	copy = mkstate( SYM_EPSILON );
+
+	for ( i = 1; i <= num; ++i )
+		copy = link_machines( copy, dupmachine( singl ) );
+
+	return copy;
+	}
+
+
+/* dumpnfa - debugging routine to write out an nfa */
+
+void dumpnfa( state1 )
+int state1;
+
+	{
+	int sym, tsp1, tsp2, anum, ns;
+
+	fprintf( stderr,
+		"\n\n********** beginning dump of nfa with start state %d\n",
+		state1 );
+
+	/* We probably should loop starting at firstst[state1] and going to
+	 * lastst[state1], but they're not maintained properly when we "or"
+	 * all of the rules together.  So we use our knowledge that the machine
+	 * starts at state 1 and ends at lastnfa.
+	 */
+
+	/* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */
+	for ( ns = 1; ns <= lastnfa; ++ns )
+		{
+		fprintf( stderr, "state # %4d\t", ns );
+
+		sym = transchar[ns];
+		tsp1 = trans1[ns];
+		tsp2 = trans2[ns];
+		anum = accptnum[ns];
+
+		fprintf( stderr, "%3d:  %4d, %4d", sym, tsp1, tsp2 );
+
+		if ( anum != NIL )
+			fprintf( stderr, "  [%d]", anum );
+
+		fprintf( stderr, "\n" );
+		}
+
+	fprintf( stderr, "********** end of dump\n" );
+	}
+
+
+/* dupmachine - make a duplicate of a given machine
+ *
+ * synopsis
+ *
+ *   copy = dupmachine( mach );
+ *
+ *     copy - holds duplicate of mach
+ *     mach - machine to be duplicated
+ *
+ * note that the copy of mach is NOT an exact duplicate; rather, all the
+ * transition states values are adjusted so that the copy is self-contained,
+ * as the original should have been.
+ *
+ * also note that the original MUST be contiguous, with its low and high
+ * states accessible by the arrays firstst and lastst
+ */
+
+int dupmachine( mach )
+int mach;
+	{
+	int i, init, state_offset;
+	int state = 0;
+	int last = lastst[mach];
+
+	for ( i = firstst[mach]; i <= last; ++i )
+		{
+		state = mkstate( transchar[i] );
+
+		if ( trans1[i] != NO_TRANSITION )
+			{
+			mkxtion( finalst[state], trans1[i] + state - i );
+
+			if ( transchar[i] == SYM_EPSILON &&
+			     trans2[i] != NO_TRANSITION )
+				mkxtion( finalst[state],
+					trans2[i] + state - i );
+			}
+
+		accptnum[state] = accptnum[i];
+		}
+
+	if ( state == 0 )
+		flexfatal( "empty machine in dupmachine()" );
+
+	state_offset = state - i + 1;
+
+	init = mach + state_offset;
+	firstst[init] = firstst[mach] + state_offset;
+	finalst[init] = finalst[mach] + state_offset;
+	lastst[init] = lastst[mach] + state_offset;
+
+	return init;
+	}
+
+
+/* finish_rule - finish up the processing for a rule
+ *
+ * An accepting number is added to the given machine.  If variable_trail_rule
+ * is true then the rule has trailing context and both the head and trail
+ * are variable size.  Otherwise if headcnt or trailcnt is non-zero then
+ * the machine recognizes a pattern with trailing context and headcnt is
+ * the number of characters in the matched part of the pattern, or zero
+ * if the matched part has variable length.  trailcnt is the number of
+ * trailing context characters in the pattern, or zero if the trailing
+ * context has variable length.
+ */
+
+void finish_rule( mach, variable_trail_rule, headcnt, trailcnt )
+int mach, variable_trail_rule, headcnt, trailcnt;
+	{
+	char action_text[MAXLINE];
+
+	add_accept( mach, num_rules );
+
+	/* We did this in new_rule(), but it often gets the wrong
+	 * number because we do it before we start parsing the current rule.
+	 */
+	rule_linenum[num_rules] = linenum;
+
+	/* If this is a continued action, then the line-number has already
+	 * been updated, giving us the wrong number.
+	 */
+	if ( continued_action )
+		--rule_linenum[num_rules];
+
+	sprintf( action_text, "case %d:\n", num_rules );
+	add_action( action_text );
+
+	if ( variable_trail_rule )
+		{
+		rule_type[num_rules] = RULE_VARIABLE;
+
+		if ( performance_report > 0 )
+			fprintf( stderr,
+				"Variable trailing context rule at line %d\n",
+				rule_linenum[num_rules] );
+
+		variable_trailing_context_rules = true;
+		}
+
+	else
+		{
+		rule_type[num_rules] = RULE_NORMAL;
+
+		if ( headcnt > 0 || trailcnt > 0 )
+			{
+			/* Do trailing context magic to not match the trailing
+			 * characters.
+			 */
+			char *scanner_cp = "yy_c_buf_p = yy_cp";
+			char *scanner_bp = "yy_bp";
+
+			add_action(
+	"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */\n" );
+
+			if ( headcnt > 0 )
+				{
+				sprintf( action_text, "%s = %s + %d;\n",
+				scanner_cp, scanner_bp, headcnt );
+				add_action( action_text );
+				}
+
+			else
+				{
+				sprintf( action_text, "%s -= %d;\n",
+					scanner_cp, trailcnt );
+				add_action( action_text );
+				}
+
+			add_action(
+			"YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
+			}
+		}
+
+	/* Okay, in the action code at this point yytext and yyleng have
+	 * their proper final values for this rule, so here's the point
+	 * to do any user action.  But don't do it for continued actions,
+	 * as that'll result in multiple YY_USER_ACTION's.
+	 */
+	if ( ! continued_action )
+		add_action( "YY_USER_ACTION\n" );
+
+	line_directive_out( (FILE *) 0 );
+	}
+
+
+/* link_machines - connect two machines together
+ *
+ * synopsis
+ *
+ *   new = link_machines( first, last );
+ *
+ *     new    - a machine constructed by connecting first to last
+ *     first  - the machine whose successor is to be last
+ *     last   - the machine whose predecessor is to be first
+ *
+ * note: this routine concatenates the machine first with the machine
+ *  last to produce a machine new which will pattern-match first first
+ *  and then last, and will fail if either of the sub-patterns fails.
+ *  FIRST is set to new by the operation.  last is unmolested.
+ */
+
+int link_machines( first, last )
+int first, last;
+	{
+	if ( first == NIL )
+		return last;
+
+	else if ( last == NIL )
+		return first;
+
+	else
+		{
+		mkxtion( finalst[first], last );
+		finalst[first] = finalst[last];
+		lastst[first] = MAX( lastst[first], lastst[last] );
+		firstst[first] = MIN( firstst[first], firstst[last] );
+
+		return first;
+		}
+	}
+
+
+/* mark_beginning_as_normal - mark each "beginning" state in a machine
+ *                            as being a "normal" (i.e., not trailing context-
+ *                            associated) states
+ *
+ * The "beginning" states are the epsilon closure of the first state
+ */
+
+void mark_beginning_as_normal( mach )
+register int mach;
+	{
+	switch ( state_type[mach] )
+		{
+		case STATE_NORMAL:
+			/* Oh, we've already visited here. */
+			return;
+
+		case STATE_TRAILING_CONTEXT:
+			state_type[mach] = STATE_NORMAL;
+
+			if ( transchar[mach] == SYM_EPSILON )
+				{
+				if ( trans1[mach] != NO_TRANSITION )
+					mark_beginning_as_normal(
+						trans1[mach] );
+
+				if ( trans2[mach] != NO_TRANSITION )
+					mark_beginning_as_normal(
+						trans2[mach] );
+				}
+			break;
+
+		default:
+			flexerror(
+				"bad state type in mark_beginning_as_normal()" );
+			break;
+		}
+	}
+
+
+/* mkbranch - make a machine that branches to two machines
+ *
+ * synopsis
+ *
+ *   branch = mkbranch( first, second );
+ *
+ *     branch - a machine which matches either first's pattern or second's
+ *     first, second - machines whose patterns are to be or'ed (the | operator)
+ *
+ * Note that first and second are NEITHER destroyed by the operation.  Also,
+ * the resulting machine CANNOT be used with any other "mk" operation except
+ * more mkbranch's.  Compare with mkor()
+ */
+
+int mkbranch( first, second )
+int first, second;
+	{
+	int eps;
+
+	if ( first == NO_TRANSITION )
+		return second;
+
+	else if ( second == NO_TRANSITION )
+		return first;
+
+	eps = mkstate( SYM_EPSILON );
+
+	mkxtion( eps, first );
+	mkxtion( eps, second );
+
+	return eps;
+	}
+
+
+/* mkclos - convert a machine into a closure
+ *
+ * synopsis
+ *   new = mkclos( state );
+ *
+ * new - a new state which matches the closure of "state"
+ */
+
+int mkclos( state )
+int state;
+	{
+	return mkopt( mkposcl( state ) );
+	}
+
+
+/* mkopt - make a machine optional
+ *
+ * synopsis
+ *
+ *   new = mkopt( mach );
+ *
+ *     new  - a machine which optionally matches whatever mach matched
+ *     mach - the machine to make optional
+ *
+ * notes:
+ *     1. mach must be the last machine created
+ *     2. mach is destroyed by the call
+ */
+
+int mkopt( mach )
+int mach;
+	{
+	int eps;
+
+	if ( ! SUPER_FREE_EPSILON(finalst[mach]) )
+		{
+		eps = mkstate( SYM_EPSILON );
+		mach = link_machines( mach, eps );
+		}
+
+	/* Can't skimp on the following if FREE_EPSILON(mach) is true because
+	 * some state interior to "mach" might point back to the beginning
+	 * for a closure.
+	 */
+	eps = mkstate( SYM_EPSILON );
+	mach = link_machines( eps, mach );
+
+	mkxtion( mach, finalst[mach] );
+
+	return mach;
+	}
+
+
+/* mkor - make a machine that matches either one of two machines
+ *
+ * synopsis
+ *
+ *   new = mkor( first, second );
+ *
+ *     new - a machine which matches either first's pattern or second's
+ *     first, second - machines whose patterns are to be or'ed (the | operator)
+ *
+ * note that first and second are both destroyed by the operation
+ * the code is rather convoluted because an attempt is made to minimize
+ * the number of epsilon states needed
+ */
+
+int mkor( first, second )
+int first, second;
+	{
+	int eps, orend;
+
+	if ( first == NIL )
+		return second;
+
+	else if ( second == NIL )
+		return first;
+
+	else
+		{
+		/* See comment in mkopt() about why we can't use the first
+		 * state of "first" or "second" if they satisfy "FREE_EPSILON".
+		 */
+		eps = mkstate( SYM_EPSILON );
+
+		first = link_machines( eps, first );
+
+		mkxtion( first, second );
+
+		if ( SUPER_FREE_EPSILON(finalst[first]) &&
+		     accptnum[finalst[first]] == NIL )
+			{
+			orend = finalst[first];
+			mkxtion( finalst[second], orend );
+			}
+
+		else if ( SUPER_FREE_EPSILON(finalst[second]) &&
+			  accptnum[finalst[second]] == NIL )
+			{
+			orend = finalst[second];
+			mkxtion( finalst[first], orend );
+			}
+
+		else
+			{
+			eps = mkstate( SYM_EPSILON );
+
+			first = link_machines( first, eps );
+			orend = finalst[first];
+
+			mkxtion( finalst[second], orend );
+			}
+		}
+
+	finalst[first] = orend;
+	return first;
+	}
+
+
+/* mkposcl - convert a machine into a positive closure
+ *
+ * synopsis
+ *   new = mkposcl( state );
+ *
+ *    new - a machine matching the positive closure of "state"
+ */
+
+int mkposcl( state )
+int state;
+	{
+	int eps;
+
+	if ( SUPER_FREE_EPSILON(finalst[state]) )
+		{
+		mkxtion( finalst[state], state );
+		return state;
+		}
+
+	else
+		{
+		eps = mkstate( SYM_EPSILON );
+		mkxtion( eps, state );
+		return link_machines( state, eps );
+		}
+	}
+
+
+/* mkrep - make a replicated machine
+ *
+ * synopsis
+ *   new = mkrep( mach, lb, ub );
+ *
+ *    new - a machine that matches whatever "mach" matched from "lb"
+ *          number of times to "ub" number of times
+ *
+ * note
+ *   if "ub" is INFINITY then "new" matches "lb" or more occurrences of "mach"
+ */
+
+int mkrep( mach, lb, ub )
+int mach, lb, ub;
+	{
+	int base_mach, tail, copy, i;
+
+	base_mach = copysingl( mach, lb - 1 );
+
+	if ( ub == INFINITY )
+		{
+		copy = dupmachine( mach );
+		mach = link_machines( mach,
+		link_machines( base_mach, mkclos( copy ) ) );
+		}
+
+	else
+		{
+		tail = mkstate( SYM_EPSILON );
+
+		for ( i = lb; i < ub; ++i )
+			{
+			copy = dupmachine( mach );
+			tail = mkopt( link_machines( copy, tail ) );
+			}
+
+		mach = link_machines( mach, link_machines( base_mach, tail ) );
+		}
+
+	return mach;
+	}
+
+
+/* mkstate - create a state with a transition on a given symbol
+ *
+ * synopsis
+ *
+ *   state = mkstate( sym );
+ *
+ *     state - a new state matching sym
+ *     sym   - the symbol the new state is to have an out-transition on
+ *
+ * note that this routine makes new states in ascending order through the
+ * state array (and increments LASTNFA accordingly).  The routine DUPMACHINE
+ * relies on machines being made in ascending order and that they are
+ * CONTIGUOUS.  Change it and you will have to rewrite DUPMACHINE (kludge
+ * that it admittedly is)
+ */
+
+int mkstate( sym )
+int sym;
+	{
+	if ( ++lastnfa >= current_mns )
+		{
+		if ( (current_mns += MNS_INCREMENT) >= MAXIMUM_MNS )
+			lerrif(
+			"input rules are too complicated (>= %d NFA states)",
+				current_mns );
+
+		++num_reallocs;
+
+		firstst = reallocate_integer_array( firstst, current_mns );
+		lastst = reallocate_integer_array( lastst, current_mns );
+		finalst = reallocate_integer_array( finalst, current_mns );
+		transchar = reallocate_integer_array( transchar, current_mns );
+		trans1 = reallocate_integer_array( trans1, current_mns );
+		trans2 = reallocate_integer_array( trans2, current_mns );
+		accptnum = reallocate_integer_array( accptnum, current_mns );
+		assoc_rule =
+			reallocate_integer_array( assoc_rule, current_mns );
+		state_type =
+			reallocate_integer_array( state_type, current_mns );
+		}
+
+	firstst[lastnfa] = lastnfa;
+	finalst[lastnfa] = lastnfa;
+	lastst[lastnfa] = lastnfa;
+	transchar[lastnfa] = sym;
+	trans1[lastnfa] = NO_TRANSITION;
+	trans2[lastnfa] = NO_TRANSITION;
+	accptnum[lastnfa] = NIL;
+	assoc_rule[lastnfa] = num_rules;
+	state_type[lastnfa] = current_state_type;
+
+	/* Fix up equivalence classes base on this transition.  Note that any
+	 * character which has its own transition gets its own equivalence
+	 * class.  Thus only characters which are only in character classes
+	 * have a chance at being in the same equivalence class.  E.g. "a|b"
+	 * puts 'a' and 'b' into two different equivalence classes.  "[ab]"
+	 * puts them in the same equivalence class (barring other differences
+	 * elsewhere in the input).
+	 */
+
+	if ( sym < 0 )
+		{
+		/* We don't have to update the equivalence classes since
+		 * that was already done when the ccl was created for the
+		 * first time.
+		 */
+		}
+
+	else if ( sym == SYM_EPSILON )
+		++numeps;
+
+	else
+		{
+		check_char( sym );
+
+		if ( useecs )
+			/* Map NUL's to csize. */
+			mkechar( sym ? sym : csize, nextecm, ecgroup );
+		}
+
+	return lastnfa;
+	}
+
+
+/* mkxtion - make a transition from one state to another
+ *
+ * synopsis
+ *
+ *   mkxtion( statefrom, stateto );
+ *
+ *     statefrom - the state from which the transition is to be made
+ *     stateto   - the state to which the transition is to be made
+ */
+
+void mkxtion( statefrom, stateto )
+int statefrom, stateto;
+	{
+	if ( trans1[statefrom] == NO_TRANSITION )
+		trans1[statefrom] = stateto;
+
+	else if ( (transchar[statefrom] != SYM_EPSILON) ||
+		  (trans2[statefrom] != NO_TRANSITION) )
+		flexfatal( "found too many transitions in mkxtion()" );
+
+	else
+		{ /* second out-transition for an epsilon state */
+		++eps2;
+		trans2[statefrom] = stateto;
+		}
+	}
+
+/* new_rule - initialize for a new rule */
+
+void new_rule()
+	{
+	if ( ++num_rules >= current_max_rules )
+		{
+		++num_reallocs;
+		current_max_rules += MAX_RULES_INCREMENT;
+		rule_type = reallocate_integer_array( rule_type,
+							current_max_rules );
+		rule_linenum = reallocate_integer_array( rule_linenum,
+							current_max_rules );
+		rule_useful = reallocate_integer_array( rule_useful,
+							current_max_rules );
+		}
+
+	if ( num_rules > MAX_RULE )
+		lerrif( "too many rules (> %d)!", MAX_RULE );
+
+	rule_linenum[num_rules] = linenum;
+	rule_useful[num_rules] = false;
+	}
diff --git a/usr.bin/lex/parse.y b/usr.bin/lex/parse.y
new file mode 100644
index 000000000000..c14f2452ca4a
--- /dev/null
+++ b/usr.bin/lex/parse.y
@@ -0,0 +1,817 @@
+/* parse.y - parser for flex input */
+
+%token CHAR NUMBER SECTEND SCDECL XSCDECL WHITESPACE NAME PREVCCL EOF_OP
+
+%{
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.15 93/12/09 13:57:23 vern Exp $ */
+
+
+/* Some versions of bison are broken in that they use alloca() but don't
+ * declare it properly.  The following is the patented (just kidding!)
+ * #ifdef chud to fix the problem, courtesy of Francois Pinard.
+ */
+#ifdef YYBISON
+/* AIX requires this to be the first thing in the file.  */
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not __GNUC__ */
+#if HAVE_ALLOCA_H
+#include <alloca.h>
+#else /* not HAVE_ALLOCA_H */
+#ifdef _AIX
+ #pragma alloca
+#else /* not _AIX */
+char *alloca ();
+#endif /* not _AIX */
+#endif /* not HAVE_ALLOCA_H */
+#endif /* not __GNUC__ */
+#endif /* YYBISON */
+
+/* Bletch, ^^^^ that was ugly! */
+
+
+#include "flexdef.h"
+
+int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, actvp, rulelen;
+int trlcontxt, xcluflg, cclsorted, varlength, variable_trail_rule;
+int *active_ss;
+Char clower();
+void build_eof_action();
+void yyerror();
+
+static int madeany = false;  /* whether we've made the '.' character class */
+int previous_continued_action;	/* whether the previous rule's action was '|' */
+
+/* On some over-ambitious machines, such as DEC Alpha's, the default
+ * token type is "long" instead of "int"; this leads to problems with
+ * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
+ * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
+ * following should ensure that the default token type is "int".
+ */
+#define YYSTYPE int
+
+%}
+
+%%
+goal		:  initlex sect1 sect1end sect2 initforrule
+			{ /* add default rule */
+			int def_rule;
+
+			pat = cclinit();
+			cclnegate( pat );
+
+			def_rule = mkstate( -pat );
+
+			/* Remember the number of the default rule so we
+			 * don't generate "can't match" warnings for it.
+			 */
+			default_rule = num_rules;
+
+			finish_rule( def_rule, false, 0, 0 );
+
+			for ( i = 1; i <= lastsc; ++i )
+				scset[i] = mkbranch( scset[i], def_rule );
+
+			if ( spprdflt )
+				add_action(
+				"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
+			else
+				add_action( "ECHO" );
+
+			add_action( ";\n\tYY_BREAK\n" );
+			}
+		;
+
+initlex		:
+			{ /* initialize for processing rules */
+
+			/* Create default DFA start condition. */
+			scinstal( "INITIAL", false );
+
+			/* Initially, the start condition scoping is
+			 * "no start conditions active".
+			 */
+			actvp = 0;
+			}
+		;
+
+sect1		:  sect1 startconddecl WHITESPACE namelist1 '\n'
+		|
+		|  error '\n'
+			{ synerr( "unknown error processing section 1" ); }
+		;
+
+sect1end	:  SECTEND
+			{
+			/* We now know how many start conditions there
+			 * are, so create the "activity" map indicating
+			 * which conditions are active.
+			 */
+			active_ss = allocate_integer_array( lastsc + 1 );
+
+			for ( i = 1; i <= lastsc; ++i )
+				active_ss[i] = 0;
+			}
+		;
+
+startconddecl	:  SCDECL
+			{ xcluflg = false; }
+
+		|  XSCDECL
+			{ xcluflg = true; }
+		;
+
+namelist1	:  namelist1 WHITESPACE NAME
+			{ scinstal( nmstr, xcluflg ); }
+
+		|  NAME
+			{ scinstal( nmstr, xcluflg ); }
+
+		|  error
+			{ synerr( "bad start condition list" ); }
+		;
+
+sect2		:  sect2 initforrule flexrule '\n'
+		|
+		;
+
+initforrule	:
+			{
+			/* Initialize for a parse of one rule. */
+			trlcontxt = variable_trail_rule = varlength = false;
+			trailcnt = headcnt = rulelen = 0;
+			current_state_type = STATE_NORMAL;
+			previous_continued_action = continued_action;
+			new_rule();
+			}
+		;
+
+flexrule	:  scon '^' rule
+			{
+			pat = $3;
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt );
+
+			for ( i = 1; i <= actvp; ++i )
+				scbol[actvsc[i]] =
+					mkbranch( scbol[actvsc[i]], pat );
+
+			if ( ! bol_needed )
+				{
+				bol_needed = true;
+
+				if ( performance_report > 1 )
+					pinpoint_message( 
+			"'^' operator results in sub-optimal performance" );
+				}
+			}
+
+		|  scon rule
+			{
+			pat = $2;
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt );
+
+			for ( i = 1; i <= actvp; ++i )
+				scset[actvsc[i]] =
+					mkbranch( scset[actvsc[i]], pat );
+			}
+
+		|  '^' rule
+			{
+			pat = $2;
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt );
+
+			/* Add to all non-exclusive start conditions,
+			 * including the default (0) start condition.
+			 */
+
+			for ( i = 1; i <= lastsc; ++i )
+				if ( ! scxclu[i] )
+					scbol[i] = mkbranch( scbol[i], pat );
+
+			if ( ! bol_needed )
+				{
+				bol_needed = true;
+
+				if ( performance_report > 1 )
+					pinpoint_message(
+			"'^' operator results in sub-optimal performance" );
+				}
+			}
+
+		|  rule
+			{
+			pat = $1;
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt );
+
+			for ( i = 1; i <= lastsc; ++i )
+				if ( ! scxclu[i] )
+					scset[i] = mkbranch( scset[i], pat );
+			}
+
+		|  scon EOF_OP
+			{ build_eof_action(); }
+
+		|  EOF_OP
+			{
+			/* This EOF applies to all start conditions
+			 * which don't already have EOF actions.
+			 */
+			actvp = 0;
+
+			for ( i = 1; i <= lastsc; ++i )
+				if ( ! sceof[i] )
+					actvsc[++actvp] = i;
+
+			if ( actvp == 0 )
+				warn(
+			"all start conditions already have <<EOF>> rules" );
+
+			else
+				build_eof_action();
+			}
+
+		|  error
+			{ synerr( "unrecognized rule" ); }
+		;
+
+scon		:  '<' namelist2 '>'
+
+		|  '<' '*' '>'
+			{
+			actvp = 0;
+
+			for ( i = 1; i <= lastsc; ++i )
+				actvsc[++actvp] = i;
+			}
+		;
+
+namelist2	:  namelist2 ',' sconname
+
+		|  { actvp = 0; } sconname
+
+		|  error
+			{ synerr( "bad start condition list" ); }
+		;
+
+sconname	:  NAME
+			{
+			if ( (scnum = sclookup( nmstr )) == 0 )
+				format_pinpoint_message(
+					"undeclared start condition %s",
+					nmstr );
+			else
+				{
+				if ( ++actvp >= current_max_scs )
+					/* Some bozo has included multiple
+					 * instances of start condition names.
+					 */
+					pinpoint_message(
+				"too many start conditions in <> construct!" );
+
+				else
+					actvsc[actvp] = scnum;
+				}
+			}
+		;
+
+rule		:  re2 re
+			{
+			if ( transchar[lastst[$2]] != SYM_EPSILON )
+				/* Provide final transition \now/ so it
+				 * will be marked as a trailing context
+				 * state.
+				 */
+				$2 = link_machines( $2,
+						mkstate( SYM_EPSILON ) );
+
+			mark_beginning_as_normal( $2 );
+			current_state_type = STATE_NORMAL;
+
+			if ( previous_continued_action )
+				{
+				/* We need to treat this as variable trailing
+				 * context so that the backup does not happen
+				 * in the action but before the action switch
+				 * statement.  If the backup happens in the
+				 * action, then the rules "falling into" this
+				 * one's action will *also* do the backup,
+				 * erroneously.
+				 */
+				if ( ! varlength || headcnt != 0 )
+					warn(
+		"trailing context made variable due to preceding '|' action" );
+
+				/* Mark as variable. */
+				varlength = true;
+				headcnt = 0;
+				}
+
+			if ( lex_compat || (varlength && headcnt == 0) )
+				{ /* variable trailing context rule */
+				/* Mark the first part of the rule as the
+				 * accepting "head" part of a trailing
+				 * context rule.
+				 *
+				 * By the way, we didn't do this at the
+				 * beginning of this production because back
+				 * then current_state_type was set up for a
+				 * trail rule, and add_accept() can create
+				 * a new state ...
+				 */
+				add_accept( $1,
+					num_rules | YY_TRAILING_HEAD_MASK );
+				variable_trail_rule = true;
+				}
+			
+			else
+				trailcnt = rulelen;
+
+			$$ = link_machines( $1, $2 );
+			}
+
+		|  re2 re '$'
+			{ synerr( "trailing context used twice" ); }
+
+		|  re '$'
+			{
+			headcnt = 0;
+			trailcnt = 1;
+			rulelen = 1;
+			varlength = false;
+
+			current_state_type = STATE_TRAILING_CONTEXT;
+
+			if ( trlcontxt )
+				{
+				synerr( "trailing context used twice" );
+				$$ = mkstate( SYM_EPSILON );
+				}
+
+			else if ( previous_continued_action )
+				{
+				/* See the comment in the rule for "re2 re"
+				 * above.
+				 */
+				warn(
+		"trailing context made variable due to preceding '|' action" );
+
+				varlength = true;
+				}
+
+			if ( lex_compat || varlength )
+				{
+				/* Again, see the comment in the rule for
+				 * "re2 re" above.
+				 */
+				add_accept( $1,
+					num_rules | YY_TRAILING_HEAD_MASK );
+				variable_trail_rule = true;
+				}
+
+			trlcontxt = true;
+
+			eps = mkstate( SYM_EPSILON );
+			$$ = link_machines( $1,
+				link_machines( eps, mkstate( '\n' ) ) );
+			}
+
+		|  re
+			{
+			$$ = $1;
+
+			if ( trlcontxt )
+				{
+				if ( lex_compat || (varlength && headcnt == 0) )
+					/* Both head and trail are
+					 * variable-length.
+					 */
+					variable_trail_rule = true;
+				else
+					trailcnt = rulelen;
+				}
+			}
+		;
+
+
+re		:  re '|' series
+			{
+			varlength = true;
+			$$ = mkor( $1, $3 );
+			}
+
+		|  series
+			{ $$ = $1; }
+		;
+
+
+re2		:  re '/'
+			{
+			/* This rule is written separately so the
+			 * reduction will occur before the trailing
+			 * series is parsed.
+			 */
+
+			if ( trlcontxt )
+				synerr( "trailing context used twice" );
+			else
+				trlcontxt = true;
+
+			if ( varlength )
+				/* We hope the trailing context is
+				 * fixed-length.
+				 */
+				varlength = false;
+			else
+				headcnt = rulelen;
+
+			rulelen = 0;
+
+			current_state_type = STATE_TRAILING_CONTEXT;
+			$$ = $1;
+			}
+		;
+
+series		:  series singleton
+			{
+			/* This is where concatenation of adjacent patterns
+			 * gets done.
+			 */
+			$$ = link_machines( $1, $2 );
+			}
+
+		|  singleton
+			{ $$ = $1; }
+		;
+
+singleton	:  singleton '*'
+			{
+			varlength = true;
+
+			$$ = mkclos( $1 );
+			}
+
+		|  singleton '+'
+			{
+			varlength = true;
+			$$ = mkposcl( $1 );
+			}
+
+		|  singleton '?'
+			{
+			varlength = true;
+			$$ = mkopt( $1 );
+			}
+
+		|  singleton '{' NUMBER ',' NUMBER '}'
+			{
+			varlength = true;
+
+			if ( $3 > $5 || $3 < 0 )
+				{
+				synerr( "bad iteration values" );
+				$$ = $1;
+				}
+			else
+				{
+				if ( $3 == 0 )
+					{
+					if ( $5 <= 0 )
+						{
+						synerr(
+						"bad iteration values" );
+						$$ = $1;
+						}
+					else
+						$$ = mkopt(
+							mkrep( $1, 1, $5 ) );
+					}
+				else
+					$$ = mkrep( $1, $3, $5 );
+				}
+			}
+
+		|  singleton '{' NUMBER ',' '}'
+			{
+			varlength = true;
+
+			if ( $3 <= 0 )
+				{
+				synerr( "iteration value must be positive" );
+				$$ = $1;
+				}
+
+			else
+				$$ = mkrep( $1, $3, INFINITY );
+			}
+
+		|  singleton '{' NUMBER '}'
+			{
+			/* The singleton could be something like "(foo)",
+			 * in which case we have no idea what its length
+			 * is, so we punt here.
+			 */
+			varlength = true;
+
+			if ( $3 <= 0 )
+				{
+				synerr( "iteration value must be positive" );
+				$$ = $1;
+				}
+
+			else
+				$$ = link_machines( $1,
+						copysingl( $1, $3 - 1 ) );
+			}
+
+		|  '.'
+			{
+			if ( ! madeany )
+				{
+				/* Create the '.' character class. */
+				anyccl = cclinit();
+				ccladd( anyccl, '\n' );
+				cclnegate( anyccl );
+
+				if ( useecs )
+					mkeccl( ccltbl + cclmap[anyccl],
+						ccllen[anyccl], nextecm,
+						ecgroup, csize, csize );
+
+				madeany = true;
+				}
+
+			++rulelen;
+
+			$$ = mkstate( -anyccl );
+			}
+
+		|  fullccl
+			{
+			if ( ! cclsorted )
+				/* Sort characters for fast searching.  We
+				 * use a shell sort since this list could
+				 * be large.
+				 */
+				cshell( ccltbl + cclmap[$1], ccllen[$1], true );
+
+			if ( useecs )
+				mkeccl( ccltbl + cclmap[$1], ccllen[$1],
+					nextecm, ecgroup, csize, csize );
+
+			++rulelen;
+
+			$$ = mkstate( -$1 );
+			}
+
+		|  PREVCCL
+			{
+			++rulelen;
+
+			$$ = mkstate( -$1 );
+			}
+
+		|  '"' string '"'
+			{ $$ = $2; }
+
+		|  '(' re ')'
+			{ $$ = $2; }
+
+		|  CHAR
+			{
+			++rulelen;
+
+			if ( caseins && $1 >= 'A' && $1 <= 'Z' )
+				$1 = clower( $1 );
+
+			$$ = mkstate( $1 );
+			}
+		;
+
+fullccl		:  '[' ccl ']'
+			{ $$ = $2; }
+
+		|  '[' '^' ccl ']'
+			{
+			cclnegate( $3 );
+			$$ = $3;
+			}
+		;
+
+ccl		:  ccl CHAR '-' CHAR
+			{
+			if ( caseins )
+				{
+				if ( $2 >= 'A' && $2 <= 'Z' )
+					$2 = clower( $2 );
+				if ( $4 >= 'A' && $4 <= 'Z' )
+					$4 = clower( $4 );
+				}
+
+			if ( $2 > $4 )
+				synerr( "negative range in character class" );
+
+			else
+				{
+				for ( i = $2; i <= $4; ++i )
+					ccladd( $1, i );
+
+				/* Keep track if this ccl is staying in
+				 * alphabetical order.
+				 */
+				cclsorted = cclsorted && ($2 > lastchar);
+				lastchar = $4;
+				}
+
+			$$ = $1;
+			}
+
+		|  ccl CHAR
+			{
+			if ( caseins && $2 >= 'A' && $2 <= 'Z' )
+				$2 = clower( $2 );
+
+			ccladd( $1, $2 );
+			cclsorted = cclsorted && ($2 > lastchar);
+			lastchar = $2;
+			$$ = $1;
+			}
+
+		|
+			{
+			cclsorted = true;
+			lastchar = 0;
+			$$ = cclinit();
+			}
+		;
+
+string		:  string CHAR
+			{
+			if ( caseins && $2 >= 'A' && $2 <= 'Z' )
+				$2 = clower( $2 );
+
+			++rulelen;
+
+			$$ = link_machines( $1, mkstate( $2 ) );
+			}
+
+		|
+			{ $$ = mkstate( SYM_EPSILON ); }
+		;
+
+%%
+
+
+/* build_eof_action - build the "<<EOF>>" action for the active start
+ *                    conditions
+ */
+
+void build_eof_action()
+	{
+	register int i;
+	char action_text[MAXLINE];
+
+	for ( i = 1; i <= actvp; ++i )
+		{
+		if ( sceof[actvsc[i]] )
+			format_pinpoint_message(
+				"multiple <<EOF>> rules for start condition %s",
+				scname[actvsc[i]] );
+
+		else
+			{
+			sceof[actvsc[i]] = true;
+			sprintf( action_text, "case YY_STATE_EOF(%s):\n",
+			scname[actvsc[i]] );
+			add_action( action_text );
+			}
+		}
+
+	line_directive_out( (FILE *) 0 );
+
+	/* This isn't a normal rule after all - don't count it as
+	 * such, so we don't have any holes in the rule numbering
+	 * (which make generating "rule can never match" warnings
+	 * more difficult.
+	 */
+	--num_rules;
+	++num_eof_rules;
+	}
+
+
+/* format_synerr - write out formatted syntax error */
+
+void format_synerr( msg, arg )
+char msg[], arg[];
+	{
+	char errmsg[MAXLINE];
+
+	(void) sprintf( errmsg, msg, arg );
+	synerr( errmsg );
+	}
+
+
+/* synerr - report a syntax error */
+
+void synerr( str )
+char str[];
+	{
+	syntaxerror = true;
+	pinpoint_message( str );
+	}
+
+
+/* warn - report a warning, unless -w was given */
+
+void warn( str )
+char str[];
+	{
+	line_warning( str, linenum );
+	}
+
+/* format_pinpoint_message - write out a message formatted with one string,
+ *			     pinpointing its location
+ */
+
+void format_pinpoint_message( msg, arg )
+char msg[], arg[];
+	{
+	char errmsg[MAXLINE];
+
+	(void) sprintf( errmsg, msg, arg );
+	pinpoint_message( errmsg );
+	}
+
+
+/* pinpoint_message - write out a message, pinpointing its location */
+
+void pinpoint_message( str )
+char str[];
+	{
+	line_pinpoint( str, linenum );
+	}
+
+
+/* line_warning - report a warning at a given line, unless -w was given */
+
+void line_warning( str, line )
+char str[];
+int line;
+	{
+	char warning[MAXLINE];
+
+	if ( ! nowarn )
+		{
+		sprintf( warning, "warning, %s", str );
+		line_pinpoint( warning, line );
+		}
+	}
+
+
+/* line_pinpoint - write out a message, pinpointing it at the given line */
+
+void line_pinpoint( str, line )
+char str[];
+int line;
+	{
+	fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
+	}
+
+
+/* yyerror - eat up an error message from the parser;
+ *	     currently, messages are ignore
+ */
+
+void yyerror( msg )
+char msg[];
+	{
+	}
diff --git a/usr.bin/lex/scan.l b/usr.bin/lex/scan.l
new file mode 100644
index 000000000000..74b589c771ce
--- /dev/null
+++ b/usr.bin/lex/scan.l
@@ -0,0 +1,572 @@
+/* scan.l - scanner for flex input */
+
+%{
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: scan.l,v 1.2 94/01/04 14:33:09 vern Exp $ */
+
+#include "flexdef.h"
+#include "parse.h"
+
+#define ACTION_ECHO add_action( yytext )
+#define MARK_END_OF_PROLOG mark_prolog();
+
+#define YY_DECL \
+	int flexscan()
+
+#define RETURNCHAR \
+	yylval = (unsigned char) yytext[0]; \
+	return CHAR;
+
+#define RETURNNAME \
+	strcpy( nmstr, yytext ); \
+	return NAME;
+
+#define PUT_BACK_STRING(str, start) \
+	for ( i = strlen( str ) - 1; i >= start; --i ) \
+		unput((str)[i])
+
+#define CHECK_REJECT(str) \
+	if ( all_upper( str ) ) \
+		reject = true;
+
+#define CHECK_YYMORE(str) \
+	if ( all_lower( str ) ) \
+		yymore_used = true;
+%}
+
+%x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
+%x FIRSTCCL CCL ACTION RECOVER BRACEERROR C_COMMENT ACTION_COMMENT
+%x ACTION_STRING PERCENT_BRACE_ACTION USED_LIST CODEBLOCK_2
+
+WS		[ \t]+
+OPTWS		[ \t]*
+NOT_WS		[^ \t\n]
+
+NL		(\n|\r\n|\n\r)
+
+NAME		([a-z_][a-z_0-9-]*)
+NOT_NAME	[^a-z_*\n]+
+
+SCNAME		{NAME}
+
+ESCSEQ		(\\([^\n]|[0-9]{1,3}|x[0-9a-f]{1,2}))
+
+FIRST_CCL_CHAR	([^\\\n]|{ESCSEQ})
+CCL_CHAR	([^\\\n\]]|{ESCSEQ})
+
+%%
+	static int bracelevel, didadef, indented_code, checking_used;
+
+	int doing_codeblock = false;
+	int i;
+	Char nmdef[MAXLINE], myesc();
+
+
+^{WS}			indented_code = true; BEGIN(CODEBLOCK);
+^"/*"			ACTION_ECHO; BEGIN(C_COMMENT);
+^"%s"{NAME}?		return SCDECL;
+^"%x"{NAME}?		return XSCDECL;
+^"%{".*{NL}		{
+			++linenum;
+			line_directive_out( (FILE *) 0 );
+			indented_code = false;
+			BEGIN(CODEBLOCK);
+			}
+
+{WS}			return WHITESPACE;
+
+^"%%".*			{
+			sectnum = 2;
+			bracelevel = 0;
+			mark_defs1();
+			line_directive_out( (FILE *) 0 );
+			BEGIN(SECT2PROLOG);
+			return SECTEND;
+			}
+
+^"%pointer".*{NL}	{
+			if ( lex_compat )
+				warn( "%pointer incompatible with -l option" );
+			else
+				yytext_is_array = false;
+			++linenum;
+			}
+^"%array".*{NL}		{
+			if ( C_plus_plus )
+				warn( "%array incompatible with -+ option" );
+			else
+				yytext_is_array = true;
+			++linenum;
+			}
+
+^"%used"		{
+			warn( "%used/%unused have been deprecated" );
+			checking_used = REALLY_USED; BEGIN(USED_LIST);
+			}
+^"%unused"		{
+			warn( "%used/%unused have been deprecated" );
+			checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
+			}
+
+
+^"%"[aceknopr]{OPTWS}[0-9]*{OPTWS}{NL}	++linenum;	/* ignore */
+
+^"%"[^sxanpekotcru{}].*	synerr( "unrecognized '%' directive" );
+
+^{NAME}			{
+			strcpy( nmstr, yytext );
+			didadef = false;
+			BEGIN(PICKUPDEF);
+			}
+
+{SCNAME}		RETURNNAME;
+^{OPTWS}{NL}		++linenum; /* allows blank lines in section 1 */
+{OPTWS}{NL}		++linenum; return '\n';
+
+
+<C_COMMENT>"*/"		ACTION_ECHO; BEGIN(INITIAL);
+<C_COMMENT>"*/".*{NL}	++linenum; ACTION_ECHO; BEGIN(INITIAL);
+<C_COMMENT>[^*\n]+	ACTION_ECHO;
+<C_COMMENT>"*"		ACTION_ECHO;
+<C_COMMENT>{NL}		++linenum; ACTION_ECHO;
+
+
+<CODEBLOCK>^"%}".*{NL}	++linenum; BEGIN(INITIAL);
+<CODEBLOCK>"reject"	ACTION_ECHO; CHECK_REJECT(yytext);
+<CODEBLOCK>"yymore"	ACTION_ECHO; CHECK_YYMORE(yytext);
+<CODEBLOCK>{NAME}|{NOT_NAME}|.	ACTION_ECHO;
+<CODEBLOCK>{NL}		{
+			++linenum;
+			ACTION_ECHO;
+			if ( indented_code )
+				BEGIN(INITIAL);
+			}
+
+
+<PICKUPDEF>{WS}		/* separates name and definition */
+
+<PICKUPDEF>{NOT_WS}.*	{
+			strcpy( (char *) nmdef, yytext );
+
+			/* Skip trailing whitespace. */
+			for ( i = strlen( (char *) nmdef ) - 1;
+			      i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
+			      --i )
+				;
+
+			nmdef[i + 1] = '\0';
+
+			ndinstal( nmstr, nmdef );
+			didadef = true;
+			}
+
+<PICKUPDEF>{NL}		{
+			if ( ! didadef )
+				synerr( "incomplete name definition" );
+			BEGIN(INITIAL);
+			++linenum;
+			}
+
+<RECOVER>.*{NL}		++linenum; BEGIN(INITIAL); RETURNNAME;
+
+
+<USED_LIST>{NL}		++linenum; BEGIN(INITIAL);
+<USED_LIST>{WS}
+<USED_LIST>"reject"	{
+			if ( all_upper( yytext ) )
+				reject_really_used = checking_used;
+			else
+				synerr(
+				"unrecognized %used/%unused construct" );
+			}
+<USED_LIST>"yymore"	{
+			if ( all_lower( yytext ) )
+				yymore_really_used = checking_used;
+			else
+				synerr(
+				"unrecognized %used/%unused construct" );
+			}
+<USED_LIST>{NOT_WS}+	synerr( "unrecognized %used/%unused construct" );
+
+
+<SECT2PROLOG>^"%{".*	++bracelevel; yyless( 2 );	/* eat only %{ */
+<SECT2PROLOG>^"%}".*	--bracelevel; yyless( 2 );	/* eat only %} */
+
+<SECT2PROLOG>^{WS}.*	ACTION_ECHO;	/* indented code in prolog */
+
+<SECT2PROLOG>^{NOT_WS}.*	{	/* non-indented code */
+			if ( bracelevel <= 0 )
+				{ /* not in %{ ... %} */
+				yyless( 0 );	/* put it all back */
+				mark_prolog();
+				BEGIN(SECT2);
+				}
+			else
+				ACTION_ECHO;
+			}
+
+<SECT2PROLOG>.*		ACTION_ECHO;
+<SECT2PROLOG>{NL}	++linenum; ACTION_ECHO;
+
+<SECT2PROLOG><<EOF>>	{
+			mark_prolog();
+			sectnum = 0;
+			yyterminate(); /* to stop the parser */
+			}
+
+<SECT2>^{OPTWS}{NL}	++linenum; /* allow blank lines in section 2 */
+
+<SECT2>^({WS}|"%{")	{
+			indented_code = (yytext[0] != '%');
+			doing_codeblock = true;
+			bracelevel = 1;
+
+			if ( indented_code )
+				ACTION_ECHO;
+
+			BEGIN(CODEBLOCK_2);
+			}
+
+<SECT2>^"<"		BEGIN(SC); return '<';
+<SECT2>^"^"		return '^';
+<SECT2>\"		BEGIN(QUOTE); return '"';
+<SECT2>"{"/[0-9]		BEGIN(NUM); return '{';
+<SECT2>"{"[^0-9\n][^}\n]*	BEGIN(BRACEERROR);
+<SECT2>"$"/([ \t]|{NL})	return '$';
+
+<SECT2>{WS}"%{"		{
+			bracelevel = 1;
+			BEGIN(PERCENT_BRACE_ACTION);
+			return '\n';
+			}
+<SECT2>{WS}"|".*{NL}	continued_action = true; ++linenum; return '\n';
+
+<SECT2>{WS}		{
+			/* This rule is separate from the one below because
+			 * otherwise we get variable trailing context, so
+			 * we can't build the scanner using -{f,F}.
+			 */
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			return '\n';
+			}
+
+<SECT2>{OPTWS}{NL}	{
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			unput( '\n' );	/* so <ACTION> sees it */
+			return '\n';
+			}
+
+<SECT2>"<<EOF>>"	return EOF_OP;
+
+<SECT2>^"%%".*		{
+			sectnum = 3;
+			BEGIN(SECT3);
+			yyterminate(); /* to stop the parser */
+			}
+
+<SECT2>"["{FIRST_CCL_CHAR}{CCL_CHAR}*	{
+			int cclval;
+
+			strcpy( nmstr, yytext );
+
+			/* Check to see if we've already encountered this
+			 * ccl.
+			 */
+			if ( (cclval = ccllookup( (Char *) nmstr )) )
+				{
+				if ( input() != ']' )
+					synerr( "bad character class" );
+
+				yylval = cclval;
+				++cclreuse;
+				return PREVCCL;
+				}
+			else
+				{
+				/* We fudge a bit.  We know that this ccl will
+				 * soon be numbered as lastccl + 1 by cclinit.
+				 */
+				cclinstal( (Char *) nmstr, lastccl + 1 );
+
+				/* Push back everything but the leading bracket
+				 * so the ccl can be rescanned.
+				 */
+				yyless( 1 );
+
+				BEGIN(FIRSTCCL);
+				return '[';
+				}
+			}
+
+<SECT2>"{"{NAME}"}"	{
+			register Char *nmdefptr;
+			Char *ndlookup();
+
+			strcpy( nmstr, yytext + 1 );
+			nmstr[yyleng - 2] = '\0';  /* chop trailing brace */
+
+			if ( ! (nmdefptr = ndlookup( nmstr )) )
+				format_synerr( "undefined definition {%s}",
+						nmstr );
+
+			else
+				{ /* push back name surrounded by ()'s */
+				int len = strlen( (char *) nmdefptr );
+
+				if ( lex_compat || nmdefptr[0] == '^' ||
+				     (len > 0 && nmdefptr[len - 1] == '$') )
+					{ /* don't use ()'s after all */
+					PUT_BACK_STRING((char *) nmdefptr, 0);
+
+					if ( nmdefptr[0] == '^' )
+						BEGIN(CARETISBOL);
+					}
+
+				else
+					{
+					unput(')');
+					PUT_BACK_STRING((char *) nmdefptr, 0);
+					unput('(');
+					}
+				}
+			}
+
+<SECT2>[/|*+?.()]	return (unsigned char) yytext[0];
+<SECT2>.		RETURNCHAR;
+
+
+<SC>[,*]		return (unsigned char) yytext[0];
+<SC>">"			BEGIN(SECT2); return '>';
+<SC>">"/^		BEGIN(CARETISBOL); return '>';
+<SC>{SCNAME}		RETURNNAME;
+<SC>.			{
+			format_synerr( "bad <start condition>: %s", yytext );
+			}
+
+<CARETISBOL>"^"		BEGIN(SECT2); return '^';
+
+
+<QUOTE>[^"\n]		RETURNCHAR;
+<QUOTE>\"		BEGIN(SECT2); return '"';
+
+<QUOTE>{NL}		{
+			synerr( "missing quote" );
+			BEGIN(SECT2);
+			++linenum;
+			return '"';
+			}
+
+
+<FIRSTCCL>"^"/[^-\]\n]	BEGIN(CCL); return '^';
+<FIRSTCCL>"^"/("-"|"]")	return '^';
+<FIRSTCCL>.		BEGIN(CCL); RETURNCHAR;
+
+<CCL>-/[^\]\n]		return '-';
+<CCL>[^\]\n]		RETURNCHAR;
+<CCL>"]"		BEGIN(SECT2); return ']';
+<CCL>.|{NL}		{
+			synerr( "bad character class" );
+			BEGIN(SECT2);
+			return ']';
+			}
+
+
+<NUM>[0-9]+		{
+			yylval = myctoi( yytext );
+			return NUMBER;
+			}
+
+<NUM>","		return ',';
+<NUM>"}"		BEGIN(SECT2); return '}';
+
+<NUM>.			{
+			synerr( "bad character inside {}'s" );
+			BEGIN(SECT2);
+			return '}';
+			}
+
+<NUM>{NL}		{
+			synerr( "missing }" );
+			BEGIN(SECT2);
+			++linenum;
+			return '}';
+			}
+
+
+<BRACEERROR>"}"		synerr( "bad name in {}'s" ); BEGIN(SECT2);
+<BRACEERROR>{NL}	synerr( "missing }" ); ++linenum; BEGIN(SECT2);
+
+
+<CODEBLOCK_2>"/*"	ACTION_ECHO; BEGIN(ACTION_COMMENT);
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>{OPTWS}"%}".*		bracelevel = 0;
+<PERCENT_BRACE_ACTION,CODEBLOCK_2,ACTION>"reject"	{
+			ACTION_ECHO;
+			CHECK_REJECT(yytext);
+			}
+<PERCENT_BRACE_ACTION,CODEBLOCK_2,ACTION>"yymore"	{
+			ACTION_ECHO;
+			CHECK_YYMORE(yytext);
+			}
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>{NAME}|{NOT_NAME}|.	ACTION_ECHO;
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>{NL}			{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 ||
+			     (doing_codeblock && indented_code) )
+				{
+				if ( ! doing_codeblock )
+					add_action( "\tYY_BREAK\n" );
+				
+				doing_codeblock = false;
+				BEGIN(SECT2);
+				}
+			}
+
+
+	/* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
+<ACTION>"{"		ACTION_ECHO; ++bracelevel;
+<ACTION>"}"		ACTION_ECHO; --bracelevel;
+<ACTION>[^a-z_{}"'/\n]+	ACTION_ECHO;
+<ACTION>{NAME}		ACTION_ECHO;
+<ACTION>"/*"		ACTION_ECHO; BEGIN(ACTION_COMMENT);
+<ACTION>"'"([^'\\\n]|\\.)*"'"	ACTION_ECHO; /* character constant */
+<ACTION>\"		ACTION_ECHO; BEGIN(ACTION_STRING);
+<ACTION>{NL}		{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 )
+				{
+				add_action( "\tYY_BREAK\n" );
+				BEGIN(SECT2);
+				}
+			}
+<ACTION>.		ACTION_ECHO;
+
+<ACTION_COMMENT>"*/"	{
+			ACTION_ECHO;
+			if ( doing_codeblock )
+				BEGIN(CODEBLOCK_2);
+			else
+				BEGIN(ACTION);
+			}
+
+<ACTION_COMMENT>"*"	ACTION_ECHO;
+<ACTION_COMMENT>[^*\n]+	ACTION_ECHO;
+<ACTION_COMMENT>[^*\n]*{NL}	++linenum; ACTION_ECHO;
+
+<ACTION_STRING>[^"\\\n]+	ACTION_ECHO;
+<ACTION_STRING>\\.	ACTION_ECHO;
+<ACTION_STRING>{NL}	++linenum; ACTION_ECHO;
+<ACTION_STRING>\"	ACTION_ECHO; BEGIN(ACTION);
+<ACTION_STRING>.	ACTION_ECHO;
+
+<ACTION,ACTION_COMMENT,ACTION_STRING><<EOF>>	{
+			synerr( "EOF encountered inside an action" );
+			yyterminate();
+			}
+
+
+<SECT2,QUOTE,CCL>{ESCSEQ}	{
+			yylval = myesc( (Char *) yytext );
+			return CHAR;
+			}
+
+<FIRSTCCL>{ESCSEQ}	{
+			yylval = myesc( (Char *) yytext );
+			BEGIN(CCL);
+			return CHAR;
+			}
+
+
+<SECT3>.*(\n?)		ECHO;
+<SECT3><<EOF>>		sectnum = 0; yyterminate();
+
+<*>.|\n			format_synerr( "bad character: %s", yytext );
+
+%%
+
+
+int yywrap()
+	{
+	if ( --num_input_files > 0 )
+		{
+		set_input_file( *++input_files );
+		return 0;
+		}
+
+	else
+		return 1;
+	}
+
+
+/* set_input_file - open the given file (if NULL, stdin) for scanning */
+
+void set_input_file( file )
+char *file;
+	{
+	if ( file )
+		{
+		infilename = file;
+		yyin = fopen( infilename, "r" );
+
+		if ( yyin == NULL )
+			lerrsf( "can't open %s", file );
+		}
+
+	else
+		{
+		yyin = stdin;
+		infilename = "<stdin>";
+		}
+	}
+
+
+/* Wrapper routines for accessing the scanner's malloc routines. */
+
+void *flex_alloc( size )
+unsigned int size;
+	{
+	return yy_flex_alloc( size );
+	}
+
+void *flex_realloc( ptr, size )
+void *ptr;
+unsigned int size;
+	{
+	return yy_flex_realloc( ptr, size );
+	}
+
+void flex_free( ptr )
+void *ptr;
+	{
+	yy_flex_free( ptr );
+	}
diff --git a/usr.bin/lex/skel.c b/usr.bin/lex/skel.c
new file mode 100644
index 000000000000..4ab49d1085cd
--- /dev/null
+++ b/usr.bin/lex/skel.c
@@ -0,0 +1,1232 @@
+/* File created from flex.skel via mkskel.sh */
+
+#include "flexdef.h"
+
+char *skel[] = {
+  "/* A lexical scanner generated by flex */",
+  "",
+  "/* Scanner skeleton version:",
+  " * $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/flex.skl,v 1.2 94/08/03 11:13:24 vern Exp $",
+  " */",
+  "",
+  "#define FLEX_SCANNER",
+  "",
+  "%-",
+  "#include <stdio.h>",
+  "%*",
+  "",
+  "",
+  "/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */",
+  "#ifdef c_plusplus",
+  "#ifndef __cplusplus",
+  "#define __cplusplus",
+  "#endif",
+  "#endif",
+  "",
+  "",
+  "#ifdef __cplusplus",
+  "",
+  "#include <stdlib.h>",
+  "%+",
+  "class istream;",
+  "%*",
+  "#include <unistd.h>",
+  "",
+  "/* Use prototypes in function declarations. */",
+  "#define YY_USE_PROTOS",
+  "",
+  "/* The \"const\" storage-class-modifier is valid. */",
+  "#define YY_USE_CONST",
+  "",
+  "#else	/* ! __cplusplus */",
+  "",
+  "#ifdef __STDC__",
+  "",
+  "#define YY_USE_PROTOS",
+  "#define YY_USE_CONST",
+  "",
+  "#endif	/* __STDC__ */",
+  "#endif	/* ! __cplusplus */",
+  "",
+  "",
+  "#ifdef __TURBOC__",
+  "#define YY_USE_CONST",
+  "#endif",
+  "",
+  "",
+  "#ifndef YY_USE_CONST",
+  "#ifndef const",
+  "#define const",
+  "#endif",
+  "#endif",
+  "",
+  "",
+  "#ifdef YY_USE_PROTOS",
+  "#define YY_PROTO(proto) proto",
+  "#else",
+  "#define YY_PROTO(proto) ()",
+  "#endif",
+  "",
+  "/* Returned upon end-of-file. */",
+  "#define YY_NULL 0",
+  "",
+  "/* Promotes a possibly negative, possibly signed char to an unsigned",
+  " * integer for use as an array index.  If the signed char is negative,",
+  " * we want to instead treat it as an 8-bit unsigned char, hence the",
+  " * double cast.",
+  " */",
+  "#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)",
+  "",
+  "/* Enter a start condition.  This macro really ought to take a parameter,",
+  " * but we do it the disgusting crufty way forced on us by the ()-less",
+  " * definition of BEGIN.",
+  " */",
+  "#define BEGIN yy_start = 1 + 2 *",
+  "",
+  "/* Translate the current start state into a value that can be later handed",
+  " * to BEGIN to return to the state.",
+  " */",
+  "#define YY_START ((yy_start - 1) / 2)",
+  "",
+  "/* Action number for EOF rule of a given start state. */",
+  "#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)",
+  "",
+  "/* Special action meaning \"start processing a new file\".  Now included",
+  " * only for backward compatibility with previous versions of flex.",
+  " */",
+  "#define YY_NEW_FILE yyrestart( yyin )",
+  "",
+  "#define YY_END_OF_BUFFER_CHAR 0",
+  "",
+  "/* Size of default input buffer. */",
+  "#define YY_BUF_SIZE 16384",
+  "",
+  "typedef struct yy_buffer_state *YY_BUFFER_STATE;",
+  "",
+  "extern int yyleng;",
+  "%-",
+  "extern FILE *yyin, *yyout;",
+  "%*",
+  "",
+  "#ifdef __cplusplus",
+  "extern \"C\" {",
+  "#endif",
+  "	extern int yywrap YY_PROTO(( void ));",
+  "#ifdef __cplusplus",
+  "	}",
+  "#endif",
+  "",
+  "#define EOB_ACT_CONTINUE_SCAN 0",
+  "#define EOB_ACT_END_OF_FILE 1",
+  "#define EOB_ACT_LAST_MATCH 2",
+  "",
+  "/* The funky do-while in the following #define is used to turn the definition",
+  " * int a single C statement (which needs a semi-colon terminator).  This",
+  " * avoids problems with code like:",
+  " *",
+  " * 	if ( condition_holds )",
+  " *		yyless( 5 );",
+  " *	else",
+  " *		do_something_else();",
+  " *",
+  " * Prior to using the do-while the compiler would get upset at the",
+  " * \"else\" because it interpreted the \"if\" statement as being all",
+  " * done when it reached the ';' after the yyless() call.",
+  " */",
+  "",
+  "/* Return all but the first 'n' matched characters back to the input stream. */",
+  "",
+  "#define yyless(n) \\",
+  "	do \\",
+  "		{ \\",
+  "		/* Undo effects of setting up yytext. */ \\",
+  "		*yy_cp = yy_hold_char; \\",
+  "		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\",
+  "		YY_DO_BEFORE_ACTION; /* set up yytext again */ \\",
+  "		} \\",
+  "	while ( 0 )",
+  "",
+  "#define unput(c) yyunput( c, yytext_ptr )",
+  "",
+  "",
+  "struct yy_buffer_state",
+  "	{",
+  "%-",
+  "	FILE *yy_input_file;",
+  "%+",
+  "	istream* yy_input_file;",
+  "%*",
+  "",
+  "	char *yy_ch_buf;		/* input buffer */",
+  "	char *yy_buf_pos;		/* current position in input buffer */",
+  "",
+  "	/* Size of input buffer in bytes, not including room for EOB",
+  "	 * characters.",
+  "	 */",
+  "	int yy_buf_size;",
+  "",
+  "	/* Number of characters read into yy_ch_buf, not including EOB",
+  "	 * characters.",
+  "	 */",
+  "	int yy_n_chars;",
+  "",
+  "	/* Whether this is an \"interactive\" input source; if so, and",
+  "	 * if we're using stdio for input, then we want to use getc()",
+  "	 * instead of fread(), to make sure we stop fetching input after",
+  "	 * each newline.",
+  "	 */",
+  "	int yy_is_interactive;",
+  "",
+  "	/* Whether to try to fill the input buffer when we reach the",
+  "	 * end of it.",
+  "	 */",
+  "	int yy_fill_buffer;",
+  "",
+  "	int yy_buffer_status;",
+  "#define YY_BUFFER_NEW 0",
+  "#define YY_BUFFER_NORMAL 1",
+  "	/* When an EOF's been seen but there's still some text to process",
+  "	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we",
+  "	 * shouldn't try reading from the input source any more.  We might",
+  "	 * still have a bunch of tokens to match, though, because of",
+  "	 * possible backing-up.",
+  "	 *",
+  "	 * When we actually see the EOF, we change the status to \"new\"",
+  "	 * (via yyrestart()), so that the user can continue scanning by",
+  "	 * just pointing yyin at a new input file.",
+  "	 */",
+  "#define YY_BUFFER_EOF_PENDING 2",
+  "	};",
+  "",
+  "%- Standard (non-C++) definition",
+  "static YY_BUFFER_STATE yy_current_buffer = 0;",
+  "%*",
+  "",
+  "/* We provide macros for accessing buffer states in case in the",
+  " * future we want to put the buffer states in a more general",
+  " * \"scanner state\".",
+  " */",
+  "#define YY_CURRENT_BUFFER yy_current_buffer",
+  "",
+  "",
+  "%- Standard (non-C++) definition",
+  "/* yy_hold_char holds the character lost when yytext is formed. */",
+  "static char yy_hold_char;",
+  "",
+  "static int yy_n_chars;		/* number of characters read into yy_ch_buf */",
+  "",
+  "",
+  "int yyleng;",
+  "",
+  "/* Points to current character in buffer. */",
+  "static char *yy_c_buf_p = (char *) 0;",
+  "static int yy_init = 1;		/* whether we need to initialize */",
+  "static int yy_start = 0;	/* start state number */",
+  "",
+  "/* Flag which is used to allow yywrap()'s to do buffer switches",
+  " * instead of setting up a fresh yyin.  A bit of a hack ...",
+  " */",
+  "static int yy_did_buffer_switch_on_eof;",
+  "",
+  "static void yyunput YY_PROTO(( int c, char *buf_ptr ));",
+  "void yyrestart YY_PROTO(( FILE *input_file ));",
+  "void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));",
+  "void yy_load_buffer_state YY_PROTO(( void ));",
+  "YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));",
+  "void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
+  "void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));",
+  "",
+  "static int yy_start_stack_ptr = 0;",
+  "static int yy_start_stack_depth = 0;",
+  "static int *yy_start_stack = 0;",
+  "static void yy_push_state YY_PROTO(( int new_state ));",
+  "static void yy_pop_state YY_PROTO(( void ));",
+  "static int yy_top_state YY_PROTO(( void ));",
+  "%*",
+  "",
+  "static void *yy_flex_alloc YY_PROTO(( unsigned int ));",
+  "static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));",
+  "static void yy_flex_free YY_PROTO(( void * ));",
+  "",
+  "#define yy_new_buffer yy_create_buffer",
+  "",
+  "%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here",
+  "",
+  "#ifndef yytext_ptr",
+  "static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));",
+  "#endif",
+  "",
+  "%- Standard (non-C++) definition",
+  "#ifdef __cplusplus",
+  "static int yyinput YY_PROTO(( void ));",
+  "#else",
+  "static int input YY_PROTO(( void ));",
+  "#endif",
+  "%*",
+  "",
+  "%- Standard (non-C++) definition",
+  "static yy_state_type yy_get_previous_state YY_PROTO(( void ));",
+  "static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));",
+  "static int yy_get_next_buffer YY_PROTO(( void ));",
+  "static void yy_fatal_error YY_PROTO(( const char msg[] ));",
+  "%*",
+  "",
+  "/* Done after the current pattern has been matched and before the",
+  " * corresponding action - sets up yytext.",
+  " */",
+  "#define YY_DO_BEFORE_ACTION \\",
+  "	yytext_ptr = yy_bp; \\",
+  "%% code to fiddle yytext and yyleng for yymore() goes here",
+  "	yy_hold_char = *yy_cp; \\",
+  "	*yy_cp = '\\0'; \\",
+  "%% code to copy yytext_ptr to yytext[] goes here, if %array",
+  "	yy_c_buf_p = yy_cp;",
+  "",
+  "%% data tables for the DFA and the user's section 1 definitions go here",
+  "",
+  "/* Macros after this point can all be overridden by user definitions in",
+  " * section 1.",
+  " */",
+  "",
+  "#ifdef YY_MALLOC_DECL",
+  "YY_MALLOC_DECL",
+  "#else",
+  "#if __STDC__",
+  "#ifndef __cplusplus",
+  "#include <stdlib.h>",
+  "#endif",
+  "#else",
+  "/* Just try to get by without declaring the routines.  This will fail",
+  " * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)",
+  " * or sizeof(void*) != sizeof(int).",
+  " */",
+  "#endif",
+  "#endif",
+  "",
+  "/* Amount of stuff to slurp up with each read. */",
+  "#ifndef YY_READ_BUF_SIZE",
+  "#define YY_READ_BUF_SIZE 8192",
+  "#endif",
+  "",
+  "/* Copy whatever the last rule matched to the standard output. */",
+  "",
+  "#ifndef ECHO",
+  "%- Standard (non-C++) definition",
+  "/* This used to be an fputs(), but since the string might contain NUL's,",
+  " * we now use fwrite().",
+  " */",
+  "#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )",
+  "%+ C++ definition",
+  "#define ECHO LexerOutput( yytext, yyleng )",
+  "%*",
+  "#endif",
+  "",
+  "/* Gets input and stuffs it into \"buf\".  number of characters read, or YY_NULL,",
+  " * is returned in \"result\".",
+  " */",
+  "#ifndef YY_INPUT",
+  "#define YY_INPUT(buf,result,max_size) \\",
+  "%% fread()/read() definition of YY_INPUT goes here unless we're doing C++",
+  "%+ C++ definition",
+  "	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\",
+  "		YY_FATAL_ERROR( \"input in flex scanner failed\" );",
+  "%*",
+  "#endif",
+  "",
+  "/* No semi-colon after return; correct usage is to write \"yyterminate();\" -",
+  " * we don't want an extra ';' after the \"return\" because that will cause",
+  " * some compilers to complain about unreachable statements.",
+  " */",
+  "#ifndef yyterminate",
+  "#define yyterminate() return YY_NULL",
+  "#endif",
+  "",
+  "/* Number of entries by which start-condition stack grows. */",
+  "#ifndef YY_START_STACK_INCR",
+  "#define YY_START_STACK_INCR 25",
+  "#endif",
+  "",
+  "/* Report a fatal error. */",
+  "#ifndef YY_FATAL_ERROR",
+  "%-",
+  "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )",
+  "%+",
+  "#define YY_FATAL_ERROR(msg) LexerError( msg )",
+  "%*",
+  "#endif",
+  "",
+  "/* Default declaration of generated scanner - a define so the user can",
+  " * easily add parameters.",
+  " */",
+  "#ifndef YY_DECL",
+  "%- Standard (non-C++) definition",
+  "#define YY_DECL int yylex YY_PROTO(( void ))",
+  "%+ C++ definition",
+  "#define YY_DECL int yyFlexLexer::yylex()",
+  "%*",
+  "#endif",
+  "",
+  "/* Code executed at the beginning of each rule, after yytext and yyleng",
+  " * have been set up.",
+  " */",
+  "#ifndef YY_USER_ACTION",
+  "#define YY_USER_ACTION",
+  "#endif",
+  "",
+  "/* Code executed at the end of each rule. */",
+  "#ifndef YY_BREAK",
+  "#define YY_BREAK break;",
+  "#endif",
+  "",
+  "YY_DECL",
+  "	{",
+  "	register yy_state_type yy_current_state;",
+  "	register char *yy_cp, *yy_bp;",
+  "	register int yy_act;",
+  "",
+  "%% user's declarations go here",
+  "",
+  "	if ( yy_init )",
+  "		{",
+  "#ifdef YY_USER_INIT",
+  "		YY_USER_INIT;",
+  "#endif",
+  "",
+  "		if ( ! yy_start )",
+  "			yy_start = 1;	/* first start state */",
+  "",
+  "		if ( ! yyin )",
+  "%-",
+  "			yyin = stdin;",
+  "%+",
+  "			yyin = &cin;",
+  "%*",
+  "",
+  "		if ( ! yyout )",
+  "%-",
+  "			yyout = stdout;",
+  "%+",
+  "			yyout = &cout;",
+  "%*",
+  "",
+  "		if ( yy_current_buffer )",
+  "			yy_init_buffer( yy_current_buffer, yyin );",
+  "		else",
+  "			yy_current_buffer =",
+  "				yy_create_buffer( yyin, YY_BUF_SIZE );",
+  "",
+  "		yy_load_buffer_state();",
+  "",
+  "		yy_init = 0;",
+  "		}",
+  "",
+  "	while ( 1 )		/* loops until end-of-file is reached */",
+  "		{",
+  "%% yymore()-related code goes here",
+  "		yy_cp = yy_c_buf_p;",
+  "",
+  "		/* Support of yytext. */",
+  "		*yy_cp = yy_hold_char;",
+  "",
+  "		/* yy_bp points to the position in yy_ch_buf of the start of",
+  "		 * the current run.",
+  "		 */",
+  "		yy_bp = yy_cp;",
+  "",
+  "%% code to set up and find next match goes here",
+  "",
+  "yy_find_action:",
+  "%% code to find the action number goes here",
+  "",
+  "		YY_DO_BEFORE_ACTION;",
+  "",
+  "%% code for yylineno update goes here, if -l option",
+  "",
+  "do_action:	/* This label is used only to access EOF actions. */",
+  "",
+  "%% debug code goes here",
+  "",
+  "		switch ( yy_act )",
+  "	{ /* beginning of action switch */",
+  "%% actions go here",
+  "",
+  "	case YY_END_OF_BUFFER:",
+  "		{",
+  "		/* Amount of text matched not including the EOB char. */",
+  "		int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;",
+  "",
+  "		/* Undo the effects of YY_DO_BEFORE_ACTION. */",
+  "		*yy_cp = yy_hold_char;",
+  "",
+  "		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )",
+  "			{",
+  "			/* We're scanning a new file or input source.  It's",
+  "			 * possible that this happened because the user",
+  "			 * just pointed yyin at a new source and called",
+  "			 * yylex().  If so, then we have to assure",
+  "			 * consistency between yy_current_buffer and our",
+  "			 * globals.  Here is the right place to do so, because",
+  "			 * this is the first action (other than possibly a",
+  "			 * back-up) that will match for the new input source.",
+  "			 */",
+  "			yy_n_chars = yy_current_buffer->yy_n_chars;",
+  "			yy_current_buffer->yy_input_file = yyin;",
+  "			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;",
+  "			}",
+  "",
+  "		/* Note that here we test for yy_c_buf_p \"<=\" to the position",
+  "		 * of the first EOB in the buffer, since yy_c_buf_p will",
+  "		 * already have been incremented past the NUL character",
+  "		 * (since all states make transitions on EOB to the",
+  "		 * end-of-buffer state).  Contrast this with the test",
+  "		 * in input().",
+  "		 */",
+  "		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
+  "			{ /* This was really a NUL. */",
+  "			yy_state_type yy_next_state;",
+  "",
+  "			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;",
+  "",
+  "			yy_current_state = yy_get_previous_state();",
+  "",
+  "			/* Okay, we're now positioned to make the NUL",
+  "			 * transition.  We couldn't have",
+  "			 * yy_get_previous_state() go ahead and do it",
+  "			 * for us because it doesn't know how to deal",
+  "			 * with the possibility of jamming (and we don't",
+  "			 * want to build jamming into it because then it",
+  "			 * will run more slowly).",
+  "			 */",
+  "",
+  "			yy_next_state = yy_try_NUL_trans( yy_current_state );",
+  "",
+  "			yy_bp = yytext_ptr + YY_MORE_ADJ;",
+  "",
+  "			if ( yy_next_state )",
+  "				{",
+  "				/* Consume the NUL. */",
+  "				yy_cp = ++yy_c_buf_p;",
+  "				yy_current_state = yy_next_state;",
+  "				goto yy_match;",
+  "				}",
+  "",
+  "			else",
+  "				{",
+  "%% code to do back-up for compressed tables and set up yy_cp goes here",
+  "				goto yy_find_action;",
+  "				}",
+  "			}",
+  "",
+  "		else switch ( yy_get_next_buffer() )",
+  "			{",
+  "			case EOB_ACT_END_OF_FILE:",
+  "				{",
+  "				yy_did_buffer_switch_on_eof = 0;",
+  "",
+  "				if ( yywrap() )",
+  "					{",
+  "					/* Note: because we've taken care in",
+  "					 * yy_get_next_buffer() to have set up",
+  "					 * yytext, we can now set up",
+  "					 * yy_c_buf_p so that if some total",
+  "					 * hoser (like flex itself) wants to",
+  "					 * call the scanner after we return the",
+  "					 * YY_NULL, it'll still work - another",
+  "					 * YY_NULL will get returned.",
+  "					 */",
+  "					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;",
+  "",
+  "					yy_act = YY_STATE_EOF(YY_START);",
+  "					goto do_action;",
+  "					}",
+  "",
+  "				else",
+  "					{",
+  "					if ( ! yy_did_buffer_switch_on_eof )",
+  "						YY_NEW_FILE;",
+  "					}",
+  "				break;",
+  "				}",
+  "",
+  "			case EOB_ACT_CONTINUE_SCAN:",
+  "				yy_c_buf_p =",
+  "					yytext_ptr + yy_amount_of_matched_text;",
+  "",
+  "				yy_current_state = yy_get_previous_state();",
+  "",
+  "				yy_cp = yy_c_buf_p;",
+  "				yy_bp = yytext_ptr + YY_MORE_ADJ;",
+  "				goto yy_match;",
+  "",
+  "			case EOB_ACT_LAST_MATCH:",
+  "				yy_c_buf_p =",
+  "				&yy_current_buffer->yy_ch_buf[yy_n_chars];",
+  "",
+  "				yy_current_state = yy_get_previous_state();",
+  "",
+  "				yy_cp = yy_c_buf_p;",
+  "				yy_bp = yytext_ptr + YY_MORE_ADJ;",
+  "				goto yy_find_action;",
+  "			}",
+  "		break;",
+  "		}",
+  "",
+  "	default:",
+  "		YY_FATAL_ERROR(",
+  "			\"fatal flex scanner internal error--no action found\" );",
+  "	} /* end of action switch */",
+  "		} /* end of scanning one token */",
+  "	} /* end of yylex */",
+  "",
+  "%+",
+  "#ifdef YY_INTERACTIVE",
+  "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )",
+  "#else",
+  "int yyFlexLexer::LexerInput( char* buf, int max_size )",
+  "#endif",
+  "	{",
+  "	if ( yyin->eof() || yyin->fail() )",
+  "		return 0;",
+  "",
+  "#ifdef YY_INTERACTIVE",
+  "	yyin->get( buf[0] );",
+  "",
+  "	if ( yyin->eof() )",
+  "		return 0;",
+  "",
+  "	if ( yyin->bad() )",
+  "		return -1;",
+  "",
+  "	return 1;",
+  "",
+  "#else",
+  "	(void) yyin->read( buf, max_size );",
+  "",
+  "	if ( yyin->bad() )",
+  "		return -1;",
+  "	else",
+  "		return yyin->gcount();",
+  "#endif",
+  "	}",
+  "",
+  "void yyFlexLexer::LexerOutput( const char* buf, int size )",
+  "	{",
+  "	(void) yyout->write( buf, size );",
+  "	}",
+  "%*",
+  "",
+  "/* yy_get_next_buffer - try to read in a new buffer",
+  " *",
+  " * Returns a code representing an action:",
+  " *	EOB_ACT_LAST_MATCH -",
+  " *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position",
+  " *	EOB_ACT_END_OF_FILE - end of file",
+  " */",
+  "",
+  "%-",
+  "static int yy_get_next_buffer()",
+  "%+",
+  "int yyFlexLexer::yy_get_next_buffer()",
+  "%*",
+  "	{",
+  "	register char *dest = yy_current_buffer->yy_ch_buf;",
+  "	register char *source = yytext_ptr - 1; /* copy prev. char, too */",
+  "	register int number_to_move, i;",
+  "	int ret_val;",
+  "",
+  "	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )",
+  "		YY_FATAL_ERROR(",
+  "		\"fatal flex scanner internal error--end of buffer missed\" );",
+  "",
+  "	if ( yy_current_buffer->yy_fill_buffer == 0 )",
+  "		{ /* Don't try to fill the buffer, so this is an EOF. */",
+  "		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )",
+  "			{",
+  "			/* We matched a singled characater, the EOB, so",
+  "			 * treat this as a final EOF.",
+  "			 */",
+  "			return EOB_ACT_END_OF_FILE;",
+  "			}",
+  "",
+  "		else",
+  "			{",
+  "			/* We matched some text prior to the EOB, first",
+  "			 * process it.",
+  "			 */",
+  "			return EOB_ACT_LAST_MATCH;",
+  "			}",
+  "		}",
+  "",
+  "	/* Try to read more data. */",
+  "",
+  "	/* First move last chars to start of buffer. */",
+  "	number_to_move = yy_c_buf_p - yytext_ptr;",
+  "",
+  "	for ( i = 0; i < number_to_move; ++i )",
+  "		*(dest++) = *(source++);",
+  "",
+  "	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )",
+  "		/* don't do the read, it's not guaranteed to return an EOF,",
+  "		 * just force an EOF",
+  "		 */",
+  "		yy_n_chars = 0;",
+  "",
+  "	else",
+  "		{",
+  "		int num_to_read =",
+  "			yy_current_buffer->yy_buf_size - number_to_move - 1;",
+  "",
+  "		while ( num_to_read <= 0 )",
+  "			{ /* Not enough room in the buffer - grow it. */",
+  "#ifdef YY_USES_REJECT",
+  "			YY_FATAL_ERROR(",
+  "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );",
+  "#else",
+  "",
+  "			/* just a shorter name for the current buffer */",
+  "			YY_BUFFER_STATE b = yy_current_buffer;",
+  "",
+  "			int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;",
+  "",
+  "			b->yy_buf_size *= 2;",
+  "			b->yy_ch_buf = (char *)",
+  "				yy_flex_realloc( (void *) b->yy_ch_buf,",
+  "						 b->yy_buf_size );",
+  "",
+  "			if ( ! b->yy_ch_buf )",
+  "				YY_FATAL_ERROR(",
+  "				\"fatal error - scanner input buffer overflow\" );",
+  "",
+  "			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];",
+  "",
+  "			num_to_read = yy_current_buffer->yy_buf_size -",
+  "						number_to_move - 1;",
+  "#endif",
+  "			}",
+  "",
+  "		if ( num_to_read > YY_READ_BUF_SIZE )",
+  "			num_to_read = YY_READ_BUF_SIZE;",
+  "",
+  "		/* Read in more data. */",
+  "		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),",
+  "			yy_n_chars, num_to_read );",
+  "		}",
+  "",
+  "	if ( yy_n_chars == 0 )",
+  "		{",
+  "		if ( number_to_move - YY_MORE_ADJ == 1 )",
+  "			{",
+  "			ret_val = EOB_ACT_END_OF_FILE;",
+  "			yyrestart( yyin );",
+  "			}",
+  "",
+  "		else",
+  "			{",
+  "			ret_val = EOB_ACT_LAST_MATCH;",
+  "			yy_current_buffer->yy_buffer_status =",
+  "				YY_BUFFER_EOF_PENDING;",
+  "			}",
+  "		}",
+  "",
+  "	else",
+  "		ret_val = EOB_ACT_CONTINUE_SCAN;",
+  "",
+  "	yy_n_chars += number_to_move;",
+  "	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;",
+  "	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;",
+  "",
+  "	/* yytext begins at the second character in yy_ch_buf; the first",
+  "	 * character is the one which preceded it before reading in the latest",
+  "	 * buffer; it needs to be kept around in case it's a newline, so",
+  "	 * yy_get_previous_state() will have with '^' rules active.",
+  "	 */",
+  "",
+  "	yytext_ptr = &yy_current_buffer->yy_ch_buf[1];",
+  "",
+  "	return ret_val;",
+  "	}",
+  "",
+  "",
+  "/* yy_get_previous_state - get the state just before the EOB char was reached */",
+  "",
+  "%-",
+  "static yy_state_type yy_get_previous_state()",
+  "%+",
+  "yy_state_type yyFlexLexer::yy_get_previous_state()",
+  "%*",
+  "	{",
+  "	register yy_state_type yy_current_state;",
+  "	register char *yy_cp;",
+  "",
+  "%% code to get the start state into yy_current_state goes here",
+  "",
+  "	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )",
+  "		{",
+  "%% code to find the next state goes here",
+  "		}",
+  "",
+  "	return yy_current_state;",
+  "	}",
+  "",
+  "",
+  "/* yy_try_NUL_trans - try to make a transition on the NUL character",
+  " *",
+  " * synopsis",
+  " *	next_state = yy_try_NUL_trans( current_state );",
+  " */",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )",
+  "#else",
+  "static yy_state_type yy_try_NUL_trans( yy_current_state )",
+  "yy_state_type yy_current_state;",
+  "#endif",
+  "%+",
+  "yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )",
+  "%*",
+  "	{",
+  "	register int yy_is_jam;",
+  "%% code to find the next state, and perhaps do backing up, goes here",
+  "",
+  "	return yy_is_jam ? 0 : yy_current_state;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "static void yyunput( int c, register char *yy_bp )",
+  "#else",
+  "static void yyunput( c, yy_bp )",
+  "int c;",
+  "register char *yy_bp;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yyunput( int c, register char* yy_bp )",
+  "%*",
+  "	{",
+  "	register char *yy_cp = yy_c_buf_p;",
+  "",
+  "	/* undo effects of setting up yytext */",
+  "	*yy_cp = yy_hold_char;",
+  "",
+  "	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
+  "		{ /* need to shift things up to make room */",
+  "		/* +2 for EOB chars. */",
+  "		register int number_to_move = yy_n_chars + 2;",
+  "		register char *dest = &yy_current_buffer->yy_ch_buf[",
+  "					yy_current_buffer->yy_buf_size + 2];",
+  "		register char *source =",
+  "				&yy_current_buffer->yy_ch_buf[number_to_move];",
+  "",
+  "		while ( source > yy_current_buffer->yy_ch_buf )",
+  "			*--dest = *--source;",
+  "",
+  "		yy_cp += dest - source;",
+  "		yy_bp += dest - source;",
+  "		yy_n_chars = yy_current_buffer->yy_buf_size;",
+  "",
+  "		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
+  "			YY_FATAL_ERROR( \"flex scanner push-back overflow\" );",
+  "		}",
+  "",
+  "	if ( yy_cp > yy_bp && yy_cp[-1] == '\\n' )",
+  "		yy_cp[-2] = '\\n';",
+  "",
+  "	*--yy_cp = (char) c;",
+  "",
+  "%% update yylineno here, if doing -l",
+  "",
+  "	/* Note: the formal parameter *must* be called \"yy_bp\" for this",
+  "	 * macro to now work correctly.",
+  "	 */",
+  "	YY_DO_BEFORE_ACTION; /* set up yytext again */",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef __cplusplus",
+  "static int yyinput()",
+  "#else",
+  "static int input()",
+  "#endif",
+  "%+",
+  "int yyFlexLexer::yyinput()",
+  "%*",
+  "	{",
+  "	int c;",
+  "",
+  "	*yy_c_buf_p = yy_hold_char;",
+  "",
+  "	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )",
+  "		{",
+  "		/* yy_c_buf_p now points to the character we want to return.",
+  "		 * If this occurs *before* the EOB characters, then it's a",
+  "		 * valid NUL; if not, then we've hit the end of the buffer.",
+  "		 */",
+  "		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
+  "			/* This was really a NUL. */",
+  "			*yy_c_buf_p = '\\0';",
+  "",
+  "		else",
+  "			{ /* need more input */",
+  "			yytext_ptr = yy_c_buf_p;",
+  "			++yy_c_buf_p;",
+  "",
+  "			switch ( yy_get_next_buffer() )",
+  "				{",
+  "				case EOB_ACT_END_OF_FILE:",
+  "					{",
+  "					if ( yywrap() )",
+  "						{",
+  "						yy_c_buf_p =",
+  "						yytext_ptr + YY_MORE_ADJ;",
+  "						return EOF;",
+  "						}",
+  "",
+  "					YY_NEW_FILE;",
+  "#ifdef __cplusplus",
+  "					return yyinput();",
+  "#else",
+  "					return input();",
+  "#endif",
+  "					}",
+  "",
+  "				case EOB_ACT_CONTINUE_SCAN:",
+  "					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;",
+  "					break;",
+  "",
+  "				case EOB_ACT_LAST_MATCH:",
+  "#ifdef __cplusplus",
+  "					YY_FATAL_ERROR(",
+  "					\"unexpected last match in yyinput()\" );",
+  "#else",
+  "					YY_FATAL_ERROR(",
+  "					\"unexpected last match in input()\" );",
+  "#endif",
+  "				}",
+  "			}",
+  "		}",
+  "",
+  "	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */",
+  "	*yy_c_buf_p = '\\0';	/* preserve yytext */",
+  "	yy_hold_char = *++yy_c_buf_p;",
+  "",
+  "	return c;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "void yyrestart( FILE *input_file )",
+  "#else",
+  "void yyrestart( input_file )",
+  "FILE *input_file;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yyrestart( istream* input_file )",
+  "%*",
+  "	{",
+  "	if ( ! yy_current_buffer )",
+  "		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );",
+  "",
+  "	yy_init_buffer( yy_current_buffer, input_file );",
+  "	yy_load_buffer_state();",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
+  "#else",
+  "void yy_switch_to_buffer( new_buffer )",
+  "YY_BUFFER_STATE new_buffer;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
+  "%*",
+  "	{",
+  "	if ( yy_current_buffer == new_buffer )",
+  "		return;",
+  "",
+  "	if ( yy_current_buffer )",
+  "		{",
+  "		/* Flush out information for old buffer. */",
+  "		*yy_c_buf_p = yy_hold_char;",
+  "		yy_current_buffer->yy_buf_pos = yy_c_buf_p;",
+  "		yy_current_buffer->yy_n_chars = yy_n_chars;",
+  "		}",
+  "",
+  "	yy_current_buffer = new_buffer;",
+  "	yy_load_buffer_state();",
+  "",
+  "	/* We don't actually know whether we did this switch during",
+  "	 * EOF (yywrap()) processing, but the only time this flag",
+  "	 * is looked at is after yywrap() is called, so it's safe",
+  "	 * to go ahead and always set it.",
+  "	 */",
+  "	yy_did_buffer_switch_on_eof = 1;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "void yy_load_buffer_state( void )",
+  "#else",
+  "void yy_load_buffer_state()",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yy_load_buffer_state()",
+  "%*",
+  "	{",
+  "	yy_n_chars = yy_current_buffer->yy_n_chars;",
+  "	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;",
+  "	yyin = yy_current_buffer->yy_input_file;",
+  "	yy_hold_char = *yy_c_buf_p;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )",
+  "#else",
+  "YY_BUFFER_STATE yy_create_buffer( file, size )",
+  "FILE *file;",
+  "int size;",
+  "#endif",
+  "%+",
+  "YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )",
+  "%*",
+  "	{",
+  "	YY_BUFFER_STATE b;",
+  "",
+  "	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
+  "",
+  "	if ( ! b )",
+  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
+  "",
+  "	b->yy_buf_size = size;",
+  "",
+  "	/* yy_ch_buf has to be 2 characters longer than the size given because",
+  "	 * we need to put in 2 end-of-buffer characters.",
+  "	 */",
+  "	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );",
+  "",
+  "	if ( ! b->yy_ch_buf )",
+  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
+  "",
+  "	yy_init_buffer( b, file );",
+  "",
+  "	return b;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "void yy_delete_buffer( YY_BUFFER_STATE b )",
+  "#else",
+  "void yy_delete_buffer( b )",
+  "YY_BUFFER_STATE b;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )",
+  "%*",
+  "	{",
+  "	if ( b == yy_current_buffer )",
+  "		yy_current_buffer = (YY_BUFFER_STATE) 0;",
+  "",
+  "	yy_flex_free( (void *) b->yy_ch_buf );",
+  "	yy_flex_free( (void *) b );",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )",
+  "#else",
+  "void yy_init_buffer( b, file )",
+  "YY_BUFFER_STATE b;",
+  "FILE *file;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )",
+  "%*",
+  "	{",
+  "	b->yy_input_file = file;",
+  "",
+  "	/* We put in the '\\n' and start reading from [1] so that an",
+  "	 * initial match-at-newline will be true.",
+  "	 */",
+  "",
+  "	b->yy_ch_buf[0] = '\\n';",
+  "	b->yy_n_chars = 1;",
+  "",
+  "	/* We always need two end-of-buffer characters.  The first causes",
+  "	 * a transition to the end-of-buffer state.  The second causes",
+  "	 * a jam in that state.",
+  "	 */",
+  "	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;",
+  "	b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;",
+  "",
+  "	b->yy_buf_pos = &b->yy_ch_buf[1];",
+  "",
+  "%-",
+  "	b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;",
+  "%+",
+  "	b->yy_is_interactive = 0;",
+  "%*",
+  "",
+  "	b->yy_fill_buffer = 1;",
+  "",
+  "	b->yy_buffer_status = YY_BUFFER_NEW;",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "static void yy_push_state( int new_state )",
+  "#else",
+  "static void yy_push_state( new_state )",
+  "int new_state;",
+  "#endif",
+  "%+",
+  "void yyFlexLexer::yy_push_state( int new_state )",
+  "%*",
+  "	{",
+  "	if ( yy_start_stack_ptr >= yy_start_stack_depth )",
+  "		{",
+  "		int new_size;",
+  "",
+  "		yy_start_stack_depth += YY_START_STACK_INCR;",
+  "		new_size = yy_start_stack_depth * sizeof( int );",
+  "",
+  "		if ( ! yy_start_stack )",
+  "			yy_start_stack = (int *) yy_flex_alloc( new_size );",
+  "",
+  "		else",
+  "			yy_start_stack = (int *) yy_flex_realloc(",
+  "					(void *) yy_start_stack, new_size );",
+  "",
+  "		if ( ! yy_start_stack )",
+  "			YY_FATAL_ERROR(",
+  "			\"out of memory expanding start-condition stack\" );",
+  "		}",
+  "",
+  "	yy_start_stack[yy_start_stack_ptr++] = YY_START;",
+  "",
+  "	BEGIN(new_state);",
+  "	}",
+  "",
+  "",
+  "%-",
+  "static void yy_pop_state()",
+  "%+",
+  "void yyFlexLexer::yy_pop_state()",
+  "%*",
+  "	{",
+  "	if ( --yy_start_stack_ptr < 0 )",
+  "		YY_FATAL_ERROR( \"start-condition stack underflow\" );",
+  "",
+  "	BEGIN(yy_start_stack[yy_start_stack_ptr]);",
+  "	}",
+  "",
+  "",
+  "%-",
+  "static int yy_top_state()",
+  "%+",
+  "int yyFlexLexer::yy_top_state()",
+  "%*",
+  "	{",
+  "	return yy_start_stack[yy_start_stack_ptr - 1];",
+  "	}",
+  "",
+  "",
+  "%-",
+  "#ifdef YY_USE_PROTOS",
+  "static void yy_fatal_error( const char msg[] )",
+  "#else",
+  "static void yy_fatal_error( msg )",
+  "char msg[];",
+  "#endif",
+  "	{",
+  "	(void) fprintf( stderr, \"%s\\n\", msg );",
+  "	exit( 1 );",
+  "	}",
+  "",
+  "%+",
+  "",
+  "void yyFlexLexer::LexerError( const char msg[] )",
+  "	{",
+  "	cerr << msg << '\\n';",
+  "	exit( 1 );",
+  "	}",
+  "%*",
+  "",
+  "",
+  "/* Redefine yyless() so it works in section 3 code. */",
+  "",
+  "#undef yyless",
+  "#define yyless(n) \\",
+  "	do \\",
+  "		{ \\",
+  "		/* Undo effects of setting up yytext. */ \\",
+  "		yytext[yyleng] = yy_hold_char; \\",
+  "		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \\",
+  "		yy_hold_char = *yy_c_buf_p; \\",
+  "		*yy_c_buf_p = '\\0'; \\",
+  "		yyleng = n; \\",
+  "		} \\",
+  "	while ( 0 )",
+  "",
+  "",
+  "/* Internal utility routines. */",
+  "",
+  "#ifndef yytext_ptr",
+  "#ifdef YY_USE_PROTOS",
+  "static void yy_flex_strncpy( char *s1, const char *s2, int n )",
+  "#else",
+  "static void yy_flex_strncpy( s1, s2, n )",
+  "char *s1;",
+  "const char *s2;",
+  "int n;",
+  "#endif",
+  "	{",
+  "	register int i;",
+  "	for ( i = 0; i < n; ++i )",
+  "		s1[i] = s2[i];",
+  "	}",
+  "#endif",
+  "",
+  "",
+  "#ifdef YY_USE_PROTOS",
+  "static void *yy_flex_alloc( unsigned int size )",
+  "#else",
+  "static void *yy_flex_alloc( size )",
+  "unsigned int size;",
+  "#endif",
+  "	{",
+  "	return (void *) malloc( size );",
+  "	}",
+  "",
+  "#ifdef YY_USE_PROTOS",
+  "static void *yy_flex_realloc( void *ptr, unsigned int size )",
+  "#else",
+  "static void *yy_flex_realloc( ptr, size )",
+  "void *ptr;",
+  "unsigned int size;",
+  "#endif",
+  "	{",
+  "	return (void *) realloc( ptr, size );",
+  "	}",
+  "",
+  "#ifdef YY_USE_PROTOS",
+  "static void yy_flex_free( void *ptr )",
+  "#else",
+  "static void yy_flex_free( ptr )",
+  "void *ptr;",
+  "#endif",
+  "	{",
+  "	free( ptr );",
+  "	}",
+  0
+};
diff --git a/usr.bin/lex/sym.c b/usr.bin/lex/sym.c
new file mode 100644
index 000000000000..3c156fe9faf0
--- /dev/null
+++ b/usr.bin/lex/sym.c
@@ -0,0 +1,262 @@
+/* sym - symbol table routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: sym.c,v 1.2 94/01/04 14:33:06 vern Exp $ */
+
+#include "flexdef.h"
+
+
+/* declare functions that have forward references */
+
+int hashfunct PROTO((register char[], int));
+
+
+struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
+struct hash_entry *sctbl[START_COND_HASH_SIZE];
+struct hash_entry *ccltab[CCL_HASH_SIZE];
+
+struct hash_entry *findsym();
+
+
+/* addsym - add symbol and definitions to symbol table
+ *
+ * -1 is returned if the symbol already exists, and the change not made.
+ */
+
+int addsym( sym, str_def, int_def, table, table_size )
+register char sym[];
+char *str_def;
+int int_def;
+hash_table table;
+int table_size;
+	{
+	int hash_val = hashfunct( sym, table_size );
+	register struct hash_entry *sym_entry = table[hash_val];
+	register struct hash_entry *new_entry;
+	register struct hash_entry *successor;
+
+	while ( sym_entry )
+		{
+		if ( ! strcmp( sym, sym_entry->name ) )
+			{ /* entry already exists */
+			return -1;
+			}
+
+		sym_entry = sym_entry->next;
+		}
+
+	/* create new entry */
+	new_entry = (struct hash_entry *)
+		flex_alloc( sizeof( struct hash_entry ) );
+
+	if ( new_entry == NULL )
+		flexfatal( "symbol table memory allocation failed" );
+
+	if ( (successor = table[hash_val]) )
+		{
+		new_entry->next = successor;
+		successor->prev = new_entry;
+		}
+	else
+		new_entry->next = NULL;
+
+	new_entry->prev = NULL;
+	new_entry->name = sym;
+	new_entry->str_val = str_def;
+	new_entry->int_val = int_def;
+
+	table[hash_val] = new_entry;
+
+	return 0;
+	}
+
+
+/* cclinstal - save the text of a character class */
+
+void cclinstal( ccltxt, cclnum )
+Char ccltxt[];
+int cclnum;
+	{
+	/* We don't bother checking the return status because we are not
+	 * called unless the symbol is new.
+	 */
+	Char *copy_unsigned_string();
+
+	(void) addsym( (char *) copy_unsigned_string( ccltxt ),
+			(char *) 0, cclnum,
+			ccltab, CCL_HASH_SIZE );
+	}
+
+
+/* ccllookup - lookup the number associated with character class text
+ *
+ * Returns 0 if there's no CCL associated with the text.
+ */
+
+int ccllookup( ccltxt )
+Char ccltxt[];
+	{
+	return findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val;
+	}
+
+
+/* findsym - find symbol in symbol table */
+
+struct hash_entry *findsym( sym, table, table_size )
+register char sym[];
+hash_table table;
+int table_size;
+	{
+	static struct hash_entry empty_entry =
+		{
+		(struct hash_entry *) 0, (struct hash_entry *) 0,
+		(char *) 0, (char *) 0, 0,
+		} ;
+	register struct hash_entry *sym_entry =
+		table[hashfunct( sym, table_size )];
+
+	while ( sym_entry )
+		{
+		if ( ! strcmp( sym, sym_entry->name ) )
+			return sym_entry;
+		sym_entry = sym_entry->next;
+		}
+
+	return &empty_entry;
+	}
+
+    
+/* hashfunct - compute the hash value for "str" and hash size "hash_size" */
+
+int hashfunct( str, hash_size )
+register char str[];
+int hash_size;
+	{
+	register int hashval;
+	register int locstr;
+
+	hashval = 0;
+	locstr = 0;
+
+	while ( str[locstr] )
+		{
+		hashval = (hashval << 1) + (unsigned char) str[locstr++];
+		hashval %= hash_size;
+		}
+
+	return hashval;
+	}
+
+
+/* ndinstal - install a name definition */
+
+void ndinstal( name, definition )
+char name[];
+Char definition[];
+	{
+	char *copy_string();
+	Char *copy_unsigned_string();
+
+	if ( addsym( copy_string( name ),
+			(char *) copy_unsigned_string( definition ), 0,
+			ndtbl, NAME_TABLE_HASH_SIZE ) )
+		synerr( "name defined twice" );
+	}
+
+
+/* ndlookup - lookup a name definition
+ *
+ * Returns a nil pointer if the name definition does not exist.
+ */
+
+Char *ndlookup( nd )
+char nd[];
+	{
+	return (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val;
+	}
+
+
+/* scextend - increase the maximum number of start conditions */
+
+void scextend()
+	{
+	current_max_scs += MAX_SCS_INCREMENT;
+
+	++num_reallocs;
+
+	scset = reallocate_integer_array( scset, current_max_scs );
+	scbol = reallocate_integer_array( scbol, current_max_scs );
+	scxclu = reallocate_integer_array( scxclu, current_max_scs );
+	sceof = reallocate_integer_array( sceof, current_max_scs );
+	scname = reallocate_char_ptr_array( scname, current_max_scs );
+	actvsc = reallocate_integer_array( actvsc, current_max_scs );
+	}
+
+
+/* scinstal - make a start condition
+ *
+ * NOTE
+ *    The start condition is "exclusive" if xcluflg is true.
+ */
+
+void scinstal( str, xcluflg )
+char str[];
+int xcluflg;
+	{
+	char *copy_string();
+
+	/* Generate start condition definition, for use in BEGIN et al. */
+	printf( "#define %s %d\n", str, lastsc );
+
+	if ( ++lastsc >= current_max_scs )
+		scextend();
+
+	scname[lastsc] = copy_string( str );
+
+	if ( addsym( scname[lastsc], (char *) 0, lastsc,
+			sctbl, START_COND_HASH_SIZE ) )
+		format_pinpoint_message( "start condition %s declared twice",
+					str );
+
+	scset[lastsc] = mkstate( SYM_EPSILON );
+	scbol[lastsc] = mkstate( SYM_EPSILON );
+	scxclu[lastsc] = xcluflg;
+	sceof[lastsc] = false;
+	}
+
+
+/* sclookup - lookup the number associated with a start condition
+ *
+ * Returns 0 if no such start condition.
+ */
+
+int sclookup( str )
+char str[];
+	{
+	return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
+	}
diff --git a/usr.bin/lex/tblcmp.c b/usr.bin/lex/tblcmp.c
new file mode 100644
index 000000000000..224dd13883b5
--- /dev/null
+++ b/usr.bin/lex/tblcmp.c
@@ -0,0 +1,888 @@
+/* tblcmp - table compression routines */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/tblcmp.c,v 2.10 93/12/07 10:18:30 vern Exp $ */
+
+#include "flexdef.h"
+
+
+/* declarations for functions that have forward references */
+
+void mkentry PROTO((register int*, int, int, int, int));
+void mkprot PROTO((int[], int, int));
+void mktemplate PROTO((int[], int, int));
+void mv2front PROTO((int));
+int tbldiff PROTO((int[], int, int[]));
+
+
+/* bldtbl - build table entries for dfa state
+ *
+ * synopsis
+ *   int state[numecs], statenum, totaltrans, comstate, comfreq;
+ *   bldtbl( state, statenum, totaltrans, comstate, comfreq );
+ *
+ * State is the statenum'th dfa state.  It is indexed by equivalence class and
+ * gives the number of the state to enter for a given equivalence class.
+ * totaltrans is the total number of transitions out of the state.  Comstate
+ * is that state which is the destination of the most transitions out of State.
+ * Comfreq is how many transitions there are out of State to Comstate.
+ *
+ * A note on terminology:
+ *    "protos" are transition tables which have a high probability of
+ * either being redundant (a state processed later will have an identical
+ * transition table) or nearly redundant (a state processed later will have
+ * many of the same out-transitions).  A "most recently used" queue of
+ * protos is kept around with the hope that most states will find a proto
+ * which is similar enough to be usable, and therefore compacting the
+ * output tables.
+ *    "templates" are a special type of proto.  If a transition table is
+ * homogeneous or nearly homogeneous (all transitions go to the same
+ * destination) then the odds are good that future states will also go
+ * to the same destination state on basically the same character set.
+ * These homogeneous states are so common when dealing with large rule
+ * sets that they merit special attention.  If the transition table were
+ * simply made into a proto, then (typically) each subsequent, similar
+ * state will differ from the proto for two out-transitions.  One of these
+ * out-transitions will be that character on which the proto does not go
+ * to the common destination, and one will be that character on which the
+ * state does not go to the common destination.  Templates, on the other
+ * hand, go to the common state on EVERY transition character, and therefore
+ * cost only one difference.
+ */
+
+void bldtbl( state, statenum, totaltrans, comstate, comfreq )
+int state[], statenum, totaltrans, comstate, comfreq;
+	{
+	int extptr, extrct[2][CSIZE + 1];
+	int mindiff, minprot, i, d;
+
+	/* If extptr is 0 then the first array of extrct holds the result
+	 * of the "best difference" to date, which is those transitions
+	 * which occur in "state" but not in the proto which, to date,
+	 * has the fewest differences between itself and "state".  If
+	 * extptr is 1 then the second array of extrct hold the best
+	 * difference.  The two arrays are toggled between so that the
+	 * best difference to date can be kept around and also a difference
+	 * just created by checking against a candidate "best" proto.
+	 */
+
+	extptr = 0;
+
+	/* If the state has too few out-transitions, don't bother trying to
+	 * compact its tables.
+	 */
+
+	if ( (totaltrans * 100) < (numecs * PROTO_SIZE_PERCENTAGE) )
+		mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
+
+	else
+		{
+		/* "checkcom" is true if we should only check "state" against
+		 * protos which have the same "comstate" value.
+		 */
+		int checkcom =
+			comfreq * 100 > totaltrans * CHECK_COM_PERCENTAGE;
+
+		minprot = firstprot;
+		mindiff = totaltrans;
+
+		if ( checkcom )
+			{
+			/* Find first proto which has the same "comstate". */
+			for ( i = firstprot; i != NIL; i = protnext[i] )
+				if ( protcomst[i] == comstate )
+					{
+					minprot = i;
+					mindiff = tbldiff( state, minprot,
+							extrct[extptr] );
+					break;
+					}
+			}
+
+		else
+			{
+			/* Since we've decided that the most common destination
+			 * out of "state" does not occur with a high enough
+			 * frequency, we set the "comstate" to zero, assuring
+			 * that if this state is entered into the proto list,
+			 * it will not be considered a template.
+			 */
+			comstate = 0;
+
+			if ( firstprot != NIL )
+				{
+				minprot = firstprot;
+				mindiff = tbldiff( state, minprot,
+						extrct[extptr] );
+				}
+			}
+
+		/* We now have the first interesting proto in "minprot".  If
+		 * it matches within the tolerances set for the first proto,
+		 * we don't want to bother scanning the rest of the proto list
+		 * to see if we have any other reasonable matches.
+		 */
+
+		if ( mindiff * 100 > totaltrans * FIRST_MATCH_DIFF_PERCENTAGE )
+			{
+			/* Not a good enough match.  Scan the rest of the
+			 * protos.
+			 */
+			for ( i = minprot; i != NIL; i = protnext[i] )
+				{
+				d = tbldiff( state, i, extrct[1 - extptr] );
+				if ( d < mindiff )
+					{
+					extptr = 1 - extptr;
+					mindiff = d;
+					minprot = i;
+					}
+				}
+			}
+
+		/* Check if the proto we've decided on as our best bet is close
+		 * enough to the state we want to match to be usable.
+		 */
+
+		if ( mindiff * 100 > totaltrans * ACCEPTABLE_DIFF_PERCENTAGE )
+			{
+			/* No good.  If the state is homogeneous enough,
+			 * we make a template out of it.  Otherwise, we
+			 * make a proto.
+			 */
+
+			if ( comfreq * 100 >=
+			     totaltrans * TEMPLATE_SAME_PERCENTAGE )
+				mktemplate( state, statenum, comstate );
+
+			else
+				{
+				mkprot( state, statenum, comstate );
+				mkentry( state, numecs, statenum,
+					JAMSTATE, totaltrans );
+				}
+			}
+
+		else
+			{ /* use the proto */
+			mkentry( extrct[extptr], numecs, statenum,
+				prottbl[minprot], mindiff );
+
+			/* If this state was sufficiently different from the
+			 * proto we built it from, make it, too, a proto.
+			 */
+
+			if ( mindiff * 100 >=
+			     totaltrans * NEW_PROTO_DIFF_PERCENTAGE )
+				mkprot( state, statenum, comstate );
+
+			/* Since mkprot added a new proto to the proto queue,
+			 * it's possible that "minprot" is no longer on the
+			 * proto queue (if it happened to have been the last
+			 * entry, it would have been bumped off).  If it's
+			 * not there, then the new proto took its physical
+			 * place (though logically the new proto is at the
+			 * beginning of the queue), so in that case the
+			 * following call will do nothing.
+			 */
+
+			mv2front( minprot );
+			}
+		}
+	}
+
+
+/* cmptmps - compress template table entries
+ *
+ * Template tables are compressed by using the 'template equivalence
+ * classes', which are collections of transition character equivalence
+ * classes which always appear together in templates - really meta-equivalence
+ * classes.
+ */
+
+void cmptmps()
+	{
+	int tmpstorage[CSIZE + 1];
+	register int *tmp = tmpstorage, i, j;
+	int totaltrans, trans;
+
+	peakpairs = numtemps * numecs + tblend;
+
+	if ( usemecs )
+		{
+		/* Create equivalence classes based on data gathered on
+		 * template transitions.
+		 */
+		nummecs = cre8ecs( tecfwd, tecbck, numecs );
+		}
+
+	else
+		nummecs = numecs;
+
+	while ( lastdfa + numtemps + 1 >= current_max_dfas )
+		increase_max_dfas();
+
+	/* Loop through each template. */
+
+	for ( i = 1; i <= numtemps; ++i )
+		{
+		/* Number of non-jam transitions out of this template. */
+		totaltrans = 0;
+
+		for ( j = 1; j <= numecs; ++j )
+			{
+			trans = tnxt[numecs * i + j];
+
+			if ( usemecs )
+				{
+				/* The absolute value of tecbck is the
+				 * meta-equivalence class of a given
+				 * equivalence class, as set up by cre8ecs().
+				 */
+				if ( tecbck[j] > 0 )
+					{
+					tmp[tecbck[j]] = trans;
+
+					if ( trans > 0 )
+						++totaltrans;
+					}
+				}
+
+			else
+				{
+				tmp[j] = trans;
+
+				if ( trans > 0 )
+					++totaltrans;
+				}
+			}
+
+		/* It is assumed (in a rather subtle way) in the skeleton
+		 * that if we're using meta-equivalence classes, the def[]
+		 * entry for all templates is the jam template, i.e.,
+		 * templates never default to other non-jam table entries
+		 * (e.g., another template)
+		 */
+
+		/* Leave room for the jam-state after the last real state. */
+		mkentry( tmp, nummecs, lastdfa + i + 1, JAMSTATE, totaltrans );
+		}
+	}
+
+
+
+/* expand_nxt_chk - expand the next check arrays */
+
+void expand_nxt_chk()
+	{
+	register int old_max = current_max_xpairs;
+
+	current_max_xpairs += MAX_XPAIRS_INCREMENT;
+
+	++num_reallocs;
+
+	nxt = reallocate_integer_array( nxt, current_max_xpairs );
+	chk = reallocate_integer_array( chk, current_max_xpairs );
+
+	zero_out( (char *) (chk + old_max),
+		MAX_XPAIRS_INCREMENT * sizeof( int ) / sizeof( char ) );
+	}
+
+
+/* find_table_space - finds a space in the table for a state to be placed
+ *
+ * synopsis
+ *     int *state, numtrans, block_start;
+ *     int find_table_space();
+ *
+ *     block_start = find_table_space( state, numtrans );
+ *
+ * State is the state to be added to the full speed transition table.
+ * Numtrans is the number of out-transitions for the state.
+ *
+ * find_table_space() returns the position of the start of the first block (in
+ * chk) able to accommodate the state
+ *
+ * In determining if a state will or will not fit, find_table_space() must take
+ * into account the fact that an end-of-buffer state will be added at [0],
+ * and an action number will be added in [-1].
+ */
+
+int find_table_space( state, numtrans )
+int *state, numtrans;
+	{
+	/* Firstfree is the position of the first possible occurrence of two
+	 * consecutive unused records in the chk and nxt arrays.
+	 */
+	register int i;
+	register int *state_ptr, *chk_ptr;
+	register int *ptr_to_last_entry_in_state;
+
+	/* If there are too many out-transitions, put the state at the end of
+	 * nxt and chk.
+	 */
+	if ( numtrans > MAX_XTIONS_FULL_INTERIOR_FIT )
+		{
+		/* If table is empty, return the first available spot in
+		 * chk/nxt, which should be 1.
+		 */
+		if ( tblend < 2 )
+			return 1;
+
+		/* Start searching for table space near the end of
+		 * chk/nxt arrays.
+		 */
+		i = tblend - numecs;
+		}
+
+	else
+		/* Start searching for table space from the beginning
+		 * (skipping only the elements which will definitely not
+		 * hold the new state).
+		 */
+		i = firstfree;
+
+	while ( 1 )	/* loops until a space is found */
+		{
+		while ( i + numecs >= current_max_xpairs )
+			expand_nxt_chk();
+
+		/* Loops until space for end-of-buffer and action number
+		 * are found.
+		 */
+		while ( 1 )
+			{
+			/* Check for action number space. */
+			if ( chk[i - 1] == 0 )
+				{
+				/* Check for end-of-buffer space. */
+				if ( chk[i] == 0 )
+					break;
+
+				else
+					/* Since i != 0, there is no use
+					 * checking to see if (++i) - 1 == 0,
+					 * because that's the same as i == 0,
+					 * so we skip a space.
+					 */
+					i += 2;
+				}
+
+			else
+				++i;
+
+			while ( i + numecs >= current_max_xpairs )
+				expand_nxt_chk();
+			}
+
+		/* If we started search from the beginning, store the new
+		 * firstfree for the next call of find_table_space().
+		 */
+		if ( numtrans <= MAX_XTIONS_FULL_INTERIOR_FIT )
+			firstfree = i + 1;
+
+		/* Check to see if all elements in chk (and therefore nxt)
+		 * that are needed for the new state have not yet been taken.
+		 */
+
+		state_ptr = &state[1];
+		ptr_to_last_entry_in_state = &chk[i + numecs + 1];
+
+		for ( chk_ptr = &chk[i + 1];
+		      chk_ptr != ptr_to_last_entry_in_state; ++chk_ptr )
+			if ( *(state_ptr++) != 0 && *chk_ptr != 0 )
+				break;
+
+		if ( chk_ptr == ptr_to_last_entry_in_state )
+			return i;
+
+		else
+		++i;
+		}
+	}
+
+
+/* inittbl - initialize transition tables
+ *
+ * Initializes "firstfree" to be one beyond the end of the table.  Initializes
+ * all "chk" entries to be zero.
+ */
+void inittbl()
+	{
+	register int i;
+
+	zero_out( (char *) chk,
+		current_max_xpairs * sizeof( int ) / sizeof( char ) );
+
+	tblend = 0;
+	firstfree = tblend + 1;
+	numtemps = 0;
+
+	if ( usemecs )
+		{
+		/* Set up doubly-linked meta-equivalence classes; these
+		 * are sets of equivalence classes which all have identical
+		 * transitions out of TEMPLATES.
+		 */
+
+		tecbck[1] = NIL;
+
+		for ( i = 2; i <= numecs; ++i )
+			{
+			tecbck[i] = i - 1;
+			tecfwd[i - 1] = i;
+			}
+
+		tecfwd[numecs] = NIL;
+		}
+	}
+
+
+/* mkdeftbl - make the default, "jam" table entries */
+
+void mkdeftbl()
+	{
+	int i;
+
+	jamstate = lastdfa + 1;
+
+	++tblend; /* room for transition on end-of-buffer character */
+
+	while ( tblend + numecs >= current_max_xpairs )
+		expand_nxt_chk();
+
+	/* Add in default end-of-buffer transition. */
+	nxt[tblend] = end_of_buffer_state;
+	chk[tblend] = jamstate;
+
+	for ( i = 1; i <= numecs; ++i )
+		{
+		nxt[tblend + i] = 0;
+		chk[tblend + i] = jamstate;
+		}
+
+	jambase = tblend;
+
+	base[jamstate] = jambase;
+	def[jamstate] = 0;
+
+	tblend += numecs;
+	++numtemps;
+	}
+
+
+/* mkentry - create base/def and nxt/chk entries for transition array
+ *
+ * synopsis
+ *   int state[numchars + 1], numchars, statenum, deflink, totaltrans;
+ *   mkentry( state, numchars, statenum, deflink, totaltrans );
+ *
+ * "state" is a transition array "numchars" characters in size, "statenum"
+ * is the offset to be used into the base/def tables, and "deflink" is the
+ * entry to put in the "def" table entry.  If "deflink" is equal to
+ * "JAMSTATE", then no attempt will be made to fit zero entries of "state"
+ * (i.e., jam entries) into the table.  It is assumed that by linking to
+ * "JAMSTATE" they will be taken care of.  In any case, entries in "state"
+ * marking transitions to "SAME_TRANS" are treated as though they will be
+ * taken care of by whereever "deflink" points.  "totaltrans" is the total
+ * number of transitions out of the state.  If it is below a certain threshold,
+ * the tables are searched for an interior spot that will accommodate the
+ * state array.
+ */
+
+void mkentry( state, numchars, statenum, deflink, totaltrans )
+register int *state;
+int numchars, statenum, deflink, totaltrans;
+	{
+	register int minec, maxec, i, baseaddr;
+	int tblbase, tbllast;
+
+	if ( totaltrans == 0 )
+		{ /* there are no out-transitions */
+		if ( deflink == JAMSTATE )
+			base[statenum] = JAMSTATE;
+		else
+			base[statenum] = 0;
+
+		def[statenum] = deflink;
+		return;
+		}
+
+	for ( minec = 1; minec <= numchars; ++minec )
+		{
+		if ( state[minec] != SAME_TRANS )
+			if ( state[minec] != 0 || deflink != JAMSTATE )
+				break;
+		}
+
+	if ( totaltrans == 1 )
+		{
+		/* There's only one out-transition.  Save it for later to fill
+		 * in holes in the tables.
+		 */
+		stack1( statenum, minec, state[minec], deflink );
+		return;
+		}
+
+	for ( maxec = numchars; maxec > 0; --maxec )
+		{
+		if ( state[maxec] != SAME_TRANS )
+			if ( state[maxec] != 0 || deflink != JAMSTATE )
+				break;
+		}
+
+	/* Whether we try to fit the state table in the middle of the table
+	 * entries we have already generated, or if we just take the state
+	 * table at the end of the nxt/chk tables, we must make sure that we
+	 * have a valid base address (i.e., non-negative).  Note that
+	 * negative base addresses dangerous at run-time (because indexing
+	 * the nxt array with one and a low-valued character will access
+	 * memory before the start of the array.
+	 */
+
+	/* Find the first transition of state that we need to worry about. */
+	if ( totaltrans * 100 <= numchars * INTERIOR_FIT_PERCENTAGE )
+		{
+		/* Attempt to squeeze it into the middle of the tables. */
+		baseaddr = firstfree;
+
+		while ( baseaddr < minec )
+			{
+			/* Using baseaddr would result in a negative base
+			 * address below; find the next free slot.
+			 */
+			for ( ++baseaddr; chk[baseaddr] != 0; ++baseaddr )
+				;
+			}
+
+		while ( baseaddr + maxec - minec + 1 >= current_max_xpairs )
+			expand_nxt_chk();
+
+		for ( i = minec; i <= maxec; ++i )
+			if ( state[i] != SAME_TRANS &&
+			     (state[i] != 0 || deflink != JAMSTATE) &&
+			     chk[baseaddr + i - minec] != 0 )
+				{ /* baseaddr unsuitable - find another */
+				for ( ++baseaddr;
+				      baseaddr < current_max_xpairs &&
+				      chk[baseaddr] != 0; ++baseaddr )
+					;
+
+				while ( baseaddr + maxec - minec + 1 >=
+					current_max_xpairs )
+					expand_nxt_chk();
+
+				/* Reset the loop counter so we'll start all
+				 * over again next time it's incremented.
+				 */
+
+				i = minec - 1;
+				}
+		}
+
+	else
+		{
+		/* Ensure that the base address we eventually generate is
+		 * non-negative.
+		 */
+		baseaddr = MAX( tblend + 1, minec );
+		}
+
+	tblbase = baseaddr - minec;
+	tbllast = tblbase + maxec;
+
+	while ( tbllast + 1 >= current_max_xpairs )
+		expand_nxt_chk();
+
+	base[statenum] = tblbase;
+	def[statenum] = deflink;
+
+	for ( i = minec; i <= maxec; ++i )
+		if ( state[i] != SAME_TRANS )
+			if ( state[i] != 0 || deflink != JAMSTATE )
+				{
+				nxt[tblbase + i] = state[i];
+				chk[tblbase + i] = statenum;
+				}
+
+	if ( baseaddr == firstfree )
+		/* Find next free slot in tables. */
+		for ( ++firstfree; chk[firstfree] != 0; ++firstfree )
+			;
+
+	tblend = MAX( tblend, tbllast );
+	}
+
+
+/* mk1tbl - create table entries for a state (or state fragment) which
+ *            has only one out-transition
+ */
+
+void mk1tbl( state, sym, onenxt, onedef )
+int state, sym, onenxt, onedef;
+	{
+	if ( firstfree < sym )
+		firstfree = sym;
+
+	while ( chk[firstfree] != 0 )
+		if ( ++firstfree >= current_max_xpairs )
+			expand_nxt_chk();
+
+	base[state] = firstfree - sym;
+	def[state] = onedef;
+	chk[firstfree] = state;
+	nxt[firstfree] = onenxt;
+
+	if ( firstfree > tblend )
+		{
+		tblend = firstfree++;
+
+		if ( firstfree >= current_max_xpairs )
+			expand_nxt_chk();
+		}
+	}
+
+
+/* mkprot - create new proto entry */
+
+void mkprot( state, statenum, comstate )
+int state[], statenum, comstate;
+	{
+	int i, slot, tblbase;
+
+	if ( ++numprots >= MSP || numecs * numprots >= PROT_SAVE_SIZE )
+		{
+		/* Gotta make room for the new proto by dropping last entry in
+		 * the queue.
+		 */
+		slot = lastprot;
+		lastprot = protprev[lastprot];
+		protnext[lastprot] = NIL;
+		}
+
+	else
+		slot = numprots;
+
+	protnext[slot] = firstprot;
+
+	if ( firstprot != NIL )
+		protprev[firstprot] = slot;
+
+	firstprot = slot;
+	prottbl[slot] = statenum;
+	protcomst[slot] = comstate;
+
+	/* Copy state into save area so it can be compared with rapidly. */
+	tblbase = numecs * (slot - 1);
+
+	for ( i = 1; i <= numecs; ++i )
+		protsave[tblbase + i] = state[i];
+	}
+
+
+/* mktemplate - create a template entry based on a state, and connect the state
+ *              to it
+ */
+
+void mktemplate( state, statenum, comstate )
+int state[], statenum, comstate;
+	{
+	int i, numdiff, tmpbase, tmp[CSIZE + 1];
+	Char transset[CSIZE + 1];
+	int tsptr;
+
+	++numtemps;
+
+	tsptr = 0;
+
+	/* Calculate where we will temporarily store the transition table
+	 * of the template in the tnxt[] array.  The final transition table
+	 * gets created by cmptmps().
+	 */
+
+	tmpbase = numtemps * numecs;
+
+	if ( tmpbase + numecs >= current_max_template_xpairs )
+		{
+		current_max_template_xpairs += MAX_TEMPLATE_XPAIRS_INCREMENT;
+
+		++num_reallocs;
+
+		tnxt = reallocate_integer_array( tnxt,
+			current_max_template_xpairs );
+		}
+
+	for ( i = 1; i <= numecs; ++i )
+		if ( state[i] == 0 )
+			tnxt[tmpbase + i] = 0;
+		else
+			{
+			transset[tsptr++] = i;
+			tnxt[tmpbase + i] = comstate;
+			}
+
+	if ( usemecs )
+		mkeccl( transset, tsptr, tecfwd, tecbck, numecs, 0 );
+
+	mkprot( tnxt + tmpbase, -numtemps, comstate );
+
+	/* We rely on the fact that mkprot adds things to the beginning
+	 * of the proto queue.
+	 */
+
+	numdiff = tbldiff( state, firstprot, tmp );
+	mkentry( tmp, numecs, statenum, -numtemps, numdiff );
+	}
+
+
+/* mv2front - move proto queue element to front of queue */
+
+void mv2front( qelm )
+int qelm;
+	{
+	if ( firstprot != qelm )
+		{
+		if ( qelm == lastprot )
+			lastprot = protprev[lastprot];
+
+		protnext[protprev[qelm]] = protnext[qelm];
+
+		if ( protnext[qelm] != NIL )
+			protprev[protnext[qelm]] = protprev[qelm];
+
+		protprev[qelm] = NIL;
+		protnext[qelm] = firstprot;
+		protprev[firstprot] = qelm;
+		firstprot = qelm;
+		}
+	}
+
+
+/* place_state - place a state into full speed transition table
+ *
+ * State is the statenum'th state.  It is indexed by equivalence class and
+ * gives the number of the state to enter for a given equivalence class.
+ * Transnum is the number of out-transitions for the state.
+ */
+
+void place_state( state, statenum, transnum )
+int *state, statenum, transnum;
+	{
+	register int i;
+	register int *state_ptr;
+	int position = find_table_space( state, transnum );
+
+	/* "base" is the table of start positions. */
+	base[statenum] = position;
+
+	/* Put in action number marker; this non-zero number makes sure that
+	 * find_table_space() knows that this position in chk/nxt is taken
+	 * and should not be used for another accepting number in another
+	 * state.
+	 */
+	chk[position - 1] = 1;
+
+	/* Put in end-of-buffer marker; this is for the same purposes as
+	 * above.
+	 */
+	chk[position] = 1;
+
+	/* Place the state into chk and nxt. */
+	state_ptr = &state[1];
+
+	for ( i = 1; i <= numecs; ++i, ++state_ptr )
+		if ( *state_ptr != 0 )
+			{
+			chk[position + i] = i;
+			nxt[position + i] = *state_ptr;
+			}
+
+	if ( position + numecs > tblend )
+		tblend = position + numecs;
+	}
+
+
+/* stack1 - save states with only one out-transition to be processed later
+ *
+ * If there's room for another state on the "one-transition" stack, the
+ * state is pushed onto it, to be processed later by mk1tbl.  If there's
+ * no room, we process the sucker right now.
+ */
+
+void stack1( statenum, sym, nextstate, deflink )
+int statenum, sym, nextstate, deflink;
+	{
+	if ( onesp >= ONE_STACK_SIZE - 1 )
+		mk1tbl( statenum, sym, nextstate, deflink );
+
+	else
+		{
+		++onesp;
+		onestate[onesp] = statenum;
+		onesym[onesp] = sym;
+		onenext[onesp] = nextstate;
+		onedef[onesp] = deflink;
+		}
+	}
+
+
+/* tbldiff - compute differences between two state tables
+ *
+ * "state" is the state array which is to be extracted from the pr'th
+ * proto.  "pr" is both the number of the proto we are extracting from
+ * and an index into the save area where we can find the proto's complete
+ * state table.  Each entry in "state" which differs from the corresponding
+ * entry of "pr" will appear in "ext".
+ *
+ * Entries which are the same in both "state" and "pr" will be marked
+ * as transitions to "SAME_TRANS" in "ext".  The total number of differences
+ * between "state" and "pr" is returned as function value.  Note that this
+ * number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
+ */
+
+int tbldiff( state, pr, ext )
+int state[], pr, ext[];
+	{
+	register int i, *sp = state, *ep = ext, *protp;
+	register int numdiff = 0;
+
+	protp = &protsave[numecs * (pr - 1)];
+
+	for ( i = numecs; i > 0; --i )
+		{
+		if ( *++protp == *++sp )
+			*++ep = SAME_TRANS;
+		else
+			{
+			*++ep = *sp;
+			++numdiff;
+			}
+		}
+
+	return numdiff;
+	}
diff --git a/usr.bin/lex/version.h b/usr.bin/lex/version.h
new file mode 100644
index 000000000000..633a31ef947e
--- /dev/null
+++ b/usr.bin/lex/version.h
@@ -0,0 +1 @@
+#define FLEX_VERSION "2.4.7"
diff --git a/usr.bin/lex/yylex.c b/usr.bin/lex/yylex.c
new file mode 100644
index 000000000000..563297a094b2
--- /dev/null
+++ b/usr.bin/lex/yylex.c
@@ -0,0 +1,199 @@
+/* yylex - scanner front-end for flex */
+
+/*-
+ * 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.
+ *
+ * Redistribution and use in source and binary forms are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+/* $Header: /home/daffy/u0/vern/flex/RCS/yylex.c,v 2.10 93/09/16 20:31:48 vern Exp $ */
+
+#include <ctype.h>
+#include "flexdef.h"
+#include "parse.h"
+
+
+/* yylex - scan for a regular expression token */
+
+int yylex()
+	{
+	int toktype;
+	static int beglin = false;
+
+	if ( eofseen )
+		toktype = EOF;
+	else
+		toktype = flexscan();
+
+	if ( toktype == EOF || toktype == 0 )
+		{
+		eofseen = 1;
+
+		if ( sectnum == 1 )
+			{
+			synerr( "premature EOF" );
+			sectnum = 2;
+			toktype = SECTEND;
+			}
+
+		else
+			toktype = 0;
+		}
+
+	if ( trace )
+		{
+		if ( beglin )
+			{
+			fprintf( stderr, "%d\t", num_rules + 1 );
+			beglin = 0;
+			}
+
+		switch ( toktype )
+			{
+			case '<':
+			case '>':
+			case '^':
+			case '$':
+			case '"':
+			case '[':
+			case ']':
+			case '{':
+			case '}':
+			case '|':
+			case '(':
+			case ')':
+			case '-':
+			case '/':
+			case '\\':
+			case '?':
+			case '.':
+			case '*':
+			case '+':
+			case ',':
+				(void) putc( toktype, stderr );
+				break;
+
+			case '\n':
+				(void) putc( '\n', stderr );
+
+				if ( sectnum == 2 )
+				beglin = 1;
+
+				break;
+
+			case SCDECL:
+				fputs( "%s", stderr );
+				break;
+
+			case XSCDECL:
+				fputs( "%x", stderr );
+				break;
+
+			case WHITESPACE:
+				(void) putc( ' ', stderr );
+				break;
+
+			case SECTEND:
+				fputs( "%%\n", stderr );
+
+				/* We set beglin to be true so we'll start
+				 * writing out numbers as we echo rules.
+				 * flexscan() has already assigned sectnum.
+				 */
+
+				if ( sectnum == 2 )
+				beglin = 1;
+
+				break;
+
+			case NAME:
+				fprintf( stderr, "'%s'", nmstr );
+				break;
+
+			case CHAR:
+				switch ( yylval )
+					{
+					case '<':
+					case '>':
+					case '^':
+					case '$':
+					case '"':
+					case '[':
+					case ']':
+					case '{':
+					case '}':
+					case '|':
+					case '(':
+					case ')':
+					case '-':
+					case '/':
+					case '\\':
+					case '?':
+					case '.':
+					case '*':
+					case '+':
+					case ',':
+						fprintf( stderr, "\\%c",
+							yylval );
+						break;
+
+					default:
+						if ( ! isascii( yylval ) ||
+						     ! isprint( yylval ) )
+							fprintf( stderr,
+								"\\%.3o",
+							(unsigned int) yylval );
+						else
+							(void) putc( yylval,
+								stderr );
+					break;
+					}
+
+				break;
+
+			case NUMBER:
+				fprintf( stderr, "%d", yylval );
+				break;
+
+			case PREVCCL:
+				fprintf( stderr, "[%d]", yylval );
+				break;
+
+			case EOF_OP:
+				fprintf( stderr, "<<EOF>>" );
+				break;
+
+			case 0:
+				fprintf( stderr, "End Marker" );
+				break;
+
+			default:
+				fprintf( stderr,
+					"*Something Weird* - tok: %d val: %d\n",
+					toktype, yylval );
+				break;
+			}
+		}
+
+	return toktype;
+	}