/*
 * A n t l r  T r a n s l a t i o n  H e a d e r
 *
 * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
 * Purdue University Electrical Engineering
 * With AHPCRC, University of Minnesota
 * ANTLR Version 1.33MR33
 *
 *   antlr -o antlr-out -e3 -nopurify -CC -gl parser.g
 *
 */

#define ANTLR_VERSION	13333
#include "pcctscfg.h"
#include "pccts_stdio.h"
#line 1 "parser.g"
#include "tokens.h"

#include "config.h"

#include <cmath>
#include <list>

#include "lsys.h"
#include "util.h"

#define PURIFY(a,b)

void parse_file (FILE *file, const string &path, lsys &l) t_err;
void parse_file (const string &path, lsys &l) t_err;

extern list<string> include_dirs;
#include "AParser.h"
#include "Parser.h"
#include "DLexerBase.h"
#include "ATokPtr.h"
#line 18 "parser.g"

#include <sstream>
#include <cstdio>

#include "DLGLexer.h"

list<string> include_dirs;

void parse_file (FILE *file, const string &path, lsys &l) t_err
{
  DLGFileInput in (file);
  DLGLexer scanner (&in);
  ANTLRTokenBuffer pipe (&scanner);
  ANTLRCommonToken token;
  scanner.setToken (&token);
  Parser parser (&pipe);
  parser.init ();
  
  parser.current_file = path;
  parser.parse_file (l);
}

void parse_file (const string &path, lsys &l) t_err
{
  string ipath(path);
  list<string>::const_iterator i = include_dirs.begin ();
  FILE *f;
  
  while (!(f = fopen (ipath.c_str (), "r")))
  {
    ipath += ".l";
    if ((f = fopen (ipath.c_str (), "r")))
    break;
    
      if (i == include_dirs.end ())
    throw error ("unable to find or open file '" + path + "'");
    
      ipath = *i + "/" + path;
    i++;
  }
  
  struct filebuf
  {
    FILE *f;
    filebuf (FILE * file) : f (file) {};
    ~filebuf () { fclose (f); };
  } auto_close(f);
  
  parse_file (f, ipath, l);
}

void
Parser::parse_file(lsys & l)
{
#line 113 "parser.g"
  zzRULE;
#line 114 "parser.g"
  parse_lsys( l );
#line 114 "parser.g"
  zzmatch(1); consume();
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x1);
}

