Import flex-2.5.37 to new vendor branch vendor/FLEX
authorJohn Marino <draco@marino.st>
Wed, 16 Jan 2013 01:38:47 +0000 (02:38 +0100)
committerJohn Marino <draco@marino.st>
Wed, 16 Jan 2013 01:38:47 +0000 (02:38 +0100)
45 files changed:
contrib/flex/AUTHORS [new file with mode: 0644]
contrib/flex/COPYING [new file with mode: 0644]
contrib/flex/FlexLexer.h [new file with mode: 0644]
contrib/flex/autogen.sh [new file with mode: 0755]
contrib/flex/buf.c [new file with mode: 0644]
contrib/flex/ccl.c [new file with mode: 0644]
contrib/flex/compile [new file with mode: 0755]
contrib/flex/depcomp [new file with mode: 0755]
contrib/flex/dfa.c [new file with mode: 0644]
contrib/flex/doc/flex.1 [new file with mode: 0644]
contrib/flex/ecs.c [new file with mode: 0644]
contrib/flex/filter.c [new file with mode: 0644]
contrib/flex/flex.skl [new file with mode: 0644]
contrib/flex/flexdef.h [new file with mode: 0644]
contrib/flex/flexint.h [new file with mode: 0644]
contrib/flex/gen.c [new file with mode: 0644]
contrib/flex/gettext.h [new file with mode: 0644]
contrib/flex/libmain.c [new file with mode: 0644]
contrib/flex/libyywrap.c [new file with mode: 0644]
contrib/flex/main.c [new file with mode: 0644]
contrib/flex/misc.c [new file with mode: 0644]
contrib/flex/missing [new file with mode: 0755]
contrib/flex/mkskel.sh [new file with mode: 0755]
contrib/flex/nfa.c [new file with mode: 0644]
contrib/flex/options.c [new file with mode: 0644]
contrib/flex/options.h [new file with mode: 0644]
contrib/flex/parse.c [new file with mode: 0644]
contrib/flex/parse.h [new file with mode: 0644]
contrib/flex/parse.y [new file with mode: 0644]
contrib/flex/regex.c [new file with mode: 0644]
contrib/flex/scan.c [new file with mode: 0644]
contrib/flex/scan.l [new file with mode: 0644]
contrib/flex/scanflags.c [new file with mode: 0644]
contrib/flex/scanopt.c [new file with mode: 0644]
contrib/flex/scanopt.h [new file with mode: 0644]
contrib/flex/skel.c [new file with mode: 0644]
contrib/flex/sym.c [new file with mode: 0644]
contrib/flex/tables.c [new file with mode: 0644]
contrib/flex/tables.h [new file with mode: 0644]
contrib/flex/tables_shared.c [new file with mode: 0644]
contrib/flex/tables_shared.h [new file with mode: 0644]
contrib/flex/tblcmp.c [new file with mode: 0644]
contrib/flex/version.h [new file with mode: 0644]
contrib/flex/ylwrap [new file with mode: 0755]
contrib/flex/yylex.c [new file with mode: 0644]

diff --git a/contrib/flex/AUTHORS b/contrib/flex/AUTHORS
new file mode 100644 (file)
index 0000000..93b3528
--- /dev/null
@@ -0,0 +1,16 @@
+
+In 2001, Will Estes took over as maintainer of flex.
+
+John Millaway is a co-author of the current version of flex. He has
+contributed a large number of new features, fixed a large number of
+outstanding bugs and has made significant contributions to the flex
+documentation.
+
+Aaron Stone has contributed several bug fixes to the flex codebase.
+
+Vern Paxson wrote flex with the help of many ideas and much
+inspiration from Van Jacobson.  Original version by Jef Poskanzer.
+
+The fast table representation is a partial implementation of a design
+done by Van Jacobson.  The implementation was done by Kevin Gong and
+Vern Paxson.
diff --git a/contrib/flex/COPYING b/contrib/flex/COPYING
new file mode 100644 (file)
index 0000000..684b011
--- /dev/null
@@ -0,0 +1,42 @@
+Flex carries the copyright used for BSD software, slightly modified
+because it originated at the Lawrence Berkeley (not Livermore!) Laboratory,
+which operates under a contract with the Department of Energy:
+
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007 The Flex Project.
+
+Copyright (c) 1990, 1997 The Regents of the University of California.
+All rights reserved.
+
+This code is derived from software contributed to Berkeley by
+Vern Paxson.
+
+The United States Government has rights in this work pursuant
+to contract no. DE-AC03-76SF00098 between the United States
+Department of Energy and the University of California.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+Neither the name of the University nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.
+
+This basically says "do whatever you please with this software except
+remove this notice or take advantage of the University's (or the flex
+authors') name".
+
+Note that the "flex.skl" scanner skeleton carries no copyright notice.
+You are free to do whatever you please with scanners generated using flex;
+for them, you are not even bound by the above copyright.
diff --git a/contrib/flex/FlexLexer.h b/contrib/flex/FlexLexer.h
new file mode 100644 (file)
index 0000000..bad4ce0
--- /dev/null
@@ -0,0 +1,206 @@
+// -*-C++-*-
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+// by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+
+//  1. Redistributions of source code must retain the above copyright
+//  notice, this list of conditions and the following disclaimer.
+//  2. Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+
+//  Neither the name of the University nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+
+//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// 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 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 {
+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 void yy_delete_buffer( struct yy_buffer_state* b ) = 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 = 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 = 0,
+                                       FLEX_STD ostream* new_out = 0 ) = 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"
+};
+
+}
+#endif // FLEXLEXER_H
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// 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
+
+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 = 0, FLEX_STD ostream* arg_yyout = 0 );
+
+       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 );
+       void yy_delete_buffer( struct yy_buffer_state* b );
+       void yyrestart( FLEX_STD istream* s );
+
+       void yypush_buffer_state( struct 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 = 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 );
+
+       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 );
+
+       int yy_start_stack_ptr;
+       int yy_start_stack_depth;
+       int* yy_start_stack;
+
+       void yy_push_state( int new_state );
+       void yy_pop_state();
+       int yy_top_state();
+
+       yy_state_type yy_get_previous_state();
+       yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+       int yy_get_next_buffer();
+
+       FLEX_STD istream* yyin; // input source for default LexerInput
+       FLEX_STD ostream* yyout;        // output sink for default LexerOutput
+
+       // yy_hold_char holds the character lost when yytext is formed.
+       char yy_hold_char;
+
+       // Number of characters read into yy_ch_buf.
+       int yy_n_chars;
+
+       // Points to current character in buffer.
+       char* yy_c_buf_p;
+
+       int yy_init;            // whether we need to initialize
+       int yy_start;           // start state number
+
+       // Flag which is used to allow yywrap()'s to do buffer switches
+       // instead of setting up a fresh yyin.  A bit of a hack ...
+       int yy_did_buffer_switch_on_eof;
+
+
+       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);
+
+       // The following are not always needed, but may be depending
+       // on use of certain flex features (like REJECT or yymore()).
+
+       yy_state_type yy_last_accepting_state;
+       char* yy_last_accepting_cpos;
+
+       yy_state_type* yy_state_buf;
+       yy_state_type* yy_state_ptr;
+
+       char* yy_full_match;
+       int* yy_full_state;
+       int yy_full_lp;
+
+       int yy_lp;
+       int yy_looking_for_trail_begin;
+
+       int yy_more_flag;
+       int yy_more_len;
+       int yy_more_offset;
+       int yy_prev_more_offset;
+};
+
+}
+
+#endif // yyFlexLexer || ! yyFlexLexerOnce
+
diff --git a/contrib/flex/autogen.sh b/contrib/flex/autogen.sh
new file mode 100755 (executable)
index 0000000..20e82fd
--- /dev/null
@@ -0,0 +1,32 @@
+#!/bin/sh
+
+#  This file is part of flex.
+
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+
+#  Neither the name of the University nor the names of its contributors
+#  may be used to endorse or promote products derived from this software
+#  without specific prior written permission.
+
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+#  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+#  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+#  PURPOSE.
+
+# If you see no configure script, then run ./autogen.sh to create it
+# and procede with the "normal" build procedures.
+
+#if we pretend to have a ChangeLog, then automake is less
+#worried. (Don't worry, we *do* have a ChangeLog, we just need the
+#Makefile first.)
+
+touch ChangeLog
+autoreconf --install --verbose
diff --git a/contrib/flex/buf.c b/contrib/flex/buf.c
new file mode 100644 (file)
index 0000000..e5deb4e
--- /dev/null
@@ -0,0 +1,273 @@
+/* flex - tool to generate fast lexical analyzers */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+\f
+#include "flexdef.h"
+
+/* Take note: The buffer object is sometimes used as a String buffer (one
+ * continuous string), and sometimes used as a list of strings, usually line by
+ * line.
+ * 
+ * The type is specified in buf_init by the elt_size. If the elt_size is
+ * sizeof(char), then the buffer should be treated as string buffer. If the
+ * elt_size is sizeof(char*), then the buffer should be treated as a list of
+ * strings.
+ *
+ * Certain functions are only appropriate for one type or the other. 
+ */
+
+/* global buffers. */
+struct Buf userdef_buf;                /**< for user #definitions triggered by cmd-line. */
+struct Buf defs_buf;           /**< for #define's autogenerated. List of strings. */
+struct Buf yydmap_buf;         /**< string buffer to hold yydmap elements */
+struct Buf m4defs_buf;          /**< m4 definitions. List of strings. */
+struct Buf top_buf;             /**< contains %top code. String buffer. */
+
+struct Buf *buf_print_strings(struct Buf * buf, FILE* out)
+{
+    int i;
+
+    if(!buf || !out)
+        return buf;
+
+    for (i=0; i < buf->nelts; i++){
+        const char * s = ((char**)buf->elts)[i];
+        if(s)
+            fprintf(out, "%s", s);
+    }
+    return buf;
+}
+
+/* Append a "%s" formatted string to a string buffer */
+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);
+       if (!t)
+           flexfatal (_("Allocation of buffer to print string failed"));
+       snprintf (t, tsz, fmt, s);
+       buf = buf_strappend (buf, t);
+       flex_free (t);
+       return buf;
+}
+
+/** Append a line directive to the string buffer.
+ * @param buf A string buffer.
+ * @param filename file name
+ * @param lineno line number
+ * @return buf
+ */
+struct Buf *buf_linedir (struct Buf *buf, const char* filename, int lineno)
+{
+    char *dst, *src, *t;
+
+    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 (!t)
+      flexfatal (_("Allocation of buffer for line directive failed"));
+    for (dst = t + sprintf (t, "#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);
+    return buf;
+}
+
+
+/** Append the contents of @a src to @a dest.
+ * @param @a dest the destination buffer
+ * @param @a dest the source buffer
+ * @return @a dest
+ */
+struct Buf *buf_concat(struct Buf* dest, const struct Buf* src)
+{
+    buf_append(dest, src->elts, src->nelts);
+    return dest;
+}
+
+
+/* Appends n characters in str to buf. */
+struct Buf *buf_strnappend (buf, str, n)
+     struct Buf *buf;
+     const char *str;
+     int n;
+{
+       buf_append (buf, str, n + 1);
+
+       /* "undo" the '\0' character that buf_append() already copied. */
+       buf->nelts--;
+
+       return buf;
+}
+
+/* Appends characters in str to buf. */
+struct Buf *buf_strappend (buf, str)
+     struct Buf *buf;
+     const char *str;
+{
+       return buf_strnappend (buf, str, strlen (str));
+}
+
+/* appends "#define str def\n" */
+struct Buf *buf_strdefine (buf, str, def)
+     struct Buf *buf;
+     const char *str;
+     const char *def;
+{
+       buf_strappend (buf, "#define ");
+       buf_strappend (buf, " ");
+       buf_strappend (buf, str);
+       buf_strappend (buf, " ");
+       buf_strappend (buf, def);
+       buf_strappend (buf, "\n");
+       return buf;
+}
+
+/** Pushes "m4_define( [[def]], [[val]])m4_dnl" to end of buffer.
+ * @param buf A buffer as a list of strings.
+ * @param def The m4 symbol to define.
+ * @param val The definition; may be NULL.
+ * @return buf
+ */
+struct Buf *buf_m4_define (struct Buf *buf, const char* def, const char* val)
+{
+    const char * fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
+    char * str;
+    size_t strsz;
+
+    val = val?val:"";
+    str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + strlen(val) + 2);
+    if (!str)
+        flexfatal (_("Allocation of buffer for m4 def failed"));
+
+    snprintf(str, strsz, fmt, def, val);
+    buf_append(buf, &str, 1);
+    return buf;
+}
+
+/** Pushes "m4_undefine([[def]])m4_dnl" to end of buffer.
+ * @param buf A buffer as a list of strings.
+ * @param def The m4 symbol to undefine.
+ * @return buf
+ */
+struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
+{
+    const char * fmt = "m4_undefine( [[%s]])m4_dnl\n";
+    char * str;
+    size_t strsz;
+
+    str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + 2);
+    if (!str)
+        flexfatal (_("Allocation of buffer for m4 undef failed"));
+
+    snprintf(str, strsz, fmt, def);
+    buf_append(buf, &str, 1);
+    return buf;
+}
+
+/* create buf with 0 elements, each of size elem_size. */
+void buf_init (buf, elem_size)
+     struct Buf *buf;
+     size_t elem_size;
+{
+       buf->elts = (void *) 0;
+       buf->nelts = 0;
+       buf->elt_size = elem_size;
+       buf->nmax = 0;
+}
+
+/* frees memory */
+void buf_destroy (buf)
+     struct Buf *buf;
+{
+       if (buf && buf->elts)
+               flex_free (buf->elts);
+       buf->elts = (void *) 0;
+}
+
+
+/* appends ptr[] to buf, grow if necessary.
+ * n_elem is number of elements in ptr[], NOT bytes.
+ * returns buf.
+ * We grow by mod(512) boundaries.
+ */
+
+struct Buf *buf_append (buf, ptr, n_elem)
+     struct Buf *buf;
+     const void *ptr;
+     int n_elem;
+{
+       int     n_alloc = 0;
+
+       if (!ptr || n_elem == 0)
+               return buf;
+
+       /* May need to alloc more. */
+       if (n_elem + buf->nelts > buf->nmax) {
+
+               /* exact amount needed... */
+               n_alloc = (n_elem + buf->nelts) * buf->elt_size;
+
+               /* ...plus some extra */
+               if (((n_alloc * buf->elt_size) % 512) != 0
+                   && buf->elt_size < 512)
+                       n_alloc +=
+                               (512 -
+                                ((n_alloc * buf->elt_size) % 512)) /
+                               buf->elt_size;
+
+               if (!buf->elts)
+                       buf->elts =
+                               allocate_array (n_alloc, buf->elt_size);
+               else
+                       buf->elts =
+                               reallocate_array (buf->elts, n_alloc,
+                                                 buf->elt_size);
+
+               buf->nmax = n_alloc;
+       }
+
+       memcpy ((char *) buf->elts + buf->nelts * buf->elt_size, ptr,
+               n_elem * buf->elt_size);
+       buf->nelts += n_elem;
+
+       return buf;
+}
+
+/* vim:set tabstop=8 softtabstop=4 shiftwidth=4: */
diff --git a/contrib/flex/ccl.c b/contrib/flex/ccl.c
new file mode 100644 (file)
index 0000000..8d66bb6
--- /dev/null
@@ -0,0 +1,310 @@
+/* ccl - routines for character classes */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+ /*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+#include "flexdef.h"
+
+/* return true if the chr is in the ccl. Takes negation into account. */
+static bool
+ccl_contains (const int cclp, const int ch)
+{
+       int     ind, len, i;
+
+       len = ccllen[cclp];
+       ind = cclmap[cclp];
+
+       for (i = 0; i < len; ++i)
+               if (ccltbl[ind + i] == ch)
+                       return !cclng[cclp];
+
+    return cclng[cclp];
+}
+
+
+/* ccladd - add a single character to a ccl */
+
+void    ccladd (cclp, ch)
+     int     cclp;
+     int     ch;
+{
+       int     ind, len, newpos, i;
+
+       check_char (ch);
+
+       len = ccllen[cclp];
+       ind = cclmap[cclp];
+
+       /* check to see if the character is already in the ccl */
+
+       for (i = 0; i < len; ++i)
+               if (ccltbl[ind + i] == ch)
+                       return;
+
+       /* mark newlines */
+       if (ch == nlch)
+               ccl_has_nl[cclp] = true;
+
+       newpos = ind + len;
+
+       if (newpos >= current_max_ccl_tbl_size) {
+               current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
+
+               ++num_reallocs;
+
+               ccltbl = reallocate_Character_array (ccltbl,
+                                                    current_max_ccl_tbl_size);
+       }
+
+       ccllen[cclp] = len + 1;
+       ccltbl[newpos] = ch;
+}
+
+/* dump_cclp - same thing as list_character_set, but for cclps.  */
+
+static void    dump_cclp (FILE* file, int cclp)
+{
+       register int i;
+
+       putc ('[', file);
+
+       for (i = 0; i < csize; ++i) {
+               if (ccl_contains(cclp, i)){
+                       register int start_char = i;
+
+                       putc (' ', file);
+
+                       fputs (readable_form (i), file);
+
+                       while (++i < csize && ccl_contains(cclp,i)) ;
+
+                       if (i - 1 > start_char)
+                               /* this was a run */
+                               fprintf (file, "-%s",
+                                        readable_form (i - 1));
+
+                       putc (' ', file);
+               }
+       }
+
+       putc (']', file);
+}
+
+
+
+/* ccl_set_diff - create a new ccl as the set difference of the two given ccls. */
+int
+ccl_set_diff (int a, int b)
+{
+    int  d, ch;
+
+    /* create new class  */
+    d = cclinit();
+
+    /* In order to handle negation, we spin through all possible chars,
+     * addding each char in a that is not in b.
+     * (This could be O(n^2), but n is small and bounded.)
+     */
+       for ( ch = 0; ch < csize; ++ch )
+        if (ccl_contains (a, ch) && !ccl_contains(b, ch))
+            ccladd (d, ch);
+
+    /* debug */
+    if (0){
+        fprintf(stderr, "ccl_set_diff (");
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, a);
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, b);
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, d);
+        fprintf(stderr, "\n)\n");
+    }
+    return d;
+}
+
+/* ccl_set_union - create a new ccl as the set union of the two given ccls. */
+int
+ccl_set_union (int a, int b)
+{
+    int  d, i;
+
+    /* create new class  */
+    d = cclinit();
+
+    /* Add all of a */
+    for (i = 0; i < ccllen[a]; ++i)
+               ccladd (d, ccltbl[cclmap[a] + i]);
+
+    /* Add all of b */
+    for (i = 0; i < ccllen[b]; ++i)
+               ccladd (d, ccltbl[cclmap[b] + i]);
+
+    /* debug */
+    if (0){
+        fprintf(stderr, "ccl_set_union (%d + %d = %d", a, b, d);
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, a);
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, b);
+            fprintf(stderr, "\n    ");
+            dump_cclp (stderr, d);
+        fprintf(stderr, "\n)\n");
+    }
+    return d;
+}
+
+
+/* cclinit - return an empty ccl */
+
+int     cclinit ()
+{
+       if (++lastccl >= current_maxccls) {
+               current_maxccls += MAX_CCLS_INCREMENT;
+
+               ++num_reallocs;
+
+               cclmap =
+                       reallocate_integer_array (cclmap, current_maxccls);
+               ccllen =
+                       reallocate_integer_array (ccllen, current_maxccls);
+               cclng = reallocate_integer_array (cclng, current_maxccls);
+               ccl_has_nl =
+                       reallocate_bool_array (ccl_has_nl,
+                                              current_maxccls);
+       }
+
+       if (lastccl == 1)
+               /* we're making the first ccl */
+               cclmap[lastccl] = 0;
+
+       else
+               /* The new pointer is just past the end of the last ccl.
+                * Since the cclmap points to the \first/ character of a
+                * ccl, adding the length of the ccl to the cclmap pointer
+                * will produce a cursor to the first free space.
+                */
+               cclmap[lastccl] =
+                       cclmap[lastccl - 1] + ccllen[lastccl - 1];
+
+       ccllen[lastccl] = 0;
+       cclng[lastccl] = 0;     /* ccl's start out life un-negated */
+       ccl_has_nl[lastccl] = false;
+
+       return lastccl;
+}
+
+
+/* cclnegate - negate the given ccl */
+
+void    cclnegate (cclp)
+     int     cclp;
+{
+       cclng[cclp] = 1;
+       ccl_has_nl[cclp] = !ccl_has_nl[cclp];
+}
+
+
+/* list_character_set - list the members of a set of characters in CCL form
+ *
+ * Writes to the given file a character-class representation of those
+ * characters present in the given CCL.  A character is present if it
+ * has a non-zero value in the cset array.
+ */
+
+void    list_character_set (file, cset)
+     FILE   *file;
+     int     cset[];
+{
+       register int i;
+
+       putc ('[', file);
+
+       for (i = 0; i < csize; ++i) {
+               if (cset[i]) {
+                       register int start_char = i;
+
+                       putc (' ', file);
+
+                       fputs (readable_form (i), file);
+
+                       while (++i < csize && cset[i]) ;
+
+                       if (i - 1 > start_char)
+                               /* this was a run */
+                               fprintf (file, "-%s",
+                                        readable_form (i - 1));
+
+                       putc (' ', file);
+               }
+       }
+
+       putc (']', file);
+}
+
+/** Determines if the range [c1-c2] is unambiguous in a case-insensitive
+ * scanner.  Specifically, if a lowercase or uppercase character, x, is in the
+ * range [c1-c2], then we require that UPPERCASE(x) and LOWERCASE(x) must also
+ * be in the range. If not, then this range is ambiguous, and the function
+ * returns false.  For example, [@-_] spans [a-z] but not [A-Z].  Beware that
+ * [a-z] will be labeled ambiguous because it does not include [A-Z].
+ *
+ * @param c1 the lower end of the range
+ * @param c2 the upper end of the range
+ * @return true if [c1-c2] is not ambiguous for a caseless scanner.
+ */
+bool range_covers_case (int c1, int c2)
+{
+       int     i, o;
+
+       for (i = c1; i <= c2; i++) {
+               if (has_case (i)) {
+                       o = reverse_case (i);
+                       if (o < c1 || c2 < o)
+                               return false;
+               }
+       }
+       return true;
+}
+
+/** Reverse the case of a character, if possible.
+ * @return c if case-reversal does not apply.
+ */
+int reverse_case (int c)
+{
+       return isupper (c) ? tolower (c) : (islower (c) ? toupper (c) : c);
+}
+
+/** Return true if c is uppercase or lowercase. */
+bool has_case (int c)
+{
+       return (isupper (c) || islower (c)) ? true : false;
+}
diff --git a/contrib/flex/compile b/contrib/flex/compile
new file mode 100755 (executable)
index 0000000..c0096a7
--- /dev/null
@@ -0,0 +1,143 @@
+#! /bin/sh
+# Wrapper for compilers which do not understand `-c -o'.
+
+scriptversion=2009-10-06.20; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2009  Free Software
+# Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+case $1 in
+  '')
+     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand `-c -o'.
+Remove `-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file `INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+esac
+
+ofile=
+cfile=
+eat=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+       # configure might choose to run compile as `compile cc -o foo foo.c'.
+       # So we strip `-o arg' only if arg is an object.
+       eat=1
+       case $2 in
+         *.o | *.obj)
+           ofile=$2
+           ;;
+         *)
+           set x "$@" -o "$2"
+           shift
+           ;;
+       esac
+       ;;
+      *.c)
+       cfile=$1
+       set x "$@" "$1"
+       shift
+       ;;
+      *)
+       set x "$@" "$1"
+       shift
+       ;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no `-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # `.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use `[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/contrib/flex/depcomp b/contrib/flex/depcomp
new file mode 100755 (executable)
index 0000000..df8eea7
--- /dev/null
@@ -0,0 +1,630 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2009-04-28.21; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009 Free
+# Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+  '')
+     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by `PROGRAMS ARGS'.
+  object      Object file output by `PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputing dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+   # This is just like dashmstdout with a different argument.
+   dashmflag=-xM
+   depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+   # This is just like msvisualcpp but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u="sed s,\\\\\\\\,/,g"
+   depmode=msvisualcpp
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
+  sed -e 's/^[^:]*: / /' \
+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the `deleted header file' problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+  tr ' ' '
+' < "$tmpdepfile" |
+## Some versions of gcc put a space before the `:'.  On the theory
+## that the space means something, we add a space to the output as
+## well.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like `#:fec' to the end of the
+    # dependency line.
+    tr ' ' '
+' < "$tmpdepfile" \
+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+    tr '
+' ' ' >> "$depfile"
+    echo >> "$depfile"
+
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' '
+' < "$tmpdepfile" \
+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+   >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts `$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form `foo.o: dependent.h'.
+    # Do two passes, one to just change these to
+    # `$object: dependent.h' and one to simply `dependent.h:'.
+    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+    # That's a tab and a space in the [].
+    sed -e 's,^.*\.[a-z]*:[     ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+icc)
+  # Intel's C compiler understands `-MD -MF file'.  However on
+  #    icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+  # ICC 7.0 will fill foo.d with something like
+  #    foo.o: sub/foo.c
+  #    foo.o: sub/foo.h
+  # which is wrong.  We want:
+  #    sub/foo.o: sub/foo.c
+  #    sub/foo.o: sub/foo.h
+  #    sub/foo.c:
+  #    sub/foo.h:
+  # ICC 7.1 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using \ :
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form `foo.o: dependent.h',
+  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # `$object: dependent.h' and one to simply `dependent.h:'.
+  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
+    sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add `dependent.h:' lines.
+    sed -ne '2,${
+              s/^ *//
+              s/ \\*$//
+              s/$/:/
+              p
+            }' "$tmpdepfile" >> "$depfile"
+  else
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+   # The Tru64 compiler uses -MD to generate dependencies as a side
+   # effect.  `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+   # dependencies in `foo.d' instead, so we check for that too.
+   # Subdirectories are respected.
+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+   test "x$dir" = "x$object" && dir=
+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+
+   if test "$libtool" = yes; then
+      # With Tru64 cc, shared objects can also be used to make a
+      # static library.  This mechanism is used in libtool 1.4 series to
+      # handle both shared and static libraries in a single compilation.
+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+      #
+      # With libtool 1.5 this exception was removed, and libtool now
+      # generates 2 separate objects for the 2 libraries.  These two
+      # compilations output dependencies in $dir.libs/$base.o.d and
+      # in $dir$base.o.d.  We have to check for both files, because
+      # one of the two compilations can be disabled.  We should prefer
+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+      # automatically cleaned when .libs/ is deleted, while ignoring
+      # the former would cause a distcleancheck panic.
+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
+      tmpdepfile2=$dir$base.o.d          # libtool 1.5
+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
+      "$@" -Wc,-MD
+   else
+      tmpdepfile1=$dir$base.o.d
+      tmpdepfile2=$dir$base.d
+      tmpdepfile3=$dir$base.d
+      tmpdepfile4=$dir$base.d
+      "$@" -MD
+   fi
+
+   stat=$?
+   if test $stat -eq 0; then :
+   else
+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+      exit $stat
+   fi
+
+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+   do
+     test -f "$tmpdepfile" && break
+   done
+   if test -f "$tmpdepfile"; then
+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+      # That's a tab and a space in the [].
+      sed -e 's,^.*\.[a-z]*:[   ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+   else
+      echo "#dummy" > "$depfile"
+   fi
+   rm -f "$tmpdepfile"
+   ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove `-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for `:'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
+  "$@" $dashmflag |
+    sed 's:^[  ]*[^: ][^:][^:]*\:[    ]*:'"$object"'\: :' > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  tr ' ' '
+' < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  sed '1,2d' "$tmpdepfile" | tr ' ' '
+' | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove `-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E |
+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+    sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+       set fnord "$@"
+       shift
+       shift
+       ;;
+    *)
+       set fnord "$@" "$arg"
+       shift
+       shift
+       ;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::     \1 \\:p' >> "$depfile"
+  echo "       " >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/contrib/flex/dfa.c b/contrib/flex/dfa.c
new file mode 100644 (file)
index 0000000..b8b68eb
--- /dev/null
@@ -0,0 +1,1096 @@
+/* dfa - DFA construction routines */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+#include "flexdef.h"
+#include "tables.h"
+
+/* declare functions that have forward references */
+
+void dump_associated_rules PROTO ((FILE *, int));
+void dump_transitions PROTO ((FILE *, int[]));
+void sympartition PROTO ((int[], int, int[], int[]));
+int symfollowset PROTO ((int[], int, int, int[]));
+
+
+/* check_for_backing_up - check a DFA state for backing up
+ *
+ * synopsis
+ *     void check_for_backing_up( int ds, int state[numecs] );
+ *
+ * ds is the number of the state to check and state[] is its out-transitions,
+ * indexed by equivalence class.
+ */
+
+void check_for_backing_up (ds, state)
+     int ds;
+     int state[];
+{
+       if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) {      /* state is non-accepting */
+               ++num_backing_up;
+
+               if (backing_up_report) {
+                       fprintf (backing_up_file,
+                                _("State #%d is non-accepting -\n"), ds);
+
+                       /* identify the state */
+                       dump_associated_rules (backing_up_file, ds);
+
+                       /* Now identify it further using the out- and
+                        * jam-transitions.
+                        */
+                       dump_transitions (backing_up_file, state);
+
+                       putc ('\n', backing_up_file);
+               }
+       }
+}
+
+
+/* check_trailing_context - check to see if NFA state set constitutes
+ *                          "dangerous" trailing context
+ *
+ * synopsis
+ *    void check_trailing_context( int nfa_states[num_states+1], int num_states,
+ *                             int accset[nacc+1], int nacc );
+ *
+ * NOTES
+ *  Trailing context is "dangerous" if both the head and the trailing
+ *  part are of variable size \and/ there's a DFA state which contains
+ *  both an accepting state for the head part of the rule and NFA states
+ *  which occur after the beginning of the trailing context.
+ *
+ *  When such a rule is matched, it's impossible to tell if having been
+ *  in the DFA state indicates the beginning of the trailing context or
+ *  further-along scanning of the pattern.  In these cases, a warning
+ *  message is issued.
+ *
+ *    nfa_states[1 .. num_states] is the list of NFA states in the DFA.
+ *    accset[1 .. nacc] is the list of accepting numbers for the DFA state.
+ */
+
+void check_trailing_context (nfa_states, num_states, accset, nacc)
+     int    *nfa_states, num_states;
+     int    *accset;
+     int nacc;
+{
+       register int i, j;
+
+       for (i = 1; i <= num_states; ++i) {
+               int     ns = nfa_states[i];
+               register int type = state_type[ns];
+               register int ar = assoc_rule[ns];
+
+               if (type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE) {   /* do nothing */
+               }
+
+               else if (type == STATE_TRAILING_CONTEXT) {
+                       /* Potential trouble.  Scan set of accepting numbers
+                        * for the one marking the end of the "head".  We
+                        * assume that this looping will be fairly cheap
+                        * since it's rare that an accepting number set
+                        * is large.
+                        */
+                       for (j = 1; j <= nacc; ++j)
+                               if (accset[j] & YY_TRAILING_HEAD_MASK) {
+                                       line_warning (_
+                                                     ("dangerous trailing context"),
+                                                     rule_linenum[ar]);
+                                       return;
+                               }
+               }
+       }
+}
+
+
+/* dump_associated_rules - list the rules associated with a DFA state
+ *
+ * Goes through the set of NFA states associated with the DFA and
+ * extracts the first MAX_ASSOC_RULES unique rules, sorts them,
+ * and writes a report to the given file.
+ */
+
+void dump_associated_rules (file, ds)
+     FILE   *file;
+     int ds;
+{
+       register int i, j;
+       register int num_associated_rules = 0;
+       int     rule_set[MAX_ASSOC_RULES + 1];
+       int    *dset = dss[ds];
+       int     size = dfasiz[ds];
+
+       for (i = 1; i <= size; ++i) {
+               register int rule_num = rule_linenum[assoc_rule[dset[i]]];
+
+               for (j = 1; j <= num_associated_rules; ++j)
+                       if (rule_num == rule_set[j])
+                               break;
+
+               if (j > num_associated_rules) { /* new rule */
+                       if (num_associated_rules < MAX_ASSOC_RULES)
+                               rule_set[++num_associated_rules] =
+                                       rule_num;
+               }
+       }
+
+       qsort (&rule_set [1], num_associated_rules, sizeof (rule_set [1]), intcmp);
+
+       fprintf (file, _(" associated rule line numbers:"));
+
+       for (i = 1; i <= num_associated_rules; ++i) {
+               if (i % 8 == 1)
+                       putc ('\n', file);
+
+               fprintf (file, "\t%d", rule_set[i]);
+       }
+
+       putc ('\n', file);
+}
+
+
+/* dump_transitions - list the transitions associated with a DFA state
+ *
+ * synopsis
+ *     dump_transitions( FILE *file, int state[numecs] );
+ *
+ * Goes through the set of out-transitions and lists them in human-readable
+ * form (i.e., not as equivalence classes); also lists jam transitions
+ * (i.e., all those which are not out-transitions, plus EOF).  The dump
+ * is done to the given file.
+ */
+
+void dump_transitions (file, state)
+     FILE   *file;
+     int state[];
+{
+       register int i, ec;
+       int     out_char_set[CSIZE];
+
+       for (i = 0; i < csize; ++i) {
+               ec = ABS (ecgroup[i]);
+               out_char_set[i] = state[ec];
+       }
+
+       fprintf (file, _(" out-transitions: "));
+
+       list_character_set (file, out_char_set);
+
+       /* now invert the members of the set to get the jam transitions */
+       for (i = 0; i < csize; ++i)
+               out_char_set[i] = !out_char_set[i];
+
+       fprintf (file, _("\n jam-transitions: EOF "));
+
+       list_character_set (file, out_char_set);
+
+       putc ('\n', file);
+}
+
+
+/* epsclosure - construct the epsilon closure of a set of ndfa states
+ *
+ * synopsis
+ *    int *epsclosure( int t[num_states], int *numstates_addr,
+ *                     int accset[num_rules+1], int *nacc_addr,
+ *                     int *hashval_addr );
+ *
+ * NOTES
+ *  The epsilon closure is the set of all states reachable by an arbitrary
+ *  number of epsilon transitions, which themselves do not have epsilon
+ *  transitions going out, unioned with the set of states which have non-null
+ *  accepting numbers.  t is an array of size numstates of nfa state numbers.
+ *  Upon return, t holds the epsilon closure and *numstates_addr is updated.
+ *  accset holds a list of the accepting numbers, and the size of accset is
+ *  given by *nacc_addr.  t may be subjected to reallocation if it is not
+ *  large enough to hold the epsilon closure.
+ *
+ *  hashval is the hash value for the dfa corresponding to the state set.
+ */
+
+int    *epsclosure (t, ns_addr, accset, nacc_addr, hv_addr)
+     int    *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
+{
+       register int stkpos, ns, tsp;
+       int     numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
+       int     stkend, nstate;
+       static int did_stk_init = false, *stk;
+
+#define MARK_STATE(state) \
+do{ trans1[state] = trans1[state] - MARKER_DIFFERENCE;} while(0)
+
+#define IS_MARKED(state) (trans1[state] < 0)
+
+#define UNMARK_STATE(state) \
+do{ trans1[state] = trans1[state] + MARKER_DIFFERENCE;} while(0)
+
+#define CHECK_ACCEPT(state) \
+do{ \
+nfaccnum = accptnum[state]; \
+if ( nfaccnum != NIL ) \
+accset[++nacc] = nfaccnum; \
+}while(0)
+
+#define DO_REALLOCATION() \
+do { \
+current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
+++num_reallocs; \
+t = reallocate_integer_array( t, current_max_dfa_size ); \
+stk = reallocate_integer_array( stk, current_max_dfa_size ); \
+}while(0) \
+
+#define PUT_ON_STACK(state) \
+do { \
+if ( ++stkend >= current_max_dfa_size ) \
+DO_REALLOCATION(); \
+stk[stkend] = state; \
+MARK_STATE(state); \
+}while(0)
+
+#define ADD_STATE(state) \
+do { \
+if ( ++numstates >= current_max_dfa_size ) \
+DO_REALLOCATION(); \
+t[numstates] = state; \
+hashval += state; \
+}while(0)
+
+#define STACK_STATE(state) \
+do { \
+PUT_ON_STACK(state); \
+CHECK_ACCEPT(state); \
+if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
+ADD_STATE(state); \
+}while(0)
+
+
+       if (!did_stk_init) {
+               stk = allocate_integer_array (current_max_dfa_size);
+               did_stk_init = true;
+       }
+
+       nacc = stkend = hashval = 0;
+
+       for (nstate = 1; nstate <= numstates; ++nstate) {
+               ns = t[nstate];
+
+               /* The state could be marked if we've already pushed it onto
+                * the stack.
+                */
+               if (!IS_MARKED (ns)) {
+                       PUT_ON_STACK (ns);
+                       CHECK_ACCEPT (ns);
+                       hashval += ns;
+               }
+       }
+
+       for (stkpos = 1; stkpos <= stkend; ++stkpos) {
+               ns = stk[stkpos];
+               transsym = transchar[ns];
+
+               if (transsym == SYM_EPSILON) {
+                       tsp = trans1[ns] + MARKER_DIFFERENCE;
+
+                       if (tsp != NO_TRANSITION) {
+                               if (!IS_MARKED (tsp))
+                                       STACK_STATE (tsp);
+
+                               tsp = trans2[ns];
+
+                               if (tsp != NO_TRANSITION
+                                   && !IS_MARKED (tsp))
+                                       STACK_STATE (tsp);
+                       }
+               }
+       }
+
+       /* Clear out "visit" markers. */
+
+       for (stkpos = 1; stkpos <= stkend; ++stkpos) {
+               if (IS_MARKED (stk[stkpos]))
+                       UNMARK_STATE (stk[stkpos]);
+               else
+                       flexfatal (_
+                                  ("consistency check failed in epsclosure()"));
+       }
+
+       *ns_addr = numstates;
+       *hv_addr = hashval;
+       *nacc_addr = nacc;
+
+       return t;
+}
+
+
+/* increase_max_dfas - increase the maximum number of DFAs */
+
+void increase_max_dfas ()
+{
+       current_max_dfas += MAX_DFAS_INCREMENT;
+
+       ++num_reallocs;
+
+       base = reallocate_integer_array (base, current_max_dfas);
+       def = reallocate_integer_array (def, current_max_dfas);
+       dfasiz = reallocate_integer_array (dfasiz, current_max_dfas);
+       accsiz = reallocate_integer_array (accsiz, current_max_dfas);
+       dhash = reallocate_integer_array (dhash, current_max_dfas);
+       dss = reallocate_int_ptr_array (dss, current_max_dfas);
+       dfaacc = reallocate_dfaacc_union (dfaacc, current_max_dfas);
+
+       if (nultrans)
+               nultrans =
+                       reallocate_integer_array (nultrans,
+                                                 current_max_dfas);
+}
+
+
+/* ntod - convert an ndfa to a dfa
+ *
+ * Creates the dfa corresponding to the ndfa we've constructed.  The
+ * dfa starts out in state #1.
+ */
+
+void ntod ()
+{
+       int    *accset, ds, nacc, newds;
+       int     sym, hashval, numstates, dsize;
+       int     num_full_table_rows=0;  /* used only for -f */
+       int    *nset, *dset;
+       int     targptr, totaltrans, i, comstate, comfreq, targ;
+       int     symlist[CSIZE + 1];
+       int     num_start_states;
+       int     todo_head, todo_next;
+
+       struct yytbl_data *yynxt_tbl = 0;
+       flex_int32_t *yynxt_data = 0, yynxt_curr = 0;
+
+       /* Note that the following are indexed by *equivalence classes*
+        * and not by characters.  Since equivalence classes are indexed
+        * beginning with 1, even if the scanner accepts NUL's, this
+        * means that (since every character is potentially in its own
+        * equivalence class) these arrays must have room for indices
+        * from 1 to CSIZE, so their size must be CSIZE + 1.
+        */
+       int     duplist[CSIZE + 1], state[CSIZE + 1];
+       int     targfreq[CSIZE + 1], targstate[CSIZE + 1];
+
+       /* accset needs to be large enough to hold all of the rules present
+        * in the input, *plus* their YY_TRAILING_HEAD_MASK variants.
+        */
+       accset = allocate_integer_array ((num_rules + 1) * 2);
+       nset = allocate_integer_array (current_max_dfa_size);
+
+       /* The "todo" queue is represented by the head, which is the DFA
+        * state currently being processed, and the "next", which is the
+        * next DFA state number available (not in use).  We depend on the
+        * fact that snstods() returns DFA's \in increasing order/, and thus
+        * need only know the bounds of the dfas to be processed.
+        */
+       todo_head = todo_next = 0;
+
+       for (i = 0; i <= csize; ++i) {
+               duplist[i] = NIL;
+               symlist[i] = false;
+       }
+
+       for (i = 0; i <= num_rules; ++i)
+               accset[i] = NIL;
+
+       if (trace) {
+               dumpnfa (scset[1]);
+               fputs (_("\n\nDFA Dump:\n\n"), stderr);
+       }
+
+       inittbl ();
+
+       /* Check to see whether we should build a separate table for
+        * transitions on NUL characters.  We don't do this for full-speed
+        * (-F) scanners, since for them we don't have a simple state
+        * number lying around with which to index the table.  We also
+        * don't bother doing it for scanners unless (1) NUL is in its own
+        * equivalence class (indicated by a positive value of
+        * ecgroup[NUL]), (2) NUL's equivalence class is the last
+        * equivalence class, and (3) the number of equivalence classes is
+        * the same as the number of characters.  This latter case comes
+        * about when useecs is false or when it's true but every character
+        * still manages to land in its own class (unlikely, but it's
+        * cheap to check for).  If all these things are true then the
+        * character code needed to represent NUL's equivalence class for
+        * indexing the tables is going to take one more bit than the
+        * number of characters, and therefore we won't be assured of
+        * being able to fit it into a YY_CHAR variable.  This rules out
+        * storing the transitions in a compressed table, since the code
+        * for interpreting them uses a YY_CHAR variable (perhaps it
+        * should just use an integer, though; this is worth pondering ...
+        * ###).
+        *
+        * Finally, for full tables, we want the number of entries in the
+        * table to be a power of two so the array references go fast (it
+        * will just take a shift to compute the major index).  If
+        * encoding NUL's transitions in the table will spoil this, we
+        * give it its own table (note that this will be the case if we're
+        * not using equivalence classes).
+        */
+
+       /* Note that the test for ecgroup[0] == numecs below accomplishes
+        * both (1) and (2) above
+        */
+       if (!fullspd && ecgroup[0] == numecs) {
+               /* NUL is alone in its equivalence class, which is the
+                * last one.
+                */
+               int     use_NUL_table = (numecs == csize);
+
+               if (fulltbl && !use_NUL_table) {
+                       /* We still may want to use the table if numecs
+                        * is a power of 2.
+                        */
+                       int     power_of_two;
+
+                       for (power_of_two = 1; power_of_two <= csize;
+                            power_of_two *= 2)
+                               if (numecs == power_of_two) {
+                                       use_NUL_table = true;
+                                       break;
+                               }
+               }
+
+               if (use_NUL_table)
+                       nultrans =
+                               allocate_integer_array (current_max_dfas);
+
+               /* From now on, nultrans != nil indicates that we're
+                * saving null transitions for later, separate encoding.
+                */
+       }
+
+
+       if (fullspd) {
+               for (i = 0; i <= numecs; ++i)
+                       state[i] = 0;
+
+               place_state (state, 0, 0);
+               dfaacc[0].dfaacc_state = 0;
+       }
+
+       else if (fulltbl) {
+               if (nultrans)
+                       /* We won't be including NUL's transitions in the
+                        * table, so build it for entries from 0 .. numecs - 1.
+                        */
+                       num_full_table_rows = numecs;
+
+               else
+                       /* Take into account the fact that we'll be including
+                        * the NUL entries in the transition table.  Build it
+                        * from 0 .. numecs.
+                        */
+                       num_full_table_rows = numecs + 1;
+
+               /* Begin generating yy_nxt[][]
+                * This spans the entire LONG function.
+                * This table is tricky because we don't know how big it will be.
+                * 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));
+               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 *
+                                           yynxt_tbl->td_hilen,
+                                           sizeof (flex_int32_t));
+               yynxt_curr = 0;
+
+               buf_prints (&yydmap_buf,
+                           "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
+                           long_align ? "flex_int32_t" : "flex_int16_t");
+
+               /* Unless -Ca, declare it "short" because it's a real
+                * long-shot that that won't be large enough.
+                */
+               if (gentables)
+                       out_str_dec
+                               ("static yyconst %s yy_nxt[][%d] =\n    {\n",
+                                long_align ? "flex_int32_t" : "flex_int16_t",
+                                num_full_table_rows);
+               else {
+                       out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
+                       out_str ("static yyconst %s *yy_nxt =0;\n",
+                                long_align ? "flex_int32_t" : "flex_int16_t");
+               }
+
+
+               if (gentables)
+                       outn ("    {");
+
+               /* Generate 0 entries for state #0. */
+               for (i = 0; i < num_full_table_rows; ++i) {
+                       mk2data (0);
+                       yynxt_data[yynxt_curr++] = 0;
+               }
+
+               dataflush ();
+               if (gentables)
+                       outn ("    },\n");
+       }
+
+       /* Create the first states. */
+
+       num_start_states = lastsc * 2;
+
+       for (i = 1; i <= num_start_states; ++i) {
+               numstates = 1;
+
+               /* For each start condition, make one state for the case when
+                * we're at the beginning of the line (the '^' operator) and
+                * one for the case when we're not.
+                */
+               if (i % 2 == 1)
+                       nset[numstates] = scset[(i / 2) + 1];
+               else
+                       nset[numstates] =
+                               mkbranch (scbol[i / 2], scset[i / 2]);
+
+               nset = epsclosure (nset, &numstates, accset, &nacc,
+                                  &hashval);
+
+               if (snstods (nset, numstates, accset, nacc, hashval, &ds)) {
+                       numas += nacc;
+                       totnst += numstates;
+                       ++todo_next;
+
+                       if (variable_trailing_context_rules && nacc > 0)
+                               check_trailing_context (nset, numstates,
+                                                       accset, nacc);
+               }
+       }
+
+       if (!fullspd) {
+               if (!snstods (nset, 0, accset, 0, 0, &end_of_buffer_state))
+                       flexfatal (_
+                                  ("could not create unique end-of-buffer state"));
+
+               ++numas;
+               ++num_start_states;
+               ++todo_next;
+       }
+
+
+       while (todo_head < todo_next) {
+               targptr = 0;
+               totaltrans = 0;
+
+               for (i = 1; i <= numecs; ++i)
+                       state[i] = 0;
+
+               ds = ++todo_head;
+
+               dset = dss[ds];
+               dsize = dfasiz[ds];
+
+               if (trace)
+                       fprintf (stderr, _("state # %d:\n"), ds);
+
+               sympartition (dset, dsize, symlist, duplist);
+
+               for (sym = 1; sym <= numecs; ++sym) {
+                       if (symlist[sym]) {
+                               symlist[sym] = 0;
+
+                               if (duplist[sym] == NIL) {
+                                       /* Symbol has unique out-transitions. */
+                                       numstates =
+                                               symfollowset (dset, dsize,
+                                                             sym, nset);
+                                       nset = epsclosure (nset,
+                                                          &numstates,
+                                                          accset, &nacc,
+                                                          &hashval);
+
+                                       if (snstods
+                                           (nset, numstates, accset, nacc,
+                                            hashval, &newds)) {
+                                               totnst = totnst +
+                                                       numstates;
+                                               ++todo_next;
+                                               numas += nacc;
+
+                                               if (variable_trailing_context_rules && nacc > 0)
+                                                       check_trailing_context
+                                                               (nset,
+                                                                numstates,
+                                                                accset,
+                                                                nacc);
+                                       }
+
+                                       state[sym] = newds;
+
+                                       if (trace)
+                                               fprintf (stderr,
+                                                        "\t%d\t%d\n", sym,
+                                                        newds);
+
+                                       targfreq[++targptr] = 1;
+                                       targstate[targptr] = newds;
+                                       ++numuniq;
+                               }
+
+                               else {
+                                       /* sym's equivalence class has the same
+                                        * transitions as duplist(sym)'s
+                                        * equivalence class.
+                                        */
+                                       targ = state[duplist[sym]];
+                                       state[sym] = targ;
+
+                                       if (trace)
+                                               fprintf (stderr,
+                                                        "\t%d\t%d\n", sym,
+                                                        targ);
+
+                                       /* Update frequency count for
+                                        * destination state.
+                                        */
+
+                                       i = 0;
+                                       while (targstate[++i] != targ) ;
+
+                                       ++targfreq[i];
+                                       ++numdup;
+                               }
+
+                               ++totaltrans;
+                               duplist[sym] = NIL;
+                       }
+               }
+
+
+               numsnpairs += totaltrans;
+
+               if (ds > num_start_states)
+                       check_for_backing_up (ds, state);
+
+               if (nultrans) {
+                       nultrans[ds] = state[NUL_ec];
+                       state[NUL_ec] = 0;      /* remove transition */
+               }
+
+               if (fulltbl) {
+
+                       /* 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,
+                                                    yynxt_tbl->td_hilen *
+                                                    yynxt_tbl->td_lolen *
+                                                    sizeof (flex_int32_t));
+
+
+                       if (gentables)
+                               outn ("    {");
+
+                       /* Supply array's 0-element. */
+                       if (ds == end_of_buffer_state) {
+                               mk2data (-end_of_buffer_state);
+                               yynxt_data[yynxt_curr++] =
+                                       -end_of_buffer_state;
+                       }
+                       else {
+                               mk2data (end_of_buffer_state);
+                               yynxt_data[yynxt_curr++] =
+                                       end_of_buffer_state;
+                       }
+
+                       for (i = 1; i < num_full_table_rows; ++i) {
+                               /* Jams are marked by negative of state
+                                * number.
+                                */
+                               mk2data (state[i] ? state[i] : -ds);
+                               yynxt_data[yynxt_curr++] =
+                                       state[i] ? state[i] : -ds;
+                       }
+
+                       dataflush ();
+                       if (gentables)
+                               outn ("    },\n");
+               }
+
+               else if (fullspd)
+                       place_state (state, ds, totaltrans);
+
+               else if (ds == end_of_buffer_state)
+                       /* Special case this state to make sure it does what
+                        * it's supposed to, i.e., jam on end-of-buffer.
+                        */
+                       stack1 (ds, 0, 0, JAMSTATE);
+
+               else {          /* normal, compressed state */
+
+                       /* Determine which destination state is the most
+                        * common, and how many transitions to it there are.
+                        */
+
+                       comfreq = 0;
+                       comstate = 0;
+
+                       for (i = 1; i <= targptr; ++i)
+                               if (targfreq[i] > comfreq) {
+                                       comfreq = targfreq[i];
+                                       comstate = targstate[i];
+                               }
+
+                       bldtbl (state, ds, totaltrans, comstate, comfreq);
+               }
+       }
+
+       if (fulltbl) {
+               dataend ();
+               if (tablesext) {
+                       yytbl_data_compress (yynxt_tbl);
+                       if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0)
+                               flexerror (_
+                                          ("Could not write yynxt_tbl[][]"));
+               }
+               if (yynxt_tbl) {
+                       yytbl_data_destroy (yynxt_tbl);
+                       yynxt_tbl = 0;
+               }
+       }
+
+       else if (!fullspd) {
+               cmptmps ();     /* create compressed template entries */
+
+               /* Create tables for all the states with only one
+                * out-transition.
+                */
+               while (onesp > 0) {
+                       mk1tbl (onestate[onesp], onesym[onesp],
+                               onenext[onesp], onedef[onesp]);
+                       --onesp;
+               }
+
+               mkdeftbl ();
+       }
+
+       flex_free ((void *) accset);
+       flex_free ((void *) nset);
+}
+
+
+/* snstods - converts a set of ndfa states into a dfa state
+ *
+ * synopsis
+ *    is_new_state = snstods( int sns[numstates], int numstates,
+ *                             int accset[num_rules+1], int nacc,
+ *                             int hashval, int *newds_addr );
+ *
+ * On return, the dfa state number is in newds.
+ */
+
+int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
+     int sns[], numstates, accset[], nacc, hashval, *newds_addr;
+{
+       int     didsort = 0;
+       register int i, j;
+       int     newds, *oldsns;
+
+       for (i = 1; i <= lastdfa; ++i)
+               if (hashval == dhash[i]) {
+                       if (numstates == dfasiz[i]) {
+                               oldsns = dss[i];
+
+                               if (!didsort) {
+                                       /* We sort the states in sns so we
+                                        * can compare it to oldsns quickly.
+                                        */
+                                       qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
+                                       didsort = 1;
+                               }
+
+                               for (j = 1; j <= numstates; ++j)
+                                       if (sns[j] != oldsns[j])
+                                               break;
+
+                               if (j > numstates) {
+                                       ++dfaeql;
+                                       *newds_addr = i;
+                                       return 0;
+                               }
+
+                               ++hshcol;
+                       }
+
+                       else
+                               ++hshsave;
+               }
+
+       /* Make a new dfa. */
+
+       if (++lastdfa >= current_max_dfas)
+               increase_max_dfas ();
+
+       newds = lastdfa;
+
+       dss[newds] = allocate_integer_array (numstates + 1);
+
+       /* If we haven't already sorted the states in sns, we do so now,
+        * so that future comparisons with it can be made quickly.
+        */
+
+       if (!didsort)
+               qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
+
+       for (i = 1; i <= numstates; ++i)
+               dss[newds][i] = sns[i];
+
+       dfasiz[newds] = numstates;
+       dhash[newds] = hashval;
+
+       if (nacc == 0) {
+               if (reject)
+                       dfaacc[newds].dfaacc_set = (int *) 0;
+               else
+                       dfaacc[newds].dfaacc_state = 0;
+
+               accsiz[newds] = 0;
+       }
+
+       else if (reject) {
+               /* We sort the accepting set in increasing order so the
+                * disambiguating rule that the first rule listed is considered
+                * match in the event of ties will work.
+                */
+
+               qsort (&accset [1], nacc, sizeof (accset [1]), intcmp);
+
+               dfaacc[newds].dfaacc_set =
+                       allocate_integer_array (nacc + 1);
+
+               /* Save the accepting set for later */
+               for (i = 1; i <= nacc; ++i) {
+                       dfaacc[newds].dfaacc_set[i] = accset[i];
+
+                       if (accset[i] <= num_rules)
+                               /* Who knows, perhaps a REJECT can yield
+                                * this rule.
+                                */
+                               rule_useful[accset[i]] = true;
+               }
+
+               accsiz[newds] = nacc;
+       }
+
+       else {
+               /* Find lowest numbered rule so the disambiguating rule
+                * will work.
+                */
+               j = num_rules + 1;
+
+               for (i = 1; i <= nacc; ++i)
+                       if (accset[i] < j)
+                               j = accset[i];
+
+               dfaacc[newds].dfaacc_state = j;
+
+               if (j <= num_rules)
+                       rule_useful[j] = true;
+       }
+
+       *newds_addr = newds;
+
+       return 1;
+}
+
+
+/* symfollowset - follow the symbol transitions one step
+ *
+ * synopsis
+ *    numstates = symfollowset( int ds[current_max_dfa_size], int dsize,
+ *                             int transsym, int nset[current_max_dfa_size] );
+ */
+
+int symfollowset (ds, dsize, transsym, nset)
+     int ds[], dsize, transsym, nset[];
+{
+       int     ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
+
+       numstates = 0;
+
+       for (i = 1; i <= dsize; ++i) {  /* for each nfa state ns in the state set of ds */
+               ns = ds[i];
+               sym = transchar[ns];
+               tsp = trans1[ns];
+
+               if (sym < 0) {  /* it's a character class */
+                       sym = -sym;
+                       ccllist = cclmap[sym];
+                       lenccl = ccllen[sym];
+
+                       if (cclng[sym]) {
+                               for (j = 0; j < lenccl; ++j) {
+                                       /* Loop through negated character
+                                        * class.
+                                        */
+                                       ch = ccltbl[ccllist + j];
+
+                                       if (ch == 0)
+                                               ch = NUL_ec;
+
+                                       if (ch > transsym)
+                                               /* Transsym isn't in negated
+                                                * ccl.
+                                                */
+                                               break;
+
+                                       else if (ch == transsym)
+                                               /* next 2 */
+                                               goto bottom;
+                               }
+
+                               /* Didn't find transsym in ccl. */
+                               nset[++numstates] = tsp;
+                       }
+
+                       else
+                               for (j = 0; j < lenccl; ++j) {
+                                       ch = ccltbl[ccllist + j];
+
+                                       if (ch == 0)
+                                               ch = NUL_ec;
+
+                                       if (ch > transsym)
+                                               break;
+                                       else if (ch == transsym) {
+                                               nset[++numstates] = tsp;
+                                               break;
+                                       }
+                               }
+               }
+
+               else if (sym == SYM_EPSILON) {  /* do nothing */
+               }
+
+               else if (ABS (ecgroup[sym]) == transsym)
+                       nset[++numstates] = tsp;
+
+             bottom:;
+       }
+
+       return numstates;
+}
+
+
+/* sympartition - partition characters with same out-transitions
+ *
+ * synopsis
+ *    sympartition( int ds[current_max_dfa_size], int numstates,
+ *                     int symlist[numecs], int duplist[numecs] );
+ */
+
+void sympartition (ds, numstates, symlist, duplist)
+     int ds[], numstates;
+     int symlist[], duplist[];
+{
+       int     tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
+
+       /* Partitioning is done by creating equivalence classes for those
+        * characters which have out-transitions from the given state.  Thus
+        * we are really creating equivalence classes of equivalence classes.
+        */
+
+       for (i = 1; i <= numecs; ++i) { /* initialize equivalence class list */
+               duplist[i] = i - 1;
+               dupfwd[i] = i + 1;
+       }
+
+       duplist[1] = NIL;
+       dupfwd[numecs] = NIL;
+
+       for (i = 1; i <= numstates; ++i) {
+               ns = ds[i];
+               tch = transchar[ns];
+
+               if (tch != SYM_EPSILON) {
+                       if (tch < -lastccl || tch >= csize) {
+                               flexfatal (_
+                                          ("bad transition character detected in sympartition()"));
+                       }
+
+                       if (tch >= 0) { /* character transition */
+                               int     ec = ecgroup[tch];
+
+                               mkechar (ec, dupfwd, duplist);
+                               symlist[ec] = 1;
+                       }
+
+                       else {  /* character class */
+                               tch = -tch;
+
+                               lenccl = ccllen[tch];
+                               cclp = cclmap[tch];
+                               mkeccl (ccltbl + cclp, lenccl, dupfwd,
+                                       duplist, numecs, NUL_ec);
+
+                               if (cclng[tch]) {
+                                       j = 0;
+
+                                       for (k = 0; k < lenccl; ++k) {
+                                               ich = ccltbl[cclp + k];
+
+                                               if (ich == 0)
+                                                       ich = NUL_ec;
+
+                                               for (++j; j < ich; ++j)
+                                                       symlist[j] = 1;
+                                       }
+
+                                       for (++j; j <= numecs; ++j)
+                                               symlist[j] = 1;
+                               }
+
+                               else
+                                       for (k = 0; k < lenccl; ++k) {
+                                               ich = ccltbl[cclp + k];
+
+                                               if (ich == 0)
+                                                       ich = NUL_ec;
+
+                                               symlist[ich] = 1;
+                                       }
+                       }
+               }
+       }
+}
diff --git a/contrib/flex/doc/flex.1 b/contrib/flex/doc/flex.1
new file mode 100644 (file)
index 0000000..256b02b
--- /dev/null
@@ -0,0 +1,165 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.37.1.
+.TH FLEX "1" "July 2012" "flex 2.5.36" "User Commands"
+.SH NAME
+flex \- the fast lexical analyser generator
+.SH SYNOPSIS
+.B flex
+[\fIOPTIONS\fR] [\fIFILE\fR]...
+.SH DESCRIPTION
+Generates programs that perform pattern\-matching on text.
+.SS "Table Compression:"
+.TP
+\fB\-Ca\fR, \fB\-\-align\fR
+trade off larger tables for better memory alignment
+.TP
+\fB\-Ce\fR, \fB\-\-ecs\fR
+construct equivalence classes
+.TP
+\fB\-Cf\fR
+do not compress tables; use \fB\-f\fR representation
+.TP
+\fB\-CF\fR
+do not compress tables; use \fB\-F\fR representation
+.TP
+\fB\-Cm\fR, \fB\-\-meta\-ecs\fR
+construct meta\-equivalence classes
+.TP
+\fB\-Cr\fR, \fB\-\-read\fR
+use read() instead of stdio for scanner input
+.TP
+\fB\-f\fR, \fB\-\-full\fR
+generate fast, large scanner. Same as \fB\-Cfr\fR
+.TP
+\fB\-F\fR, \fB\-\-fast\fR
+use alternate table representation. Same as \fB\-CFr\fR
+.TP
+\fB\-Cem\fR
+default compression (same as \fB\-\-ecs\fR \fB\-\-meta\-ecs\fR)
+.SS "Debugging:"
+.TP
+\fB\-d\fR, \fB\-\-debug\fR
+enable debug mode in scanner
+.TP
+\fB\-b\fR, \fB\-\-backup\fR
+write backing\-up information to lex.backup
+.TP
+\fB\-p\fR, \fB\-\-perf\-report\fR
+write performance report to stderr
+.TP
+\fB\-s\fR, \fB\-\-nodefault\fR
+suppress default rule to ECHO unmatched text
+.TP
+\fB\-T\fR, \fB\-\-trace\fR
+flex should run in trace mode
+.TP
+\fB\-w\fR, \fB\-\-nowarn\fR
+do not generate warnings
+.TP
+\fB\-v\fR, \fB\-\-verbose\fR
+write summary of scanner statistics to stdout
+.SS "Files:"
+.TP
+\fB\-o\fR, \fB\-\-outfile\fR=\fIFILE\fR
+specify output filename
+.TP
+\fB\-S\fR, \fB\-\-skel\fR=\fIFILE\fR
+specify skeleton file
+.TP
+\fB\-t\fR, \fB\-\-stdout\fR
+write scanner on stdout instead of lex.yy.c
+.TP
+\fB\-\-yyclass\fR=\fINAME\fR
+name of C++ class
+.TP
+\fB\-\-header\-file\fR=\fIFILE\fR
+create a C header file in addition to the scanner
+.HP
+\fB\-\-tables\-file\fR[=\fIFILE\fR] write tables to FILE
+.SS "Scanner behavior:"
+.TP
+\fB\-7\fR, \fB\-\-7bit\fR
+generate 7\-bit scanner
+.TP
+\fB\-8\fR, \fB\-\-8bit\fR
+generate 8\-bit scanner
+.TP
+\fB\-B\fR, \fB\-\-batch\fR
+generate batch scanner (opposite of \fB\-I\fR)
+.TP
+\fB\-i\fR, \fB\-\-case\-insensitive\fR
+ignore case in patterns
+.TP
+\fB\-l\fR, \fB\-\-lex\-compat\fR
+maximal compatibility with original lex
+.TP
+\fB\-X\fR, \fB\-\-posix\-compat\fR
+maximal compatibility with POSIX lex
+.TP
+\fB\-I\fR, \fB\-\-interactive\fR
+generate interactive scanner (opposite of \fB\-B\fR)
+.TP
+\fB\-\-yylineno\fR
+track line count in yylineno
+.SS "Generated code:"
+.TP
+\-+,  \fB\-\-c\fR++
+generate C++ scanner class
+.TP
+\fB\-Dmacro\fR[=\fIdefn\fR]
+#define macro defn  (default defn is '1')
+.TP
+\fB\-L\fR,  \fB\-\-noline\fR
+suppress #line directives in scanner
+.TP
+\fB\-P\fR,  \fB\-\-prefix\fR=\fISTRING\fR
+use STRING as prefix instead of "yy"
+.TP
+\fB\-R\fR,  \fB\-\-reentrant\fR
+generate a reentrant C scanner
+.TP
+\fB\-\-bison\-bridge\fR
+scanner for bison pure parser.
+.TP
+\fB\-\-bison\-locations\fR
+include yylloc support.
+.TP
+\fB\-\-stdinit\fR
+initialize yyin/yyout to stdin/stdout
+.HP
+\fB\-\-noansi\-definitions\fR old\-style function definitions
+.TP
+\fB\-\-noansi\-prototypes\fR
+empty parameter list in prototypes
+.TP
+\fB\-\-nounistd\fR
+do not include <unistd.h>
+.TP
+\fB\-\-noFUNCTION\fR
+do not generate a particular FUNCTION
+.SS "Miscellaneous:"
+.TP
+\fB\-c\fR
+do\-nothing POSIX option
+.TP
+\fB\-n\fR
+do\-nothing POSIX option
+.HP
+\-?
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+produce this help message
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+report flex version
+.SH "SEE ALSO"
+The full documentation for
+.B flex
+is maintained as a Texinfo manual.  If the
+.B info
+and
+.B flex
+programs are properly installed at your site, the command
+.IP
+.B info flex
+.PP
+should give you access to the complete manual.
diff --git a/contrib/flex/ecs.c b/contrib/flex/ecs.c
new file mode 100644 (file)
index 0000000..e2abbe4
--- /dev/null
@@ -0,0 +1,219 @@
+/* ecs - equivalence class routines */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/* This file is part of flex */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+
+#include "flexdef.h"
+
+/* ccl2ecl - convert character classes to set of equivalence classes */
+
+void    ccl2ecl ()
+{
+       int     i, ich, newlen, cclp, ccls, cclmec;
+
+       for (i = 1; i <= lastccl; ++i) {
+               /* We loop through each character class, and for each character
+                * in the class, add the character's equivalence class to the
+                * new "character" class we are creating.  Thus when we are all
+                * done, character classes will really consist of collections
+                * of equivalence classes
+                */
+
+               newlen = 0;
+               cclp = cclmap[i];
+
+               for (ccls = 0; ccls < ccllen[i]; ++ccls) {
+                       ich = ccltbl[cclp + ccls];
+                       cclmec = ecgroup[ich];
+
+                       if (cclmec > 0) {
+                               ccltbl[cclp + newlen] = cclmec;
+                               ++newlen;
+                       }
+               }
+
+               ccllen[i] = newlen;
+       }
+}
+
+
+/* cre8ecs - associate equivalence class numbers with class members
+ *
+ * fwd is the forward linked-list of equivalence class members.  bck
+ * is the backward linked-list, and num is the number of class members.
+ *
+ * Returned is the number of classes.
+ */
+
+int     cre8ecs (fwd, bck, num)
+     int     fwd[], bck[], num;
+{
+       int     i, j, numcl;
+
+       numcl = 0;
+
+       /* Create equivalence class numbers.  From now on, ABS( bck(x) )
+        * is the equivalence class number for object x.  If bck(x)
+        * is positive, then x is the representative of its equivalence
+        * class.
+        */
+       for (i = 1; i <= num; ++i)
+               if (bck[i] == NIL) {
+                       bck[i] = ++numcl;
+                       for (j = fwd[i]; j != NIL; j = fwd[j])
+                               bck[j] = -numcl;
+               }
+
+       return numcl;
+}
+
+
+/* mkeccl - update equivalence classes based on character class xtions
+ *
+ * synopsis
+ *    Char ccls[];
+ *    int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
+ *    void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
+ *                     int llsiz, int NUL_mapping );
+ *
+ * ccls contains the elements of the character class, lenccl is the
+ * number of elements in the ccl, fwd is the forward link-list of equivalent
+ * characters, bck is the backward link-list, and llsiz size of the link-list.
+ *
+ * NUL_mapping is the value which NUL (0) should be mapped to.
+ */
+
+void    mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
+     Char    ccls[];
+     int     lenccl, fwd[], bck[], llsiz, NUL_mapping;
+{
+       int     cclp, oldec, newec;
+       int     cclm, i, j;
+       static unsigned char cclflags[CSIZE];   /* initialized to all '\0' */
+
+       /* Note that it doesn't matter whether or not the character class is
+        * negated.  The same results will be obtained in either case.
+        */
+
+       cclp = 0;
+
+       while (cclp < lenccl) {
+               cclm = ccls[cclp];
+
+               if (NUL_mapping && cclm == 0)
+                       cclm = NUL_mapping;
+
+               oldec = bck[cclm];
+               newec = cclm;
+
+               j = cclp + 1;
+
+               for (i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i]) {       /* look for the symbol in the character class */
+                       for (; j < lenccl; ++j) {
+                               register int ccl_char;
+
+                               if (NUL_mapping && ccls[j] == 0)
+                                       ccl_char = NUL_mapping;
+                               else
+                                       ccl_char = ccls[j];
+
+                               if (ccl_char > i)
+                                       break;
+
+                               if (ccl_char == i && !cclflags[j]) {
+                                       /* We found an old companion of cclm
+                                        * in the ccl.  Link it into the new
+                                        * equivalence class and flag it as
+                                        * having been processed.
+                                        */
+
+                                       bck[i] = newec;
+                                       fwd[newec] = i;
+                                       newec = i;
+                                       /* Set flag so we don't reprocess. */
+                                       cclflags[j] = 1;
+
+                                       /* Get next equivalence class member. */
+                                       /* continue 2 */
+                                       goto next_pt;
+                               }
+                       }
+
+                       /* Symbol isn't in character class.  Put it in the old
+                        * equivalence class.
+                        */
+
+                       bck[i] = oldec;
+
+                       if (oldec != NIL)
+                               fwd[oldec] = i;
+
+                       oldec = i;
+
+                     next_pt:;
+               }
+
+               if (bck[cclm] != NIL || oldec != bck[cclm]) {
+                       bck[cclm] = NIL;
+                       fwd[oldec] = NIL;
+               }
+
+               fwd[newec] = NIL;
+
+               /* Find next ccl member to process. */
+
+               for (++cclp; cclflags[cclp] && cclp < lenccl; ++cclp) {
+                       /* Reset "doesn't need processing" flag. */
+                       cclflags[cclp] = 0;
+               }
+       }
+}
+
+
+/* mkechar - create equivalence class for single character */
+
+void    mkechar (tch, fwd, bck)
+     int     tch, fwd[], bck[];
+{
+       /* If until now the character has been a proper subset of
+        * an equivalence class, break it away to create a new ec
+        */
+
+       if (fwd[tch] != NIL)
+               bck[fwd[tch]] = bck[tch];
+
+       if (bck[tch] != NIL)
+               fwd[bck[tch]] = fwd[tch];
+
+       fwd[tch] = NIL;
+       bck[tch] = NIL;
+}
diff --git a/contrib/flex/filter.c b/contrib/flex/filter.c
new file mode 100644 (file)
index 0000000..c82f7f8
--- /dev/null
@@ -0,0 +1,444 @@
+/* filter - postprocessing of flex output through filters */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+#include "flexdef.h"
+static const char * check_4_gnu_m4 =
+    "m4_dnl ifdef(`__gnu__', ,"
+    "`errprint(Flex requires GNU M4. Set the PATH or set the M4 environment variable to its path name.)"
+    " m4exit(2)')\n";
+
+
+/** global chain. */
+struct filter *output_chain = NULL;
+
+/* Allocate and initialize an external filter.
+ * @param chain the current chain or NULL for new chain
+ * @param cmd the command to execute.
+ * @param ... a NULL terminated list of (const char*) arguments to command,
+ *            not including argv[0].
+ * @return newest filter in chain
+ */
+struct filter *filter_create_ext (struct filter *chain, const char *cmd,
+                                 ...)
+{
+       struct filter *f;
+       int     max_args;
+       const char *s;
+       va_list ap;
+
+       /* allocate and initialize new filter */
+       f = (struct filter *) flex_alloc (sizeof (struct filter));
+       if (!f)
+               flexerror (_("flex_alloc failed (f) in filter_create_ext"));
+       memset (f, 0, sizeof (*f));
+       f->filter_func = NULL;
+       f->extra = NULL;
+       f->next = NULL;
+       f->argc = 0;
+
+       if (chain != NULL) {
+               /* append f to end of chain */
+               while (chain->next)
+                       chain = chain->next;
+               chain->next = f;
+       }
+
+
+       /* allocate argv, and populate it with the argument list. */
+       max_args = 8;
+       f->argv =
+               (const char **) flex_alloc (sizeof (char *) *
+                                           (max_args + 1));
+       if (!f->argv)
+               flexerror (_("flex_alloc 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[f->argc++] = s;
+       }
+       f->argv[f->argc] = NULL;
+
+       va_end (ap);
+       return f;
+}
+
+/* Allocate and initialize an internal filter.
+ * @param chain the current chain or NULL for new chain
+ * @param filter_func The function that will perform the filtering.
+ *        filter_func should return 0 if successful, and -1
+ *        if an error occurs -- or it can simply exit().
+ * @param extra optional user-defined data to pass to the filter.
+ * @return newest filter in chain
+ */
+struct filter *filter_create_int (struct filter *chain,
+                                 int (*filter_func) (struct filter *),
+                                 void *extra)
+{
+       struct filter *f;
+
+       /* allocate and initialize new filter */
+       f = (struct filter *) flex_alloc (sizeof (struct filter));
+       if (!f)
+               flexerror (_("flex_alloc failed in filter_create_int"));
+       memset (f, 0, sizeof (*f));
+       f->next = NULL;
+       f->argc = 0;
+       f->argv = NULL;
+
+       f->filter_func = filter_func;
+       f->extra = extra;
+
+       if (chain != NULL) {
+               /* append f to end of chain */
+               while (chain->next)
+                       chain = chain->next;
+               chain->next = f;
+       }
+
+       return f;
+}
+
+/** Fork and exec entire filter chain.
+ *  @param chain The head of the chain.
+ *  @return true on success.
+ */
+bool filter_apply_chain (struct filter * chain)
+{
+       int     pid, pipes[2];
+       int     r;
+       const int readsz = 512;
+       char   *buf;
+
+
+       /* Tricky recursion, since we want to begin the chain
+        * at the END. Why? Because we need all the forked processes
+        * to be children of the main flex process.
+        */
+       if (chain)
+               filter_apply_chain (chain->next);
+       else
+               return true;
+
+       /* Now we are the right-most unprocessed link in the chain.
+        */
+
+       fflush (stdout);
+       fflush (stderr);
+
+
+       if (pipe (pipes) == -1)
+               flexerror (_("pipe failed"));
+
+       if ((pid = fork ()) == -1)
+               flexerror (_("fork failed"));
+
+       if (pid == 0) {
+               /* child */
+
+        /* We need stdin (the FILE* stdin) to connect to this new pipe.
+         * There is no portable way to set stdin to a new file descriptor,
+         * as stdin is not an lvalue on some systems (BSD).
+         * So we dup the new pipe onto the stdin descriptor and use a no-op fseek
+         * to sync the stream. This is a Hail Mary situation. It seems to work.
+         */
+               close (pipes[1]);
+clearerr(stdin);
+               if (dup2 (pipes[0], fileno (stdin)) == -1)
+                       flexfatal (_("dup2(pipes[0],0)"));
+               close (pipes[0]);
+        fseek (stdin, 0, SEEK_CUR);
+
+               /* run as a filter, either internally or by exec */
+               if (chain->filter_func) {
+                       int     r;
+
+                       if ((r = chain->filter_func (chain)) == -1)
+                               flexfatal (_("filter_func failed"));
+                       exit (0);
+               }
+               else {
+                       execvp (chain->argv[0],
+                               (char **const) (chain->argv));
+            lerrsf_fatal ( _("exec of %s failed"),
+                    chain->argv[0]);
+               }
+
+               exit (1);
+       }
+
+       /* Parent */
+       close (pipes[0]);
+       if (dup2 (pipes[1], fileno (stdout)) == -1)
+               flexfatal (_("dup2(pipes[1],1)"));
+       close (pipes[1]);
+    fseek (stdout, 0, SEEK_CUR);
+
+       return true;
+}
+
+/** Truncate the chain to max_len number of filters.
+ * @param chain the current chain.
+ * @param max_len the maximum length of the chain.
+ * @return the resulting length of the chain.
+ */
+int filter_truncate (struct filter *chain, int max_len)
+{
+       int     len = 1;
+
+       if (!chain)
+               return 0;
+
+       while (chain->next && len < max_len) {
+               chain = chain->next;
+               ++len;
+       }
+
+       chain->next = NULL;
+       return len;
+}
+
+/** Splits the chain in order to write to a header file.
+ *  Similar in spirit to the 'tee' program.
+ *  The header file name is in extra.
+ *  @return 0 (zero) on success, and -1 on failure.
+ */
+int filter_tee_header (struct filter *chain)
+{
+       /* This function reads from stdin and writes to both the C file and the
+        * header file at the same time.
+        */
+
+       const int readsz = 512;
+       char   *buf;
+       int     to_cfd = -1;
+       FILE   *to_c = NULL, *to_h = NULL;
+       bool    write_header;
+
+       write_header = (chain->extra != NULL);
+
+       /* Store a copy of the stdout pipe, which is already piped to C file
+        * through the running chain. Then create a new pipe to the H file as
+        * stdout, and fork the rest of the chain again.
+        */
+
+       if ((to_cfd = dup (1)) == -1)
+               flexfatal (_("dup(1) failed"));
+       to_c = fdopen (to_cfd, "w");
+
+       if (write_header) {
+               if (freopen ((char *) chain->extra, "w", stdout) == NULL)
+                       flexfatal (_("freopen(headerfilename) failed"));
+
+               filter_apply_chain (chain->next);
+               to_h = stdout;
+       }
+
+       /* Now to_c is a pipe to the C branch, and to_h is a pipe to the H branch.
+        */
+
+       if (write_header) {
+        fputs (check_4_gnu_m4, to_h);
+               fputs ("m4_changecom`'m4_dnl\n", to_h);
+               fputs ("m4_changequote`'m4_dnl\n", to_h);
+               fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_h);
+           fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_h);
+               fputs ("m4_define( [[M4_YY_IN_HEADER]],[[]])m4_dnl\n",
+                      to_h);
+               fprintf (to_h, "#ifndef %sHEADER_H\n", prefix);
+               fprintf (to_h, "#define %sHEADER_H 1\n", prefix);
+               fprintf (to_h, "#define %sIN_HEADER 1\n\n", prefix);
+               fprintf (to_h,
+                        "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
+                        headerfilename ? headerfilename : "<stdout>");
+
+       }
+
+    fputs (check_4_gnu_m4, to_c);
+       fputs ("m4_changecom`'m4_dnl\n", to_c);
+       fputs ("m4_changequote`'m4_dnl\n", to_c);
+       fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_c);
+       fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_c);
+       fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
+                outfilename ? outfilename : "<stdout>");
+
+       buf = (char *) flex_alloc (readsz);
+       if (!buf)
+               flexerror (_("flex_alloc failed in filter_tee_header"));
+       while (fgets (buf, readsz, stdin)) {
+               fputs (buf, to_c);
+               if (write_header)
+                       fputs (buf, to_h);
+       }
+
+       if (write_header) {
+               fprintf (to_h, "\n");
+
+               /* write a fake line number. It will get fixed by the linedir filter. */
+               fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");
+
+               fprintf (to_h, "#undef %sIN_HEADER\n", prefix);
+               fprintf (to_h, "#endif /* %sHEADER_H */\n", prefix);
+               fputs ("m4_undefine( [[M4_YY_IN_HEADER]])m4_dnl\n", to_h);
+
+               fflush (to_h);
+               if (ferror (to_h))
+                       lerrsf (_("error writing output file %s"),
+                               (char *) chain->extra);
+
+               else if (fclose (to_h))
+                       lerrsf (_("error closing output file %s"),
+                               (char *) chain->extra);
+       }
+
+       fflush (to_c);
+       if (ferror (to_c))
+               lerrsf (_("error writing output file %s"),
+                       outfilename ? outfilename : "<stdout>");
+
+       else if (fclose (to_c))
+               lerrsf (_("error closing output file %s"),
+                       outfilename ? outfilename : "<stdout>");
+
+       while (wait (0) > 0) ;
+
+       exit (0);
+       return 0;
+}
+
+/** Adjust the line numbers in the #line directives of the generated scanner.
+ * After the m4 expansion, the line numbers are incorrect since the m4 macros
+ * can add or remove lines.  This only adjusts line numbers for generated code,
+ * not user code. This also happens to be a good place to squeeze multiple
+ * blank lines into a single blank line.
+ */
+int filter_fix_linedirs (struct filter *chain)
+{
+       char   *buf;
+       const int readsz = 512;
+       int     lineno = 1;
+       bool    in_gen = true;  /* in generated code */
+       bool    last_was_blank = false;
+
+       if (!chain)
+               return 0;
+
+       buf = (char *) flex_alloc (readsz);
+       if (!buf)
+               flexerror (_("flex_alloc failed in filter_fix_linedirs"));
+
+       while (fgets (buf, readsz, stdin)) {
+
+               regmatch_t m[10];
+
+               /* Check for #line directive. */
+               if (buf[0] == '#'
+                       && regexec (&regex_linedir, buf, 3, m, 0) == 0) {
+
+                       int     num;
+                       char   *fname;
+
+                       /* extract the line number and filename */
+                       num = regmatch_strtol (&m[1], buf, NULL, 0);
+                       fname = regmatch_dup (&m[2], buf);
+
+                       if (strcmp (fname,
+                               outfilename ? outfilename : "<stdout>")
+                                       == 0
+                        || strcmp (fname,
+                               headerfilename ? headerfilename : "<stdout>")
+                                       == 0) {
+
+                               char    *s1, *s2;
+                               char    filename[MAXLINE];
+
+                               s1 = fname;
+                               s2 = filename;
+
+                               while ((s2 - filename) < (MAXLINE - 1) && *s1) {
+                                       /* Escape the backslash */
+                                       if (*s1 == '\\')
+                                               *s2++ = '\\';
+                                       /* Escape the double quote */
+                                       if (*s1 == '\"')
+                                               *s2++ = '\\';
+                                       /* Copy the character as usual */
+                                       *s2++ = *s1++;
+                               }
+
+                               *s2 = '\0';
+
+                               /* Adjust the line directives. */
+                               in_gen = true;
+                               snprintf (buf, readsz, "#line %d \"%s\"\n",
+                                         lineno + 1, filename);
+                       }
+                       else {
+                               /* it's a #line directive for code we didn't write */
+                               in_gen = false;
+                       }
+
+                       free (fname);
+                       last_was_blank = false;
+               }
+
+               /* squeeze blank lines from generated code */
+               else if (in_gen
+                        && regexec (&regex_blank_line, buf, 0, NULL,
+                                    0) == 0) {
+                       if (last_was_blank)
+                               continue;
+                       else
+                               last_was_blank = true;
+               }
+
+               else {
+                       /* it's a line of normal, non-empty code. */
+                       last_was_blank = false;
+               }
+
+               fputs (buf, stdout);
+               lineno++;
+       }
+       fflush (stdout);
+       if (ferror (stdout))
+               lerrsf (_("error writing output file %s"),
+                       outfilename ? outfilename : "<stdout>");
+
+       else if (fclose (stdout))
+               lerrsf (_("error closing output file %s"),
+                       outfilename ? outfilename : "<stdout>");
+
+       return 0;
+}
+
+/* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */
diff --git a/contrib/flex/flex.skl b/contrib/flex/flex.skl
new file mode 100644 (file)
index 0000000..01d8204
--- /dev/null
@@ -0,0 +1,3432 @@
+%# -*-C-*- vi: set ft=c:
+%# This file is processed in several stages.
+%# Here are the stages, as best as I can describe:
+%#
+%#   1. flex.skl is processed through GNU m4 during the
+%#      pre-compilation stage of flex. Only macros starting
+%#      with `m4preproc_' are processed, and quoting is normal.
+%#
+%#   2. The preprocessed skeleton is translated verbatim into a
+%#      C array, saved as "skel.c" and compiled into the flex binary.
+%#
+%#   3. At runtime, the skeleton is generated and filtered (again)
+%#      through m4. Macros beginning with `m4_' will be processed.
+%#      The quoting is "[[" and "]]" so we don't interfere with
+%#      user code.
+%# 
+%# All generate macros for the m4 stage contain the text "m4" or "M4"
+%# in them. This is to distinguish them from CPP macros.
+%# The exception to this rule is YY_G, which is an m4 macro, 
+%# but it needs to be remain short because it is used everywhere.
+%#
+/* A lexical scanner generated by flex */
+
+%#  Macros for preproc stage.
+m4preproc_changecom
+
+%# Macros for runtime processing stage.
+m4_changecom
+m4_changequote
+m4_changequote([[, ]])
+
+%# 
+%# Lines in this skeleton starting with a "%" character are "control lines"
+%# and affect the generation of the scanner. The possible control codes are
+%# listed and processed in misc.c.
+%#
+%#   %#  -  A comment. The current line is omitted from the generated scanner.
+%#   %if-c++-only  -  The following lines are printed for C++ scanners ONLY.
+%#   %if-c-only    -  The following lines are NOT printed for C++ scanners.
+%#   %if-c-or-c++  -  The following lines are printed in BOTH C and C++ scanners.
+%#   %if-reentrant     - Print for reentrant scanners.(push)
+%#   %if-not-reentrant - Print for non-reentrant scanners. (push)
+%#   %if-bison-bridge  - Print for bison-bridge. (push)
+%#   %if-not-bison-bridge  - Print for non-bison-bridge. (push)
+%#   %endif        - pop from the previous if code.
+%#   %%  -  A stop-point, where code is inserted by flex.
+%#          Each stop-point is numbered here and also in the code generator.
+%#          (See gen.c, etc. for details.)
+%#   %not-for-header  -  Begin code that should NOT appear in a ".h" file.
+%#   %ok-for-header   -  %c and %e are used for building a header file.
+%#   %if-tables-serialization
+%#
+%#   All control-lines EXCEPT comment lines ("%#") will be inserted into
+%#   the generated scanner as a C-style comment. This is to aid those who
+%#   edit the skeleton.
+%#
+
+%not-for-header
+%if-c-only
+%if-not-reentrant
+m4_ifelse(M4_YY_PREFIX,yy,,
+#define yy_create_buffer M4_YY_PREFIX[[_create_buffer]]
+#define yy_delete_buffer M4_YY_PREFIX[[_delete_buffer]]
+#define yy_flex_debug M4_YY_PREFIX[[_flex_debug]]
+#define yy_init_buffer M4_YY_PREFIX[[_init_buffer]]
+#define yy_flush_buffer M4_YY_PREFIX[[_flush_buffer]]
+#define yy_load_buffer_state M4_YY_PREFIX[[_load_buffer_state]]
+#define yy_switch_to_buffer M4_YY_PREFIX[[_switch_to_buffer]]
+#define yyin M4_YY_PREFIX[[in]]
+#define yyleng M4_YY_PREFIX[[leng]]
+#define yylex M4_YY_PREFIX[[lex]]
+#define yylineno M4_YY_PREFIX[[lineno]]
+#define yyout M4_YY_PREFIX[[out]]
+#define yyrestart M4_YY_PREFIX[[restart]]
+#define yytext M4_YY_PREFIX[[text]]
+#define yywrap M4_YY_PREFIX[[wrap]]
+#define yyalloc M4_YY_PREFIX[[alloc]]
+#define yyrealloc M4_YY_PREFIX[[realloc]]
+#define yyfree M4_YY_PREFIX[[free]]
+)
+%endif
+%endif
+%ok-for-header
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION FLEX_MAJOR_VERSION
+#define YY_FLEX_MINOR_VERSION FLEX_MINOR_VERSION
+#define YY_FLEX_SUBMINOR_VERSION FLEX_SUBMINOR_VERSION
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+%# Some negated symbols
+m4_ifdef( [[M4_YY_IN_HEADER]], , [[m4_define([[M4_YY_NOT_IN_HEADER]], [[]])]])
+m4_ifdef( [[M4_YY_REENTRANT]], , [[m4_define([[M4_YY_NOT_REENTRANT]], [[]])]])
+
+%# This is the m4 way to say "(stack_used || is_reentrant)
+m4_ifdef( [[M4_YY_STACK_USED]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])
+m4_ifdef( [[M4_YY_REENTRANT]],  [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])
+
+%# Prefixes.
+%# The complexity here is necessary so that m4 preserves
+%# the argument lists to each C function.
+
+
+m4_ifdef( [[M4_YY_PREFIX]],, [[m4_define([[M4_YY_PREFIX]], [[yy]])]])
+
+m4preproc_define(`M4_GEN_PREFIX',
+    ``m4_define(yy[[$1]], [[M4_YY_PREFIX[[$1]]m4_ifelse($'`#,0,,[[($'`@)]])]])'')
+
+%if-c++-only
+    /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
+     * following macro. This is required in order to pass the c++-multiple-scanners
+     * test in the regression suite. We get reports that it breaks inheritance.
+     * We will address this in a future release of flex, or omit the C++ scanner
+     * altogether.
+     */
+    #define yyFlexLexer M4_YY_PREFIX[[FlexLexer]]
+%endif
+
+%if-c-only
+    M4_GEN_PREFIX(`_create_buffer')
+    M4_GEN_PREFIX(`_delete_buffer')
+    M4_GEN_PREFIX(`_scan_buffer')
+    M4_GEN_PREFIX(`_scan_string')
+    M4_GEN_PREFIX(`_scan_bytes')
+    M4_GEN_PREFIX(`_init_buffer')
+    M4_GEN_PREFIX(`_flush_buffer')
+    M4_GEN_PREFIX(`_load_buffer_state')
+    M4_GEN_PREFIX(`_switch_to_buffer')
+    M4_GEN_PREFIX(`push_buffer_state')
+    M4_GEN_PREFIX(`pop_buffer_state')
+    M4_GEN_PREFIX(`ensure_buffer_stack')
+    M4_GEN_PREFIX(`lex')
+    M4_GEN_PREFIX(`restart')
+    M4_GEN_PREFIX(`lex_init')
+    M4_GEN_PREFIX(`lex_init_extra')
+    M4_GEN_PREFIX(`lex_destroy')
+    M4_GEN_PREFIX(`get_debug')
+    M4_GEN_PREFIX(`set_debug')
+    M4_GEN_PREFIX(`get_extra')
+    M4_GEN_PREFIX(`set_extra')
+    M4_GEN_PREFIX(`get_in')
+    M4_GEN_PREFIX(`set_in')
+    M4_GEN_PREFIX(`get_out')
+    M4_GEN_PREFIX(`set_out')
+    M4_GEN_PREFIX(`get_leng')
+    M4_GEN_PREFIX(`get_text')
+    M4_GEN_PREFIX(`get_lineno')
+    M4_GEN_PREFIX(`set_lineno')
+    m4_ifdef( [[M4_YY_REENTRANT]],
+    [[
+        M4_GEN_PREFIX(`get_column')
+        M4_GEN_PREFIX(`set_column')
+    ]])
+    M4_GEN_PREFIX(`wrap')
+%endif
+
+m4_ifdef( [[M4_YY_BISON_LVAL]],
+[[
+    M4_GEN_PREFIX(`get_lval')
+    M4_GEN_PREFIX(`set_lval')
+]])
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    M4_GEN_PREFIX(`get_lloc')
+    M4_GEN_PREFIX(`set_lloc')
+]])
+
+
+    M4_GEN_PREFIX(`alloc')
+    M4_GEN_PREFIX(`realloc')
+    M4_GEN_PREFIX(`free')
+
+%if-c-only
+m4_ifdef( [[M4_YY_NOT_REENTRANT]],
+[[
+    M4_GEN_PREFIX(`text')
+    M4_GEN_PREFIX(`leng')
+    M4_GEN_PREFIX(`in')
+    M4_GEN_PREFIX(`out')
+    M4_GEN_PREFIX(`_flex_debug')
+    M4_GEN_PREFIX(`lineno')
+]])
+%endif
+
+
+m4_ifdef( [[M4_YY_TABLES_EXTERNAL]],
+[[
+    M4_GEN_PREFIX(`tables_fload')
+    M4_GEN_PREFIX(`tables_destroy')
+    M4_GEN_PREFIX(`TABLES_NAME')
+]])
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+%if-c-only
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+%endif
+
+%if-tables-serialization
+#include <sys/types.h>
+#include <netinet/in.h>
+%endif
+/* end standard C headers. */
+
+%if-c-or-c++
+m4preproc_include(`flexint.h')
+%endif
+
+%if-c++-only
+/* begin standard C++ headers. */
+#include <iostream> 
+#include <errno.h>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+/* 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
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+%# For compilers that can not handle prototypes.
+%# e.g.,
+%# The function prototype
+%#    int foo(int x, char* y);
+%# 
+%# ...should be written as
+%#    int foo M4_YY_PARAMS(int x, char* y);
+%# 
+%# ...which could possibly generate
+%#    int foo ();
+%# 
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_PROTOS]],
+[[
+    m4_define( [[M4_YY_PARAMS]], [[()]])
+]],
+[[
+    m4_define( [[M4_YY_PARAMS]], [[($*)]])
+]])
+
+%not-for-header
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+%ok-for-header
+
+%not-for-header
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+%ok-for-header
+
+
+
+%if-reentrant
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+%# Declare yyguts variable
+m4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*)yyscanner]])
+%# Perform a noop access on yyguts to prevent unused variable complains
+m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[(void)yyg]])
+%# For use wherever a Global is accessed or assigned.
+m4_define( [[YY_G]], [[yyg->$1]])
+
+%# For use in function prototypes to append the additional argument.
+m4_define( [[M4_YY_PROTO_LAST_ARG]],  [[, yyscan_t yyscanner]])
+m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[yyscan_t yyscanner]])
+
+%# For use in function definitions to append the additional argument.
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
+[[
+    m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscanner]])
+    m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscanner]])
+]],
+[[
+    m4_define( [[M4_YY_DEF_LAST_ARG]],  [[, yyscan_t yyscanner]])
+    m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[yyscan_t yyscanner]])
+]])
+m4_define( [[M4_YY_DECL_LAST_ARG]],  [[yyscan_t yyscanner;]])
+
+%# For use in function calls to pass the additional argument.
+m4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]])
+m4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]])
+
+%# For use in function documentation to adjust for additional argument.
+m4_define( [[M4_YY_DOC_PARAM]], [[@param yyscanner The scanner object.]])
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin YY_G(yyin_r)
+#define yyout YY_G(yyout_r)
+#define yyextra YY_G(yyextra_r)
+#define yyleng YY_G(yyleng_r)
+#define yytext YY_G(yytext_r)
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug YY_G(yy_flex_debug_r)
+
+m4_define( [[M4_YY_INCR_LINENO]],
+[[   
+    do{ yylineno++;
+        yycolumn=0;
+    }while(0)
+]])
+
+%endif
+
+
+
+%if-not-reentrant
+
+m4_define( [[M4_YY_INCR_LINENO]],
+[[   
+    yylineno++;
+]])
+
+%# Define these macros to be no-ops.
+m4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]])
+m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[m4_dnl]])
+m4_define( [[YY_G]], [[($1)]])
+m4_define( [[M4_YY_PROTO_LAST_ARG]])
+m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[void]])
+m4_define( [[M4_YY_DEF_LAST_ARG]])
+
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
+[[
+    m4_define( [[M4_YY_DEF_ONLY_ARG]])
+]],
+[[
+    m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[void]])
+]])
+m4_define([[M4_YY_DECL_LAST_ARG]])
+m4_define([[M4_YY_CALL_LAST_ARG]])
+m4_define([[M4_YY_CALL_ONLY_ARG]])
+m4_define( [[M4_YY_DOC_PARAM]], [[]])
+
+%endif
+
+
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
+[[
+%# For compilers that need traditional function definitions.
+%# e.g.,
+%# The function prototype taking 2 arguments
+%#    int foo (int x, char* y)
+%#
+%# ...should be written as
+%#    int foo YYFARGS2(int,x, char*,y)
+%#
+%# ...which could possibly generate
+%#    int foo (x,y,yyscanner)
+%#        int x;
+%#        char * y;
+%#        yyscan_t yyscanner;
+%#
+%# Generate traditional function defs
+    m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG) [[\]]
+        M4_YY_DECL_LAST_ARG]])
+    m4_define( [[YYFARGS1]], [[($2 M4_YY_DEF_LAST_ARG) [[\]]
+        $1 $2; [[\]]
+        M4_YY_DECL_LAST_ARG]])
+    m4_define( [[YYFARGS2]], [[($2,$4 M4_YY_DEF_LAST_ARG) [[\]]
+        $1 $2; [[\]]
+        $3 $4; [[\]]
+        M4_YY_DECL_LAST_ARG]])
+    m4_define( [[YYFARGS3]], [[($2,$4,$6 M4_YY_DEF_LAST_ARG) [[\]]
+        $1 $2; [[\]]
+        $3 $4; [[\]]
+        $5 $6; [[\]]
+        M4_YY_DECL_LAST_ARG]])
+]],
+[[
+%# Generate C99 function defs.
+    m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG)]])
+    m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]])
+    m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]])
+    m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]])
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN YY_G(yy_start) = 1 + 2 *
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((YY_G(yy_start) - 1) / 2)
+#define YYSTATE YY_START
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG )
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define YY_END_OF_BUFFER_CHAR 0
+]])
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#define YY_BUF_SIZE 16384
+#endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+]])
+
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+%if-not-reentrant
+extern yy_size_t yyleng;
+%endif
+
+%if-c-only
+%if-not-reentrant
+extern FILE *yyin, *yyout;
+%endif
+%endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+    m4_ifdef( [[M4_YY_USE_LINENO]],
+    [[
+    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
+     *       access to the local variable yy_act. Since yyless() is a macro, it would break
+     *       existing scanners that call yyless() from OUTSIDE yylex. 
+     *       One obvious solution it to make yy_act a global. I tried that, and saw
+     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
+     *       normally declared as a register variable-- so it is not worth it.
+     */
+    #define  YY_LESS_LINENO(n) \
+            do { \
+                int yyl;\
+                for ( yyl = n; yyl < yyleng; ++yyl )\
+                    if ( yytext[yyl] == '\n' )\
+                        --yylineno;\
+            }while(0)
+    ]],
+    [[
+    #define YY_LESS_LINENO(n)
+    ]])
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = YY_G(yy_hold_char); \
+               YY_RESTORE_YY_MORE_OFFSET \
+               YY_G(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+               } \
+       while ( 0 )
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define unput(c) yyunput( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG )
+]])
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+       {
+%if-c-only
+       FILE *yy_input_file;
+%endif
+
+%if-c++-only
+       std::istream* yy_input_file;
+%endif
+
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       yy_size_t 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
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
+
+       int yy_buffer_status;
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+       /* When an EOF's been seen but there's still some text to process
+        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+        * shouldn't try reading from the input source any more.  We might
+        * still have a bunch of tokens to match, though, because of
+        * possible backing-up.
+        *
+        * When we actually see the EOF, we change the status to "new"
+        * (via yyrestart()), so that the user can continue scanning by
+        * just pointing yyin at a new input file.
+        */
+#define YY_BUFFER_EOF_PENDING 2
+]])
+       };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+%if-c-only Standard (non-C++) definition
+%not-for-header
+%if-not-reentrant
+
+/* 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. */
+%endif
+%ok-for-header
+%endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( YY_G(yy_buffer_stack) \
+                          ? YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] \
+                          : NULL)
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]
+]])
+
+%if-c-only Standard (non-C++) definition
+
+%if-not-reentrant
+%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;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 0;                /* whether we need to initialize */
+static int yy_start = 0;       /* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+%ok-for-header
+%endif
+
+void yyrestart M4_YY_PARAMS( FILE *input_file M4_YY_PROTO_LAST_ARG );
+void yy_switch_to_buffer M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );
+YY_BUFFER_STATE yy_create_buffer M4_YY_PARAMS( FILE *file, int size M4_YY_PROTO_LAST_ARG );
+void yy_delete_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );
+void yy_flush_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );
+void yypush_buffer_state M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );
+void yypop_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+static void yyensure_buffer_stack M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+static void yy_load_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+static void yy_init_buffer M4_YY_PARAMS( YY_BUFFER_STATE b, FILE *file M4_YY_PROTO_LAST_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG)
+]])
+
+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 );
+
+%endif
+
+void *yyalloc M4_YY_PARAMS( yy_size_t M4_YY_PROTO_LAST_ARG );
+void *yyrealloc M4_YY_PARAMS( void *, yy_size_t M4_YY_PROTO_LAST_ARG );
+void yyfree M4_YY_PARAMS( void * M4_YY_PROTO_LAST_ARG );
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define yy_new_buffer yy_create_buffer
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define yy_set_interactive(is_interactive) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define yy_set_bol(at_bol) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+]])
+
+%% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
+
+%if-c-only Standard (non-C++) definition
+
+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 );
+static void yy_fatal_error M4_YY_PARAMS( yyconst char msg[] M4_YY_PROTO_LAST_ARG );
+]])
+
+%endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+       YY_G(yytext_ptr) = yy_bp; \
+%% [2.0] code to fiddle yytext and yyleng for yymore() goes here \
+       YY_G(yy_hold_char) = *yy_cp; \
+       *yy_cp = '\0'; \
+%% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \
+       YY_G(yy_c_buf_p) = yy_cp;
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+%% [4.0] data tables for the DFA and the user's section 1 definitions go here
+]])
+
+m4_ifdef( [[M4_YY_IN_HEADER]], [[#ifdef YY_HEADER_EXPORT_START_CONDITIONS]])
+M4_YY_SC_DEFS
+m4_ifdef( [[M4_YY_IN_HEADER]], [[#endif]])
+
+m4_ifdef( [[M4_YY_NO_UNISTD_H]],,
+[[
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+%if-c-only
+#include <unistd.h>
+%endif
+%if-c++-only
+#include <unistd.h>
+%endif
+#endif
+]])
+
+m4_ifdef( [[M4_EXTRA_TYPE_DEFS]],
+[[
+#define YY_EXTRA_TYPE M4_EXTRA_TYPE_DEFS
+]],
+[[
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+]]
+)
+
+%if-c-only Reentrant structure and macros (non-C++).
+%if-reentrant
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    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. */
+    char yy_hold_char;
+    yy_size_t yy_n_chars;
+    yy_size_t yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+    yy_state_type *yy_state_buf;
+    yy_state_type *yy_state_ptr;
+    char *yy_full_match;
+    int yy_lp;
+
+    /* These are only needed for trailing context rules,
+     * but there's no conditional variable for that yet. */
+    int yy_looking_for_trail_begin;
+    int yy_full_lp;
+    int *yy_full_state;
+]])
+
+m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
+[[
+    char yytext_r[YYLMAX];
+    char *yytext_ptr;
+    int yy_more_offset;
+    int yy_prev_more_offset;
+]],
+[[
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+]])
+
+m4_ifdef( [[M4_YY_BISON_LVAL]],
+[[
+    YYSTYPE * yylval_r;
+]])
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    YYLTYPE * yylloc_r;
+]])
+
+    }; /* end struct yyguts_t */
+]])
+
+
+%if-c-only
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+static int yy_init_globals M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+%endif
+
+%if-reentrant
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+    m4_ifdef( [[M4_YY_BISON_LVAL]],
+    [[
+    /* This must go here because YYSTYPE and YYLTYPE are included
+     * from bison output in section 1.*/
+    #    define yylval YY_G(yylval_r)
+    ]])
+
+    m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+    [[
+    #    define yylloc YY_G(yylloc_r)
+    ]])
+]])
+
+int yylex_init M4_YY_PARAMS(yyscan_t* scanner);
+
+int yylex_init_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+%endif
+
+%endif End reentrant structures and macros.
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+m4_ifdef( [[M4_YY_NO_DESTROY]],,
+[[
+int yylex_destroy M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
+[[
+int yyget_debug M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
+[[
+void yyset_debug M4_YY_PARAMS( int debug_flag M4_YY_PROTO_LAST_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
+[[
+YY_EXTRA_TYPE yyget_extra M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
+[[
+void yyset_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_IN]],,
+[[
+FILE *yyget_in M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_IN]],,
+[[
+void yyset_in  M4_YY_PARAMS( FILE * in_str M4_YY_PROTO_LAST_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_OUT]],,
+[[
+FILE *yyget_out M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_OUT]],,
+[[
+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 );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
+[[
+char *yyget_text M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
+[[
+int yyget_lineno M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
+[[
+void yyset_lineno M4_YY_PARAMS( int line_number M4_YY_PROTO_LAST_ARG );
+]])
+
+m4_ifdef( [[M4_YY_REENTRANT]],
+[[
+m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
+[[
+int yyget_column  M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+]])
+
+m4_ifdef( [[M4_YY_REENTRANT]],
+[[
+m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
+[[
+void yyset_column M4_YY_PARAMS( int column_no M4_YY_PROTO_LAST_ARG );
+]])
+]])
+
+%if-bison-bridge
+m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
+[[
+YYSTYPE * yyget_lval M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+]])
+
+void yyset_lval M4_YY_PARAMS( YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG );
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
+    [[
+       YYLTYPE *yyget_lloc M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+    ]])
+
+    m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
+    [[
+        void yyset_lloc M4_YY_PARAMS( YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG );
+    ]])
+]])
+%endif
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+#else
+extern int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+#endif
+#endif
+
+%not-for-header
+    m4_ifdef( [[M4_YY_NO_UNPUT]],,
+    [[
+    static void yyunput M4_YY_PARAMS( int c, char *buf_ptr  M4_YY_PROTO_LAST_ARG);
+    ]])
+%ok-for-header
+%endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy M4_YY_PARAMS( char *, yyconst char *, int M4_YY_PROTO_LAST_ARG);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen M4_YY_PARAMS( yyconst char * M4_YY_PROTO_LAST_ARG);
+#endif
+
+#ifndef YY_NO_INPUT
+%if-c-only Standard (non-C++) definition
+%not-for-header
+#ifdef __cplusplus
+static int yyinput M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+#else
+static int input M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+#endif
+%ok-for-header
+%endif
+#endif
+
+
+%if-c-only
+%# TODO: This is messy.
+m4_ifdef( [[M4_YY_STACK_USED]],
+[[
+
+m4_ifdef( [[M4_YY_NOT_REENTRANT]],
+[[
+    m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+    [[
+        static int yy_start_stack_ptr = 0;
+        static int yy_start_stack_depth = 0;
+        static int *yy_start_stack = NULL;
+    ]])
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+    m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
+    [[
+    static void yy_push_state M4_YY_PARAMS( int new_state M4_YY_PROTO_LAST_ARG);
+    ]])
+    m4_ifdef( [[M4_YY_NO_POP_STATE]],,
+    [[
+    static void yy_pop_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+    ]])
+    m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
+    [[
+    static int yy_top_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );
+    ]])
+]])
+
+]],
+[[
+m4_define( [[M4_YY_NO_PUSH_STATE]])
+m4_define( [[M4_YY_NO_POP_STATE]])
+m4_define( [[M4_YY_NO_TOP_STATE]])
+]])
+%endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+%if-c-only Standard (non-C++) definition
+/* 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)
+%endif
+%if-c++-only C++ definition
+#define ECHO LexerOutput( yytext, yyleng )
+%endif
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+%% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \
+\
+%if-c++-only C++ definition \
+       if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
+               YY_FATAL_ERROR( "input in flex scanner failed" );
+%endif
+
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+]])
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+%if-c-only
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg M4_YY_CALL_LAST_ARG)
+%endif
+%if-c++-only
+#define YY_FATAL_ERROR(msg) LexerError( msg )
+%endif
+#endif
+]])
+
+%if-tables-serialization structures and prototypes
+m4preproc_include(`tables_shared.h')
+
+/* Load the DFA tables from the given stream.  */
+int yytables_fload M4_YY_PARAMS(FILE * fp M4_YY_PROTO_LAST_ARG);
+
+/* Unload the tables from memory. */
+int yytables_destroy M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG);
+%not-for-header
+
+/** Describes a mapping from a serialized table id to its deserialized state in
+ * this scanner.  This is the bridge between our "generic" deserialization code
+ * and the specifics of this scanner. 
+ */
+struct yytbl_dmap {
+       enum yytbl_id dm_id;/**< table identifier */
+       void  **dm_arr;         /**< address of pointer to store the deserialized table. */
+       size_t  dm_sz;          /**< local sizeof() each element in table. */
+};
+
+/** A {0,0,0}-terminated list of structs, forming the map */
+static struct yytbl_dmap yydmap[] =
+{
+%tables-yydmap generated elements
+    {0,0,0}
+};
+
+/** A tables-reader object to maintain some state in the read. */
+struct yytbl_reader {
+    FILE * fp; /**< input stream */
+    flex_uint32_t bread; /**< bytes read since beginning of current tableset */
+};
+
+%endif
+/* end tables serialization structures and prototypes */
+
+%ok-for-header
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+%if-c-only Standard (non-C++) definition
+
+
+m4_define( [[M4_YY_LEX_PROTO]], [[M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG)]])
+m4_define( [[M4_YY_LEX_DECLARATION]], [[YYFARGS0(void)]])
+
+m4_ifdef( [[M4_YY_BISON_LVAL]],
+[[
+    m4_dnl  The bison pure parser is used. Redefine yylex to
+    m4_dnl  accept the lval parameter.
+
+    m4_define( [[M4_YY_LEX_PROTO]], [[\]]
+               [[M4_YY_PARAMS(YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG)]])
+    m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
+               [[YYFARGS1(YYSTYPE *,yylval_param)]])
+]])
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    m4_dnl  Locations are used. yylex should also accept the ylloc parameter.
+
+    m4_define( [[M4_YY_LEX_PROTO]], [[\]]
+               [[M4_YY_PARAMS(YYSTYPE * yylval_param, YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG)]])
+    m4_define( [[M4_YY_LEX_DECLARATION]], [[\]]
+               [[YYFARGS2(YYSTYPE *,yylval_param, YYLTYPE *,yylloc_param)]])
+]])
+
+extern int yylex M4_YY_LEX_PROTO;
+
+#define YY_DECL int yylex M4_YY_LEX_DECLARATION
+%endif
+%if-c++-only C++ definition
+#define YY_DECL int yyFlexLexer::yylex()
+%endif
+#endif /* !YY_DECL */
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+%% [6.0] YY_RULE_SETUP definition goes here
+]])
+
+%not-for-header
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+       register yy_state_type yy_current_state;
+       register char *yy_cp, *yy_bp;
+       register int yy_act;
+    M4_YY_DECL_GUTS_VAR();
+
+m4_ifdef( [[M4_YY_NOT_REENTRANT]],
+[[
+    m4_ifdef( [[M4_YY_BISON_LVAL]],
+    [[
+        YYSTYPE * yylval;
+    ]])
+    m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+    [[
+        YYLTYPE * yylloc;
+    ]])
+]])
+
+%% [7.0] user's declarations go here
+
+m4_ifdef( [[M4_YY_BISON_LVAL]],
+[[
+    yylval = yylval_param;
+]])
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    yylloc = yylloc_param;
+]])
+
+       if ( !YY_G(yy_init) )
+               {
+               YY_G(yy_init) = 1;
+
+#ifdef YY_USER_INIT
+               YY_USER_INIT;
+#endif
+
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+        /* Create the reject buffer large enough to save one state per allowed character. */
+        if ( ! YY_G(yy_state_buf) )
+            YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  M4_YY_CALL_LAST_ARG);
+            if ( ! YY_G(yy_state_buf) )
+                YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+]])
+
+               if ( ! YY_G(yy_start) )
+                       YY_G(yy_start) = 1;     /* first start state */
+
+               if ( ! yyin )
+%if-c-only
+                       yyin = stdin;
+%endif
+%if-c++-only
+                       yyin = & std::cin;
+%endif
+
+               if ( ! yyout )
+%if-c-only
+                       yyout = stdout;
+%endif
+%if-c++-only
+                       yyout = & std::cout;
+%endif
+
+               if ( ! YY_CURRENT_BUFFER ) {
+                       yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
+                       YY_CURRENT_BUFFER_LVALUE =
+                               yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
+               }
+
+               yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+               }
+
+       while ( 1 )             /* loops until end-of-file is reached */
+               {
+%% [8.0] yymore()-related code goes here
+               yy_cp = YY_G(yy_c_buf_p);
+
+               /* Support of yytext. */
+               *yy_cp = YY_G(yy_hold_char);
+
+               /* yy_bp points to the position in yy_ch_buf of the start of
+                * the current run.
+                */
+               yy_bp = yy_cp;
+
+%% [9.0] code to set up and find next match goes here
+
+yy_find_action:
+%% [10.0] code to find the action number goes here
+
+               YY_DO_BEFORE_ACTION;
+
+%% [11.0] code for yylineno update goes here
+
+do_action:     /* This label is used only to access EOF actions. */
+
+%% [12.0] debug code goes here
+
+               switch ( yy_act )
+       { /* beginning of action switch */
+%% [13.0] actions go here
+
+       case YY_END_OF_BUFFER:
+               {
+               /* Amount of text matched not including the EOB char. */
+               int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;
+
+               /* Undo the effects of YY_DO_BEFORE_ACTION. */
+               *yy_cp = YY_G(yy_hold_char);
+               YY_RESTORE_YY_MORE_OFFSET
+
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+                       {
+                       /* We're scanning a new file or input source.  It's
+                        * possible that this happened because the user
+                        * just pointed yyin at a new source and called
+                        * yylex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
+                        * globals.  Here is the right place to do so, because
+                        * this is the first action (other than possibly a
+                        * back-up) that will match for the new input source.
+                        */
+                       YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+                       }
+
+               /* Note that here we test for yy_c_buf_p "<=" to the position
+                * of the first EOB in the buffer, since yy_c_buf_p will
+                * already have been incremented past the NUL character
+                * (since all states make transitions on EOB to the
+                * end-of-buffer state).  Contrast this with the test
+                * in input().
+                */
+               if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
+                       { /* This was really a NUL. */
+                       yy_state_type yy_next_state;
+
+                       YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;
+
+                       yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
+
+                       /* Okay, we're now positioned to make the NUL
+                        * transition.  We couldn't have
+                        * yy_get_previous_state() go ahead and do it
+                        * for us because it doesn't know how to deal
+                        * with the possibility of jamming (and we don't
+                        * want to build jamming into it because then it
+                        * will run more slowly).
+                        */
+
+                       yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG);
+
+                       yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
+
+                       if ( yy_next_state )
+                               {
+                               /* Consume the NUL. */
+                               yy_cp = ++YY_G(yy_c_buf_p);
+                               yy_current_state = yy_next_state;
+                               goto yy_match;
+                               }
+
+                       else
+                               {
+%% [14.0] code to do back-up for compressed tables and set up yy_cp goes here
+                               goto yy_find_action;
+                               }
+                       }
+
+               else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
+                       {
+                       case EOB_ACT_END_OF_FILE:
+                               {
+                               YY_G(yy_did_buffer_switch_on_eof) = 0;
+
+                               if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
+                                       {
+                                       /* Note: because we've taken care in
+                                        * yy_get_next_buffer() to have set up
+                                        * yytext, we can now set up
+                                        * yy_c_buf_p so that if some total
+                                        * hoser (like flex itself) wants to
+                                        * call the scanner after we return the
+                                        * YY_NULL, it'll still work - another
+                                        * YY_NULL will get returned.
+                                        */
+                                       YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;
+
+                                       yy_act = YY_STATE_EOF(YY_START);
+                                       goto do_action;
+                                       }
+
+                               else
+                                       {
+                                       if ( ! YY_G(yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+                                       }
+                               break;
+                               }
+
+                       case EOB_ACT_CONTINUE_SCAN:
+                               YY_G(yy_c_buf_p) =
+                                       YY_G(yytext_ptr) + yy_amount_of_matched_text;
+
+                               yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
+
+                               yy_cp = YY_G(yy_c_buf_p);
+                               yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_match;
+
+                       case EOB_ACT_LAST_MATCH:
+                               YY_G(yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];
+
+                               yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );
+
+                               yy_cp = YY_G(yy_c_buf_p);
+                               yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_find_action;
+                       }
+               break;
+               }
+
+       default:
+               YY_FATAL_ERROR(
+                       "fatal flex scanner internal error--no action found" );
+       } /* end of action switch */
+               } /* end of scanning one token */
+} /* end of yylex */
+%ok-for-header
+
+%if-c++-only
+%not-for-header
+/* The contents of this function are C++ specific, so the YY_G macro is not used.
+ */
+yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
+{
+       yyin = arg_yyin;
+       yyout = arg_yyout;
+       yy_c_buf_p = 0;
+       yy_init = 0;
+       yy_start = 0;
+       yy_flex_debug = 0;
+       yylineno = 1;   // this will only get updated if %option yylineno
+
+       yy_did_buffer_switch_on_eof = 0;
+
+       yy_looking_for_trail_begin = 0;
+       yy_more_flag = 0;
+       yy_more_len = 0;
+       yy_more_offset = yy_prev_more_offset = 0;
+
+       yy_start_stack_ptr = yy_start_stack_depth = 0;
+       yy_start_stack = NULL;
+
+       yy_buffer_stack = 0;
+       yy_buffer_stack_top = 0;
+       yy_buffer_stack_max = 0;
+
+
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+       yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE];
+]],
+[[
+       yy_state_buf = 0;
+]])
+}
+
+/* The contents of this function are C++ specific, so the YY_G macro is not used.
+ */
+yyFlexLexer::~yyFlexLexer()
+{
+       delete [] yy_state_buf;
+       yyfree( yy_start_stack M4_YY_CALL_LAST_ARG );
+       yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
+       yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG );
+}
+
+/* The contents of this function are C++ specific, so the YY_G macro is not used.
+ */
+void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
+{
+       if ( new_in )
+               {
+               yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
+               yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG);
+               }
+
+       if ( new_out )
+               yyout = new_out;
+}
+
+#ifdef YY_INTERACTIVE
+int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
+#else
+int yyFlexLexer::LexerInput( char* buf, int max_size )
+#endif
+{
+       if ( yyin->eof() || yyin->fail() )
+               return 0;
+
+#ifdef YY_INTERACTIVE
+       yyin->get( buf[0] );
+
+       if ( yyin->eof() )
+               return 0;
+
+       if ( yyin->bad() )
+               return -1;
+
+       return 1;
+
+#else
+       (void) yyin->read( buf, max_size );
+
+       if ( yyin->bad() )
+               return -1;
+       else
+               return yyin->gcount();
+#endif
+}
+
+void yyFlexLexer::LexerOutput( const char* buf, int size )
+{
+       (void) yyout->write( buf, size );
+}
+%ok-for-header
+%endif
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *     EOB_ACT_LAST_MATCH -
+ *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *     EOB_ACT_END_OF_FILE - end of file
+ */
+%if-c-only
+static int yy_get_next_buffer YYFARGS0(void)
+%endif
+%if-c++-only
+int yyFlexLexer::yy_get_next_buffer()
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = YY_G(yytext_ptr);
+       register int number_to_move, i;
+       int ret_val;
+
+       if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] )
+               YY_FATAL_ERROR(
+               "fatal flex scanner internal error--end of buffer missed" );
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+               { /* Don't try to fill the buffer, so this is an EOF. */
+               if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
+                       {
+                       /* We matched a single character, the EOB, so
+                        * treat this as a final EOF.
+                        */
+                       return EOB_ACT_END_OF_FILE;
+                       }
+
+               else
+                       {
+                       /* We matched some text prior to the EOB, first
+                        * process it.
+                        */
+                       return EOB_ACT_LAST_MATCH;
+                       }
+               }
+
+       /* Try to read more data. */
+
+       /* First move last chars to start of buffer. */
+       number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;
+
+       for ( i = 0; i < number_to_move; ++i )
+               *(dest++) = *(source++);
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+               /* don't do the read, it's not guaranteed to return an EOF,
+                * just force an EOF
+                */
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0;
+
+       else
+               {
+                       yy_size_t num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+               while ( num_to_read <= 0 )
+                       { /* Not enough room in the buffer - grow it. */
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+                       YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+]],
+[[
+                       /* just a shorter name for the current buffer */
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+                       int yy_c_buf_p_offset =
+                               (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
+
+                       if ( b->yy_is_our_buffer )
+                               {
+                               yy_size_t new_size = b->yy_buf_size * 2;
+
+                               if ( new_size <= 0 )
+                                       b->yy_buf_size += b->yy_buf_size / 8;
+                               else
+                                       b->yy_buf_size *= 2;
+
+                               b->yy_ch_buf = (char *)
+                                       /* Include room in for 2 EOB chars. */
+                                       yyrealloc( (void *) b->yy_ch_buf,
+                                                        b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
+                               }
+                       else
+                               /* Can't grow it, we don't own it. */
+                               b->yy_ch_buf = 0;
+
+                       if ( ! b->yy_ch_buf )
+                               YY_FATAL_ERROR(
+                               "fatal error - scanner input buffer overflow" );
+
+                       YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+                                               number_to_move - 1;
+]])
+                       }
+
+               if ( num_to_read > YY_READ_BUF_SIZE )
+                       num_to_read = YY_READ_BUF_SIZE;
+
+               /* Read in more data. */
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       YY_G(yy_n_chars), num_to_read );
+
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
+               }
+
+       if ( YY_G(yy_n_chars) == 0 )
+               {
+               if ( number_to_move == YY_MORE_ADJ )
+                       {
+                       ret_val = EOB_ACT_END_OF_FILE;
+                       yyrestart( yyin  M4_YY_CALL_LAST_ARG);
+                       }
+
+               else
+                       {
+                       ret_val = EOB_ACT_LAST_MATCH;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+                               YY_BUFFER_EOF_PENDING;
+                       }
+               }
+
+       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) {
+               /* 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);
+               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 )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+       }
+
+       YY_G(yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+       YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+       return ret_val;
+}
+]])
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+%if-c-only
+%not-for-header
+    static yy_state_type yy_get_previous_state YYFARGS0(void)
+%endif
+%if-c++-only
+    yy_state_type yyFlexLexer::yy_get_previous_state()
+%endif
+{
+       register yy_state_type yy_current_state;
+       register char *yy_cp;
+    M4_YY_DECL_GUTS_VAR();
+
+%% [15.0] code to get the start state into yy_current_state goes here
+
+       for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
+               {
+%% [16.0] code to find the next state goes here
+               }
+
+       return yy_current_state;
+}
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *     next_state = yy_try_NUL_trans( current_state );
+ */
+%if-c-only
+    static yy_state_type yy_try_NUL_trans  YYFARGS1( yy_state_type, yy_current_state)
+%endif
+%if-c++-only
+    yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
+%endif
+{
+       register int yy_is_jam;
+    M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */
+%% [17.0] code to find the next state, and perhaps do backing up, goes here
+
+       M4_YY_NOOP_GUTS_VAR();
+       return yy_is_jam ? 0 : yy_current_state;
+}
+
+
+%if-c-only
+m4_ifdef( [[M4_YY_NO_UNPUT]],,
+[[
+    static void yyunput YYFARGS2( int,c, register char *,yy_bp)
+%endif
+%if-c++-only
+    void yyFlexLexer::yyunput( int c, register char* yy_bp)
+%endif
+{
+       register char *yy_cp;
+    M4_YY_DECL_GUTS_VAR();
+
+    yy_cp = YY_G(yy_c_buf_p);
+
+       /* undo effects of setting up yytext */
+       *yy_cp = YY_G(yy_hold_char);
+
+       if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+               { /* need to shift things up to make room */
+               /* +2 for EOB chars. */
+               register yy_size_t number_to_move = YY_G(yy_n_chars) + 2;
+               register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+                                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+               register char *source =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       *--dest = *--source;
+
+               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;
+
+               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+                       YY_FATAL_ERROR( "flex scanner push-back overflow" );
+               }
+
+       *--yy_cp = (char) c;
+
+%% [18.0] update yylineno here
+m4_ifdef( [[M4_YY_USE_LINENO]],
+[[
+    if ( c == '\n' ){
+        --yylineno;
+    }
+]])
+
+       YY_G(yytext_ptr) = yy_bp;
+       YY_G(yy_hold_char) = *yy_cp;
+       YY_G(yy_c_buf_p) = yy_cp;
+}
+%if-c-only
+]])
+%endif
+
+%if-c-only
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput YYFARGS0(void)
+#else
+    static int input  YYFARGS0(void)
+#endif
+
+%endif
+%if-c++-only
+    int yyFlexLexer::yyinput()
+%endif
+{
+       int c;
+    M4_YY_DECL_GUTS_VAR();
+
+       *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
+
+       if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+               {
+               /* yy_c_buf_p now points to the character we want to return.
+                * If this occurs *before* the EOB characters, then it's a
+                * valid NUL; if not, then we've hit the end of the buffer.
+                */
+               if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
+                       /* This was really a NUL. */
+                       *YY_G(yy_c_buf_p) = '\0';
+
+               else
+                       { /* need more input */
+                       yy_size_t 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 ) )
+                               {
+                               case EOB_ACT_LAST_MATCH:
+                                       /* This happens because yy_g_n_b()
+                                        * sees that we've accumulated a
+                                        * token and flags that we need to
+                                        * try matching the token before
+                                        * proceeding.  But for input(),
+                                        * there's no matching to consider.
+                                        * So convert the EOB_ACT_LAST_MATCH
+                                        * to EOB_ACT_END_OF_FILE.
+                                        */
+
+                                       /* Reset buffer status. */
+                                       yyrestart( yyin M4_YY_CALL_LAST_ARG);
+
+                                       /*FALLTHROUGH*/
+
+                               case EOB_ACT_END_OF_FILE:
+                                       {
+                                       if ( yywrap( M4_YY_CALL_ONLY_ARG ) )
+                                               return EOF;
+
+                                       if ( ! YY_G(yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+#ifdef __cplusplus
+                                       return yyinput(M4_YY_CALL_ONLY_ARG);
+#else
+                                       return input(M4_YY_CALL_ONLY_ARG);
+#endif
+                                       }
+
+                               case EOB_ACT_CONTINUE_SCAN:
+                                       YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
+                                       break;
+                               }
+                       }
+               }
+
+       c = *(unsigned char *) YY_G(yy_c_buf_p);        /* cast for 8-bit char's */
+       *YY_G(yy_c_buf_p) = '\0';       /* preserve yytext */
+       YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);
+
+%% [19.0] update BOL and yylineno
+
+       return c;
+}
+%if-c-only
+#endif /* ifndef YY_NO_INPUT */
+%endif
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * M4_YY_DOC_PARAM
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+%if-c-only
+    void yyrestart  YYFARGS1( FILE *,input_file)
+%endif
+%if-c++-only
+    void yyFlexLexer::yyrestart( std::istream* input_file )
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+
+       if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
+               YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);
+       }
+
+       yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG);
+       yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * M4_YY_DOC_PARAM
+ */
+%if-c-only
+    void yy_switch_to_buffer  YYFARGS1( YY_BUFFER_STATE ,new_buffer)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              yypop_buffer_state();
+        *              yypush_buffer_state(new_buffer);
+     */
+       yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);
+       if ( YY_CURRENT_BUFFER == new_buffer )
+               return;
+
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
+               }
+
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+
+       /* We don't actually know whether we did this switch during
+        * EOF (yywrap()) processing, but the only time this flag
+        * is looked at is after yywrap() is called, so it's safe
+        * to go ahead and always set it.
+        */
+       YY_G(yy_did_buffer_switch_on_eof) = 1;
+}
+
+
+%if-c-only
+static void yy_load_buffer_state  YYFARGS0(void)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_load_buffer_state()
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * M4_YY_DOC_PARAM
+ * @return the allocated buffer state.
+ */
+%if-c-only
+    YY_BUFFER_STATE yy_create_buffer  YYFARGS2( FILE *,file, int ,size)
+%endif
+%if-c++-only
+    YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
+%endif
+{
+       YY_BUFFER_STATE b;
+    m4_dnl M4_YY_DECL_GUTS_VAR();
+
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+       b->yy_buf_size = size;
+
+       /* yy_ch_buf has to be 2 characters longer than the size given because
+        * we need to put in 2 end-of-buffer characters.
+        */
+       b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );
+       if ( ! b->yy_ch_buf )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+       b->yy_is_our_buffer = 1;
+
+       yy_init_buffer( b, file M4_YY_CALL_LAST_ARG);
+
+       return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * M4_YY_DOC_PARAM
+ */
+%if-c-only
+    void yy_delete_buffer YYFARGS1( YY_BUFFER_STATE ,b)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+
+       if ( ! b )
+               return;
+
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+       if ( b->yy_is_our_buffer )
+               yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG );
+
+       yyfree( (void *) b M4_YY_CALL_LAST_ARG );
+}
+
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+%if-c-only
+    static void yy_init_buffer  YYFARGS2( YY_BUFFER_STATE ,b, FILE *,file)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
+%endif
+
+{
+       int oerrno = errno;
+    M4_YY_DECL_GUTS_VAR();
+
+       yy_flush_buffer( b M4_YY_CALL_LAST_ARG);
+
+       b->yy_input_file = file;
+       b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+%if-c-only
+m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]],
+[[
+       b->yy_is_interactive = 1;
+]],
+[[
+    m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],
+    [[
+        b->yy_is_interactive = 0;
+    ]],
+    [[
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    ]])
+]])
+%endif
+%if-c++-only
+       b->yy_is_interactive = 0;
+%endif
+       errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * M4_YY_DOC_PARAM
+ */
+%if-c-only
+    void yy_flush_buffer YYFARGS1( YY_BUFFER_STATE ,b)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       if ( ! b )
+               return;
+
+       b->yy_n_chars = 0;
+
+       /* We always need two end-of-buffer characters.  The first causes
+        * a transition to the end-of-buffer state.  The second causes
+        * a jam in that state.
+        */
+       b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+       b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+       b->yy_buf_pos = &b->yy_ch_buf[0];
+
+       b->yy_at_bol = 1;
+       b->yy_buffer_status = YY_BUFFER_NEW;
+
+       if ( b == YY_CURRENT_BUFFER )
+               yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+}
+
+%if-c-or-c++
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  M4_YY_DOC_PARAM
+ */
+%if-c-only
+void yypush_buffer_state YYFARGS1(YY_BUFFER_STATE,new_buffer)
+%endif
+%if-c++-only
+void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       if (new_buffer == NULL)
+               return;
+
+       yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG);
+
+       /* This block is copied from yy_switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
+               }
+
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               YY_G(yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+       /* copied from yy_switch_to_buffer. */
+       yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+       YY_G(yy_did_buffer_switch_on_eof) = 1;
+}
+%endif
+
+
+%if-c-or-c++
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  M4_YY_DOC_PARAM
+ */
+%if-c-only
+void yypop_buffer_state YYFARGS0(void)
+%endif
+%if-c++-only
+void yyFlexLexer::yypop_buffer_state (void)
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       yy_delete_buffer(YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if (YY_G(yy_buffer_stack_top) > 0)
+               --YY_G(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );
+               YY_G(yy_did_buffer_switch_on_eof) = 1;
+       }
+}
+%endif
+
+
+%if-c-or-c++
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+%if-c-only
+static void yyensure_buffer_stack YYFARGS0(void)
+%endif
+%if-c++-only
+void yyFlexLexer::yyensure_buffer_stack(void)
+%endif
+{
+       yy_size_t num_to_alloc;
+    M4_YY_DECL_GUTS_VAR();
+
+       if (!YY_G(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
+         */
+               num_to_alloc = 1;
+               YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               M4_YY_CALL_LAST_ARG);
+               if ( ! YY_G(yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+                                                                 
+               
+               memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               YY_G(yy_buffer_stack_max) = num_to_alloc;
+               YY_G(yy_buffer_stack_top) = 0;
+               return;
+       }
+
+       if (YY_G(yy_buffer_stack_top) >= (YY_G(yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = YY_G(yy_buffer_stack_max) + grow_size;
+               YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+                                                               (YY_G(yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               M4_YY_CALL_LAST_ARG);
+               if ( ! YY_G(yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+               /* zero only the new slots.*/
+               memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               YY_G(yy_buffer_stack_max) = num_to_alloc;
+       }
+}
+%endif
+
+
+
+
+m4_ifdef( [[M4_YY_NO_SCAN_BUFFER]],,
+[[
+%if-c-only
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * M4_YY_DOC_PARAM
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE yy_scan_buffer  YYFARGS2( char *,base, yy_size_t ,size)
+{
+       YY_BUFFER_STATE b;
+    m4_dnl M4_YY_DECL_GUTS_VAR();
+
+       if ( size < 2 ||
+            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;
+
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+       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_n_chars = b->yy_buf_size;
+       b->yy_is_interactive = 0;
+       b->yy_at_bol = 1;
+       b->yy_fill_buffer = 0;
+       b->yy_buffer_status = YY_BUFFER_NEW;
+
+       yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG );
+
+       return b;
+}
+%endif
+]])
+
+
+m4_ifdef( [[M4_YY_NO_SCAN_STRING]],,
+[[
+%if-c-only
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * M4_YY_DOC_PARAM
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+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);
+}
+%endif
+]])
+
+
+m4_ifdef( [[M4_YY_NO_SCAN_BYTES]],,
+[[
+%if-c-only
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a 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 b;
+       char *buf;
+       yy_size_t n;
+       int i;
+    m4_dnl M4_YY_DECL_GUTS_VAR();
+
+       /* Get memory for full buffer, including space for trailing EOB's. */
+       n = _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()" );
+
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
+
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+       b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG);
+       if ( ! b )
+               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+       /* It's okay to grow etc. this buffer, and we should throw it
+        * away when we're done.
+        */
+       b->yy_is_our_buffer = 1;
+
+       return b;
+}
+%endif
+]])
+
+
+m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,
+[[
+%if-c-only
+    static void yy_push_state YYFARGS1( int ,new_state)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_push_state( int new_state )
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) )
+               {
+               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 );
+
+               if ( ! YY_G(yy_start_stack) )
+                       YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG );
+
+               else
+                       YY_G(yy_start_stack) = (int *) yyrealloc(
+                                       (void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG );
+
+               if ( ! YY_G(yy_start_stack) )
+                       YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
+               }
+
+       YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START;
+
+       BEGIN(new_state);
+}
+]])
+
+
+m4_ifdef( [[M4_YY_NO_POP_STATE]],,
+[[
+%if-c-only
+    static void yy_pop_state  YYFARGS0(void)
+%endif
+%if-c++-only
+    void yyFlexLexer::yy_pop_state()
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       if ( --YY_G(yy_start_stack_ptr) < 0 )
+               YY_FATAL_ERROR( "start-condition stack underflow" );
+
+       BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
+}
+]])
+
+
+m4_ifdef( [[M4_YY_NO_TOP_STATE]],,
+[[
+%if-c-only
+    static int yy_top_state  YYFARGS0(void)
+%endif
+%if-c++-only
+    int yyFlexLexer::yy_top_state()
+%endif
+{
+    M4_YY_DECL_GUTS_VAR();
+       return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1];
+}
+]])
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+%if-c-only
+static void yy_fatal_error YYFARGS1(yyconst char*, msg)
+{
+    m4_dnl M4_YY_DECL_GUTS_VAR();
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
+%endif
+%if-c++-only
+void yyFlexLexer::LexerError( yyconst char msg[] )
+{
+    M4_YY_DECL_GUTS_VAR();
+       std::cerr << msg << std::endl;
+       exit( YY_EXIT_FAILURE );
+}
+%endif
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               yytext[yyleng] = YY_G(yy_hold_char); \
+               YY_G(yy_c_buf_p) = yytext + yyless_macro_arg; \
+               YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
+               *YY_G(yy_c_buf_p) = '\0'; \
+               yyleng = yyless_macro_arg; \
+               } \
+       while ( 0 )
+
+
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+%if-c-only
+%if-reentrant
+m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,
+[[
+/** Get the user-defined data for this scanner.
+ * M4_YY_DOC_PARAM
+ */
+YY_EXTRA_TYPE yyget_extra  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yyextra;
+}
+]])
+%endif
+
+m4_ifdef( [[M4_YY_NO_GET_LINENO]],,
+[[
+/** Get the current line number.
+ * M4_YY_DOC_PARAM
+ */
+int yyget_lineno  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    
+    m4_ifdef( [[M4_YY_REENTRANT]],
+    [[
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    ]])
+    return yylineno;
+}
+]])
+
+m4_ifdef( [[M4_YY_REENTRANT]],
+[[
+m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,
+[[
+/** Get the current column number.
+ * M4_YY_DOC_PARAM
+ */
+int yyget_column  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    
+    m4_ifdef( [[M4_YY_REENTRANT]],
+    [[
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    ]])
+    return yycolumn;
+}
+]])
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_IN]],,
+[[
+/** Get the input stream.
+ * M4_YY_DOC_PARAM
+ */
+FILE *yyget_in  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yyin;
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_GET_OUT]],,
+[[
+/** Get the output stream.
+ * M4_YY_DOC_PARAM
+ */
+FILE *yyget_out  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yyout;
+}
+]])
+
+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)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yyleng;
+}
+]])
+
+/** Get the current token.
+ * M4_YY_DOC_PARAM
+ */
+m4_ifdef( [[M4_YY_NO_GET_TEXT]],,
+[[
+char *yyget_text  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yytext;
+}
+]])
+
+%if-reentrant
+m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,
+[[
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * M4_YY_DOC_PARAM
+ */
+void yyset_extra YYFARGS1( YY_EXTRA_TYPE ,user_defined)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yyextra = user_defined ;
+}
+]])
+%endif
+
+m4_ifdef( [[M4_YY_NO_SET_LINENO]],,
+[[
+/** Set the current line number.
+ * @param line_number
+ * M4_YY_DOC_PARAM
+ */
+void yyset_lineno YYFARGS1( int ,line_number)
+{
+    M4_YY_DECL_GUTS_VAR();
+
+    m4_ifdef( [[M4_YY_REENTRANT]],
+    [[
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+    ]])
+    yylineno = line_number;
+}
+]])
+
+m4_ifdef( [[M4_YY_REENTRANT]],
+[[
+m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,
+[[
+/** Set the current column.
+ * @param line_number
+ * M4_YY_DOC_PARAM
+ */
+void yyset_column YYFARGS1( int , column_no)
+{
+    M4_YY_DECL_GUTS_VAR();
+
+    m4_ifdef( [[M4_YY_REENTRANT]],
+    [[
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+    ]])
+    yycolumn = column_no;
+}
+]])
+]])
+
+
+m4_ifdef( [[M4_YY_NO_SET_IN]],,
+[[
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * M4_YY_DOC_PARAM
+ * @see yy_switch_to_buffer
+ */
+void yyset_in YYFARGS1( FILE * ,in_str)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yyin = in_str ;
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_OUT]],,
+[[
+void yyset_out YYFARGS1( FILE * ,out_str)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yyout = out_str ;
+}
+]])
+
+
+m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,
+[[
+int yyget_debug  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yy_flex_debug;
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,
+[[
+void yyset_debug YYFARGS1( int ,bdebug)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yy_flex_debug = bdebug ;
+}
+]])
+%endif
+
+%if-reentrant
+/* Accessor methods for yylval and yylloc */
+
+%if-bison-bridge
+m4_ifdef( [[M4_YY_NO_GET_LVAL]],,
+[[
+YYSTYPE * yyget_lval  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yylval;
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_SET_LVAL]],,
+[[
+void yyset_lval YYFARGS1( YYSTYPE * ,yylval_param)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yylval = yylval_param;
+}
+]])
+
+m4_ifdef( [[<M4_YY_BISON_LLOC>]],
+[[
+    m4_ifdef( [[M4_YY_NO_GET_LLOC]],,
+    [[
+YYLTYPE *yyget_lloc  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    return yylloc;
+}
+    ]])
+
+    m4_ifdef( [[M4_YY_NO_SET_LLOC]],,
+    [[
+void yyset_lloc YYFARGS1( YYLTYPE * ,yylloc_param)
+{
+    M4_YY_DECL_GUTS_VAR();
+    yylloc = yylloc_param;
+}
+    ]])
+]])
+
+%endif
+
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
+[[
+int yylex_init( ptr_yy_globals )
+    yyscan_t* ptr_yy_globals;
+]],
+[[
+int yylex_init(yyscan_t* ptr_yy_globals)
+]])
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],
+[[
+int yylex_init_extra( yy_user_defined, ptr_yy_globals )
+    YY_EXTRA_TYPE yy_user_defined;
+    yyscan_t* ptr_yy_globals;
+]],
+[[
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+]])
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+       
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+       
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+    
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+    
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+    
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+%endif if-c-only
+
+
+%if-c-only
+static int yy_init_globals YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+m4_ifdef( [[M4_YY_USE_LINENO]],
+[[
+    m4_ifdef( [[M4_YY_NOT_REENTRANT]],
+    [[
+    /* We do not touch yylineno unless the option is enabled. */
+    yylineno =  1;
+    ]])
+]])
+    YY_G(yy_buffer_stack) = 0;
+    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_init) = 0;
+    YY_G(yy_start) = 0;
+
+m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
+[[
+    YY_G(yy_start_stack_ptr) = 0;
+    YY_G(yy_start_stack_depth) = 0;
+    YY_G(yy_start_stack) =  NULL;
+]])
+
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+    YY_G(yy_state_buf) = 0;
+    YY_G(yy_state_ptr) = 0;
+    YY_G(yy_full_match) = 0;
+    YY_G(yy_lp) = 0;
+]])
+
+m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],
+[[
+    YY_G(yytext_ptr) = 0;
+    YY_G(yy_more_offset) = 0;
+    YY_G(yy_prev_more_offset) = 0;
+]])
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+%endif
+
+
+%if-c-only SNIP! this currently causes conflicts with the c++ scanner
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  YYFARGS0(void)
+{
+    M4_YY_DECL_GUTS_VAR();
+
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               yypop_buffer_state(M4_YY_CALL_ONLY_ARG);
+       }
+
+       /* Destroy the stack itself. */
+       yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG);
+       YY_G(yy_buffer_stack) = NULL;
+
+m4_ifdef( [[M4_YY_HAS_START_STACK_VARS]],
+[[
+    /* Destroy the start condition stack. */
+        yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG );
+        YY_G(yy_start_stack) = NULL;
+]])
+
+m4_ifdef( [[M4_YY_USES_REJECT]],
+[[
+    yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG);
+    YY_G(yy_state_buf)  = NULL;
+]])
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( M4_YY_CALL_ONLY_ARG);
+
+%if-reentrant
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner M4_YY_CALL_LAST_ARG );
+    yyscanner = NULL;
+%endif
+    return 0;
+}
+%endif
+
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+/*
+ * Internal utility routines.
+ */
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#ifndef yytext_ptr
+static void yy_flex_strncpy YYFARGS3( char*,s1, yyconst char *,s2, int,n)
+{
+       register int i;
+       for ( i = 0; i < n; ++i )
+               s1[i] = s2[i];
+}
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NOT_IN_HEADER]],
+[[
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YYFARGS1( yyconst char *,s)
+{
+       register int n;
+       for ( n = 0; s[n]; ++n )
+               ;
+
+       return n;
+}
+#endif
+]])
+
+m4_ifdef( [[M4_YY_NO_FLEX_ALLOC]],,
+[[
+void *yyalloc YYFARGS1( yy_size_t ,size)
+{
+       return (void *) malloc( size );
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_FLEX_REALLOC]],,
+[[
+void *yyrealloc  YYFARGS2( void *,ptr, yy_size_t ,size)
+{
+       /* The cast to (char *) in the following accommodates both
+        * implementations that use char* generic pointers, and those
+        * that use void* generic pointers.  It works with the latter
+        * because both ANSI C and C++ allow castless assignment from
+        * any pointer type to void*, and deal with argument conversions
+        * as though doing an assignment.
+        */
+       return (void *) realloc( (char *) ptr, size );
+}
+]])
+
+m4_ifdef( [[M4_YY_NO_FLEX_FREE]],,
+[[
+void yyfree YYFARGS1( void *,ptr)
+{
+       free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
+}
+]])
+
+%if-tables-serialization definitions
+m4preproc_include(`tables_shared.c')
+
+static int yytbl_read8 (void *v, struct yytbl_reader * rd)
+{
+    errno = 0;
+    if (fread (v, sizeof (flex_uint8_t), 1, rd->fp) != 1){
+        errno = EIO;
+        return -1;
+    }
+    rd->bread += sizeof(flex_uint8_t);
+    return 0;
+}
+
+static int yytbl_read16 (void *v, struct yytbl_reader * rd)
+{
+    errno = 0;
+    if (fread (v, sizeof (flex_uint16_t), 1, rd->fp) != 1){
+        errno = EIO;
+        return -1;
+    }
+    *((flex_uint16_t *) v) = ntohs (*((flex_uint16_t *) v));
+    rd->bread += sizeof(flex_uint16_t);
+    return 0;
+}
+
+static int yytbl_read32 (void *v, struct yytbl_reader * rd)
+{
+    errno = 0;
+    if (fread (v, sizeof (flex_uint32_t), 1, rd->fp) != 1){
+        errno = EIO;
+        return -1;
+    }
+    *((flex_uint32_t *) v) = ntohl (*((flex_uint32_t *) v));
+    rd->bread += sizeof(flex_uint32_t);
+    return 0;
+}
+
+/** Read the header */
+static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader *, rd)
+{
+    int     bytes;
+    memset (th, 0, sizeof (struct yytbl_hdr));
+
+    if (yytbl_read32 (&(th->th_magic), rd) != 0)
+        return -1;
+
+    if (th->th_magic != YYTBL_MAGIC){
+        YY_FATAL_ERROR( "bad magic number" );   /* TODO: not fatal. */
+        return -1;
+    }
+
+    if (yytbl_read32 (&(th->th_hsize), rd) != 0
+        || yytbl_read32 (&(th->th_ssize), rd) != 0
+        || yytbl_read16 (&(th->th_flags), rd) != 0)
+        return -1;
+
+    /* Sanity check on header size. Greater than 1k suggests some funny business. */
+    if (th->th_hsize < 16 || th->th_hsize > 1024){
+        YY_FATAL_ERROR( "insane header size detected" );   /* TODO: not fatal. */
+        return -1;
+    }
+
+    /* Allocate enough space for the version and name fields */
+    bytes = th->th_hsize - 14;
+    th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
+    if ( ! th->th_version )
+        YY_FATAL_ERROR( "out of dynamic memory in yytbl_hdr_read()" );
+
+    /* we read it all into th_version, and point th_name into that data */
+    if (fread (th->th_version, 1, bytes, rd->fp) != bytes){
+        errno = EIO;
+        yyfree(th->th_version M4_YY_CALL_LAST_ARG);
+        th->th_version = NULL;
+        return -1;
+    }
+    else
+        rd->bread += bytes;
+
+    th->th_name = th->th_version + strlen (th->th_version) + 1;
+    return 0;
+}
+
+/** lookup id in the dmap list.
+ *  @param dmap pointer to first element in list
+ *  @return NULL if not found.
+ */
+static struct yytbl_dmap *yytbl_dmap_lookup YYFARGS2(struct yytbl_dmap *, dmap,
+                                                      int, id)
+{
+    while (dmap->dm_id)
+        if (dmap->dm_id == id)
+            return dmap;
+        else
+            dmap++;
+    return NULL;
+}
+
+/** Read a table while mapping its contents to the local array. 
+ *  @param dmap used to performing mapping
+ *  @return 0 on success
+ */
+static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_reader*, rd)
+{
+    struct yytbl_data td;
+    struct yytbl_dmap *transdmap=0;
+    int     len, i, rv, inner_loop_count;
+    void   *p=0;
+
+    memset (&td, 0, sizeof (struct yytbl_data));
+
+    if (yytbl_read16 (&td.td_id, rd) != 0
+        || yytbl_read16 (&td.td_flags, rd) != 0
+        || yytbl_read32 (&td.td_hilen, rd) != 0
+        || yytbl_read32 (&td.td_lolen, rd) != 0)
+        return -1;
+
+    /* Lookup the map for the transition table so we have it in case we need it
+     * inside the loop below. This scanner might not even have a transition
+     * table, which is ok.
+     */
+    transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG);
+
+    if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL){
+        YY_FATAL_ERROR( "table id not found in map." );   /* TODO: not fatal. */
+        return -1;
+    }
+
+    /* Allocate space for table.
+     * The --full yy_transition table is a special case, since we
+     * need the dmap.dm_sz entry to tell us the sizeof the individual
+     * struct members.
+     */
+    {
+    size_t  bytes;
+
+    if ((td.td_flags & YYTD_STRUCT))
+        bytes = sizeof(struct yy_trans_info) * td.td_lolen * (td.td_hilen ? td.td_hilen : 1);
+    else
+        bytes = td.td_lolen * (td.td_hilen ? td.td_hilen : 1) * dmap->dm_sz;
+
+    if(M4_YY_TABLES_VERIFY)
+        /* We point to the array itself */
+        p = dmap->dm_arr; 
+    else
+        /* We point to the address of a pointer. */
+        *dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG);
+        if ( ! p )
+            YY_FATAL_ERROR( "out of dynamic memory in yytbl_data_load()" );
+    }
+
+    /* If it's a struct, we read 2 integers to get one element */
+    if ((td.td_flags & YYTD_STRUCT) != 0)
+        inner_loop_count = 2;
+    else
+        inner_loop_count = 1;
+
+    /* read and map each element.
+     * This loop iterates once for each element of the td_data array.
+     * Notice that we increment 'i' in the inner loop.
+     */
+    len = yytbl_calc_total_len (&td);
+    for (i = 0; i < len; ){
+        int    j;
+
+
+        /* This loop really executes exactly 1 or 2 times.
+         * The second time is to handle the second member of the
+         * YYTD_STRUCT for the yy_transition array.
+         */
+        for (j = 0; j < inner_loop_count; j++, i++) {
+            flex_int32_t t32;
+
+            /* read into t32 no matter what the real size is. */
+            {
+            flex_int16_t t16;
+            flex_int8_t  t8;
+
+            switch (YYTDFLAGS2BYTES (td.td_flags)) {
+            case sizeof (flex_int32_t):
+                rv = yytbl_read32 (&t32, rd);
+                break;
+            case sizeof (flex_int16_t):
+                rv = yytbl_read16 (&t16, rd);
+                t32 = t16;
+                break;
+            case sizeof (flex_int8_t):
+                rv = yytbl_read8 (&t8, rd);
+                t32 = t8;
+                break;
+            default: 
+                YY_FATAL_ERROR( "invalid td_flags" );   /* TODO: not fatal. */
+                return -1;
+            }
+            }
+            if (rv != 0)
+                return -1;
+
+            /* copy into the deserialized array... */
+
+            if ((td.td_flags & YYTD_STRUCT)) {
+                /* t32 is the j'th member of a two-element struct. */
+                void   *v;
+
+                v = j == 0 ? &(((struct yy_trans_info *) p)->yy_verify)
+                    : &(((struct yy_trans_info *) p)->yy_nxt);
+
+                switch (dmap->dm_sz) {
+                case sizeof (flex_int32_t):
+                    if (M4_YY_TABLES_VERIFY){
+                        if( ((flex_int32_t *) v)[0] != (flex_int32_t) t32)
+                           YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int32_t" );
+                    }else
+                        ((flex_int32_t *) v)[0] = (flex_int32_t) t32;
+                    break;
+                case sizeof (flex_int16_t):
+                    if (M4_YY_TABLES_VERIFY ){
+                        if(((flex_int16_t *) v)[0] != (flex_int16_t) t32)
+                        YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int16_t" );
+                    }else
+                        ((flex_int16_t *) v)[0] = (flex_int16_t) t32;
+                    break;
+                case sizeof(flex_int8_t):
+                    if (M4_YY_TABLES_VERIFY ){
+                         if( ((flex_int8_t *) v)[0] != (flex_int8_t) t32)
+                        YY_FATAL_ERROR( "tables verification failed at YYTD_STRUCT flex_int8_t" );
+                    }else
+                        ((flex_int8_t *) v)[0] = (flex_int8_t) t32;
+                    break;
+                default:
+                    YY_FATAL_ERROR( "invalid dmap->dm_sz for struct" );   /* TODO: not fatal. */
+                    return -1;
+                }
+
+                /* if we're done with j, increment p */
+                if (j == 1)
+                    p = (struct yy_trans_info *) p + 1;
+            }
+            else if ((td.td_flags & YYTD_PTRANS)) {
+                /* t32 is an index into the transition array. */
+                struct yy_trans_info *v;
+
+
+                if (!transdmap){
+                    YY_FATAL_ERROR( "transition table not found" );   /* TODO: not fatal. */
+                    return -1;
+                }
+                
+                if( M4_YY_TABLES_VERIFY)
+                    v = &(((struct yy_trans_info *) (transdmap->dm_arr))[t32]);
+                else
+                    v = &((*((struct yy_trans_info **) (transdmap->dm_arr)))[t32]);
+
+                if(M4_YY_TABLES_VERIFY ){
+                    if( ((struct yy_trans_info **) p)[0] != v)
+                        YY_FATAL_ERROR( "tables verification failed at YYTD_PTRANS" );
+                }else
+                    ((struct yy_trans_info **) p)[0] = v;
+                
+                /* increment p */
+                p = (struct yy_trans_info **) p + 1;
+            }
+            else {
+                /* t32 is a plain int. copy data, then incrememnt p. */
+                switch (dmap->dm_sz) {
+                case sizeof (flex_int32_t):
+                    if(M4_YY_TABLES_VERIFY ){
+                        if( ((flex_int32_t *) p)[0] != (flex_int32_t) t32)
+                        YY_FATAL_ERROR( "tables verification failed at flex_int32_t" );
+                    }else
+                        ((flex_int32_t *) p)[0] = (flex_int32_t) t32;
+                    p = ((flex_int32_t *) p) + 1;
+                    break;
+                case sizeof (flex_int16_t):
+                    if(M4_YY_TABLES_VERIFY ){
+                        if( ((flex_int16_t *) p)[0] != (flex_int16_t) t32)
+                        YY_FATAL_ERROR( "tables verification failed at flex_int16_t" );
+                    }else
+                        ((flex_int16_t *) p)[0] = (flex_int16_t) t32;
+                    p = ((flex_int16_t *) p) + 1;
+                    break;
+                case sizeof (flex_int8_t):
+                    if(M4_YY_TABLES_VERIFY ){
+                        if( ((flex_int8_t *) p)[0] != (flex_int8_t) t32)
+                        YY_FATAL_ERROR( "tables verification failed at flex_int8_t" );
+                    }else
+                        ((flex_int8_t *) p)[0] = (flex_int8_t) t32;
+                    p = ((flex_int8_t *) p) + 1;
+                    break;
+                default:
+                    YY_FATAL_ERROR( "invalid dmap->dm_sz for plain int" );   /* TODO: not fatal. */
+                    return -1;
+                }
+            }
+        }
+
+    }
+
+    /* Now eat padding. */
+    {
+        int pad;
+        pad = yypad64(rd->bread);
+        while(--pad >= 0){
+            flex_int8_t t8;
+            if(yytbl_read8(&t8,rd) != 0)
+                return -1;
+        }
+    }
+
+    return 0;
+}
+
+%define-yytables   The name for this specific scanner's tables.
+
+/* Find the key and load the DFA tables from the given stream.  */
+static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key)
+{
+    int rv=0;
+    struct yytbl_hdr th;
+    struct yytbl_reader rd;
+
+    rd.fp = fp;
+    th.th_version = NULL;
+
+    /* Keep trying until we find the right set of tables or end of file. */
+    while (!feof(rd.fp)) {
+        rd.bread = 0;
+        if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0){
+            rv = -1;
+            goto return_rv;
+        }
+
+        /* A NULL key means choose the first set of tables. */
+        if (key == NULL)
+            break;
+
+        if (strcmp(th.th_name,key) != 0){
+            /* Skip ahead to next set */
+            fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR);
+            yyfree(th.th_version M4_YY_CALL_LAST_ARG);
+            th.th_version = NULL;
+        }
+        else
+            break;
+    }
+
+    while (rd.bread < th.th_ssize){
+        /* Load the data tables */
+        if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){
+            rv = -1;
+            goto return_rv;
+        }
+    }
+
+return_rv:
+    if(th.th_version){
+        yyfree(th.th_version M4_YY_CALL_LAST_ARG);
+        th.th_version = NULL;
+    }
+
+    return rv;
+}
+
+/** Load the DFA tables for this scanner from the given stream.  */
+int yytables_fload YYFARGS1(FILE *, fp)
+{
+
+    if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0)
+        return -1;
+    return 0;
+}
+
+/** Destroy the loaded tables, freeing memory, etc.. */
+int yytables_destroy YYFARGS0(void)
+{   
+    struct yytbl_dmap *dmap=0;
+
+    if(!M4_YY_TABLES_VERIFY){
+        /* Walk the dmap, freeing the pointers */
+        for(dmap=yydmap; dmap->dm_id; dmap++) {
+            void * v;
+            v = dmap->dm_arr;
+            if(v && *(char**)v){
+                    yyfree(*(char**)v M4_YY_CALL_LAST_ARG);
+                    *(char**)v = NULL;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/* end table serialization code definitions */
+%endif
+
+
+m4_ifdef([[M4_YY_MAIN]], [[
+int main M4_YY_PARAMS(void);
+
+int main ()
+{
+
+%if-reentrant
+    yyscan_t lexer;
+    yylex_init(&lexer);
+    yylex( lexer );
+    yylex_destroy( lexer);
+
+%endif
+%if-not-reentrant
+       yylex();
+%endif
+
+       return 0;
+}
+]])
+
+%ok-for-header
+m4_ifdef( [[M4_YY_IN_HEADER]],
+[[
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+]])
diff --git a/contrib/flex/flexdef.h b/contrib/flex/flexdef.h
new file mode 100644 (file)
index 0000000..0e81410
--- /dev/null
@@ -0,0 +1,1223 @@
+
+/* flexdef - definitions file for flex */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+#ifndef FLEXDEF_H
+#define FLEXDEF_H 1
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* AIX requires this to be the first thing in the file.  */
+#ifndef __GNUC__
+# 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 <string.h>
+#include <math.h>
+#endif
+#ifdef HAVE_ASSERT_H
+#include <assert.h>
+#else
+#define assert(Pred)
+#endif
+
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_SYS_PARAMS_H
+#include <sys/params.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#ifdef HAVE_STDBOOL_H
+#include <stdbool.h>
+#else
+#define bool int
+#define true 1
+#define false 0
+#endif
+#ifdef HAVE_REGEX_H
+#include <regex.h>
+#endif
+#include "flexint.h"
+
+/* We use gettext. So, when we write strings which should be translated, we mark them with _() */
+#ifdef ENABLE_NLS
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif /* HAVE_LOCALE_H */
+#include "gettext.h"
+#define _(String) gettext (String)
+#else
+#define _(STRING) STRING
+#endif /* ENABLE_NLS */
+
+/* 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
+
+#ifndef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
+#ifndef MAX
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#endif
+#ifndef ABS
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+#endif
+
+
+/* ANSI C does not guarantee that isascii() is defined */
+#ifndef isascii
+#define isascii(c) ((c) <= 0177)
+#endif
+
+#define unspecified -1
+
+/* Special chk[] values marking the slots taking by end-of-buffer and action
+ * numbers.
+ */
+#define EOB_POSITION -1
+#define ACTION_POSITION -2
+
+/* Number of data items per line for -f output. */
+#define NUMDATAITEMS 10
+
+/* Number of lines of data in -f output before inserting a blank line for
+ * readability.
+ */
+#define NUMDATALINES 10
+
+/* transition_struct_out() definitions. */
+#define TRANS_STRUCT_PRINT_LENGTH 14
+
+/* Returns true if an nfa state has an epsilon out-transition slot
+ * that can be used.  This definition is currently not used.
+ */
+#define FREE_EPSILON(state) \
+       (transchar[state] == SYM_EPSILON && \
+        trans2[state] == NO_TRANSITION && \
+        finalst[state] != state)
+
+/* Returns true if an nfa state has an epsilon out-transition character
+ * and both slots are free
+ */
+#define SUPER_FREE_EPSILON(state) \
+       (transchar[state] == SYM_EPSILON && \
+        trans1[state] == NO_TRANSITION) \
+
+/* Maximum number of NFA states that can comprise a DFA state.  It's real
+ * big because if there's a lot of rules, the initial state will have a
+ * huge epsilon closure.
+ */
+#define INITIAL_MAX_DFA_SIZE 750
+#define MAX_DFA_SIZE_INCREMENT 750
+
+
+/* A note on the following masks.  They are used to mark accepting numbers
+ * as being special.  As such, they implicitly limit the number of accepting
+ * numbers (i.e., rules) because if there are too many rules the rule numbers
+ * will overload the mask bits.  Fortunately, this limit is \large/ (0x2000 ==
+ * 8192) so unlikely to actually cause any problems.  A check is made in
+ * new_rule() to ensure that this limit is not reached.
+ */
+
+/* Mask to mark a trailing context accepting number. */
+#define YY_TRAILING_MASK 0x2000
+
+/* Mask to mark the accepting number of the "head" of a trailing context
+ * rule.
+ */
+#define YY_TRAILING_HEAD_MASK 0x4000
+
+/* Maximum number of rules, as outlined in the above note. */
+#define MAX_RULE (YY_TRAILING_MASK - 1)
+
+
+/* NIL must be 0.  If not, its special meaning when making equivalence classes
+ * (it marks the representative of a given e.c.) will be unidentifiable.
+ */
+#define NIL 0
+
+#define JAM -1                 /* to mark a missing DFA transition */
+#define NO_TRANSITION NIL
+#define UNIQUE -1              /* marks a symbol as an e.c. representative */
+#define INFINITE_REPEAT -1             /* for x{5,} constructions */
+
+#define INITIAL_MAX_CCLS 100   /* max number of unique character classes */
+#define MAX_CCLS_INCREMENT 100
+
+/* Size of table holding members of character classes. */
+#define INITIAL_MAX_CCL_TBL_SIZE 500
+#define MAX_CCL_TBL_SIZE_INCREMENT 250
+
+#define INITIAL_MAX_RULES 100  /* default maximum number of rules */
+#define MAX_RULES_INCREMENT 100
+
+#define INITIAL_MNS 2000       /* default maximum number of nfa states */
+#define MNS_INCREMENT 1000     /* amount to bump above by if it's not enough */
+
+#define INITIAL_MAX_DFAS 1000  /* default maximum number of dfa states */
+#define MAX_DFAS_INCREMENT 1000
+
+#define JAMSTATE -32766                /* marks a reference to the state that always jams */
+
+/* Maximum number of NFA states. */
+#define MAXIMUM_MNS 31999
+#define MAXIMUM_MNS_LONG 1999999999
+
+/* Enough so that if it's subtracted from an NFA state number, the result
+ * is guaranteed to be negative.
+ */
+#define MARKER_DIFFERENCE (maximum_mns+2)
+
+/* Maximum number of nxt/chk pairs for non-templates. */
+#define INITIAL_MAX_XPAIRS 2000
+#define MAX_XPAIRS_INCREMENT 2000
+
+/* Maximum number of nxt/chk pairs needed for templates. */
+#define INITIAL_MAX_TEMPLATE_XPAIRS 2500
+#define MAX_TEMPLATE_XPAIRS_INCREMENT 2500
+
+#define SYM_EPSILON (CSIZE + 1)        /* to mark transitions on the symbol epsilon */
+
+#define INITIAL_MAX_SCS 40     /* maximum number of start conditions */
+#define MAX_SCS_INCREMENT 40   /* amount to bump by if it's not enough */
+
+#define ONE_STACK_SIZE 500     /* stack of states with only one out-transition */
+#define SAME_TRANS -1          /* transition is the same as "default" entry for state */
+
+/* The following percentages are used to tune table compression:
+
+ * The percentage the number of out-transitions a state must be of the
+ * number of equivalence classes in order to be considered for table
+ * compaction by using protos.
+ */
+#define PROTO_SIZE_PERCENTAGE 15
+
+/* The percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * that the state's transition table is first compared with a potential
+ * template of the most common out-transition instead of with the first
+ * proto in the proto queue.
+ */
+#define CHECK_COM_PERCENTAGE 50
+
+/* The percentage the number of differences between a state's transition
+ * table and the proto it was first compared with must be of the total
+ * number of out-transitions of the state in order to keep the first
+ * proto as a good match and not search any further.
+ */
+#define FIRST_MATCH_DIFF_PERCENTAGE 10
+
+/* The percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to use the proto as an acceptable close match.
+ */
+#define ACCEPTABLE_DIFF_PERCENTAGE 50
+
+/* The percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * to consider making a template from the state.
+ */
+#define TEMPLATE_SAME_PERCENTAGE 60
+
+/* The percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to create a new proto from the state.
+ */
+#define NEW_PROTO_DIFF_PERCENTAGE 20
+
+/* The percentage the total number of out-transitions of a state must be
+ * of the number of equivalence classes in order to consider trying to
+ * fit the transition table into "holes" inside the nxt/chk table.
+ */
+#define INTERIOR_FIT_PERCENTAGE 15
+
+/* Size of region set aside to cache the complete transition table of
+ * protos on the proto queue to enable quick comparisons.
+ */
+#define PROT_SAVE_SIZE 2000
+
+#define MSP 50                 /* maximum number of saved protos (protos on the proto queue) */
+
+/* Maximum number of out-transitions a state can have that we'll rummage
+ * around through the interior of the internal fast table looking for a
+ * spot for it.
+ */
+#define MAX_XTIONS_FULL_INTERIOR_FIT 4
+
+/* Maximum number of rules which will be reported as being associated
+ * with a DFA state.
+ */
+#define MAX_ASSOC_RULES 100
+
+/* Number that, if used to subscript an array, has a good chance of producing
+ * an error; should be small enough to fit into a short.
+ */
+#define BAD_SUBSCRIPT -32767
+
+/* Absolute value of largest number that can be stored in a short, with a
+ * bit of slop thrown in for general paranoia.
+ */
+#define MAX_SHORT 32700
+
+
+/* Declarations for global variables. */
+
+
+/* Variables for flags:
+ * printstats - if true (-v), dump statistics
+ * syntaxerror - true if a syntax error has been found
+ * eofseen - true if we've seen an eof in the input file
+ * ddebug - if true (-d), make a "debug" scanner
+ * trace - if true (-T), trace processing
+ * nowarn - if true (-w), do not generate warnings
+ * spprdflt - if true (-s), suppress the default rule
+ * interactive - if true (-I), generate an interactive scanner
+ * lex_compat - if true (-l), maximize compatibility with AT&T lex
+ * posix_compat - if true (-X), maximize compatibility with POSIX lex
+ * do_yylineno - if true, generate code to maintain yylineno
+ * useecs - if true (-Ce flag), use equivalence classes
+ * fulltbl - if true (-Cf flag), don't compress the DFA state table
+ * usemecs - if true (-Cm flag), use meta-equivalence classes
+ * fullspd - if true (-F flag), use Jacobson method of table representation
+ * gen_line_dirs - if true (i.e., no -L flag), generate #line directives
+ * performance_report - if > 0 (i.e., -p flag), generate a report relating
+ *   to scanner performance; if > 1 (-p -p), report on minor performance
+ *   problems, too
+ * backing_up_report - if true (i.e., -b flag), generate "lex.backup" file
+ *   listing backing-up states
+ * C_plus_plus - if true (i.e., -+ flag), generate a C++ scanner class;
+ *   otherwise, a standard C scanner
+ * reentrant - if true (-R), generate a reentrant C scanner.
+ * bison_bridge_lval - if true (--bison-bridge), bison pure calling convention.
+ * bison_bridge_lloc - if true (--bison-locations), bison yylloc.
+ * long_align - if true (-Ca flag), favor long-word alignment.
+ * use_read - if true (-f, -F, or -Cr) then use read() for scanner input;
+ *   otherwise, use fread().
+ * yytext_is_array - if true (i.e., %array directive), then declare
+ *   yytext as a array instead of a character pointer.  Nice and inefficient.
+ * do_yywrap - do yywrap() processing on EOF.  If false, EOF treated as
+ *   "no more files".
+ * csize - size of character set for the scanner we're generating;
+ *   128 for 7-bit chars and 256 for 8-bit
+ * yymore_used - if true, yymore() is used in input rules
+ * reject - if true, generate back-up tables for REJECT macro
+ * real_reject - if true, scanner really uses REJECT (as opposed to just
+ *   having "reject" set for variable trailing context)
+ * continued_action - true if this rule's action is to "fall through" to
+ *   the next rule's action (i.e., the '|' action)
+ * in_rule - true if we're inside an individual rule, false if not.
+ * yymore_really_used - whether to treat yymore() as really used, regardless
+ *   of what we think based on references to it in the user's actions.
+ * reject_really_used - same for REJECT
+ */
+
+extern int printstats, syntaxerror, eofseen, ddebug, trace, nowarn,
+       spprdflt;
+extern int interactive, lex_compat, posix_compat, do_yylineno;
+extern int useecs, fulltbl, usemecs, fullspd;
+extern int gen_line_dirs, performance_report, backing_up_report;
+extern int reentrant, bison_bridge_lval, bison_bridge_lloc;
+extern bool ansi_func_defs, ansi_func_protos;
+extern int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap;
+extern int csize;
+extern int yymore_used, reject, real_reject, continued_action, in_rule;
+
+extern int yymore_really_used, reject_really_used;
+
+
+/* Variables used in the flex input routines:
+ * datapos - characters on current output line
+ * dataline - number of contiguous lines of data in current data
+ *     statement.  Used to generate readable -f output
+ * linenum - current input line number
+ * skelfile - the skeleton file
+ * skel - compiled-in skeleton array
+ * skel_ind - index into "skel" array, if skelfile is nil
+ * yyin - input file
+ * backing_up_file - file to summarize backing-up states to
+ * infilename - name of input file
+ * outfilename - name of output file
+ * headerfilename - name of the .h file to generate
+ * did_outfilename - whether outfilename was explicitly set
+ * prefix - the prefix used for externally visible names ("yy" by default)
+ * yyclass - yyFlexLexer subclass to use for YY_DECL
+ * do_stdinit - whether to initialize yyin/yyout to stdin/stdout
+ * use_stdout - the -t flag
+ * input_files - array holding names of input files
+ * num_input_files - size of input_files array
+ * program_name - name with which program was invoked
+ *
+ * action_array - array to hold the rule actions
+ * action_size - size of action_array
+ * defs1_offset - index where the user's section 1 definitions start
+ *     in action_array
+ * prolog_offset - index where the prolog starts in action_array
+ * action_offset - index where the non-prolog starts in action_array
+ * action_index - index where the next action should go, with respect
+ *     to "action_array"
+ */
+
+extern int datapos, dataline, linenum;
+extern FILE *skelfile, *yyin, *backing_up_file;
+extern const char *skel[];
+extern int skel_ind;
+extern char *infilename, *outfilename, *headerfilename;
+extern int did_outfilename;
+extern char *prefix, *yyclass, *extra_type;
+extern int do_stdinit, use_stdout;
+extern char **input_files;
+extern int num_input_files;
+extern char *program_name;
+
+extern char *action_array;
+extern int action_size;
+extern int defs1_offset, prolog_offset, action_offset, action_index;
+
+
+/* Variables for stack of states having only one out-transition:
+ * onestate - state number
+ * onesym - transition symbol
+ * onenext - target state
+ * onedef - default base entry
+ * onesp - stack pointer
+ */
+
+extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+
+
+/* Variables for nfa machine data:
+ * maximum_mns - maximal number of NFA states supported by tables
+ * current_mns - current maximum on number of NFA states
+ * num_rules - number of the last accepting state; also is number of
+ *     rules created so far
+ * num_eof_rules - number of <<EOF>> rules
+ * default_rule - number of the default rule
+ * current_max_rules - current maximum number of rules
+ * lastnfa - last nfa state number created
+ * firstst - physically the first state of a fragment
+ * lastst - last physical state of fragment
+ * finalst - last logical state of fragment
+ * transchar - transition character
+ * trans1 - transition state
+ * trans2 - 2nd transition state for epsilons
+ * accptnum - accepting number
+ * assoc_rule - rule associated with this NFA state (or 0 if none)
+ * state_type - a STATE_xxx type identifying whether the state is part
+ *     of a normal rule, the leading state in a trailing context
+ *     rule (i.e., the state which marks the transition from
+ *     recognizing the text-to-be-matched to the beginning of
+ *     the trailing context), or a subsequent state in a trailing
+ *     context rule
+ * rule_type - a RULE_xxx type identifying whether this a ho-hum
+ *     normal rule or one which has variable head & trailing
+ *     context
+ * rule_linenum - line number associated with rule
+ * rule_useful - true if we've determined that the rule can be matched
+ * rule_has_nl - true if rule could possibly match a newline
+ * ccl_has_nl - true if current ccl could match a newline
+ * nlch - default eol char
+ */
+
+extern int maximum_mns, current_mns, current_max_rules;
+extern int num_rules, num_eof_rules, default_rule, lastnfa;
+extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
+extern int *accptnum, *assoc_rule, *state_type;
+extern int *rule_type, *rule_linenum, *rule_useful;
+extern bool *rule_has_nl, *ccl_has_nl;
+extern int nlch;
+
+/* Different types of states; values are useful as masks, as well, for
+ * routines like check_trailing_context().
+ */
+#define STATE_NORMAL 0x1
+#define STATE_TRAILING_CONTEXT 0x2
+
+/* Global holding current type of state we're making. */
+
+extern int current_state_type;
+
+/* Different types of rules. */
+#define RULE_NORMAL 0
+#define RULE_VARIABLE 1
+
+/* True if the input rules include a rule with both variable-length head
+ * and trailing context, false otherwise.
+ */
+extern int variable_trailing_context_rules;
+
+
+/* Variables for protos:
+ * numtemps - number of templates created
+ * numprots - number of protos created
+ * protprev - backlink to a more-recently used proto
+ * protnext - forward link to a less-recently used proto
+ * prottbl - base/def table entry for proto
+ * protcomst - common state of proto
+ * firstprot - number of the most recently used proto
+ * lastprot - number of the least recently used proto
+ * protsave contains the entire state array for protos
+ */
+
+extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
+extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
+
+
+/* Variables for managing equivalence classes:
+ * numecs - number of equivalence classes
+ * nextecm - forward link of Equivalence Class members
+ * ecgroup - class number or backward link of EC members
+ * nummecs - number of meta-equivalence classes (used to compress
+ *   templates)
+ * tecfwd - forward link of meta-equivalence classes members
+ * tecbck - backward link of MEC's
+ */
+
+/* Reserve enough room in the equivalence class arrays so that we
+ * can use the CSIZE'th element to hold equivalence class information
+ * for the NUL character.  Later we'll move this information into
+ * the 0th element.
+ */
+extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs;
+
+/* Meta-equivalence classes are indexed starting at 1, so it's possible
+ * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1
+ * slots total (since the arrays are 0-based).  nextecm[] and ecgroup[]
+ * don't require the extra position since they're indexed from 1 .. CSIZE - 1.
+ */
+extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1];
+
+
+/* Variables for start conditions:
+ * lastsc - last start condition created
+ * current_max_scs - current limit on number of start conditions
+ * scset - set of rules active in start condition
+ * scbol - set of rules active only at the beginning of line in a s.c.
+ * scxclu - true if start condition is exclusive
+ * sceof - true if start condition has EOF rule
+ * scname - start condition name
+ */
+
+extern int lastsc, *scset, *scbol, *scxclu, *sceof;
+extern int current_max_scs;
+extern char **scname;
+
+
+/* Variables for dfa machine data:
+ * current_max_dfa_size - current maximum number of NFA states in DFA
+ * current_max_xpairs - current maximum number of non-template xtion pairs
+ * current_max_template_xpairs - current maximum number of template pairs
+ * current_max_dfas - current maximum number DFA states
+ * lastdfa - last dfa state number created
+ * nxt - state to enter upon reading character
+ * chk - check value to see if "nxt" applies
+ * tnxt - internal nxt table for templates
+ * base - offset into "nxt" for given state
+ * def - where to go if "chk" disallows "nxt" entry
+ * nultrans - NUL transition for each state
+ * NUL_ec - equivalence class of the NUL character
+ * tblend - last "nxt/chk" table entry being used
+ * firstfree - first empty entry in "nxt/chk" table
+ * dss - nfa state set for each dfa
+ * dfasiz - size of nfa state set for each dfa
+ * dfaacc - accepting set for each dfa state (if using REJECT), or accepting
+ *     number, if not
+ * accsiz - size of accepting set for each dfa state
+ * dhash - dfa state hash value
+ * numas - number of DFA accepting states created; note that this
+ *     is not necessarily the same value as num_rules, which is the analogous
+ *     value for the NFA
+ * numsnpairs - number of state/nextstate transition pairs
+ * jambase - position in base/def where the default jam table starts
+ * jamstate - state number corresponding to "jam" state
+ * end_of_buffer_state - end-of-buffer dfa state number
+ */
+
+extern int current_max_dfa_size, current_max_xpairs;
+extern int current_max_template_xpairs, current_max_dfas;
+extern int lastdfa, *nxt, *chk, *tnxt;
+extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss,
+       *dfasiz;
+extern union dfaacc_union {
+       int    *dfaacc_set;
+       int     dfaacc_state;
+}      *dfaacc;
+extern int *accsiz, *dhash, numas;
+extern int numsnpairs, jambase, jamstate;
+extern int end_of_buffer_state;
+
+/* Variables for ccl information:
+ * lastccl - ccl index of the last created ccl
+ * current_maxccls - current limit on the maximum number of unique ccl's
+ * cclmap - maps a ccl index to its set pointer
+ * ccllen - gives the length of a ccl
+ * cclng - true for a given ccl if the ccl is negated
+ * cclreuse - counts how many times a ccl is re-used
+ * current_max_ccl_tbl_size - current limit on number of characters needed
+ *     to represent the unique ccl's
+ * ccltbl - holds the characters in each ccl - indexed by cclmap
+ */
+
+extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
+extern int current_maxccls, current_max_ccl_tbl_size;
+extern Char *ccltbl;
+
+
+/* Variables for miscellaneous information:
+ * nmstr - last NAME scanned by the scanner
+ * sectnum - section number currently being parsed
+ * nummt - number of empty nxt/chk table entries
+ * hshcol - number of hash collisions detected by snstods
+ * dfaeql - number of times a newly created dfa was equal to an old one
+ * numeps - number of epsilon NFA states created
+ * eps2 - number of epsilon states which have 2 out-transitions
+ * num_reallocs - number of times it was necessary to realloc() a group
+ *       of arrays
+ * tmpuses - number of DFA states that chain to templates
+ * totnst - total number of NFA states used to make DFA states
+ * peakpairs - peak number of transition pairs we had to store internally
+ * numuniq - number of unique transitions
+ * numdup - number of duplicate transitions
+ * hshsave - number of hash collisions saved by checking number of states
+ * num_backing_up - number of DFA states requiring backing up
+ * bol_needed - whether scanner needs beginning-of-line recognition
+ */
+
+extern char nmstr[MAXLINE];
+extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
+extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
+extern int num_backing_up, bol_needed;
+
+void   *allocate_array PROTO ((int, size_t));
+void   *reallocate_array PROTO ((void *, int, size_t));
+
+void   *flex_alloc PROTO ((size_t));
+void   *flex_realloc PROTO ((void *, size_t));
+void flex_free PROTO ((void *));
+
+#define allocate_integer_array(size) \
+       (int *) allocate_array( size, sizeof( int ) )
+
+#define reallocate_integer_array(array,size) \
+       (int *) reallocate_array( (void *) array, size, sizeof( int ) )
+
+#define allocate_bool_array(size) \
+       (bool *) allocate_array( size, sizeof( bool ) )
+
+#define reallocate_bool_array(array,size) \
+       (bool *) reallocate_array( (void *) array, size, sizeof( bool ) )
+
+#define allocate_int_ptr_array(size) \
+       (int **) allocate_array( size, sizeof( int * ) )
+
+#define allocate_char_ptr_array(size) \
+       (char **) allocate_array( size, sizeof( char * ) )
+
+#define allocate_dfaacc_union(size) \
+       (union dfaacc_union *) \
+               allocate_array( size, sizeof( union dfaacc_union ) )
+
+#define reallocate_int_ptr_array(array,size) \
+       (int **) reallocate_array( (void *) array, size, sizeof( int * ) )
+
+#define reallocate_char_ptr_array(array,size) \
+       (char **) reallocate_array( (void *) array, size, sizeof( char * ) )
+
+#define reallocate_dfaacc_union(array, size) \
+       (union dfaacc_union *) \
+       reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) )
+
+#define allocate_character_array(size) \
+       (char *) allocate_array( size, sizeof( char ) )
+
+#define reallocate_character_array(array,size) \
+       (char *) reallocate_array( (void *) array, size, sizeof( char ) )
+
+#define allocate_Character_array(size) \
+       (Char *) allocate_array( size, sizeof( Char ) )
+
+#define reallocate_Character_array(array,size) \
+       (Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
+
+
+/* Used to communicate between scanner and parser.  The type should really
+ * be YYSTYPE, but we can't easily get our hands on it.
+ */
+extern int yylval;
+
+
+/* External functions that are cross-referenced among the flex source files. */
+
+
+/* from file ccl.c */
+
+extern void ccladd PROTO ((int, int)); /* add a single character to a ccl */
+extern int cclinit PROTO ((void));     /* make an empty ccl */
+extern void cclnegate PROTO ((int));   /* negate a ccl */
+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[]));
+
+
+/* from file dfa.c */
+
+/* Check a DFA state for backing up. */
+extern void check_for_backing_up PROTO ((int, int[]));
+
+/* Check to see if NFA state set constitutes "dangerous" trailing context. */
+extern void check_trailing_context PROTO ((int *, int, int *, int));
+
+/* Construct the epsilon closure of a set of ndfa states. */
+extern int *epsclosure PROTO ((int *, int *, int[], int *, int *));
+
+/* Increase the maximum number of dfas. */
+extern void increase_max_dfas PROTO ((void));
+
+extern void ntod PROTO ((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 *));
+
+
+/* from file ecs.c */
+
+/* Convert character classes to set of equivalence classes. */
+extern void ccl2ecl PROTO ((void));
+
+/* Associate equivalence class numbers with class members. */
+extern int cre8ecs PROTO ((int[], int[], int));
+
+/* Update equivalence classes based on character class transitions. */
+extern void mkeccl PROTO ((Char[], int, int[], int[], int, int));
+
+/* Create equivalence class for single character. */
+extern void mkechar PROTO ((int, int[], int[]));
+
+
+/* from file gen.c */
+
+extern void do_indent PROTO ((void));  /* indent to the current level */
+
+/* Generate the code to keep backing-up information. */
+extern void gen_backing_up PROTO ((void));
+
+/* Generate the code to perform the backing up. */
+extern void gen_bu_action PROTO ((void));
+
+/* Generate full speed compressed transition table. */
+extern void genctbl PROTO ((void));
+
+/* Generate the code to find the action number. */
+extern void gen_find_action PROTO ((void));
+
+extern void genftbl PROTO ((void));    /* generate full transition table */
+
+/* Generate the code to find the next compressed-table state. */
+extern void gen_next_compressed_state PROTO ((char *));
+
+/* Generate the code to find the next match. */
+extern void gen_next_match PROTO ((void));
+
+/* Generate the code to find the next state. */
+extern void gen_next_state PROTO ((int));
+
+/* Generate the code to make a NUL transition. */
+extern void gen_NUL_trans PROTO ((void));
+
+/* Generate the code to find the start state. */
+extern void gen_start_state PROTO ((void));
+
+/* Generate data statements for the transition tables. */
+extern void gentabs PROTO ((void));
+
+/* Write out a formatted string at the current indentation level. */
+extern void indent_put2s PROTO ((const char *, const char *));
+
+/* Write out a string + newline at the current indentation level. */
+extern void indent_puts PROTO ((const char *));
+
+extern void make_tables PROTO ((void));        /* generate transition tables */
+
+
+/* from file main.c */
+
+extern void check_options PROTO ((void));
+extern void flexend PROTO ((int));
+extern void usage PROTO ((void));
+
+
+/* from file misc.c */
+
+/* Add a #define to the action file. */
+extern void action_define PROTO ((const char *defname, int value));
+
+/* Add the given text to the stored actions. */
+extern void add_action PROTO ((const char *new_text));
+
+/* True if a string is all lower case. */
+extern int all_lower PROTO ((register char *));
+
+/* True if a string is all upper case. */
+extern int all_upper PROTO ((register char *));
+
+/* Compare two integers for use by qsort. */
+extern int intcmp PROTO ((const void *, const void *));
+
+/* Check a character to make sure it's in the expected range. */
+extern void check_char PROTO ((int c));
+
+/* Replace upper-case letter to lower-case. */
+extern Char clower PROTO ((int));
+
+/* Returns a dynamically allocated copy of a string. */
+extern char *copy_string PROTO ((register const char *));
+
+/* Returns a dynamically allocated copy of a (potentially) unsigned string. */
+extern Char *copy_unsigned_string PROTO ((register Char *));
+
+/* Compare two characters for use by qsort with '\0' sorting last. */
+extern int cclcmp PROTO ((const void *, const void *));
+
+/* Finish up a block of data declarations. */
+extern void dataend PROTO ((void));
+
+/* Flush generated data statements. */
+extern void dataflush PROTO ((void));
+
+/* Report an error message and terminate. */
+extern void flexerror PROTO ((const char *));
+
+/* Report a fatal error message and terminate. */
+extern void flexfatal PROTO ((const char *));
+
+/* Report a fatal error with a pinpoint, and terminate */
+#if HAVE_DECL___FUNC__
+#define flex_die(msg) \
+    do{ \
+        fprintf (stderr,\
+                _("%s: fatal internal error at %s:%d (%s): %s\n"),\
+                program_name, __FILE__, (int)__LINE__,\
+                __func__,msg);\
+        FLEX_EXIT(1);\
+    }while(0)
+#else /* ! HAVE_DECL___FUNC__ */
+#define flex_die(msg) \
+    do{ \
+        fprintf (stderr,\
+                _("%s: fatal internal error at %s:%d %s\n"),\
+                program_name, __FILE__, (int)__LINE__,\
+                msg);\
+        FLEX_EXIT(1);\
+    }while(0)
+#endif /* ! HAVE_DECL___func__ */
+
+/* Convert a hexadecimal digit string to an integer value. */
+extern int htoi PROTO ((Char[]));
+
+/* Report an error message formatted with one integer argument. */
+extern void lerrif PROTO ((const char *, int));
+
+/* Report an error message formatted with one string argument. */
+extern void lerrsf PROTO ((const char *, const char *));
+
+/* Spit out a "#line" statement. */
+extern void line_directive_out PROTO ((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));
+
+/* Mark the current position in the action array as the end of the prolog. */
+extern void mark_prolog PROTO ((void));
+
+/* Generate a data statment for a two-dimensional array. */
+extern void mk2data PROTO ((int));
+
+extern void mkdata PROTO ((int));      /* generate a data statement */
+
+/* Return the integer represented by a string of digits. */
+extern int myctoi PROTO ((const char *));
+
+/* Return character corresponding to escape sequence. */
+extern Char myesc PROTO ((Char[]));
+
+/* Convert an octal digit string to an integer value. */
+extern int otoi PROTO ((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);
+
+/* Return a printable version of the given character, which might be
+ * 8-bit.
+ */
+extern char *readable_form PROTO ((int));
+
+/* Write out one section of the skeleton file. */
+extern void skelout PROTO ((void));
+
+/* Output a yy_trans_info structure. */
+extern void transition_struct_out PROTO ((int, int));
+
+/* Only needed when using certain broken versions of bison to build parse.c. */
+extern void *yy_flex_xmalloc PROTO ((int));
+
+/* Set a region of memory to 0. */
+extern void zero_out PROTO ((char *, size_t));
+
+
+/* from file nfa.c */
+
+/* Add an accepting state to a machine. */
+extern void add_accept PROTO ((int, int));
+
+/* Make a given number of copies of a singleton machine. */
+extern int copysingl PROTO ((int, int));
+
+/* Debugging routine to write out an nfa. */
+extern void dumpnfa PROTO ((int));
+
+/* Finish up the processing for a rule. */
+extern void finish_rule PROTO ((int, int, int, int, int));
+
+/* Connect two machines together. */
+extern int link_machines PROTO ((int, int));
+
+/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
+ * not trailing context associated) state.
+ */
+extern void mark_beginning_as_normal PROTO ((register int));
+
+/* Make a machine that branches to two machines. */
+extern int mkbranch PROTO ((int, int));
+
+extern int mkclos PROTO ((int));       /* convert a machine into a closure */
+extern int mkopt PROTO ((int));        /* make a machine optional */
+
+/* Make a machine that matches either one of two machines. */
+extern int mkor PROTO ((int, int));
+
+/* Convert a machine into a positive closure. */
+extern int mkposcl PROTO ((int));
+
+extern int mkrep PROTO ((int, int, int));      /* make a replicated machine */
+
+/* Create a state with a transition on a given symbol. */
+extern int mkstate PROTO ((int));
+
+extern void new_rule PROTO ((void));   /* initialize for a new rule */
+
+
+/* from file parse.y */
+
+/* Build the "<<EOF>>" action for the active start conditions. */
+extern void build_eof_action PROTO ((void));
+
+/* Write out a message formatted with one string, pinpointing its location. */
+extern void format_pinpoint_message PROTO ((const char *, const char *));
+
+/* Write out a message, pinpointing its location. */
+extern void pinpoint_message PROTO ((const char *));
+
+/* Write out a warning, pinpointing it at the given line. */
+extern void line_warning PROTO ((const char *, int));
+
+/* Write out a message, pinpointing it at the given line. */
+extern void line_pinpoint PROTO ((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 */
+
+
+/* from file scan.l */
+
+/* The Flex-generated scanner for flex. */
+extern int flexscan PROTO ((void));
+
+/* Open the given file (if NULL, stdin) for scanning. */
+extern void set_input_file PROTO ((char *));
+
+/* Wrapup a file in the lexical analyzer. */
+extern int yywrap PROTO ((void));
+
+
+/* from file sym.c */
+
+/* Save the text of a character class. */
+extern void cclinstal PROTO ((Char[], int));
+
+/* Lookup the number associated with character class. */
+extern int ccllookup PROTO ((Char[]));
+
+extern void ndinstal PROTO ((const char *, Char[]));   /* install a name definition */
+extern Char *ndlookup PROTO ((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 */
+
+/* Lookup the number associated with a start condition. */
+extern int sclookup PROTO ((const char *));
+
+
+/* from file tblcmp.c */
+
+/* Build table entries for dfa state. */
+extern void bldtbl PROTO ((int[], int, int, int, int));
+
+extern void cmptmps PROTO ((void));    /* compress template table entries */
+extern void expand_nxt_chk PROTO ((void));     /* increase nxt/chk arrays */
+
+/* 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 */
+
+/* Make the default, "jam" table entries. */
+extern void mkdeftbl PROTO ((void));
+
+/* Create table entries for a state (or state fragment) which has
+ * only one out-transition.
+ */
+extern void mk1tbl PROTO ((int, int, int, int));
+
+/* Place a state into full speed transition table. */
+extern void place_state PROTO ((int *, int, int));
+
+/* Save states with only one out-transition to be processed later. */
+extern void stack1 PROTO ((int, int, int, int));
+
+
+/* from file yylex.c */
+
+extern int yylex PROTO ((void));
+
+/* A growable array. See buf.c. */
+struct Buf {
+       void   *elts;           /* elements. */
+       int     nelts;          /* number of elements. */
+       size_t  elt_size;       /* in bytes. */
+       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 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. */
+extern struct Buf yydmap_buf;  /* a string buffer to hold yydmap elements */
+extern struct Buf m4defs_buf;  /* Holds m4 definitions. */
+extern struct Buf top_buf;     /* contains %top code. String buffer. */
+
+/* For blocking out code from the header file. */
+#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[")
+#define OUT_END_CODE()   outn("]])")
+
+/* For setjmp/longjmp (instead of calling exit(2)). Linkage in main.c */
+extern jmp_buf flex_main_jmp_buf;
+
+#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1)
+
+/* Removes all \n and \r chars from tail of str. returns str. */
+extern char *chomp (char *str);
+
+/* ctype functions forced to return boolean */
+#define b_isalnum(c) (isalnum(c)?true:false)
+#define b_isalpha(c) (isalpha(c)?true:false)
+#define b_isascii(c) (isascii(c)?true:false)
+#define b_isblank(c) (isblank(c)?true:false)
+#define b_iscntrl(c) (iscntrl(c)?true:false)
+#define b_isdigit(c) (isdigit(c)?true:false)
+#define b_isgraph(c) (isgraph(c)?true:false)
+#define b_islower(c) (islower(c)?true:false)
+#define b_isprint(c) (isprint(c)?true:false)
+#define b_ispunct(c) (ispunct(c)?true:false)
+#define b_isspace(c) (isspace(c)?true:false)
+#define b_isupper(c) (isupper(c)?true:false)
+#define b_isxdigit(c) (isxdigit(c)?true:false)
+
+/* return true if char is uppercase or lowercase. */
+bool has_case(int c);
+
+/* Change case of character if possible. */
+int reverse_case(int c);
+
+/* return false if [c1-c2] is ambiguous for a caseless scanner. */
+bool range_covers_case (int c1, int c2);
+
+/*
+ *  From "filter.c"
+ */
+
+/** A single stdio filter to execute.
+ *  The filter may be external, such as "sed", or it
+ *  may be internal, as a function call.
+ */
+struct filter {
+    int    (*filter_func)(struct filter*); /**< internal filter function */
+    void * extra;         /**< extra data passed to filter_func */
+       int     argc;         /**< arg count */
+       const char ** argv;   /**< arg vector, \0-terminated */
+    struct filter * next; /**< next filter or NULL */
+};
+
+/* 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,
+                                 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));
+
+
+/*
+ * From "regex.c"
+ */
+
+extern regex_t regex_linedir, regex_blank_line;
+bool flex_init_regex(void);
+void flex_regcomp(regex_t *preg, const char *regex, int cflags);
+char   *regmatch_dup (regmatch_t * m, const char *src);
+char   *regmatch_cpy (regmatch_t * m, char *dest, const char *src);
+int regmatch_len (regmatch_t * m);
+int regmatch_strtol (regmatch_t * m, const char *src, char **endptr, int base);
+bool regmatch_empty (regmatch_t * m);
+
+/* From "scanflags.h" */
+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_top()           (_sf_stk[_sf_top_ix])
+#define sf_case_ins()      (sf_top() & _SF_CASE_INS)
+#define sf_dot_all()       (sf_top() & _SF_DOT_ALL)
+#define sf_skip_ws()       (sf_top() & _SF_SKIP_WS)
+#define sf_set_case_ins(X)      ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS))
+#define sf_set_dot_all(X)       ((X) ? (sf_top() |= _SF_DOT_ALL)  : (sf_top() &= ~_SF_DOT_ALL))
+#define sf_set_skip_ws(X)       ((X) ? (sf_top() |= _SF_SKIP_WS)  : (sf_top() &= ~_SF_SKIP_WS))
+extern void sf_init(void);
+extern void sf_push(void);
+extern void sf_pop(void);
+
+
+#endif /* not defined FLEXDEF_H */
diff --git a/contrib/flex/flexint.h b/contrib/flex/flexint.h
new file mode 100644 (file)
index 0000000..f9fa80c
--- /dev/null
@@ -0,0 +1,63 @@
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
diff --git a/contrib/flex/gen.c b/contrib/flex/gen.c
new file mode 100644 (file)
index 0000000..5a5daef
--- /dev/null
@@ -0,0 +1,2169 @@
+/* gen - actual generation (writing) of flex scanners */
+
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  Neither the name of the University nor the names of its contributors */
+/*  may be used to endorse or promote products derived from this software */
+/*  without specific prior written permission. */
+
+/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/*  PURPOSE. */
+
+#include "flexdef.h"
+#include "tables.h"
+
+
+/* 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 *));
+
+
+static int indent_level = 0;   /* each level is 8 spaces */
+
+#define indent_up() (++indent_level)
+#define indent_down() (--indent_level)
+#define set_indent(indent_val) indent_level = indent_val
+
+/* Almost everything is done in terms of arrays starting at 1, so provide
+ * a null entry for the zero element of all C arrays.  (The exception
+ * to this is that the fast table representation generally uses the
+ * 0 elements of its arrays, too.)
+ */
+
+static const char *get_int16_decl (void)
+{
+       return (gentables)
+               ? "static yyconst flex_int16_t %s[%d] =\n    {   0,\n"
+               : "static yyconst flex_int16_t * %s = 0;\n";
+}
+
+
+static const char *get_int32_decl (void)
+{
+       return (gentables)
+               ? "static yyconst flex_int32_t %s[%d] =\n    {   0,\n"
+               : "static yyconst flex_int32_t * %s = 0;\n";
+}
+
+static const char *get_state_decl (void)
+{
+       return (gentables)
+               ? "static yyconst yy_state_type %s[%d] =\n    {   0,\n"
+               : "static yyconst yy_state_type * %s = 0;\n";
+}
+
+/* Indent to the current level. */
+
+void do_indent ()
+{
+       register int i = indent_level * 8;
+
+       while (i >= 8) {
+               outc ('\t');
+               i -= 8;
+       }
+
+       while (i > 0) {
+               outc (' ');
+               --i;
+       }
+}
+
+
+/** Make the table for possible eol matches.
+ *  @return the newly allocated rule_can_match_eol table
+ */
+static struct yytbl_data *mkeoltbl (void)
+{
+       int     i;
+       flex_int8_t *tdata = 0;
+       struct yytbl_data *tbl;
+
+       tbl = (struct yytbl_data *) 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));
+
+       for (i = 1; i <= num_rules; i++)
+               tdata[i] = rule_has_nl[i] ? 1 : 0;
+
+       buf_prints (&yydmap_buf,
+                   "\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n",
+                   "flex_int32_t");
+       return tbl;
+}
+
+/* Generate the table for possible eol matches. */
+static void geneoltbl ()
+{
+       int     i;
+
+       outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");
+       outn ("/* Table of booleans, true if rule could match eol. */");
+       out_str_dec (get_int32_decl (), "yy_rule_can_match_eol",
+                    num_rules + 1);
+
+       if (gentables) {
+               for (i = 1; i <= num_rules; i++) {
+                       out_dec ("%d, ", rule_has_nl[i] ? 1 : 0);
+                       /* format nicely, 20 numbers per line. */
+                       if ((i % 20) == 19)
+                               out ("\n    ");
+               }
+               out ("    };\n");
+       }
+       outn ("]])");
+}
+
+
+/* Generate the code to keep backing-up information. */
+
+void gen_backing_up ()
+{
+       if (reject || num_backing_up == 0)
+               return;
+
+       if (fullspd)
+               indent_puts ("if ( yy_current_state[-1].yy_nxt )");
+       else
+               indent_puts ("if ( yy_accept[yy_current_state] )");
+
+       indent_up ();
+       indent_puts ("{");
+       indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;");
+       indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;");
+       indent_puts ("}");
+       indent_down ();
+}
+
+
+/* Generate the code to perform the backing up. */
+
+void gen_bu_action ()
+{
+       if (reject || num_backing_up == 0)
+               return;
+
+       set_indent (3);
+
+       indent_puts ("case 0: /* must back up */");
+       indent_puts ("/* undo the effects of YY_DO_BEFORE_ACTION */");
+       indent_puts ("*yy_cp = YY_G(yy_hold_char);");
+
+       if (fullspd || fulltbl)
+               indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos) + 1;");
+       else
+               /* Backing-up info for compressed tables is taken \after/
+                * yy_cp has been incremented for the next state.
+                */
+               indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos);");
+
+       indent_puts ("yy_current_state = YY_G(yy_last_accepting_state);");
+       indent_puts ("goto yy_find_action;");
+       outc ('\n');
+
+       set_indent (0);
+}
+
+/** mkctbl - make full speed compressed transition table
+ * This is an array of structs; each struct a pair of integers.
+ * You should call mkssltbl() immediately after this.
+ * Then, I think, mkecstbl(). Arrrg.
+ * @return the newly allocated trans table
+ */
+
+static struct yytbl_data *mkctbl (void)
+{
+       register int i;
+       struct yytbl_data *tbl = 0;
+       flex_int32_t *tdata = 0, curr = 0;
+       int     end_of_buffer_action = num_rules + 1;
+
+       buf_prints (&yydmap_buf,
+                   "\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n",
+                   ((tblend + numecs + 1) >= INT16_MAX
+                    || long_align) ? "flex_int32_t" : "flex_int16_t");
+
+       tbl = (struct yytbl_data *) 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));
+
+       /* We want the transition to be represented as the offset to the
+        * next state, not the actual state number, which is what it currently
+        * is.  The offset is base[nxt[i]] - (base of current state)].  That's
+        * just the difference between the starting points of the two involved
+        * states (to - from).
+        *
+        * First, though, we need to find some way to put in our end-of-buffer
+        * flags and states.  We do this by making a state with absolutely no
+        * transitions.  We put it at the end of the table.
+        */
+
+       /* We need to have room in nxt/chk for two more slots: One for the
+        * action and one for the end-of-buffer transition.  We now *assume*
+        * that we're guaranteed the only character we'll try to index this
+        * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
+        * there's room for jam entries for other characters.
+        */
+
+       while (tblend + 2 >= current_max_xpairs)
+               expand_nxt_chk ();
+
+       while (lastdfa + 1 >= current_max_dfas)
+               increase_max_dfas ();
+
+       base[lastdfa + 1] = tblend + 2;
+       nxt[tblend + 1] = end_of_buffer_action;
+       chk[tblend + 1] = numecs + 1;
+       chk[tblend + 2] = 1;    /* anything but EOB */
+
+       /* So that "make test" won't show arb. differences. */
+       nxt[tblend + 2] = 0;
+
+       /* Make sure every state has an end-of-buffer transition and an
+        * action #.
+        */
+       for (i = 0; i <= lastdfa; ++i) {
+               int     anum = dfaacc[i].dfaacc_state;
+               int     offset = base[i];
+
+               chk[offset] = EOB_POSITION;
+               chk[offset - 1] = ACTION_POSITION;
+               nxt[offset - 1] = anum; /* action number */
+       }
+
+       for (i = 0; i <= tblend; ++i) {
+               if (chk[i] == EOB_POSITION) {
+                       tdata[curr++] = 0;
+                       tdata[curr++] = base[lastdfa + 1] - i;
+               }
+
+               else if (chk[i] == ACTION_POSITION) {
+                       tdata[curr++] = 0;
+                       tdata[curr++] = nxt[i];
+               }
+
+               else if (chk[i] > numecs || chk[i] == 0) {
+                       tdata[curr++] = 0;
+                       tdata[curr++] = 0;
+               }
+               else {          /* verify, transition */
+
+                       tdata[curr++] = chk[i];
+                       tdata[curr++] = base[nxt[i]] - (i - chk[i]);
+               }
+       }
+
+
+       /* Here's the final, end-of-buffer state. */
+       tdata[curr++] = chk[tblend + 1];
+       tdata[curr++] = nxt[tblend + 1];
+
+       tdata[curr++] = chk[tblend + 2];
+       tdata[curr++] = nxt[tblend + 2];
+
+       return tbl;
+}
+
+
+/** Make start_state_list table.
+ *  @return the newly allocated start_state_list table
+ */
+static struct yytbl_data *mkssltbl (void)
+{
+       struct yytbl_data *tbl = 0;
+       flex_int32_t *tdata = 0;
+       flex_int32_t i;
+
+       tbl = (struct yytbl_data *) 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));
+
+       for (i = 0; i <= lastsc * 2; ++i)
+               tdata[i] = base[i];
+
+       buf_prints (&yydmap_buf,
+                   "\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n",
+                   "struct yy_trans_info*");
+
+       return tbl;
+}
+
+
+
+/* genctbl - generates full speed compressed transition table */
+
+void genctbl ()
+{
+       register int i;
+       int     end_of_buffer_action = num_rules + 1;
+
+       /* Table of verify for transition and offset to next state. */
+       if (gentables)
+               out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n    {\n", tblend + numecs + 1);
+       else
+               outn ("static yyconst struct yy_trans_info *yy_transition = 0;");
+
+       /* We want the transition to be represented as the offset to the
+        * next state, not the actual state number, which is what it currently
+        * is.  The offset is base[nxt[i]] - (base of current state)].  That's
+        * just the difference between the starting points of the two involved
+        * states (to - from).
+        *
+        * First, though, we need to find some way to put in our end-of-buffer
+        * flags and states.  We do this by making a state with absolutely no
+        * transitions.  We put it at the end of the table.
+        */
+
+       /* We need to have room in nxt/chk for two more slots: One for the
+        * action and one for the end-of-buffer transition.  We now *assume*
+        * that we're guaranteed the only character we'll try to index this
+        * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
+        * there's room for jam entries for other characters.
+        */
+
+       while (tblend + 2 >= current_max_xpairs)
+               expand_nxt_chk ();
+
+       while (lastdfa + 1 >= current_max_dfas)
+               increase_max_dfas ();
+
+       base[lastdfa + 1] = tblend + 2;
+       nxt[tblend + 1] = end_of_buffer_action;
+       chk[tblend + 1] = numecs + 1;
+       chk[tblend + 2] = 1;    /* anything but EOB */
+
+       /* So that "make test" won't show arb. differences. */
+       nxt[tblend + 2] = 0;
+
+       /* Make sure every state has an end-of-buffer transition and an
+        * action #.
+        */
+       for (i = 0; i <= lastdfa; ++i) {
+               int     anum = dfaacc[i].dfaacc_state;
+               int     offset = base[i];
+
+               chk[offset] = EOB_POSITION;
+               chk[offset - 1] = ACTION_POSITION;
+               nxt[offset - 1] = anum; /* action number */
+       }
+
+       for (i = 0; i <= tblend; ++i) {
+               if (chk[i] == EOB_POSITION)
+                       transition_struct_out (0, base[lastdfa + 1] - i);
+
+               else if (chk[i] == ACTION_POSITION)
+                       transition_struct_out (0, nxt[i]);
+
+               else if (chk[i] > numecs || chk[i] == 0)
+                       transition_struct_out (0, 0);   /* unused slot */
+
+               else            /* verify, transition */
+                       transition_struct_out (chk[i],
+                                              base[nxt[i]] - (i -
+                                                              chk[i]));
+       }
+
+
+       /* Here's the final, end-of-buffer state. */
+       transition_struct_out (chk[tblend + 1], nxt[tblend + 1]);
+       transition_struct_out (chk[tblend + 2], nxt[tblend + 2]);
+
+       if (gentables)
+               outn ("    };\n");
+
+       /* Table of pointers to start states. */
+       if (gentables)
+               out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1);
+       else
+               outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;");
+
+       if (gentables) {
+               outn ("    {");
+
+               for (i = 0; i <= lastsc * 2; ++i)
+                       out_dec ("    &yy_transition[%d],\n", base[i]);
+
+               dataend ();
+       }
+
+       if (useecs)
+               genecs ();
+}
+
+
+/* mkecstbl - Make equivalence-class tables.  */
+
+struct yytbl_data *mkecstbl (void)
+{
+       register int i;
+       struct yytbl_data *tbl = 0;
+       flex_int32_t *tdata = 0;
+
+       tbl = (struct yytbl_data *) 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));
+
+       for (i = 1; i < csize; ++i) {
+               ecgroup[i] = ABS (ecgroup[i]);
+               tdata[i] = ecgroup[i];
+       }
+
+       buf_prints (&yydmap_buf,
+                   "\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n",
+                   "flex_int32_t");
+
+       return tbl;
+}
+
+/* Generate equivalence-class tables. */
+
+void genecs ()
+{
+       register int i, j;
+       int     numrows;
+
+       out_str_dec (get_int32_decl (), "yy_ec", csize);
+
+       for (i = 1; i < csize; ++i) {
+               ecgroup[i] = ABS (ecgroup[i]);
+               mkdata (ecgroup[i]);
+       }
+
+       dataend ();
+
+       if (trace) {
+               fputs (_("\n\nEquivalence Classes:\n\n"), stderr);
+
+               numrows = csize / 8;
+
+               for (j = 0; j < numrows; ++j) {
+                       for (i = j; i < csize; i = i + numrows) {
+                               fprintf (stderr, "%4s = %-2d",
+                                        readable_form (i), ecgroup[i]);
+
+                               putc (' ', stderr);
+                       }
+
+                       putc ('\n', stderr);
+               }
+       }
+}
+
+
+/* Generate the code to find the action number. */
+
+void gen_find_action ()
+{
+       if (fullspd)
+               indent_puts ("yy_act = yy_current_state[-1].yy_nxt;");
+
+       else if (fulltbl)
+               indent_puts ("yy_act = yy_accept[yy_current_state];");
+
+       else if (reject) {
+               indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");
+               indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");
+
+               outn ("find_rule: /* we branch to this label when backing up */");
+
+               indent_puts
+                       ("for ( ; ; ) /* until we find what rule we matched */");
+
+               indent_up ();
+
+               indent_puts ("{");
+
+               indent_puts
+                       ("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )");
+               indent_up ();
+               indent_puts ("{");
+               indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];");
+
+               if (variable_trailing_context_rules) {
+                       indent_puts
+                               ("if ( yy_act & YY_TRAILING_HEAD_MASK ||");
+                       indent_puts ("     YY_G(yy_looking_for_trail_begin) )");
+                       indent_up ();
+                       indent_puts ("{");
+
+                       indent_puts
+                               ("if ( yy_act == YY_G(yy_looking_for_trail_begin) )");
+                       indent_up ();
+                       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_puts ("}");
+                       indent_down ();
+
+                       indent_puts
+                               ("else if ( yy_act & YY_TRAILING_MASK )");
+                       indent_up ();
+                       indent_puts ("{");
+                       indent_puts
+                               ("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;");
+                       indent_puts
+                               ("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;");
+
+                       if (real_reject) {
+                               /* Remember matched text in case we back up
+                                * due to REJECT.
+                                */
+                               indent_puts
+                                       ("YY_G(yy_full_match) = yy_cp;");
+                               indent_puts
+                                       ("YY_G(yy_full_state) = YY_G(yy_state_ptr);");
+                               indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
+                       }
+
+                       indent_puts ("}");
+                       indent_down ();
+
+                       indent_puts ("else");
+                       indent_up ();
+                       indent_puts ("{");
+                       indent_puts ("YY_G(yy_full_match) = yy_cp;");
+                       indent_puts
+                               ("YY_G(yy_full_state) = YY_G(yy_state_ptr);");
+                       indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
+                       indent_puts ("break;");
+                       indent_puts ("}");
+                       indent_down ();
+
+                       indent_puts ("++YY_G(yy_lp);");
+                       indent_puts ("goto find_rule;");
+               }
+
+               else {
+                       /* Remember matched text in case we back up due to
+                        * trailing context plus REJECT.
+                        */
+                       indent_up ();
+                       indent_puts ("{");
+                       indent_puts ("YY_G(yy_full_match) = yy_cp;");
+                       indent_puts ("break;");
+                       indent_puts ("}");
+                       indent_down ();
+               }
+
+               indent_puts ("}");
+               indent_down ();
+
+               indent_puts ("--yy_cp;");
+
+               /* We could consolidate the following two lines with those at
+                * the beginning, but at the cost of complaints that we're
+                * branching inside a loop.
+                */
+               indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");
+               indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");
+
+               indent_puts ("}");
+
+               indent_down ();
+       }
+
+       else {                  /* compressed */
+               indent_puts ("yy_act = yy_accept[yy_current_state];");
+
+               if (interactive && !reject) {
+                       /* Do the guaranteed-needed backing up to figure out
+                        * the match.
+                        */
+                       indent_puts ("if ( yy_act == 0 )");
+                       indent_up ();
+                       indent_puts ("{ /* have to back up */");
+                       indent_puts
+                               ("yy_cp = YY_G(yy_last_accepting_cpos);");
+                       indent_puts
+                               ("yy_current_state = YY_G(yy_last_accepting_state);");
+                       indent_puts
+                               ("yy_act = yy_accept[yy_current_state];");
+                       indent_puts ("}");
+                       indent_down ();
+               }
+       }
+}
+
+/* mkftbl - make the full table and return the struct .
+ * you should call mkecstbl() after this.
+ */
+
+struct yytbl_data *mkftbl (void)
+{
+       register int i;
+       int     end_of_buffer_action = num_rules + 1;
+       struct yytbl_data *tbl;
+       flex_int32_t *tdata = 0;
+
+       tbl = (struct yytbl_data *) 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));
+
+       dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
+
+       for (i = 1; i <= lastdfa; ++i) {
+               register int anum = dfaacc[i].dfaacc_state;
+
+               tdata[i] = anum;
+
+               if (trace && anum)
+                       fprintf (stderr, _("state # %d accepts: [%d]\n"),
+                                i, anum);
+       }
+
+       buf_prints (&yydmap_buf,
+                   "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
+                   long_align ? "flex_int32_t" : "flex_int16_t");
+       return tbl;
+}
+
+
+/* genftbl - generate full transition table */
+
+void genftbl ()
+{
+       register int i;
+       int     end_of_buffer_action = num_rules + 1;
+
+       out_str_dec (long_align ? get_int32_decl () : get_int16_decl (),
+                    "yy_accept", lastdfa + 1);
+
+       dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
+
+       for (i = 1; i <= lastdfa; ++i) {
+               register int anum = dfaacc[i].dfaacc_state;
+
+               mkdata (anum);
+
+               if (trace && anum)
+                       fprintf (stderr, _("state # %d accepts: [%d]\n"),
+                                i, anum);
+       }
+
+       dataend ();
+
+       if (useecs)
+               genecs ();
+
+       /* Don't have to dump the actual full table entries - they were
+        * created on-the-fly.
+        */
+}
+
+
+/* Generate the code to find the next compressed-table state. */
+
+void gen_next_compressed_state (char_map)
+     char   *char_map;
+{
+       indent_put2s ("register YY_CHAR yy_c = %s;", char_map);
+
+       /* Save the backing-up info \before/ computing the next state
+        * because we always compute one more state than needed - we
+        * always proceed until we reach a jam state
+        */
+       gen_backing_up ();
+
+       indent_puts
+               ("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )");
+       indent_up ();
+       indent_puts ("{");
+       indent_puts ("yy_current_state = (int) yy_def[yy_current_state];");
+
+       if (usemecs) {
+               /* We've arrange it so that templates are never chained
+                * to one another.  This means we can afford to make a
+                * very simple test to see if we need to convert to
+                * yy_c's meta-equivalence class without worrying
+                * about erroneously looking up the meta-equivalence
+                * class twice
+                */
+               do_indent ();
+
+               /* lastdfa + 2 is the beginning of the templates */
+               out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2);
+
+               indent_up ();
+               indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];");
+               indent_down ();
+       }
+
+       indent_puts ("}");
+       indent_down ();
+
+       indent_puts
+               ("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];");
+}
+
+
+/* Generate the code to find the next match. */
+
+void gen_next_match ()
+{
+       /* NOTE - changes in here should be reflected in gen_next_state() and
+        * gen_NUL_trans().
+        */
+       char   *char_map = useecs ?
+               "yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)";
+
+       char   *char_map_2 = useecs ?
+               "yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)";
+
+       if (fulltbl) {
+               if (gentables)
+                       indent_put2s
+                               ("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )",
+                                char_map);
+               else
+                       indent_put2s
+                               ("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN +  %s ]) > 0 )",
+                                char_map);
+
+               indent_up ();
+
+               if (num_backing_up > 0) {
+                       indent_puts ("{");
+                       gen_backing_up ();
+                       outc ('\n');
+               }
+
+               indent_puts ("++yy_cp;");
+
+               if (num_backing_up > 0)
+
+                       indent_puts ("}");
+
+               indent_down ();
+
+               outc ('\n');
+               indent_puts ("yy_current_state = -yy_current_state;");
+       }
+
+       else if (fullspd) {
+               indent_puts ("{");
+               indent_puts
+                       ("register yyconst struct yy_trans_info *yy_trans_info;\n");
+               indent_puts ("register YY_CHAR yy_c;\n");
+               indent_put2s ("for ( yy_c = %s;", char_map);
+               indent_puts
+                       ("      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->");
+               indent_puts ("yy_verify == yy_c;");
+               indent_put2s ("      yy_c = %s )", char_map_2);
+
+               indent_up ();
+
+               if (num_backing_up > 0)
+                       indent_puts ("{");
+
+               indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");
+
+               if (num_backing_up > 0) {
+                       outc ('\n');
+                       gen_backing_up ();
+                       indent_puts ("}");
+               }
+
+               indent_down ();
+               indent_puts ("}");
+       }
+
+       else {                  /* compressed */
+               indent_puts ("do");
+
+               indent_up ();
+               indent_puts ("{");
+
+               gen_next_state (false);
+
+               indent_puts ("++yy_cp;");
+
+
+               indent_puts ("}");
+               indent_down ();
+
+               do_indent ();
+
+               if (interactive)
+                       out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase);
+               else
+                       out_dec ("while ( yy_current_state != %d );\n",
+                                jamstate);
+
+               if (!reject && !interactive) {
+                       /* Do the guaranteed-needed backing up to figure out
+                        * the match.
+                        */
+                       indent_puts
+                               ("yy_cp = YY_G(yy_last_accepting_cpos);");
+                       indent_puts
+                               ("yy_current_state = YY_G(yy_last_accepting_state);");
+               }
+       }
+}
+
+
+/* Generate the code to find the next state. */
+
+void gen_next_state (worry_about_NULs)
+     int worry_about_NULs;
+{                              /* NOTE - changes in here should be reflected in gen_next_match() */
+       char    char_map[256];
+
+       if (worry_about_NULs && !nultrans) {
+               if (useecs)
+                       snprintf (char_map, sizeof(char_map),
+                                       "(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)",
+                                       NUL_ec);
+               else
+            snprintf (char_map, sizeof(char_map),
+                                       "(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)",
+                                       NUL_ec);
+       }
+
+       else
+               strcpy (char_map, useecs ?
+                       "yy_ec[YY_SC_TO_UI(*yy_cp)]" :
+                       "YY_SC_TO_UI(*yy_cp)");
+
+       if (worry_about_NULs && nultrans) {
+               if (!fulltbl && !fullspd)
+                       /* Compressed tables back up *before* they match. */
+                       gen_backing_up ();
+
+               indent_puts ("if ( *yy_cp )");
+               indent_up ();
+               indent_puts ("{");
+       }
+
+       if (fulltbl) {
+               if (gentables)
+                       indent_put2s
+                               ("yy_current_state = yy_nxt[yy_current_state][%s];",
+                                char_map);
+               else
+                       indent_put2s
+                               ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s];",
+                                char_map);
+       }
+
+       else if (fullspd)
+               indent_put2s
+                       ("yy_current_state += yy_current_state[%s].yy_nxt;",
+                        char_map);
+
+       else
+               gen_next_compressed_state (char_map);
+
+       if (worry_about_NULs && nultrans) {
+
+               indent_puts ("}");
+               indent_down ();
+               indent_puts ("else");
+               indent_up ();
+               indent_puts
+                       ("yy_current_state = yy_NUL_trans[yy_current_state];");
+               indent_down ();
+       }
+
+       if (fullspd || fulltbl)
+               gen_backing_up ();
+
+       if (reject)
+               indent_puts ("*YY_G(yy_state_ptr)++ = yy_current_state;");
+}
+
+
+/* Generate the code to make a NUL transition. */
+
+void gen_NUL_trans ()
+{                              /* NOTE - changes in here should be reflected in gen_next_match() */
+       /* Only generate a definition for "yy_cp" if we'll generate code
+        * that uses it.  Otherwise lint and the like complain.
+        */
+       int     need_backing_up = (num_backing_up > 0 && !reject);
+
+       if (need_backing_up && (!nultrans || fullspd || fulltbl))
+               /* We're going to need yy_cp lying around for the call
+                * below to gen_backing_up().
+                */
+               indent_puts ("register char *yy_cp = YY_G(yy_c_buf_p);");
+
+       outc ('\n');
+
+       if (nultrans) {
+               indent_puts
+                       ("yy_current_state = yy_NUL_trans[yy_current_state];");
+               indent_puts ("yy_is_jam = (yy_current_state == 0);");
+       }
+
+       else if (fulltbl) {
+               do_indent ();
+               if (gentables)
+                       out_dec ("yy_current_state = yy_nxt[yy_current_state][%d];\n", NUL_ec);
+               else
+                       out_dec ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %d];\n", NUL_ec);
+               indent_puts ("yy_is_jam = (yy_current_state <= 0);");
+       }
+
+       else if (fullspd) {
+               do_indent ();
+               out_dec ("register int yy_c = %d;\n", NUL_ec);
+
+               indent_puts
+                       ("register yyconst struct yy_trans_info *yy_trans_info;\n");
+               indent_puts
+                       ("yy_trans_info = &yy_current_state[(unsigned int) yy_c];");
+               indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");
+
+               indent_puts
+                       ("yy_is_jam = (yy_trans_info->yy_verify != yy_c);");
+       }
+
+       else {
+               char    NUL_ec_str[20];
+
+               snprintf (NUL_ec_str, sizeof(NUL_ec_str), "%d", NUL_ec);
+               gen_next_compressed_state (NUL_ec_str);
+
+               do_indent ();
+               out_dec ("yy_is_jam = (yy_current_state == %d);\n",
+                        jamstate);
+
+               if (reject) {
+                       /* Only stack this state if it's a transition we
+                        * actually make.  If we stack it on a jam, then
+                        * the state stack and yy_c_buf_p get out of sync.
+                        */
+                       indent_puts ("if ( ! yy_is_jam )");
+                       indent_up ();
+                       indent_puts
+                               ("*YY_G(yy_state_ptr)++ = yy_current_state;");
+                       indent_down ();
+               }
+       }
+
+       /* If we've entered an accepting state, back up; note that
+        * compressed tables have *already* done such backing up, so
+        * we needn't bother with it again.
+        */
+       if (need_backing_up && (fullspd || fulltbl)) {
+               outc ('\n');
+               indent_puts ("if ( ! yy_is_jam )");
+               indent_up ();
+               indent_puts ("{");
+               gen_backing_up ();
+               indent_puts ("}");
+               indent_down ();
+       }
+}
+
+
+/* Generate the code to find the start state. */
+
+void gen_start_state ()
+{
+       if (fullspd) {
+               if (bol_needed) {
+                       indent_puts
+                               ("yy_current_state = yy_start_state_list[YY_G(yy_start) + YY_AT_BOL()];");
+               }
+               else
+                       indent_puts
+                               ("yy_current_state = yy_start_state_list[YY_G(yy_start)];");
+       }
+
+       else {
+               indent_puts ("yy_current_state = YY_G(yy_start);");
+
+               if (bol_needed)
+                       indent_puts ("yy_current_state += YY_AT_BOL();");
+
+               if (reject) {
+                       /* Set up for storing up states. */
+                       outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[[");
+                       indent_puts
+                               ("YY_G(yy_state_ptr) = YY_G(yy_state_buf);");
+                       indent_puts
+                               ("*YY_G(yy_state_ptr)++ = yy_current_state;");
+                       outn ("]])");
+               }
+       }
+}
+
+
+/* gentabs - generate data statements for the transition tables */
+
+void gentabs ()
+{
+       int     i, j, k, *accset, nacc, *acc_array, total_states;
+       int     end_of_buffer_action = num_rules + 1;
+       struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0,
+               *yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0;
+       flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0,
+               *yynxt_data = 0, *yychk_data = 0, *yyacclist_data=0;
+       flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0;
+
+       acc_array = allocate_integer_array (current_max_dfas);
+       nummt = 0;
+
+       /* The compressed table format jams by entering the "jam state",
+        * losing information about the previous state in the process.
+        * In order to recover the previous state, we effectively need
+        * to keep backing-up information.
+        */
+       ++num_backing_up;
+
+       if (reject) {
+               /* Write out accepting list and pointer list.
+
+                * First we generate the "yy_acclist" array.  In the process,
+                * we compute the indices that will go into the "yy_accept"
+                * array, and save the indices in the dfaacc array.
+                */
+               int     EOB_accepting_list[2];
+
+               /* Set up accepting structures for the End Of Buffer state. */
+               EOB_accepting_list[0] = 0;
+               EOB_accepting_list[1] = end_of_buffer_action;
+               accsiz[end_of_buffer_state] = 1;
+               dfaacc[end_of_buffer_state].dfaacc_set =
+                       EOB_accepting_list;
+
+               out_str_dec (long_align ? get_int32_decl () :
+                            get_int16_decl (), "yy_acclist", MAX (numas,
+                                                                  1) + 1);
+        
+        buf_prints (&yydmap_buf,
+                "\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));
+        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));
+        yyacclist_curr = 1;
+
+               j = 1;          /* index into "yy_acclist" array */
+
+               for (i = 1; i <= lastdfa; ++i) {
+                       acc_array[i] = j;
+
+                       if (accsiz[i] != 0) {
+                               accset = dfaacc[i].dfaacc_set;
+                               nacc = accsiz[i];
+
+                               if (trace)
+                                       fprintf (stderr,
+                                                _("state # %d accepts: "),
+                                                i);
+
+                               for (k = 1; k <= nacc; ++k) {
+                                       int     accnum = accset[k];
+
+                                     &n