Increased gnu make compatibility.

18 files changed, 4149 insertions, 1746 deletions

diff --git a/tools/mhmake/src/build.cpp b/tools/mhmake/src/build.cpp
index 525ff8c05..3a6af155c 100644
--- a/tools/mhmake/src/build.cpp
+++ b/tools/mhmake/src/build.cpp
@@ -440,7 +440,7 @@ mh_pid_t mhmakefileparser::DeleteFiles(const string &Params) const
       if (DeleteDir(FileName,DirSearch,bRemoveDir) && !IgnoreError)

       {

         cerr << "Error deleting "<<FileName<<endl;

-        return false;

+        return (mh_pid_t)-1;

       }

     }

     else

@@ -866,7 +866,7 @@ string mhmakefileparser::GetFullCommand(string Command)
     const char *pBeg=Command.c_str();

     const char *pEnd=pBeg+Command.length()-1;

     bool HasExt=false;

-    while (pEnd>pBeg && *pEnd!=OSPATHSEP)

+    while (pEnd>pBeg && *pEnd!='\\' && *pEnd!='/')

     {

       if (*pEnd=='.')

       {

@@ -1315,7 +1315,7 @@ mh_pid_t mhmakefileparser::ExecuteCommand(string Command, bool &IgnoreError, str
 {

   bool Echo=true;

   IgnoreError=false;

-  while (1)

+  while (Command.length())

   {

     if (Command[0]=='@')

     {

@@ -1331,6 +1331,8 @@ mh_pid_t mhmakefileparser::ExecuteCommand(string Command, bool &IgnoreError, str
     }

     break;

   }

+  if (!Command.length())

+    (mh_pid_t)0;

   string InCommand=Command;

   if (g_Quiet)

     Echo=false;

@@ -1378,7 +1380,7 @@ mh_pid_t mhmakefileparser::ExecuteCommand(string Command, bool &IgnoreError, str
   }

   else

   {

-    if (Command!="echo")

+    if (Command!="echo" || strchr(Params.c_str(),'|'))  // the EchoCommand(Params) does not implement piping, only redirecting (>)

     {

       string FullCommand=GetFullCommand(Command);

       string ComSpec=GetComspec();

@@ -1449,6 +1451,15 @@ void mhmakefileparser::BuildDependencies(const refptr<rule> &pRule, fileinfo* pT
   while (pDepIt!=Deps.end())

   {

     mh_time_t DepDate=WaitBuildTarget(*pDepIt);

+    #ifdef _DEBUG

+    if (!DepDate.DoesExist()&&!(*pDepIt)->IsPhony())

+    {

+      if (!(*pDepIt)->GetDir()->GetDate().DoesExist())

+        cout << "Building of "<<(*pDepIt)->GetFullFileName()<<" failed because directory does not exist (rule defined to create it?)\n";

+      else

+        cout << "Does not known how to create "<<(*pDepIt)->GetFullFileName()<<".\n";

+    }

+    #endif

     if (DepDate.IsNewer(YoungestDate))

       YoungestDate=DepDate;

     if (DepDate.IsNewer(TargetDate))

@@ -1572,7 +1583,7 @@ mh_time_t mhmakefileparser::StartBuildTarget(fileinfo* pTarget,bool bCheckTarget
         #endif

         break;

       }

-      else

+      else if (!IMPLICITRULE::PushRule(ResultIt->second))

       {

         #ifdef _DEBUG

         m_ImplicitSearch++;

@@ -1585,6 +1596,7 @@ mh_time_t mhmakefileparser::StartBuildTarget(fileinfo* pTarget,bool bCheckTarget
           if (pNewTarget!=NULL)

             DepDate=pNewTarget->GetDate();

         }

+        IMPLICITRULE::PopRule(ResultIt->second);

         #ifdef _DEBUG

         m_ImplicitSearch--;

         #endif

@@ -1613,6 +1625,12 @@ mh_time_t mhmakefileparser::StartBuildTarget(fileinfo* pTarget,bool bCheckTarget
           break;

         }

       }

+      #ifdef _DEBUG

+      else if (g_PrintAdditionalInfo)

+      {

+        cout << "Stopping implicit search of "<<pTarget->GetFullFileName()<<" because of implicit rule recursion detected.\n";

+      }

+      #endif

       ResultIt++;

     }

     if (pRule)

@@ -1627,7 +1645,7 @@ mh_time_t mhmakefileparser::StartBuildTarget(fileinfo* pTarget,bool bCheckTarget
     }

   }

 

-  mhmakeparser *pMakefile=NULL;

+  mhmakefileparser *pMakefile=NULL;

   if (pRule)

   {

     pMakefile=pRule->GetMakefile();

diff --git a/tools/mhmake/src/commandqueue.cpp b/tools/mhmake/src/commandqueue.cpp
index fca26f997..6f3fd4d1a 100644
--- a/tools/mhmake/src/commandqueue.cpp
+++ b/tools/mhmake/src/commandqueue.cpp
@@ -116,7 +116,7 @@ void commandqueue::ThrowCommandExecutionError(refptr<activeentry> pActiveEntry)
 {

   fileinfo*     pTarget=pActiveEntry->pTarget;

   const string    &Command=pActiveEntry->Command;

-  mhmakeparser    *pMakefile=pTarget->GetRule()->GetMakefile();

+  mhmakefileparser *pMakefile=pTarget->GetRule()->GetMakefile();

 

   string ErrorMessage = string("Error running command: ")+ Command +"\n";

   ErrorMessage += "Command defined in makefile: " + pMakefile->GetMakeDir()->GetQuotedFullFileName();

@@ -167,7 +167,7 @@ void commandqueue::RemoveActiveEntry(unsigned Entry)
 bool commandqueue::StartExecuteNextCommand(refptr<activeentry> pActiveEntry, mh_pid_t *pActiveProcess)

 {

   fileinfo* pTarget=pActiveEntry->pTarget;

-  mhmakeparser *pMakefile=pTarget->GetRule()->GetMakefile();

+  mhmakefileparser *pMakefile=pTarget->GetRule()->GetMakefile();

 

   pMakefile->SetRuleThatIsBuild(pTarget); // Make sure that the command expension is correct

   string Command=pMakefile->ExpandExpression(*pActiveEntry->CurrentCommandIt);

@@ -222,7 +222,7 @@ void commandqueue::TargetBuildFinished(refptr<activeentry> pActiveEntry)
   pTarget->SetCommandsMd5_32(Md5_32);  /* If the rule of the target was added with an implicit rule the targets in the rule is empty */

 

   refptr<rule> pRule=pTarget->GetRule();

-  mhmakeparser *pMakefile=pRule->GetMakefile();

+  mhmakefileparser *pMakefile=pRule->GetMakefile();

 

   pMakefile->AddTarget(pTarget);

   pMakefile->SetAutoDepsDirty();

@@ -251,7 +251,7 @@ bool commandqueue::StartExecuteCommands(fileinfo* pTarget)
   cout << "Building " << pTarget->GetQuotedFullFileName()<<endl;

   // We do not have to put it in the queue, we can start executing directly

   refptr<rule> pRule=pTarget->GetRule();

-  mhmakeparser *pMakefile=pRule->GetMakefile();

+  mhmakefileparser *pMakefile=pRule->GetMakefile();

   vector<string>::iterator CommandIt=pRule->GetCommands().begin();

 

   refptr<activeentry> pActiveEntry=CreateActiveEntry();

diff --git a/tools/mhmake/src/fileinfo.h b/tools/mhmake/src/fileinfo.h
index 8d58a1efa..bb5e0ce71 100644
--- a/tools/mhmake/src/fileinfo.h
+++ b/tools/mhmake/src/fileinfo.h
@@ -136,7 +136,7 @@ class fileinfo
   bool m_IsPhony;

   int m_BuildStatus;  /* Bit 0 means the target built is started, Bit 1 means the target is still building */

   refptr<rule> m_pRule;

-  mhmakeparser *m_pAutoDepsMakefile;

+  mhmakefileparser *m_pAutoDepsMakefile;

   vector<fileinfo*> m_Deps;

   mh_time_t m_Date;

   uint32 m_CommandsMd5_32;  // 32-bit Md5 checksum of commands to build this target

@@ -291,7 +291,7 @@ public:
     return m_Deps;

   }

   string GetPrerequisits(void) const;

-  void SetAutoDepsScan(mhmakeparser *pMakefile)

+  void SetAutoDepsScan(mhmakefileparser *pMakefile)

   {

     #ifdef _DEBUG

     if (m_pAutoDepsMakefile)

@@ -299,7 +299,7 @@ public:
     #endif

     m_pAutoDepsMakefile=pMakefile;

   }

-  mhmakeparser *GetAutoDepsMakefile(void) const

+  mhmakefileparser *GetAutoDepsMakefile(void) const

   {

     return m_pAutoDepsMakefile;

   }

diff --git a/tools/mhmake/src/flex.skl b/tools/mhmake/src/flex.skl
new file mode 100644
index 000000000..4d57bac46
--- /dev/null
+++ b/tools/mhmake/src/flex.skl
@@ -0,0 +1,3426 @@
+%# -*-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.
+
+%# 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]])]])
+
+%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')
+]])
+
+%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++
+#include <flexint.h>
+%endif
+
+%if-c++-only
+/* begin standard C++ headers. */
+#include <iostream>
+#include <errno.h>
+#include <cstdlib>
+#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]])
+%# 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( [[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
+
+%if-not-reentrant
+extern int 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_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#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.
+   */
+  int yy_n_chars;
+
+  /* Whether we "own" the buffer - i.e., we know we created it,
+   * and can realloc() it to grow it, and should free() it to
+   * 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 int yy_n_chars;    /* number of characters read into yy_ch_buf */
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 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, int 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;
+    int yy_n_chars;
+    int 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]],,
+[[
+int 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 );
+]])
+
+%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 fwrite( yytext, yyleng, 1, yyout )
+%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()
+{
+  mystack::iterator It=m_IncludeStack.begin();
+  while (It!=m_IncludeStack.end())
+  {
+    yy_delete_buffer((*It)->m_BufferState); /* When the stack is deleted, the lexer is not run anymore, so we have to clean up the buffers ourself */
+    It++;
+  }
+  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 (int)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
+    {
+      int 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;
+
+      int yy_c_buf_p_offset =
+        (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
+
+      if ( b->yy_is_our_buffer )
+        {
+        int 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), (size_t) 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
+
+  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 int 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 */
+      int offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
+      ++YY_G(yy_c_buf_p);
+
+      switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )
+        {
+        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 );
+}
+
+
+%if-c-only
+m4_ifdef( [[M4_YY_ALWAYS_INTERACTIVE]],,
+[[
+    m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],,
+    [[
+#ifndef __cplusplus
+extern int isatty M4_YY_PARAMS( int );
+#endif /* __cplusplus */
+    ]])
+]])
+%endif
+
+%if-c++-only
+m4_ifdef( [[M4_YY_NEVER_INTERACTIVE]],,
+[[
+]])
+%endif
+
+/* 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
+{
+  int 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 bytes the byte buffer to scan
+ * @param 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, int ,_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
+ */
+int 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" M4_YY_CALL_LAST_ARG);
+    ]])
+    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" M4_YY_CALL_LAST_ARG);
+    ]])
+    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.*/ M4_YY_CALL_LAST_ARG);
+        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.*/ M4_YY_CALL_LAST_ARG);
+        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.*/ M4_YY_CALL_LAST_ARG);
+        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.*/ M4_YY_CALL_LAST_ARG);
+                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" M4_YY_CALL_LAST_ARG);
+                    }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" M4_YY_CALL_LAST_ARG);
+                    }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" M4_YY_CALL_LAST_ARG);
+                    }else
+                        ((flex_int8_t *) v)[0] = (flex_int8_t) t32;
+                    break;
+                default:
+                    yy_fatal_error("invalid dmap->dm_sz for struct" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG);
+                    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.*/ M4_YY_CALL_LAST_ARG);
+                    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" M4_YY_CALL_LAST_ARG);
+                }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" M4_YY_CALL_LAST_ARG);
+                    }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" M4_YY_CALL_LAST_ARG);
+                    }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" M4_YY_CALL_LAST_ARG);
+                    }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.*/ M4_YY_CALL_LAST_ARG);
+                    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/tools/mhmake/src/flexint.h b/tools/mhmake/src/flexint.h
new file mode 100644
index 000000000..673aa1757
--- /dev/null
+++ b/tools/mhmake/src/flexint.h
@@ -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;
+#endif /* ! C99 */
+
+/* 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 /* ! FLEXINT_H */
diff --git a/tools/mhmake/src/flexlexer.h b/tools/mhmake/src/flexlexer.h
new file mode 100644
index 000000000..48dab04ae
--- /dev/null
+++ b/tools/mhmake/src/flexlexer.h
@@ -0,0 +1,260 @@
+// -*-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 "mhmakeparser.h"
+
+#include <iostream>
+#  ifndef FLEX_STD
+#    define FLEX_STD std::
+#  endif
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+  FlexLexer() : yylineno(1), m_BraceIndent(0) {}
+  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(TOKENVALUE &theValue) = 0;
+
+
+  // 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"
+
+public:
+
+  struct INSTACK
+  {
+    YY_BUFFER_STATE m_BufferState;
+    ifstream m_Stream;
+    string m_FileName;
+    int yylineno;
+    INSTACK(YY_BUFFER_STATE BufferState, const string &FileToOpen, const string &PrevFileName, int Line) :
+      m_BufferState(BufferState),
+      m_FileName(PrevFileName),
+      yylineno(Line),
+      m_Stream(FileToOpen.c_str(), ios_base::in)
+    {
+    }
+    bool fail() const
+    {
+      return m_Stream.fail();
+    }
+    ifstream *GetStream()
+    {
+      return &m_Stream;
+    }
+  };
+  class mystack: public iterstack<INSTACK*>
+  {
+  public:
+    ~mystack()
+    {
+      iterator It=begin();
+      while (It!=end())
+      {
+        delete *It;
+        It++;
+      }
+    }
+    void pop()
+    {
+      INSTACK *pToRemove=top();
+      iterstack<INSTACK*>::pop();
+      delete pToRemove;  /* Buffer does not need to be deleted because the lexer does this when it calls the pop */
+    }
+  };
+  int m_BraceIndent;
+  size_t m_IndentSkip;
+  iterstack<int> m_IndentStack;
+  bool m_IgnoreIncludeError;
+  string m_InputFileName;
+  string m_curtoken;
+  mystack m_IncludeStack;
+  mhmakeparser *m_pParser;
+  mhmakeparser *GetParser()
+  {
+    return m_pParser;
+  }
+
+};
+
+}
+#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 mhmakeFlexLexer : public FlexLexer {
+public:
+  // arg_yyin and arg_yyout default to the cin and cout, but we
+  // only make that assignment when initializing in yylex().
+  mhmakeFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
+
+  virtual ~mhmakeFlexLexer();
+
+  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(TOKENVALUE &theValue);
+  virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 );
+
+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();
+  int yywrap();
+
+  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/tools/mhmake/src/flexskel.cc b/tools/mhmake/src/flexskel.cc
deleted file mode 100644
index e83775372..000000000
--- a/tools/mhmake/src/flexskel.cc
+++ /dev/null
@@ -1,1053 +0,0 @@
-/*  This file is part of mhmake.

- *

- *  Copyright (C) 2001-2010 marha_at_sourceforge.net

- *

- *  Mhmake 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 3 of the License, or

- *  (at your option) any later version.

- *

- *  Mhmake 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 Mhmake.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/* $Rev$ */