void
Parser::parse_lsys(lsys & l)
{
#line 117 "parser.g"
  zzRULE;
  if ( (setwd1[LA(1)]&0x2)&&((
istok(LT(1), "include") )||(
istok(LT(1), "ruleset") )||(
istok(LT(1), "define") )||(
istok(LT(1), "ignore") )||(
!istok(LT(1), ")") )) ) {
#line 118 "parser.g"
    {
      int zzcnt=1;
      if (((
istok(LT(1), "include") )||(
istok(LT(1), "ruleset") )||(
istok(LT(1), "define") )||(
istok(LT(1), "ignore") )||(
!istok(LT(1), ")") ))) {
      do {
#line 118 "parser.g"
        statement(  l );
      } while ( (setwd1[LA(1)]&0x4)&&((
istok(LT(1), "include") )||(
istok(LT(1), "ruleset") )||(
istok(LT(1), "define") )||(
istok(LT(1), "ignore") )||(
!istok(LT(1), ")") )) );
      }
    }
  }
  else {
    if ( (setwd1[LA(1)]&0x8) ) {
    }
    else {FAIL(1,err1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd1, 0x10);
}

void
Parser::statement(lsys & l)
{
#line 121 "parser.g"
  zzRULE;
  ANTLRTokenPtr qw_str=NULL, br_str=NULL;
#line 122 "parser.g"
  string s; lsys *m = 0; /* calm down gcc */
  if ( (setwd1[LA(1)]&0x20)&&(
istok(LT(1), "include") ) ) {
    if (!(
#line 123 "parser.g"
istok(LT(1), "include") )      ) {zzfailed_pred("   istok(LT(1), \"include\") ",0 /* report */, { 0; /* no user action */ } );}
#line 123 "parser.g"
    zzsetmatch(WildCard_set, WildCard_errset); consume();
#line 125 "parser.g"
    {
      if ( (LA(1)==Name) ) {
#line 125 "parser.g"
        zzmatch(Name);
        qw_str = (ANTLRTokenPtr)LT(1);

#line 126 "parser.g"
        
        ::parse_file ( qw_str->getText(), l);
 consume();
      }
      else {
        if ( (LA(1)==17) ) {
#line 130 "parser.g"
          zzmatch(17); consume();
#line 130 "parser.g"
          zzmatch(Name);
          br_str = (ANTLRTokenPtr)LT(1);
 consume();
#line 130 "parser.g"
          zzmatch(18);
#line 131 "parser.g"
          
          m = new lsys;
          ::parse_file ( br_str->getText (), *m);
          l.add_lsys (m);
 consume();
        }
        else {FAIL(1,err4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
      }
    }
  }
  else {
    if ( (setwd1[LA(1)]&0x40)&&(
istok(LT(1), "ruleset") ) ) {
      if (!(
#line 137 "parser.g"
istok(LT(1), "ruleset") )        ) {zzfailed_pred("   istok(LT(1), \"ruleset\") ",0 /* report */, { 0; /* no user action */ } );}
#line 137 "parser.g"
      zzsetmatch(WildCard_set, WildCard_errset); consume();
#line 138 "parser.g"
      {
        if ( (LA(1)==Name) ) {
#line 138 "parser.g"
           s  = module_name();

        }
        else {
          if ( (LA(1)==17) ) {
          }
          else {FAIL(1,err5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
      }
#line 139 "parser.g"
      zzmatch(17);
#line 140 "parser.g"
      m = new lsys;
 consume();
#line 141 "parser.g"
      parse_lsys( *m );
#line 142 "parser.g"
      l.add_lsys (m);
#line 143 "parser.g"
      zzmatch(18); consume();
    }
    else {
      if ( (setwd1[LA(1)]&0x80)&&(
istok(LT(1), "define") ) ) {
        if (!(
#line 144 "parser.g"
istok(LT(1), "define") )          ) {zzfailed_pred("   istok(LT(1), \"define\") ",0 /* report */, { 0; /* no user action */ } );}
#line 144 "parser.g"
        zzsetmatch(WildCard_set, WildCard_errset); consume();
#line 145 "parser.g"
         s  = module_name();

#line 145 "parser.g"
        expr_any(  l.defines[s] );
#line 145 "parser.g"
        zzmatch(19); consume();
      }
      else {
        if ( (setwd2[LA(1)]&0x1)&&(
istok(LT(1), "ignore") ) ) {
          if (!(
#line 146 "parser.g"
istok(LT(1), "ignore") )            ) {zzfailed_pred("   istok(LT(1), \"ignore\") ",0 /* report */, { 0; /* no user action */ } );}
#line 146 "parser.g"
          zzsetmatch(WildCard_set, WildCard_errset); consume();
#line 147 "parser.g"
          {
            int zzcnt=1;
            do {
#line 147 "parser.g"
               s  = module_ref();

#line 147 "parser.g"
              l.ignore_module.insert (s);
            } while ( (setwd2[LA(1)]&0x2) );
          }
#line 147 "parser.g"
          zzmatch(19); consume();
        }
        else {
          if ( (setwd2[LA(1)]&0x4)&&(
!istok(LT(1), ")") ) ) {
            if (!(
#line 148 "parser.g"
!istok(LT(1), ")") )              ) {zzfailed_pred("   !istok(LT(1), \")\") ",0 /* report */, { 0; /* no user action */ } );}
#line 149 "parser.g"
            parse_rule(  l );
          }
          else {FAIL(1,err6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd2, 0x8);
}

void
Parser::parse_rule(lsys & l)
{
#line 152 "parser.g"
  zzRULE;
#line 153 "parser.g"
  rule r;
  r.constraint = module (1); r.iterations.is_expr = 1;
  r.iterations = module (0); r.iterations.is_expr = 1;
#line 157 "parser.g"
  parse_modvec( r.pre );
#line 158 "parser.g"
  {
    if ( (LA(1)==20) ) {
#line 158 "parser.g"
      zzmatch(20); consume();
#line 158 "parser.g"
      parse_module( *(module *)&r );
    }
    else {
      if ( (setwd2[LA(1)]&0x10) ) {
#line 159 "parser.g"
        
        if (r.pre.size () == 0)
        throw error ("symbol to be replaced must be a single module, not an empty sequence", LT(1)->getLine ());
        else if (r.pre.size () != 1)
        throw error ("symbol to be replaced must be a single module, not more", r.pre.first ());
        else
        {
          *(module *)&r = r.pre.first ();
          r.pre.erase ();
        }
      }
      else {FAIL(1,err7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 171 "parser.g"
  {
    if ( (LA(1)==21) ) {
#line 171 "parser.g"
      zzmatch(21); consume();
#line 171 "parser.g"
      parse_modvec( r.post );
    }
    else {
      if ( (setwd2[LA(1)]&0x20) ) {
      }
      else {FAIL(1,err8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 172 "parser.g"
  {
    if ( (LA(1)==22) ) {
#line 172 "parser.g"
      zzmatch(22); consume();
#line 172 "parser.g"
      expr_numeric( r.constraint );
    }
    else {
      if ( (LA(1)==23) ) {
      }
      else {FAIL(1,err9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 173 "parser.g"
  zzmatch(23); consume();
#line 173 "parser.g"
  {
    if ( (setwd2[LA(1)]&0x40) ) {
#line 173 "parser.g"
      parse_modvec( r.repl );
    }
    else {
      if ( (setwd2[LA(1)]&0x80) ) {
      }
      else {FAIL(1,err10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 174 "parser.g"
  {
    if ( (LA(1)==24) ) {
#line 174 "parser.g"
      zzmatch(24); consume();
#line 174 "parser.g"
      expr_numeric( r.iterations );
    }
    else {
      if ( (LA(1)==19) ) {
      }
      else {FAIL(1,err11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 175 "parser.g"
  zzmatch(19);
#line 176 "parser.g"
  l.add_rule(r);
 consume();
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd3, 0x1);
}

void
Parser::parse_modvec(module_vec & v)
{
#line 179 "parser.g"
  zzRULE;
#line 180 "parser.g"
  module m;
#line 181 "parser.g"
  {
    int zzcnt=1;
    do {
#line 181 "parser.g"
      parse_module( m );
#line 181 "parser.g"
      v.push_back (m);
    } while ( (setwd3[LA(1)]&0x2) );
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd3, 0x4);
}

void
Parser::parse_module(module & m)
{
#line 184 "parser.g"
  zzRULE;
#line 185 "parser.g"
  module v;
  m.erase ();
#line 188 "parser.g"
  module_head(  m );
#line 189 "parser.g"
  {
    if ( (LA(1)==17) ) {
#line 189 "parser.g"
      zzmatch(17); consume();
#line 190 "parser.g"
      expr_any( v );
#line 190 "parser.g"
      m.push_back (v); v.erase ();
#line 191 "parser.g"
      {
        while ( (LA(1)==24) ) {
#line 191 "parser.g"
          zzmatch(24); consume();
#line 191 "parser.g"
          expr_any( v );
#line 191 "parser.g"
          m.push_back (v); v.erase ();
        }
      }
#line 192 "parser.g"
      zzmatch(18); consume();
    }
    else {
      if ( (setwd3[LA(1)]&0x8) ) {
      }
      else {FAIL(1,err12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd3, 0x10);
}

void
Parser::module_head(module & m)
{
#line 196 "parser.g"
  zzRULE;
  ANTLRTokenPtr n=NULL;
  if ( (LA(1)==Number) ) {
#line 197 "parser.g"
    zzmatch(Number);
    n = (ANTLRTokenPtr)LT(1);

#line 197 "parser.g"
    m = module (atof ( n->getText ()));  m.where = here ();
 consume();
  }
  else {
    if ( (setwd3[LA(1)]&0x20) ) {
#line 198 "parser.g"
        m.str  = module_ref();

#line 198 "parser.g"
      m.is_num = 0;  m.where = here ();
    }
    else {FAIL(1,err13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd3, 0x40);
}

string
Parser::module_name(void)
{
  string   _retv;
#line 201 "parser.g"
  zzRULE;
  ANTLRTokenPtr a=NULL;
#line 202 "parser.g"
  zzmatch(Name);
  a = (ANTLRTokenPtr)LT(1);

#line 202 "parser.g"
  _retv =  a->getText();
 consume();
  return _retv;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd3, 0x80);
  return _retv;
}

string
Parser::module_ref(void)
{
  string   _retv;
#line 205 "parser.g"
  zzRULE;
  if ( (LA(1)==Name) ) {
#line 206 "parser.g"
     _retv  = module_name();

  }
  else {
    if ( (LA(1)==25) ) {
#line 207 "parser.g"
      zzmatch(25);
#line 207 "parser.g"
      _retv = "\\";
 consume();
    }
    else {
      if ( (LA(1)==26) ) {
#line 208 "parser.g"
        zzmatch(26);
#line 208 "parser.g"
        _retv = "+";
 consume();
      }
      else {
        if ( (LA(1)==27) ) {
#line 209 "parser.g"
          zzmatch(27);
#line 209 "parser.g"
          _retv = "-";
 consume();
        }
        else {
          if ( (LA(1)==28) ) {
#line 210 "parser.g"
            zzmatch(28);
#line 210 "parser.g"
            _retv = "*";
 consume();
          }
          else {
            if ( (LA(1)==29) ) {
#line 211 "parser.g"
              zzmatch(29);
#line 211 "parser.g"
              _retv = "/";
 consume();
            }
            else {
              if ( (LA(1)==30) ) {
#line 212 "parser.g"
                zzmatch(30);
#line 212 "parser.g"
                _retv = "^";
 consume();
              }
              else {
                if ( (LA(1)==31) ) {
#line 213 "parser.g"
                  zzmatch(31);
#line 213 "parser.g"
                  _retv = "{";
 consume();
                }
                else {
                  if ( (LA(1)==32) ) {
#line 214 "parser.g"
                    zzmatch(32);
#line 214 "parser.g"
                    _retv = "}";
 consume();
                  }
                  else {
                    if ( (LA(1)==33) ) {
#line 215 "parser.g"
                      zzmatch(33);
#line 215 "parser.g"
                      _retv = ".";
 consume();
                    }
                    else {
                      if ( (LA(1)==34) ) {
#line 216 "parser.g"
                        zzmatch(34);
#line 216 "parser.g"
                        _retv = "|";
 consume();
                      }
                      else {
                        if ( (LA(1)==35) ) {
#line 217 "parser.g"
                          zzmatch(35);
#line 217 "parser.g"
                          _retv = "~";
 consume();
                        }
                        else {
                          if ( (LA(1)==36) ) {
#line 218 "parser.g"
                            zzmatch(36);
#line 218 "parser.g"
                            _retv = "[";
 consume();
                          }
                          else {
                            if ( (LA(1)==37) ) {
#line 219 "parser.g"
                              zzmatch(37);
#line 219 "parser.g"
                              _retv = "]";
 consume();
                            }
                            else {
                              if ( (LA(1)==38) ) {
#line 220 "parser.g"
                                zzmatch(38);
#line 220 "parser.g"
                                _retv = "!";
 consume();
                              }
                              else {
                                if ( (LA(1)==39) ) {
#line 221 "parser.g"
                                  zzmatch(39);
#line 221 "parser.g"
                                  _retv = "&";
 consume();
                                }
                                else {
                                  if ( (LA(1)==40) ) {
#line 222 "parser.g"
                                    zzmatch(40);
#line 222 "parser.g"
                                    _retv = "%";
 consume();
                                  }
                                  else {FAIL(1,err14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  return _retv;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd4, 0x1);
  return _retv;
}

void
Parser::expr_any(module & v)
{
#line 225 "parser.g"
  zzRULE;
  if ( (setwd4[LA(1)]&0x2) ) {
#line 226 "parser.g"
    expr_numeric(  v );
  }
  else {
    if ( (setwd4[LA(1)]&0x4) ) {
#line 227 "parser.g"
      expr_modvec(  v );
    }
    else {FAIL(1,err15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd4, 0x8);
}

void
Parser::expr_modvec(module & v)
{
#line 230 "parser.g"
  zzRULE;
  if ( (LA(1)==9) ) {
#line 231 "parser.g"
    zzmatch(9); consume();
#line 231 "parser.g"
    parse_modvec(  v );
#line 231 "parser.g"
    v.str.erase ();  v.is_expr = 0;
#line 231 "parser.g"
    zzmatch(9); consume();
  }
  else {
    if ( (LA(1)==41) ) {
#line 232 "parser.g"
      zzmatch(41); consume();
#line 232 "parser.g"
      parse_modvec(  v );
#line 232 "parser.g"
      v.str.erase ();  v.is_expr = 0;
    }
    else {FAIL(1,err16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd4, 0x10);
}

void
Parser::expr_numeric(module & v)
{
#line 235 "parser.g"
  zzRULE;
#line 236 "parser.g"
  expr_0(  v );
#line 236 "parser.g"
  v.is_expr = 1;
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd4, 0x20);
}

void
Parser::expr_0(module & v)
{
#line 239 "parser.g"
  zzRULE;
#line 240 "parser.g"
  module r;
  if ( (setwd4[LA(1)]&0x40) ) {
#line 241 "parser.g"
    expr_1(  v );
#line 243 "parser.g"
    {
      for (;;) {
        if ( !((setwd4[LA(1)]&0x80))) break;
        if ( (LA(1)==42) ) {
#line 241 "parser.g"
          zzmatch(42); consume();
#line 241 "parser.g"
          expr_2( r );
#line 241 "parser.g"
          v = module ("&&",  v, r);
        }
        else {
          if ( (LA(1)==43) ) {
#line 242 "parser.g"
            zzmatch(43); consume();
#line 242 "parser.g"
            expr_2( r );
#line 242 "parser.g"
            v = module ("||",  v, r);
          }
          else break; /* MR6 code for exiting loop "for sure" */
        }
      }
    }
  }
  else {
    if ( (LA(1)==38) ) {
#line 244 "parser.g"
      zzmatch(38); consume();
#line 244 "parser.g"
      expr_1( r );
#line 244 "parser.g"
      v = module ("!",  r);
    }
    else {FAIL(1,err17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd5, 0x1);
}

void
Parser::expr_1(module & v)
{
#line 247 "parser.g"
  zzRULE;
#line 248 "parser.g"
  module r;
#line 249 "parser.g"
  expr_2(  v );
#line 249 "parser.g"
  {
    if ( (LA(1)==21) ) {
#line 249 "parser.g"
      zzmatch(21); consume();
#line 249 "parser.g"
      expr_2( r );
#line 249 "parser.g"
      v = module (">" ,  v, r);
    }
    else {
      if ( (LA(1)==44) ) {
#line 250 "parser.g"
        zzmatch(44); consume();
#line 250 "parser.g"
        expr_2( r );
#line 250 "parser.g"
        v = module (">=",  v, r);
      }
      else {
        if ( (LA(1)==45) ) {
#line 251 "parser.g"
          zzmatch(45); consume();
#line 251 "parser.g"
          expr_2( r );
#line 251 "parser.g"
          v = module ("==",  v, r);
        }
        else {
          if ( (LA(1)==46) ) {
#line 252 "parser.g"
            zzmatch(46); consume();
#line 252 "parser.g"
            expr_2( r );
#line 252 "parser.g"
            v = module ("==",  v, r);
          }
          else {
            if ( (LA(1)==47) ) {
#line 253 "parser.g"
              zzmatch(47); consume();
#line 253 "parser.g"
              expr_2( r );
#line 253 "parser.g"
              v = module ("!=",  v, r);
            }
            else {
              if ( (LA(1)==20) ) {
#line 254 "parser.g"
                zzmatch(20); consume();
#line 254 "parser.g"
                expr_2( r );
#line 254 "parser.g"
                v = module ("<" ,  v, r);
              }
              else {
                if ( (LA(1)==48) ) {
#line 255 "parser.g"
                  zzmatch(48); consume();
#line 255 "parser.g"
                  expr_2( r );
#line 255 "parser.g"
                  v = module ("<=",  v, r);
                }
                else {
                  if ( (setwd5[LA(1)]&0x2) ) {
                  }
                  else {FAIL(1,err18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
                }
              }
            }
          }
        }
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd5, 0x4);
}

void
Parser::expr_2(module & v)
{
#line 259 "parser.g"
  zzRULE;
#line 260 "parser.g"
  module r;
#line 261 "parser.g"
  v = module (0);
#line 262 "parser.g"
  {
    if ( (setwd5[LA(1)]&0x8) ) {
#line 262 "parser.g"
      expr_3(  v );
    }
    else {
      if ( (setwd5[LA(1)]&0x10) ) {
      }
      else {FAIL(1,err19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
#line 264 "parser.g"
  {
    for (;;) {
      if ( !((setwd5[LA(1)]&0x20))) break;
      if ( (LA(1)==26) ) {
#line 262 "parser.g"
        zzmatch(26); consume();
#line 262 "parser.g"
        expr_3( r );
#line 262 "parser.g"
        v = module ("+",  v, r);
      }
      else {
        if ( (LA(1)==27) ) {
#line 263 "parser.g"
          zzmatch(27); consume();
#line 263 "parser.g"
          expr_3( r );
#line 263 "parser.g"
          v = module ("-",  v, r);
        }
        else break; /* MR6 code for exiting loop "for sure" */
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd5, 0x40);
}

void
Parser::expr_3(module & v)
{
#line 267 "parser.g"
  zzRULE;
#line 268 "parser.g"
  module r;
#line 269 "parser.g"
  expr_4(  v );
#line 272 "parser.g"
  {
    for (;;) {
      if ( !((setwd5[LA(1)]&0x80))) break;
      if ( (LA(1)==28) ) {
#line 269 "parser.g"
        zzmatch(28); consume();
#line 269 "parser.g"
        expr_4( r );
#line 269 "parser.g"
        v = module ("*",  v, r);
      }
      else {
        if ( (LA(1)==29) ) {
#line 270 "parser.g"
          zzmatch(29); consume();
#line 270 "parser.g"
          expr_4( r );
#line 270 "parser.g"
          v = module ("/",  v, r);
        }
        else {
          if ( (LA(1)==40) ) {
#line 271 "parser.g"
            zzmatch(40); consume();
#line 271 "parser.g"
            expr_4( r );
#line 271 "parser.g"
            v = module ("%",  v ,r);
          }
          else break; /* MR6 code for exiting loop "for sure" */
        }
      }
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd6, 0x1);
}

void
Parser::expr_4(module & v)
{
#line 275 "parser.g"
  zzRULE;
#line 276 "parser.g"
  module r;
#line 277 "parser.g"
  expr_5(  v );
#line 278 "parser.g"
  {
    while ( (LA(1)==30) ) {
#line 277 "parser.g"
      zzmatch(30); consume();
#line 277 "parser.g"
      expr_5( r );
#line 277 "parser.g"
      v = module ("^",  v, r);
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd6, 0x2);
}

void
Parser::expr_5(module & v)
{
#line 281 "parser.g"
  zzRULE;
  if ( (LA(1)==17) ) {
#line 282 "parser.g"
    zzmatch(17); consume();
#line 282 "parser.g"
    expr_0(  v );
#line 282 "parser.g"
    v.where = here ();
#line 282 "parser.g"
    zzmatch(18); consume();
  }
  else {
    if ( (setwd6[LA(1)]&0x4) ) {
#line 283 "parser.g"
      expr_atom(  v );
    }
    else {FAIL(1,err20,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd6, 0x8);
}

void
Parser::expr_atom(module & v)
{
#line 286 "parser.g"
  zzRULE;
  ANTLRTokenPtr num=NULL;
  if ( (LA(1)==Number) ) {
#line 287 "parser.g"
    zzmatch(Number);
    num = (ANTLRTokenPtr)LT(1);

#line 287 "parser.g"
    v = module (atof ( num->getText ()));  v.where = here ();
 consume();
  }
  else {
    if ( (LA(1)==Name) ) {
#line 288 "parser.g"
      expr_module(  v );
    }
    else {FAIL(1,err21,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd6, 0x10);
}

void
Parser::expr_module(module & m)
{
#line 291 "parser.g"
  zzRULE;
#line 292 "parser.g"
  module v;
  m.erase ();
  m.where = here ();
#line 296 "parser.g"
    m.str  = module_name();

#line 297 "parser.g"
  {
    if ( (LA(1)==17) ) {
#line 297 "parser.g"
      zzmatch(17); consume();
#line 298 "parser.g"
      expr_any( v );
#line 298 "parser.g"
      m.push_back (v); v.erase ();
#line 299 "parser.g"
      {
        while ( (LA(1)==24) ) {
#line 299 "parser.g"
          zzmatch(24); consume();
#line 299 "parser.g"
          expr_any( v );
#line 299 "parser.g"
          m.push_back (v); v.erase ();
        }
      }
#line 300 "parser.g"
      zzmatch(18); consume();
    }
    else {
      if ( (setwd6[LA(1)]&0x20) ) {
      }
      else {FAIL(1,err22,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
  return;
fail:
  syn(zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk);
  resynch(setwd6, 0x40);
}
#line 306 "parser.g"

void Parser::syn (_ANTLRTokenPtr tok, ANTLRChar * egroup, SetWordType * eset,
ANTLRTokenType etok, int k)
{
  ostringstream msg;
  
  syntaxErrCount++;
  
  msg << current_file << ":" << LT (1)->getLine () << ": syntax error at \"" << LT (1)->getText ();
  
  if (etok || eset)
  {
    if (k == 1)
    msg << " missing";
    else
    {
      msg << "; \"" << LT (1)->getText () << "\" not";
      if (set_deg (eset) > 1)
      msg << " in";
    }
    
      if (set_deg (eset) > 0)
    {
      SetWordType *p = eset;
      SetWordType *endp = &(p[bsetsize]);
      unsigned e = 0;
      
          if (set_deg (eset) > 1)
      msg << " {";
      do
      {
        register SetWordType t = *p;
        register SetWordType *b = &(bitmask[0]);
        do
        {
          if (t & *b)
          msg << " " << token_tbl[e];
          e++;
        }
        while (++b < &(bitmask[sizeof (SetWordType) * 8]));
      }
      while (++p < endp);
      if (set_deg (eset) > 1)
      msg << " }";
    }
    else
    msg << " " << token_tbl[etok];
    
      if (strlen (egroup) > 0)
    msg << " in " << egroup;
    
      msg << endl;
    throw error (msg.str ());
  }
}