merge tag v2.6.1

Signed-off-by: Manoj Srivastava <srivasta@debian.org>

24 files changed, 879 insertions, 1248 deletions

diff --git a/src/FlexLexer.h b/src/FlexLexer.h
index b725b1f..c4dad2b 100644
--- a/src/FlexLexer.h
+++ b/src/FlexLexer.h
@@ -35,78 +35,74 @@
 // to rename each yyFlexLexer to some other xxFlexLexer.  You then
 // include <FlexLexer.h> in your other sources once per lexer class:
 //
-//	#undef yyFlexLexer
-//	#define yyFlexLexer xxFlexLexer
-//	#include <FlexLexer.h>
+//      #undef yyFlexLexer
+//      #define yyFlexLexer xxFlexLexer
+//      #include <FlexLexer.h>
 //
-//	#undef yyFlexLexer
-//	#define yyFlexLexer zzFlexLexer
-//	#include <FlexLexer.h>
-//	...
+//      #undef yyFlexLexer
+//      #define yyFlexLexer zzFlexLexer
+//      #include <FlexLexer.h>
+//      ...
 
 #ifndef __FLEX_LEXER_H
 // Never included before - need to define base class.
 #define __FLEX_LEXER_H
 
 #include <iostream>
-#  ifndef FLEX_STD
-#    define FLEX_STD std::
-#  endif
 
 extern "C++" {
 
 struct yy_buffer_state;
 typedef int yy_state_type;
 
-class FlexLexer {
+class FlexLexer
+{
 public:
-	virtual ~FlexLexer()	{ }
-
-	const char* YYText() const	{ return yytext; }
-	int YYLeng()	const	{ return yyleng; }
-
-	virtual void
-		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
-	virtual struct yy_buffer_state*
-		yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
-	virtual struct yy_buffer_state*
-		yy_create_buffer( FLEX_STD istream& s, int size ) = 0;
-	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
-	virtual void yyrestart( FLEX_STD istream* s ) = 0;	
-	virtual void yyrestart( FLEX_STD istream& s ) = 0;
-
-	virtual int yylex() = 0;
-
-	// Call yylex with new input/output sources.
-	int yylex( FLEX_STD istream& new_in, FLEX_STD ostream& new_out )
-	{
-		switch_streams( new_in, new_out );
-		return yylex();
-	}
-	
-	int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0)
-	{
-		switch_streams( new_in, new_out );
-		return yylex();
-	}
-
-	// Switch to new input/output streams.  A nil stream pointer
-	// indicates "keep the current one".
-	virtual void switch_streams( FLEX_STD istream* new_in,
-					FLEX_STD ostream* new_out ) = 0;
-	virtual void switch_streams( FLEX_STD istream& new_in,
-					FLEX_STD ostream& new_out ) = 0;
-
-	int lineno() const		{ return yylineno; }
-
-	int debug() const		{ return yy_flex_debug; }
-	void set_debug( int flag )	{ yy_flex_debug = flag; }
+  virtual ~FlexLexer()        { }
+
+  const char* YYText() const  { return yytext; }
+  int YYLeng()        const   { return yyleng; }
+
+  virtual void
+  yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
+  virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
+  virtual void yyrestart( std::istream* s ) = 0;
+  virtual void yyrestart( std::istream& s ) = 0;
+
+  virtual int yylex() = 0;
+
+  // Call yylex with new input/output sources.
+  int yylex( std::istream& new_in, std::ostream& new_out )
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  int yylex( std::istream* new_in, std::ostream* new_out = 0)
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  // Switch to new input/output streams.  A nil stream pointer
+  // indicates "keep the current one".
+  virtual void switch_streams( std::istream* new_in,
+                               std::ostream* new_out ) = 0;
+  virtual void switch_streams( std::istream& new_in,
+                               std::ostream& new_out ) = 0;
+
+  int lineno() const          { return yylineno; }
+
+  int debug() const           { return yy_flex_debug; }
+  void set_debug( int flag )  { yy_flex_debug = flag; }
 
 protected:
-	char* yytext;
-	int yyleng;
-	int yylineno;		// only maintained if you use %option yylineno
-	int yy_flex_debug;	// only has effect with -d or "%option debug"
+  char* yytext;
+  int yyleng;
+  int yylineno;       // only maintained if you use %option yylineno
+  int yy_flex_debug;  // only has effect with -d or "%option debug"
 };
 
 }
@@ -116,110 +112,109 @@ protected:
 // Either this is the first time through (yyFlexLexerOnce not defined),
 // or this is a repeated include to define a different flavor of
 // yyFlexLexer, as discussed in the flex manual.
-#define yyFlexLexerOnce
+# define yyFlexLexerOnce
 
 extern "C++" {
 
 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( FLEX_STD istream& arg_yyin, FLEX_STD ostream& arg_yyout );
-	yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
+  // arg_yyin and arg_yyout default to the cin and cout, but we
+  // only make that assignment when initializing in yylex().
+  yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
+  yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
 private:
-	void ctor_common();
+  void ctor_common();
 
 public:
 
-	virtual ~yyFlexLexer();
+  virtual ~yyFlexLexer();
 
-	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
-	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );	
-	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream& s, int size );
-	void yy_delete_buffer( struct yy_buffer_state* b );
-	void yyrestart( FLEX_STD istream* s );
-	void yyrestart( FLEX_STD istream& s );
+  void yy_switch_to_buffer( yy_buffer_state* new_buffer );
+  yy_buffer_state* yy_create_buffer( std::istream* s, int size );
+  yy_buffer_state* yy_create_buffer( std::istream& s, int size );
+  void yy_delete_buffer( yy_buffer_state* b );
+  void yyrestart( std::istream* s );
+  void yyrestart( std::istream& s );
 
-	void yypush_buffer_state( struct yy_buffer_state* new_buffer );
-	void yypop_buffer_state();
+  void yypush_buffer_state( yy_buffer_state* new_buffer );
+  void yypop_buffer_state();
 
-	virtual int yylex();
-	virtual void switch_streams( FLEX_STD istream& new_in, FLEX_STD ostream& new_out );
-	virtual void switch_streams( FLEX_STD istream* new_in = 0, FLEX_STD ostream* new_out = 0 );
-	virtual int yywrap();
+  virtual int yylex();
+  virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
+  virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
+  virtual int yywrap();
 
 protected:
-	virtual int LexerInput( char* buf, int max_size );
-	virtual void LexerOutput( const char* buf, int size );
-	virtual void LexerError( const char* msg );
+  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 yyunput( int c, char* buf_ptr );
+  int yyinput();
 
-	void yy_load_buffer_state();
-	void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream& s );
-	void yy_flush_buffer( struct yy_buffer_state* b );
+  void yy_load_buffer_state();
+  void yy_init_buffer( yy_buffer_state* b, std::istream& s );
+  void yy_flush_buffer( yy_buffer_state* b );
 
-	int yy_start_stack_ptr;
-	int yy_start_stack_depth;
-	int* yy_start_stack;
+  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();
+  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();
+  yy_state_type yy_get_previous_state();
+  yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+  int yy_get_next_buffer();
 
-	FLEX_STD istream yyin;	// input source for default LexerInput
-	FLEX_STD ostream yyout;	// output sink for default LexerOutput
+  std::istream yyin;  // input source for default LexerInput
+  std::ostream yyout; // output sink for default LexerOutput
 
-	// yy_hold_char holds the character lost when yytext is formed.
-	char yy_hold_char;
+  // 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;
+  // Number of characters read into yy_ch_buf.
+  int yy_n_chars;
 
-	// Points to current character in buffer.
-	char* yy_c_buf_p;
+  // 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
+  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;
+  // 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;
 
 
-	size_t yy_buffer_stack_top; /**< index of top of stack. */
-	size_t yy_buffer_stack_max; /**< capacity of stack. */
-	struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
-	void yyensure_buffer_stack(void);
+  size_t yy_buffer_stack_top; /**< index of top of stack. */
+  size_t yy_buffer_stack_max; /**< capacity of stack. */
+  yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+  void yyensure_buffer_stack(void);
 
-	// The following are not always needed, but may be depending
-	// on use of certain flex features (like REJECT or yymore()).
+  // 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_last_accepting_state;
+  char* yy_last_accepting_cpos;
 
-	yy_state_type* yy_state_buf;
-	yy_state_type* yy_state_ptr;
+  yy_state_type* yy_state_buf;
+  yy_state_type* yy_state_ptr;
 
-	char* yy_full_match;
-	int* yy_full_state;
-	int yy_full_lp;
+  char* yy_full_match;
+  int* yy_full_state;
+  int yy_full_lp;
 
-	int yy_lp;
-	int yy_looking_for_trail_begin;
+  int yy_lp;
+  int yy_looking_for_trail_begin;
 
-	int yy_more_flag;
-	int yy_more_len;
-	int yy_more_offset;
-	int yy_prev_more_offset;
+  int yy_more_flag;
+  int yy_more_len;
+  int yy_more_offset;
+  int yy_prev_more_offset;
 };
 
 }
 
 #endif // yyFlexLexer || ! yyFlexLexerOnce
-
diff --git a/src/Makefile.am b/src/Makefile.am
index e324854..416995e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,39 +1,47 @@
 AM_YFLAGS = -d
 localedir = $(datadir)/locale
 AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" -I$(top_srcdir)/intl
-LIBS = @LIBINTL@ @LIBS@
+LIBS = @LIBS@
 
 m4 = @M4@
 
 bin_PROGRAMS = flex
+noinst_PROGRAMS = stage1flex
 lib_LTLIBRARIES = \
 	libfl.la \
 	libfl_pic.la
 
+stage1flex_SOURCES = \
+	scan.l \
+	$(COMMON_SOURCES)
+
 flex_SOURCES = \
+	stage1scan.l \
+	$(COMMON_SOURCES)
+
+COMMON_SOURCES = \
+	buf.c \
 	ccl.c \
 	dfa.c \
 	ecs.c \
-	scanflags.c \
+	filter.c \
 	gen.c \
 	main.c \
 	misc.c \
 	nfa.c \
+	options.c \
 	parse.y \
-	scan.l \
+	regex.c \
+	scanflags.c \
+	scanopt.c \
 	skel.c \
 	sym.c \
-	tblcmp.c \
-	yylex.c \
-	options.c \
-	scanopt.c \
-	buf.c \
 	tables.c \
 	tables_shared.c \
-	filter.c \
-	regex.c
+	tblcmp.c \
+	yylex.c
 
-LDADD = ../lib/libcompat.la
+LDADD = ../lib/libcompat.la @LIBINTL@
 
 libfl_la_SOURCES = \
 	libmain.c \
@@ -64,13 +72,25 @@ EXTRA_DIST = \
 	mkskel.sh \
 	gettext.h
 
-BUILT_SOURCES = \
-	skel.c
+DISTCLEANFILES = stage1scan.c
 
 MAINTAINERCLEANFILES = skel.c
 
-skel.c: flex.skl mkskel.sh flexint.h tables_shared.h
-	sed 's/m4_/m4postproc_/g; s/m4preproc_/m4_/g' $(srcdir)/flex.skl | $(m4) -P -DFLEX_MAJOR_VERSION=`echo $(VERSION)|cut -f 1 -d .` -DFLEX_MINOR_VERSION=`echo $(VERSION)|cut -f 2 -d .` -DFLEX_SUBMINOR_VERSION=`echo $(VERSION)|cut -f 3 -d .` | sed 's/m4postproc_/m4_/g' | $(SHELL) $(srcdir)/mkskel.sh  >skel.c
+$(srcdir)/skel.c: flex.skl mkskel.sh flexint.h tables_shared.h
+	sed 's/m4_/m4postproc_/g; s/m4preproc_/m4_/g' $(srcdir)/flex.skl | \
+	  $(m4) -P -I $(srcdir)						   \
+	    -DFLEX_MAJOR_VERSION=`   echo $(VERSION)|cut -f 1 -d .`	   \
+	    -DFLEX_MINOR_VERSION=`   echo $(VERSION)|cut -f 2 -d .`	   \
+	    -DFLEX_SUBMINOR_VERSION=`echo $(VERSION)|cut -f 3 -d .` |	   \
+	  sed 's/m4postproc_/m4_/g' |					   \
+	  $(SHELL) $(srcdir)/mkskel.sh >skel.c.tmp
+	mv skel.c.tmp $(srcdir)/skel.c
+
+stage1scan.l: scan.l
+	cp $(srcdir)/scan.l $(srcdir)/stage1scan.l
+
+stage1scan.c: stage1scan.l stage1flex$(EXEEXT)
+	$(top_builddir)/src/stage1flex$(EXEEXT) -o $@ $<
 
 # Explicitly describe dependencies.
 # You can recreate this with `gcc -I. -MM *.c'
diff --git a/src/buf.c b/src/buf.c
index fa713a6..c03b85f 100644
--- a/src/buf.c
+++ b/src/buf.c
@@ -73,12 +73,13 @@ struct Buf *buf_prints (struct Buf *buf, const char *fmt, const char *s)
 	char   *t;
         size_t tsz;
 
-	t = flex_alloc (tsz = strlen (fmt) + strlen (s) + 1);
+	tsz = strlen(fmt) + strlen(s) + 1;
+	t = malloc(tsz);
 	if (!t)
 	    flexfatal (_("Allocation of buffer to print string failed"));
 	snprintf (t, tsz, fmt, s);
 	buf = buf_strappend (buf, t);
-	flex_free (t);
+	free(t);
 	return buf;
 }
 