-

-/* A lexical scanner generated by flex */

-/* scanner skeleton version:

- * $Header: c:\\Program\040Files\\Development\\CVS\040Repository/flex++/flexskel.cc,v 1.1.1.1 2002/04/13 06:01:32 Bear Exp $

- */

-/* MODIFIED FOR C++ CLASS BY Alain Coetmeur: coetmeur(at)icdc.fr */

-/* Note that (at) mean the 'at' symbol that I cannot write */

-/* because it is expanded to the class name */

-/* made at Informatique-CDC, Research&development department */

-/* company from the Caisse Des Depots et Consignations */

-/* institutional financial group  */

-

-/* theses symbols are added before this file */

-/* #define YY_CHAR 'unsigned char' if 8bit or 'char' if 7bit */

-/* #define FLEX_DEBUG if debug mode */

-#define FLEX_SCANNER

-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */

-#ifdef c_plusplus

-#ifndef __cplusplus

-#define __cplusplus

-#endif

-#endif

-/* Old MSC, before c7 */

-#ifdef MSDOS

-#ifndef _MSDOS

-#define _MSDOS

-#endif

-#endif

-/* turboc */

-#ifdef __MSDOS__

-#ifndef _MSDOS

-#define _MSDOS

-#endif

-#endif

-

-#ifdef __cplusplus

-#include <stdlib.h>

-#define YY_USE_CONST

-#define YY_USE_PROTOS

-#ifndef YY_USE_CLASS

-#define YY_USE_CLASS

-#endif

-#else   /* ! __cplusplus */

-#ifdef __STDC__

-#ifdef __GNUC__

-#include <stddef.h>

-void *malloc( size_t );

-void free( void* );

-int read();

-#else

-#include <stdlib.h>

-#endif  /* __GNUC__ */

-#define YY_USE_PROTOS

-#define YY_USE_CONST

-#endif  /* __STDC__ */

-#endif  /* ! __cplusplus */

-#ifdef __TURBOC__

-#define YY_USE_CONST

-#endif

-#include <stdio.h>

-

-

-/*********************************************/

-/* COMPILER DEPENDENT   MACROS               */

-/*********************************************/

-/* use prototypes in function declarations */

-/* the "const" storage-class-modifier is valid */

-#ifndef YY_USE_CONST

-#define const

-#endif

-/* use prototypes in function declarations */

-#ifndef YY_PROTO

-#ifdef YY_USE_PROTOS

-#define YY_PROTO(proto) proto

-#else

-#define YY_PROTO(proto) ()

-#endif

-#endif

-

-

-/*********************/

-/* parameters        */

-

-/* amount of stuff to slurp up with each read */

-#ifndef YY_READ_BUF_SIZE

-#define YY_READ_BUF_SIZE 8192

-#endif

-/* size of default input buffer */

-#ifndef YY_BUF_SIZE

-#define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2)

-#endif

-

-/***********************************/

-/* to be redefined for application */

-

-/* returned upon end-of-file */

-#define YY_END_TOK 0

-/* 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.

- */

-#define yyterminate() return ( YY_NULL )

-

-/* code executed at the end of each rule */

-#define YY_BREAK break;

-

-/* #define YY_USER_ACTION */

-/* #define YY_USER_INIT */

-

-

-#ifndef YY_USE_CLASS

-/* copy whatever the last rule matched to the standard output */

-/* cast to (char *) is because for 8-bit chars, yy___text is (unsigned char *) */

-/* this used to be an fputs(), but since the string might contain NUL's,

- * we now use fwrite()

- */

-#define ECHO (void) fwrite( (char *) yy___text, yy___leng, 1, yy___out )

-

-/* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,

- * is returned in "result".

- */

-#ifdef _MSDOS

-#define YY_INPUT(buf,result,max_size) \

-  if ( (result = fread(buf,1,max_size,yy___in)) < 0 ) \

-      YY_FATAL_ERROR( "fread() in flex scanner failed" );

-#else

-#define YY_INPUT(buf,result,max_size) \

-  if ( (result = read( fileno(yy___in), (char *) buf, max_size )) < 0 ) \

-      YY_FATAL_ERROR( "read() in flex scanner failed" );

-

-#endif

-/* report a fatal error */

-

-/* The funky do-while is used to turn this macro definition into

- * a single C statement (which needs a semi-colon terminator).

- * This avoids problems with code like:

- *

- *      if ( something_happens )

- *              YY_FATAL_ERROR( "oops, the something happened" );

- *      else

- *              everything_okay();

- *

- * Prior to using the do-while the compiler would get upset at the

- * "else" because it interpreted the "if" statement as being all

- * done when it reached the ';' after the YY_FATAL_ERROR() call.

- */

-

-#define YY_FATAL_ERROR(msg) \

-  do \

-  { \

-    (void) fputs( msg, yy___stderr  ); \

-    (void) putc( '\n', yy___stderr  ); \

-    exit( 1 ); \

-  } \

-  while ( 0 )

-

-/* default yywrap function - always treat EOF as an EOF */

-#define yywrap() 1

-

-

-/* default declaration of generated scanner - a define so the user can

- * easily add parameters

- */

-#define YY_DECL int yylex YY_PROTO(( void ))

-#else

-/* c++ */

-#define ECHO yy___echo()

-#define YY_INPUT(buf,result,max_size) \

-  if ( yy___input((char *)buf, result,max_size) < 0 ) \

-    YY_FATAL_ERROR( "YY_INPUT() in flex scanner failed" );

-

-#define YY_FATAL_ERROR(msg) yy___fatal_error(msg)

-#define yywrap() yy___wrap()

-

-#endif

-/***********************************/

-/* not to be changed */

-#define YY_NULL 0

-#define YY_END_OF_BUFFER_CHAR 0

-/* special action meaning "start processing a new file" */

-#define YY_NEW_FILE yy___newfile

-/* enter a start condition.  This macro really ought to take a parameter,

- * but we do it the disgusting crufty way forced on us by the ()-less

- * definition of BEGIN

- */

-#define BEGIN yy_start = 1 + 2 *

-

-/* action number for EOF rule of a given start state */

-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

-

-

-

-%% section 1 definitions go here

-

-#define yy___stderr YY_@_ERRFILE

-#define yy___text YY_@_TEXT

-#define yy___leng YY_@_LENG

-#define yy___in YY_@_IN

-#define yy___out YY_@_OUT

-#define yy___newfile \

-  do \

-  { \

-    YY_@_INIT_BUFFER( YY_@_CURRENT_BUFFER, yy___in ); \

-    YY_@_LOAD_BUFFER_STATE(); \

-  } \

-  while ( 0 )

-#if YY_@_DEBUG != 0

-#define yy___flex_debug YY_@_DEBUG_FLAG

-#endif

-

-

-#ifdef YY_USE_CLASS

-

-#define yy___echo YY_@_ECHO

-#define yy___input YY_@_INPUT

-#define yy___fatal_error YY_@_FATAL_ERROR

-#define yy___wrap YY_@_WRAP

-

-#endif

-

-/* done after the current pattern has been matched and before the

- * corresponding action - sets up yy___text

- */

-#define YY_DO_BEFORE_ACTION \

-  yy___text = yy_bp; \

-%% code to fiddle yy___text and yy___leng for yymore() goes here

-  yy_hold_char = *yy_cp; \

-  *yy_cp = '\0'; \

-  yy_c_buf_p = yy_cp;

-

-#define EOB_ACT_CONTINUE_SCAN 0

-#define EOB_ACT_END_OF_FILE 1

-#define EOB_ACT_LAST_MATCH 2

-

-/* return all but the first 'n' matched characters back to the input stream */

-#define yyless(n) \

-  do \

-  { \

-    /* undo effects of setting up yy___text */ \

-    *yy_cp = yy_hold_char; \

-    yy_c_buf_p = yy_cp = yy_bp + n; \

-    YY_DO_BEFORE_ACTION; /* set up yy___text again */ \

-  } \

-  while ( 0 )

-

-#define unput(c) yyunput( c, yy___text )

-

-

-

-struct yy_buffer_state

-{

-  YY_@_IFILE  *yy_input_file;

-

-  YY_@_CHAR *yy_ch_buf;               /* input buffer */

-  YY_@_CHAR *yy_buf_pos;      /* current position in input buffer */

-

-  /* size of input buffer in bytes, not including room for EOB characters */

-  int yy_buf_size;

-

-  /* number of characters read into yy_ch_buf, not including EOB characters */

-  size_t yy_n_chars;

-

-  int yy_eof_status;          /* whether we've seen an EOF on this buffer */

-#define EOF_NOT_SEEN 0

-    /* "pending" happens when the EOF has been seen but there's still

-     * some text process

-     */

-#define EOF_PENDING 1

-#define EOF_DONE 2

-  };

-

-/* 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"

- */

-

-#ifndef YY_USE_CLASS

-

-#if YY_@_DEBUG != 0

-int YY_@_DEBUG_FLAG=YY_@_DEBUG_INIT;

-#endif

-#define YY_CURRENT_BUFFER YY_@_CURRENT_BUFFER

-static YY_BUFFER_STATE YY_@_CURRENT_BUFFER;

-/* yy_hold_char holds the character lost when yy___text is formed */

-static YY_@_CHAR yy_hold_char;

-

-static int yy_n_chars;          /* number of characters read into yy_ch_buf */

-

-/* GLOBAL */

-YY_@_CHAR *yy___text;

-size_t yy___leng;

-

-YY_@_IFILE  *yy___in = (YY_@_IFILE  *) 0;

-YY_@_OFILE *yy___out = (YY_@_OFILE  *) 0;

-

-#ifdef __cplusplus

-static int yyinput YY_PROTO(( void ));

-#else

-static int input YY_PROTO(( void ));

-#endif

-/* these variables are all declared out here so that section 3 code can

- * manipulate them

- */

-/* points to current character in buffer */

-static YY_@_CHAR *yy_c_buf_p = (YY_@_CHAR *) 0;

-static int yy_init = 1;         /* whether we need to initialize */

-static int yy_start = 0;        /* start state number */

-

-/* flag which is used to allow yywrap()'s to do buffer switches

- * instead of setting up a fresh yy___in.  A bit of a hack ...

- */

-static int yy_did_buffer_switch_on_eof;

-

-static int yy_get_next_buffer YY_PROTO(( void ));

-static void yyunput YY_PROTO(( YY_@_CHAR c, YY_@_CHAR *buf_ptr ));

-

-#else

-/* c++ */

-#ifndef YY_@_ECHO_NOCODE

-void YY_@_CLASS::yy___echo()

-{

-  YY_@_ECHO_CODE

-}

-#endif

-#ifndef YY_@_INPUT_NOCODE

-size_t  YY_@_CLASS::yy___input(char * buffer,size_t &result,size_t max_size)

-{

-  YY_@_INPUT_CODE

-}

-#endif

-#ifndef YY_@_FATAL_ERROR_NOCODE

-void YY_@_CLASS::yy___fatal_error(const char *msg)

-{

-  YY_@_FATAL_ERROR_CODE

-}

-#endif

-#ifndef YY_@_WRAP_NOCODE

-int  YY_@_CLASS::yy___wrap()

-{

-  YY_@_WRAP_CODE

-}

-#endif

-void YY_@_CLASS::yy_initialize()

-{

-  yy___in=0;yy___out=0;yy_init = 1;

-  yy_start=0;

-  yy___text=0;yy___leng=0;

-  YY_@_CURRENT_BUFFER=0;

-  yy_did_buffer_switch_on_eof=0;

-  yy_c_buf_p=0;yy_hold_char=0;yy_n_chars=0;

-#if YY_@_DEBUG != 0

-  YY_@_DEBUG_FLAG=YY_@_DEBUG_INIT;

-#endif

-}

-

-YY_@_CLASS::YY_@_CLASS(YY_@_CONSTRUCTOR_PARAM) YY_@_CONSTRUCTOR_INIT

-{

-  yy_initialize();

-  YY_@_CONSTRUCTOR_CODE;

-}

-YY_@_CLASS::~YY_@_CLASS()

-{

-  YY_@_DESTRUCTOR_CODE;

-  if (YY_@_CURRENT_BUFFER)

-    YY_@_DELETE_BUFFER(YY_@_CURRENT_BUFFER);

-}

-

-#endif

-

-

-#ifndef YY_USER_ACTION

-#define YY_USER_ACTION

-#endif

-

-#ifndef YY_USER_INIT

-#define YY_USER_INIT

-#endif

-

-%% data tables for the DFA go here

-#ifndef YY_USE_CLASS

-static yy_state_type yy_get_previous_state YY_PROTO(( void ));

-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));

-#else

-#define yy_get_previous_state() ((yy_state_type)(yy_get_previous_state_()))

-#define yy_try_NUL_trans(c) ((yy_state_type)(yy_try_NUL_trans_(c)))

-#endif

-

-#ifndef YY_USE_CLASS

-#ifdef YY_@_LEX_DEFINED

-YY_@_LEX_RETURN YY_@_LEX ( YY_@_LEX_PARAM )

-YY_@_LEX_PARAM_DEF

-#else

-YY_DECL

-#endif

-#else

-YY_@_LEX_RETURN YY_@_CLASS::YY_@_LEX ( YY_@_LEX_PARAM)

-

-#endif

-{

-  register yy_state_type yy_current_state;

-  register YY_@_CHAR *yy_cp, *yy_bp;

-  register int yy_act;

-

-%% user's declarations go here

-

-  if ( yy_init )

-  {

-

-    {

-      YY_USER_INIT;

-    }

-    if ( ! yy_start )

-      yy_start = 1;       /* first start state */

-

-    if ( ! yy___in )

-      yy___in = YY_@_IFILE_DEFAULT;

-

-    if ( ! yy___out )

-      yy___out = YY_@_OFILE_DEFAULT;

-

-    if ( YY_@_CURRENT_BUFFER )

-      YY_@_INIT_BUFFER( YY_@_CURRENT_BUFFER, yy___in );

-    else

-      YY_@_CURRENT_BUFFER = YY_@_CREATE_BUFFER( yy___in, YY_BUF_SIZE );

-

-    YY_@_LOAD_BUFFER_STATE();

-    yy_init=0;

-  }

-

-  while ( 1 )         /* loops until end-of-file is reached */

-  {

-%% yymore()-related code goes here

-    yy_cp = yy_c_buf_p;

-

-    /* support of yy___text */

-    *yy_cp = yy_hold_char;

-

-    /* yy_bp points to the position in yy_ch_buf of the start of the

-     * current run.

-     */

-    yy_bp = yy_cp;

-

-%% code to set up and find next match goes here

-

-yy_find_action:

-%% code to find the action number goes here

-

-    YY_DO_BEFORE_ACTION;

-    YY_USER_ACTION;

-

-do_action:      /* this label is used only to access EOF actions */

-#if YY_@_DEBUG != 0

-    if ( yy___flex_debug )

-    {

-      if ( yy_act == 0 )

-#ifndef YY_@_IOSTREAM

-        fprintf( yy___stderr , "--scanner backtracking\n" );

-#else

-        yy___stderr <<"--scanner backtracking"<<endl;

-#endif

-      else if ( yy_act < YY_END_OF_BUFFER -1 )

-#ifndef YY_@_IOSTREAM

-        fprintf( yy___stderr ,

-         "--accepting rule at line %d (\"%s\")\n",

-         yy_rule_linenum[yy_act], yy___text );

-#else

-        yy___stderr <<"--accepting rule at line "

-                    <<(int)yy_rule_linenum[yy_act]

-                    <<" (\""<<(char *)yy___text<<"\")"<<endl;

-#endif

-      else if ( yy_act == YY_END_OF_BUFFER -1 )

-#ifndef YY_@_IOSTREAM

-        fprintf( yy___stderr , "--accepting default rule (\"%s\")\n", yy___text );

-#else

-      yy___stderr <<"--accepting default rule (\""<<(char *)yy___text<<"\")"<<endl;

-#endif

-      else if ( yy_act == YY_END_OF_BUFFER )

-#ifndef YY_@_IOSTREAM

-        fprintf( yy___stderr , "--(end of buffer or a NUL)\n" );

-#else

-        yy___stderr <<"--(end of buffer or a NUL)"<<endl;

-#endif

-      else

-#ifndef YY_@_IOSTREAM

-        fprintf( yy___stderr , "--EOF\n" );

-#else

-      yy___stderr <<"--EOF"<<endl;

-#endif

-    }

-#endif

-  switch ( yy_act )

-  {

-%% 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___text - 1);

-

-      /* undo the effects of YY_DO_BEFORE_ACTION */

-      *yy_cp = yy_hold_char;

-

-      /* 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 yyinput().

-       */

-      if ( yy_c_buf_p <= &YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars] )

-          /* this was really a NUL */

-      {

-        yy_state_type yy_next_state;

-

-        yy_c_buf_p = yy___text + yy_amount_of_matched_text;

-

-        yy_current_state = yy_get_previous_state();

-

-        /* okay, we're now positioned to make the

-         * NUL transition.  We couldn't have

-         * yy_get_previous_state() go ahead and do it

-         * for us because it doesn't know how to deal

-         * with the possibility of jamming (and we

-         * don't want to build jamming into it because

-         * then it will run more slowly)

-         */

-

-        yy_next_state = yy_try_NUL_trans( yy_current_state );

-

-        yy_bp = yy___text + YY_MORE_ADJ;

-

-        if ( yy_next_state )

-        {

-          /* consume the NUL */

-          yy_cp = ++yy_c_buf_p;

-          yy_current_state = yy_next_state;

-          goto yy_match;

-        }

-        else

-        {

-%% code to do backtracking for compressed tables and set up yy_cp goes here

-          goto yy_find_action;

-        }

-      }

-      else switch ( yy_get_next_buffer() )

-      {

-        case EOB_ACT_END_OF_FILE:

-        {

-          yy_did_buffer_switch_on_eof = 0;

-

-          if ( yywrap() )

-          {

-            /* note: because we've taken care in

-             * yy_get_next_buffer() to have set up yy___text,

-             * we can now set up yy_c_buf_p so that if some

-             * total hoser (like flex itself) wants

-             * to call the scanner after we return the

-             * YY_NULL, it'll still work - another YY_NULL

-             * will get returned.

-             */

-            yy_c_buf_p = yy___text + YY_MORE_ADJ;

-

-            yy_act = YY_STATE_EOF((yy_start - 1) / 2);

-            goto do_action;

-          }

-          else

-          {

-            if ( ! yy_did_buffer_switch_on_eof )

-              YY_NEW_FILE;

-          }

-        }

-        break;

-

-        case EOB_ACT_CONTINUE_SCAN:

-          yy_c_buf_p = yy___text + yy_amount_of_matched_text;

-

-          yy_current_state = yy_get_previous_state();

-

-          yy_cp = yy_c_buf_p;

-          yy_bp = yy___text + YY_MORE_ADJ;

-          goto yy_match;

-

-        case EOB_ACT_LAST_MATCH:

-          yy_c_buf_p = &YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars];

-

-          yy_current_state = yy_get_previous_state();

-

-          yy_cp = yy_c_buf_p;

-          yy_bp = yy___text + YY_MORE_ADJ;

-          goto yy_find_action;

-      }

-      break;

-    }

-

-    default:

-#if YY_@_DEBUG != 0

-#ifndef YY_@_IOSTREAM

-      fprintf(yy___stderr , "action # %d\n", yy_act );

-#else

-      yy___stderr <<"action # "<<(int)yy_act<<endl;

-#endif

-#endif

-      YY_FATAL_ERROR("fatal flex scanner internal error--no action found" );

-    }

-  }

-  yyterminate();/* avoid the no return value error message on MS-C7/dos */

-}

-

-

-/* yy_get_next_buffer - try to read in a new buffer

- *

- * synopsis

- *     int yy_get_next_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

- */

-#ifndef YY_USE_CLASS

-static int yy_get_next_buffer()

-#else

-int YY_@_CLASS::yy_get_next_buffer()

-#endif

-{

-  register YY_@_CHAR *dest = YY_@_CURRENT_BUFFER->yy_ch_buf;

-  register YY_@_CHAR *source = yy___text - 1; /* copy prev. char, too */

-  register ptrdiff_t number_to_move, i;

-  int ret_val;

-

-  if ( yy_c_buf_p > &YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars + 1] )

-    YY_FATAL_ERROR("fatal flex scanner internal error--end of buffer missed" );

-

-    /* try to read more data */

-

-    /* first move last chars to start of buffer */

-  number_to_move = yy_c_buf_p - yy___text;

-

-  for ( i = 0; i < number_to_move; ++i )

-    *(dest++) = *(source++);

-

-  if ( YY_@_CURRENT_BUFFER->yy_eof_status != EOF_NOT_SEEN )

-    /* don't do the read, it's not guaranteed to return an EOF,

-     * just force an EOF

-     */

-    yy_n_chars = 0;

-

-  else

-  {

-    ptrdiff_t num_to_read = YY_@_CURRENT_BUFFER->yy_buf_size - number_to_move - 1;

-

-    if ( num_to_read > YY_READ_BUF_SIZE )

-      num_to_read = YY_READ_BUF_SIZE;

-

-    else if ( num_to_read <= 0 )

-      YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );

-

-    /* read in more data */

-    YY_INPUT( (&YY_@_CURRENT_BUFFER->yy_ch_buf[number_to_move]), yy_n_chars, num_to_read );

-  }

-

-  if ( yy_n_chars == 0 )

-  {

-    if ( number_to_move - YY_MORE_ADJ == 1 )

-    {

-      ret_val = EOB_ACT_END_OF_FILE;

-      YY_@_CURRENT_BUFFER->yy_eof_status = EOF_DONE;

-    }

-    else

-    {

-      ret_val = EOB_ACT_LAST_MATCH;

-      YY_@_CURRENT_BUFFER->yy_eof_status = EOF_PENDING;

-    }

-  }

-  else

-    ret_val = EOB_ACT_CONTINUE_SCAN;

-

-  yy_n_chars += number_to_move;

-  YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;

-  YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

-

-  /* yy___text begins at the second character in yy_ch_buf; the first

-   * character is the one which preceded it before reading in the latest

-   * buffer; it needs to be kept around in case it's a newline, so

-   * yy_get_previous_state() will have with '^' rules active

-   */

-

-  yy___text = &YY_@_CURRENT_BUFFER->yy_ch_buf[1];

-

-  return ( ret_val );

-}

-

-

-/* yy_get_previous_state - get the state just before the EOB char was reached

- *

- * synopsis

- *     yy_state_type yy_get_previous_state();

- */

-

-#ifndef YY_USE_CLASS

-static yy_state_type yy_get_previous_state()

-#else

-long YY_@_CLASS::yy_get_previous_state_()

-#endif

-{

-  register yy_state_type yy_current_state;

-  register YY_@_CHAR *yy_cp;

-

-%% code to get the start state into yy_current_state goes here

-

-  for ( yy_cp = yy___text + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )

-  {

-%% code to find the next state goes here

-  }

-

-#ifndef YY_USE_CLASS

-  return ( yy_current_state );

-#else

-  return (long)( yy_current_state );

-#endif

-}

-

-

-/* yy_try_NUL_trans - try to make a transition on the NUL character

- *

- * synopsis

- *     next_state = yy_try_NUL_trans( current_state );

- */

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )

-#else

-static yy_state_type yy_try_NUL_trans( yy_current_state )

-register yy_state_type yy_current_state;

-#endif

-#else

-long YY_@_CLASS::yy_try_NUL_trans_(long yy_current_state_)

-#endif

-

-{

-#ifndef YY_USE_CLASS

-#else

-  yy_state_type yy_current_state=(yy_state_type)yy_current_state_;

-#endif

-  register int yy_is_jam;

-%% code to find the next state, and perhaps do backtracking, goes here

-

-#ifndef YY_USE_CLASS

-  return ( yy_is_jam ? 0 : yy_current_state );

-#else

-  return (long)( yy_is_jam ? 0 : yy_current_state );

-#endif

-}

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-static void yyunput( YY_@_CHAR c, register YY_@_CHAR *yy_bp )

-#else

-static void yyunput( c, yy_bp )

-YY_@_CHAR c;

-register YY_@_CHAR *yy_bp;

-#endif

-#else

-void YY_@_CLASS::yyunput( YY_@_CHAR c, YY_@_CHAR *yy_bp )

-#endif

-

-{

-  register YY_@_CHAR *yy_cp = yy_c_buf_p;

-

-    /* undo effects of setting up yy___text */

-  *yy_cp = yy_hold_char;

-

-  if ( yy_cp < YY_@_CURRENT_BUFFER->yy_ch_buf + 2 )

-  { /* need to shift things up to make room */

-    register ptrdiff_t number_to_move = yy_n_chars + 2; /* +2 for EOB chars */

-    register YY_@_CHAR *dest = &YY_@_CURRENT_BUFFER->yy_ch_buf[YY_@_CURRENT_BUFFER->yy_buf_size + 2];

-    register YY_@_CHAR *source = &YY_@_CURRENT_BUFFER->yy_ch_buf[number_to_move];

-

-    while ( source > YY_@_CURRENT_BUFFER->yy_ch_buf )

-        *--dest = *--source;

-

-    yy_cp += dest - source;

-    yy_bp += dest - source;

-    yy_n_chars = YY_@_CURRENT_BUFFER->yy_buf_size;

-

-    if ( yy_cp < YY_@_CURRENT_BUFFER->yy_ch_buf + 2 )

-        YY_FATAL_ERROR( "flex scanner push-back overflow" );

-  }

-

-  *--yy_cp = c;

-

-    /* note: the formal parameter *must* be called "yy_bp" for this

-     *       macro to now work correctly

-     */

-  YY_DO_BEFORE_ACTION; /* set up yy___text again */

-}

-

-#ifndef YY_USE_CLASS

-#ifdef __cplusplus

-static int yyinput()

-#else

-static int input()

-#endif

-#else

-int YY_@_CLASS::input()

-#endif

-{

-  int c;

-  YY_@_CHAR *yy_cp = yy_c_buf_p;

-

-  *yy_cp = yy_hold_char;

-

-  if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )

-  {

-    /* yy_c_buf_p now points to the character we want to return.

-     * If this occurs *before* the EOB characters, then it's a

-     * valid NUL; if not, then we've hit the end of the buffer.

-     */

-    if ( yy_c_buf_p < &YY_@_CURRENT_BUFFER->yy_ch_buf[yy_n_chars] )

-      /* this was really a NUL */

-      *yy_c_buf_p = '\0';

-    else

-    { /* need more input */

-      yy___text = yy_c_buf_p;

-      ++yy_c_buf_p;

-

-    switch ( yy_get_next_buffer() )

-    {

-      case EOB_ACT_END_OF_FILE:

-      {

-        if ( yywrap() )

-        {

-          yy_c_buf_p = yy___text + YY_MORE_ADJ;

-          return ( EOF );

-        }

-

-        YY_NEW_FILE;

-#ifndef YY_USE_CLASS

-#ifdef __cplusplus

-        return ( yyinput() );

-#else

-        return ( input() );

-#endif

-#else

-        return ( input() );

-#endif

-      }

-      break;

-

-      case EOB_ACT_CONTINUE_SCAN:

-        yy_c_buf_p = yy___text + YY_MORE_ADJ;

-      break;

-

-      case EOB_ACT_LAST_MATCH:

-#ifndef YY_USE_CLASS

-#ifdef __cplusplus

-        YY_FATAL_ERROR( "unexpected last match in yyinput()" );

-#else

-        YY_FATAL_ERROR( "unexpected last match in input()" );

-#endif

-#else

-        YY_FATAL_ERROR( "unexpected last match in YY_@_CLASS::input()" );

-#endif

-      }

-    }

-  }

-

-  c = *yy_c_buf_p;

-  yy_hold_char = *++yy_c_buf_p;

-

-  return ( c );

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-void YY_@_RESTART( YY_@_IFILE  *input_file )

-#else

-void YY_@_RESTART( input_file )

-YY_@_IFILE  *input_file;

-#endif

-#else

-void YY_@_CLASS::YY_@_RESTART ( YY_@_IFILE  *input_file )

-#endif

-

-{

-  YY_@_INIT_BUFFER( YY_@_CURRENT_BUFFER, input_file );

-  YY_@_LOAD_BUFFER_STATE();

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-void YY_@_SWITCH_TO_BUFFER( YY_BUFFER_STATE new_buffer )

-#else

-void YY_@_SWITCH_TO_BUFFER( new_buffer )

-YY_BUFFER_STATE new_buffer;

-#endif

-#else

-void YY_@_CLASS::YY_@_SWITCH_TO_BUFFER( YY_BUFFER_STATE new_buffer )

-#endif

-

-{

-  if ( YY_@_CURRENT_BUFFER == new_buffer )

-    return;

-

-  if ( YY_@_CURRENT_BUFFER )

-  {

-    /* flush out information for old buffer */

-    *yy_c_buf_p = yy_hold_char;

-    YY_@_CURRENT_BUFFER->yy_buf_pos = yy_c_buf_p;

-    YY_@_CURRENT_BUFFER->yy_n_chars = yy_n_chars;

-  }

-

-  YY_@_CURRENT_BUFFER = new_buffer;

-  YY_@_LOAD_BUFFER_STATE();

-

-  /* we don't actually know whether we did this switch during

-   * EOF (yywrap()) processing, but the only time this flag

-   * is looked at is after yywrap() is called, so it's safe

-   * to go ahead and always set it.

-   */

-  yy_did_buffer_switch_on_eof = 1;

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-void YY_@_LOAD_BUFFER_STATE( void )

-#else

-void YY_@_LOAD_BUFFER_STATE()

-#endif

-#else

-void YY_@_CLASS::YY_@_LOAD_BUFFER_STATE(  )

-#endif

-

-{

-  yy_n_chars = YY_@_CURRENT_BUFFER->yy_n_chars;

-  yy___text = yy_c_buf_p = YY_@_CURRENT_BUFFER->yy_buf_pos;

-  yy___in = YY_@_CURRENT_BUFFER->yy_input_file;

-  yy_hold_char = *yy_c_buf_p;

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-YY_BUFFER_STATE YY_@_CREATE_BUFFER( YY_@_IFILE  *file, int size )

-#else

-YY_BUFFER_STATE YY_@_CREATE_BUFFER( file, size )

-YY_@_IFILE  *file;

-int size;

-#endif

-#else

-YY_BUFFER_STATE YY_@_CLASS::YY_@_CREATE_BUFFER( YY_@_IFILE  *file, int size )

-#endif

-

-{

-  YY_BUFFER_STATE b;

-

-  b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );

-

-  if ( ! b )

-    YY_FATAL_ERROR( "out of dynamic memory in YY_@_CREATE_BUFFER()" );

-

-  b->yy_buf_size = size;

-

-  /* yy_ch_buf has to be 2 characters longer than the size given because

-   * we need to put in 2 end-of-buffer characters.

-   */

-  b->yy_ch_buf = (YY_@_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );

-

-  if ( ! b->yy_ch_buf )

-    YY_FATAL_ERROR( "out of dynamic memory in YY_@_CREATE_BUFFER()" );

-

-  YY_@_INIT_BUFFER( b, file );

-

-  return ( b );

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-void YY_@_DELETE_BUFFER( YY_BUFFER_STATE b )

-#else

-void YY_@_DELETE_BUFFER( b )

-YY_BUFFER_STATE b;

-#endif

-#else

-void YY_@_CLASS::YY_@_DELETE_BUFFER( YY_BUFFER_STATE b )

-#endif

-

-{

-  if ( b == YY_@_CURRENT_BUFFER )

-    YY_@_CURRENT_BUFFER = (YY_BUFFER_STATE) 0;

-

-  free( (char *) b->yy_ch_buf );

-  free( (char *) b );

-}

-

-

-#ifndef YY_USE_CLASS

-#ifdef YY_USE_PROTOS

-void YY_@_INIT_BUFFER( YY_BUFFER_STATE b, YY_@_IFILE  *file )

-#else

-void YY_@_INIT_BUFFER( b, file )

-YY_BUFFER_STATE b;

-YY_@_IFILE  *file;

-#endif

-#else

-void YY_@_CLASS::YY_@_INIT_BUFFER( YY_BUFFER_STATE b, YY_@_IFILE  *file)

-#endif

-

-{

-  b->yy_input_file = file;

-

-  /* we put in the '\n' and start reading from [1] so that an

-   * initial match-at-newline will be true.

-   */

-

-  b->yy_ch_buf[0] = '\n';

-  b->yy_n_chars = 1;

-

-  /* we always need two end-of-buffer characters.  The first causes

-   * a transition to the end-of-buffer state.  The second causes

-   * a jam in that state.

-   */

-  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

-  b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;

-

-  b->yy_buf_pos = &b->yy_ch_buf[1];

-

-  b->yy_eof_status = EOF_NOT_SEEN;

-}

-

diff --git a/tools/mhmake/src/flexskel.h b/tools/mhmake/src/flexskel.h
deleted file mode 100644
index 69d0eeeb4..000000000
--- a/tools/mhmake/src/flexskel.h
+++ /dev/null
@@ -1,395 +0,0 @@
-/*  This file is part of mhmake.

- *

- *  Copyright (C) 2001-2010 marha@sourceforge.net

- *

- *  Mhmake 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 3 of the License, or

- *  (at your option) any later version.

- *

- *  Mhmake 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 Mhmake.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/* $Rev$ */

-

-/* A lexical scanner header generated by flex */

-/* MODIFIED FOR C++ CLASS BY Alain Coetmeur: coetmeur(at)icdc.fr */

-/* Note that (at) mean the 'at' symbol that I cannot write */

-/* because it is expanded to the class name */

-/* made at Informatique-CDC, Research&development department */

-/* company from the Caisse Des Depots et Consignations */

-

-

-/*********************************************/

-/* SYSTEM dependent declaration, includes... */

-/*********************************************/

-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */

-#ifdef c_plusplus

-#ifndef __cplusplus

-#define __cplusplus

-#endif

-#endif

-#ifdef __cplusplus

-#ifndef YY_USE_PROTOS

-#define YY_USE_PROTOS

-#endif

-#ifndef YY_USE_CLASS

-#define YY_USE_CLASS

-#endif

-#else /* ! __cplusplus */

-#ifdef __STDC__

-#ifdef __GNUC__

-#else

-#endif  /* __GNUC__ */

-#ifndef YY_USE_PROTOS

-#define YY_USE_PROTOS

-#endif

-#endif  /* __STDC__ */

-#endif  /* ! __cplusplus */

-/*********************************************/

-/* COMPILER DEPENDENT   MACROS               */

-/*********************************************/

-/* use prototypes in function declarations */

-#ifndef YY_PROTO

-#ifdef YY_USE_PROTOS

-#define YY_PROTO(proto) proto

-#else

-#define YY_PROTO(proto) ()

-#endif

-#endif

-#include <stdio.h>

-

-

-

-

-%% here is the declaration from section1 %header{

-

-#ifdef YY_USE_CLASS

-#ifdef YY_@_IOSTREAM

-#include <iostream.h>

-#define YY_@_IFILE  istream

-#define YY_@_OFILE ostream

-#define YY_@_ERRFILE cerr

-

-#ifndef YY_@_IFILE_DEFAULT

-#define YY_@_IFILE_DEFAULT &cin

-#endif

-

-#ifndef YY_@_OFILE_DEFAULT

-#define YY_@_OFILE_DEFAULT &cout

-#endif

-

-#endif

-#endif

-

-#ifndef YY_@_IFILE

-#define YY_@_IFILE FILE

-#endif

-

-#ifndef YY_@_OFILE

-#define YY_@_OFILE FILE

-#endif

-

-#ifndef YY_@_ERRFILE

-#define YY_@_ERRFILE stderr

-#endif

-

-#ifndef YY_@_IFILE_DEFAULT

-#define YY_@_IFILE_DEFAULT stdin

-#endif

-

-#ifndef YY_@_OFILE_DEFAULT

-#define YY_@_OFILE_DEFAULT stdout

-#endif

-

-

-

-

-#ifndef YY_@_TEXT

-#define YY_@_TEXT yytext

-#endif

-#ifndef YY_@_LENG

-#define YY_@_LENG yyleng

-#endif

-#ifndef YY_@_IN

-#define YY_@_IN yyin

-#endif

-#ifndef YY_@_OUT

-#define YY_@_OUT yyout

-#endif

-

-#ifndef YY_@_LEX_RETURN

-#define YY_@_LEX_RETURN int

-#else

-#ifndef YY_@_LEX_DEFINED

-#define YY_@_LEX_DEFINED

-#endif

-#endif

-

-#ifndef YY_@_LEX

-#define YY_@_LEX yylex

-#else

-#ifndef YY_@_LEX_DEFINED

-#define YY_@_LEX_DEFINED

-#endif

-#endif

-

-#ifndef YY_@_LEX_PARAM

-#ifndef YY_USE_PROTOS

-#define YY_@_LEX_PARAM

-#else

-#define YY_@_LEX_PARAM void

-#endif

-#else

-#ifndef YY_@_LEX_DEFINED

-#define YY_@_LEX_DEFINED

-#endif

-#endif

-

-#ifndef YY_@_LEX_PARAM_DEF

-#define YY_@_LEX_PARAM_DEF

-#else

-#ifndef YY_@_LEX_DEFINED

-#define YY_@_LEX_DEFINED

-#endif

-#endif

-

-#ifndef YY_@_RESTART

-#define YY_@_RESTART yyrestart

-#endif

-#ifndef YY_@_SWITCH_TO_BUFFER

-#define YY_@_SWITCH_TO_BUFFER yy_switch_to_buffer

-#endif

-#ifndef YY_@_LOAD_BUFFER_STATE

-#define YY_@_LOAD_BUFFER_STATE yy_load_buffer_state

-#endif

-

-#ifndef YY_@_CREATE_BUFFER

-#define YY_@_CREATE_BUFFER yy_create_buffer

-#ifndef YY_USE_CLASS

-#ifndef yy_new_buffer

-#define yy_new_buffer yy_create_buffer

-#endif

-#endif

-#endif

-#ifndef YY_@_DELETE_BUFFER

-#define YY_@_DELETE_BUFFER yy_delete_buffer

-#endif

-#ifndef YY_@_INIT_BUFFER

-#define YY_@_INIT_BUFFER yy_init_buffer

-#endif

-

-

-

-#ifdef YY_@_FLEX_DEBUG

-#ifndef YY_@_DEBUG

-#define YY_@_DEBUG 1

-#endif

-#else

-#ifndef YY_@_DEBUG

-#define YY_@_DEBUG 0

-#endif

-#endif

-

-#if YY_@_DEBUG != 0

-#ifndef YY_@_DEBUG_FLAG

-#define YY_@_DEBUG_FLAG yy_flex_debug

-#endif

-#ifndef YY_@_DEBUG_INIT

-#define YY_@_DEBUG_INIT 1

-#endif

-#endif

-

-

-

-

-#ifndef YY_USE_CLASS

-#ifndef YY_@_CURRENT_BUFFER

-#define YY_@_CURRENT_BUFFER yy_current_buffer

-#endif

-typedef struct yy_buffer_state *YY_BUFFER_STATE;

-

-extern void YY_@_RESTART YY_PROTO(( YY_@_IFILE *input_file ));

-extern void YY_@_SWITCH_TO_BUFFER YY_PROTO(( YY_BUFFER_STATE new_buffer ));

-extern void YY_@_LOAD_BUFFER_STATE YY_PROTO(( void ));

-extern YY_BUFFER_STATE YY_@_CREATE_BUFFER YY_PROTO(( YY_@_IFILE *file, int size ));

-extern void YY_@_DELETE_BUFFER YY_PROTO(( YY_BUFFER_STATE b ));

-extern void YY_@_INIT_BUFFER YY_PROTO(( YY_BUFFER_STATE b, YY_@_IFILE *file ));

-

-#if YY_@_DEBUG != 0

-extern int YY_@_DEBUG_FLAG ;

-#endif

-extern YY_@_CHAR  *YY_@_TEXT;

-extern int YY_@_LENG;

-extern YY_@_IFILE *YY_@_IN;

-extern YY_@_OFILE *YY_@_OUT;

-#ifdef YY_@_LEX_DEFINED

-extern YY_@_LEX_RETURN YY_@_LEX ( YY_@_LEX_PARAM )

-YY_@_LEX_PARAM_DEF

-#else

-#ifndef YY_DECL

-extern YY_@_LEX_RETURN YY_@_LEX ( YY_@_LEX_PARAM )

-YY_@_LEX_PARAM_DEF

-#else

-/* no declaration if oldstyle flex */

-#endif

-#endif

-#else

-

-#ifndef YY_@_CURRENT_BUFFER

-#define YY_@_CURRENT_BUFFER YY_CURRENT_BUFFER

-#endif

-#ifndef YY_@_CLASS

-#define YY_@_CLASS @

-#endif

-#ifndef YY_@_ECHO

-#define YY_@_ECHO yy_echo

-#endif

-#ifdef YY_@_ECHO_PURE

-#define YY_@_ECHO_NOCODE

-#endif

-

-#ifndef YY_@_ECHO_CODE

-#ifndef YY_@_IOSTREAM

-#define YY_@_ECHO_CODE fwrite( (char *) YY_@_TEXT, YY_@_LENG, 1, YY_@_OUT );

-#else

-#define YY_@_ECHO_CODE (YY_@_OUT->write( (char *) YY_@_TEXT, YY_@_LENG));

-#endif

-#endif

-

-#ifndef YY_@_INPUT

-#define YY_@_INPUT yy_input

-#endif

-#ifdef YY_@_INPUT_PURE

-#define YY_@_INPUT_NOCODE

-#endif

-

-#ifndef YY_@_INPUT_CODE

-#ifndef YY_@_IOSTREAM

-#define YY_@_INPUT_CODE return result= ::fread(  buffer, 1,max_size,YY_@_IN );

-#else

-#define YY_@_INPUT_CODE if(YY_@_IN->eof())  result=0;else {YY_@_IN->read(buffer,max_size);result=YY_@_IN->gcount();YY_@_IN->clear(YY_@_IN->rdstate()&(~ios::failbit));if(YY_@_IN->bad()) result= -1;} return result;

-#endif

-#endif

-

-#ifdef YY_@_FATAL_ERROR_PURE

-#define YY_@_FATAL_ERRO_NOCODE

-#endif

-#ifndef YY_@_FATAL_ERROR

-#define YY_@_FATAL_ERROR yy_fatal_error

-#endif

-

-#ifndef YY_@_FATAL_ERROR_CODE

-#ifndef YY_@_IOSTREAM

-#define YY_@_FATAL_ERROR_CODE fputs( msg, YY_@_ERRFILE );putc( '\n', YY_@_ERRFILE );exit( 1 );

-#else

-#define YY_@_FATAL_ERROR_CODE YY_@_ERRFILE<< msg <<endl;exit( 1 );

-#endif

-#endif

-

-#ifndef YY_@_WRAP

-#define YY_@_WRAP yy_wrap

-#endif

-#ifdef YY_@_WRAP_PURE

-#define YY_@_WRAP_NOCODE

-#endif

-#ifndef YY_@_WRAP_CODE

-#define YY_@_WRAP_CODE return 1;

-#endif

-

-

-#ifndef YY_@_INHERIT

-#define YY_@_INHERIT

-#endif

-#ifndef YY_@_MEMBERS

-#define YY_@_MEMBERS

-#endif

-#ifndef YY_@_CONSTRUCTOR_PARAM

-#define YY_@_CONSTRUCTOR_PARAM

-#endif

-#ifndef YY_@_CONSTRUCTOR_CODE

-#define YY_@_CONSTRUCTOR_CODE

-#endif

-#ifndef YY_@_CONSTRUCTOR_INIT

-#define YY_@_CONSTRUCTOR_INIT

-#endif

-#ifndef YY_@_DESTRUCTOR_CODE

-#define YY_@_DESTRUCTOR_CODE

-#endif

-typedef struct yy_buffer_state *YY_BUFFER_STATE;

-

-class YY_@_CLASS YY_@_INHERIT

-{

-private:/* data */

-  YY_@_CHAR  *yy_c_buf_p;

-  YY_@_CHAR  yy_hold_char;

-  size_t yy_n_chars;

-  int yy_init;

-  int yy_start;

-  int yy_did_buffer_switch_on_eof;

-private: /* functions */

-  void yy_initialize();

-  int input();

-  int yyinput() {return input();};

-  int yy_get_next_buffer();

-  void yyunput( YY_@_CHAR  c, YY_@_CHAR  *buf_ptr );

-  /* use long instead of yy_state_type because it is undef */

-  long yy_get_previous_state_ ( void );

-  long yy_try_NUL_trans_  ( long current_state_ );

-protected:/* non virtual */

-  YY_BUFFER_STATE YY_@_CURRENT_BUFFER;

-  void YY_@_RESTART ( YY_@_IFILE *input_file );

-  void YY_@_SWITCH_TO_BUFFER( YY_BUFFER_STATE new_buffer );

-  void YY_@_LOAD_BUFFER_STATE( void );

-  YY_BUFFER_STATE YY_@_CREATE_BUFFER( YY_@_IFILE *file, int size );

-  void YY_@_DELETE_BUFFER( YY_BUFFER_STATE b );

-  void YY_@_INIT_BUFFER( YY_BUFFER_STATE b, YY_@_IFILE *file );

-  protected: /* virtual */

-  virtual void YY_@_ECHO()

-#ifdef YY_@_ECHO_PURE

-  =0

-#endif

-  ;

-  virtual size_t  YY_@_INPUT(char  *buf,size_t &result,size_t max_size)

-#ifdef YY_@_INPUT_PURE

-   =0

-#endif

-  ;

-  virtual void  YY_@_FATAL_ERROR(const char *msg)

-#ifdef YY_@_FATAL_ERROR_PURE

-  =0

-#endif

-  ;

-  virtual int  YY_@_WRAP()

-#ifdef YY_@_WRAP_PURE

-  =0

-#endif

-  ;

-public:

-  YY_@_CHAR  *YY_@_TEXT;

-  size_t YY_@_LENG;

-  YY_@_IFILE *YY_@_IN;

-  YY_@_OFILE *YY_@_OUT;

-  YY_@_LEX_RETURN YY_@_LEX ( YY_@_LEX_PARAM);

-  YY_@_CLASS(YY_@_CONSTRUCTOR_PARAM) ;

-  virtual ~YY_@_CLASS() ;

-#if YY_@_DEBUG != 0

-  int YY_@_DEBUG_FLAG;

-#endif

-public: /* added members */

-  YY_@_MEMBERS

-};

-#endif

-

-/* declaration of externs for public use of yylex scanner */

-

-%% here is the declaration from section2 %header{

-

-/* end of generated header */

-

diff --git a/tools/mhmake/src/functions.cpp b/tools/mhmake/src/functions.cpp
index 97dc99c01..1602112c3 100644
--- a/tools/mhmake/src/functions.cpp
+++ b/tools/mhmake/src/functions.cpp
@@ -525,7 +525,7 @@ string mhmakefileparser::f_addprefix(const string & Arg) const
   string PreFix;

   pTmp=NextCharItem(pTmp,PreFix,',');

   #ifdef _DEBUG

-  if (!*pTmp) {

+  if (PreFix.empty()) {

     throw ("Wrong number of arguments in function addprefix");

   }

   #endif

diff --git a/tools/mhmake/src/mhmakefileparser.cpp b/tools/mhmake/src/mhmakefileparser.cpp
index 3d074e801..a2d4537a0 100644
--- a/tools/mhmake/src/mhmakefileparser.cpp
+++ b/tools/mhmake/src/mhmakefileparser.cpp
@@ -24,14 +24,14 @@
 

 #include "mhmakefileparser.h"

 #include "rule.h"

-#include "mhmakelexer.h"

+#include "flexlexer.h"

 

 commandqueue mhmakefileparser::sm_CommandQueue;

 

 ///////////////////////////////////////////////////////////////////////////////

 int mhmakefileparser::yylex(void)

 {

-  m_yyloc=m_ptheLexer->m_Line;

+  m_yyloc=m_ptheLexer->lineno();

   return m_ptheLexer->yylex(m_theTokenValue);

 }

 

@@ -44,23 +44,24 @@ void mhmakefileparser::yyerror(const char *m)
 ///////////////////////////////////////////////////////////////////////////////

 int mhmakefileparser::ParseFile(const fileinfo *pFileInfo, const fileinfo *pMakeDir)

 {

-  mhmakelexer theLexer;

-  m_ptheLexer=&theLexer;

   if (pMakeDir)

   {

     m_MakeDir=pMakeDir;

     m_Variables[CURDIR]=m_MakeDir->GetQuotedFullFileName();

   }

-  theLexer.m_InputFileName=pFileInfo->GetFullFileName();

-  theLexer.m_pParser=(mhmakeparser*)this;

-  theLexer.yyin=::fopen(pFileInfo->GetFullFileName().c_str(),"r");

-  if (!theLexer.yyin)

+

+  ifstream yyin(pFileInfo->GetFullFileName().c_str(),ios_base::in);

+  if (yyin.fail())

   {

     cerr << "Error opening makefile: "<<pFileInfo->GetQuotedFullFileName()<<endl;

     return 1;

   }

+

+  mhmakeFlexLexer theLexer(&yyin);

+  m_ptheLexer=&theLexer;

+  theLexer.m_InputFileName=pFileInfo->GetFullFileName();

+  theLexer.m_pParser=(mhmakeparser*)this;

   int Ret=yyparse();

-  ::fclose(theLexer.yyin);

   return Ret;

 }

 

@@ -169,7 +170,21 @@ bool mhmakefileparser::IsEqual(const string &EqualExpr) const
 ///////////////////////////////////////////////////////////////////////////////

 string mhmakefileparser::ExpandExpression(const string &Expr) const

 {

-  ((mhmakefileparser*)this)->m_InExpandExpression++;

+  bool Recurse;

+  string Ret(Expr);

+  do

+  {

+    Recurse=false;

+    Ret=ExpandExpressionRecurse(Ret,Recurse);

+  }

+  while (Recurse);

+  return Ret;

+}

+

+///////////////////////////////////////////////////////////////////////////////

+string mhmakefileparser::ExpandExpressionRecurse(const string &Expr, bool &Recurse) const

+{

+  //((mhmakefileparser*)this)->m_InExpandExpression++;

   size_t i=0;

   size_t Length=Expr.size();

   string Ret;

@@ -182,7 +197,7 @@ string mhmakefileparser::ExpandExpression(const string &Expr) const
       char CharNext=Expr[i];

       if (CharNext=='$')

       {

-        ToAdd="$$";

+        ToAdd="$";

         i++;

       }

       else

@@ -191,13 +206,13 @@ string mhmakefileparser::ExpandExpression(const string &Expr) const
         i++;

         if (inew>i)

         {

-          ToAdd=ExpandMacro(Expr.substr(i,inew-i-1));

+          ToAdd=ExpandMacro(Expr.substr(i,inew-i-1),Recurse);

           i=inew;

         }

         else

         {

           // This is a single character expression

-          ToAdd=ExpandMacro(string(1,Expr[i-1]));

+          ToAdd=ExpandMacro(string(1,Expr[i-1]),Recurse);

         }

       }

       Ret+=ToAdd;

@@ -207,28 +222,14 @@ string mhmakefileparser::ExpandExpression(const string &Expr) const
       Ret+=Char;

     }

   }

-  if (m_InExpandExpression==1)

-  {

-      // Here we do a special case in case we still have a $ within a %

-    if (Ret.find('$')!=string::npos)

-      Ret=ExpandExpression(Ret);

-    size_t Pos;

-    while ((Pos=Ret.find("$$"))!=string::npos)

-    {

-      Ret=Ret.replace(Pos,2,"$");

-    }

-  }

-  ((mhmakefileparser*)this)->m_InExpandExpression--;

 

   return Ret;

 }

 

 ///////////////////////////////////////////////////////////////////////////////

-string mhmakefileparser::ExpandMacro(const string &Expr) const

+string mhmakefileparser::ExpandMacro(const string &Expr, bool &Recurse) const

 {

-  if (Expr.find('%')!=string::npos && Expr.find('$')==string::npos && Expr.find(':')==string::npos)

-    return string("$(")+Expr+")";

-  string ExpandedExpr=ExpandExpression(Expr);

+  string ExpandedExpr=ExpandExpressionRecurse(Expr,Recurse);

 

   const char *pTmp=ExpandedExpr.c_str();

   /* First remove leading spaces */

@@ -272,8 +273,17 @@ string mhmakefileparser::ExpandMacro(const string &Expr) const
     {

       string Func(pVar,pVarEnd);

       string Arg(pTmp);

-      if (Arg.find('%')!=string::npos && Arg.find('$')!=string::npos)

-        return string("$(")+ExpandedExpr+")";

+      if (Recurse)

+      {

+        #ifdef _DEBUG

+        if (!(Arg.find('%')!=string::npos && Arg.find('$')!=string::npos))

+          throw(string("Bug in mhmake: expected a % and $ sign: ")+Arg);

+        #endif

+        return string("$(")+ExpandedExpr+")";  // we cannot call the function yet since there is still a $(*%*) macro to resolve. so

+                                               // return it a a macro again so it can be resolved when the % is resolved

+                                               // remark that the current test is not completely safe because the % could be out of

+                                               // the $ macro

+      }

       function_f pFunc=m_Functions[Func];

       #ifdef _DEBUG

       if (pFunc)

@@ -299,9 +309,23 @@ string mhmakefileparser::ExpandMacro(const string &Expr) const
   }

   else

   {

+    if (ExpandedExpr.find('%')!=string::npos)

+    {

+      // we have encountered a *%* macro. This means a previous subst is not yet finished. so return

+      // it back as a macro so it can be expanded again later when the % is replaced

+      Recurse=true;

+      return string("$(")+ExpandedExpr+")";

+    }

+    #ifdef _DEBUG

+    else if (ExpandedExpr.find('$')!=string::npos)

+      throw(string("Bug in mhmake: wasn't expecting a $ sign in: ")+ExpandedExpr);

+    #endif

+    else

+    {

     return ExpandExpression(ExpandVar(ExpandedExpr));

   }

 }

+}

 

 ///////////////////////////////////////////////////////////////////////////////

 string mhmakefileparser::ExpandVar(const string &Var) const

diff --git a/tools/mhmake/src/mhmakefileparser.h b/tools/mhmake/src/mhmakefileparser.h
index 8bc0adbe9..6bdaa911d 100644
--- a/tools/mhmake/src/mhmakefileparser.h
+++ b/tools/mhmake/src/mhmakefileparser.h
@@ -27,7 +27,7 @@
 

 class rule;

 

-class mhmakelexer;

+class mhmakeFlexLexer;

 

 struct TOKENVALUE

 {

@@ -58,13 +58,12 @@ class mhmakefileparser : public refbase
 private:

   static commandqueue   sm_CommandQueue;

 

-  mhmakelexer          *m_ptheLexer;

+  mhmakeFlexLexer      *m_ptheLexer;

   int                   m_yyloc;

   fileinfo             *m_RuleThatIsBuild;

   vector<string>        m_ToBeIncludeAfterBuild;

   vector<string>        m_MakefilesToLoad;

   fileinfo*             m_AutoDepFileLoaded;

-  int                   m_InExpandExpression;

   mh_time_t             m_Date;

   uint32                m_EnvMd5_32;   /* Cached Md5_32 value of the userd environment variables */

 #ifdef _DEBUG

@@ -118,7 +117,6 @@ public:
 

   mhmakefileparser(const map<string,string> &CommandLineVars)

     :  m_CommandLineVars(CommandLineVars)

-      ,m_InExpandExpression(0)

       ,m_AutoDepsDirty(false)

       ,m_ForceAutoDepRescan(false)

       ,m_SkipHeadersInitialized(false)

@@ -126,6 +124,8 @@ public:
       ,m_EnvMd5_32(0)

       ,m_pEnv(NULL)

       ,m_FirstTarget(NULL)

+      ,m_RuleThatIsBuild(NULL)

+      ,m_AutoDepFileLoaded(NULL)

       #ifdef _DEBUG

       ,m_ImplicitSearch(0)

       #endif

@@ -216,7 +216,7 @@ public:
   bool SkipHeaderFile(const string &FileName);

   void InitEnv() const;

 

-  virtual ~mhmakefileparser()

+  virtual ~mhmakefileparser() /* virtual to be sure the correct destructor is called when we delete with a pointer to this class which in reality is a pointer to a derived class */

   {

     SaveAutoDepsFile();

 #ifndef WIN32

@@ -240,7 +240,8 @@ public:
   bool IsEqual(const string &EqualExpr) const;

   bool IsExprTrue(const string &EqualExpr) const;

   string ExpandExpression(const string &Expr) const;

-  string ExpandMacro(const string &Expr) const;

+  string ExpandExpressionRecurse(const string &Expr, bool &Recurse) const;

+  string ExpandMacro(const string &Expr, bool &Recurse) const;

   string ExpandVar(const string &Var) const;

 

   void PrintVariables(bool Expand=false) const;

diff --git a/tools/mhmake/src/mhmakelexer.l b/tools/mhmake/src/mhmakelexer.l
index 62df687e1..8cf0f1680 100644
--- a/tools/mhmake/src/mhmakelexer.l
+++ b/tools/mhmake/src/mhmakelexer.l
@@ -19,9 +19,8 @@
 /* $Rev$ */

 

 /* -------------- declaration section -------------- */

-%name mhmakelexer

-%header{

-#include "mhmakeparser.h"

+%{

+

 #include "fileinfo.h"

 #include "rule.h"

 #include "util.h"

@@ -53,51 +52,59 @@ static void SaveMakMd5(fileinfo *pTarget)
   fclose(pFile);

 }

 

-%}

-

-%define LEX_PARAM TOKENVALUE &theValue

-%define MEMBERS public: \

-        struct INSTACK\

-        {\

-          YY_BUFFER_STATE m_BufferState;\

-          string m_FileName;\

-          int m_Line;\

-          INSTACK(YY_BUFFER_STATE BufferState,string FileName,int Line) :\

-            m_BufferState(BufferState),m_FileName(FileName),m_Line(Line) {}\

-        };\

-        int m_Line;\

-        int m_BraceIndent;\

-        size_t m_IndentSkip;\

-        iterstack<int> m_IndentStack;\

-        bool m_IgnoreIncludeError;\

-        string m_InputFileName; \

-        string m_curtoken; \

-        iterstack<INSTACK> m_IncludeStack; \

-        mhmakeparser *m_pParser;\

-        mhmakeparser *GetParser()\

-        {\

-          return m_pParser;\

+static void ReplaceCurlyBraces(string &String)

+{

+  int Pos=String.find_first_of('{',0);

+  if (Pos!=string::npos)

+  {

+    /* if not { found, } will not be there eather (or it is a valid syntax, so it may generate an error) */

+    do

+    {

+      String.replace(Pos,1,1,'(');

+      Pos=String.find_first_of('{',Pos);

+    }

+    while (Pos!=string::npos);

+    Pos=0;

+    while ((Pos=String.find_first_of('}',Pos))!=string::npos)

+      String.replace(Pos,1,1,')');

         }

+}

 

-%define CONSTRUCTOR_INIT : m_Line(1), m_BraceIndent(0)

+#define YY_DECL int mhmakeFlexLexer::yylex(TOKENVALUE &theValue)

+

+%}

+

+%option prefix="mhmake"

+%option never-interactive

+%option 8bit

+%option c++

+%option full

+%option noyywrap

+%option warn

 

 /* -------------- rules section -------------- */

 %x INCLUDE IFDEF IF IFNDEF SKIPUNTILELSEORENDIF QUOTE MAKEEXPRES SINGLEQUOTE COMMANDPARSE

-%x IFEQ IFNEQ ERRORMACRO MESSAGEMACRO MESSAGEINFO MESSAGEERROR REPARSEMACRO LOAD_MAKEFILE

+%x IFEQ IFNEQ ERRORMACRO MESSAGEMACRO REPARSEMACRO LOAD_MAKEFILE

+%x DEFINE

 

 %%

 

  /*---------------------------------------------------------------------------*/

-[ \t\r]*\n/[ ][ \t]* |

+[ \t\r]*\n[ ][ \t]* {

+  yy_set_bol(1); // Make sure the next rule also matches the ^

+  yylineno++;

+  return mhmakeparser::NEWLINE;

+}

+

 [ \t\r]*\n {

-  PRINTF(("%s %d: NEWLINE:\n",m_InputFileName.c_str(),m_Line));

-  m_Line++;

+  PRINTF(("%s %d: NEWLINE:\n",m_InputFileName.c_str(),yylineno));

+  yylineno++;

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*[s\-]?include {

-  PRINTF(("%s %d: INCLUDE: ",m_InputFileName.c_str(),m_Line));

+^[s\-]?include {

+  PRINTF(("%s %d: INCLUDE: ",m_InputFileName.c_str(),yylineno));

   BEGIN(INCLUDE);

   unsigned i=0;

   while (strchr(" \t",yytext[i])) i++;

@@ -114,7 +121,10 @@ static void SaveMakMd5(fileinfo *pTarget)
 <INCLUDE>[^\r\n]+ { /* got the include file name */

   mhmakeparser *pParser=GetParser();

 

-  string IncludeFileNames=pParser->ExpandExpression((const char*)yytext);

+  /* replace the {} by () before expanding */

+  string IncludeFileNames(yytext);

+  ReplaceCurlyBraces(IncludeFileNames);

+  IncludeFileNames=pParser->ExpandExpression(IncludeFileNames);

   PRINTF(("%s -> %s\n",yytext,IncludeFileNames.c_str()));

 

   const char *pTmp=IncludeFileNames.c_str();

@@ -138,31 +148,34 @@ static void SaveMakMd5(fileinfo *pTarget)
       pParser->AddIncludedMakefile(pInclude);

 

       string strToInclude=pInclude->GetFullFileName();

-      FILE *pTmp = ::fopen(strToInclude.c_str(), "r" );

-      if ( ! pTmp )

+      INSTACK *pStackElem=new INSTACK(YY_CURRENT_BUFFER, strToInclude, m_InputFileName, yylineno);

+      if ( pStackElem->fail() )

       {

+        delete pStackElem;

         if (!m_IgnoreIncludeError)

         {

-          iterstack<INSTACK>::reverse_iterator StackIt=m_IncludeStack.rbegin();

+          mystack::reverse_iterator StackIt=m_IncludeStack.rbegin();

           while (StackIt!=m_IncludeStack.rend())

           {

-            cout<<" in "<<StackIt->m_FileName<<" ("<<StackIt->m_Line<<")";

+            cout<<" in "<<(*StackIt)->m_FileName<<" ("<<(*StackIt)->yylineno<<")";

             StackIt++;

           }

           cout<<endl;

-          cout<<"Warning error opening file "<<strToInclude<<" in "<<m_InputFileName<<" ("<<m_Line<<")\n";

+          cout<<"Warning error opening file "<<strToInclude<<" in "<<m_InputFileName<<" ("<<yylineno<<")\n";

           pParser->IncludeAfterBuild(strToInclude);

         }

+        else

+         pInclude->SetPhony();  /* To be sure that no message is printed when mhmake is trying to build the file later */

       }

       else

       {

-        m_IncludeStack.push(INSTACK(YY_mhmakelexer_CURRENT_BUFFER,m_InputFileName,m_Line));

-        m_Line=1;

+        m_IncludeStack.push(pStackElem);

+        yylineno=1;

 

-        yyin=pTmp;

         m_InputFileName=strToInclude;

 

-        YY_mhmakelexer_SWITCH_TO_BUFFER(YY_mhmakelexer_CREATE_BUFFER( yyin, YY_BUF_SIZE ) );

+        yypush_buffer_state(yy_create_buffer( pStackElem->GetStream(), YY_BUF_SIZE ));

+        yyrestart(pStackElem->GetStream());

       }

 

     }

@@ -173,15 +186,17 @@ static void SaveMakMd5(fileinfo *pTarget)
 

  /*---------------------------------------------------------------------------*/

 load_makefile {

-  PRINTF(("%s %d: LOAD_MAKEFILE:\n",m_InputFileName.c_str(),m_Line));

+  PRINTF(("%s %d: LOAD_MAKEFILE:\n",m_InputFileName.c_str(),yylineno));

   BEGIN(LOAD_MAKEFILE);

   return mhmakeparser::NEWLINE;  // Return a newline to be sure that the previous line is completely parse by yacc (in case it is a variable definition)

 }

 

  /*****************************************************************************/

 <LOAD_MAKEFILE>[^\r\n]+ {

-  string ListOfMakefiles=GetParser()->ExpandExpression((const char*)yytext);

-  PRINTF(("%s %d: LOAD_MAKEFILE: '%s'\n",m_InputFileName.c_str(),m_Line,ListOfMakefiles.c_str()));

+  string ListOfMakefiles((const char*)yytext);

+  ReplaceCurlyBraces(ListOfMakefiles);

+  ListOfMakefiles=GetParser()->ExpandExpression(ListOfMakefiles);

+  PRINTF(("%s %d: LOAD_MAKEFILE: '%s'\n",m_InputFileName.c_str(),yylineno,ListOfMakefiles.c_str()));

 

   const char *pTmp=ListOfMakefiles.c_str();

   while (*pTmp)

@@ -190,7 +205,7 @@ load_makefile {
     pTmp=NextCharItem(pTmp,Item,';');

     if (Item.empty())

     {

-      throw m_InputFileName + "(" + stringify(m_Line) + "): Error in load_makefile statement";

+      throw m_InputFileName + "(" + stringify(yylineno) + "): Error in load_makefile statement";

     }

     GetParser()->AddMakefileToMakefilesToLoad(Item);

   }

@@ -198,78 +213,78 @@ load_makefile {
 }

  /*---------------------------------------------------------------------------*/

 <LOAD_MAKEFILE>\r?\n {

-  m_Line++;

+  yylineno++;

   BEGIN(INITIAL);

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]+ {

-  PRINTF(("%s %d: SPACE:\n",m_InputFileName.c_str(),m_Line));

+  PRINTF(("%s %d: SPACE:\n",m_InputFileName.c_str(),yylineno));

   return mhmakeparser::SPACE;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*=[ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: EQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  m_Line++;

+  PRINTF(("%s %d: EQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+  yylineno++;

   theValue.theString=(const char *)yytext;

   return mhmakeparser::EQUAL;

 }

 

 [ \t]*=[ \t]* {

-  PRINTF(("%s %d: EQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: EQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::EQUAL;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*:=[ \t]*\\[ \t\r]*\n[ \t]* {

-  m_Line++;

-  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  yylineno++;

+  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::IMEQUAL;

 }

 

 [ \t]*:=[ \t]* {

-  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::IMEQUAL;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*\?=[ \t]*\\[ \t\r]*\n[ \t]* {

-  m_Line++;

-  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  yylineno++;

+  PRINTF(("%s %d: OPTEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::OPTEQUAL;

 }

 

 [ \t]*\?=[ \t]* {

-  PRINTF(("%s %d: IMEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: OPTEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::OPTEQUAL;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*\+=[ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: PEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  m_Line++;

+  PRINTF(("%s %d: PEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+  yylineno++;

   return mhmakeparser::PEQUAL;

 }

 

 [ \t]*\+=[ \t]* {

-  PRINTF(("%s %d: PEQUAL: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: PEQUAL: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::PEQUAL;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*;[ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: -SEMICOLON (NEWLINE): %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: -SEMICOLON (NEWLINE): %s\n",m_InputFileName.c_str(),yylineno,yytext));

   m_curtoken=g_EmptyString;

-  m_Line++;

+  yylineno++;

   BEGIN(COMMANDPARSE);

   return mhmakeparser::NEWLINE;

 }

 

 [ \t]*;[ \t]* {

-  PRINTF(("%s %d: -SEMICOLON (NEWLINE): %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: -SEMICOLON (NEWLINE): %s\n",m_InputFileName.c_str(),yylineno,yytext));

   m_curtoken=g_EmptyString;

   BEGIN(COMMANDPARSE);

   return mhmakeparser::NEWLINE;

@@ -277,169 +292,170 @@ load_makefile {
 

  /*---------------------------------------------------------------------------*/

 [ \t]*::[ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: DOUBLECOLON: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  m_Line++;

+  PRINTF(("%s %d: DOUBLECOLON: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+  yylineno++;

   theValue.theString=(const char *)yytext;

   return mhmakeparser::DOUBLECOLON;

 }

 

 [ \t]*::[ \t]* {

-  PRINTF(("%s %d: DOUBLECOLON: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: DOUBLECOLON: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::DOUBLECOLON;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*:[ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: COLON: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  m_Line++;

+  PRINTF(("%s %d: COLON: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+  yylineno++;

   theValue.theString=(const char *)yytext;

   return mhmakeparser::COLON;

 }

 

 [ \t]*:[ \t]* {

-  PRINTF(("%s %d: COLON: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: COLON: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::COLON;

 }

 

  /*---------------------------------------------------------------------------*/

 , {

-  PRINTF(("%s %d: COMMA: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: COMMA: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::COMMA;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*endif {

+^endif {

   if (m_IndentStack.size())

   {

     m_IndentStack.pop();

-    PRINTF(("%s %d: %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

   }

   else

   {

-     throw string("Unexpected endif at line ") + stringify(m_Line) + " of " + m_InputFileName;

+     throw string("Unexpected endif at line ") + stringify(yylineno) + " of " + m_InputFileName;

   }

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*ifdef[ \t]*\\[ \t\r]*\n[ \t]* {

+^ifdef[ \t]*\\[ \t\r]*\n[ \t]* {

   BEGIN(IFDEF);

-  m_Line++;

+  yylineno++;

   return mhmakeparser::NEWLINE;

 }

 

-^[ \t]*ifdef[ \t]+ {

+^ifdef[ \t]+ {

   BEGIN(IFDEF);

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*if[ \t]*\\[ \t\r]*\n[ \t]* {

+^if[ \t]*\\[ \t\r]*\n[ \t]* {

   BEGIN(IF);

-  m_Line++;

+  yylineno++;

   m_curtoken=g_EmptyString;

   return mhmakeparser::NEWLINE;

 }

 

-^[ \t]*if[ \t]+ {

+^if[ \t]+ {

   BEGIN(IF);

   m_curtoken=g_EmptyString;

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*ifndef[ \t]*\\[ \t\r]*\n[ \t]* {

+^ifndef[ \t]*\\[ \t\r]*\n[ \t]* {

   BEGIN(IFNDEF);

-  m_Line++;

+  yylineno++;

   return mhmakeparser::NEWLINE;

 }

 

-^[ \t]*ifndef[ \t]+ {

+^ifndef[ \t]+ {

   BEGIN(IFNDEF);

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*ifeq[ \t]*\\[ \t\r]*\n[ \t]* {

+^ifeq[ \t]*\\[ \t\r]*\n[ \t]* {

   BEGIN(IFEQ);

   m_curtoken=g_EmptyString;

-  m_Line++;

+  yylineno++;

   return mhmakeparser::NEWLINE;

 }

 

-^[ \t]*ifeq[ \t]+ {

+^ifeq[ \t]+ {

   BEGIN(IFEQ);

   m_curtoken=g_EmptyString;

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*ifneq[ \t]*\\[ \t\r]*\n[ \t]* {

+^ifneq[ \t]*\\[ \t\r]*\n[ \t]* {

   BEGIN(IFNEQ);

   m_curtoken=g_EmptyString;

-  m_Line++;

+  yylineno++;

   return mhmakeparser::NEWLINE;

 }

 

-^[ \t]*ifneq[ \t]+ {

+^ifneq[ \t]+ {

   BEGIN(IFNEQ);

   m_curtoken=g_EmptyString;

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*else[ \t]* {

+^else[ \t]* {

   if (m_IndentStack.size() && (!m_IndentStack.top()))

   {

-    PRINTF(("%s %d: skipping else: depth %d\n",m_InputFileName.c_str(),m_Line,m_IndentStack.size()));

+    PRINTF(("%s %d: skipping else: depth %d\n",m_InputFileName.c_str(),yylineno,m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     m_IndentStack.top()=1;

     BEGIN(SKIPUNTILELSEORENDIF);

   }

   else

   {

-     throw string("Unexpected else at line ") + stringify(m_Line) + " of file " + m_InputFileName;

+     throw string("Unexpected else at line ") + stringify(yylineno) + " of file " + m_InputFileName;

   }

 }

 

  /*****************************************************************************/

 <IFEQ>\n {

-  unput( yytext[0] );

+  yyless(0);

   m_IndentStack.push(0);

   if (GetParser()->IsEqual(m_curtoken))

   {

-    PRINTF(("%s %d: Not Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     BEGIN(INITIAL);

   }

   else

   {

-    PRINTF(("%s %d: Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

 }

 

-<IF,IFEQ,IFNEQ>[ \t]*\\[ \t\r]*\n[ \t]* { m_Line++; m_curtoken += g_SpaceString;}

+<IF,IFEQ,IFNEQ>[ \t]*\\[ \t\r]*\n[ \t]* { yylineno++; m_curtoken += g_SpaceString;}

 

 <IF,IFEQ,IFNEQ>\r    /* skip */

 

-<IF,IFEQ,IFNEQ>[^\\\r\n]+ |

+<IF,IFEQ,IFNEQ>[^\\\r\n{}\$]+ |

+<IF,IFEQ,IFNEQ>\$ |

 <IF,IFEQ,IFNEQ>\\                        { m_curtoken += (const char *)yytext; }

 

  /*****************************************************************************/

 <IFNEQ>\n {

-  unput( yytext[0] );

+  yyless(0);

   m_IndentStack.push(0);

   if (!GetParser()->IsEqual(m_curtoken))

   {

-    PRINTF(("%s %d: Not Skipping ifneq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping ifneq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     BEGIN(INITIAL);

   }

   else

   {

-    PRINTF(("%s %d: Skipping ifneq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping ifneq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

@@ -447,39 +463,39 @@ load_makefile {
 

  /*****************************************************************************/

 <IF>[ \t\r]*[a-zA-Z0-9_]+[ \t\r]*\n {

-  unput( '\n' );

+  yyless(yyleng-1);

   m_IndentStack.push(0);

 #ifndef WIN32

-  int lastidx=strlen((const char *)yytext)-1;

+  int lastidx=yyleng-1;

   if (yytext[lastidx]=='\r')

     yytext[lastidx]='\0';

 #endif

   string Val=GetParser()->ExpandVar((const char *)yytext);

   if (Val.empty() || Val=="0")

   {

-    PRINTF(("%s %d: Skipping if %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping if %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

   else

   {

-    PRINTF(("%s %d: Not Skipping if %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping if %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     BEGIN(INITIAL);

   }

 }

 

  /*---------------------------------------------------------------------------*/

 <IF>\n {

-  unput( yytext[0] );

+  yyless(0);

   m_IndentStack.push(0);

   if (GetParser()->IsExprTrue(m_curtoken))

   {

-    PRINTF(("%s %d: Not Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     BEGIN(INITIAL);

   }

   else

   {

-    PRINTF(("%s %d: Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str(),m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping ifeq %s: depth %d\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str(),m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

@@ -493,12 +509,12 @@ load_makefile {
   m_IndentStack.push(0);

   if (GetParser()->IsDefined((const char *)yytext))

   {

-    PRINTF(("%s %d: Not Skipping ifdef %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping ifdef %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     BEGIN(INITIAL);

   }

   else

   {

-    PRINTF(("%s %d: Skipping ifdef %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping ifdef %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

@@ -508,12 +524,12 @@ load_makefile {
 <IFNDEF>[a-zA-Z0-9_]+ {

   m_IndentStack.push(0);

   if (!GetParser()->IsDefined((const char *)yytext)) {

-    PRINTF(("%s %d: Not Skipping ifndef %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Not Skipping ifndef %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     BEGIN(INITIAL);

   }

   else

   {

-    PRINTF(("%s %d: Skipping ifndef %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext,m_IndentStack.size()));

+    PRINTF(("%s %d: Skipping ifndef %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext,m_IndentStack.size()));

     m_IndentSkip=m_IndentStack.size();

     BEGIN(SKIPUNTILELSEORENDIF);

   }

@@ -521,26 +537,26 @@ load_makefile {
 

  /*****************************************************************************/

 <SKIPUNTILELSEORENDIF>\n[ ]*endif {

-  m_Line++;

+  yylineno++;

   if (!m_IndentStack.size())

   {

-    throw string("Unexpected endif at line ") + stringify(m_Line) + " of " + m_InputFileName;

+    throw string("Unexpected endif at line ") + stringify(yylineno) + " of " + m_InputFileName;

   }

   else

   {

     m_IndentStack.pop();

-    PRINTF(("%s %d: endif: depth %d\n",m_InputFileName.c_str(),m_Line,m_IndentStack.size()));

+    PRINTF(("%s %d: endif: depth %d\n",m_InputFileName.c_str(),yylineno,m_IndentStack.size()));

     if (m_IndentStack.size()==m_IndentSkip-1) BEGIN(INITIAL);

   }

 }

 

  /*---------------------------------------------------------------------------*/

 <SKIPUNTILELSEORENDIF>\n[ ]*else {

-  m_Line++;

-  PRINTF(("%s %d: else: depth %d\n",m_InputFileName.c_str(),m_Line,m_IndentStack.size()));

+  yylineno++;

+  PRINTF(("%s %d: else: depth %d\n",m_InputFileName.c_str(),yylineno,m_IndentStack.size()));

   if (m_IndentStack.top())

   {

-    throw string("Unexpected else at line ") + stringify(m_Line) + " of file " + m_InputFileName;

+    throw string("Unexpected else at line ") + stringify(yylineno) + " of file " + m_InputFileName;

   }

   m_IndentStack.top()=1;

   if (m_IndentStack.size()==m_IndentSkip)

@@ -551,9 +567,9 @@ load_makefile {
 

  /*---------------------------------------------------------------------------*/

 <SKIPUNTILELSEORENDIF>\n[ ]*if(def|ndef|eq|neq)? {

-  m_Line++;

+  yylineno++;

   m_IndentStack.push(0);

-  PRINTF(("%s %d: %s: depth %d\n",m_InputFileName.c_str(),m_Line,yytext+1,m_IndentStack.size()));

+  PRINTF(("%s %d: %s: depth %d\n",m_InputFileName.c_str(),yylineno,yytext+1,m_IndentStack.size()));

 }

 

  /*---------------------------------------------------------------------------*/

@@ -561,91 +577,118 @@ load_makefile {
  /*---------------------------------------------------------------------------*/

 <SKIPUNTILELSEORENDIF>[^a-zA-Z\n]+ /* skip */

  /*---------------------------------------------------------------------------*/

-<SKIPUNTILELSEORENDIF>\n[ ]*[a-zA-Z]+ m_Line++;

+<SKIPUNTILELSEORENDIF>\n[ ]*[a-zA-Z]+ yylineno++;

  /*---------------------------------------------------------------------------*/

 <SKIPUNTILELSEORENDIF>\n {

-  m_Line++;

+  yylineno++;

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*#[^\n]* {

-  PRINTF(("%s %d: -COMMENT: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: -COMMENT: %s\n",m_InputFileName.c_str(),yylineno,yytext));

 }

 

  /*---------------------------------------------------------------------------*/

 [ \t]*\\[ \t\r]*\n[ \t]* {

-  PRINTF(("%s %d: SPACE:\n",m_InputFileName.c_str(),m_Line));

-  m_Line++;

+  PRINTF(("%s %d: SPACE:\n",m_InputFileName.c_str(),yylineno));

+  yylineno++;

   return mhmakeparser::SPACE;

 }

 

  /*---------------------------------------------------------------------------*/

 \.PHONY {

-  PRINTF(("%s %d: .PHONY: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: .PHONY: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::PHONY;

 }

 

  /*---------------------------------------------------------------------------*/

 \.AUTODEPS {

-  PRINTF(("%s %d: .AUTODEPS: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: .AUTODEPS: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::AUTODEPS;

 }

 

  /*---------------------------------------------------------------------------*/

 export {

-  PRINTF(("%s %d: export: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: export: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::EXPORT;

 }

 

  /*---------------------------------------------------------------------------*/

-^[ \t]*vpath {

-  PRINTF(("%s %d: vpath\n",m_InputFileName.c_str(),m_Line));

+^vpath {

+  PRINTF(("%s %d: vpath\n",m_InputFileName.c_str(),yylineno));

   return mhmakeparser::VPATH;

 }

 

  /*---------------------------------------------------------------------------*/

 [a-zA-Z]:[a-zA-Z0-9\\\._\~\-%\@<&/]+\\[ \t\r]*\n {

-  size_t EndIndex=::strlen((const char*)yytext);

+  size_t EndIndex=yyleng;

   while (strchr(" \t\r\n\\",yytext[--EndIndex]));

   yyless(EndIndex+1);

 

-  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

 }

 

 [a-zA-Z]:[a-zA-Z0-9\\\._\~\-%\@<&/]+ {

-  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

 }

 

  /*---------------------------------------------------------------------------*/

 ([a-zA-Z0-9\\\._\~\-\+%\@<&;/\*\|]|\\\ |\\#)+\\[ \t\r]*\n  {

-  size_t EndIndex=::strlen((const char*)yytext);

+  size_t EndIndex=yyleng;

   while (strchr(" \t\r\n\\",yytext[--EndIndex]));

   yyless(EndIndex+1);

 

-  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

 }

 

 ([a-zA-Z0-9\\\._\~\-\+%\@<&;/\*\|]|\\\ |\\#)+\+=  {

-  size_t Len;

-  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  Len=strlen((const char *)yytext)-2;

-  yyless(Len);

+  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+  yyless(yyleng-2);

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

 }

 

 ([a-zA-Z0-9\\\._\~\-\+%\@<&;/\*\|]|\\\ |\\#)+  {

-  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: STRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

 }

 

+^define[ \t]+[a-zA-Z0-9_\.]+[ \t]*\n {

+  const char *pVar=(const char *)yytext;

+  while (strchr(" \t",*pVar)) pVar++;

+  pVar+=6;

+  theValue.theString=pVar;

+  BEGIN(DEFINE);

+  m_curtoken=g_EmptyString;

+  PRINTF(("%s %d: VARDEF: %s\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str()));

+  yylineno++;

+  return mhmakeparser::VARDEF;

+}

+

+<DEFINE>[ \t]*\\[ \t\r]*\n[ \t]* {

+  yylineno++;

+  m_curtoken+=g_SpaceString;

+}

+

+<DEFINE>. {

+  m_curtoken+=(const char *)yytext;

+}

+

+<DEFINE>[ \t]*\n[ \t]*endef {

+  yylineno++;

+  theValue.theString=m_curtoken;

+  PRINTF(("%s %d: VARVAL: %s\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str()));

+  BEGIN(INITIAL);

+  return mhmakeparser::VARVAL;

+}

+

  /*---------------------------------------------------------------------------*/

 \"  {

   BEGIN(QUOTE);

@@ -661,45 +704,33 @@ export {
  /*---------------------------------------------------------------------------*/

 \$\(  {

   m_BraceIndent++;

-  PRINTF(("%s %d: BEGIN MACRO $(: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: BEGIN MACRO $(: %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   BEGIN(MAKEEXPRES);

-  yymore();

+  m_curtoken=(const char *)yytext;

 }

 

  /*---------------------------------------------------------------------------*/

 \$\([ \t]*error[ \t]+ {

   m_BraceIndent++;

-  PRINTF(("%s %d: BEGIN ERROR MACRO $(: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: BEGIN ERROR MACRO $(: %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   BEGIN(ERRORMACRO);

   m_curtoken=g_EmptyString;

+  return mhmakeparser::NEWLINE; // Make sure that the previous lines are matched by the bison parser (so that all variables until here are defined)

 }

 

  /*---------------------------------------------------------------------------*/

-\$\([ \t]*message[ \t]+ {

+\$\([ \t]*(message|info)[ \t]+ {

   m_BraceIndent++;

-  PRINTF(("%s %d: BEGIN MESSAGE MACRO $(: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: BEGIN MESSAGE MACRO $(: %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   BEGIN(MESSAGEMACRO);

   m_curtoken=g_EmptyString;

-}

-

- /*---------------------------------------------------------------------------*/

-[ \t]*\$\{[ \t]*info[ \t]+ {

-  PRINTF(("%s %d: BEGIN INFO MESSAGE ${: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

-  BEGIN(MESSAGEINFO);

-  m_curtoken=g_EmptyString;

-}

-

- /*---------------------------------------------------------------------------*/

-[ \t]*\$\{[ \t]*error[ \t]+ {

-  PRINTF(("%s %d: BEGIN ERROR MESSAGE ${: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

-  BEGIN(MESSAGEERROR);

-  m_curtoken=g_EmptyString;

+  return mhmakeparser::NEWLINE; // Make sure that the previous lines are matched by the bison parser (so that all variables until here are defined)

 }

 

  /*---------------------------------------------------------------------------*/

 \$\([ \t]*reparse[ \t]+ {

   m_BraceIndent++;

-  PRINTF(("%s %d: BEGIN REPARSE MACRO $(: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: BEGIN REPARSE MACRO $(: %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   BEGIN(REPARSEMACRO);

   m_curtoken=g_EmptyString;

   return mhmakeparser::NEWLINE;

@@ -707,19 +738,19 @@ export {
 

  /*---------------------------------------------------------------------------*/

 \(   {

-  PRINTF(("%s %d: OPENBRACE: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: OPENBRACE: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::OPENBRACE;

 }

 

  /*---------------------------------------------------------------------------*/

 \)   {

-  PRINTF(("%s %d: CLOSEBRACE: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: CLOSEBRACE: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   return mhmakeparser::CLOSEBRACE;

 }

 

  /*---------------------------------------------------------------------------*/

 \$[<@/$] {

-  PRINTF(("%s %d: DOLLAREXPR: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: DOLLAREXPR: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   theValue.theString=(const char *)yytext;

   return mhmakeparser::DOLLAREXPR;

 }

@@ -727,40 +758,50 @@ export {
  /*---------------------------------------------------------------------------*/

 [ \t\r]*\n\t[ \t]* {

   /* token newline */

-  PRINTF(("%s %d: NEWLINE\n",m_InputFileName.c_str(),m_Line));

-  m_Line++;

+  PRINTF(("%s %d: NEWLINE\n",m_InputFileName.c_str(),yylineno));

+  yylineno++;

   m_curtoken=g_EmptyString;

   BEGIN(COMMANDPARSE);

   return mhmakeparser::NEWLINE;

 }

 

  /*---------------------------------------------------------------------------*/

+<*>\$\{ {

+  unput('(');

+  unput('$');

+}

+ /*---------------------------------------------------------------------------*/

+<*>\} {

+  unput(')');

+}

+

+ /*---------------------------------------------------------------------------*/

 [^\n] {

-  PRINTF(("%s %d: ANYCHAR: %d: %s\n",m_InputFileName.c_str(),m_Line,m_Line,yytext));

+  PRINTF(("%s %d: ANYCHAR: %d: %s\n",m_InputFileName.c_str(),yylineno,yylineno,yytext));

 }

 

  /*****************************************************************************/

 

 <COMMANDPARSE>[ \t\r]*\n {

-  PRINTF(("%s %d: COMMAND: %d: %s\n",m_InputFileName.c_str(),m_Line,m_Line,m_curtoken.c_str()));

+  PRINTF(("%s %d: COMMAND: %d: %s\n",m_InputFileName.c_str(),yylineno,yylineno,m_curtoken.c_str()));

   theValue.theString=m_curtoken;

-  m_Line++;

+  yylineno++;

   BEGIN(INITIAL);

   return mhmakeparser::COMMAND;

 }

 

  /*---------------------------------------------------------------------------*/

 <COMMANDPARSE>[ \t\r]*\n\t[ \t]* {

-  PRINTF(("%s %d: COMMAND: %s\n",m_InputFileName.c_str(),m_Line,m_curtoken.c_str()));

+  PRINTF(("%s %d: COMMAND: %s\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str()));

   theValue.theString=m_curtoken;

-  m_Line++;

+  yylineno++;

   m_curtoken=g_EmptyString;

   return mhmakeparser::COMMAND;

 }

 

  /*---------------------------------------------------------------------------*/

 <COMMANDPARSE>[ \t]*\\[ \t\r]*\n[ \t]* {

-  m_Line++;

+  yylineno++;

   m_curtoken+=g_SpaceString;

 }

 

@@ -770,35 +811,28 @@ export {
 }

 

  /*---------------------------------------------------------------------------*/

-<COMMANDPARSE>[^ \r\n#\\]+ |

+<COMMANDPARSE>[^ \r\n#\\{}$]+ |

+<COMMANDPARSE>\$ |

 <COMMANDPARSE>\\ {

   m_curtoken+=(const char *)yytext;

 }

 

  /*---------------------------------------------------------------------------*/

 <COMMANDPARSE>[ \t]*\\#[^\n]* {

-  char ToAdd[100];

-  int i=0;

   int nChars=(int)((strchr((const char *)yytext,'#')-(char*)yytext))+1;

-  while (strchr(" \t",yytext[i]))

-  {

-    ToAdd[i]=yytext[i];

-    i++;

-  }

-  ToAdd[i++]='#';

-  ToAdd[i++]=0;

-  m_curtoken+=ToAdd;

   yyless(nChars);

+  m_curtoken+=string(yytext,nChars-2);

+  m_curtoken+='#';

 }

 

  /*---------------------------------------------------------------------------*/

 <COMMANDPARSE>[ \t]*#[^\n]* {

-  PRINTF(("%s %d: -COMMENT: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: -COMMENT: %s\n",m_InputFileName.c_str(),yylineno,yytext));

 }

 

  /*****************************************************************************/

 <QUOTE>\" {

-  PRINTF(("%s %d: QUOTEDSTRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: QUOTEDSTRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   BEGIN(INITIAL);

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

@@ -807,7 +841,8 @@ export {
  /*---------------------------------------------------------------------------*/

 <QUOTE>\r /* skip */

 

-<QUOTE>[^\\\"\r\n]+  |

+<QUOTE>[^\\\"\r\n{}$]+  |

+<QUOTE>\$            |

 <QUOTE>\\            |

 <QUOTE>\\\"          |

 <QUOTE>\\#  {

@@ -816,7 +851,7 @@ export {
 

  /*****************************************************************************/

 <SINGLEQUOTE>\' {

-  PRINTF(("%s %d: QUOTEDSTRING: %s\n",m_InputFileName.c_str(),m_Line,yytext));

+  PRINTF(("%s %d: QUOTEDSTRING: %s\n",m_InputFileName.c_str(),yylineno,yytext));

   BEGIN(INITIAL);

   theValue.theString=(const char *)yytext;

   return mhmakeparser::STRING;

@@ -825,7 +860,8 @@ export {
  /*---------------------------------------------------------------------------*/

 <SINGLEQUOTE>\r /* skip */

 

-<SINGLEQUOTE>[^\\\'\r\n]+ |

+<SINGLEQUOTE>[^\\\'\r\n{}$]+ |

+<SINGLEQUOTE>\$           |

 <SINGLEQUOTE>\\           |

 <SINGLEQUOTE>\\\'         |

 <SINGLEQUOTE>\\# {

@@ -835,57 +871,39 @@ export {
  /*****************************************************************************/

 <ERRORMACRO>\) {

   m_BraceIndent--;

-  PRINTF(("%s %d: CLOSE BRACE ERROR MACRO ): %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: CLOSE BRACE ERROR MACRO ): %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   if (!m_BraceIndent)

   {

-    PRINTF(("%s %d: ERRORMACRO: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-    yyless(0);

-    throw GetParser()->ExpandExpression((const char*)yytext);

+    PRINTF(("%s %d: ERRORMACRO: %s\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str()));

+    throw string("\n-> ")+m_InputFileName.c_str()+"("+stringify(yylineno)+") : "+GetParser()->ExpandExpression(m_curtoken);

   } else {

-    yymore();

-  }

+    m_curtoken+=(const char *)yytext;

 }

-

- /*****************************************************************************/

-<MESSAGEERROR>[^\}]+ {

-  throw(GetParser()->ExpandExpression((const char*)yytext));

-}

-

- /*****************************************************************************/

-<MESSAGEINFO>[^\}]+ {

-  cerr<<GetParser()->ExpandExpression((const char*)yytext)<<endl;

-}

-

- /*****************************************************************************/

-<MESSAGEINFO>\} {

-  PRINTF(("%s %d: MESSAGEINFO: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-  BEGIN(INITIAL);

 }

 

  /*****************************************************************************/

 <MESSAGEMACRO>\) {

   m_BraceIndent--;

-  PRINTF(("%s %d: CLOSE BRACE MESSAGE MACRO ): %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: CLOSE BRACE MESSAGE MACRO ): %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   if (!m_BraceIndent)

   {

-    PRINTF(("%s %d: MESSAGEMACRO: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-    yytext[strlen((const char*)yytext)-1]=0;

-    cerr<<GetParser()->ExpandExpression((const char*)yytext)<<endl;

+    PRINTF(("%s %d: MESSAGEMACRO: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+    cerr<<m_InputFileName.c_str()<<"("<<stringify(yylineno)+") : "<<GetParser()->ExpandExpression(m_curtoken)<<endl;

     BEGIN(INITIAL);

   } else {

-    yymore();

+    m_curtoken+=(const char *)yytext;

   }

 }

 

  /*****************************************************************************/

 <REPARSEMACRO>\) {

   m_BraceIndent--;

-  PRINTF(("%s %d: CLOSE BRACE REPARSE MACRO ): %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: CLOSE BRACE REPARSE MACRO ): %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   if (!m_BraceIndent)

   {

-    PRINTF(("%s %d: REPARSEMACRO: %s\n",m_InputFileName.c_str(),m_Line,yytext));

-    string Deps=GetParser()->ExpandExpression((const char*)yytext);

-    PRINTF(("%s %d: REPARSEMACRO expanded: %s\n",m_InputFileName.c_str(),m_Line,Deps.c_str()));

+    PRINTF(("%s %d: REPARSEMACRO: %s\n",m_InputFileName.c_str(),yylineno,yytext));

+    string Deps=GetParser()->ExpandExpression(m_curtoken);

+    PRINTF(("%s %d: REPARSEMACRO expanded: %s\n",m_InputFileName.c_str(),yylineno,Deps.c_str()));

     string::const_reverse_iterator It=Deps.rbegin()+1; // +1 because we don't want the latest brace

     string::const_reverse_iterator ItBeg=Deps.rend();

     while (It!= ItBeg)

@@ -898,42 +916,45 @@ export {
   }

   else

   {

-    yymore();

+    m_curtoken+=(const char *)yytext;

   }

 }

 

  /*****************************************************************************/

 <MAKEEXPRES>\) {

   m_BraceIndent--;

-  PRINTF(("%s %d: CLOSE BRACE MAKEEXPRES MACRO ): %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

+  PRINTF(("%s %d: CLOSE BRACE MAKEEXPRES MACRO ): %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

   if (!m_BraceIndent)

   {

-    PRINTF(("%s %d: DOLLAREXPR: %s\n",m_InputFileName.c_str(),m_Line,yytext));

     BEGIN(INITIAL);

-    theValue.theString=(const char *)yytext;

+    m_curtoken+=(const char *)yytext;

+    theValue.theString=m_curtoken;

+    PRINTF(("%s %d: DOLLAREXPR: %s\n",m_InputFileName.c_str(),yylineno,m_curtoken.c_str()));

     return mhmakeparser::DOLLAREXPR;

   }

   else

   {

-    yymore();

+    m_curtoken+=(const char *)yytext;

   }

 }

 

  /*---------------------------------------------------------------------------*/

 <MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>\$\( {

   m_BraceIndent++;

-  PRINTF(("%s %d: MACRO extra $(: %d\n",m_InputFileName.c_str(),m_Line,m_BraceIndent));

-  yymore();

+  PRINTF(("%s %d: MACRO extra $(: %d\n",m_InputFileName.c_str(),yylineno,m_BraceIndent));

+  m_curtoken+=(const char *)yytext;

 }

 

  /*---------------------------------------------------------------------------*/

-<MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>[^$\(\)\r\n]+ |

+<MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>[^$\(\){}\r\n\\]+ |

 <MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>\$        |

+<MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>\\        |

 <MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>\( {

-  yymore();

+  m_curtoken+=(const char *)yytext;

 }

-<MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>\r?\n {

-  m_Line++;

+<MAKEEXPRES,ERRORMACRO,MESSAGEMACRO,REPARSEMACRO>[ \t\r]*\\[ \t\r]*\n[ \t\r]* {

+  yylineno++;

+  m_curtoken+=g_SpaceString;

 }

 

 <SKIPUNTILELSEORENDIF><<EOF>> {

@@ -955,12 +976,10 @@ export {
   }

   else

   {

-    ::fclose(YY_mhmakelexer_CURRENT_BUFFER->yy_input_file);

-    YY_mhmakelexer_DELETE_BUFFER(YY_mhmakelexer_CURRENT_BUFFER);

-    INSTACK *pInStack=&m_IncludeStack.top();

-    YY_mhmakelexer_SWITCH_TO_BUFFER(pInStack->m_BufferState);

+    INSTACK *pInStack=m_IncludeStack.top();

+    yypop_buffer_state();

     m_InputFileName=pInStack->m_FileName;

-    m_Line=pInStack->m_Line;

+    yylineno=pInStack->yylineno;

     m_IncludeStack.pop();

   }

 }

diff --git a/tools/mhmake/src/mhmakeparser.y b/tools/mhmake/src/mhmakeparser.y
index e2312b50e..f1ab48606 100644
--- a/tools/mhmake/src/mhmakeparser.y
+++ b/tools/mhmake/src/mhmakeparser.y
@@ -41,7 +41,7 @@
 

 %token <theString> COMMAND

 %token <theString> COMMA OPENBRACE CLOSEBRACE

-%token <theString> STRING DOLLAREXPR EQUAL COLON DOUBLECOLON

+%token <theString> STRING DOLLAREXPR EQUAL COLON DOUBLECOLON VARDEF VARVAL

 %token IMEQUAL PEQUAL OPTEQUAL PHONY AUTODEPS EXPORT NEWLINE INCLUDEMAK SPACE VPATH

 

 %type <theString> expression nonspaceexpression simpleexpression

@@ -182,7 +182,12 @@ vpathrule: VPATH SPACE nonspaceexpression SPACE expression NEWLINE
            }

 ;

 

-varassignment: STRING EQUAL maybeemptyexpression

+varassignment: VARDEF VARVAL

+               {

+                 m_Variables[f_strip($1)]=$2;

+                 PRINTF(("Defining variable %s to %s\n",f_strip($1).c_str(), $2.c_str()));

+               }

+               | STRING EQUAL maybeemptyexpression

                {

                  m_Variables[$1]=$3;

                  PRINTF(("Setting variable %s to %s\n",$1.c_str(), $3.c_str()));

diff --git a/tools/mhmake/src/rule.cpp b/tools/mhmake/src/rule.cpp
index dc8ab3b00..cee38ddb9 100644
--- a/tools/mhmake/src/rule.cpp
+++ b/tools/mhmake/src/rule.cpp
@@ -27,6 +27,7 @@
 

 refptr<rule> NullRule;

 

+set<rule*> IMPLICITRULE::m_ImplicitRuleRecurseDetStack;

 vector<pair<fileinfo *, vector<pair< fileinfo *,refptr<rule> > > > > IMPLICITRULE::m_ImplicitRules;

 

 makecommand g_MakeCommand;  // Order is important since sm_Statics is using g_MakeCommand

@@ -78,8 +79,8 @@ static bool FindDep(fileinfo *pDep, vector<pair<fileinfo*,refptr<rule> > >*pImpl
         else

           cerr << ErrorMessage << endl;

       }

-      mhmakeparser *pOldMakefile=SecIt->second->GetMakefile();

-      mhmakeparser *pNewMakefile=Rule->GetMakefile();

+      mhmakefileparser *pOldMakefile=SecIt->second->GetMakefile();

+      mhmakefileparser *pNewMakefile=Rule->GetMakefile();

       vector<string>::iterator OldIt=OldCommands.begin();

       vector<string>::iterator NewIt=NewCommands.begin();

       while (OldIt!=OldCommands.end())

@@ -107,6 +108,14 @@ static bool FindDep(fileinfo *pDep, vector<pair<fileinfo*,refptr<rule> > >*pImpl
 ///////////////////////////////////////////////////////////////////////////////

 void IMPLICITRULE::AddImplicitRule(fileinfo *pTarget,const vector<fileinfo*> &Deps,refptr<rule> Rule)

 {

+  if (!Rule)

+  {

+    #ifdef _DEBUG

+    if (g_PrintAdditionalInfo)

+      cout << "No commands defined for implicit rule " << pTarget->GetFullFileName()<<endl;

+    #endif

+    return;

+  }

   // first search if there is already the same target in the current list of implicit rules

   vector<pair<fileinfo*,refptr<rule> > >* pImplicitRule=NULL;

   vector<pair<fileinfo *, vector<pair< fileinfo *,refptr<rule> > > > >::iterator RuleIt=m_ImplicitRules.begin();

@@ -164,13 +173,20 @@ void IMPLICITRULE::SearchImplicitRule(const fileinfo *pTarget,vector< pair<filei
 #ifdef _DEBUG

         if (!ResIt->second)

         {

-          throw string("No rhs for implicit rule : ") + ImpRegExIt->first->GetFullFileName();

+          throw string("No commands for implicit rule : ") + ImpRegExIt->first->GetFullFileName();

         }

 #endif

         ResIt->second->SetStem(Res.m_Stem);

         if (ResIt->first!=NULL)

         {

           string Dependent=ReplaceWithStem(ResIt->first->GetFullFileName(),Res.m_Stem);

+          #ifdef _DEBUG

+          if (Dependent.length()>MAX_PATH)

+          {

+            /* File name is getting too long, this is most probable an infinit loop */

+            throw(string("Filename too long in implicit rule search: ")+Dependent+"\nProbably some infinit loop in the implicit rules search.\n");

+          }

+          #endif

           Result.push_back(pair<fileinfo*,refptr<rule> >(GetFileInfo(Dependent,ResIt->second->GetMakefile()->GetMakeDir()),ResIt->second));

         }

         else

diff --git a/tools/mhmake/src/rule.h b/tools/mhmake/src/rule.h
index 1ec944f96..3b288e3d2 100644
--- a/tools/mhmake/src/rule.h
+++ b/tools/mhmake/src/rule.h
@@ -23,17 +23,17 @@
 

 #include "refptr.h"

 #include "md5.h"

-class mhmakeparser;

+class mhmakefileparser;

 class fileinfo;

 

 class rule: public refbase

 {

   vector<string> m_Commands;

   string m_Stem;   // Contains the stem in case the rule is part of an implicit rule (filled in in the implicit search)

-  mhmakeparser* m_pMakefile;

+  mhmakefileparser* m_pMakefile;

   vector< fileinfo* > m_Targets;  /* Targets that are build with this rule, do not use refptr here because otherwise we get circular references */

 public:

-  rule(mhmakeparser *pMakefile): m_pMakefile(pMakefile)

+  rule(mhmakefileparser *pMakefile): m_pMakefile(pMakefile)

   {

   }

 

@@ -56,11 +56,11 @@ public:
   {

     return m_Stem;

   }

-  void SetMakefile(mhmakeparser *pMakefile)

+  void SetMakefile(mhmakefileparser *pMakefile)

   {

     m_pMakefile=pMakefile;

   }

-  mhmakeparser *GetMakefile()

+  mhmakefileparser *GetMakefile()

   {

     return m_pMakefile;

   }

@@ -76,11 +76,29 @@ public:
 

 class IMPLICITRULE

 {

+  static set<rule*> m_ImplicitRuleRecurseDetStack;

   static vector<pair<fileinfo *, vector<pair< fileinfo *,refptr<rule> > > > > m_ImplicitRules;  // Use a vector and not a map because the order of the implicit rules is important

 public:

   static void AddImplicitRule(fileinfo *pTarget,const vector<fileinfo*> &Deps,refptr<rule> pRule);

   static void SearchImplicitRule(const fileinfo *pTarget,vector< pair<fileinfo*,refptr<rule> > >&Result);

   static void PrintImplicitRules();

+  static bool PushRule(rule *pRule)

+  {

+    set<rule*>::iterator pFound=m_ImplicitRuleRecurseDetStack.find(pRule);

+    if (pFound==m_ImplicitRuleRecurseDetStack.end())

+    {

+      m_ImplicitRuleRecurseDetStack.insert(pRule);

+      return false;

+    }

+    else

+    {

+      return true;

+    }

+  }

+  static void PopRule(rule *pRule)

+  {

+    m_ImplicitRuleRecurseDetStack.erase(pRule);

+  }

 };

 

 extern refptr<rule> NullRule;

diff --git a/tools/mhmake/src/stdafx.h b/tools/mhmake/src/stdafx.h
index 3a6bbb946..5d1ffedfb 100644
--- a/tools/mhmake/src/stdafx.h
+++ b/tools/mhmake/src/stdafx.h
@@ -36,6 +36,7 @@
 #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers

 

 #include <iostream>

+#include <fstream>

 #include <string>

 #include <vector>

 #include <queue>

diff --git a/tools/mhmake/src/util.cpp b/tools/mhmake/src/util.cpp
index 2e26cf2e7..63bdb767b 100644
--- a/tools/mhmake/src/util.cpp
+++ b/tools/mhmake/src/util.cpp
@@ -470,7 +470,7 @@ loadedmakefile::loadedmakefile(const fileinfo *pDir, vector<string> &Args,const
           break;

         case 'C':

 #ifdef _DEBUG

-          if ((*ArgIt)[2]=='D')

+          if (ArgIt->size()>2 && (*ArgIt)[2]=='D')

           {

             g_CheckCircularDeps=true;

             break;

@@ -593,7 +593,7 @@ void loadedmakefile::LoadMakefile()
     cout << "Loading makefile "<<m_Makefile->GetQuotedFullFileName()<<endl;

   #endif

 

-  m_pParser=refptr<mhmakeparser>(new mhmakeparser(m_CommandLineVars));

+  m_pParser=refptr<mhmakefileparser>(new mhmakeparser(m_CommandLineVars));

 

   // Add the MAKECMDGOALS environment variable

   string MakeCmdGoals;

diff --git a/tools/mhmake/src/util.h b/tools/mhmake/src/util.h
index ff1fac9aa..60809cd85 100644
--- a/tools/mhmake/src/util.h
+++ b/tools/mhmake/src/util.h
@@ -50,7 +50,7 @@
 #define PLATFORM     "linux"

 #endif

 

-#define MHMAKEVER    "2.2.9"

+#define MHMAKEVER    "2.3.15"

 

 class makecommand

 {

@@ -170,7 +170,7 @@ struct loadedmakefile : public refbase
   map<string,string>   m_CommandLineVars;

 

   vector<string>       m_CommandLineTargets;

-  refptr<mhmakeparser> m_pParser;

+  refptr<mhmakefileparser> m_pParser;

 

   loadedmakefile(const fileinfo *pDir, vector<string> &Args,const string &Makefile=g_EmptyString);