@@ -92,21 +93,26 @@ struct Buf *buf_linedir (struct Buf *buf, const char* filename, int lineno)
 {
     char *dst, *t;
     const char *src;
+    size_t tsz;
 
-    t = flex_alloc (strlen ("#line \"\"\n")          +   /* constant parts */
-                    2 * strlen (filename)            +   /* filename with possibly all backslashes escaped */
-                    (int) (1 + log10 (abs (lineno))) +   /* line number */
-                    1);                                  /* NUL */
+    if (gen_line_dirs)
+	return buf;
+
+    tsz = strlen("#line \"\"\n")                +   /* constant parts */
+               2 * strlen (filename)            +   /* filename with possibly all backslashes escaped */
+               (int) (1 + log10 (abs (lineno))) +   /* line number */
+               1;                                   /* NUL */
+    t = malloc(tsz);
     if (!t)
       flexfatal (_("Allocation of buffer for line directive failed"));
-    for (dst = t + sprintf (t, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
+    for (dst = t + snprintf (t, tsz, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
       if (*src == '\\')   /* escape backslashes */
         *dst++ = '\\';
     *dst++ = '"';
     *dst++ = '\n';
     *dst   = '\0';
     buf = buf_strappend (buf, t);
-    flex_free (t);
+    free(t);
     return buf;
 }
 
@@ -124,10 +130,7 @@ struct Buf *buf_concat(struct Buf* dest, const struct Buf* src)
 
 
 /* Appends n characters in str to buf. */
-struct Buf *buf_strnappend (buf, str, n)
-     struct Buf *buf;
-     const char *str;
-     int n;
+struct Buf *buf_strnappend (struct Buf *buf, const char *str, int n)
 {
 	buf_append (buf, str, n + 1);
 
@@ -138,18 +141,13 @@ struct Buf *buf_strnappend (buf, str, n)
 }
 
 /* Appends characters in str to buf. */
-struct Buf *buf_strappend (buf, str)
-     struct Buf *buf;
-     const char *str;
+struct Buf *buf_strappend (struct Buf *buf, const char *str)
 {
-	return buf_strnappend (buf, str, strlen (str));
+	return buf_strnappend (buf, str, (int) strlen (str));
 }
 
 /* appends "#define str def\n" */
-struct Buf *buf_strdefine (buf, str, def)
-     struct Buf *buf;
-     const char *str;
-     const char *def;
+struct Buf *buf_strdefine (struct Buf *buf, const char *str, const char *def)
 {
 	buf_strappend (buf, "#define ");
 	buf_strappend (buf, " ");
@@ -173,7 +171,8 @@ struct Buf *buf_m4_define (struct Buf *buf, const char* def, const char* val)
     size_t strsz;
 
     val = val?val:"";
-    str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + strlen(val) + 2);
+    strsz = strlen(fmt) + strlen(def) + strlen(val) + 2;
+    str = malloc(strsz);
     if (!str)
         flexfatal (_("Allocation of buffer for m4 def failed"));
 
@@ -193,7 +192,8 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
     char * str;
     size_t strsz;
 
-    str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + 2);
+    strsz = strlen(fmt) + strlen(def) + 2;
+    str = malloc(strsz);
     if (!str)
         flexfatal (_("Allocation of buffer for m4 undef failed"));
 
@@ -203,23 +203,21 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
 }
 
 /* create buf with 0 elements, each of size elem_size. */
-void buf_init (buf, elem_size)
-     struct Buf *buf;
-     size_t elem_size;
+void buf_init (struct Buf *buf, size_t elem_size)
 {
-	buf->elts = (void *) 0;
+	buf->elts = NULL;
 	buf->nelts = 0;
 	buf->elt_size = elem_size;
 	buf->nmax = 0;
 }
 
 /* frees memory */
-void buf_destroy (buf)
-     struct Buf *buf;
+void buf_destroy (struct Buf *buf)
 {
-	if (buf && buf->elts)
-		flex_free (buf->elts);
-	buf->elts = (void *) 0;
+	if (buf) {
+		free(buf->elts);
+		buf->elts = NULL;
+	}
 }
 
 
@@ -229,10 +227,7 @@ void buf_destroy (buf)
  * We grow by mod(512) boundaries.
  */
 
-struct Buf *buf_append (buf, ptr, n_elem)
-     struct Buf *buf;
-     const void *ptr;
-     int n_elem;
+struct Buf *buf_append (struct Buf *buf, const void *ptr, int n_elem)
 {
 	int     n_alloc = 0;
 
@@ -242,8 +237,8 @@ struct Buf *buf_append (buf, ptr, n_elem)
 	/* May need to alloc more. */
 	if (n_elem + buf->nelts > buf->nmax) {
 
-		/* exact amount needed... */
-		n_alloc = (n_elem + buf->nelts) * buf->elt_size;
+		/* exact count needed... */
+		n_alloc = n_elem + buf->nelts;
 
 		/* ...plus some extra */
 		if (((n_alloc * buf->elt_size) % 512) != 0
diff --git a/src/ccl.c b/src/ccl.c
index 7b134af..ff9a213 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -52,9 +52,7 @@ ccl_contains (const int cclp, const int ch)
 
 /* ccladd - add a single character to a ccl */
 
-void    ccladd (cclp, ch)
-     int     cclp;
-     int     ch;
+void ccladd (int cclp, int ch)
 {
 	int     ind, len, newpos, i;
 
@@ -85,7 +83,7 @@ void    ccladd (cclp, ch)
 	}
 
 	ccllen[cclp] = len + 1;
-	ccltbl[newpos] = ch;
+	ccltbl[newpos] = (unsigned char) ch;
 }
 
 /* dump_cclp - same thing as list_character_set, but for cclps.  */
@@ -185,7 +183,7 @@ ccl_set_union (int a, int b)
 
 /* cclinit - return an empty ccl */
 
-int     cclinit ()
+int     cclinit (void)
 {
 	if (++lastccl >= current_maxccls) {
 		current_maxccls += MAX_CCLS_INCREMENT;
@@ -225,8 +223,7 @@ int     cclinit ()
 
 /* cclnegate - negate the given ccl */
 
-void    cclnegate (cclp)
-     int     cclp;
+void    cclnegate (int cclp)
 {
 	cclng[cclp] = 1;
 	ccl_has_nl[cclp] = !ccl_has_nl[cclp];
@@ -240,9 +237,7 @@ void    cclnegate (cclp)
  * has a non-zero value in the cset array.
  */
 
-void    list_character_set (file, cset)
-     FILE   *file;
-     int     cset[];
+void    list_character_set (FILE *file, int cset[])
 {
 	int i;
 
diff --git a/src/dfa.c b/src/dfa.c
index 0a68e3a..be62da8 100644
--- a/src/dfa.c
+++ b/src/dfa.c
@@ -34,10 +34,10 @@
 
 /* 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[]));
+void	dump_associated_rules(FILE *, int);
+void	dump_transitions(FILE *, int[]);
+void	sympartition(int[], int, int[], int[]);
+int	symfollowset(int[], int, int, int[]);
 
 
 /* check_for_backing_up - check a DFA state for backing up
@@ -49,9 +49,7 @@ int symfollowset PROTO ((int[], int, int, int[]));
  * indexed by equivalence class.
  */
 
-void check_for_backing_up (ds, state)
-     int ds;
-     int state[];
+void check_for_backing_up (int ds, int state[])
 {
 	if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) {	/* state is non-accepting */
 		++num_backing_up;
@@ -96,10 +94,7 @@ void check_for_backing_up (ds, state)
  *    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;
-     int nacc;
+void check_trailing_context (int *nfa_states, int num_states, int *accset, int nacc)
 {
 	int i, j;
 
@@ -137,9 +132,7 @@ void check_trailing_context (nfa_states, num_states, accset, nacc)
  * and writes a report to the given file.
  */
 
-void dump_associated_rules (file, ds)
-     FILE   *file;
-     int ds;
+void dump_associated_rules (FILE *file, int ds)
 {
 	int i, j;
 	int num_associated_rules = 0;
@@ -161,7 +154,7 @@ void dump_associated_rules (file, ds)
 		}
 	}
 
-	qsort (&rule_set [1], num_associated_rules, sizeof (rule_set [1]), intcmp);
+	qsort (&rule_set [1], (size_t) num_associated_rules, sizeof (rule_set [1]), intcmp);
 
 	fprintf (file, _(" associated rule line numbers:"));
 
@@ -187,9 +180,7 @@ void dump_associated_rules (file, ds)
  * is done to the given file.
  */
 
-void dump_transitions (file, state)
-     FILE   *file;
-     int state[];
+void dump_transitions (FILE *file, int state[])
 {
 	int i, ec;
 	int out_char_set[CSIZE];
@@ -235,8 +226,7 @@ void dump_transitions (file, state)
  *  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;
+int    *epsclosure (int *t, int *ns_addr, int accset[], int *nacc_addr, int *hv_addr)
 {
 	int     stkpos, ns, tsp;
 	int     numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
@@ -351,7 +341,7 @@ ADD_STATE(state); \
 
 /* increase_max_dfas - increase the maximum number of DFAs */
 
-void increase_max_dfas ()
+void increase_max_dfas (void)
 {
 	current_max_dfas += MAX_DFAS_INCREMENT;
 
@@ -378,7 +368,7 @@ void increase_max_dfas ()
  * dfa starts out in state #1.
  */
 
-void ntod ()
+void ntod (void)
 {
 	int    *accset, ds, nacc, newds;
 	int     sym, hashval, numstates, dsize;
@@ -521,15 +511,13 @@ void ntod ()
 		 * So we'll have to realloc() on the way...
 		 * we'll wait until we can calculate yynxt_tbl->td_hilen.
 		 */
-		yynxt_tbl =
-			(struct yytbl_data *) calloc (1,
-						      sizeof (struct
-							      yytbl_data));
+		yynxt_tbl = calloc(1, sizeof (struct yytbl_data));
+     
 		yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
 		yynxt_tbl->td_hilen = 1;
 		yynxt_tbl->td_lolen = num_full_table_rows;
 		yynxt_tbl->td_data = yynxt_data =
-			(flex_int32_t *) calloc (yynxt_tbl->td_lolen *
+			calloc(yynxt_tbl->td_lolen *
 					    yynxt_tbl->td_hilen,
 					    sizeof (flex_int32_t));
 		yynxt_curr = 0;
@@ -713,7 +701,7 @@ void ntod ()
 			/* Each time we hit here, it's another td_hilen, so we realloc. */
 			yynxt_tbl->td_hilen++;
 			yynxt_tbl->td_data = yynxt_data =
-				(flex_int32_t *) realloc (yynxt_data,
+				realloc (yynxt_data,
 						     yynxt_tbl->td_hilen *
 						     yynxt_tbl->td_lolen *
 						     sizeof (flex_int32_t));
@@ -805,8 +793,8 @@ void ntod ()
 		mkdeftbl ();
 	}
 
-	flex_free ((void *) accset);
-	flex_free ((void *) nset);
+	free(accset);
+	free(nset);
 }
 
 
@@ -820,8 +808,7 @@ void ntod ()
  * 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 snstods (int sns[], int numstates, int accset[], int nacc, int hashval, int *newds_addr)
 {
 	int didsort = 0;
 	int i, j;
@@ -836,7 +823,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
 					/* We sort the states in sns so we
 					 * can compare it to oldsns quickly.
 					 */
-					qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
+					qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
 					didsort = 1;
 				}
 
@@ -871,7 +858,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
 	 */
 
 	if (!didsort)
-		qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
+          	qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
 
 	for (i = 1; i <= numstates; ++i)
 		dss[newds][i] = sns[i];
@@ -881,7 +868,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
 
 	if (nacc == 0) {
 		if (reject)
-			dfaacc[newds].dfaacc_set = (int *) 0;
+			dfaacc[newds].dfaacc_set = NULL;
 		else
 			dfaacc[newds].dfaacc_state = 0;
 
@@ -894,7 +881,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
 		 * match in the event of ties will work.
 		 */
 
-		qsort (&accset [1], nacc, sizeof (accset [1]), intcmp);
+		qsort (&accset [1], (size_t) nacc, sizeof (accset [1]), intcmp);
 
 		dfaacc[newds].dfaacc_set =
 			allocate_integer_array (nacc + 1);
@@ -942,8 +929,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
  *				int transsym, int nset[current_max_dfa_size] );
  */
 
-int symfollowset (ds, dsize, transsym, nset)
-     int ds[], dsize, transsym, nset[];
+int symfollowset (int ds[], int dsize, int transsym, int nset[])
 {
 	int     ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
 
@@ -1020,9 +1006,7 @@ int symfollowset (ds, dsize, transsym, nset)
  *			int symlist[numecs], int duplist[numecs] );
  */
 
-void sympartition (ds, numstates, symlist, duplist)
-     int ds[], numstates;
-     int symlist[], duplist[];
+void sympartition (int ds[], int numstates, int symlist[], int duplist[])
 {
 	int     tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
 
diff --git a/src/ecs.c b/src/ecs.c
index b206351..b2afc1f 100644
--- a/src/ecs.c
+++ b/src/ecs.c
@@ -36,7 +36,7 @@
 
 /* ccl2ecl - convert character classes to set of equivalence classes */
 
-void    ccl2ecl ()
+void    ccl2ecl (void)
 {
 	int     i, ich, newlen, cclp, ccls, cclmec;
 
@@ -74,8 +74,7 @@ void    ccl2ecl ()
  * Returned is the number of classes.
  */
 
-int     cre8ecs (fwd, bck, num)
-     int     fwd[], bck[], num;
+int     cre8ecs (int fwd[], int bck[], int num)
 {
 	int     i, j, numcl;
 
@@ -100,9 +99,9 @@ int     cre8ecs (fwd, bck, num)
 /* mkeccl - update equivalence classes based on character class xtions
  *
  * synopsis
- *    Char ccls[];
+ *    unsigned char ccls[];
  *    int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
- *    void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
+ *    void mkeccl( unsigned 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
@@ -112,9 +111,7 @@ int     cre8ecs (fwd, bck, num)
  * 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;
+void    mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsiz, int NUL_mapping)
 {
 	int     cclp, oldec, newec;
 	int     cclm, i, j;
@@ -201,8 +198,7 @@ void    mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
 
 /* mkechar - create equivalence class for single character */
 
-void    mkechar (tch, fwd, bck)
-     int     tch, fwd[], bck[];
+void    mkechar (int tch, int fwd[], int bck[])
 {
 	/* If until now the character has been a proper subset of
 	 * an equivalence class, break it away to create a new ec
diff --git a/src/filter.c b/src/filter.c
index 987366a..1ac199f 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -47,9 +47,9 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
 	va_list ap;
 
 	/* allocate and initialize new filter */
-	f = (struct filter *) flex_alloc (sizeof (struct filter));
+	f = malloc(sizeof(struct filter));
 	if (!f)
-		flexerror (_("flex_alloc failed (f) in filter_create_ext"));
+		flexerror(_("malloc failed (f) in filter_create_ext"));
 	memset (f, 0, sizeof (*f));
 	f->filter_func = NULL;
 	f->extra = NULL;
@@ -66,23 +66,16 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
 
 	/* allocate argv, and populate it with the argument list. */
 	max_args = 8;
-	f->argv =
-		(const char **) flex_alloc (sizeof (char *) *
-					    (max_args + 1));
+	f->argv = malloc(sizeof(char *) * (size_t) (max_args + 1));
 	if (!f->argv)
-		flexerror (_("flex_alloc failed (f->argv) in filter_create_ext"));
+		flexerror(_("malloc failed (f->argv) in filter_create_ext"));
 	f->argv[f->argc++] = cmd;
 
 	va_start (ap, cmd);
 	while ((s = va_arg (ap, const char *)) != NULL) {
 		if (f->argc >= max_args) {
 			max_args += 8;
-			f->argv =
-				(const char **) flex_realloc (f->argv,
-							      sizeof (char
-								      *) *
-							      (max_args +
-							       1));
+			f->argv = realloc(f->argv, sizeof(char*) * (size_t) (max_args + 1));
 		}
 		f->argv[f->argc++] = s;
 	}
@@ -107,9 +100,9 @@ struct filter *filter_create_int (struct filter *chain,
 	struct filter *f;
 
 	/* allocate and initialize new filter */
-	f = (struct filter *) flex_alloc (sizeof (struct filter));
+	f = malloc(sizeof(struct filter));
 	if (!f)
-		flexerror (_("flex_alloc failed in filter_create_int"));
+		flexerror(_("malloc failed in filter_create_int"));
 	memset (f, 0, sizeof (*f));
 	f->next = NULL;
 	f->argc = 0;
@@ -174,6 +167,8 @@ clearerr(stdin);
 			flexfatal (_("dup2(pipes[0],0)"));
 		close (pipes[0]);
         fseek (stdin, 0, SEEK_CUR);
+        ungetc(' ', stdin); /* still an evil hack, but one that works better */
+        (void)fgetc(stdin); /* on NetBSD than the fseek attempt does */
 
 		/* run as a filter, either internally or by exec */
 		if (chain->filter_func) {
@@ -288,9 +283,9 @@ int filter_tee_header (struct filter *chain)
 	fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
 		 outfilename ? outfilename : "<stdout>");
 
-	buf = (char *) flex_alloc (readsz);
+	buf = malloc((size_t) readsz);
 	if (!buf)
-		flexerror (_("flex_alloc failed in filter_tee_header"));
+		flexerror(_("malloc failed in filter_tee_header"));
 	while (fgets (buf, readsz, stdin)) {
 		fputs (buf, to_c);
 		if (write_header)
@@ -341,7 +336,7 @@ int filter_tee_header (struct filter *chain)
 int filter_fix_linedirs (struct filter *chain)
 {
 	char   *buf;
-	const int readsz = 512;
+	const size_t readsz = 512;
 	int     lineno = 1;
 	bool    in_gen = true;	/* in generated code */
 	bool    last_was_blank = false;
@@ -349,11 +344,11 @@ int filter_fix_linedirs (struct filter *chain)
 	if (!chain)
 		return 0;
 
-	buf = (char *) flex_alloc (readsz);
+	buf = malloc(readsz);
 	if (!buf)
-		flexerror (_("flex_alloc failed in filter_fix_linedirs"));
+		flexerror(_("malloc failed in filter_fix_linedirs"));
 
-	while (fgets (buf, readsz, stdin)) {
+	while (fgets (buf, (int) readsz, stdin)) {
 
 		regmatch_t m[10];
 
diff --git a/src/flex.skl b/src/flex.skl
index de2e758..fc6915a 100644
--- a/src/flex.skl
+++ b/src/flex.skl
@@ -223,25 +223,13 @@ m4preproc_include(`flexint.h')
 /* end standard C++ headers. */
 %endif
 
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
+/* TODO: this is always defined, so inline it */
 #define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
 #else
-#define yyconst
+#define yynoreturn
 #endif
 
 %# For compilers that can not handle prototypes.
@@ -477,7 +465,7 @@ typedef size_t yy_size_t;
 #endif
 
 %if-not-reentrant
-extern yy_size_t yyleng;
+extern int yyleng;
 %endif
 
 %if-c-only
@@ -566,12 +554,12 @@ struct yy_buffer_state
 	/* Size of input buffer in bytes, not including room for EOB
 	 * characters.
 	 */
-	yy_size_t yy_buf_size;
+	int yy_buf_size;
 
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -628,7 +616,7 @@ m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
 /* Stack of input buffers. */
 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
-static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
 %endif
 %ok-for-header
 %endif
@@ -660,11 +648,11 @@ m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
 %not-for-header
 /* yy_hold_char holds the character lost when yytext is formed. */
 static char yy_hold_char;
-static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */
-yy_size_t yyleng;
+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 char *yy_c_buf_p = NULL;
 static int yy_init = 0;		/* whether we need to initialize */
 static int yy_start = 0;	/* start state number */
 
@@ -697,7 +685,7 @@ m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
 
 YY_BUFFER_STATE yy_scan_buffer M4_YY_PARAMS( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG );
 YY_BUFFER_STATE yy_scan_string M4_YY_PARAMS( yyconst char *yy_str M4_YY_PROTO_LAST_ARG );
-YY_BUFFER_STATE yy_scan_bytes M4_YY_PARAMS( yyconst char *bytes, yy_size_t len M4_YY_PROTO_LAST_ARG );
+YY_BUFFER_STATE yy_scan_bytes M4_YY_PARAMS( yyconst char *bytes, int len M4_YY_PROTO_LAST_ARG );
 
 %endif
 
@@ -755,10 +743,7 @@ m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
 static yy_state_type yy_get_previous_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
 static yy_state_type yy_try_NUL_trans M4_YY_PARAMS( yy_state_type current_state  M4_YY_PROTO_LAST_ARG);
 static int yy_get_next_buffer M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
-#if defined(__GNUC__) && __GNUC__ >= 3
-__attribute__((__noreturn__))
-#endif
-static void yy_fatal_error M4_YY_PARAMS( yyconst char msg[] M4_YY_PROTO_LAST_ARG );
+static void yynoreturn yy_fatal_error M4_YY_PARAMS( yyconst char* msg M4_YY_PROTO_LAST_ARG );
 ]])
 
 %endif
@@ -831,8 +816,8 @@ struct yyguts_t
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
-    yy_size_t yy_n_chars;
-    yy_size_t yyleng_r;
+    int yy_n_chars;
+    int yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
@@ -969,7 +954,7 @@ void yyset_out  M4_YY_PARAMS( FILE * _out_str M4_YY_PROTO_LAST_ARG );
 
 m4_ifdef( [[M4_YY_NO_GET_LENG]],,
 [[
-yy_size_t yyget_leng M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+			int yyget_leng M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
 ]])
 
 m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
@@ -1125,7 +1110,7 @@ m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
 %endif
 %if-c++-only C++ definition
 #define ECHO LexerOutput( yytext, yyleng )
@@ -1533,7 +1518,7 @@ do_action:	/* This label is used only to access EOF actions. */
  * This constructor simply maintains backward compatibility.
  * DEPRECATED
  */
-yyFlexLexer::yyFlexLexer( FLEX_STD istream* arg_yyin, FLEX_STD ostream* arg_yyout ):
+yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout ):
 	yyin(arg_yyin ? arg_yyin->rdbuf() : std::cin.rdbuf()),
 	yyout(arg_yyout ? arg_yyout->rdbuf() : std::cout.rdbuf())
 {
@@ -1569,7 +1554,7 @@ void yyFlexLexer::ctor_common()
 	yy_start_stack_ptr = yy_start_stack_depth = 0;
 	yy_start_stack = NULL;
 
-	yy_buffer_stack = 0;
+	yy_buffer_stack = NULL;
 	yy_buffer_stack_top = 0;
 	yy_buffer_stack_max = 0;
 
@@ -1718,7 +1703,7 @@ int yyFlexLexer::yy_get_next_buffer()
 
 	else
 		{
-			yy_size_t num_to_read =
+			int num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
@@ -1737,7 +1722,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]],
 
 			if ( b->yy_is_our_buffer )
 				{
-				yy_size_t new_size = b->yy_buf_size * 2;
+				int new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1751,7 +1736,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]],
 				}
 			else
 				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = 0;
+				b->yy_ch_buf = NULL;
 
 			if ( ! b->yy_ch_buf )
 				YY_FATAL_ERROR(
@@ -1793,9 +1778,9 @@ m4_ifdef( [[M4_YY_USES_REJECT]],
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-	if ((yy_size_t) (YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+	if ((int) (YY_G(yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);
+		int new_size = YY_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);
 		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
 			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size M4_YY_CALL_LAST_ARG );
 		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
@@ -1879,7 +1864,7 @@ m4_ifdef( [[M4_YY_NO_UNPUT]],,
 	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		yy_size_t number_to_move = YY_G(yy_n_chars) + 2;
+		int number_to_move = YY_G(yy_n_chars) + 2;
 		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
 					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 		char *source =
@@ -1891,7 +1876,7 @@ m4_ifdef( [[M4_YY_NO_UNPUT]],,
 		yy_cp += (int) (dest - source);
 		yy_bp += (int) (dest - source);
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
-			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+			YY_G(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
 		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 			YY_FATAL_ERROR( "flex scanner push-back overflow" );
@@ -1946,7 +1931,7 @@ m4_ifdef( [[M4_YY_USE_LINENO]],
 
 		else
 			{ /* need more input */
-			yy_size_t offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
+			int offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
 			++YY_G(yy_c_buf_p);
 
 			switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
@@ -1970,7 +1955,7 @@ m4_ifdef( [[M4_YY_USE_LINENO]],
 				case EOB_ACT_END_OF_FILE:
 					{
 					if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
-						return EOF;
+						return 0;
 
 					if ( ! YY_G(yy_did_buffer_switch_on_eof) )
 						YY_NEW_FILE;
@@ -2341,7 +2326,7 @@ static void yyensure_buffer_stack YYFARGS0(void)
 void yyFlexLexer::yyensure_buffer_stack(void)
 %endif
 {
-	yy_size_t num_to_alloc;
+	int num_to_alloc;
     M4_YY_DECL_GUTS_VAR();
 
 	if (!YY_G(yy_buffer_stack)) {
@@ -2406,7 +2391,7 @@ YY_BUFFER_STATE yy_scan_buffer  YYFARGS2( char *,base, yy_size_t ,size)
 	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
 	     base[size-1] != YY_END_OF_BUFFER_CHAR )
 		/* They forgot to leave room for the EOB's. */
-		return 0;
+		return NULL;
 
 	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
 	if ( ! b )
@@ -2415,7 +2400,7 @@ YY_BUFFER_STATE yy_scan_buffer  YYFARGS2( char *,base, yy_size_t ,size)
 	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
 	b->yy_buf_pos = b->yy_ch_buf = base;
 	b->yy_is_our_buffer = 0;
-	b->yy_input_file = 0;
+	b->yy_input_file = NULL;
 	b->yy_n_chars = b->yy_buf_size;
 	b->yy_is_interactive = 0;
 	b->yy_at_bol = 1;
@@ -2445,7 +2430,7 @@ YY_BUFFER_STATE yy_scan_string YYFARGS1( yyconst char *, yystr)
 {
     m4_dnl M4_YY_DECL_GUTS_VAR();
 
-	return yy_scan_bytes( yystr, strlen(yystr) M4_YY_CALL_LAST_ARG);
+	return yy_scan_bytes( yystr, (int) strlen(yystr) M4_YY_CALL_LAST_ARG);
 }
 %endif
 ]])
@@ -2461,7 +2446,7 @@ m4_ifdef( [[M4_YY_NO_SCAN_BYTES]],,
  * M4_YY_DOC_PARAM
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE yy_scan_bytes  YYFARGS2( yyconst char *,yybytes, yy_size_t ,_yybytes_len)
+YY_BUFFER_STATE yy_scan_bytes  YYFARGS2( yyconst char *,yybytes, int ,_yybytes_len)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
@@ -2470,7 +2455,7 @@ YY_BUFFER_STATE yy_scan_bytes  YYFARGS2( yyconst char *,yybytes, yy_size_t ,_yyb
     m4_dnl M4_YY_DECL_GUTS_VAR();
 
 	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = _yybytes_len + 2;
+	n = (yy_size_t) _yybytes_len + 2;
 	buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG );
 	if ( ! buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
@@ -2510,7 +2495,7 @@ m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
 		yy_size_t new_size;
 
 		YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
-		new_size = YY_G(yy_start_stack_depth) * sizeof( int );
+		new_size = (yy_size_t) YY_G(yy_start_stack_depth) * sizeof( int );
 
 		if ( ! YY_G(yy_start_stack) )
 			YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG );
@@ -2567,7 +2552,7 @@ m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
 #endif
 
 %if-c-only
-static void yy_fatal_error YYFARGS1(yyconst char*, msg)
+static void yynoreturn yy_fatal_error YYFARGS1(yyconst char*, msg)
 {
 	M4_YY_DECL_GUTS_VAR();
 	M4_YY_NOOP_GUTS_VAR();
@@ -2576,7 +2561,7 @@ static void yy_fatal_error YYFARGS1(yyconst char*, msg)
 }
 %endif
 %if-c++-only
-void yyFlexLexer::LexerError( yyconst char msg[] )
+void yyFlexLexer::LexerError( yyconst char* msg )
 {
     M4_YY_DECL_GUTS_VAR();
 	std::cerr << msg << std::endl;
@@ -2688,7 +2673,7 @@ m4_ifdef( [[M4_YY_NO_GET_LENG]],,
 /** Get the length of the current token.
  * M4_YY_DOC_PARAM
  */
-yy_size_t yyget_leng  YYFARGS0(void)
+int yyget_leng  YYFARGS0(void)
 {
     M4_YY_DECL_GUTS_VAR();
     return yyleng;
@@ -2951,10 +2936,10 @@ m4_ifdef( [[M4_YY_USE_LINENO]],
     yylineno =  1;
     ]])
 ]])
-    YY_G(yy_buffer_stack) = 0;
+    YY_G(yy_buffer_stack) = NULL;
     YY_G(yy_buffer_stack_top) = 0;
     YY_G(yy_buffer_stack_max) = 0;
-    YY_G(yy_c_buf_p) = (char *) 0;
+    YY_G(yy_c_buf_p) = NULL;
     YY_G(yy_init) = 0;
     YY_G(yy_start) = 0;
 
@@ -2985,8 +2970,8 @@ m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
     yyin = stdin;
     yyout = stdout;
 #else
-    yyin = (FILE *) 0;
-    yyout = (FILE *) 0;
+    yyin = NULL;
+    yyout = NULL;
 #endif
 
     /* For future reference: Set errno on error, since we are called by
@@ -3083,7 +3068,7 @@ void *yyalloc YYFARGS1( yy_size_t ,size)
 {
 	M4_YY_DECL_GUTS_VAR();
 	M4_YY_NOOP_GUTS_VAR();
-	return (void *) malloc( size );
+	return malloc(size);
 }
 ]])
 
@@ -3101,7 +3086,7 @@ void *yyrealloc  YYFARGS2( void *,ptr, yy_size_t ,size)
 	 * any pointer type to void*, and deal with argument conversions
 	 * as though doing an assignment.
 	 */
-	return (void *) realloc( (char *) ptr, size );
+	return realloc(ptr, size);
 }
 ]])
 
diff --git a/src/flexdef.h b/src/flexdef.h
index 496e34c..27ad610 100644
--- a/src/flexdef.h
+++ b/src/flexdef.h
@@ -39,30 +39,15 @@
 #include <config.h>
 #endif
 
-/* AIX requires this to be the first thing in the file.  */
-#if !defined(__GNUC__) && !defined(__lint__)
-# if HAVE_ALLOCA_H
-#  include <alloca.h>
-# else
-#  ifdef _AIX
- #pragma alloca
-#  else
-#   ifndef alloca /* predefined by HP cc +Olibcalls */
-char *alloca ();
-#   endif
-#  endif
-# endif
-#endif
-
-#ifdef STDC_HEADERS
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <setjmp.h>
 #include <ctype.h>
+#include <libgen.h> /* for XPG version of basename(3) */
 #include <string.h>
 #include <math.h>
-#endif
+
 #ifdef HAVE_ASSERT_H
 #include <assert.h>
 #else
@@ -81,16 +66,11 @@ char *alloca ();
 #ifdef HAVE_SYS_PARAMS_H
 #include <sys/params.h>
 #endif
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
 #endif
-#ifdef HAVE_STDBOOL_H
+#include <sys/wait.h>
 #include <stdbool.h>
-#else
-#define bool int
-#define true 1
-#define false 0
-#endif
 #ifdef HAVE_REGEX_H
 #include <regex.h>
 #endif
@@ -109,33 +89,12 @@ char *alloca ();
 
 /* 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
-#if defined(__STDC__)
-#define PROTO(proto) proto
-#else
-#define PROTO(proto) ()
-#endif
-#endif
-
-#ifdef VMS
-#ifndef __VMS_POSIX
-#define unlink remove
-#define SHORT_FILE_NAMES
-#endif
-#endif
-
-#ifdef MS_DOS
-#define SHORT_FILE_NAMES
-#endif
-
-
 /* Maximum line length we'll have to deal with. */
 #define MAXLINE 2048
 
@@ -150,11 +109,6 @@ char *alloca ();
 #endif
 
 
-/* ANSI C does not guarantee that isascii() is defined */
-#ifndef isascii
-#define isascii(c) ((c) <= 0177)
-#endif
-
 #define unspecified -1
 
 /* Special chk[] values marking the slots taking by end-of-buffer and action
@@ -445,7 +399,7 @@ extern int trace_hex;
  */
 
 extern int datapos, dataline, linenum;
-extern FILE *skelfile, *yyin, *backing_up_file;
+extern FILE *skelfile, *backing_up_file;
 extern const char *skel[];
 extern int skel_ind;
 extern char *infilename, *outfilename, *headerfilename;
@@ -647,7 +601,7 @@ extern int end_of_buffer_state;
 
 extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
 extern int current_maxccls, current_max_ccl_tbl_size;
-extern Char *ccltbl;
+extern unsigned char *ccltbl;
 
 
 /* Variables for miscellaneous information:
@@ -675,62 +629,54 @@ 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, size_t));
-void   *reallocate_array PROTO ((void *, int, size_t));
+#ifndef HAVE_REALLOCARRAY
+void *reallocarray(void *, size_t, size_t);
+#endif
 
-void   *flex_alloc PROTO ((size_t));
-void   *flex_realloc PROTO ((void *, size_t));
-void flex_free PROTO ((void *));
+void   *allocate_array(int, size_t);
+void   *reallocate_array(void *, int, size_t);
 
 #define allocate_integer_array(size) \
-	(int *) allocate_array( size, sizeof( int ) )
+	allocate_array(size, sizeof(int))
 
 #define reallocate_integer_array(array,size) \
-	(int *) reallocate_array( (void *) array, size, sizeof( int ) )
+	reallocate_array((void *) array, size, sizeof(int))
 
 #define allocate_bool_array(size) \
-	(bool *) allocate_array( size, sizeof( bool ) )
+	allocate_array(size, sizeof(bool))
 
 #define reallocate_bool_array(array,size) \
-	(bool *) reallocate_array( (void *) array, size, sizeof( bool ) )
+	reallocate_array((void *) array, size, sizeof(bool))
 
 #define allocate_int_ptr_array(size) \
-	(int **) allocate_array( size, sizeof( int * ) )
+	allocate_array(size, sizeof(int *))
 
 #define allocate_char_ptr_array(size) \
-	(char **) allocate_array( size, sizeof( char * ) )
+	allocate_array(size, sizeof(char *))
 
 #define allocate_dfaacc_union(size) \
-	(union dfaacc_union *) \
-		allocate_array( size, sizeof( 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 * ) )
+	reallocate_array((void *) array, size, sizeof(int *))
 
 #define reallocate_char_ptr_array(array,size) \
-	(char **) reallocate_array( (void *) array, size, sizeof( 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 ) )
+	reallocate_array((void *) array, size, sizeof(union dfaacc_union))
 
 #define allocate_character_array(size) \
-	(char *) allocate_array( size, sizeof( char ) )
+	allocate_array( size, sizeof(char))
 
 #define reallocate_character_array(array,size) \
-	(char *) reallocate_array( (void *) array, size, sizeof( char ) )
+	reallocate_array((void *) array, size, sizeof(char))
 
 #define allocate_Character_array(size) \
-	(Char *) allocate_array( size, sizeof( Char ) )
+	allocate_array(size, sizeof(unsigned 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;
+	reallocate_array((void *) array, size, sizeof(unsigned char))
 
 
 /* External functions that are cross-referenced among the flex source files. */
@@ -738,146 +684,143 @@ extern int yylval;
 
 /* 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 */
+extern void ccladd(int, int);	/* add a single character to a ccl */
+extern int cclinit(void);	/* make an empty ccl */
+extern void cclnegate(int);	/* negate a ccl */
 extern int ccl_set_diff (int a, int b); /* set difference of two ccls. */
 extern int ccl_set_union (int a, int b); /* set union of two ccls. */
 
 /* List the members of a set of characters in CCL form. */
-extern void list_character_set PROTO ((FILE *, int[]));
+extern void list_character_set(FILE *, int[]);
 
 
 /* from file dfa.c */
 
 /* Check a DFA state for backing up. */
-extern void check_for_backing_up PROTO ((int, int[]));
+extern void check_for_backing_up(int, int[]);
 
 /* Check to see if NFA state set constitutes "dangerous" trailing context. */
-extern void check_trailing_context PROTO ((int *, int, int *, int));
+extern void check_trailing_context(int *, int, int *, int);
 
 /* Construct the epsilon closure of a set of ndfa states. */
-extern int *epsclosure PROTO ((int *, int *, int[], int *, int *));
+extern int *epsclosure(int *, int *, int[], int *, int *);
 
 /* Increase the maximum number of dfas. */
-extern void increase_max_dfas PROTO ((void));
+extern void increase_max_dfas(void);
 
-extern void ntod PROTO ((void));	/* convert a ndfa to a dfa */
+extern void ntod(void);	/* convert a ndfa to a dfa */
 
 /* Converts a set of ndfa states into a dfa state. */
-extern int snstods PROTO ((int[], int, int[], int, int, int *));
+extern int snstods(int[], int, int[], int, int, int *);
 
 
 /* from file ecs.c */
 
 /* Convert character classes to set of equivalence classes. */
-extern void ccl2ecl PROTO ((void));
+extern void ccl2ecl(void);
 
 /* Associate equivalence class numbers with class members. */
-extern int cre8ecs PROTO ((int[], int[], int));
+extern int cre8ecs(int[], int[], int);
 
 /* Update equivalence classes based on character class transitions. */
-extern void mkeccl PROTO ((Char[], int, int[], int[], int, int));
+extern void mkeccl(unsigned char[], int, int[], int[], int, int);
 
 /* Create equivalence class for single character. */
-extern void mkechar PROTO ((int, int[], int[]));
+extern void mkechar(int, int[], int[]);
 
 
 /* from file gen.c */
 
-extern void do_indent PROTO ((void));	/* indent to the current level */
+extern void do_indent(void);	/* indent to the current level */
 
 /* Generate the code to keep backing-up information. */
-extern void gen_backing_up PROTO ((void));
+extern void gen_backing_up(void);
 
 /* Generate the code to perform the backing up. */
-extern void gen_bu_action PROTO ((void));
+extern void gen_bu_action(void);
 
 /* Generate full speed compressed transition table. */
-extern void genctbl PROTO ((void));
+extern void genctbl(void);
 
 /* Generate the code to find the action number. */
-extern void gen_find_action PROTO ((void));
+extern void gen_find_action(void);
 
-extern void genftbl PROTO ((void));	/* generate full transition table */
+extern void genftbl(void);	/* generate full transition table */
 
 /* Generate the code to find the next compressed-table state. */
-extern void gen_next_compressed_state PROTO ((char *));
+extern void gen_next_compressed_state(char *);
 
 /* Generate the code to find the next match. */
-extern void gen_next_match PROTO ((void));
+extern void gen_next_match(void);
 
 /* Generate the code to find the next state. */
-extern void gen_next_state PROTO ((int));
+extern void gen_next_state(int);
 
 /* Generate the code to make a NUL transition. */
-extern void gen_NUL_trans PROTO ((void));
+extern void gen_NUL_trans(void);
 
 /* Generate the code to find the start state. */
-extern void gen_start_state PROTO ((void));
+extern void gen_start_state(void);
 
 /* Generate data statements for the transition tables. */
-extern void gentabs PROTO ((void));
+extern void gentabs(void);
 
 /* Write out a formatted string at the current indentation level. */
-extern void indent_put2s PROTO ((const char *, const char *));
+extern void indent_put2s(const char *, const char *);
 
 /* Write out a string + newline at the current indentation level. */
-extern void indent_puts PROTO ((const char *));
+extern void indent_puts(const char *);
 
-extern void make_tables PROTO ((void));	/* generate transition tables */
+extern void make_tables(void);	/* generate transition tables */
 
 
 /* from file main.c */
 
-extern void check_options PROTO ((void));
-extern void flexend PROTO ((int));
-extern void usage PROTO ((void));
+extern void check_options(void);
+extern void flexend(int);
+extern void usage(void);
 
 
 /* from file misc.c */
 
 /* Add a #define to the action file. */
-extern void action_define PROTO ((const char *defname, int value));
+extern void action_define(const char *defname, int value);
 
 /* Add the given text to the stored actions. */
-extern void add_action PROTO ((const char *new_text));
+extern void add_action(const char *new_text);
 
 /* True if a string is all lower case. */
-extern int all_lower PROTO ((char *));
+extern int all_lower(char *);
 
 /* True if a string is all upper case. */
-extern int all_upper PROTO ((char *));
+extern int all_upper(char *);
 
 /* Compare two integers for use by qsort. */
-extern int intcmp PROTO ((const void *, const void *));
+extern int intcmp(const void *, const void *);
 
 /* Check a character to make sure it's in the expected range. */
-extern void check_char PROTO ((int c));
+extern void check_char(int c);
 
 /* Replace upper-case letter to lower-case. */
-extern Char clower PROTO ((int));
+extern unsigned char clower(int);
 
-/* Returns a dynamically allocated copy of a string. */
-extern char *copy_string PROTO ((const char *));
-
-/* Returns a dynamically allocated copy of a (potentially) unsigned string. */
-extern Char *copy_unsigned_string PROTO ((Char *));
+/* strdup() that fails fatally on allocation failures. */
+extern char *xstrdup(const char *);
 
 /* Compare two characters for use by qsort with '\0' sorting last. */
-extern int cclcmp PROTO ((const void *, const void *));
+extern int cclcmp(const void *, const void *);
 
 /* Finish up a block of data declarations. */
-extern void dataend PROTO ((void));
+extern void dataend(void);
 
 /* Flush generated data statements. */
-extern void dataflush PROTO ((void));
+extern void dataflush(void);
 
 /* Report an error message and terminate. */
-extern void flexerror PROTO ((const char *));
+extern void flexerror(const char *);
 
 /* Report a fatal error message and terminate. */
-extern void flexfatal PROTO ((const char *));
+extern void flexfatal(const char *);
 
 /* Report a fatal error with a pinpoint, and terminate */
 #if HAVE_DECL___FUNC__
@@ -901,207 +844,199 @@ extern void flexfatal PROTO ((const char *));
 #endif /* ! HAVE_DECL___func__ */
 
 /* Convert a hexadecimal digit string to an integer value. */
-extern int htoi PROTO ((Char[]));
+extern int htoi(unsigned char[]);
 
 /* Report an error message formatted  */
-extern void lerr PROTO ((const char *, ...))
+extern void lerr(const char *, ...)
 #if defined(__GNUC__) && __GNUC__ >= 3
     __attribute__((__format__(__printf__, 1, 2)))
 #endif
 ;
 
 /* Like lerr, but also exit after displaying message. */
-extern void lerr_fatal PROTO ((const char *, ...))
+extern void lerr_fatal(const char *, ...)
 #if defined(__GNUC__) && __GNUC__ >= 3
     __attribute__((__format__(__printf__, 1, 2)))
 #endif
 ;
 
 /* Spit out a "#line" statement. */
-extern void line_directive_out PROTO ((FILE *, int));
+extern void line_directive_out(FILE *, int);
 
 /* Mark the current position in the action array as the end of the section 1
  * user defs.
  */
-extern void mark_defs1 PROTO ((void));
+extern void mark_defs1(void);
 
 /* Mark the current position in the action array as the end of the prolog. */
-extern void mark_prolog PROTO ((void));
+extern void mark_prolog(void);
 
 /* Generate a data statment for a two-dimensional array. */
-extern void mk2data PROTO ((int));
+extern void mk2data(int);
 
-extern void mkdata PROTO ((int));	/* generate a data statement */
+extern void mkdata(int);	/* generate a data statement */
 
 /* Return the integer represented by a string of digits. */
-extern int myctoi PROTO ((const char *));
+extern int myctoi(const char *);
 
 /* Return character corresponding to escape sequence. */
-extern Char myesc PROTO ((Char[]));
+extern unsigned char myesc(unsigned char[]);
 
 /* Convert an octal digit string to an integer value. */
-extern int otoi PROTO ((Char[]));
+extern int otoi(unsigned char[]);
 
 /* Output a (possibly-formatted) string to the generated scanner. */
-extern void out PROTO ((const char *));
-extern void out_dec PROTO ((const char *, int));
-extern void out_dec2 PROTO ((const char *, int, int));
-extern void out_hex PROTO ((const char *, unsigned int));
-extern void out_str PROTO ((const char *, const char *));
-extern void out_str3
-PROTO ((const char *, const char *, const char *, const char *));
-extern void out_str_dec PROTO ((const char *, const char *, int));
-extern void outc PROTO ((int));
-extern void outn PROTO ((const char *));
-extern void out_m4_define (const char* def, const char* val);
+extern void out(const char *);
+extern void out_dec(const char *, int);
+extern void out_dec2(const char *, int, int);
+extern void out_hex(const char *, unsigned int);
+extern void out_str(const char *, const char *);
+extern void out_str3(const char *, const char *, const char *, const char *);
+extern void out_str_dec(const char *, const char *, int);
+extern void outc(int);
+extern void outn(const char *);
+extern void out_m4_define(const char* def, const char* val);
 
 /* Return a printable version of the given character, which might be
  * 8-bit.
  */
-extern char *readable_form PROTO ((int));
+extern char *readable_form(int);
 
 /* Write out one section of the skeleton file. */
-extern void skelout PROTO ((void));
+extern void skelout(void);
 
 /* Output a yy_trans_info structure. */
-extern void transition_struct_out PROTO ((int, int));
+extern void transition_struct_out(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 *, size_t));
+extern void *yy_flex_xmalloc(int);
 
 
 /* from file nfa.c */
 
 /* Add an accepting state to a machine. */
-extern void add_accept PROTO ((int, int));
+extern void add_accept(int, int);
 
 /* Make a given number of copies of a singleton machine. */
-extern int copysingl PROTO ((int, int));
+extern int copysingl(int, int);
 
 /* Debugging routine to write out an nfa. */
-extern void dumpnfa PROTO ((int));
+extern void dumpnfa(int);
 
 /* Finish up the processing for a rule. */
-extern void finish_rule PROTO ((int, int, int, int, int));
+extern void finish_rule(int, int, int, int, int);
 
 /* Connect two machines together. */
-extern int link_machines PROTO ((int, int));
+extern int link_machines(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 ((int));
+extern void mark_beginning_as_normal(int);
 
 /* Make a machine that branches to two machines. */
-extern int mkbranch PROTO ((int, int));
+extern int mkbranch(int, int);
 
-extern int mkclos PROTO ((int));	/* convert a machine into a closure */
-extern int mkopt PROTO ((int));	/* make a machine optional */
+extern int mkclos(int);	/* convert a machine into a closure */
+extern int mkopt(int);	/* make a machine optional */
 
 /* Make a machine that matches either one of two machines. */
-extern int mkor PROTO ((int, int));
+extern int mkor(int, int);
 
 /* Convert a machine into a positive closure. */
-extern int mkposcl PROTO ((int));
+extern int mkposcl(int);
 
-extern int mkrep PROTO ((int, int, int));	/* make a replicated machine */
+extern int mkrep(int, int, int);	/* make a replicated machine */
 
 /* Create a state with a transition on a given symbol. */
-extern int mkstate PROTO ((int));
+extern int mkstate(int);
 
-extern void new_rule PROTO ((void));	/* initialize for a new rule */
+extern void new_rule(void);	/* initialize for a new rule */
 
 
 /* from file parse.y */
 
 /* Build the "<<EOF>>" action for the active start conditions. */
-extern void build_eof_action PROTO ((void));
+extern void build_eof_action(void);
 
 /* Write out a message formatted with one string, pinpointing its location. */
-extern void format_pinpoint_message PROTO ((const char *, const char *));
+extern void format_pinpoint_message(const char *, const char *);
 
 /* Write out a message, pinpointing its location. */
-extern void pinpoint_message PROTO ((const char *));
+extern void pinpoint_message(const char *);
 
 /* Write out a warning, pinpointing it at the given line. */
-extern void line_warning PROTO ((const char *, int));
+extern void line_warning(const char *, int);
 
 /* Write out a message, pinpointing it at the given line. */
-extern void line_pinpoint PROTO ((const char *, int));
+extern void line_pinpoint(const char *, int);
 
 /* Report a formatted syntax error. */
-extern void format_synerr PROTO ((const char *, const char *));
-extern void synerr PROTO ((const char *));	/* report a syntax error */
-extern void format_warn PROTO ((const char *, const char *));
-extern void warn PROTO ((const char *));	/* report a warning */
-extern void yyerror PROTO ((const char *));	/* report a parse error */
-extern int yyparse PROTO ((void));	/* the YACC parser */
+extern void format_synerr(const char *, const char *);
+extern void synerr(const char *);	/* report a syntax error */
+extern void format_warn(const char *, const char *);
+extern void warn(const char *);	/* report a warning */
+extern void yyerror(const char *);	/* report a parse error */
 
 
 /* from file scan.l */
 
 /* The Flex-generated scanner for flex. */
-extern int flexscan PROTO ((void));
+extern int flexscan(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));
+extern void set_input_file(char *);
 
 
 /* from file sym.c */
 
 /* Save the text of a character class. */
-extern void cclinstal PROTO ((Char[], int));
+extern void cclinstal(char[], int);
 
 /* Lookup the number associated with character class. */
-extern int ccllookup PROTO ((Char[]));
+extern int ccllookup(char[]);
 
-extern void ndinstal PROTO ((const char *, Char[]));	/* install a name definition */
-extern Char *ndlookup PROTO ((const char *));	/* lookup a name definition */
+extern void ndinstal(const char *, char[]);	/* install a name definition */
+extern char *ndlookup(const char *);	/* lookup a name definition */
 
 /* Increase maximum number of SC's. */
-extern void scextend PROTO ((void));
-extern void scinstal PROTO ((const char *, int));	/* make a start condition */
+extern void scextend(void);
+extern void scinstal(const char *, int);	/* make a start condition */
 
 /* Lookup the number associated with a start condition. */
-extern int sclookup PROTO ((const char *));
+extern int sclookup(const char *);
 
 
 /* from file tblcmp.c */
 
 /* Build table entries for dfa state. */
-extern void bldtbl PROTO ((int[], int, int, int, int));
+extern void bldtbl(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 cmptmps(void);	/* compress template table entries */
+extern void expand_nxt_chk(void);	/* increase nxt/chk arrays */
 
 /* Finds a space in the table for a state to be placed. */
-extern int find_table_space PROTO ((int *, int));
-extern void inittbl PROTO ((void));	/* initialize transition tables */
+extern int find_table_space(int *, int);
+extern void inittbl(void);	/* initialize transition tables */
 
 /* Make the default, "jam" table entries. */
-extern void mkdeftbl PROTO ((void));
+extern void mkdeftbl(void);
 
 /* Create table entries for a state (or state fragment) which has
  * only one out-transition.
  */
-extern void mk1tbl PROTO ((int, int, int, int));
+extern void mk1tbl(int, int, int, int);
 
 /* Place a state into full speed transition table. */
-extern void place_state PROTO ((int *, int, int));
+extern void place_state(int *, int, int);
 
 /* Save states with only one out-transition to be processed later. */
-extern void stack1 PROTO ((int, int, int, int));
+extern void stack1(int, int, int, int);
 
 
 /* from file yylex.c */
 
-extern int yylex PROTO ((void));
+extern int yylex(void);
 
 /* A growable array. See buf.c. */
 struct Buf {
@@ -1111,21 +1046,18 @@ struct Buf {
 	int     nmax;		/* max capacity of elements. */
 };
 
-extern void buf_init PROTO ((struct Buf * buf, size_t elem_size));
-extern void buf_destroy PROTO ((struct Buf * buf));
-extern struct Buf *buf_append
-PROTO ((struct Buf * buf, const void *ptr, int n_elem));
-extern struct Buf *buf_concat PROTO((struct Buf* dest, const struct Buf* src));
-extern struct Buf *buf_strappend PROTO ((struct Buf *, const char *str));
-extern struct Buf *buf_strnappend
-PROTO ((struct Buf *, const char *str, int nchars));
-extern struct Buf *buf_strdefine
-PROTO ((struct Buf * buf, const char *str, const char *def));
-extern struct Buf *buf_prints PROTO((struct Buf *buf, const char *fmt, const char* s));
-extern struct Buf *buf_m4_define PROTO((struct Buf *buf, const char* def, const char* val));
-extern struct Buf *buf_m4_undefine PROTO((struct Buf *buf, const char* def));
-extern struct Buf *buf_print_strings PROTO((struct Buf * buf, FILE* out));
-extern struct Buf *buf_linedir PROTO((struct Buf *buf, const char* filename, int lineno));
+extern void buf_init(struct Buf * buf, size_t elem_size);
+extern void buf_destroy(struct Buf * buf);
+extern struct Buf *buf_append(struct Buf * buf, const void *ptr, int n_elem);
+extern struct Buf *buf_concat(struct Buf* dest, const struct Buf* src);
+extern struct Buf *buf_strappend(struct Buf *, const char *str);
+extern struct Buf *buf_strnappend(struct Buf *, const char *str, int nchars);
+extern struct Buf *buf_strdefine(struct Buf * buf, const char *str, const char *def);
+extern struct Buf *buf_prints(struct Buf *buf, const char *fmt, const char* s);
+extern struct Buf *buf_m4_define(struct Buf *buf, const char* def, const char* val);
+extern struct Buf *buf_m4_undefine(struct Buf *buf, const char* def);
+extern struct Buf *buf_print_strings(struct Buf * buf, FILE* out);
+extern struct Buf *buf_linedir(struct Buf *buf, const char* filename, int lineno);
 
 extern struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */
 extern struct Buf defs_buf;    /* a char* buffer to save #define'd some symbols generated by flex. */
@@ -1187,14 +1119,14 @@ struct filter {
 
 /* output filter chain */
 extern struct filter * output_chain;
-extern struct filter *filter_create_ext PROTO((struct filter * chain, const char *cmd, ...));
-struct filter *filter_create_int PROTO((struct filter *chain,
+extern struct filter *filter_create_ext (struct filter * chain, const char *cmd, ...);
+struct filter *filter_create_int(struct filter *chain,
 				  int (*filter_func) (struct filter *),
-                  void *extra));
-extern bool filter_apply_chain PROTO((struct filter * chain));
-extern int filter_truncate (struct filter * chain, int max_len);
-extern int filter_tee_header PROTO((struct filter *chain));
-extern int filter_fix_linedirs PROTO((struct filter *chain));
+                  void *extra);
+extern bool filter_apply_chain(struct filter * chain);
+extern int filter_truncate(struct filter * chain, int max_len);
+extern int filter_tee_header(struct filter *chain);
+extern int filter_fix_linedirs(struct filter *chain);
 
 
 /*
@@ -1214,9 +1146,9 @@ bool regmatch_empty (regmatch_t * m);
 typedef unsigned int scanflags_t;
 extern scanflags_t* _sf_stk;
 extern size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */
-#define _SF_CASE_INS   0x0001
-#define _SF_DOT_ALL    0x0002
-#define _SF_SKIP_WS    0x0004
+#define _SF_CASE_INS   ((scanflags_t) 0x0001)
+#define _SF_DOT_ALL    ((scanflags_t) 0x0002)
+#define _SF_SKIP_WS    ((scanflags_t) 0x0004)
 #define sf_top()           (_sf_stk[_sf_top_ix])
 #define sf_case_ins()      (sf_top() & _SF_CASE_INS)
 #define sf_dot_all()       (sf_top() & _SF_DOT_ALL)
diff --git a/src/gen.c b/src/gen.c
index 81e7c27..4688709 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -37,16 +37,11 @@
 
 /* declare functions that have forward references */
 
-void gen_next_state PROTO ((int));
-void genecs PROTO ((void));
-void indent_put2s PROTO ((const char *, const char *));
-void indent_puts PROTO ((const char *));
+void	genecs(void);
 
 
 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
@@ -125,12 +120,12 @@ static struct yytbl_data *mkeoltbl (void)
 	flex_int8_t *tdata = 0;
 	struct yytbl_data *tbl;
 
-	tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
+	tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL);
 	tbl->td_flags = YYTD_DATA8;
 	tbl->td_lolen = num_rules + 1;
 	tbl->td_data = tdata =
-		(flex_int8_t *) calloc (tbl->td_lolen, sizeof (flex_int8_t));
+		calloc(tbl->td_lolen, sizeof (flex_int8_t));
 
 	for (i = 1; i <= num_rules; i++)
 		tdata[i] = rule_has_nl[i] ? 1 : 0;
@@ -176,12 +171,12 @@ void gen_backing_up (void)
 	else
 		indent_puts ("if ( yy_accept[yy_current_state] )");
 
-	indent_up ();
+	++indent_level;
 	indent_puts ("{");
 	indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;");
 	indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;");
 	indent_puts ("}");
-	indent_down ();
+	--indent_level;
 }
 
 
@@ -232,14 +227,14 @@ static struct yytbl_data *mkctbl (void)
 		    ((tblend + numecs + 1) >= INT16_MAX
 		     || long_align) ? "flex_int32_t" : "flex_int16_t");
 
-	tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
+	tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (tbl, YYTD_ID_TRANSITION);
 	tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT;
 	tbl->td_hilen = 0;
 	tbl->td_lolen = tblend + numecs + 1;	/* number of structs */
 
 	tbl->td_data = tdata =
-		(flex_int32_t *) calloc (tbl->td_lolen * 2, sizeof (flex_int32_t));
+		calloc(tbl->td_lolen * 2, sizeof (flex_int32_t));
 
 	/* We want the transition to be represented as the offset to the
 	 * next state, not the actual state number, which is what it currently
@@ -328,14 +323,14 @@ static struct yytbl_data *mkssltbl (void)
 	flex_int32_t *tdata = 0;
 	flex_int32_t i;
 
-	tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
+	tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST);
 	tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS;
 	tbl->td_hilen = 0;
 	tbl->td_lolen = lastsc * 2 + 1;
 
 	tbl->td_data = tdata =
-		(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(tbl->td_lolen, sizeof (flex_int32_t));
 
 	for (i = 0; i <= lastsc * 2; ++i)
 		tdata[i] = base[i];
@@ -452,20 +447,20 @@ void genctbl (void)
 
 /* mkecstbl - Make equivalence-class tables.  */
 
-struct yytbl_data *mkecstbl (void)
+static struct yytbl_data *mkecstbl (void)
 {
 	int i;
 	struct yytbl_data *tbl = 0;
 	flex_int32_t *tdata = 0;
 
-	tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
+	tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (tbl, YYTD_ID_EC);
 	tbl->td_flags |= YYTD_DATA32;
 	tbl->td_hilen = 0;
 	tbl->td_lolen = csize;
 
 	tbl->td_data = tdata =
-		(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(tbl->td_lolen, sizeof (flex_int32_t));
 
 	for (i = 1; i < csize; ++i) {
 		ecgroup[i] = ABS (ecgroup[i]);
@@ -534,13 +529,13 @@ void gen_find_action (void)
 		indent_puts
 			("for ( ; ; ) /* until we find what rule we matched */");
 
-		indent_up ();
+		++indent_level;
 
 		indent_puts ("{");
 
 		indent_puts
 			("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 		indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];");
 
@@ -548,25 +543,25 @@ void gen_find_action (void)
 			indent_puts
 				("if ( yy_act & YY_TRAILING_HEAD_MASK ||");
 			indent_puts ("     YY_G(yy_looking_for_trail_begin) )");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{");
 
 			indent_puts
 				("if ( yy_act == YY_G(yy_looking_for_trail_begin) )");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{");
 			indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;");
 			indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;");
 			indent_puts ("break;");
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 
 			indent_puts
 				("else if ( yy_act & YY_TRAILING_MASK )");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{");
 			indent_puts
 				("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;");
@@ -585,10 +580,10 @@ void gen_find_action (void)
 			}
 
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 
 			indent_puts ("else");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{");
 			indent_puts ("YY_G(yy_full_match) = yy_cp;");
 			indent_puts
@@ -596,7 +591,7 @@ void gen_find_action (void)
 			indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
 			indent_puts ("break;");
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 
 			indent_puts ("++YY_G(yy_lp);");
 			indent_puts ("goto find_rule;");
@@ -606,16 +601,16 @@ void gen_find_action (void)
 			/* Remember matched text in case we back up due to
 			 * trailing context plus REJECT.
 			 */
-			indent_up ();
+			++indent_level;
 			indent_puts ("{");
 			indent_puts ("YY_G(yy_full_match) = yy_cp;");
 			indent_puts ("break;");
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 		}
 
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 
 		indent_puts ("--yy_cp;");
 
@@ -628,7 +623,7 @@ void gen_find_action (void)
 
 		indent_puts ("}");
 
-		indent_down ();
+		--indent_level;
 	}
 
 	else {			/* compressed */
@@ -639,7 +634,7 @@ void gen_find_action (void)
 			 * the match.
 			 */
 			indent_puts ("if ( yy_act == 0 )");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{ /* have to back up */");
 			indent_puts
 				("yy_cp = YY_G(yy_last_accepting_cpos);");
@@ -648,7 +643,7 @@ void gen_find_action (void)
 			indent_puts
 				("yy_act = yy_accept[yy_current_state];");
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 		}
 	}
 }
@@ -664,14 +659,14 @@ struct yytbl_data *mkftbl (void)
 	struct yytbl_data *tbl;
 	flex_int32_t *tdata = 0;
 
-	tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
+	tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (tbl, YYTD_ID_ACCEPT);
 	tbl->td_flags |= YYTD_DATA32;
 	tbl->td_hilen = 0;	/* it's a one-dimensional array */
 	tbl->td_lolen = lastdfa + 1;
 
 	tbl->td_data = tdata =
-		(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(tbl->td_lolen, sizeof (flex_int32_t));
 
 	dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
 
@@ -727,8 +722,7 @@ void genftbl (void)
 
 /* Generate the code to find the next compressed-table state. */
 
-void gen_next_compressed_state (char_map)
-     char   *char_map;
+void gen_next_compressed_state (char *char_map)
 {
 	indent_put2s ("YY_CHAR yy_c = %s;", char_map);
 
@@ -740,7 +734,7 @@ void gen_next_compressed_state (char_map)
 
 	indent_puts
 		("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )");
-	indent_up ();
+	++indent_level;
 	indent_puts ("{");
 	indent_puts ("yy_current_state = (int) yy_def[yy_current_state];");
 
@@ -757,16 +751,16 @@ void gen_next_compressed_state (char_map)
 		/* lastdfa + 2 is the beginning of the templates */
 		out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2);
 
-		indent_up ();
+		++indent_level;
 		indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];");
-		indent_down ();
+		--indent_level;
 	}
 
 	indent_puts ("}");
-	indent_down ();
+	--indent_level;
 
 	indent_puts
-		("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];");
+		("yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];");
 }
 
 
@@ -793,7 +787,7 @@ void gen_next_match (void)
 				("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN +  %s ]) > 0 )",
 				 char_map);
 
-		indent_up ();
+		++indent_level;
 
 		if (num_backing_up > 0) {
 			indent_puts ("{");
@@ -807,7 +801,7 @@ void gen_next_match (void)
 
 			indent_puts ("}");
 
-		indent_down ();
+		--indent_level;
 
 		outc ('\n');
 		indent_puts ("yy_current_state = -yy_current_state;");
@@ -824,7 +818,7 @@ void gen_next_match (void)
 		indent_puts ("yy_verify == yy_c;");
 		indent_put2s ("      yy_c = %s )", char_map_2);
 
-		indent_up ();
+		++indent_level;
 
 		if (num_backing_up > 0)
 			indent_puts ("{");
@@ -837,14 +831,14 @@ void gen_next_match (void)
 			indent_puts ("}");
 		}
 
-		indent_down ();
+		--indent_level;
 		indent_puts ("}");
 	}
 
 	else {			/* compressed */
 		indent_puts ("do");
 
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 
 		gen_next_state (false);
@@ -853,7 +847,7 @@ void gen_next_match (void)
 
 
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 
 		do_indent ();
 
@@ -878,8 +872,7 @@ void gen_next_match (void)
 
 /* Generate the code to find the next state. */
 
-void gen_next_state (worry_about_NULs)
-     int worry_about_NULs;
+void gen_next_state (int worry_about_NULs)
 {				/* NOTE - changes in here should be reflected in gen_next_match() */
 	char    char_map[256];
 
@@ -905,7 +898,7 @@ void gen_next_state (worry_about_NULs)
 			gen_backing_up ();
 
 		indent_puts ("if ( *yy_cp )");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 	}
 
@@ -931,12 +924,12 @@ void gen_next_state (worry_about_NULs)
 	if (worry_about_NULs && nultrans) {
 
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 		indent_puts ("else");
-		indent_up ();
+		++indent_level;
 		indent_puts
 			("yy_current_state = yy_NUL_trans[yy_current_state];");
-		indent_down ();
+		--indent_level;
 	}
 
 	if (fullspd || fulltbl)
@@ -1009,10 +1002,10 @@ void gen_NUL_trans (void)
 			 * the state stack and yy_c_buf_p get out of sync.
 			 */
 			indent_puts ("if ( ! yy_is_jam )");
-			indent_up ();
+			++indent_level;
 			indent_puts
 				("*YY_G(yy_state_ptr)++ = yy_current_state;");
-			indent_down ();
+			--indent_level;
 		}
 	}
 
@@ -1023,11 +1016,11 @@ void gen_NUL_trans (void)
 	if (need_backing_up && (fullspd || fulltbl)) {
 		outc ('\n');
 		indent_puts ("if ( ! yy_is_jam )");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 		gen_backing_up ();
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 	}
 }
 
@@ -1111,11 +1104,11 @@ void gentabs (void)
                 "\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n",
                 long_align ? "flex_int32_t" : "flex_int16_t");
 
-        yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data));
+        yyacclist_tbl = calloc(1,sizeof(struct yytbl_data));
         yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST);
         yyacclist_tbl->td_lolen  = MAX(numas,1) + 1;
         yyacclist_tbl->td_data = yyacclist_data = 
-            (flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t));
+            calloc(yyacclist_tbl->td_lolen, sizeof (flex_int32_t));
         yyacclist_curr = 1;
 
 		j = 1;		/* index into "yy_acclist" array */
@@ -1220,13 +1213,11 @@ void gentabs (void)
 		    "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
 		    long_align ? "flex_int32_t" : "flex_int16_t");
 
-	yyacc_tbl =
-		(struct yytbl_data *) calloc (1,
-					      sizeof (struct yytbl_data));
+	yyacc_tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT);
 	yyacc_tbl->td_lolen = k;
 	yyacc_tbl->td_data = yyacc_data =
-		(flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(yyacc_tbl->td_lolen, sizeof (flex_int32_t));
     yyacc_curr=1;
 
 	for (i = 1; i <= lastdfa; ++i) {
@@ -1279,14 +1270,11 @@ void gentabs (void)
 		 * templates with).
 		 */
 		flex_int32_t *yymecs_data = 0;
-		yymeta_tbl =
-			(struct yytbl_data *) calloc (1,
-						      sizeof (struct
-							      yytbl_data));
+		yymeta_tbl = calloc(1, sizeof (struct yytbl_data));
 		yytbl_data_init (yymeta_tbl, YYTD_ID_META);
 		yymeta_tbl->td_lolen = numecs + 1;
 		yymeta_tbl->td_data = yymecs_data =
-			(flex_int32_t *) calloc (yymeta_tbl->td_lolen,
+			calloc(yymeta_tbl->td_lolen,
 					    sizeof (flex_int32_t));
 
 		if (trace)
@@ -1330,13 +1318,11 @@ void gentabs (void)
 		    "\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n",
 		    (tblend >= INT16_MAX
 		     || long_align) ? "flex_uint32_t" : "flex_uint16_t");
-	yybase_tbl =
-		(struct yytbl_data *) calloc (1,
-					      sizeof (struct yytbl_data));
+	yybase_tbl = calloc (1, sizeof (struct yytbl_data));
 	yytbl_data_init (yybase_tbl, YYTD_ID_BASE);
 	yybase_tbl->td_lolen = total_states + 1;
 	yybase_tbl->td_data = yybase_data =
-		(flex_int32_t *) calloc (yybase_tbl->td_lolen,
+		calloc(yybase_tbl->td_lolen,
 				    sizeof (flex_int32_t));
 	yybase_curr = 1;
 
@@ -1390,13 +1376,11 @@ void gentabs (void)
 		    (total_states >= INT16_MAX
 		     || long_align) ? "flex_int32_t" : "flex_int16_t");
 
-	yydef_tbl =
-		(struct yytbl_data *) calloc (1,
-					      sizeof (struct yytbl_data));
+	yydef_tbl = calloc(1, sizeof (struct yytbl_data));
 	yytbl_data_init (yydef_tbl, YYTD_ID_DEF);
 	yydef_tbl->td_lolen = total_states + 1;
 	yydef_tbl->td_data = yydef_data =
-		(flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(yydef_tbl->td_lolen, sizeof (flex_int32_t));
 
 	for (i = 1; i <= total_states; ++i) {
 		mkdata (def[i]);
@@ -1424,13 +1408,11 @@ void gentabs (void)
 		    (total_states >= INT16_MAX
 		     || long_align) ? "flex_uint32_t" : "flex_uint16_t");
 
-	yynxt_tbl =
-		(struct yytbl_data *) calloc (1,
-					      sizeof (struct yytbl_data));
+	yynxt_tbl = calloc (1, sizeof (struct yytbl_data));
 	yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
 	yynxt_tbl->td_lolen = tblend + 1;
 	yynxt_tbl->td_data = yynxt_data =
-		(flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t));
+		calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t));
 
 	for (i = 1; i <= tblend; ++i) {
 		/* Note, the order of the following test is important.
@@ -1463,13 +1445,11 @@ void gentabs (void)
 		    (total_states >= INT16_MAX
 		     || long_align) ? "flex_int32_t" : "flex_int16_t");
 
-	yychk_tbl =
-		(struct yytbl_data *) calloc (1,
-					      sizeof (struct yytbl_data));
+	yychk_tbl = calloc (1, sizeof (struct yytbl_data));
 	yytbl_data_init (yychk_tbl, YYTD_ID_CHK);
 	yychk_tbl->td_lolen = tblend + 1;
 	yychk_tbl->td_data = yychk_data =
-		(flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t));
+		calloc(yychk_tbl->td_lolen, sizeof (flex_int32_t));
 
 	for (i = 1; i <= tblend; ++i) {
 		if (chk[i] == 0)
@@ -1489,7 +1469,7 @@ void gentabs (void)
 	}
 	/* End generating yy_chk */
 
-	flex_free ((void *) acc_array);
+	free(acc_array);
 }
 
 
@@ -1497,8 +1477,7 @@ void gentabs (void)
  * current indentation level, adding a final newline.
  */
 
-void indent_put2s (fmt, arg)
-     const char *fmt, *arg;
+void indent_put2s (const char *fmt, const char *arg)
 {
 	do_indent ();
 	out_str (fmt, arg);
@@ -1510,8 +1489,7 @@ void indent_put2s (fmt, arg)
  * newline.
  */
 
-void indent_puts (str)
-     const char *str;
+void indent_puts (const char *str)
 {
 	do_indent ();
 	outn (str);
@@ -1538,11 +1516,11 @@ void make_tables (void)
 	if (yymore_used && !yytext_is_array) {
 		indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\");
 		indent_puts
-			("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\");
+			("yyleng = (int) (yy_cp - YY_G(yytext_ptr)); \\");
 	}
 
 	else
-		indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\");
+		indent_puts ("yyleng = (int) (yy_cp - yy_bp); \\");
 
 	/* Now also deal with copying yytext_ptr to yytext if needed. */
 	skelout ();		/* %% [3.0] - break point in skel */
@@ -1553,10 +1531,10 @@ void make_tables (void)
 		else
 			indent_puts ("if ( yyleng >= YYLMAX ) \\");
 
-		indent_up ();
+		++indent_level;
 		indent_puts
 			("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\");
-		indent_down ();
+		--indent_level;
 
 		if (yymore_used) {
 			indent_puts
@@ -1593,7 +1571,7 @@ void make_tables (void)
 
 		set_indent (0);
 		indent_puts ("struct yy_trans_info");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 
 		/* We require that yy_verify and yy_nxt must be of the same size int. */
@@ -1609,7 +1587,7 @@ void make_tables (void)
 
 		indent_put2s ("%s yy_nxt;", trans_offset_type);
 		indent_puts ("};");
-		indent_down ();
+		--indent_level;
 	}
 	else {
 		/* We generate a bogus 'struct yy_trans_info' data type
@@ -1621,12 +1599,12 @@ void make_tables (void)
 			("/* This struct is not used in this scanner,");
 		indent_puts ("   but its presence is necessary. */");
 		indent_puts ("struct yy_trans_info");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 		indent_puts ("flex_int32_t yy_verify;");
 		indent_puts ("flex_int32_t yy_nxt;");
 		indent_puts ("};");
-		indent_down ();
+		--indent_level;
 	}
 
 	if (fullspd) {
@@ -1724,16 +1702,13 @@ void make_tables (void)
 			    (fullspd) ? "struct yy_trans_info*" :
 			    "flex_int32_t");
 
-		yynultrans_tbl =
-			(struct yytbl_data *) calloc (1,
-						      sizeof (struct
-							      yytbl_data));
+		yynultrans_tbl = calloc(1, sizeof (struct yytbl_data));
 		yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS);
 		if (fullspd)
 			yynultrans_tbl->td_flags |= YYTD_PTRANS;
 		yynultrans_tbl->td_lolen = lastdfa + 1;
 		yynultrans_tbl->td_data = yynultrans_data =
-			(flex_int32_t *) calloc (yynultrans_tbl->td_lolen,
+			calloc(yynultrans_tbl->td_lolen,
 					    sizeof (flex_int32_t));
 
 		for (i = 1; i <= lastdfa; ++i) {
@@ -1850,13 +1825,13 @@ void make_tables (void)
 			indent_puts ("#define YY_MORE_ADJ 0");
 			indent_puts
 				("#define YY_RESTORE_YY_MORE_OFFSET \\");
-			indent_up ();
+			++indent_level;
 			indent_puts ("{ \\");
 			indent_puts
 				("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\");
 			indent_puts ("yyleng -= YY_G(yy_more_offset); \\");
 			indent_puts ("}");
-			indent_down ();
+			--indent_level;
 		}
 		else {
 			indent_puts
@@ -1900,7 +1875,7 @@ void make_tables (void)
 	if (!C_plus_plus) {
 		if (use_read) {
 			outn ("\terrno=0; \\");
-			outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\");
+			outn ("\twhile ( (result = (int) read( fileno(yyin), buf, max_size )) < 0 ) \\");
 			outn ("\t{ \\");
 			outn ("\t\tif( errno != EINTR) \\");
 			outn ("\t\t{ \\");
@@ -1929,7 +1904,7 @@ void make_tables (void)
 			outn ("\telse \\");
 			outn ("\t\t{ \\");
 			outn ("\t\terrno=0; \\");
-			outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\");
+			outn ("\t\twhile ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\");
 			outn ("\t\t\t{ \\");
 			outn ("\t\t\tif( errno != EINTR) \\");
 			outn ("\t\t\t\t{ \\");
@@ -1946,16 +1921,16 @@ void make_tables (void)
 	skelout ();		/* %% [6.0] - break point in skel */
 
 	indent_puts ("#define YY_RULE_SETUP \\");
-	indent_up ();
+	++indent_level;
 	if (bol_needed) {
 		indent_puts ("if ( yyleng > 0 ) \\");
-		indent_up ();
+		++indent_level;
 		indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\");
 		indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\");
-		indent_down ();
+		--indent_level;
 	}
 	indent_puts ("YY_USER_ACTION");
-	indent_down ();
+	--indent_level;
 
 	skelout ();		/* %% [7.0] - break point in skel */
 
@@ -1971,13 +1946,13 @@ void make_tables (void)
 	if (yymore_used && !yytext_is_array) {
 		indent_puts ("YY_G(yy_more_len) = 0;");
 		indent_puts ("if ( YY_G(yy_more_flag) )");
-		indent_up ();
+		++indent_level;
 		indent_puts ("{");
 		indent_puts
 			("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);");
 		indent_puts ("YY_G(yy_more_flag) = 0;");
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 	}
 
 	skelout ();		/* %% [9.0] - break point in skel */
@@ -1996,39 +1971,39 @@ void make_tables (void)
 	outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");
 	indent_puts
 		("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )");
-	indent_up ();
+	++indent_level;
 	indent_puts ("{");
 	indent_puts ("yy_size_t yyl;");
 	do_indent ();
 	out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n",
 		 yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" :
 				"YY_G(yy_more_len)") : "0");
-	indent_up ();
+	++indent_level;
 	indent_puts ("if ( yytext[yyl] == '\\n' )");
-	indent_up ();
+	++indent_level;
 	indent_puts ("M4_YY_INCR_LINENO();");
-	indent_down ();
-	indent_down ();
+	--indent_level;
+	--indent_level;
 	indent_puts ("}");
-	indent_down ();
+	--indent_level;
 	outn ("]])");
 
 	skelout ();		/* %% [12.0] - break point in skel */
 	if (ddebug) {
 		indent_puts ("if ( yy_flex_debug )");
-		indent_up ();
+		++indent_level;
 
 		indent_puts ("{");
 		indent_puts ("if ( yy_act == 0 )");
-		indent_up ();
+		++indent_level;
 		indent_puts (C_plus_plus ?
 			     "std::cerr << \"--scanner backing up\\n\";" :
 			     "fprintf( stderr, \"--scanner backing up\\n\" );");
-		indent_down ();
+		--indent_level;
 
 		do_indent ();
 		out_dec ("else if ( yy_act < %d )\n", num_rules);
-		indent_up ();
+		++indent_level;
 
 		if (C_plus_plus) {
 			indent_puts
@@ -2044,11 +2019,11 @@ void make_tables (void)
 				("         (long)yy_rule_linenum[yy_act], yytext );");
 		}
 
-		indent_down ();
+		--indent_level;
 
 		do_indent ();
 		out_dec ("else if ( yy_act == %d )\n", num_rules);
-		indent_up ();
+		++indent_level;
 
 		if (C_plus_plus) {
 			indent_puts
@@ -2060,21 +2035,21 @@ void make_tables (void)
 			indent_puts ("         yytext );");
 		}
 
-		indent_down ();
+		--indent_level;
 
 		do_indent ();
 		out_dec ("else if ( yy_act == %d )\n", num_rules + 1);
-		indent_up ();
+		++indent_level;
 
 		indent_puts (C_plus_plus ?
 			     "std::cerr << \"--(end of buffer or a NUL)\\n\";" :
 			     "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );");
 
-		indent_down ();
+		--indent_level;
 
 		do_indent ();
 		outn ("else");
-		indent_up ();
+		++indent_level;
 
 		if (C_plus_plus) {
 			indent_puts
@@ -2085,15 +2060,15 @@ void make_tables (void)
 				("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );");
 		}
 
-		indent_down ();
+		--indent_level;
 
 		indent_puts ("}");
-		indent_down ();
+		--indent_level;
 	}
 
 	/* Copy actions to output file. */
 	skelout ();		/* %% [13.0] - break point in skel */
-	indent_up ();
+	++indent_level;
 	gen_bu_action ();
 	out (&action_array[action_offset]);
 
@@ -2108,9 +2083,9 @@ void make_tables (void)
 		}
 
 	if (did_eof_rule) {
-		indent_up ();
+		++indent_level;
 		indent_puts ("yyterminate();");
-		indent_down ();
+		--indent_level;
 	}
 
 
@@ -2168,17 +2143,17 @@ void make_tables (void)
 		if (do_yylineno) {
 			indent_puts
 				("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )");
-			indent_up ();
+			++indent_level;
 			indent_puts ("M4_YY_INCR_LINENO();");
-			indent_down ();
+			--indent_level;
 		}
 	}
 
 	else if (do_yylineno) {
 		indent_puts ("if ( c == '\\n' )");
-		indent_up ();
+		++indent_level;
 		indent_puts ("M4_YY_INCR_LINENO();");
-		indent_down ();
+		--indent_level;
 	}
 
 	skelout ();
diff --git a/src/libmain.c b/src/libmain.c
index f400fc3..bb2fe35 100644
--- a/src/libmain.c
+++ b/src/libmain.c
@@ -21,6 +21,8 @@
 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
 /*  PURPOSE. */
 
+#include <stdlib.h>
+
 extern int yylex (void);
 
 int     main (int argc, char *argv[])
@@ -30,5 +32,5 @@ int     main (int argc, char *argv[])
 
 	while (yylex () != 0) ;
 
-	return 0;
+	exit(0);
 }
diff --git a/src/main.c b/src/main.c
index 8710702..e329e4e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -36,15 +36,15 @@
 #include "version.h"
 #include "options.h"
 #include "tables.h"
+#include "parse.h"
 
 static char flex_version[] = FLEX_VERSION;
 
 /* declare functions that have forward references */
 
-void flexinit PROTO ((int, char **));
-void readin PROTO ((void));
-void set_up_initial_allocations PROTO ((void));
-static char *basename2 PROTO ((char *path, int should_strip_ext));
+void flexinit(int, char **);
+void readin(void);
+void set_up_initial_allocations(void);
 
 
 /* these globals are all defined and commented in flexdef.h */
@@ -94,7 +94,7 @@ int    *accsiz, *dhash, numas;
 int     numsnpairs, jambase, jamstate;
 int     lastccl, *cclmap, *ccllen, *cclng, cclreuse;
 int     current_maxccls, current_max_ccl_tbl_size;
-Char   *ccltbl;
+unsigned char   *ccltbl;
 char    nmstr[MAXLINE];
 int     sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
 int     tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
@@ -117,19 +117,9 @@ struct yytbl_writer tableswr;
  */
 char   *program_name = "flex";
 
-#ifndef SHORT_FILE_NAMES
 static const char outfile_template[] = "lex.%s.%s";
 static const char backing_name[] = "lex.backup";
 static const char tablesfile_template[] = "lex.%s.tables";
-#else
-static const char outfile_template[] = "lex%s.%s";
-static const char backing_name[] = "lex.bck";
-static const char tablesfile_template[] = "lex%s.tbl";
-#endif
-
-#ifdef MS_DOS
-extern unsigned _stklen = 16384;
-#endif
 
 /* From scan.l */
 extern FILE* yyout;
@@ -144,12 +134,9 @@ const char *escaped_qend   = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
 /* For debugging. The max number of filters to apply to skeleton. */
 static int preproc_level = 1000;
 
-int flex_main PROTO ((int argc, char *argv[]));
-int main PROTO ((int argc, char *argv[]));
+int flex_main (int argc, char *argv[]);
 
-int flex_main (argc, argv)
-     int argc;
-     char   *argv[];
+int flex_main (int argc, char *argv[])
 {
 	int     i, exit_status, child_status;
 
@@ -209,9 +196,7 @@ int flex_main (argc, argv)
 }
 
 /* Wrapper around flex_main, so flex_main can be built as a library. */
-int main (argc, argv)
-     int argc;
-     char   *argv[];
+int main (int argc, char *argv[])
 {
 #if ENABLE_NLS
 #if HAVE_LOCALE_H
@@ -227,7 +212,7 @@ int main (argc, argv)
 
 /* check_options - check user-specified options */
 
-void check_options ()
+void check_options (void)
 {
 	int     i;
     const char * m4 = NULL;
@@ -363,8 +348,46 @@ void check_options ()
 
     /* Setup the filter chain. */
     output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
-    if ( !(m4 = getenv("M4")))
-        m4 = M4;
+    if ( !(m4 = getenv("M4"))) {
+	    char *slash;
+		m4 = M4;
+		if ((slash = strrchr(M4, '/')) != NULL) {
+			m4 = slash+1;
+			/* break up $PATH */
+			const char *path = getenv("PATH");
+			if (!path) {
+				m4 = M4;
+			} else {
+				do {
+					char m4_path[PATH_MAX];
+					int length = strlen(path);
+					struct stat sbuf;
+
+					const char *endOfDir = strchr(path, ':');
+					if (!endOfDir)
+						endOfDir = path+length;
+
+					if ((endOfDir-path+2) >= sizeof(m4_path)) {
+					    path = endOfDir+1;
+						continue;
+					}
+
+					strncpy(m4_path, path, sizeof(m4_path));
+					m4_path[endOfDir-path] = '/';
+					m4_path[endOfDir-path+1] = '\0';
+					strncat(m4_path, m4, sizeof(m4_path));
+					if (stat(m4_path, &sbuf) == 0 &&
+						(S_ISREG(sbuf.st_mode)) && sbuf.st_mode & S_IXUSR) {
+						m4 = strdup(m4_path);
+						break;
+					}
+					path = endOfDir+1;
+				} while (path[0]);
+				if (!path[0])
+				    m4 = M4;
+			}
+		}
+	}
     filter_create_ext(output_chain, m4, "-P", 0);
     filter_create_int(output_chain, filter_fix_linedirs, NULL);
 
@@ -396,20 +419,19 @@ void check_options ()
 
 		if (!tablesfilename) {
 			nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
-			tablesfilename = pname = (char *) calloc (nbytes, 1);
+			tablesfilename = pname = calloc(nbytes, 1);
 			snprintf (pname, nbytes, tablesfile_template, prefix);
 		}
 
 		if ((tablesout = fopen (tablesfilename, "w")) == NULL)
 			lerr (_("could not create %s"), tablesfilename);
-		if (pname)
-			free (pname);
+		free(pname);
 		tablesfilename = 0;
 
 		yytbl_writer_init (&tableswr, tablesout);
 
 		nbytes = strlen (prefix) + strlen ("tables") + 2;
-		tablesname = (char *) calloc (nbytes, 1);
+		tablesname = calloc(nbytes, 1);
 		snprintf (tablesname, nbytes, "%stables", prefix);
 		yytbl_hdr_init (&hdr, flex_version, tablesname);
 
@@ -452,7 +474,8 @@ void check_options ()
              char *str, *fmt = "#define %s %d\n";
              size_t strsz;
 
-             str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2);
+             strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2;
+             str = malloc(strsz);
              if (!str)
                flexfatal(_("allocation of macro definition failed"));
              snprintf(str, strsz, fmt,      scname[i], i - 1);
@@ -474,7 +497,8 @@ void check_options ()
     m4defs_buf.nelts = 0; /* memory leak here. */
 
     /* Place a bogus line directive, it will be fixed in the filter. */
-    outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
+    if (gen_line_dirs)
+        outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
 
 	/* Dump the user defined preproc directives. */
 	if (userdef_buf.elts)
@@ -490,9 +514,7 @@ void check_options ()
  *    This routine does not return.
  */
 
-void flexend (exit_status)
-     int exit_status;
-
+void flexend (int exit_status)
 {
 	static int called_before = -1;	/* prevent infinite recursion. */
 	int     tblsiz;
@@ -539,7 +561,6 @@ void flexend (exit_status)
                 "EOB_ACT_END_OF_FILE",
                 "EOB_ACT_LAST_MATCH",
                 "FLEX_SCANNER",
-                "FLEX_STD",
                 "REJECT",
                 "YYFARGS0",
                 "YYFARGS1",
@@ -926,9 +947,7 @@ void flexend (exit_status)
 
 /* flexinit - initialize flex */
 
-void flexinit (argc, argv)
-     int argc;
-     char  **argv;
+void flexinit (int argc, char **argv)
 {
 	int     i, sawcmpflag, rv, optind;
 	char   *arg;
@@ -982,9 +1001,9 @@ void flexinit (argc, argv)
     flex_init_regex();
 
 	/* Enable C++ if program name ends with '+'. */
-	program_name = basename2 (argv[0], 0);
+	program_name = basename (argv[0]);
 
-	if (program_name[0] != '\0' &&
+	if (program_name != NULL &&
 	    program_name[strlen (program_name) - 1] == '+')
 		C_plus_plus = true;
 
@@ -1456,13 +1475,13 @@ void flexinit (argc, argv)
 
 /* readin - read in the rules section of the input file(s) */
 
-void readin ()
+void readin (void)
 {
 	static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
 	static char yy_nostdinit[] =
-		"FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
+		"FILE *yyin = NULL, *yyout = NULL;";
 
-	line_directive_out ((FILE *) 0, 1);
+	line_directive_out(NULL, 1);
 
 	if (yyparse ()) {
 		pinpoint_message (_("fatal parse error"));
@@ -1715,7 +1734,7 @@ void readin ()
 
 /* set_up_initial_allocations - allocate memory for internal tables */
 
-void set_up_initial_allocations ()
+void set_up_initial_allocations (void)
 {
 	maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
 	current_mns = INITIAL_MNS;
@@ -1769,31 +1788,11 @@ void set_up_initial_allocations ()
 	dss = allocate_int_ptr_array (current_max_dfas);
 	dfaacc = allocate_dfaacc_union (current_max_dfas);
 
-	nultrans = (int *) 0;
+	nultrans = NULL;
 }
 
 
-/* extracts basename from path, optionally stripping the extension "\.*"
- * (same concept as /bin/sh `basename`, but different handling of extension). */
-static char *basename2 (path, strip_ext)
-     char   *path;
-     int strip_ext;		/* boolean */
-{
-	char   *b, *e = 0;
-
-	b = path;
-	for (b = path; *path; path++)
-		if (*path == '/')
-			b = path + 1;
-		else if (*path == '.')
-			e = path;
-
-	if (strip_ext && e && e > b)
-		*e = '\0';
-	return b;
-}
-
-void usage ()
+void usage (void)
 {
 	FILE   *f = stdout;
 
diff --git a/src/misc.c b/src/misc.c
index 8e0edca..a2f67fc 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -60,14 +60,15 @@ static void sko_push(bool dc)
 {
     if(!sko_stack){
         sko_sz = 1;
-        sko_stack = (struct sko_state*)flex_alloc(sizeof(struct sko_state)*sko_sz);
+        sko_stack = malloc(sizeof(struct sko_state) * (size_t) sko_sz);
         if (!sko_stack)
             flexfatal(_("allocation of sko_stack failed"));
         sko_len = 0;
     }
     if(sko_len >= sko_sz){
         sko_sz *= 2;
-        sko_stack = (struct sko_state*)flex_realloc(sko_stack,sizeof(struct sko_state)*sko_sz);
+        sko_stack = realloc(sko_stack,
+			sizeof(struct sko_state) * (size_t) sko_sz);
     }
     
     /* initialize to zero and push */
@@ -90,9 +91,7 @@ static void sko_pop(bool* dc)
 }
 
 /* Append "#define defname value\n" to the running buffer. */
-void action_define (defname, value)
-     const char *defname;
-     int value;
+void action_define (const char *defname, int value)
 {
 	char    buf[MAXLINE];
 	char   *cpy;
@@ -108,7 +107,7 @@ void action_define (defname, value)
 	add_action (buf);
 
 	/* track #defines so we can undef them when we're done. */
-	cpy = copy_string (defname);
+	cpy = xstrdup(defname);
 	buf_append (&defs_buf, &cpy, 1);
 }
 
@@ -137,10 +136,9 @@ static void action_m4_define (const char *defname, const char * value)
 #endif
 
 /* Append "new_text" to the running buffer. */
-void add_action (new_text)
-     const char   *new_text;
+void add_action (const char *new_text)
 {
-	int     len = strlen (new_text);
+	int     len = (int) strlen (new_text);
 
 	while (len + action_index >= action_size - 10 /* slop */ ) {
 		int     new_size = action_size * 2;
@@ -166,14 +164,12 @@ void add_action (new_text)
 
 /* allocate_array - allocate memory for an integer array of the given size */
 
-void   *allocate_array (size, element_size)
-     int size;
-     size_t element_size;
+void   *allocate_array (int size, size_t element_size)
 {
 	void *mem;
 	size_t  num_bytes = element_size * size;
 
-	mem = flex_alloc (num_bytes);
+	mem = malloc(num_bytes);
 	if (!mem)
 		flexfatal (_
 			   ("memory allocation failed in allocate_array()"));
@@ -184,11 +180,10 @@ void   *allocate_array (size, element_size)
 
 /* all_lower - true if a string is all lower-case */
 
-int all_lower (str)
-     char *str;
+int all_lower (char *str)
 {
 	while (*str) {
-		if (!isascii ((Char) * str) || !islower ((Char) * str))
+		if (!isascii ((unsigned char) * str) || !islower ((unsigned char) * str))
 			return 0;
 		++str;
 	}
@@ -199,11 +194,10 @@ int all_lower (str)
 
 /* all_upper - true if a string is all upper-case */
 
-int all_upper (str)
-     char *str;
+int all_upper (char *str)
 {
 	while (*str) {
-		if (!isascii ((Char) * str) || !isupper ((Char) * str))
+		if (!isascii ((unsigned char) * str) || !isupper ((unsigned char) * str))
 			return 0;
 		++str;
 	}
@@ -225,8 +219,7 @@ int intcmp (const void *a, const void *b)
  *		and exits.
  */
 
-void check_char (c)
-     int c;
+void check_char (int c)
 {
 	if (c >= CSIZE)
 		lerr (_("bad character '%s' detected in check_char()"),
@@ -242,57 +235,20 @@ void check_char (c)
 
 /* clower - replace upper-case letter to lower-case */
 
-Char clower (c)
-     int c;
+unsigned char clower (int c)
 {
-	return (Char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
+	return (unsigned char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
 }
 
 
-/* copy_string - returns a dynamically allocated copy of a string */
-
-char   *copy_string (str)
-     const char *str;
+char *xstrdup(const char *s)
 {
-	const char *c1;
-	char *c2;
-	char   *copy;
-	unsigned int size;
-
-	/* find length */
-	for (c1 = str; *c1; ++c1) ;
-
-	size = (c1 - str + 1) * sizeof (char);
-
-	copy = (char *) flex_alloc (size);
-
-	if (copy == NULL)
-		flexfatal (_("dynamic memory failure in copy_string()"));
+	char *s2;
 
-	for (c2 = copy; (*c2++ = *str++) != 0;) ;
+	if ((s2 = strdup(s)) == NULL)
+		flexfatal (_("memory allocation failure in xstrdup()"));
 
-	return copy;
-}
-
-
-/* copy_unsigned_string -
- *    returns a dynamically allocated copy of a (potentially) unsigned string
- */
-
-Char   *copy_unsigned_string (str)
-     Char *str;
-{
-	Char *c;
-	Char   *copy;
-
-	/* find length */
-	for (c = str; *c; ++c) ;
-
-	copy = allocate_Character_array (c - str + 1);
-
-	for (c = copy; (*c++ = *str++) != 0;) ;
-
-	return copy;
+	return s2;
 }
 
 
@@ -300,19 +256,19 @@ Char   *copy_unsigned_string (str)
 
 int cclcmp (const void *a, const void *b)
 {
-  if (!*(const Char *) a)
+  if (!*(const unsigned char *) a)
 	return 1;
   else
-	if (!*(const Char *) b)
+	if (!*(const unsigned char *) b)
 	  return - 1;
 	else
-	  return *(const Char *) a - *(const Char *) b;
+	  return *(const unsigned char *) a - *(const unsigned char *) b;
 }
 
 
 /* dataend - finish up a block of data declarations */
 
-void dataend ()
+void dataend (void)
 {
 	/* short circuit any output */
 	if (gentables) {
@@ -330,7 +286,7 @@ void dataend ()
 
 /* dataflush - flush generated data statements */
 
-void dataflush ()
+void dataflush (void)
 {
 	/* short circuit any output */
 	if (!gentables)
@@ -353,8 +309,7 @@ void dataflush ()
 
 /* flexerror - report an error message and terminate */
 
-void flexerror (msg)
-     const char *msg;
+void flexerror (const char *msg)
 {
 	fprintf (stderr, "%s: %s\n", program_name, msg);
 	flexend (1);
@@ -363,8 +318,7 @@ void flexerror (msg)
 
 /* flexfatal - report a fatal error message and terminate */
 
-void flexfatal (msg)
-     const char *msg;
+void flexfatal (const char *msg)
 {
 	fprintf (stderr, _("%s: fatal internal error, %s\n"),
 		 program_name, msg);
@@ -374,8 +328,7 @@ void flexfatal (msg)
 
 /* htoi - convert a hexadecimal digit string to an integer value */
 
-int htoi (str)
-     Char str[];
+int htoi (unsigned char str[])
 {
 	unsigned int result;
 
@@ -387,7 +340,8 @@ int htoi (str)
 
 /* lerr - report an error message */
 
-void lerr (const char *msg, ...) {
+void lerr (const char *msg, ...)
+{
 	char    errmsg[MAXLINE];
 	va_list args;
 
@@ -414,9 +368,7 @@ void lerr_fatal (const char *msg, ...)
 
 /* line_directive_out - spit out a "#line" statement */
 
-void line_directive_out (output_file, do_infile)
-     FILE   *output_file;
-     int do_infile;
+void line_directive_out (FILE *output_file, int do_infile)
 {
 	char    directive[MAXLINE], filename[MAXLINE];
 	char   *s1, *s2, *s3;
@@ -464,7 +416,7 @@ void line_directive_out (output_file, do_infile)
  *               representing where the user's section 1 definitions end
  *		 and the prolog begins
  */
-void mark_defs1 ()
+void mark_defs1 (void)
 {
 	defs1_offset = 0;
 	action_array[action_index++] = '\0';
@@ -476,7 +428,7 @@ void mark_defs1 ()
 /* mark_prolog - mark the current position in the action array as
  *               representing the end of the action prolog
  */
-void mark_prolog ()
+void mark_prolog (void)
 {
 	action_array[action_index++] = '\0';
 	action_offset = action_index;
@@ -488,8 +440,7 @@ void mark_prolog ()
  *
  * Generates a data statement initializing the current 2-D array to "value".
  */
-void mk2data (value)
-     int value;
+void mk2data (int value)
 {
 	/* short circuit any output */
 	if (!gentables)
@@ -518,8 +469,7 @@ void mk2data (value)
  * Generates a data statement initializing the current array element to
  * "value".
  */
-void mkdata (value)
-     int value;
+void mkdata (int value)
 {
 	/* short circuit any output */
 	if (!gentables)
@@ -544,8 +494,7 @@ void mkdata (value)
 
 /* myctoi - return the integer represented by a string of digits */
 
-int myctoi (array)
-     const char *array;
+int myctoi (const char *array)
 {
 	int     val = 0;
 
@@ -557,10 +506,9 @@ int myctoi (array)
 
 /* myesc - return character corresponding to escape sequence */
 
-Char myesc (array)
-     Char array[];
+unsigned char myesc (unsigned char array[])
 {
-	Char    c, esc_char;
+	unsigned char    c, esc_char;
 
 	switch (array[1]) {
 	case 'b':
@@ -573,19 +521,10 @@ Char myesc (array)
 		return '\r';
 	case 't':
 		return '\t';
-
-#if defined (__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':
@@ -645,8 +584,7 @@ Char myesc (array)
 
 /* otoi - convert an octal digit string to an integer value */
 
-int otoi (str)
-     Char str[];
+int otoi (unsigned char str[])
 {
 	unsigned int result;
 
@@ -659,60 +597,47 @@ int otoi (str)
  *	 generated scanner, keeping track of the line count.
  */
 
-void out (str)
-     const char *str;
+void out (const char *str)
 {
 	fputs (str, stdout);
 }
 
-void out_dec (fmt, n)
-     const char *fmt;
-     int n;
+void out_dec (const char *fmt, int n)
 {
 	fprintf (stdout, fmt, n);
 }
 
-void out_dec2 (fmt, n1, n2)
-     const char *fmt;
-     int n1, n2;
+void out_dec2 (const char *fmt, int n1, int n2)
 {
 	fprintf (stdout, fmt, n1, n2);
 }
 
-void out_hex (fmt, x)
-     const char *fmt;
-     unsigned int x;
+void out_hex (const char *fmt, unsigned int x)
 {
 	fprintf (stdout, fmt, x);
 }
 
-void out_str (fmt, str)
-     const char *fmt, str[];
+void out_str (const char *fmt, const char str[])
 {
 	fprintf (stdout,fmt, str);
 }
 
-void out_str3 (fmt, s1, s2, s3)
-     const char *fmt, s1[], s2[], s3[];
+void out_str3 (const char *fmt, const char s1[], const char s2[], const char s3[])
 {
 	fprintf (stdout,fmt, s1, s2, s3);
 }
 
-void out_str_dec (fmt, str, n)
-     const char *fmt, str[];
-     int n;
+void out_str_dec (const char *fmt, const char str[], int n)
 {
 	fprintf (stdout,fmt, str, n);
 }
 
-void outc (c)
-     int c;
+void outc (int c)
 {
 	fputc (c, stdout);
 }
 
-void outn (str)
-     const char *str;
+void outn (const char *str)
 {
 	fputs (str,stdout);
     fputc('\n',stdout);
@@ -734,8 +659,7 @@ void out_m4_define (const char* def, const char* val)
  * The returned string is in static storage.
  */
 
-char   *readable_form (c)
-     int c;
+char   *readable_form (int c)
 {
 	static char rform[20];
 
@@ -751,14 +675,10 @@ char   *readable_form (c)
 			return "\\r";
 		case '\t':
 			return "\\t";
-
-#if defined (__STDC__)
 		case '\a':
 			return "\\a";
 		case '\v':
 			return "\\v";
-#endif
-
 		default:
 			if(trace_hex)
 				snprintf (rform, sizeof(rform), "\\x%.2x", (unsigned int) c);
@@ -782,15 +702,12 @@ char   *readable_form (c)
 
 /* reallocate_array - increase the size of a dynamic array */
 
-void   *reallocate_array (array, size, element_size)
-     void   *array;
-     int size;
-     size_t element_size;
+void   *reallocate_array (void *array, int size, size_t element_size)
 {
 	void *new_array;
 	size_t  num_bytes = element_size * size;
 
-	new_array = flex_realloc (array, num_bytes);
+	new_array = realloc(array, num_bytes);
 	if (!new_array)
 		flexfatal (_("attempt to increase array size failed"));
 
@@ -804,7 +721,7 @@ void   *reallocate_array (array, size, element_size)
  *    Copies skelfile or skel array to stdout until a line beginning with
  *    "%%" or EOF is found.
  */
-void skelout ()
+void skelout (void)
 {
 	char    buf_storage[MAXLINE];
 	char   *buf = buf_storage;
@@ -935,8 +852,7 @@ void skelout ()
  * element_n.  Formats the output with spaces and carriage returns.
  */
 
-void transition_struct_out (element_v, element_n)
-     int element_v, element_n;
+void transition_struct_out (int element_v, int element_n)
 {
 
 	/* short circuit any output */
@@ -960,12 +876,14 @@ void transition_struct_out (element_v, element_n)
 
 /* The following is only needed when building flex's parser using certain
  * broken versions of bison.
+ *
+ * XXX: this is should go soon
  */
-void   *yy_flex_xmalloc (size)
-     int size;
+void   *yy_flex_xmalloc (int size)
 {
-	void   *result = flex_alloc ((size_t) size);
+	void   *result;
 
+	result = malloc((size_t) size);
 	if (!result)
 		flexfatal (_
 			   ("memory allocation failed in yy_flex_xmalloc()"));
@@ -974,29 +892,10 @@ void   *yy_flex_xmalloc (size)
 }
 
 
-/* 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;
-     size_t size_in_bytes;
-{
-	char *rp, *rp_end;
-
-	rp = region_ptr;
-	rp_end = region_ptr + size_in_bytes;
-
-	while (rp < rp_end)
-		*rp++ = 0;
-}
-
 /* Remove all '\n' and '\r' characters, if any, from the end of str.
  * str can be any null-terminated string, or NULL.
  * returns str. */
-char   *chomp (str)
-     char   *str;
+char   *chomp (char *str)
 {
 	char   *p = str;
 
diff --git a/src/nfa.c b/src/nfa.c
index ee06578..816c356 100644
--- a/src/nfa.c
+++ b/src/nfa.c
@@ -36,8 +36,8 @@
 
 /* declare functions that have forward references */
 
-int dupmachine PROTO ((int));
-void mkxtion PROTO ((int, int));
+int	dupmachine(int);
+void	mkxtion(int, int);
 
 
 /* add_accept - add an accepting state to a machine
@@ -45,8 +45,7 @@ void mkxtion PROTO ((int, int));
  * accepting_number becomes mach's accepting number.
  */
 
-void    add_accept (mach, accepting_number)
-     int     mach, accepting_number;
+void    add_accept (int mach, int 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
@@ -77,8 +76,7 @@ void    add_accept (mach, accepting_number)
  *     num    - the number of copies of singl to be present in newsng
  */
 
-int     copysingl (singl, num)
-     int     singl, num;
+int     copysingl (int singl, int num)
 {
 	int     copy, i;
 
@@ -93,9 +91,7 @@ int     copysingl (singl, num)
 
 /* dumpnfa - debugging routine to write out an nfa */
 
-void    dumpnfa (state1)
-     int     state1;
-
+void    dumpnfa (int state1)
 {
 	int     sym, tsp1, tsp2, anum, ns;
 
@@ -148,8 +144,7 @@ void    dumpnfa (state1)
  * states accessible by the arrays firstst and lastst
  */
 
-int     dupmachine (mach)
-     int     mach;
+int     dupmachine (int mach)
 {
 	int     i, init, state_offset;
 	int     state = 0;
@@ -196,9 +191,8 @@ int     dupmachine (mach)
  * context has variable length.
  */
 
-void    finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
-		     pcont_act)
-     int     mach, variable_trail_rule, headcnt, trailcnt, pcont_act;
+void    finish_rule (int mach, int variable_trail_rule, int headcnt, int trailcnt,
+		     int pcont_act)
 {
 	char    action_text[MAXLINE];
 
@@ -292,7 +286,7 @@ void    finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
 	if (!continued_action)
 		add_action ("YY_RULE_SETUP\n");
 
-	line_directive_out ((FILE *) 0, 1);
+	line_directive_out(NULL, 1);
 }
 
 
@@ -312,8 +306,7 @@ void    finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
  *  FIRST is set to new by the operation.  last is unmolested.
  */
 
-int     link_machines (first, last)
-     int     first, last;
+int     link_machines (int first, int last)
 {
 	if (first == NIL)
 		return last;
@@ -339,8 +332,7 @@ int     link_machines (first, last)
  * The "beginning" states are the epsilon closure of the first state
  */
 
-void    mark_beginning_as_normal (mach)
-     int mach;
+void    mark_beginning_as_normal (int mach)
 {
 	switch (state_type[mach]) {
 	case STATE_NORMAL:
@@ -381,8 +373,7 @@ void    mark_beginning_as_normal (mach)
  * more mkbranch's.  Compare with mkor()
  */
 
-int     mkbranch (first, second)
-     int     first, second;
+int     mkbranch (int first, int second)
 {
 	int     eps;
 
@@ -409,8 +400,7 @@ int     mkbranch (first, second)
  * new - a new state which matches the closure of "state"
  */
 
-int     mkclos (state)
-     int     state;
+int     mkclos (int state)
 {
 	return mkopt (mkposcl (state));
 }
@@ -430,8 +420,7 @@ int     mkclos (state)
  *     2. mach is destroyed by the call
  */
 
-int     mkopt (mach)
-     int     mach;
+int     mkopt (int mach)
 {
 	int     eps;
 
@@ -467,8 +456,7 @@ int     mkopt (mach)
  * the number of epsilon states needed
  */
 
-int     mkor (first, second)
-     int     first, second;
+int     mkor (int first, int second)
 {
 	int     eps, orend;
 
@@ -523,8 +511,7 @@ int     mkor (first, second)
  *    new - a machine matching the positive closure of "state"
  */
 
-int     mkposcl (state)
-     int     state;
+int     mkposcl (int state)
 {
 	int     eps;
 
@@ -553,8 +540,7 @@ int     mkposcl (state)
  *   if "ub" is INFINITE_REPEAT then "new" matches "lb" or more occurrences of "mach"
  */
 
-int     mkrep (mach, lb, ub)
-     int     mach, lb, ub;
+int     mkrep (int mach, int lb, int ub)
 {
 	int     base_mach, tail, copy, i;
 
@@ -600,8 +586,7 @@ int     mkrep (mach, lb, ub)
  * that it admittedly is)
  */
 
-int     mkstate (sym)
-     int     sym;
+int     mkstate (int sym)
 {
 	if (++lastnfa >= current_mns) {
 		if ((current_mns += MNS_INCREMENT) >= maximum_mns)
@@ -677,8 +662,7 @@ current_mns);
  *     stateto   - the state to which the transition is to be made
  */
 
-void    mkxtion (statefrom, stateto)
-     int     statefrom, stateto;
+void    mkxtion (int statefrom, int stateto)
 {
 	if (trans1[statefrom] == NO_TRANSITION)
 		trans1[statefrom] = stateto;
@@ -695,7 +679,7 @@ void    mkxtion (statefrom, stateto)
 
 /* new_rule - initialize for a new rule */
 
-void    new_rule ()
+void    new_rule (void)
 {
 	if (++num_rules >= current_max_rules) {
 		++num_reallocs;
diff --git a/src/parse.y b/src/parse.y
index 939cc05..908361b 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -1,8 +1,8 @@
 /* parse.y - parser for flex input */
 
 %token CHAR NUMBER SECTEND SCDECL XSCDECL NAME PREVCCL EOF_OP
-%token OPTION_OP OPT_OUTFILE OPT_PREFIX OPT_YYCLASS OPT_HEADER OPT_EXTRA_TYPE
-%token OPT_TABLES
+%token TOK_OPTION TOK_OUTFILE TOK_PREFIX TOK_YYCLASS TOK_HEADER_FILE TOK_EXTRA_TYPE
+%token TOK_TABLES_FILE
 
 %token CCE_ALNUM CCE_ALPHA CCE_BLANK CCE_CNTRL CCE_DIGIT CCE_GRAPH
 %token CCE_LOWER CCE_PRINT CCE_PUNCT CCE_SPACE CCE_UPPER CCE_XDIGIT
@@ -184,28 +184,28 @@ namelist1	:  namelist1 NAME
 			{ synerr( _("bad start condition list") ); }
 		;
 
-options		:  OPTION_OP optionlist
+options		:  TOK_OPTION optionlist
 		;
 
 optionlist	:  optionlist option
 		|
 		;
 
-option		:  OPT_OUTFILE '=' NAME
+option		:  TOK_OUTFILE '=' NAME
 			{
-			outfilename = copy_string( nmstr );
+			outfilename = xstrdup(nmstr);
 			did_outfilename = 1;
 			}
-		|  OPT_EXTRA_TYPE '=' NAME
-			{ extra_type = copy_string( nmstr ); }
-		|  OPT_PREFIX '=' NAME
-			{ prefix = copy_string( nmstr ); }
-		|  OPT_YYCLASS '=' NAME
-			{ yyclass = copy_string( nmstr ); }
-		|  OPT_HEADER '=' NAME
-			{ headerfilename = copy_string( nmstr ); }
-	    |  OPT_TABLES '=' NAME
-            { tablesext = true; tablesfilename = copy_string( nmstr ); }
+		|  TOK_EXTRA_TYPE '=' NAME
+			{ extra_type = xstrdup(nmstr); }
+		|  TOK_PREFIX '=' NAME
+			{ prefix = xstrdup(nmstr); }
+		|  TOK_YYCLASS '=' NAME
+			{ yyclass = xstrdup(nmstr); }
+		|  TOK_HEADER_FILE '=' NAME
+			{ headerfilename = xstrdup(nmstr); }
+	    |  TOK_TABLES_FILE '=' NAME
+            { tablesext = true; tablesfilename = xstrdup(nmstr); }
 		;
 
 sect2		:  sect2 scon initforrule flexrule '\n'
@@ -725,7 +725,7 @@ singleton	:  singleton '*'
 			{
 				/* Sort characters for fast searching.
 				 */
-				qsort( ccltbl + cclmap[$1], ccllen[$1], sizeof (*ccltbl), cclcmp );
+				qsort( ccltbl + cclmap[$1], (size_t) ccllen[$1], sizeof (*ccltbl), cclcmp );
 
 			if ( useecs )
 				mkeccl( ccltbl + cclmap[$1], ccllen[$1],
@@ -951,7 +951,7 @@ string		:  string CHAR
  *                    conditions
  */
 
-void build_eof_action()
+void build_eof_action(void)
 	{
 	int i;
 	char action_text[MAXLINE];
@@ -976,7 +976,7 @@ void build_eof_action()
 			}
 		}
 
-	line_directive_out( (FILE *) 0, 1 );
+	line_directive_out(NULL, 1);
 
 	/* 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
@@ -990,8 +990,7 @@ void build_eof_action()
 
 /* format_synerr - write out formatted syntax error */
 
-void format_synerr( msg, arg )
-const char *msg, arg[];
+void format_synerr( const char *msg, const char arg[] )
 	{
 	char errmsg[MAXLINE];
 
@@ -1002,8 +1001,7 @@ const char *msg, arg[];
 
 /* synerr - report a syntax error */
 
-void synerr( str )
-const char *str;
+void synerr( const char *str )
 	{
 	syntaxerror = true;
 	pinpoint_message( str );
@@ -1012,8 +1010,7 @@ const char *str;
 
 /* format_warn - write out formatted warning */
 
-void format_warn( msg, arg )
-const char *msg, arg[];
+void format_warn( const char *msg, const char arg[] )
 	{
 	char warn_msg[MAXLINE];
 
@@ -1024,8 +1021,7 @@ const char *msg, arg[];
 
 /* warn - report a warning, unless -w was given */
 
-void warn( str )
-const char *str;
+void warn( const char *str )
 	{
 	line_warning( str, linenum );
 	}
@@ -1034,8 +1030,7 @@ const char *str;
  *			     pinpointing its location
  */
 
-void format_pinpoint_message( msg, arg )
-const char *msg, arg[];
+void format_pinpoint_message( const char *msg, const char arg[] )
 	{
 	char errmsg[MAXLINE];
 
@@ -1046,8 +1041,7 @@ const char *msg, arg[];
 
 /* pinpoint_message - write out a message, pinpointing its location */
 
-void pinpoint_message( str )
-const char *str;
+void pinpoint_message( const char *str )
 	{
 	line_pinpoint( str, linenum );
 	}
@@ -1055,9 +1049,7 @@ const char *str;
 
 /* line_warning - report a warning at a given line, unless -w was given */
 
-void line_warning( str, line )
-const char *str;
-int line;
+void line_warning( const char *str, int line )
 	{
 	char warning[MAXLINE];
 
@@ -1071,9 +1063,7 @@ int line;
 
 /* line_pinpoint - write out a message, pinpointing it at the given line */
 
-void line_pinpoint( str, line )
-const char *str;
-int line;
+void line_pinpoint( const char *str, int line )
 	{
 	fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
 	}
@@ -1083,8 +1073,7 @@ int line;
  *	     currently, messages are ignore
  */
 
-void yyerror( msg )
-const char *msg;
+void yyerror( const char *msg )
 	{
 		(void)msg;
 	}
diff --git a/src/regex.c b/src/regex.c
index 2bb580e..84f0e9e 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -57,10 +57,10 @@ void flex_regcomp(regex_t *preg, const char *regex, int cflags)
         const int errbuf_sz = 200;
         char *errbuf, *rxerr;
 
-		errbuf = (char*)flex_alloc(errbuf_sz *sizeof(char));
+		errbuf = malloc(errbuf_sz * sizeof(char));
 		if (!errbuf)
 			flexfatal(_("Unable to allocate buffer to report regcomp"));
-		rxerr = (char*)flex_alloc(errbuf_sz *sizeof(char));
+		rxerr = malloc(errbuf_sz * sizeof(char));
 		if (!rxerr)
 			flexfatal(_("Unable to allocate buffer for regerror"));
 		regerror (err, preg, rxerr, errbuf_sz);
@@ -85,7 +85,7 @@ char   *regmatch_dup (regmatch_t * m, const char *src)
 	if (m == NULL || m->rm_so < 0)
 		return NULL;
 	len = m->rm_eo - m->rm_so;
-	str = (char *) flex_alloc ((len + 1) * sizeof (char));
+	str = malloc((len + 1) * sizeof(char));
 	if (!str)
 		flexfatal(_("Unable to allocate a copy of the match"));
 	strncpy (str, src + m->rm_so, len);
diff --git a/src/scan.l b/src/scan.l
index 9eb857a..cfc832d 100644
--- a/src/scan.l
+++ b/src/scan.l
@@ -59,7 +59,7 @@ extern const char *escaped_qstart, *escaped_qend;
 #define MARK_END_OF_PROLOG mark_prolog();
 
 #define YY_DECL \
-	int flexscan()
+	int flexscan(void)
 
 #define RETURNCHAR \
 	yylval = (unsigned char) yytext[0]; \
@@ -135,7 +135,7 @@ M4QEND      "]]"
 
 	int doing_codeblock = false;
 	int i, brace_depth=0, brace_start_line=0;
-	Char nmdef[MAXLINE];
+	char nmdef[MAXLINE];
 
 
 <INITIAL>{
@@ -146,7 +146,7 @@ M4QEND      "]]"
 	^"%x"{NAME}?	return XSCDECL;
 	^"%{".*{NL}	{
 			++linenum;
-			line_directive_out( (FILE *) 0, 1 );
+			line_directive_out(NULL, 1);
 			indented_code = false;
 			BEGIN(CODEBLOCK);
 			}
@@ -166,7 +166,7 @@ M4QEND      "]]"
 			sectnum = 2;
 			bracelevel = 0;
 			mark_defs1();
-			line_directive_out( (FILE *) 0, 1 );
+			line_directive_out(NULL, 1);
 			BEGIN(SECT2PROLOG);
 			return SECTEND;
 			}
@@ -174,7 +174,7 @@ M4QEND      "]]"
 	^"%pointer".*{NL}	yytext_is_array = false; ++linenum;
 	^"%array".*{NL}		yytext_is_array = true; ++linenum;
 
-	^"%option"	BEGIN(OPTION); return OPTION_OP;
+	^"%option"	BEGIN(OPTION); return TOK_OPTION;
 
 	^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL}	++linenum; /* ignore */
 	^"%"{LEXOPT}{WS}.*{NL}	++linenum;	/* ignore */
@@ -231,8 +231,8 @@ M4QEND      "]]"
 	[[:digit:]]+	linenum = myctoi( yytext );
 
 	\"[^"\n]*\"	{
-			flex_free( (void *) infilename );
-			infilename = copy_string( yytext + 1 );
+			free(infilename);
+			infilename = xstrdup(yytext + 1);
 			infilename[strlen( infilename ) - 1] = '\0';
 			}
 	.		/* ignore spurious characters */
@@ -272,8 +272,8 @@ M4QEND      "]]"
                 buf_strnappend(&top_buf, yytext, yyleng);
             }
 
-    {M4QSTART}  buf_strnappend(&top_buf, escaped_qstart, strlen(escaped_qstart));
-    {M4QEND}    buf_strnappend(&top_buf, escaped_qend, strlen(escaped_qend));
+    {M4QSTART}  buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart));
+    {M4QEND}    buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend));
 
     [^{}\r\n]  {
                 buf_strnappend(&top_buf, yytext, yyleng);
@@ -293,7 +293,7 @@ M4QEND      "]]"
 	{NOT_WS}[^\r\n]*	{
  		        if(yyleng < MAXLINE)
  		         {
-			strcpy( (char *) nmdef, yytext );
+			strcpy( nmdef, yytext );
  		         }
  		        else
  		         {
@@ -301,7 +301,7 @@ M4QEND      "]]"
  		           FLEX_EXIT(EXIT_FAILURE);
 			 }
 			/* Skip trailing whitespace. */
-			for ( i = strlen( (char *) nmdef ) - 1;
+			for ( i = strlen( nmdef ) - 1;
 			      i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
 			      --i )
 				;
@@ -364,6 +364,7 @@ M4QEND      "]]"
 	interactive	interactive = option_sense;
 	lex-compat	lex_compat = option_sense;
 	posix-compat	posix_compat = option_sense;
+	line		gen_line_dirs = option_sense;
 	main		{
 			ACTION_M4_IFDEF( "M4""_YY_MAIN", option_sense);
             /* Override yywrap */
@@ -420,12 +421,12 @@ M4QEND      "]]"
     yyget_lloc      ACTION_M4_IFDEF("M4""_YY_NO_GET_LLOC", ! option_sense);
     yyset_lloc      ACTION_M4_IFDEF("M4""_YY_NO_SET_LLOC", ! option_sense);
 
-	extra-type	return OPT_EXTRA_TYPE;
-	outfile		return OPT_OUTFILE;
-	prefix		return OPT_PREFIX;
-	yyclass		return OPT_YYCLASS;
-	header(-file)?      return OPT_HEADER;
-	tables-file         return OPT_TABLES;
+	extra-type	return TOK_EXTRA_TYPE;
+	outfile		return TOK_OUTFILE;
+	prefix		return TOK_PREFIX;
+	yyclass		return TOK_YYCLASS;
+	header(-file)?      return TOK_HEADER_FILE;
+	tables-file         return TOK_TABLES_FILE;
 	tables-verify   {
                     tablesverify = option_sense;
                     if(!tablesext && option_sense)
@@ -527,8 +528,7 @@ M4QEND      "]]"
                         if (sf_skip_ws()){
                             /* We're in the middle of a (?x: ) pattern. */
                             /* Push back everything starting at the "|" */
-                            size_t amt;
-                            amt = strchr (yytext, '|') - yytext;
+                            int amt = (int) (strchr (yytext, '|') - yytext);
                             yyless(amt);
                         }
                         else {
@@ -627,7 +627,7 @@ M4QEND      "]]"
                    * The reason it was disabled is so yacc/bison can parse
                    * ccl operations, such as ccl difference and union.
                    */
-                &&  (cclval = ccllookup( (Char *) nmstr )) != 0 )
+                &&  (cclval = ccllookup( nmstr )) != 0 )
 				{
 				if ( input() != ']' )
 					synerr( _( "bad character class" ) );
@@ -641,7 +641,7 @@ M4QEND      "]]"
 				/* We fudge a bit.  We know that this ccl will
 				 * soon be numbered as lastccl + 1 by cclinit.
 				 */
-				cclinstal( (Char *) nmstr, lastccl + 1 );
+				cclinstal( nmstr, lastccl + 1 );
 
 				/* Push back everything but the leading bracket
 				 * so the ccl can be rescanned.
@@ -661,7 +661,7 @@ M4QEND      "]]"
      * context.
      */
 	"{"{NAME}"}"[[:space:]]?	 {
-			Char *nmdefptr;
+			char *nmdefptr;
             int end_is_ws, end_ch;
 
             end_ch = yytext[yyleng-1];
@@ -685,7 +685,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 
 			else
 				{ /* push back name surrounded by ()'s */
-				int len = strlen( (char *) nmdefptr );
+				int len = strlen( nmdefptr );
                 if (end_is_ws)
                     unput(end_ch);
 
@@ -693,7 +693,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 				     (len > 0 && nmdefptr[len - 1] == '$')
                      || (end_is_ws && trlcontxt && !sf_skip_ws()))
 					{ /* don't use ()'s after all */
-					PUT_BACK_STRING((char *) nmdefptr, 0);
+					PUT_BACK_STRING(nmdefptr, 0);
 
 					if ( nmdefptr[0] == '^' )
 						BEGIN(CARETISBOL);
@@ -702,7 +702,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 				else
 					{
 					unput(')');
-					PUT_BACK_STRING((char *) nmdefptr, 0);
+					PUT_BACK_STRING(nmdefptr, 0);
 					unput('(');
 					}
 				}
@@ -738,7 +738,13 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
                     return '(';
                 }
     "("         sf_push(); return '(';
-    ")"         sf_pop(); return ')';
+    ")"         {
+                    if (_sf_top_ix > 0) {
+                        sf_pop();
+                        return ')';
+                    } else
+                        synerr(_("unbalanced parenthesis"));
+                }
 
 	[/|*+?.(){}]	return (unsigned char) yytext[0];
 	.		RETURNCHAR;
@@ -947,7 +953,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 			}
 
 <SECT2,QUOTE,FIRSTCCL,CCL>{ESCSEQ}	{
-			yylval = myesc( (Char *) yytext );
+			yylval = myesc( (unsigned char *) yytext );
 
 			if ( YY_START == FIRSTCCL )
 				BEGIN(CCL);
@@ -969,7 +975,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 %%
 
 
-int yywrap()
+int yywrap(void)
 	{
 	if ( --num_input_files > 0 )
 		{
@@ -984,12 +990,11 @@ int yywrap()
 
 /* set_input_file - open the given file (if NULL, stdin) for scanning */
 
-void set_input_file( file )
-char *file;
+void set_input_file( char *file )
 	{
 	if ( file && strcmp( file, "-" ) )
 		{
-		infilename = copy_string( file );
+		infilename = xstrdup(file);
 		yyin = fopen( infilename, "r" );
 
 		if ( yyin == NULL )
@@ -999,31 +1004,8 @@ char *file;
 	else
 		{
 		yyin = stdin;
-		infilename = copy_string( "<stdin>" );
+		infilename = xstrdup("<stdin>");
 		}
 
 	linenum = 1;
 	}
-
-
-/* Wrapper routines for accessing the scanner's malloc routines. */
-
-void *flex_alloc( size )
-size_t size;
-	{
-	return (void *) malloc( size );
-	}
-
-void *flex_realloc( ptr, size )
-void *ptr;
-size_t size;
-	{
-	return (void *) realloc( ptr, size );
-	}
-
-void flex_free( ptr )
-void *ptr;
-	{
-	if ( ptr )
-		free( ptr );
-	}
diff --git a/src/scanflags.c b/src/scanflags.c
index 5beb24a..aa3de8a 100644
--- a/src/scanflags.c
+++ b/src/scanflags.c
@@ -40,7 +40,8 @@ void
 sf_push (void)
 {
     if (_sf_top_ix + 1 >= _sf_max)
-        _sf_stk = (scanflags_t*) flex_realloc ( (void*) _sf_stk, sizeof(scanflags_t) * (_sf_max += 32));
+        _sf_max += 32;
+        _sf_stk = realloc(_sf_stk, sizeof(scanflags_t) * _sf_max);
 
     // copy the top element
     _sf_stk[_sf_top_ix + 1] = _sf_stk[_sf_top_ix];
@@ -59,7 +60,8 @@ void
 sf_init (void)
 {
     assert(_sf_stk == NULL);
-    _sf_stk = (scanflags_t*) flex_alloc ( sizeof(scanflags_t) * (_sf_max = 32));
+    _sf_max = 32;
+    _sf_stk = malloc(sizeof(scanflags_t) * _sf_max);
     if (!_sf_stk)
         lerr_fatal(_("Unable to allocate %zu of stack"), sizeof(scanflags_t));
     _sf_stk[_sf_top_ix] = 0;
diff --git a/src/scanopt.c b/src/scanopt.c
index 10c372a..a118541 100644
--- a/src/scanopt.c
+++ b/src/scanopt.c
@@ -37,20 +37,6 @@
 
 /* Internal structures */
 
-#ifdef HAVE_STRCASECMP
-#define STRCASECMP(a,b) strcasecmp(a,b)
-#else
-static int STRCASECMP PROTO ((const char *, const char *));
-
-static int STRCASECMP (a, b)
-     const char *a;
-     const char *b;
-{
-	while (tolower ((unsigned char)*a++) == tolower ((unsigned char)*b++)) ;
-	return b - a;
-}
-#endif
-
 #define ARG_NONE 0x01
 #define ARG_REQ  0x02
 #define ARG_OPT  0x04
@@ -77,56 +63,45 @@ struct _scanopt_t {
 };
 
 /* Accessor functions. These WOULD be one-liners, but portability calls. */
-static const char *NAME PROTO ((struct _scanopt_t *, int));
-static int PRINTLEN PROTO ((struct _scanopt_t *, int));
-static int RVAL PROTO ((struct _scanopt_t *, int));
-static int FLAGS PROTO ((struct _scanopt_t *, int));
-static const char *DESC PROTO ((struct _scanopt_t *, int));
-static int scanopt_err PROTO ((struct _scanopt_t *, int, int));
-static int matchlongopt PROTO ((char *, char **, int *, char **, int *));
-static int find_opt
-PROTO ((struct _scanopt_t *, int, char *, int, int *, int *opt_offset));
-
-static const char *NAME (s, i)
-     struct _scanopt_t *s;
-     int     i;
+static const char *NAME(struct _scanopt_t *, int);
+static int PRINTLEN(struct _scanopt_t *, int);
+static int RVAL(struct _scanopt_t *, int);
+static int FLAGS(struct _scanopt_t *, int);
+static const char *DESC(struct _scanopt_t *, int);
+static int scanopt_err(struct _scanopt_t *, int, int);
+static int matchlongopt(char *, char **, int *, char **, int *);
+static int find_opt(struct _scanopt_t *, int, char *, int, int *, int *opt_offset);
+
+static const char *NAME (struct _scanopt_t *s, int i)
 {
 	return s->options[i].opt_fmt +
 		((s->aux[i].flags & IS_LONG) ? 2 : 1);
 }
 
-static int PRINTLEN (s, i)
-     struct _scanopt_t *s;
-     int     i;
+static int PRINTLEN (struct _scanopt_t *s, int i)
 {
 	return s->aux[i].printlen;
 }
 
-static int RVAL (s, i)
-     struct _scanopt_t *s;
-     int     i;
+static int RVAL (struct _scanopt_t *s, int i)
 {
 	return s->options[i].r_val;
 }
 
-static int FLAGS (s, i)
-     struct _scanopt_t *s;
-     int     i;
+static int FLAGS (struct _scanopt_t *s, int i)
 {
 	return s->aux[i].flags;
 }
 
-static const char *DESC (s, i)
-     struct _scanopt_t *s;
-     int     i;
+static const char *DESC (struct _scanopt_t *s, int i)
 {
 	return s->options[i].desc ? s->options[i].desc : "";
 }
 
 #ifndef NO_SCANOPT_USAGE
-static int get_cols PROTO ((void));
+static int get_cols (void);
 
-static int get_cols ()
+static int get_cols (void)
 {
 	char   *env;
 	int     cols = 80;	/* default */
@@ -159,15 +134,11 @@ static int get_cols ()
        (s)->subscript= 0;  \
     }while(0)
 
-scanopt_t *scanopt_init (options, argc, argv, flags)
-     const optspec_t *options;
-     int     argc;
-     char  **argv;
-     int     flags;
+scanopt_t *scanopt_init (const optspec_t *options, int argc, char **argv, int flags)
 {
 	int     i;
 	struct _scanopt_t *s;
-	s = (struct _scanopt_t *) malloc (sizeof (struct _scanopt_t));
+	s = malloc(sizeof (struct _scanopt_t));
 
 	s->options = options;
 	s->optc = 0;
@@ -186,10 +157,10 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
 		s->optc++;
 
 	/* Build auxiliary data */
-	s->aux = (struct _aux *) malloc (s->optc * sizeof (struct _aux));
+	s->aux = malloc((size_t) s->optc * sizeof (struct _aux));
 
 	for (i = 0; i < s->optc; i++) {
-		const Char *p, *pname;
+		const unsigned char *p, *pname;
 		const struct optspec_t *opt;
 		struct _aux *aux;
 
@@ -200,14 +171,14 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
 
 		if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') {
 			aux->flags |= IS_LONG;
-			pname = (const Char *)(opt->opt_fmt + 2);
+			pname = (const unsigned char *)(opt->opt_fmt + 2);
 			s->has_long = 1;
 		}
 		else {
-			pname = (const Char *)(opt->opt_fmt + 1);
+			pname = (const unsigned char *)(opt->opt_fmt + 1);
 			s->has_short = 1;
 		}
-		aux->printlen = strlen (opt->opt_fmt);
+		aux->printlen = (int) strlen (opt->opt_fmt);
 
 		aux->namelen = 0;
 		for (p = pname + 1; *p; p++) {
@@ -255,10 +226,7 @@ typedef struct usg_elem usg_elem;
 [indent][option, alias1, alias2...][indent][description line1
                                             description line2...]
  */
-int     scanopt_usage (scanner, fp, usage)
-     scanopt_t *scanner;
-     FILE   *fp;
-     const char *usage;
+int     scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
 {
 	struct _scanopt_t *s;
 	int     i, columns, indent = 2;
@@ -293,7 +261,7 @@ int     scanopt_usage (scanner, fp, usage)
 	fprintf (fp, "\n");
 
 	/* Sort by r_val and string. Yes, this is O(n*n), but n is small. */
-	store = (usg_elem *) malloc (s->optc * sizeof (usg_elem));
+	store = malloc((size_t) s->optc * sizeof (usg_elem));
 	for (i = 0; i < s->optc; i++) {
 
 		/* grab the next preallocate node. */
@@ -319,7 +287,7 @@ int     scanopt_usage (scanner, fp, usage)
 				}
 				if (!ptr_if_no_alias
 				    &&
-				    STRCASECMP (NAME (s, (*ue_curr)->idx),
+				    strcasecmp (NAME (s, (*ue_curr)->idx),
 						NAME (s, ue->idx)) > 0) {
 					ptr_if_no_alias = ue_curr;
 				}
@@ -391,7 +359,7 @@ int     scanopt_usage (scanner, fp, usage)
 			maxlen[0] = len;
 
 		/* It's much easier to calculate length for description column! */
-		len = strlen (DESC (s, ue->idx));
+		len = (int) strlen (DESC (s, ue->idx));
 		if (len > maxlen[1])
 			maxlen[1] = len;
 	}
@@ -529,10 +497,7 @@ int     scanopt_usage (scanner, fp, usage)
 #endif /* no scanopt_usage */
 
 
-static int scanopt_err (s, is_short, err)
-     struct _scanopt_t *s;
-     int     is_short;
-     int     err;
+static int scanopt_err (struct _scanopt_t *s, int is_short, int err)
 {
 	const char *optname = "";
 	char    optchar[2];
@@ -587,16 +552,11 @@ static int scanopt_err (s, is_short, err)
  * optname will point to str + 2
  *
  */
-static int matchlongopt (str, optname, optlen, arg, arglen)
-     char   *str;
-     char  **optname;
-     int    *optlen;
-     char  **arg;
-     int    *arglen;
+static int matchlongopt (char *str, char **optname, int *optlen, char **arg, int *arglen)
 {
 	char   *p;
 
-	*optname = *arg = (char *) 0;
+	*optname = *arg = NULL;
 	*optlen = *arglen = 0;
 
 	/* Match regex /--./   */
@@ -605,7 +565,7 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
 		return 0;
 
 	p += 2;
-	*optname = (char *) p;
+	*optname = p;
 
 	/* find the end of optname */
 	while (*p && *p != '=')
@@ -634,13 +594,8 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
  * Short options must be exact.
  * Return boolean true if found and no error.
  * Error stored in err_code or zero if no error. */
-static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
-     struct _scanopt_t *s;
-     int     lookup_long;
-     char   *optstart;
-     int     len;
-     int    *err_code;
-     int    *opt_offset;
+static int find_opt (struct _scanopt_t *s, int lookup_long, char *optstart, int
+	len, int *err_code, int *opt_offset)
 {
 	int     nmatch = 0, lastr_val = 0, i;
 
@@ -651,11 +606,9 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
 		return 0;
 
 	for (i = 0; i < s->optc; i++) {
-		char   *optname;
+		const char   *optname;
 
-		optname =
-			(char *) (s->options[i].opt_fmt +
-				  (lookup_long ? 2 : 1));
+		optname = s->options[i].opt_fmt + (lookup_long ? 2 : 1);
 
 		if (lookup_long && (s->aux[i].flags & IS_LONG)) {
 			if (len > s->aux[i].namelen)
@@ -699,10 +652,7 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
 }
 
 
-int     scanopt (svoid, arg, optindex)
-     scanopt_t *svoid;
-     char  **arg;
-     int    *optindex;
+int     scanopt (scanopt_t *svoid, char **arg, int *optindex)
 {
 	char   *optname = NULL, *optarg = NULL, *pstart;
 	int     namelen = 0, arglen = 0;
@@ -788,7 +738,7 @@ int     scanopt (svoid, arg, optindex)
 			arglen = 0;
 		}
 		else
-			arglen = strlen (optarg);
+			arglen = (int) strlen (optarg);
 	}
 
 	/* At this point, we have a long or short option matched at opt_offset into
@@ -848,16 +798,14 @@ int     scanopt (svoid, arg, optindex)
 }
 
 
-int     scanopt_destroy (svoid)
-     scanopt_t *svoid;
+int     scanopt_destroy (scanopt_t *svoid)
 {
 	struct _scanopt_t *s;
 
 	s = (struct _scanopt_t *) svoid;
-	if (s) {
-		if (s->aux)
-			free (s->aux);
-		free (s);
+	if (s != NULL) {
+		free(s->aux);
+		free(s);
 	}
 	return 0;
 }
diff --git a/src/scanopt.h b/src/scanopt.h
index 359a18a..c6e7dec 100644
--- a/src/scanopt.h
+++ b/src/scanopt.h
@@ -47,9 +47,6 @@
 #ifdef __cplusplus
 extern  "C" {
 #endif
-#ifndef PROTO
-#define PROTO(args) args
-#endif
 /* Error codes. */ enum scanopt_err_t {
 		SCANOPT_ERR_OPT_UNRECOGNIZED = -1,	/* Unrecognized option. */
 		SCANOPT_ERR_OPT_AMBIGUOUS = -2,	/* It matched more than one option name. */
@@ -85,12 +82,12 @@ extern  "C" {
  *   flags   - Control behavior.
  * Return:  A malloc'd pointer .
  */
-	scanopt_t *scanopt_init PROTO ((const optspec_t * options,
-					int argc, char **argv, int flags));
+	scanopt_t *scanopt_init (const optspec_t * options, int argc,
+				 char **argv, int flags);
 
 /* Frees memory used by scanner.
  * Always returns 0. */
-	int scanopt_destroy PROTO ((scanopt_t * scanner));
+	int scanopt_destroy (scanopt_t * scanner);
 
 #ifndef NO_SCANOPT_USAGE
 /* Prints a usage message based on contents of optlist.
@@ -100,10 +97,7 @@ extern  "C" {
  *   usage    - Text to be prepended to option list. May be NULL.
  * Return:  Always returns 0 (zero).
  */
-	int scanopt_usage
-		PROTO (
-		       (scanopt_t * scanner, FILE * fp,
-			const char *usage));
+	int scanopt_usage (scanopt_t * scanner, FILE * fp, const char *usage);
 #endif
 
 /* Scans command-line options in argv[].
@@ -120,10 +114,7 @@ extern  "C" {
  *          < 0 on error (return value is an error code).
  *
  */
-	int scanopt
-		PROTO (
-		       (scanopt_t * scanner, char **optarg,
-			int *optindex));
+	int scanopt (scanopt_t * scanner, char **optarg, int *optindex);
 
 #ifdef __cplusplus
 }
diff --git a/src/sym.c b/src/sym.c
index 232cd0a..14fb161 100644
--- a/src/sym.c
+++ b/src/sym.c
@@ -59,12 +59,10 @@ static struct hash_entry *ccltab[CCL_HASH_SIZE];
 
 /* declare functions that have forward references */
 
-static int addsym PROTO ((char[], char *, int, hash_table, int));
-static struct hash_entry *findsym PROTO ((const char *sym,
-					  hash_table table,
-
-					  int table_size));
-static int hashfunct PROTO ((const char *, int));
+static int addsym(char[], char *, int, hash_table, int);
+static struct hash_entry *findsym (const char *sym, hash_table table,
+				   int table_size);
+static int hashfunct(const char *, int);
 
 
 /* addsym - add symbol and definitions to symbol table
@@ -72,12 +70,7 @@ static int hashfunct PROTO ((const char *, int));
  * -1 is returned if the symbol already exists, and the change not made.
  */
 
-static int addsym (sym, str_def, int_def, table, table_size)
-     char sym[];
-     char   *str_def;
-     int     int_def;
-     hash_table table;
-     int     table_size;
+static int addsym (char sym[], char *str_def, int int_def, hash_table table, int table_size)
 {
 	int    hash_val = hashfunct (sym, table_size);
 	struct hash_entry *sym_entry = table[hash_val];
@@ -93,8 +86,7 @@ static int addsym (sym, str_def, int_def, table, table_size)
 	}
 
 	/* create new entry */
-	new_entry = (struct hash_entry *)
-		flex_alloc (sizeof (struct hash_entry));
+	new_entry = malloc(sizeof(struct hash_entry));
 
 	if (new_entry == NULL)
 		flexfatal (_("symbol table memory allocation failed"));
@@ -119,15 +111,13 @@ static int addsym (sym, str_def, int_def, table, table_size)
 
 /* cclinstal - save the text of a character class */
 
-void    cclinstal (ccltxt, cclnum)
-     Char    ccltxt[];
-     int     cclnum;
+void    cclinstal (char ccltxt[], int cclnum)
 {
 	/* We don't bother checking the return status because we are not
 	 * called unless the symbol is new.
 	 */
 
-	(void) addsym ((char *) copy_unsigned_string (ccltxt),
+	(void) addsym (xstrdup(ccltxt),
 		       (char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
 }
 
@@ -137,23 +127,18 @@ void    cclinstal (ccltxt, cclnum)
  * Returns 0 if there's no CCL associated with the text.
  */
 
-int     ccllookup (ccltxt)
-     Char    ccltxt[];
+int     ccllookup (char ccltxt[])
 {
-	return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
+	return findsym (ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
 }
 
 
 /* findsym - find symbol in symbol table */
 
-static struct hash_entry *findsym (sym, table, table_size)
-     const char *sym;
-     hash_table table;
-     int     table_size;
+static struct hash_entry *findsym (const 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,
+		NULL, NULL, NULL, NULL, 0,
 	};
 	struct hash_entry *sym_entry =
 
@@ -170,9 +155,7 @@ static struct hash_entry *findsym (sym, table, table_size)
 
 /* hashfunct - compute the hash value for "str" and hash size "hash_size" */
 
-static int hashfunct (str, hash_size)
-     const char *str;
-     int     hash_size;
+static int hashfunct (const char *str, int hash_size)
 {
 	int hashval;
 	int locstr;
@@ -191,13 +174,11 @@ static int hashfunct (str, hash_size)
 
 /* ndinstal - install a name definition */
 
-void    ndinstal (name, definition)
-     const char *name;
-     Char    definition[];
+void    ndinstal (const char *name, char definition[])
 {
 
-	if (addsym (copy_string (name),
-		    (char *) copy_unsigned_string (definition), 0,
+	if (addsym (xstrdup(name),
+		    xstrdup(definition), 0,
 		    ndtbl, NAME_TABLE_HASH_SIZE))
 			synerr (_("name defined twice"));
 }
@@ -208,16 +189,15 @@ void    ndinstal (name, definition)
  * Returns a nil pointer if the name definition does not exist.
  */
 
-Char   *ndlookup (nd)
-     const char *nd;
+char   *ndlookup (const char *nd)
 {
-	return (Char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
+	return findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
 }
 
 
 /* scextend - increase the maximum number of start conditions */
 
-void    scextend ()
+void    scextend (void)
 {
 	current_max_scs += MAX_SCS_INCREMENT;
 
@@ -237,17 +217,15 @@ void    scextend ()
  *    The start condition is "exclusive" if xcluflg is true.
  */
 
-void    scinstal (str, xcluflg)
-     const char *str;
-     int     xcluflg;
+void    scinstal (const char *str, int xcluflg)
 {
 
 	if (++lastsc >= current_max_scs)
 		scextend ();
 
-	scname[lastsc] = copy_string (str);
+	scname[lastsc] = xstrdup(str);
 
-	if (addsym (scname[lastsc], (char *) 0, lastsc,
+	if (addsym(scname[lastsc], NULL, lastsc,
 		    sctbl, START_COND_HASH_SIZE))
 			format_pinpoint_message (_
 						 ("start condition %s declared twice"),
@@ -265,8 +243,7 @@ str);
  * Returns 0 if no such start condition.
  */
 
-int     sclookup (str)
-     const char *str;
+int     sclookup (const char *str)
 {
 	return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
 }
diff --git a/src/tables.c b/src/tables.c
index ef49ad0..3d043c6 100644
--- a/src/tables.c
+++ b/src/tables.c
@@ -90,8 +90,8 @@ int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
 	th->th_hsize += yypad64 (th->th_hsize);
 	th->th_ssize = 0;	// Not known at this point.
 	th->th_flags = 0;
-	th->th_version = copy_string (version_str);
-	th->th_name = copy_string (name);
+	th->th_version = xstrdup(version_str);
+	th->th_name = xstrdup(name);
 	return 0;
 }
 
@@ -115,8 +115,7 @@ int yytbl_data_init (struct yytbl_data *td, enum yytbl_id id)
  */
 int yytbl_data_destroy (struct yytbl_data *td)
 {
-	if (td->td_data)
-		free (td->td_data);
+	free(td->td_data);
 	td->td_data = 0;
 	free (td);
 	return 0;
@@ -159,12 +158,12 @@ int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th)
 		flex_die (_("th_ssize|th_flags write failed"));
 	bwritten += 6;
 
-	sz = strlen (th->th_version) + 1;
+	sz = (int) strlen (th->th_version) + 1;
 	if ((rv = yytbl_writen (wr, th->th_version, sz)) != sz)
 		flex_die (_("th_version writen failed"));
 	bwritten += rv;
 
-	sz = strlen (th->th_name) + 1;
+	sz = (int) strlen (th->th_name) + 1;
 	if ((rv = yytbl_writen (wr, th->th_name, sz)) != sz)
 		flex_die (_("th_name writen failed"));
 	bwritten += rv;
@@ -482,7 +481,7 @@ void yytbl_data_compress (struct yytbl_data *tbl)
 	}
 
 	total_len = yytbl_calc_total_len (tbl);
-	newtbl.td_data = calloc (total_len, newsz);
+	newtbl.td_data = calloc ((size_t) total_len, newsz);
 	newtbl.td_flags =
 		TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz);
 
diff --git a/src/tblcmp.c b/src/tblcmp.c
index 0c058e6..b0dc8b3 100644
--- a/src/tblcmp.c
+++ b/src/tblcmp.c
@@ -36,11 +36,11 @@
 
 /* declarations for functions that have forward references */
 
-void mkentry PROTO ((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[]));
+void mkentry(int *, int, int, int, int);
+void mkprot(int[], int, int);
+void mktemplate(int[], int, int);
+void mv2front(int);
+int tbldiff(int[], int, int[]);
 
 
 /* bldtbl - build table entries for dfa state
@@ -78,8 +78,7 @@ int tbldiff PROTO ((int[], int, int[]));
  * cost only one difference.
  */
 
-void    bldtbl (state, statenum, totaltrans, comstate, comfreq)
-     int     state[], statenum, totaltrans, comstate, comfreq;
+void    bldtbl (int state[], int statenum, int totaltrans, int comstate, int comfreq)
 {
 	int     extptr, extrct[2][CSIZE + 1];
 	int     mindiff, minprot, i, d;
@@ -221,7 +220,7 @@ void    bldtbl (state, statenum, totaltrans, comstate, comfreq)
  * classes.
  */
 
-void    cmptmps ()
+void    cmptmps (void)
 {
 	int tmpstorage[CSIZE + 1];
 	int *tmp = tmpstorage, i, j;
@@ -289,7 +288,7 @@ void    cmptmps ()
 
 /* expand_nxt_chk - expand the next check arrays */
 
-void    expand_nxt_chk ()
+void    expand_nxt_chk (void)
 {
 	int old_max = current_max_xpairs;
 
@@ -300,8 +299,7 @@ void    expand_nxt_chk ()
 	nxt = reallocate_integer_array (nxt, current_max_xpairs);
 	chk = reallocate_integer_array (chk, current_max_xpairs);
 
-	zero_out ((char *) (chk + old_max),
-		  (size_t) (MAX_XPAIRS_INCREMENT * sizeof (int)));
+	memset(chk + old_max, 0, MAX_XPAIRS_INCREMENT * sizeof(int));
 }
 
 
@@ -324,8 +322,7 @@ void    expand_nxt_chk ()
  * and an action number will be added in [-1].
  */
 
-int     find_table_space (state, numtrans)
-     int    *state, numtrans;
+int     find_table_space (int *state, int numtrans)
 {
 	/* Firstfree is the position of the first possible occurrence of two
 	 * consecutive unused records in the chk and nxt arrays.
@@ -419,13 +416,11 @@ int     find_table_space (state, numtrans)
  * Initializes "firstfree" to be one beyond the end of the table.  Initializes
  * all "chk" entries to be zero.
  */
-void    inittbl ()
+void    inittbl (void)
 {
 	int i;
 
-	zero_out ((char *) chk,
-
-		  (size_t) (current_max_xpairs * sizeof (int)));
+	memset(chk, 0, current_max_xpairs * sizeof(int));
 
 	tblend = 0;
 	firstfree = tblend + 1;
@@ -451,7 +446,7 @@ void    inittbl ()
 
 /* mkdeftbl - make the default, "jam" table entries */
 
-void    mkdeftbl ()
+void    mkdeftbl (void)
 {
 	int     i;
 
@@ -500,9 +495,8 @@ void    mkdeftbl ()
  * state array.
  */
 
-void    mkentry (state, numchars, statenum, deflink, totaltrans)
-     int *state;
-     int numchars, statenum, deflink, totaltrans;
+void    mkentry (int *state, int numchars, int statenum, int deflink,
+		 int totaltrans)
 {
 	int minec, maxec, i, baseaddr;
 	int tblbase, tbllast;
@@ -616,8 +610,7 @@ void    mkentry (state, numchars, statenum, deflink, totaltrans)
  *            has only one out-transition
  */
 
-void    mk1tbl (state, sym, onenxt, onedef)
-     int     state, sym, onenxt, onedef;
+void    mk1tbl (int state, int sym, int onenxt, int onedef)
 {
 	if (firstfree < sym)
 		firstfree = sym;
@@ -642,8 +635,7 @@ void    mk1tbl (state, sym, onenxt, onedef)
 
 /* mkprot - create new proto entry */
 
-void    mkprot (state, statenum, comstate)
-     int     state[], statenum, comstate;
+void    mkprot (int state[], int statenum, int comstate)
 {
 	int     i, slot, tblbase;
 
@@ -680,11 +672,10 @@ void    mkprot (state, statenum, comstate)
  *              to it
  */
 
-void    mktemplate (state, statenum, comstate)
-     int     state[], statenum, comstate;
+void    mktemplate (int state[], int statenum, int comstate)
 {
 	int     i, numdiff, tmpbase, tmp[CSIZE + 1];
-	Char    transset[CSIZE + 1];
+	unsigned char    transset[CSIZE + 1];
 	int     tsptr;
 
 	++numtemps;
@@ -732,8 +723,7 @@ void    mktemplate (state, statenum, comstate)
 
 /* mv2front - move proto queue element to front of queue */
 
-void    mv2front (qelm)
-     int     qelm;
+void    mv2front (int qelm)
 {
 	if (firstprot != qelm) {
 		if (qelm == lastprot)
@@ -759,8 +749,7 @@ void    mv2front (qelm)
  * Transnum is the number of out-transitions for the state.
  */
 
-void    place_state (state, statenum, transnum)
-     int    *state, statenum, transnum;
+void    place_state (int *state, int statenum, int transnum)
 {
 	int i;
 	int *state_ptr;
@@ -802,8 +791,7 @@ void    place_state (state, statenum, transnum)
  * no room, we process the sucker right now.
  */
 
-void    stack1 (statenum, sym, nextstate, deflink)
-     int     statenum, sym, nextstate, deflink;
+void    stack1 (int statenum, int sym, int nextstate, int deflink)
 {
 	if (onesp >= ONE_STACK_SIZE - 1)
 		mk1tbl (statenum, sym, nextstate, deflink);
@@ -832,8 +820,7 @@ void    stack1 (statenum, sym, nextstate, deflink)
  * number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
  */
 
-int     tbldiff (state, pr, ext)
-     int     state[], pr, ext[];
+int     tbldiff (int state[], int pr, int ext[])
 {
 	int i, *sp = state, *ep = ext, *protp;
 	int numdiff = 0;
diff --git a/src/yylex.c b/src/yylex.c
index 17b3e61..c3de1d5 100644
--- a/src/yylex.c
+++ b/src/yylex.c
@@ -174,12 +174,12 @@ int     yylex (void)
 			fprintf (stderr, "<<EOF>>");
 			break;
 
-		case OPTION_OP:
+		case TOK_OPTION:
 			fprintf (stderr, "%s ", yytext);
 			break;
 
-		case OPT_OUTFILE:
-		case OPT_PREFIX:
+		case TOK_OUTFILE:
+		case TOK_PREFIX:
 		case CCE_ALNUM:
 		case CCE_ALPHA:
 		case CCE_BLANK: