debian/patches/05_antlr32.patch

   1 Index: BstParser.java
   2 ===================================================================
   3 --- a/src/java/net/sf/jabref/bst/BstParser.java (revision 2214)
   4 +++ b/src/java/net/sf/jabref/bst/BstParser.java (working copy)
   5 @@ -1,52 +1,62 @@
   6  package net.sf.jabref.bst;
   7
   8 -// $ANTLR 3.0b5 Bst.g 2006-11-23 23:20:24
   9 +// $ANTLR 3.2 debian-4 Bst.g 2010-08-02 19:59:10
  10
  11 +import org.antlr.runtime.*;
  12 +import java.util.Stack;
  13 +import java.util.List;
  14  import java.util.ArrayList;
  15 -import java.util.List;
  16
  17 -import org.antlr.runtime.BitSet;
  18 -import org.antlr.runtime.EarlyExitException;
  19 -import org.antlr.runtime.NoViableAltException;
  20 -import org.antlr.runtime.Parser;
  21 -import org.antlr.runtime.ParserRuleReturnScope;
  22 -import org.antlr.runtime.RecognitionException;
  23 -import org.antlr.runtime.Token;
  24 -import org.antlr.runtime.TokenStream;
  25 -import org.antlr.runtime.tree.CommonTreeAdaptor;
  26 -import org.antlr.runtime.tree.TreeAdaptor;
  27
  28 -@SuppressWarnings({"unused", "unchecked"})
  29 +import org.antlr.runtime.tree.*;
  30 +
  31  public class BstParser extends Parser {
  32      public static final String[] tokenNames = new String[] {
  33          "<invalid>", "<EOR>", "<DOWN>", "<UP>", "IDLIST", "STACK", "ENTRY", "COMMANDS", "STRINGS", "INTEGERS", "FUNCTION", "MACRO", "STRING", "READ", "EXECUTE", "ITERATE", "REVERSE", "SORT", "IDENTIFIER", "INTEGER", "QUOTED", "LETTER", "NUMERAL", "WS", "LINE_COMMENT", "'{'", "'}'", "'<'", "'>'", "'='", "'+'", "'-'", "':='", "'*'"
  34      };
  35 +    public static final int INTEGER=19;
  36 +    public static final int FUNCTION=10;
  37 +    public static final int T__29=29;
  38 +    public static final int T__28=28;
  39 +    public static final int T__27=27;
  40 +    public static final int T__26=26;
  41 +    public static final int LINE_COMMENT=24;
  42 +    public static final int QUOTED=20;
  43 +    public static final int T__25=25;
  44      public static final int LETTER=21;
  45 +    public static final int EXECUTE=14;
  46 +    public static final int STRINGS=8;
  47 +    public static final int SORT=17;
  48      public static final int ENTRY=6;
  49 +    public static final int EOF=-1;
  50      public static final int INTEGERS=9;
  51 +    public static final int T__30=30;
  52 +    public static final int ITERATE=15;
  53 +    public static final int T__31=31;
  54 +    public static final int T__32=32;
  55      public static final int WS=23;
  56 +    public static final int T__33=33;
  57      public static final int COMMANDS=7;
  58 -    public static final int STRING=12;
  59 -    public static final int EXECUTE=14;
  60 -    public static final int LINE_COMMENT=24;
  61 -    public static final int SORT=17;
  62 +    public static final int READ=13;
  63 +    public static final int IDENTIFIER=18;
  64 +    public static final int IDLIST=4;
  65 +    public static final int NUMERAL=22;
  66      public static final int STACK=5;
  67      public static final int REVERSE=16;
  68 -    public static final int QUOTED=20;
  69 -    public static final int INTEGER=19;
  70 -    public static final int ITERATE=15;
  71 -    public static final int FUNCTION=10;
  72 -    public static final int EOF=-1;
  73 -    public static final int STRINGS=8;
  74 -    public static final int IDENTIFIER=18;
  75      public static final int MACRO=11;
  76 -    public static final int IDLIST=4;
  77 -    public static final int NUMERAL=22;
  78 -    public static final int READ=13;
  79 +    public static final int STRING=12;
  80
  81 +    // delegates
  82 +    // delegators
  83 +
  84 +
  85          public BstParser(TokenStream input) {
  86 -            super(input);
  87 +            this(input, new RecognizerSharedState());
  88          }
  89 +        public BstParser(TokenStream input, RecognizerSharedState state) {
  90 +            super(input, state);
  91 +
  92 +        }
  93
  94      protected TreeAdaptor adaptor = new CommonTreeAdaptor();
  95
  96 @@ -57,29 +67,29 @@
  97          return adaptor;
  98      }
  99
 100 -    public String[] getTokenNames() { return tokenNames; }
 101 +    public String[] getTokenNames() { return BstParser.tokenNames; }
 102      public String getGrammarFileName() { return "Bst.g"; }
 103
 104
 105      public static class program_return extends ParserRuleReturnScope {
 106          Object tree;
 107          public Object getTree() { return tree; }
 108 -    }
 109 +    };
 110
 111 -    // $ANTLR start program
 112 +    // $ANTLR start "program"
 113      // Bst.g:14:1: program : ( commands )+ -> ^( COMMANDS ( commands )+ ) ;
 114 -    public program_return program() throws RecognitionException {
 115 -        program_return retval = new program_return();
 116 +    public final BstParser.program_return program() throws RecognitionException {
 117 +        BstParser.program_return retval = new BstParser.program_return();
 118          retval.start = input.LT(1);
 119
 120          Object root_0 = null;
 121
 122 -        commands_return commands1 = null;
 123 +        BstParser.commands_return commands1 = null;
 124
 125 -        List list_commands=new ArrayList();
 126
 127 +        RewriteRuleSubtreeStream stream_commands=new RewriteRuleSubtreeStream(adaptor,"rule commands");
 128          try {
 129 -            // Bst.g:14:11: ( ( commands )+ -> ^( COMMANDS ( commands )+ ) )
 130 +            // Bst.g:14:9: ( ( commands )+ -> ^( COMMANDS ( commands )+ ) )
 131              // Bst.g:14:11: ( commands )+
 132              {
 133              // Bst.g:14:11: ( commands )+
 134 @@ -88,6 +98,7 @@
 135              do {
 136                  int alt1=2;
 137                  int LA1_0 = input.LA(1);
 138 +
 139                  if ( (LA1_0==ENTRY||(LA1_0>=STRINGS && LA1_0<=MACRO)||(LA1_0>=READ && LA1_0<=SORT)) ) {
 140                      alt1=1;
 141                  }
 142 @@ -99,10 +110,11 @@
 143                     {
 144                     pushFollow(FOLLOW_commands_in_program45);
 145                     commands1=commands();
 146 -                   _fsp--;
 147
 148 -                   list_commands.add(commands1.tree);
 149 +                   state._fsp--;
 150
 151 +                   stream_commands.add(commands1.getTree());
 152 +
 153                     }
 154                     break;
 155
 156 @@ -116,65 +128,69 @@
 157              } while (true);
 158
 159
 160 +
 161              // AST REWRITE
 162 -
 163 -                       int i_0 = 0;
 164 +            // elements: commands
 165 +            // token labels:
 166 +            // rule labels: retval
 167 +            // token list labels:
 168 +            // rule list labels:
 169 +            // wildcard labels:
 170              retval.tree = root_0;
 171 -            root_0 = adaptor.nil();
 172 +            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 173 +
 174 +            root_0 = (Object)adaptor.nil();
 175              // 14:21: -> ^( COMMANDS ( commands )+ )
 176              {
 177                  // Bst.g:14:24: ^( COMMANDS ( commands )+ )
 178                  {
 179 -                Object root_1 = adaptor.nil();
 180 -                root_1 = adaptor.becomeRoot(adaptor.create(COMMANDS, "COMMANDS"), root_1);
 181 +                Object root_1 = (Object)adaptor.nil();
 182 +                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMMANDS, "COMMANDS"), root_1);
 183
 184 -                // Bst.g:14:35: ( commands )+
 185 -                {
 186 -                int n_1 = list_commands == null ? 0 : list_commands.size();
 187 -
 188 +                if ( !(stream_commands.hasNext()) ) {
 189 +                    throw new RewriteEarlyExitException();
 190 +                }
 191 +                while ( stream_commands.hasNext() ) {
 192 +                    adaptor.addChild(root_1, stream_commands.nextTree());
 193
 194 -
 195 -                if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops");
 196 -                for (int i_1=0; i_1<n_1; i_1++) {
 197 -                    adaptor.addChild(root_1, list_commands.get(i_1));
 198 -
 199                  }
 200 -                }
 201 +                stream_commands.reset();
 202
 203                  adaptor.addChild(root_0, root_1);
 204                  }
 205
 206              }
 207
 208 +            retval.tree = root_0;
 209 +            }
 210
 211 +            retval.stop = input.LT(-1);
 212
 213 -            }
 214 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 215 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 216
 217          }
 218          catch (RecognitionException re) {
 219              reportError(re);
 220              recover(input,re);
 221 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 222 +
 223          }
 224          finally {
 225 -            retval.stop = input.LT(-1);
 226 -
 227 -                retval.tree = adaptor.rulePostProcessing(root_0);
 228 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 229 -
 230 -       }
 231 +        }
 232          return retval;
 233      }
 234 -    // $ANTLR end program
 235 +    // $ANTLR end "program"
 236
 237      public static class commands_return extends ParserRuleReturnScope {
 238          Object tree;
 239          public Object getTree() { return tree; }
 240 -    }
 241 +    };
 242
 243 -    // $ANTLR start commands
 244 -    // Bst.g:16:1: commands : ( STRINGS^^ idList | INTEGERS^^ idList | FUNCTION^^ id stack | MACRO^^ id '{'! STRING '}'! | READ^^ | EXECUTE^^ '{'! function '}'! | ITERATE^^ '{'! function '}'! | REVERSE^^ '{'! function '}'! | ENTRY^^ idList0 idList0 idList0 | SORT^^ );
 245 -    public commands_return commands() throws RecognitionException {
 246 -        commands_return retval = new commands_return();
 247 +    // $ANTLR start "commands"
 248 +    // Bst.g:16:1: commands : ( STRINGS idList | INTEGERS idList | FUNCTION id stack | MACRO id '{' STRING '}' | READ | EXECUTE '{' function '}' | ITERATE '{' function '}' | REVERSE '{' function '}' | ENTRY idList0 idList0 idList0 | SORT );
 249 +    public final BstParser.commands_return commands() throws RecognitionException {
 250 +        BstParser.commands_return retval = new BstParser.commands_return();
 251          retval.start = input.LT(1);
 252
 253          Object root_0 = null;
 254 @@ -198,27 +214,27 @@
 255          Token char_literal26=null;
 256          Token ENTRY27=null;
 257          Token SORT31=null;
 258 -        idList_return idList3 = null;
 259 +        BstParser.idList_return idList3 = null;
 260
 261 -        idList_return idList5 = null;
 262 +        BstParser.idList_return idList5 = null;
 263
 264 -        id_return id7 = null;
 265 +        BstParser.id_return id7 = null;
 266
 267 -        stack_return stack8 = null;
 268 +        BstParser.stack_return stack8 = null;
 269
 270 -        id_return id10 = null;
 271 +        BstParser.id_return id10 = null;
 272
 273 -        function_return function17 = null;
 274 +        BstParser.function_return function17 = null;
 275
 276 -        function_return function21 = null;
 277 +        BstParser.function_return function21 = null;
 278
 279 -        function_return function25 = null;
 280 +        BstParser.function_return function25 = null;
 281
 282 -        idList0_return idList028 = null;
 283 +        BstParser.idList0_return idList028 = null;
 284
 285 -        idList0_return idList029 = null;
 286 +        BstParser.idList0_return idList029 = null;
 287
 288 -        idList0_return idList030 = null;
 289 +        BstParser.idList0_return idList030 = null;
 290
 291
 292          Object STRINGS2_tree=null;
 293 @@ -242,280 +258,294 @@
 294          Object SORT31_tree=null;
 295
 296          try {
 297 -            // Bst.g:17:4: ( STRINGS^^ idList | INTEGERS^^ idList | FUNCTION^^ id stack | MACRO^^ id '{'! STRING '}'! | READ^^ | EXECUTE^^ '{'! function '}'! | ITERATE^^ '{'! function '}'! | REVERSE^^ '{'! function '}'! | ENTRY^^ idList0 idList0 idList0 | SORT^^ )
 298 +            // Bst.g:17:2: ( STRINGS idList | INTEGERS idList | FUNCTION id stack | MACRO id '{' STRING '}' | READ | EXECUTE '{' function '}' | ITERATE '{' function '}' | REVERSE '{' function '}' | ENTRY idList0 idList0 idList0 | SORT )
 299              int alt2=10;
 300              switch ( input.LA(1) ) {
 301              case STRINGS:
 302 +                {
 303                  alt2=1;
 304 +                }
 305                  break;
 306              case INTEGERS:
 307 +                {
 308                  alt2=2;
 309 +                }
 310                  break;
 311              case FUNCTION:
 312 +                {
 313                  alt2=3;
 314 +                }
 315                  break;
 316              case MACRO:
 317 +                {
 318                  alt2=4;
 319 +                }
 320                  break;
 321              case READ:
 322 +                {
 323                  alt2=5;
 324 +                }
 325                  break;
 326              case EXECUTE:
 327 +                {
 328                  alt2=6;
 329 +                }
 330                  break;
 331              case ITERATE:
 332 +                {
 333                  alt2=7;
 334 +                }
 335                  break;
 336              case REVERSE:
 337 +                {
 338                  alt2=8;
 339 +                }
 340                  break;
 341              case ENTRY:
 342 +                {
 343                  alt2=9;
 344 +                }
 345                  break;
 346              case SORT:
 347 +                {
 348                  alt2=10;
 349 +                }
 350                  break;
 351              default:
 352                  NoViableAltException nvae =
 353 -                    new NoViableAltException("16:1: commands : ( STRINGS^^ idList | INTEGERS^^ idList | FUNCTION^^ id stack | MACRO^^ id '{'! STRING '}'! | READ^^ | EXECUTE^^ '{'! function '}'! | ITERATE^^ '{'! function '}'! | REVERSE^^ '{'! function '}'! | ENTRY^^ idList0 idList0 idList0 | SORT^^ );", 2, 0, input);
 354 +                    new NoViableAltException("", 2, 0, input);
 355
 356                  throw nvae;
 357              }
 358
 359              switch (alt2) {
 360                  case 1 :
 361 -                    // Bst.g:17:4: STRINGS^^ idList
 362 +                    // Bst.g:17:4: STRINGS idList
 363                      {
 364 -                    root_0 = adaptor.nil();
 365 +                    root_0 = (Object)adaptor.nil();
 366
 367 -                    STRINGS2=input.LT(1);
 368 -                    match(input,STRINGS,FOLLOW_STRINGS_in_commands65);
 369 -                    STRINGS2_tree = adaptor.create(STRINGS2);
 370 -                    root_0 = adaptor.becomeRoot(STRINGS2_tree, root_0);
 371 +                    STRINGS2=(Token)match(input,STRINGS,FOLLOW_STRINGS_in_commands65);
 372 +                    STRINGS2_tree = (Object)adaptor.create(STRINGS2);
 373 +                    root_0 = (Object)adaptor.becomeRoot(STRINGS2_tree, root_0);
 374
 375                      pushFollow(FOLLOW_idList_in_commands68);
 376                      idList3=idList();
 377 -                    _fsp--;
 378
 379 -                    adaptor.addChild(root_0, idList3.tree);
 380 +                    state._fsp--;
 381
 382 +                    adaptor.addChild(root_0, idList3.getTree());
 383 +
 384                      }
 385                      break;
 386                  case 2 :
 387 -                    // Bst.g:18:4: INTEGERS^^ idList
 388 +                    // Bst.g:18:4: INTEGERS idList
 389                      {
 390 -                    root_0 = adaptor.nil();
 391 +                    root_0 = (Object)adaptor.nil();
 392
 393 -                    INTEGERS4=input.LT(1);
 394 -                    match(input,INTEGERS,FOLLOW_INTEGERS_in_commands73);
 395 -                    INTEGERS4_tree = adaptor.create(INTEGERS4);
 396 -                    root_0 = adaptor.becomeRoot(INTEGERS4_tree, root_0);
 397 +                    INTEGERS4=(Token)match(input,INTEGERS,FOLLOW_INTEGERS_in_commands73);
 398 +                    INTEGERS4_tree = (Object)adaptor.create(INTEGERS4);
 399 +                    root_0 = (Object)adaptor.becomeRoot(INTEGERS4_tree, root_0);
 400
 401                      pushFollow(FOLLOW_idList_in_commands76);
 402                      idList5=idList();
 403 -                    _fsp--;
 404
 405 -                    adaptor.addChild(root_0, idList5.tree);
 406 +                    state._fsp--;
 407
 408 +                    adaptor.addChild(root_0, idList5.getTree());
 409 +
 410                      }
 411                      break;
 412                  case 3 :
 413 -                    // Bst.g:19:4: FUNCTION^^ id stack
 414 +                    // Bst.g:19:4: FUNCTION id stack
 415                      {
 416 -                    root_0 = adaptor.nil();
 417 +                    root_0 = (Object)adaptor.nil();
 418
 419 -                    FUNCTION6=input.LT(1);
 420 -                    match(input,FUNCTION,FOLLOW_FUNCTION_in_commands81);
 421 -                    FUNCTION6_tree = adaptor.create(FUNCTION6);
 422 -                    root_0 = adaptor.becomeRoot(FUNCTION6_tree, root_0);
 423 +                    FUNCTION6=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_commands81);
 424 +                    FUNCTION6_tree = (Object)adaptor.create(FUNCTION6);
 425 +                    root_0 = (Object)adaptor.becomeRoot(FUNCTION6_tree, root_0);
 426
 427                      pushFollow(FOLLOW_id_in_commands84);
 428                      id7=id();
 429 -                    _fsp--;
 430
 431 -                    adaptor.addChild(root_0, id7.tree);
 432 +                    state._fsp--;
 433 +
 434 +                    adaptor.addChild(root_0, id7.getTree());
 435                      pushFollow(FOLLOW_stack_in_commands86);
 436                      stack8=stack();
 437 -                    _fsp--;
 438
 439 -                    adaptor.addChild(root_0, stack8.tree);
 440 +                    state._fsp--;
 441
 442 +                    adaptor.addChild(root_0, stack8.getTree());
 443 +
 444                      }
 445                      break;
 446                  case 4 :
 447 -                    // Bst.g:20:4: MACRO^^ id '{'! STRING '}'!
 448 +                    // Bst.g:20:4: MACRO id '{' STRING '}'
 449                      {
 450 -                    root_0 = adaptor.nil();
 451 +                    root_0 = (Object)adaptor.nil();
 452
 453 -                    MACRO9=input.LT(1);
 454 -                    match(input,MACRO,FOLLOW_MACRO_in_commands91);
 455 -                    MACRO9_tree = adaptor.create(MACRO9);
 456 -                    root_0 = adaptor.becomeRoot(MACRO9_tree, root_0);
 457 +                    MACRO9=(Token)match(input,MACRO,FOLLOW_MACRO_in_commands91);
 458 +                    MACRO9_tree = (Object)adaptor.create(MACRO9);
 459 +                    root_0 = (Object)adaptor.becomeRoot(MACRO9_tree, root_0);
 460
 461                      pushFollow(FOLLOW_id_in_commands94);
 462                      id10=id();
 463 -                    _fsp--;
 464
 465 -                    adaptor.addChild(root_0, id10.tree);
 466 -                    char_literal11=input.LT(1);
 467 -                    match(input,25,FOLLOW_25_in_commands96);
 468 -                    STRING12=input.LT(1);
 469 -                    match(input,STRING,FOLLOW_STRING_in_commands99);
 470 -                    STRING12_tree = adaptor.create(STRING12);
 471 +                    state._fsp--;
 472 +
 473 +                    adaptor.addChild(root_0, id10.getTree());
 474 +                    char_literal11=(Token)match(input,25,FOLLOW_25_in_commands96);
 475 +                    STRING12=(Token)match(input,STRING,FOLLOW_STRING_in_commands99);
 476 +                    STRING12_tree = (Object)adaptor.create(STRING12);
 477                      adaptor.addChild(root_0, STRING12_tree);
 478
 479 -                    char_literal13=input.LT(1);
 480 -                    match(input,26,FOLLOW_26_in_commands101);
 481 +                    char_literal13=(Token)match(input,26,FOLLOW_26_in_commands101);
 482
 483                      }
 484                      break;
 485                  case 5 :
 486 -                    // Bst.g:21:4: READ^^
 487 +                    // Bst.g:21:4: READ
 488                      {
 489 -                    root_0 = adaptor.nil();
 490 +                    root_0 = (Object)adaptor.nil();
 491
 492 -                    READ14=input.LT(1);
 493 -                    match(input,READ,FOLLOW_READ_in_commands107);
 494 -                    READ14_tree = adaptor.create(READ14);
 495 -                    root_0 = adaptor.becomeRoot(READ14_tree, root_0);
 496 +                    READ14=(Token)match(input,READ,FOLLOW_READ_in_commands107);
 497 +                    READ14_tree = (Object)adaptor.create(READ14);
 498 +                    root_0 = (Object)adaptor.becomeRoot(READ14_tree, root_0);
 499
 500
 501                      }
 502                      break;
 503                  case 6 :
 504 -                    // Bst.g:22:4: EXECUTE^^ '{'! function '}'!
 505 +                    // Bst.g:22:4: EXECUTE '{' function '}'
 506                      {
 507 -                    root_0 = adaptor.nil();
 508 +                    root_0 = (Object)adaptor.nil();
 509
 510 -                    EXECUTE15=input.LT(1);
 511 -                    match(input,EXECUTE,FOLLOW_EXECUTE_in_commands113);
 512 -                    EXECUTE15_tree = adaptor.create(EXECUTE15);
 513 -                    root_0 = adaptor.becomeRoot(EXECUTE15_tree, root_0);
 514 +                    EXECUTE15=(Token)match(input,EXECUTE,FOLLOW_EXECUTE_in_commands113);
 515 +                    EXECUTE15_tree = (Object)adaptor.create(EXECUTE15);
 516 +                    root_0 = (Object)adaptor.becomeRoot(EXECUTE15_tree, root_0);
 517
 518 -                    char_literal16=input.LT(1);
 519 -                    match(input,25,FOLLOW_25_in_commands116);
 520 +                    char_literal16=(Token)match(input,25,FOLLOW_25_in_commands116);
 521                      pushFollow(FOLLOW_function_in_commands119);
 522                      function17=function();
 523 -                    _fsp--;
 524
 525 -                    adaptor.addChild(root_0, function17.tree);
 526 -                    char_literal18=input.LT(1);
 527 -                    match(input,26,FOLLOW_26_in_commands121);
 528 +                    state._fsp--;
 529
 530 +                    adaptor.addChild(root_0, function17.getTree());
 531 +                    char_literal18=(Token)match(input,26,FOLLOW_26_in_commands121);
 532 +
 533                      }
 534                      break;
 535                  case 7 :
 536 -                    // Bst.g:23:4: ITERATE^^ '{'! function '}'!
 537 +                    // Bst.g:23:4: ITERATE '{' function '}'
 538                      {
 539 -                    root_0 = adaptor.nil();
 540 +                    root_0 = (Object)adaptor.nil();
 541
 542 -                    ITERATE19=input.LT(1);
 543 -                    match(input,ITERATE,FOLLOW_ITERATE_in_commands127);
 544 -                    ITERATE19_tree = adaptor.create(ITERATE19);
 545 -                    root_0 = adaptor.becomeRoot(ITERATE19_tree, root_0);
 546 +                    ITERATE19=(Token)match(input,ITERATE,FOLLOW_ITERATE_in_commands127);
 547 +                    ITERATE19_tree = (Object)adaptor.create(ITERATE19);
 548 +                    root_0 = (Object)adaptor.becomeRoot(ITERATE19_tree, root_0);
 549
 550 -                    char_literal20=input.LT(1);
 551 -                    match(input,25,FOLLOW_25_in_commands130);
 552 +                    char_literal20=(Token)match(input,25,FOLLOW_25_in_commands130);
 553                      pushFollow(FOLLOW_function_in_commands133);
 554                      function21=function();
 555 -                    _fsp--;
 556
 557 -                    adaptor.addChild(root_0, function21.tree);
 558 -                    char_literal22=input.LT(1);
 559 -                    match(input,26,FOLLOW_26_in_commands135);
 560 +                    state._fsp--;
 561
 562 +                    adaptor.addChild(root_0, function21.getTree());
 563 +                    char_literal22=(Token)match(input,26,FOLLOW_26_in_commands135);
 564 +
 565                      }
 566                      break;
 567                  case 8 :
 568 -                    // Bst.g:24:4: REVERSE^^ '{'! function '}'!
 569 +                    // Bst.g:24:4: REVERSE '{' function '}'
 570                      {
 571 -                    root_0 = adaptor.nil();
 572 +                    root_0 = (Object)adaptor.nil();
 573
 574 -                    REVERSE23=input.LT(1);
 575 -                    match(input,REVERSE,FOLLOW_REVERSE_in_commands141);
 576 -                    REVERSE23_tree = adaptor.create(REVERSE23);
 577 -                    root_0 = adaptor.becomeRoot(REVERSE23_tree, root_0);
 578 +                    REVERSE23=(Token)match(input,REVERSE,FOLLOW_REVERSE_in_commands141);
 579 +                    REVERSE23_tree = (Object)adaptor.create(REVERSE23);
 580 +                    root_0 = (Object)adaptor.becomeRoot(REVERSE23_tree, root_0);
 581
 582 -                    char_literal24=input.LT(1);
 583 -                    match(input,25,FOLLOW_25_in_commands144);
 584 +                    char_literal24=(Token)match(input,25,FOLLOW_25_in_commands144);
 585                      pushFollow(FOLLOW_function_in_commands147);
 586                      function25=function();
 587 -                    _fsp--;
 588
 589 -                    adaptor.addChild(root_0, function25.tree);
 590 -                    char_literal26=input.LT(1);
 591 -                    match(input,26,FOLLOW_26_in_commands149);
 592 +                    state._fsp--;
 593
 594 +                    adaptor.addChild(root_0, function25.getTree());
 595 +                    char_literal26=(Token)match(input,26,FOLLOW_26_in_commands149);
 596 +
 597                      }
 598                      break;
 599                  case 9 :
 600 -                    // Bst.g:25:4: ENTRY^^ idList0 idList0 idList0
 601 +                    // Bst.g:25:4: ENTRY idList0 idList0 idList0
 602                      {
 603 -                    root_0 = adaptor.nil();
 604 +                    root_0 = (Object)adaptor.nil();
 605
 606 -                    ENTRY27=input.LT(1);
 607 -                    match(input,ENTRY,FOLLOW_ENTRY_in_commands155);
 608 -                    ENTRY27_tree = adaptor.create(ENTRY27);
 609 -                    root_0 = adaptor.becomeRoot(ENTRY27_tree, root_0);
 610 +                    ENTRY27=(Token)match(input,ENTRY,FOLLOW_ENTRY_in_commands155);
 611 +                    ENTRY27_tree = (Object)adaptor.create(ENTRY27);
 612 +                    root_0 = (Object)adaptor.becomeRoot(ENTRY27_tree, root_0);
 613
 614                      pushFollow(FOLLOW_idList0_in_commands158);
 615                      idList028=idList0();
 616 -                    _fsp--;
 617
 618 -                    adaptor.addChild(root_0, idList028.tree);
 619 +                    state._fsp--;
 620 +
 621 +                    adaptor.addChild(root_0, idList028.getTree());
 622                      pushFollow(FOLLOW_idList0_in_commands160);
 623                      idList029=idList0();
 624 -                    _fsp--;
 625
 626 -                    adaptor.addChild(root_0, idList029.tree);
 627 +                    state._fsp--;
 628 +
 629 +                    adaptor.addChild(root_0, idList029.getTree());
 630                      pushFollow(FOLLOW_idList0_in_commands162);
 631                      idList030=idList0();
 632 -                    _fsp--;
 633
 634 -                    adaptor.addChild(root_0, idList030.tree);
 635 +                    state._fsp--;
 636
 637 +                    adaptor.addChild(root_0, idList030.getTree());
 638 +
 639                      }
 640                      break;
 641                  case 10 :
 642 -                    // Bst.g:26:4: SORT^^
 643 +                    // Bst.g:26:4: SORT
 644                      {
 645 -                    root_0 = adaptor.nil();
 646 +                    root_0 = (Object)adaptor.nil();
 647
 648 -                    SORT31=input.LT(1);
 649 -                    match(input,SORT,FOLLOW_SORT_in_commands167);
 650 -                    SORT31_tree = adaptor.create(SORT31);
 651 -                    root_0 = adaptor.becomeRoot(SORT31_tree, root_0);
 652 +                    SORT31=(Token)match(input,SORT,FOLLOW_SORT_in_commands167);
 653 +                    SORT31_tree = (Object)adaptor.create(SORT31);
 654 +                    root_0 = (Object)adaptor.becomeRoot(SORT31_tree, root_0);
 655
 656
 657                      }
 658                      break;
 659
 660              }
 661 +            retval.stop = input.LT(-1);
 662 +
 663 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 664 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 665 +
 666          }
 667          catch (RecognitionException re) {
 668              reportError(re);
 669              recover(input,re);
 670 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 671 +
 672          }
 673          finally {
 674 -            retval.stop = input.LT(-1);
 675 -
 676 -                retval.tree = adaptor.rulePostProcessing(root_0);
 677 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 678 -
 679 -       }
 680 +        }
 681          return retval;
 682      }
 683 -    // $ANTLR end commands
 684 +    // $ANTLR end "commands"
 685
 686      public static class identifier_return extends ParserRuleReturnScope {
 687          Object tree;
 688          public Object getTree() { return tree; }
 689 -    }
 690 +    };
 691
 692 -    // $ANTLR start identifier
 693 +    // $ANTLR start "identifier"
 694      // Bst.g:28:1: identifier : IDENTIFIER ;
 695 -    public identifier_return identifier() throws RecognitionException {
 696 -        identifier_return retval = new identifier_return();
 697 +    public final BstParser.identifier_return identifier() throws RecognitionException {
 698 +        BstParser.identifier_return retval = new BstParser.identifier_return();
 699          retval.start = input.LT(1);
 700
 701          Object root_0 = null;
 702 @@ -525,121 +555,121 @@
 703          Object IDENTIFIER32_tree=null;
 704
 705          try {
 706 -            // Bst.g:29:4: ( IDENTIFIER )
 707 +            // Bst.g:29:2: ( IDENTIFIER )
 708              // Bst.g:29:4: IDENTIFIER
 709              {
 710 -            root_0 = adaptor.nil();
 711 +            root_0 = (Object)adaptor.nil();
 712
 713 -            IDENTIFIER32=input.LT(1);
 714 -            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier178);
 715 -            IDENTIFIER32_tree = adaptor.create(IDENTIFIER32);
 716 +            IDENTIFIER32=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier178);
 717 +            IDENTIFIER32_tree = (Object)adaptor.create(IDENTIFIER32);
 718              adaptor.addChild(root_0, IDENTIFIER32_tree);
 719
 720
 721              }
 722
 723 +            retval.stop = input.LT(-1);
 724 +
 725 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 726 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 727 +
 728          }
 729          catch (RecognitionException re) {
 730              reportError(re);
 731              recover(input,re);
 732 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 733 +
 734          }
 735          finally {
 736 -            retval.stop = input.LT(-1);
 737 -
 738 -                retval.tree = adaptor.rulePostProcessing(root_0);
 739 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 740 -
 741 -       }
 742 +        }
 743          return retval;
 744      }
 745 -    // $ANTLR end identifier
 746 +    // $ANTLR end "identifier"
 747
 748      public static class id_return extends ParserRuleReturnScope {
 749          Object tree;
 750          public Object getTree() { return tree; }
 751 -    }
 752 +    };
 753
 754 -    // $ANTLR start id
 755 -    // Bst.g:31:1: id : '{'! identifier '}'! ;
 756 -    public id_return id() throws RecognitionException {
 757 -        id_return retval = new id_return();
 758 +    // $ANTLR start "id"
 759 +    // Bst.g:31:1: id : '{' identifier '}' ;
 760 +    public final BstParser.id_return id() throws RecognitionException {
 761 +        BstParser.id_return retval = new BstParser.id_return();
 762          retval.start = input.LT(1);
 763
 764          Object root_0 = null;
 765
 766          Token char_literal33=null;
 767          Token char_literal35=null;
 768 -        identifier_return identifier34 = null;
 769 +        BstParser.identifier_return identifier34 = null;
 770
 771
 772          Object char_literal33_tree=null;
 773          Object char_literal35_tree=null;
 774
 775          try {
 776 -            // Bst.g:32:4: ( '{'! identifier '}'! )
 777 -            // Bst.g:32:4: '{'! identifier '}'!
 778 +            // Bst.g:32:2: ( '{' identifier '}' )
 779 +            // Bst.g:32:4: '{' identifier '}'
 780              {
 781 -            root_0 = adaptor.nil();
 782 +            root_0 = (Object)adaptor.nil();
 783
 784 -            char_literal33=input.LT(1);
 785 -            match(input,25,FOLLOW_25_in_id188);
 786 +            char_literal33=(Token)match(input,25,FOLLOW_25_in_id188);
 787              pushFollow(FOLLOW_identifier_in_id191);
 788              identifier34=identifier();
 789 -            _fsp--;
 790
 791 -            adaptor.addChild(root_0, identifier34.tree);
 792 -            char_literal35=input.LT(1);
 793 -            match(input,26,FOLLOW_26_in_id193);
 794 +            state._fsp--;
 795
 796 +            adaptor.addChild(root_0, identifier34.getTree());
 797 +            char_literal35=(Token)match(input,26,FOLLOW_26_in_id193);
 798 +
 799              }
 800
 801 +            retval.stop = input.LT(-1);
 802 +
 803 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 804 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 805 +
 806          }
 807          catch (RecognitionException re) {
 808              reportError(re);
 809              recover(input,re);
 810 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 811 +
 812          }
 813          finally {
 814 -            retval.stop = input.LT(-1);
 815 -
 816 -                retval.tree = adaptor.rulePostProcessing(root_0);
 817 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 818 -
 819 -       }
 820 +        }
 821          return retval;
 822      }
 823 -    // $ANTLR end id
 824 +    // $ANTLR end "id"
 825
 826      public static class idList_return extends ParserRuleReturnScope {
 827          Object tree;
 828          public Object getTree() { return tree; }
 829 -    }
 830 +    };
 831
 832 -    // $ANTLR start idList
 833 +    // $ANTLR start "idList"
 834      // Bst.g:34:1: idList : '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) ;
 835 -
 836 -       public idList_return idList() throws RecognitionException {
 837 -        idList_return retval = new idList_return();
 838 +    public final BstParser.idList_return idList() throws RecognitionException {
 839 +        BstParser.idList_return retval = new BstParser.idList_return();
 840          retval.start = input.LT(1);
 841
 842          Object root_0 = null;
 843
 844          Token char_literal36=null;
 845          Token char_literal38=null;
 846 -        identifier_return identifier37 = null;
 847 +        BstParser.identifier_return identifier37 = null;
 848
 849 -        List list_identifier=new ArrayList();
 850 -        List list_26=new ArrayList();
 851 -        List list_25=new ArrayList();
 852 +
 853          Object char_literal36_tree=null;
 854          Object char_literal38_tree=null;
 855 -
 856 +        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
 857 +        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
 858 +        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
 859          try {
 860 -            // Bst.g:35:4: ( '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) )
 861 +            // Bst.g:35:2: ( '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) )
 862              // Bst.g:35:4: '{' ( identifier )+ '}'
 863              {
 864 -            char_literal36=input.LT(1);
 865 -            match(input,25,FOLLOW_25_in_idList205);
 866 -            list_25.add(char_literal36);
 867 +            char_literal36=(Token)match(input,25,FOLLOW_25_in_idList205);
 868 +            stream_25.add(char_literal36);
 869
 870              // Bst.g:35:8: ( identifier )+
 871              int cnt3=0;
 872 @@ -647,6 +677,7 @@
 873              do {
 874                  int alt3=2;
 875                  int LA3_0 = input.LA(1);
 876 +
 877                  if ( (LA3_0==IDENTIFIER) ) {
 878                      alt3=1;
 879                  }
 880 @@ -658,10 +689,11 @@
 881                     {
 882                     pushFollow(FOLLOW_identifier_in_idList207);
 883                     identifier37=identifier();
 884 -                   _fsp--;
 885
 886 -                   list_identifier.add(identifier37.tree);
 887 +                   state._fsp--;
 888
 889 +                   stream_identifier.add(identifier37.getTree());
 890 +
 891                     }
 892                     break;
 893
 894 @@ -674,96 +706,100 @@
 895                  cnt3++;
 896              } while (true);
 897
 898 -            char_literal38=input.LT(1);
 899 -            match(input,26,FOLLOW_26_in_idList210);
 900 -            list_26.add(char_literal38);
 901 +            char_literal38=(Token)match(input,26,FOLLOW_26_in_idList210);
 902 +            stream_26.add(char_literal38);
 903
 904
 905 +
 906              // AST REWRITE
 907 -            int i_0 = 0;
 908 +            // elements: identifier
 909 +            // token labels:
 910 +            // rule labels: retval
 911 +            // token list labels:
 912 +            // rule list labels:
 913 +            // wildcard labels:
 914              retval.tree = root_0;
 915 -            root_0 = adaptor.nil();
 916 +            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 917 +
 918 +            root_0 = (Object)adaptor.nil();
 919              // 35:24: -> ^( IDLIST ( identifier )+ )
 920              {
 921                  // Bst.g:35:27: ^( IDLIST ( identifier )+ )
 922                  {
 923 -                Object root_1 = adaptor.nil();
 924 -                root_1 = adaptor.becomeRoot(adaptor.create(IDLIST, "IDLIST"), root_1);
 925 +                Object root_1 = (Object)adaptor.nil();
 926 +                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDLIST, "IDLIST"), root_1);
 927
 928 -                // Bst.g:35:36: ( identifier )+
 929 -                {
 930 -                int n_1 = list_identifier == null ? 0 : list_identifier.size();
 931 -
 932 +                if ( !(stream_identifier.hasNext()) ) {
 933 +                    throw new RewriteEarlyExitException();
 934 +                }
 935 +                while ( stream_identifier.hasNext() ) {
 936 +                    adaptor.addChild(root_1, stream_identifier.nextTree());
 937
 938 -
 939 -                if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops");
 940 -                for (int i_1=0; i_1<n_1; i_1++) {
 941 -                    adaptor.addChild(root_1, list_identifier.get(i_1));
 942 -
 943                  }
 944 -                }
 945 +                stream_identifier.reset();
 946
 947                  adaptor.addChild(root_0, root_1);
 948                  }
 949
 950              }
 951
 952 +            retval.tree = root_0;
 953 +            }
 954
 955 +            retval.stop = input.LT(-1);
 956
 957 -            }
 958 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 959 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 960
 961          }
 962          catch (RecognitionException re) {
 963              reportError(re);
 964              recover(input,re);
 965 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 966 +
 967          }
 968          finally {
 969 -            retval.stop = input.LT(-1);
 970 -
 971 -                retval.tree = adaptor.rulePostProcessing(root_0);
 972 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 973 -
 974 -       }
 975 +        }
 976          return retval;
 977      }
 978 -    // $ANTLR end idList
 979 +    // $ANTLR end "idList"
 980
 981      public static class idList0_return extends ParserRuleReturnScope {
 982          Object tree;
 983          public Object getTree() { return tree; }
 984 -    }
 985 +    };
 986
 987 -    // $ANTLR start idList0
 988 +    // $ANTLR start "idList0"
 989      // Bst.g:37:1: idList0 : '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) ;
 990 -    public idList0_return idList0() throws RecognitionException {
 991 -        idList0_return retval = new idList0_return();
 992 +    public final BstParser.idList0_return idList0() throws RecognitionException {
 993 +        BstParser.idList0_return retval = new BstParser.idList0_return();
 994          retval.start = input.LT(1);
 995
 996          Object root_0 = null;
 997
 998          Token char_literal39=null;
 999          Token char_literal41=null;
1000 -        identifier_return identifier40 = null;
1001 +        BstParser.identifier_return identifier40 = null;
1002
1003 -        List list_identifier=new ArrayList();
1004 -        List list_26=new ArrayList();
1005 -        List list_25=new ArrayList();
1006 +
1007          Object char_literal39_tree=null;
1008          Object char_literal41_tree=null;
1009 -
1010 +        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
1011 +        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
1012 +        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
1013          try {
1014 -            // Bst.g:38:4: ( '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) )
1015 +            // Bst.g:38:2: ( '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) )
1016              // Bst.g:38:4: '{' ( identifier )* '}'
1017              {
1018 -            char_literal39=input.LT(1);
1019 -            match(input,25,FOLLOW_25_in_idList0230);
1020 -            list_25.add(char_literal39);
1021 +            char_literal39=(Token)match(input,25,FOLLOW_25_in_idList0230);
1022 +            stream_25.add(char_literal39);
1023
1024              // Bst.g:38:8: ( identifier )*
1025              loop4:
1026              do {
1027                  int alt4=2;
1028                  int LA4_0 = input.LA(1);
1029 +
1030                  if ( (LA4_0==IDENTIFIER) ) {
1031                      alt4=1;
1032                  }
1033 @@ -775,10 +811,11 @@
1034                     {
1035                     pushFollow(FOLLOW_identifier_in_idList0232);
1036                     identifier40=identifier();
1037 -                   _fsp--;
1038
1039 -                   list_identifier.add(identifier40.tree);
1040 +                   state._fsp--;
1041
1042 +                   stream_identifier.add(identifier40.getTree());
1043 +
1044                     }
1045                     break;
1046
1047 @@ -787,68 +824,71 @@
1048                  }
1049              } while (true);
1050
1051 -            char_literal41=input.LT(1);
1052 -            match(input,26,FOLLOW_26_in_idList0235);
1053 -            list_26.add(char_literal41);
1054 +            char_literal41=(Token)match(input,26,FOLLOW_26_in_idList0235);
1055 +            stream_26.add(char_literal41);
1056
1057
1058 +
1059              // AST REWRITE
1060 -            int i_0 = 0;
1061 +            // elements: identifier
1062 +            // token labels:
1063 +            // rule labels: retval
1064 +            // token list labels:
1065 +            // rule list labels:
1066 +            // wildcard labels:
1067              retval.tree = root_0;
1068 -            root_0 = adaptor.nil();
1069 +            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1070 +
1071 +            root_0 = (Object)adaptor.nil();
1072              // 38:24: -> ^( IDLIST ( identifier )* )
1073              {
1074                  // Bst.g:38:27: ^( IDLIST ( identifier )* )
1075                  {
1076 -                Object root_1 = adaptor.nil();
1077 -                root_1 = adaptor.becomeRoot(adaptor.create(IDLIST, "IDLIST"), root_1);
1078 +                Object root_1 = (Object)adaptor.nil();
1079 +                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDLIST, "IDLIST"), root_1);
1080
1081                  // Bst.g:38:36: ( identifier )*
1082 -                {
1083 -                int n_1 = list_identifier == null ? 0 : list_identifier.size();
1084 -
1085 +                while ( stream_identifier.hasNext() ) {
1086 +                    adaptor.addChild(root_1, stream_identifier.nextTree());
1087
1088 -
1089 -                for (int i_1=0; i_1<n_1; i_1++) {
1090 -                    adaptor.addChild(root_1, list_identifier.get(i_1));
1091 -
1092                  }
1093 -                }
1094 +                stream_identifier.reset();
1095
1096                  adaptor.addChild(root_0, root_1);
1097                  }
1098
1099              }
1100
1101 +            retval.tree = root_0;
1102 +            }
1103
1104 +            retval.stop = input.LT(-1);
1105
1106 -            }
1107 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1108 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1109
1110          }
1111          catch (RecognitionException re) {
1112              reportError(re);
1113              recover(input,re);
1114 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1115 +
1116          }
1117          finally {
1118 -            retval.stop = input.LT(-1);
1119 -
1120 -                retval.tree = adaptor.rulePostProcessing(root_0);
1121 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1122 -
1123 -       }
1124 +        }
1125          return retval;
1126      }
1127 -    // $ANTLR end idList0
1128 +    // $ANTLR end "idList0"
1129
1130      public static class function_return extends ParserRuleReturnScope {
1131          Object tree;
1132          public Object getTree() { return tree; }
1133 -    }
1134 +    };
1135
1136 -    // $ANTLR start function
1137 +    // $ANTLR start "function"
1138      // Bst.g:40:1: function : ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier );
1139 -    public function_return function() throws RecognitionException {
1140 -        function_return retval = new function_return();
1141 +    public final BstParser.function_return function() throws RecognitionException {
1142 +        BstParser.function_return retval = new BstParser.function_return();
1143          retval.start = input.LT(1);
1144
1145          Object root_0 = null;
1146 @@ -860,7 +900,7 @@
1147          Token char_literal46=null;
1148          Token string_literal47=null;
1149          Token char_literal48=null;
1150 -        identifier_return identifier49 = null;
1151 +        BstParser.identifier_return identifier49 = null;
1152
1153
1154          Object char_literal42_tree=null;
1155 @@ -872,36 +912,52 @@
1156          Object char_literal48_tree=null;
1157
1158          try {
1159 -            // Bst.g:41:4: ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier )
1160 +            // Bst.g:41:2: ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier )
1161              int alt5=8;
1162              switch ( input.LA(1) ) {
1163              case 27:
1164 +                {
1165                  alt5=1;
1166 +                }
1167                  break;
1168              case 28:
1169 +                {
1170                  alt5=2;
1171 +                }
1172                  break;
1173              case 29:
1174 +                {
1175                  alt5=3;
1176 +                }
1177                  break;
1178              case 30:
1179 +                {
1180                  alt5=4;
1181 +                }
1182                  break;
1183              case 31:
1184 +                {
1185                  alt5=5;
1186 +                }
1187                  break;
1188              case 32:
1189 +                {
1190                  alt5=6;
1191 +                }
1192                  break;
1193              case 33:
1194 +                {
1195                  alt5=7;
1196 +                }
1197                  break;
1198              case IDENTIFIER:
1199 +                {
1200                  alt5=8;
1201 +                }
1202                  break;
1203              default:
1204                  NoViableAltException nvae =
1205 -                    new NoViableAltException("40:1: function : ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier );", 5, 0, input);
1206 +                    new NoViableAltException("", 5, 0, input);
1207
1208                  throw nvae;
1209              }
1210 @@ -910,11 +966,10 @@
1211                  case 1 :
1212                      // Bst.g:41:4: '<'
1213                      {
1214 -                    root_0 = adaptor.nil();
1215 +                    root_0 = (Object)adaptor.nil();
1216
1217 -                    char_literal42=input.LT(1);
1218 -                    match(input,27,FOLLOW_27_in_function254);
1219 -                    char_literal42_tree = adaptor.create(char_literal42);
1220 +                    char_literal42=(Token)match(input,27,FOLLOW_27_in_function254);
1221 +                    char_literal42_tree = (Object)adaptor.create(char_literal42);
1222                      adaptor.addChild(root_0, char_literal42_tree);
1223
1224
1225 @@ -923,11 +978,10 @@
1226                  case 2 :
1227                      // Bst.g:41:10: '>'
1228                      {
1229 -                    root_0 = adaptor.nil();
1230 +                    root_0 = (Object)adaptor.nil();
1231
1232 -                    char_literal43=input.LT(1);
1233 -                    match(input,28,FOLLOW_28_in_function258);
1234 -                    char_literal43_tree = adaptor.create(char_literal43);
1235 +                    char_literal43=(Token)match(input,28,FOLLOW_28_in_function258);
1236 +                    char_literal43_tree = (Object)adaptor.create(char_literal43);
1237                      adaptor.addChild(root_0, char_literal43_tree);
1238
1239
1240 @@ -936,11 +990,10 @@
1241                  case 3 :
1242                      // Bst.g:41:16: '='
1243                      {
1244 -                    root_0 = adaptor.nil();
1245 +                    root_0 = (Object)adaptor.nil();
1246
1247 -                    char_literal44=input.LT(1);
1248 -                    match(input,29,FOLLOW_29_in_function262);
1249 -                    char_literal44_tree = adaptor.create(char_literal44);
1250 +                    char_literal44=(Token)match(input,29,FOLLOW_29_in_function262);
1251 +                    char_literal44_tree = (Object)adaptor.create(char_literal44);
1252                      adaptor.addChild(root_0, char_literal44_tree);
1253
1254
1255 @@ -949,11 +1002,10 @@
1256                  case 4 :
1257                      // Bst.g:41:22: '+'
1258                      {
1259 -                    root_0 = adaptor.nil();
1260 +                    root_0 = (Object)adaptor.nil();
1261
1262 -                    char_literal45=input.LT(1);
1263 -                    match(input,30,FOLLOW_30_in_function266);
1264 -                    char_literal45_tree = adaptor.create(char_literal45);
1265 +                    char_literal45=(Token)match(input,30,FOLLOW_30_in_function266);
1266 +                    char_literal45_tree = (Object)adaptor.create(char_literal45);
1267                      adaptor.addChild(root_0, char_literal45_tree);
1268
1269
1270 @@ -962,11 +1014,10 @@
1271                  case 5 :
1272                      // Bst.g:41:28: '-'
1273                      {
1274 -                    root_0 = adaptor.nil();
1275 +                    root_0 = (Object)adaptor.nil();
1276
1277 -                    char_literal46=input.LT(1);
1278 -                    match(input,31,FOLLOW_31_in_function270);
1279 -                    char_literal46_tree = adaptor.create(char_literal46);
1280 +                    char_literal46=(Token)match(input,31,FOLLOW_31_in_function270);
1281 +                    char_literal46_tree = (Object)adaptor.create(char_literal46);
1282                      adaptor.addChild(root_0, char_literal46_tree);
1283
1284
1285 @@ -975,11 +1026,10 @@
1286                  case 6 :
1287                      // Bst.g:41:34: ':='
1288                      {
1289 -                    root_0 = adaptor.nil();
1290 +                    root_0 = (Object)adaptor.nil();
1291
1292 -                    string_literal47=input.LT(1);
1293 -                    match(input,32,FOLLOW_32_in_function274);
1294 -                    string_literal47_tree = adaptor.create(string_literal47);
1295 +                    string_literal47=(Token)match(input,32,FOLLOW_32_in_function274);
1296 +                    string_literal47_tree = (Object)adaptor.create(string_literal47);
1297                      adaptor.addChild(root_0, string_literal47_tree);
1298
1299
1300 @@ -988,11 +1038,10 @@
1301                  case 7 :
1302                      // Bst.g:41:41: '*'
1303                      {
1304 -                    root_0 = adaptor.nil();
1305 +                    root_0 = (Object)adaptor.nil();
1306
1307 -                    char_literal48=input.LT(1);
1308 -                    match(input,33,FOLLOW_33_in_function278);
1309 -                    char_literal48_tree = adaptor.create(char_literal48);
1310 +                    char_literal48=(Token)match(input,33,FOLLOW_33_in_function278);
1311 +                    char_literal48_tree = (Object)adaptor.create(char_literal48);
1312                      adaptor.addChild(root_0, char_literal48_tree);
1313
1314
1315 @@ -1001,64 +1050,66 @@
1316                  case 8 :
1317                      // Bst.g:41:47: identifier
1318                      {
1319 -                    root_0 = adaptor.nil();
1320 +                    root_0 = (Object)adaptor.nil();
1321
1322                      pushFollow(FOLLOW_identifier_in_function282);
1323                      identifier49=identifier();
1324 -                    _fsp--;
1325
1326 -                    adaptor.addChild(root_0, identifier49.tree);
1327 +                    state._fsp--;
1328
1329 +                    adaptor.addChild(root_0, identifier49.getTree());
1330 +
1331                      }
1332                      break;
1333
1334              }
1335 +            retval.stop = input.LT(-1);
1336 +
1337 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1338 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1339 +
1340          }
1341          catch (RecognitionException re) {
1342              reportError(re);
1343              recover(input,re);
1344 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1345 +
1346          }
1347          finally {
1348 -            retval.stop = input.LT(-1);
1349 -
1350 -                retval.tree = adaptor.rulePostProcessing(root_0);
1351 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1352 -
1353 -       }
1354 +        }
1355          return retval;
1356      }
1357 -    // $ANTLR end function
1358 +    // $ANTLR end "function"
1359
1360      public static class stack_return extends ParserRuleReturnScope {
1361          Object tree;
1362          public Object getTree() { return tree; }
1363 -    }
1364 +    };
1365
1366 -    // $ANTLR start stack
1367 +    // $ANTLR start "stack"
1368      // Bst.g:43:1: stack : '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) ;
1369 -    public stack_return stack() throws RecognitionException {
1370 -        stack_return retval = new stack_return();
1371 +    public final BstParser.stack_return stack() throws RecognitionException {
1372 +        BstParser.stack_return retval = new BstParser.stack_return();
1373          retval.start = input.LT(1);
1374
1375          Object root_0 = null;
1376
1377          Token char_literal50=null;
1378          Token char_literal52=null;
1379 -        stackitem_return stackitem51 = null;
1380 +        BstParser.stackitem_return stackitem51 = null;
1381
1382 -        List list_stackitem=new ArrayList();
1383 -        List list_26=new ArrayList();
1384 -        List list_25=new ArrayList();
1385 +
1386          Object char_literal50_tree=null;
1387          Object char_literal52_tree=null;
1388 -
1389 +        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
1390 +        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
1391 +        RewriteRuleSubtreeStream stream_stackitem=new RewriteRuleSubtreeStream(adaptor,"rule stackitem");
1392          try {
1393 -            // Bst.g:44:4: ( '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) )
1394 +            // Bst.g:44:2: ( '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) )
1395              // Bst.g:44:4: '{' ( stackitem )+ '}'
1396              {
1397 -            char_literal50=input.LT(1);
1398 -            match(input,25,FOLLOW_25_in_stack293);
1399 -            list_25.add(char_literal50);
1400 +            char_literal50=(Token)match(input,25,FOLLOW_25_in_stack293);
1401 +            stream_25.add(char_literal50);
1402
1403              // Bst.g:44:8: ( stackitem )+
1404              int cnt6=0;
1405 @@ -1066,6 +1117,7 @@
1406              do {
1407                  int alt6=2;
1408                  int LA6_0 = input.LA(1);
1409 +
1410                  if ( (LA6_0==STRING||(LA6_0>=IDENTIFIER && LA6_0<=QUOTED)||LA6_0==25||(LA6_0>=27 && LA6_0<=33)) ) {
1411                      alt6=1;
1412                  }
1413 @@ -1077,10 +1129,11 @@
1414                     {
1415                     pushFollow(FOLLOW_stackitem_in_stack295);
1416                     stackitem51=stackitem();
1417 -                   _fsp--;
1418
1419 -                   list_stackitem.add(stackitem51.tree);
1420 +                   state._fsp--;
1421
1422 +                   stream_stackitem.add(stackitem51.getTree());
1423 +
1424                     }
1425                     break;
1426
1427 @@ -1093,69 +1146,73 @@
1428                  cnt6++;
1429              } while (true);
1430
1431 -            char_literal52=input.LT(1);
1432 -            match(input,26,FOLLOW_26_in_stack298);
1433 -            list_26.add(char_literal52);
1434 +            char_literal52=(Token)match(input,26,FOLLOW_26_in_stack298);
1435 +            stream_26.add(char_literal52);
1436
1437
1438 +
1439              // AST REWRITE
1440 -            int i_0 = 0;
1441 +            // elements: stackitem
1442 +            // token labels:
1443 +            // rule labels: retval
1444 +            // token list labels:
1445 +            // rule list labels:
1446 +            // wildcard labels:
1447              retval.tree = root_0;
1448 -            root_0 = adaptor.nil();
1449 +            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1450 +
1451 +            root_0 = (Object)adaptor.nil();
1452              // 44:23: -> ^( STACK ( stackitem )+ )
1453              {
1454                  // Bst.g:44:26: ^( STACK ( stackitem )+ )
1455                  {
1456 -                Object root_1 = adaptor.nil();
1457 -                root_1 = adaptor.becomeRoot(adaptor.create(STACK, "STACK"), root_1);
1458 +                Object root_1 = (Object)adaptor.nil();
1459 +                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(STACK, "STACK"), root_1);
1460
1461 -                // Bst.g:44:34: ( stackitem )+
1462 -                {
1463 -                int n_1 = list_stackitem == null ? 0 : list_stackitem.size();
1464 -
1465 +                if ( !(stream_stackitem.hasNext()) ) {
1466 +                    throw new RewriteEarlyExitException();
1467 +                }
1468 +                while ( stream_stackitem.hasNext() ) {
1469 +                    adaptor.addChild(root_1, stream_stackitem.nextTree());
1470
1471 -
1472 -                if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops");
1473 -                for (int i_1=0; i_1<n_1; i_1++) {
1474 -                    adaptor.addChild(root_1, list_stackitem.get(i_1));
1475 -
1476                  }
1477 -                }
1478 +                stream_stackitem.reset();
1479
1480                  adaptor.addChild(root_0, root_1);
1481                  }
1482
1483              }
1484
1485 +            retval.tree = root_0;
1486 +            }
1487
1488 +            retval.stop = input.LT(-1);
1489
1490 -            }
1491 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1492 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1493
1494          }
1495          catch (RecognitionException re) {
1496              reportError(re);
1497              recover(input,re);
1498 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1499 +
1500          }
1501          finally {
1502 -            retval.stop = input.LT(-1);
1503 -
1504 -                retval.tree = adaptor.rulePostProcessing(root_0);
1505 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1506 -
1507 -       }
1508 +        }
1509          return retval;
1510      }
1511 -    // $ANTLR end stack
1512 +    // $ANTLR end "stack"
1513
1514      public static class stackitem_return extends ParserRuleReturnScope {
1515          Object tree;
1516          public Object getTree() { return tree; }
1517 -    }
1518 +    };
1519
1520 -    // $ANTLR start stackitem
1521 +    // $ANTLR start "stackitem"
1522      // Bst.g:46:1: stackitem : ( function | STRING | INTEGER | QUOTED | stack );
1523 -    public stackitem_return stackitem() throws RecognitionException {
1524 -        stackitem_return retval = new stackitem_return();
1525 +    public final BstParser.stackitem_return stackitem() throws RecognitionException {
1526 +        BstParser.stackitem_return retval = new BstParser.stackitem_return();
1527          retval.start = input.LT(1);
1528
1529          Object root_0 = null;
1530 @@ -1163,9 +1220,9 @@
1531          Token STRING54=null;
1532          Token INTEGER55=null;
1533          Token QUOTED56=null;
1534 -        function_return function53 = null;
1535 +        BstParser.function_return function53 = null;
1536
1537 -        stack_return stack57 = null;
1538 +        BstParser.stack_return stack57 = null;
1539
1540
1541          Object STRING54_tree=null;
1542 @@ -1173,7 +1230,7 @@
1543          Object QUOTED56_tree=null;
1544
1545          try {
1546 -            // Bst.g:47:4: ( function | STRING | INTEGER | QUOTED | stack )
1547 +            // Bst.g:47:2: ( function | STRING | INTEGER | QUOTED | stack )
1548              int alt7=5;
1549              switch ( input.LA(1) ) {
1550              case IDENTIFIER:
1551 @@ -1184,23 +1241,33 @@
1552              case 31:
1553              case 32:
1554              case 33:
1555 +                {
1556                  alt7=1;
1557 +                }
1558                  break;
1559              case STRING:
1560 +                {
1561                  alt7=2;
1562 +                }
1563                  break;
1564              case INTEGER:
1565 +                {
1566                  alt7=3;
1567 +                }
1568                  break;
1569              case QUOTED:
1570 +                {
1571                  alt7=4;
1572 +                }
1573                  break;
1574              case 25:
1575 +                {
1576                  alt7=5;
1577 +                }
1578                  break;
1579              default:
1580                  NoViableAltException nvae =
1581 -                    new NoViableAltException("46:1: stackitem : ( function | STRING | INTEGER | QUOTED | stack );", 7, 0, input);
1582 +                    new NoViableAltException("", 7, 0, input);
1583
1584                  throw nvae;
1585              }
1586 @@ -1209,24 +1276,24 @@
1587                  case 1 :
1588                      // Bst.g:47:4: function
1589                      {
1590 -                    root_0 = adaptor.nil();
1591 +                    root_0 = (Object)adaptor.nil();
1592
1593                      pushFollow(FOLLOW_function_in_stackitem317);
1594                      function53=function();
1595 -                    _fsp--;
1596
1597 -                    adaptor.addChild(root_0, function53.tree);
1598 +                    state._fsp--;
1599
1600 +                    adaptor.addChild(root_0, function53.getTree());
1601 +
1602                      }
1603                      break;
1604                  case 2 :
1605                      // Bst.g:48:4: STRING
1606                      {
1607 -                    root_0 = adaptor.nil();
1608 +                    root_0 = (Object)adaptor.nil();
1609
1610 -                    STRING54=input.LT(1);
1611 -                    match(input,STRING,FOLLOW_STRING_in_stackitem322);
1612 -                    STRING54_tree = adaptor.create(STRING54);
1613 +                    STRING54=(Token)match(input,STRING,FOLLOW_STRING_in_stackitem322);
1614 +                    STRING54_tree = (Object)adaptor.create(STRING54);
1615                      adaptor.addChild(root_0, STRING54_tree);
1616
1617
1618 @@ -1235,11 +1302,10 @@
1619                  case 3 :
1620                      // Bst.g:49:4: INTEGER
1621                      {
1622 -                    root_0 = adaptor.nil();
1623 +                    root_0 = (Object)adaptor.nil();
1624
1625 -                    INTEGER55=input.LT(1);
1626 -                    match(input,INTEGER,FOLLOW_INTEGER_in_stackitem328);
1627 -                    INTEGER55_tree = adaptor.create(INTEGER55);
1628 +                    INTEGER55=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_stackitem328);
1629 +                    INTEGER55_tree = (Object)adaptor.create(INTEGER55);
1630                      adaptor.addChild(root_0, INTEGER55_tree);
1631
1632
1633 @@ -1248,11 +1314,10 @@
1634                  case 4 :
1635                      // Bst.g:50:4: QUOTED
1636                      {
1637 -                    root_0 = adaptor.nil();
1638 +                    root_0 = (Object)adaptor.nil();
1639
1640 -                    QUOTED56=input.LT(1);
1641 -                    match(input,QUOTED,FOLLOW_QUOTED_in_stackitem334);
1642 -                    QUOTED56_tree = adaptor.create(QUOTED56);
1643 +                    QUOTED56=(Token)match(input,QUOTED,FOLLOW_QUOTED_in_stackitem334);
1644 +                    QUOTED56_tree = (Object)adaptor.create(QUOTED56);
1645                      adaptor.addChild(root_0, QUOTED56_tree);
1646
1647
1648 @@ -1261,35 +1326,40 @@
1649                  case 5 :
1650                      // Bst.g:51:4: stack
1651                      {
1652 -                    root_0 = adaptor.nil();
1653 +                    root_0 = (Object)adaptor.nil();
1654
1655                      pushFollow(FOLLOW_stack_in_stackitem339);
1656                      stack57=stack();
1657 -                    _fsp--;
1658
1659 -                    adaptor.addChild(root_0, stack57.tree);
1660 +                    state._fsp--;
1661
1662 +                    adaptor.addChild(root_0, stack57.getTree());
1663 +
1664                      }
1665                      break;
1666
1667              }
1668 +            retval.stop = input.LT(-1);
1669 +
1670 +            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1671 +            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1672 +
1673          }
1674          catch (RecognitionException re) {
1675              reportError(re);
1676              recover(input,re);
1677 +       retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1678 +
1679          }
1680          finally {
1681 -            retval.stop = input.LT(-1);
1682 -
1683 -                retval.tree = adaptor.rulePostProcessing(root_0);
1684 -                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1685 -
1686 -       }
1687 +        }
1688          return retval;
1689      }
1690 -    // $ANTLR end stackitem
1691 +    // $ANTLR end "stackitem"
1692
1693 +    // Delegated rules
1694
1695 +
1696
1697
1698      public static final BitSet FOLLOW_commands_in_program45 = new BitSet(new long[]{0x000000000003EF42L});
1699 @@ -1324,14 +1394,14 @@
1700      public static final BitSet FOLLOW_idList0_in_commands162 = new BitSet(new long[]{0x0000000000000002L});
1701      public static final BitSet FOLLOW_SORT_in_commands167 = new BitSet(new long[]{0x0000000000000002L});
1702      public static final BitSet FOLLOW_IDENTIFIER_in_identifier178 = new BitSet(new long[]{0x0000000000000002L});
1703 -    public static final BitSet FOLLOW_25_in_id188 = new BitSet(new long[]{0x0000000000040000L});
1704 +    public static final BitSet FOLLOW_25_in_id188 = new BitSet(new long[]{0x00000003F8040000L});
1705      public static final BitSet FOLLOW_identifier_in_id191 = new BitSet(new long[]{0x0000000004000000L});
1706      public static final BitSet FOLLOW_26_in_id193 = new BitSet(new long[]{0x0000000000000002L});
1707 -    public static final BitSet FOLLOW_25_in_idList205 = new BitSet(new long[]{0x0000000000040000L});
1708 -    public static final BitSet FOLLOW_identifier_in_idList207 = new BitSet(new long[]{0x0000000004040000L});
1709 +    public static final BitSet FOLLOW_25_in_idList205 = new BitSet(new long[]{0x00000003F8040000L});
1710 +    public static final BitSet FOLLOW_identifier_in_idList207 = new BitSet(new long[]{0x00000003FC040000L});
1711      public static final BitSet FOLLOW_26_in_idList210 = new BitSet(new long[]{0x0000000000000002L});
1712 -    public static final BitSet FOLLOW_25_in_idList0230 = new BitSet(new long[]{0x0000000004040000L});
1713 -    public static final BitSet FOLLOW_identifier_in_idList0232 = new BitSet(new long[]{0x0000000004040000L});
1714 +    public static final BitSet FOLLOW_25_in_idList0230 = new BitSet(new long[]{0x00000003FC040000L});
1715 +    public static final BitSet FOLLOW_identifier_in_idList0232 = new BitSet(new long[]{0x00000003FC040000L});
1716      public static final BitSet FOLLOW_26_in_idList0235 = new BitSet(new long[]{0x0000000000000002L});
1717      public static final BitSet FOLLOW_27_in_function254 = new BitSet(new long[]{0x0000000000000002L});
1718      public static final BitSet FOLLOW_28_in_function258 = new BitSet(new long[]{0x0000000000000002L});
1719 @@ -1350,4 +1420,4 @@
1720      public static final BitSet FOLLOW_QUOTED_in_stackitem334 = new BitSet(new long[]{0x0000000000000002L});
1721      public static final BitSet FOLLOW_stack_in_stackitem339 = new BitSet(new long[]{0x0000000000000002L});
1722
1723 -}
1724 \ No newline at end of file
1725 +}
1726 Index: BstLexer.java
1727 ===================================================================
1728 --- a/src/java/net/sf/jabref/bst/BstLexer.java  (revision 2214)
1729 +++ b/src/java/net/sf/jabref/bst/BstLexer.java  (working copy)
1730 @@ -1,328 +1,245 @@
1731  package net.sf.jabref.bst;
1732
1733 -// $ANTLR 3.0b5 Bst.g 2006-11-23 23:20:24
1734 +// $ANTLR 3.2 debian-4 Bst.g 2010-08-02 19:59:11
1735
1736 -import org.antlr.runtime.CharStream;
1737 -import org.antlr.runtime.EarlyExitException;
1738 -import org.antlr.runtime.Lexer;
1739 -import org.antlr.runtime.MismatchedSetException;
1740 -import org.antlr.runtime.NoViableAltException;
1741 -import org.antlr.runtime.RecognitionException;
1742 -import org.antlr.runtime.Token;
1743 +import org.antlr.runtime.*;
1744 +import java.util.Stack;
1745 +import java.util.List;
1746 +import java.util.ArrayList;
1747
1748  public class BstLexer extends Lexer {
1749 +    public static final int FUNCTION=10;
1750 +    public static final int INTEGER=19;
1751 +    public static final int T__29=29;
1752 +    public static final int T__28=28;
1753 +    public static final int T__27=27;
1754 +    public static final int T__26=26;
1755 +    public static final int LINE_COMMENT=24;
1756 +    public static final int QUOTED=20;
1757 +    public static final int T__25=25;
1758      public static final int LETTER=21;
1759 -    public static final int T29=29;
1760 -    public static final int T33=33;
1761 -    public static final int INTEGERS=9;
1762 -    public static final int ENTRY=6;
1763 -    public static final int WS=23;
1764 -    public static final int COMMANDS=7;
1765 -    public static final int STRING=12;
1766 -    public static final int T28=28;
1767      public static final int EXECUTE=14;
1768 -    public static final int LINE_COMMENT=24;
1769 +    public static final int STRINGS=8;
1770      public static final int SORT=17;
1771 -    public static final int STACK=5;
1772 -    public static final int REVERSE=16;
1773 -    public static final int QUOTED=20;
1774 -    public static final int T25=25;
1775 -    public static final int INTEGER=19;
1776 -    public static final int ITERATE=15;
1777 -    public static final int FUNCTION=10;
1778 -    public static final int T26=26;
1779 +    public static final int ENTRY=6;
1780      public static final int EOF=-1;
1781 -    public static final int T32=32;
1782 -    public static final int Tokens=34;
1783 -    public static final int STRINGS=8;
1784 -    public static final int T31=31;
1785 -    public static final int T27=27;
1786 +    public static final int INTEGERS=9;
1787 +    public static final int T__30=30;
1788 +    public static final int T__31=31;
1789 +    public static final int ITERATE=15;
1790 +    public static final int T__32=32;
1791 +    public static final int T__33=33;
1792 +    public static final int WS=23;
1793 +    public static final int COMMANDS=7;
1794 +    public static final int READ=13;
1795      public static final int IDENTIFIER=18;
1796 -    public static final int MACRO=11;
1797 -    public static final int T30=30;
1798      public static final int IDLIST=4;
1799      public static final int NUMERAL=22;
1800 -    public static final int READ=13;
1801 -    public BstLexer() {
1802 -
1803 -    }
1804 +    public static final int STACK=5;
1805 +    public static final int REVERSE=16;
1806 +    public static final int MACRO=11;
1807 +    public static final int STRING=12;
1808 +
1809 +    // delegates
1810 +    // delegators
1811 +
1812 +    public BstLexer() {;}
1813      public BstLexer(CharStream input) {
1814 -        super(input);
1815 +        this(input, new RecognizerSharedState());
1816      }
1817 +    public BstLexer(CharStream input, RecognizerSharedState state) {
1818 +        super(input,state);
1819 +
1820 +    }
1821      public String getGrammarFileName() { return "Bst.g"; }
1822
1823 -    // $ANTLR start T25
1824 -    public void mT25() throws RecognitionException {
1825 +    // $ANTLR start "T__25"
1826 +    public final void mT__25() throws RecognitionException {
1827          try {
1828 -            ruleNestingLevel++;
1829 -            int _type = T25;
1830 -            int _start = getCharIndex();
1831 -            int _line = getLine();
1832 -            int _charPosition = getCharPositionInLine();
1833 -            int _channel = Token.DEFAULT_CHANNEL;
1834 +            int _type = T__25;
1835 +            int _channel = DEFAULT_TOKEN_CHANNEL;
1836              // Bst.g:3:7: ( '{' )
1837 -            // Bst.g:3:7: '{'
1838 +            // Bst.g:3:9: '{'
1839              {
1840              match('{');
1841
1842              }
1843
1844 -
1845 -
1846 -                    if ( token==null && ruleNestingLevel==1 ) {
1847 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
1848 -                    }
1849 -
1850 -                        }
1851 +            state.type = _type;
1852 +            state.channel = _channel;
1853 +        }
1854          finally {
1855 -            ruleNestingLevel--;
1856          }
1857      }
1858 -    // $ANTLR end T25
1859 +    // $ANTLR end "T__25"
1860
1861 -    // $ANTLR start T26
1862 -    public void mT26() throws RecognitionException {
1863 +    // $ANTLR start "T__26"
1864 +    public final void mT__26() throws RecognitionException {
1865          try {
1866 -            ruleNestingLevel++;
1867 -            int _type = T26;
1868 -            int _start = getCharIndex();
1869 -            int _line = getLine();
1870 -            int _charPosition = getCharPositionInLine();
1871 -            int _channel = Token.DEFAULT_CHANNEL;
1872 +            int _type = T__26;
1873 +            int _channel = DEFAULT_TOKEN_CHANNEL;
1874              // Bst.g:4:7: ( '}' )
1875 -            // Bst.g:4:7: '}'
1876 +            // Bst.g:4:9: '}'
1877              {
1878              match('}');
1879
1880              }
1881
1882 -
1883 -
1884 -                    if ( token==null && ruleNestingLevel==1 ) {
1885 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
1886 -                    }
1887 -
1888 -                        }
1889 +            state.type = _type;
1890 +            state.channel = _channel;
1891 +        }
1892          finally {
1893 -            ruleNestingLevel--;
1894          }
1895      }
1896 -    // $ANTLR end T26
1897 +    // $ANTLR end "T__26"
1898
1899 -    // $ANTLR start T27
1900 -    public void mT27() throws RecognitionException {
1901 +    // $ANTLR start "T__27"
1902 +    public final void mT__27() throws RecognitionException {
1903          try {
1904 -            ruleNestingLevel++;
1905 -            int _type = T27;
1906 -            int _start = getCharIndex();
1907 -            int _line = getLine();
1908 -            int _charPosition = getCharPositionInLine();
1909 -            int _channel = Token.DEFAULT_CHANNEL;
1910 +            int _type = T__27;
1911 +            int _channel = DEFAULT_TOKEN_CHANNEL;
1912              // Bst.g:5:7: ( '<' )
1913 -            // Bst.g:5:7: '<'
1914 +            // Bst.g:5:9: '<'
1915              {
1916              match('<');
1917
1918              }
1919
1920 -
1921 -
1922 -                    if ( token==null && ruleNestingLevel==1 ) {
1923 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
1924 -                    }
1925 -
1926 -                        }
1927 +            state.type = _type;
1928 +            state.channel = _channel;
1929 +        }
1930          finally {
1931 -            ruleNestingLevel--;
1932          }
1933      }
1934 -    // $ANTLR end T27
1935 +    // $ANTLR end "T__27"
1936
1937 -    // $ANTLR start T28
1938 -    public void mT28() throws RecognitionException {
1939 +    // $ANTLR start "T__28"
1940 +    public final void mT__28() throws RecognitionException {
1941          try {
1942 -            ruleNestingLevel++;
1943 -            int _type = T28;
1944 -            int _start = getCharIndex();
1945 -            int _line = getLine();
1946 -            int _charPosition = getCharPositionInLine();
1947 -            int _channel = Token.DEFAULT_CHANNEL;
1948 +            int _type = T__28;
1949 +            int _channel = DEFAULT_TOKEN_CHANNEL;
1950              // Bst.g:6:7: ( '>' )
1951 -            // Bst.g:6:7: '>'
1952 +            // Bst.g:6:9: '>'
1953              {
1954              match('>');
1955
1956              }
1957
1958 -
1959 -
1960 -                    if ( token==null && ruleNestingLevel==1 ) {
1961 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
1962 -                    }
1963 -
1964 -                        }
1965 +            state.type = _type;
1966 +            state.channel = _channel;
1967 +        }
1968          finally {
1969 -            ruleNestingLevel--;
1970          }
1971      }
1972 -    // $ANTLR end T28
1973 +    // $ANTLR end "T__28"
1974
1975 -    // $ANTLR start T29
1976 -    public void mT29() throws RecognitionException {
1977 +    // $ANTLR start "T__29"
1978 +    public final void mT__29() throws RecognitionException {
1979          try {
1980 -            ruleNestingLevel++;
1981 -            int _type = T29;
1982 -            int _start = getCharIndex();
1983 -            int _line = getLine();
1984 -            int _charPosition = getCharPositionInLine();
1985 -            int _channel = Token.DEFAULT_CHANNEL;
1986 +            int _type = T__29;
1987 +            int _channel = DEFAULT_TOKEN_CHANNEL;
1988              // Bst.g:7:7: ( '=' )
1989 -            // Bst.g:7:7: '='
1990 +            // Bst.g:7:9: '='
1991              {
1992              match('=');
1993
1994              }
1995
1996 -
1997 -
1998 -                    if ( token==null && ruleNestingLevel==1 ) {
1999 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2000 -                    }
2001 -
2002 -                        }
2003 +            state.type = _type;
2004 +            state.channel = _channel;
2005 +        }
2006          finally {
2007 -            ruleNestingLevel--;
2008          }
2009      }
2010 -    // $ANTLR end T29
2011 +    // $ANTLR end "T__29"
2012
2013 -    // $ANTLR start T30
2014 -    public void mT30() throws RecognitionException {
2015 +    // $ANTLR start "T__30"
2016 +    public final void mT__30() throws RecognitionException {
2017          try {
2018 -            ruleNestingLevel++;
2019 -            int _type = T30;
2020 -            int _start = getCharIndex();
2021 -            int _line = getLine();
2022 -            int _charPosition = getCharPositionInLine();
2023 -            int _channel = Token.DEFAULT_CHANNEL;
2024 +            int _type = T__30;
2025 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2026              // Bst.g:8:7: ( '+' )
2027 -            // Bst.g:8:7: '+'
2028 +            // Bst.g:8:9: '+'
2029              {
2030              match('+');
2031
2032              }
2033
2034 -
2035 -
2036 -                    if ( token==null && ruleNestingLevel==1 ) {
2037 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2038 -                    }
2039 -
2040 -                        }
2041 +            state.type = _type;
2042 +            state.channel = _channel;
2043 +        }
2044          finally {
2045 -            ruleNestingLevel--;
2046          }
2047      }
2048 -    // $ANTLR end T30
2049 +    // $ANTLR end "T__30"
2050
2051 -    // $ANTLR start T31
2052 -    public void mT31() throws RecognitionException {
2053 +    // $ANTLR start "T__31"
2054 +    public final void mT__31() throws RecognitionException {
2055          try {
2056 -            ruleNestingLevel++;
2057 -            int _type = T31;
2058 -            int _start = getCharIndex();
2059 -            int _line = getLine();
2060 -            int _charPosition = getCharPositionInLine();
2061 -            int _channel = Token.DEFAULT_CHANNEL;
2062 +            int _type = T__31;
2063 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2064              // Bst.g:9:7: ( '-' )
2065 -            // Bst.g:9:7: '-'
2066 +            // Bst.g:9:9: '-'
2067              {
2068              match('-');
2069
2070              }
2071
2072 -
2073 -
2074 -                    if ( token==null && ruleNestingLevel==1 ) {
2075 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2076 -                    }
2077 -
2078 -                        }
2079 +            state.type = _type;
2080 +            state.channel = _channel;
2081 +        }
2082          finally {
2083 -            ruleNestingLevel--;
2084          }
2085      }
2086 -    // $ANTLR end T31
2087 +    // $ANTLR end "T__31"
2088
2089 -    // $ANTLR start T32
2090 -    public void mT32() throws RecognitionException {
2091 +    // $ANTLR start "T__32"
2092 +    public final void mT__32() throws RecognitionException {
2093          try {
2094 -            ruleNestingLevel++;
2095 -            int _type = T32;
2096 -            int _start = getCharIndex();
2097 -            int _line = getLine();
2098 -            int _charPosition = getCharPositionInLine();
2099 -            int _channel = Token.DEFAULT_CHANNEL;
2100 +            int _type = T__32;
2101 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2102              // Bst.g:10:7: ( ':=' )
2103 -            // Bst.g:10:7: ':='
2104 +            // Bst.g:10:9: ':='
2105              {
2106              match(":=");
2107
2108
2109              }
2110
2111 -
2112 -
2113 -                    if ( token==null && ruleNestingLevel==1 ) {
2114 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2115 -                    }
2116 -
2117 -                        }
2118 +            state.type = _type;
2119 +            state.channel = _channel;
2120 +        }
2121          finally {
2122 -            ruleNestingLevel--;
2123          }
2124      }
2125 -    // $ANTLR end T32
2126 +    // $ANTLR end "T__32"
2127
2128 -    // $ANTLR start T33
2129 -    public void mT33() throws RecognitionException {
2130 +    // $ANTLR start "T__33"
2131 +    public final void mT__33() throws RecognitionException {
2132          try {
2133 -            ruleNestingLevel++;
2134 -            int _type = T33;
2135 -            int _start = getCharIndex();
2136 -            int _line = getLine();
2137 -            int _charPosition = getCharPositionInLine();
2138 -            int _channel = Token.DEFAULT_CHANNEL;
2139 +            int _type = T__33;
2140 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2141              // Bst.g:11:7: ( '*' )
2142 -            // Bst.g:11:7: '*'
2143 +            // Bst.g:11:9: '*'
2144              {
2145              match('*');
2146
2147              }
2148
2149 -
2150 -
2151 -                    if ( token==null && ruleNestingLevel==1 ) {
2152 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2153 -                    }
2154 -
2155 -                        }
2156 +            state.type = _type;
2157 +            state.channel = _channel;
2158 +        }
2159          finally {
2160 -            ruleNestingLevel--;
2161          }
2162      }
2163 -    // $ANTLR end T33
2164 +    // $ANTLR end "T__33"
2165
2166 -    // $ANTLR start STRINGS
2167 -    public void mSTRINGS() throws RecognitionException {
2168 +    // $ANTLR start "STRINGS"
2169 +    public final void mSTRINGS() throws RecognitionException {
2170          try {
2171 -            ruleNestingLevel++;
2172              int _type = STRINGS;
2173 -            int _start = getCharIndex();
2174 -            int _line = getLine();
2175 -            int _charPosition = getCharPositionInLine();
2176 -            int _channel = Token.DEFAULT_CHANNEL;
2177 -            // Bst.g:53:11: ( 'STRINGS' )
2178 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2179 +            // Bst.g:53:9: ( 'STRINGS' )
2180              // Bst.g:53:11: 'STRINGS'
2181              {
2182              match("STRINGS");
2183 @@ -330,29 +247,20 @@
2184
2185              }
2186
2187 -
2188 -
2189 -                    if ( token==null && ruleNestingLevel==1 ) {
2190 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2191 -                    }
2192 -
2193 -                        }
2194 +            state.type = _type;
2195 +            state.channel = _channel;
2196 +        }
2197          finally {
2198 -            ruleNestingLevel--;
2199          }
2200      }
2201 -    // $ANTLR end STRINGS
2202 +    // $ANTLR end "STRINGS"
2203
2204 -    // $ANTLR start INTEGERS
2205 -    public void mINTEGERS() throws RecognitionException {
2206 +    // $ANTLR start "INTEGERS"
2207 +    public final void mINTEGERS() throws RecognitionException {
2208          try {
2209 -            ruleNestingLevel++;
2210              int _type = INTEGERS;
2211 -            int _start = getCharIndex();
2212 -            int _line = getLine();
2213 -            int _charPosition = getCharPositionInLine();
2214 -            int _channel = Token.DEFAULT_CHANNEL;
2215 -            // Bst.g:54:12: ( 'INTEGERS' )
2216 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2217 +            // Bst.g:54:10: ( 'INTEGERS' )
2218              // Bst.g:54:12: 'INTEGERS'
2219              {
2220              match("INTEGERS");
2221 @@ -360,29 +268,20 @@
2222
2223              }
2224
2225 -
2226 -
2227 -                    if ( token==null && ruleNestingLevel==1 ) {
2228 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2229 -                    }
2230 -
2231 -                        }
2232 +            state.type = _type;
2233 +            state.channel = _channel;
2234 +        }
2235          finally {
2236 -            ruleNestingLevel--;
2237          }
2238      }
2239 -    // $ANTLR end INTEGERS
2240 +    // $ANTLR end "INTEGERS"
2241
2242 -    // $ANTLR start FUNCTION
2243 -    public void mFUNCTION() throws RecognitionException {
2244 +    // $ANTLR start "FUNCTION"
2245 +    public final void mFUNCTION() throws RecognitionException {
2246          try {
2247 -            ruleNestingLevel++;
2248              int _type = FUNCTION;
2249 -            int _start = getCharIndex();
2250 -            int _line = getLine();
2251 -            int _charPosition = getCharPositionInLine();
2252 -            int _channel = Token.DEFAULT_CHANNEL;
2253 -            // Bst.g:55:12: ( 'FUNCTION' )
2254 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2255 +            // Bst.g:55:10: ( 'FUNCTION' )
2256              // Bst.g:55:12: 'FUNCTION'
2257              {
2258              match("FUNCTION");
2259 @@ -390,29 +289,20 @@
2260
2261              }
2262
2263 -
2264 -
2265 -                    if ( token==null && ruleNestingLevel==1 ) {
2266 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2267 -                    }
2268 -
2269 -                        }
2270 +            state.type = _type;
2271 +            state.channel = _channel;
2272 +        }
2273          finally {
2274 -            ruleNestingLevel--;
2275          }
2276      }
2277 -    // $ANTLR end FUNCTION
2278 +    // $ANTLR end "FUNCTION"
2279
2280 -    // $ANTLR start EXECUTE
2281 -    public void mEXECUTE() throws RecognitionException {
2282 +    // $ANTLR start "EXECUTE"
2283 +    public final void mEXECUTE() throws RecognitionException {
2284          try {
2285 -            ruleNestingLevel++;
2286              int _type = EXECUTE;
2287 -            int _start = getCharIndex();
2288 -            int _line = getLine();
2289 -            int _charPosition = getCharPositionInLine();
2290 -            int _channel = Token.DEFAULT_CHANNEL;
2291 -            // Bst.g:56:11: ( 'EXECUTE' )
2292 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2293 +            // Bst.g:56:9: ( 'EXECUTE' )
2294              // Bst.g:56:11: 'EXECUTE'
2295              {
2296              match("EXECUTE");
2297 @@ -420,29 +310,20 @@
2298
2299              }
2300
2301 -
2302 -
2303 -                    if ( token==null && ruleNestingLevel==1 ) {
2304 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2305 -                    }
2306 -
2307 -                        }
2308 +            state.type = _type;
2309 +            state.channel = _channel;
2310 +        }
2311          finally {
2312 -            ruleNestingLevel--;
2313          }
2314      }
2315 -    // $ANTLR end EXECUTE
2316 +    // $ANTLR end "EXECUTE"
2317
2318 -    // $ANTLR start SORT
2319 -    public void mSORT() throws RecognitionException {
2320 +    // $ANTLR start "SORT"
2321 +    public final void mSORT() throws RecognitionException {
2322          try {
2323 -            ruleNestingLevel++;
2324              int _type = SORT;
2325 -            int _start = getCharIndex();
2326 -            int _line = getLine();
2327 -            int _charPosition = getCharPositionInLine();
2328 -            int _channel = Token.DEFAULT_CHANNEL;
2329 -            // Bst.g:57:8: ( 'SORT' )
2330 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2331 +            // Bst.g:57:6: ( 'SORT' )
2332              // Bst.g:57:8: 'SORT'
2333              {
2334              match("SORT");
2335 @@ -450,29 +331,20 @@
2336
2337              }
2338
2339 -
2340 -
2341 -                    if ( token==null && ruleNestingLevel==1 ) {
2342 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2343 -                    }
2344 -
2345 -                        }
2346 +            state.type = _type;
2347 +            state.channel = _channel;
2348 +        }
2349          finally {
2350 -            ruleNestingLevel--;
2351          }
2352      }
2353 -    // $ANTLR end SORT
2354 +    // $ANTLR end "SORT"
2355
2356 -    // $ANTLR start ITERATE
2357 -    public void mITERATE() throws RecognitionException {
2358 +    // $ANTLR start "ITERATE"
2359 +    public final void mITERATE() throws RecognitionException {
2360          try {
2361 -            ruleNestingLevel++;
2362              int _type = ITERATE;
2363 -            int _start = getCharIndex();
2364 -            int _line = getLine();
2365 -            int _charPosition = getCharPositionInLine();
2366 -            int _channel = Token.DEFAULT_CHANNEL;
2367 -            // Bst.g:58:11: ( 'ITERATE' )
2368 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2369 +            // Bst.g:58:9: ( 'ITERATE' )
2370              // Bst.g:58:11: 'ITERATE'
2371              {
2372              match("ITERATE");
2373 @@ -480,29 +352,20 @@
2374
2375              }
2376
2377 -
2378 -
2379 -                    if ( token==null && ruleNestingLevel==1 ) {
2380 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2381 -                    }
2382 -
2383 -                        }
2384 +            state.type = _type;
2385 +            state.channel = _channel;
2386 +        }
2387          finally {
2388 -            ruleNestingLevel--;
2389          }
2390      }
2391 -    // $ANTLR end ITERATE
2392 +    // $ANTLR end "ITERATE"
2393
2394 -    // $ANTLR start REVERSE
2395 -    public void mREVERSE() throws RecognitionException {
2396 +    // $ANTLR start "REVERSE"
2397 +    public final void mREVERSE() throws RecognitionException {
2398          try {
2399 -            ruleNestingLevel++;
2400              int _type = REVERSE;
2401 -            int _start = getCharIndex();
2402 -            int _line = getLine();
2403 -            int _charPosition = getCharPositionInLine();
2404 -            int _channel = Token.DEFAULT_CHANNEL;
2405 -            // Bst.g:59:11: ( 'REVERSE' )
2406 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2407 +            // Bst.g:59:9: ( 'REVERSE' )
2408              // Bst.g:59:11: 'REVERSE'
2409              {
2410              match("REVERSE");
2411 @@ -510,29 +373,20 @@
2412
2413              }
2414
2415 -
2416 -
2417 -                    if ( token==null && ruleNestingLevel==1 ) {
2418 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2419 -                    }
2420 -
2421 -                        }
2422 +            state.type = _type;
2423 +            state.channel = _channel;
2424 +        }
2425          finally {
2426 -            ruleNestingLevel--;
2427          }
2428      }
2429 -    // $ANTLR end REVERSE
2430 +    // $ANTLR end "REVERSE"
2431
2432 -    // $ANTLR start ENTRY
2433 -    public void mENTRY() throws RecognitionException {
2434 +    // $ANTLR start "ENTRY"
2435 +    public final void mENTRY() throws RecognitionException {
2436          try {
2437 -            ruleNestingLevel++;
2438              int _type = ENTRY;
2439 -            int _start = getCharIndex();
2440 -            int _line = getLine();
2441 -            int _charPosition = getCharPositionInLine();
2442 -            int _channel = Token.DEFAULT_CHANNEL;
2443 -            // Bst.g:60:9: ( 'ENTRY' )
2444 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2445 +            // Bst.g:60:7: ( 'ENTRY' )
2446              // Bst.g:60:9: 'ENTRY'
2447              {
2448              match("ENTRY");
2449 @@ -540,29 +394,20 @@
2450
2451              }
2452
2453 -
2454 -
2455 -                    if ( token==null && ruleNestingLevel==1 ) {
2456 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2457 -                    }
2458 -
2459 -                        }
2460 +            state.type = _type;
2461 +            state.channel = _channel;
2462 +        }
2463          finally {
2464 -            ruleNestingLevel--;
2465          }
2466      }
2467 -    // $ANTLR end ENTRY
2468 +    // $ANTLR end "ENTRY"
2469
2470 -    // $ANTLR start READ
2471 -    public void mREAD() throws RecognitionException {
2472 +    // $ANTLR start "READ"
2473 +    public final void mREAD() throws RecognitionException {
2474          try {
2475 -            ruleNestingLevel++;
2476              int _type = READ;
2477 -            int _start = getCharIndex();
2478 -            int _line = getLine();
2479 -            int _charPosition = getCharPositionInLine();
2480 -            int _channel = Token.DEFAULT_CHANNEL;
2481 -            // Bst.g:61:8: ( 'READ' )
2482 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2483 +            // Bst.g:61:6: ( 'READ' )
2484              // Bst.g:61:8: 'READ'
2485              {
2486              match("READ");
2487 @@ -570,29 +415,20 @@
2488
2489              }
2490
2491 -
2492 -
2493 -                    if ( token==null && ruleNestingLevel==1 ) {
2494 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2495 -                    }
2496 -
2497 -                        }
2498 +            state.type = _type;
2499 +            state.channel = _channel;
2500 +        }
2501          finally {
2502 -            ruleNestingLevel--;
2503          }
2504      }
2505 -    // $ANTLR end READ
2506 +    // $ANTLR end "READ"
2507
2508 -    // $ANTLR start MACRO
2509 -    public void mMACRO() throws RecognitionException {
2510 +    // $ANTLR start "MACRO"
2511 +    public final void mMACRO() throws RecognitionException {
2512          try {
2513 -            ruleNestingLevel++;
2514              int _type = MACRO;
2515 -            int _start = getCharIndex();
2516 -            int _line = getLine();
2517 -            int _charPosition = getCharPositionInLine();
2518 -            int _channel = Token.DEFAULT_CHANNEL;
2519 -            // Bst.g:62:9: ( 'MACRO' )
2520 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2521 +            // Bst.g:62:7: ( 'MACRO' )
2522              // Bst.g:62:9: 'MACRO'
2523              {
2524              match("MACRO");
2525 @@ -600,29 +436,20 @@
2526
2527              }
2528
2529 -
2530 -
2531 -                    if ( token==null && ruleNestingLevel==1 ) {
2532 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2533 -                    }
2534 -
2535 -                        }
2536 +            state.type = _type;
2537 +            state.channel = _channel;
2538 +        }
2539          finally {
2540 -            ruleNestingLevel--;
2541          }
2542      }
2543 -    // $ANTLR end MACRO
2544 +    // $ANTLR end "MACRO"
2545
2546 -    // $ANTLR start QUOTED
2547 -    public void mQUOTED() throws RecognitionException {
2548 +    // $ANTLR start "QUOTED"
2549 +    public final void mQUOTED() throws RecognitionException {
2550          try {
2551 -            ruleNestingLevel++;
2552              int _type = QUOTED;
2553 -            int _start = getCharIndex();
2554 -            int _line = getLine();
2555 -            int _charPosition = getCharPositionInLine();
2556 -            int _channel = Token.DEFAULT_CHANNEL;
2557 -            // Bst.g:65:4: ( '\\'' IDENTIFIER )
2558 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2559 +            // Bst.g:65:2: ( '\\'' IDENTIFIER )
2560              // Bst.g:65:4: '\\'' IDENTIFIER
2561              {
2562              match('\'');
2563 @@ -630,29 +457,20 @@
2564
2565              }
2566
2567 -
2568 -
2569 -                    if ( token==null && ruleNestingLevel==1 ) {
2570 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2571 -                    }
2572 -
2573 -                        }
2574 +            state.type = _type;
2575 +            state.channel = _channel;
2576 +        }
2577          finally {
2578 -            ruleNestingLevel--;
2579          }
2580      }
2581 -    // $ANTLR end QUOTED
2582 +    // $ANTLR end "QUOTED"
2583
2584 -    // $ANTLR start IDENTIFIER
2585 -    public void mIDENTIFIER() throws RecognitionException {
2586 +    // $ANTLR start "IDENTIFIER"
2587 +    public final void mIDENTIFIER() throws RecognitionException {
2588          try {
2589 -            ruleNestingLevel++;
2590              int _type = IDENTIFIER;
2591 -            int _start = getCharIndex();
2592 -            int _line = getLine();
2593 -            int _charPosition = getCharPositionInLine();
2594 -            int _channel = Token.DEFAULT_CHANNEL;
2595 -            // Bst.g:68:4: ( LETTER ( LETTER | NUMERAL )* )
2596 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2597 +            // Bst.g:68:2: ( LETTER ( LETTER | NUMERAL )* )
2598              // Bst.g:68:4: LETTER ( LETTER | NUMERAL )*
2599              {
2600              mLETTER();
2601 @@ -661,6 +479,7 @@
2602              do {
2603                  int alt1=3;
2604                  int LA1_0 = input.LA(1);
2605 +
2606                  if ( (LA1_0=='$'||LA1_0=='.'||(LA1_0>='A' && LA1_0<='Z')||(LA1_0>='a' && LA1_0<='z')) ) {
2607                      alt1=1;
2608                  }
2609 @@ -693,82 +512,70 @@
2610
2611              }
2612
2613 -
2614 -
2615 -                    if ( token==null && ruleNestingLevel==1 ) {
2616 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2617 -                    }
2618 -
2619 -                        }
2620 +            state.type = _type;
2621 +            state.channel = _channel;
2622 +        }
2623          finally {
2624 -            ruleNestingLevel--;
2625          }
2626      }
2627 -    // $ANTLR end IDENTIFIER
2628 +    // $ANTLR end "IDENTIFIER"
2629
2630 -    // $ANTLR start LETTER
2631 -    public void mLETTER() throws RecognitionException {
2632 +    // $ANTLR start "LETTER"
2633 +    public final void mLETTER() throws RecognitionException {
2634          try {
2635 -            ruleNestingLevel++;
2636 -            // Bst.g:71:4: ( ('a'..'z'|'A'..'Z'|'.'|'$'))
2637 -            // Bst.g:71:4: ('a'..'z'|'A'..'Z'|'.'|'$')
2638 +            // Bst.g:71:2: ( ( 'a' .. 'z' | 'A' .. 'Z' | '.' | '$' ) )
2639 +            // Bst.g:71:4: ( 'a' .. 'z' | 'A' .. 'Z' | '.' | '$' )
2640              {
2641              if ( input.LA(1)=='$'||input.LA(1)=='.'||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
2642                  input.consume();
2643
2644              }
2645              else {
2646 -                MismatchedSetException mse =
2647 -                    new MismatchedSetException(null,input);
2648 -                recover(mse);    throw mse;
2649 -            }
2650 +                MismatchedSetException mse = new MismatchedSetException(null,input);
2651 +                recover(mse);
2652 +                throw mse;}
2653
2654
2655              }
2656
2657          }
2658          finally {
2659 -            ruleNestingLevel--;
2660          }
2661      }
2662 -    // $ANTLR end LETTER
2663 +    // $ANTLR end "LETTER"
2664
2665 -    // $ANTLR start STRING
2666 -    public void mSTRING() throws RecognitionException {
2667 +    // $ANTLR start "STRING"
2668 +    public final void mSTRING() throws RecognitionException {
2669          try {
2670 -            ruleNestingLevel++;
2671              int _type = STRING;
2672 -            int _start = getCharIndex();
2673 -            int _line = getLine();
2674 -            int _charPosition = getCharPositionInLine();
2675 -            int _channel = Token.DEFAULT_CHANNEL;
2676 -            // Bst.g:74:4: ( '\"' (~ '\"' )* '\"' )
2677 -            // Bst.g:74:4: '\"' (~ '\"' )* '\"'
2678 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2679 +            // Bst.g:74:2: ( '\"' (~ ( '\"' ) )* '\"' )
2680 +            // Bst.g:74:4: '\"' (~ ( '\"' ) )* '\"'
2681              {
2682              match('\"');
2683 -            // Bst.g:74:8: (~ '\"' )*
2684 +            // Bst.g:74:8: (~ ( '\"' ) )*
2685              loop2:
2686              do {
2687                  int alt2=2;
2688                  int LA2_0 = input.LA(1);
2689 -                if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='\uFFFE')) ) {
2690 +
2691 +                if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='\uFFFF')) ) {
2692                      alt2=1;
2693                  }
2694
2695
2696                  switch (alt2) {
2697                 case 1 :
2698 -                   // Bst.g:74:9: ~ '\"'
2699 +                   // Bst.g:74:9: ~ ( '\"' )
2700                     {
2701 -                   if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFE') ) {
2702 +                   if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
2703                         input.consume();
2704
2705                     }
2706                     else {
2707 -                       MismatchedSetException mse =
2708 -                           new MismatchedSetException(null,input);
2709 -                       recover(mse);    throw mse;
2710 -                   }
2711 +                       MismatchedSetException mse = new MismatchedSetException(null,input);
2712 +                       recover(mse);
2713 +                       throw mse;}
2714
2715
2716                     }
2717 @@ -783,51 +590,42 @@
2718
2719              }
2720
2721 -
2722 -
2723 -                    if ( token==null && ruleNestingLevel==1 ) {
2724 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2725 -                    }
2726 -
2727 -                        }
2728 +            state.type = _type;
2729 +            state.channel = _channel;
2730 +        }
2731          finally {
2732 -            ruleNestingLevel--;
2733          }
2734      }
2735 -    // $ANTLR end STRING
2736 +    // $ANTLR end "STRING"
2737
2738 -    // $ANTLR start INTEGER
2739 -    public void mINTEGER() throws RecognitionException {
2740 +    // $ANTLR start "INTEGER"
2741 +    public final void mINTEGER() throws RecognitionException {
2742          try {
2743 -            ruleNestingLevel++;
2744              int _type = INTEGER;
2745 -            int _start = getCharIndex();
2746 -            int _line = getLine();
2747 -            int _charPosition = getCharPositionInLine();
2748 -            int _channel = Token.DEFAULT_CHANNEL;
2749 -            // Bst.g:77:4: ( '#' ( ('+'|'-'))? ( NUMERAL )+ )
2750 -            // Bst.g:77:4: '#' ( ('+'|'-'))? ( NUMERAL )+
2751 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2752 +            // Bst.g:77:2: ( '#' ( '+' | '-' )? ( NUMERAL )+ )
2753 +            // Bst.g:77:4: '#' ( '+' | '-' )? ( NUMERAL )+
2754              {
2755              match('#');
2756 -            // Bst.g:77:8: ( ('+'|'-'))?
2757 +            // Bst.g:77:8: ( '+' | '-' )?
2758              int alt3=2;
2759              int LA3_0 = input.LA(1);
2760 +
2761              if ( (LA3_0=='+'||LA3_0=='-') ) {
2762                  alt3=1;
2763              }
2764              switch (alt3) {
2765                  case 1 :
2766 -                    // Bst.g:77:9: ('+'|'-')
2767 +                    // Bst.g:
2768                      {
2769                      if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
2770                          input.consume();
2771
2772                      }
2773                      else {
2774 -                        MismatchedSetException mse =
2775 -                            new MismatchedSetException(null,input);
2776 -                        recover(mse);    throw mse;
2777 -                    }
2778 +                        MismatchedSetException mse = new MismatchedSetException(null,input);
2779 +                        recover(mse);
2780 +                        throw mse;}
2781
2782
2783                      }
2784 @@ -841,6 +639,7 @@
2785              do {
2786                  int alt4=2;
2787                  int LA4_0 = input.LA(1);
2788 +
2789                  if ( ((LA4_0>='0' && LA4_0<='9')) ) {
2790                      alt4=1;
2791                  }
2792 @@ -867,24 +666,18 @@
2793
2794              }
2795
2796 -
2797 -
2798 -                    if ( token==null && ruleNestingLevel==1 ) {
2799 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2800 -                    }
2801 -
2802 -                        }
2803 +            state.type = _type;
2804 +            state.channel = _channel;
2805 +        }
2806          finally {
2807 -            ruleNestingLevel--;
2808          }
2809      }
2810 -    // $ANTLR end INTEGER
2811 +    // $ANTLR end "INTEGER"
2812
2813 -    // $ANTLR start NUMERAL
2814 -    public void mNUMERAL() throws RecognitionException {
2815 +    // $ANTLR start "NUMERAL"
2816 +    public final void mNUMERAL() throws RecognitionException {
2817          try {
2818 -            ruleNestingLevel++;
2819 -            // Bst.g:80:4: ( ( '0' .. '9' ) )
2820 +            // Bst.g:80:2: ( ( '0' .. '9' ) )
2821              // Bst.g:80:4: ( '0' .. '9' )
2822              {
2823              // Bst.g:80:4: ( '0' .. '9' )
2824 @@ -899,47 +692,42 @@
2825
2826          }
2827          finally {
2828 -            ruleNestingLevel--;
2829          }
2830      }
2831 -    // $ANTLR end NUMERAL
2832 +    // $ANTLR end "NUMERAL"
2833
2834 -    // $ANTLR start WS
2835 -    public void mWS() throws RecognitionException {
2836 +    // $ANTLR start "WS"
2837 +    public final void mWS() throws RecognitionException {
2838          try {
2839 -            ruleNestingLevel++;
2840              int _type = WS;
2841 -            int _start = getCharIndex();
2842 -            int _line = getLine();
2843 -            int _charPosition = getCharPositionInLine();
2844 -            int _channel = Token.DEFAULT_CHANNEL;
2845 -            // Bst.g:82:9: ( ( (' '|'\\t'|'\\r'|'\\n'))+ )
2846 -            // Bst.g:82:9: ( (' '|'\\t'|'\\r'|'\\n'))+
2847 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2848 +            // Bst.g:83:2: ( ( ' ' | '\\t' | '\\n' )+ )
2849 +            // Bst.g:83:4: ( ' ' | '\\t' | '\\n' )+
2850              {
2851 -            // Bst.g:82:9: ( (' '|'\\t'|'\\r'|'\\n'))+
2852 +            // Bst.g:83:4: ( ' ' | '\\t' | '\\n' )+
2853              int cnt5=0;
2854              loop5:
2855              do {
2856                  int alt5=2;
2857                  int LA5_0 = input.LA(1);
2858 -                if ( ((LA5_0>='\t' && LA5_0<='\n')||LA5_0=='\r'||LA5_0==' ') ) {
2859 +
2860 +                if ( ((LA5_0>='\t' && LA5_0<='\n')||LA5_0==' ') ) {
2861                      alt5=1;
2862                  }
2863
2864
2865                  switch (alt5) {
2866                 case 1 :
2867 -                   // Bst.g:82:13: (' '|'\\t'|'\\r'|'\\n')
2868 +                   // Bst.g:
2869                     {
2870 -                   if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
2871 +                   if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)==' ' ) {
2872                         input.consume();
2873
2874                     }
2875                     else {
2876 -                       MismatchedSetException mse =
2877 -                           new MismatchedSetException(null,input);
2878 -                       recover(mse);    throw mse;
2879 -                   }
2880 +                       MismatchedSetException mse = new MismatchedSetException(null,input);
2881 +                       recover(mse);
2882 +                       throw mse;}
2883
2884
2885                     }
2886 @@ -954,59 +742,50 @@
2887                  cnt5++;
2888              } while (true);
2889
2890 -             _channel=HIDDEN;
2891 +            _channel=99;
2892
2893              }
2894
2895 -
2896 -
2897 -                    if ( token==null && ruleNestingLevel==1 ) {
2898 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2899 -                    }
2900 -
2901 -                        }
2902 +            state.type = _type;
2903 +            state.channel = _channel;
2904 +        }
2905          finally {
2906 -            ruleNestingLevel--;
2907          }
2908      }
2909 -    // $ANTLR end WS
2910 +    // $ANTLR end "WS"
2911
2912 -    // $ANTLR start LINE_COMMENT
2913 -    public void mLINE_COMMENT() throws RecognitionException {
2914 +    // $ANTLR start "LINE_COMMENT"
2915 +    public final void mLINE_COMMENT() throws RecognitionException {
2916          try {
2917 -            ruleNestingLevel++;
2918              int _type = LINE_COMMENT;
2919 -            int _start = getCharIndex();
2920 -            int _line = getLine();
2921 -            int _charPosition = getCharPositionInLine();
2922 -            int _channel = Token.DEFAULT_CHANNEL;
2923 -            // Bst.g:90:7: ( '%' (~ ('\\n'|'\\r'))* ( '\\r' )? '\\n' )
2924 -            // Bst.g:90:7: '%' (~ ('\\n'|'\\r'))* ( '\\r' )? '\\n'
2925 +            int _channel = DEFAULT_TOKEN_CHANNEL;
2926 +            // Bst.g:86:5: ( '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
2927 +            // Bst.g:86:7: '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
2928              {
2929              match('%');
2930 -            // Bst.g:90:11: (~ ('\\n'|'\\r'))*
2931 +            // Bst.g:86:11: (~ ( '\\n' | '\\r' ) )*
2932              loop6:
2933              do {
2934                  int alt6=2;
2935                  int LA6_0 = input.LA(1);
2936 -                if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFE')) ) {
2937 +
2938 +                if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) {
2939                      alt6=1;
2940                  }
2941
2942
2943                  switch (alt6) {
2944                 case 1 :
2945 -                   // Bst.g:90:11: ~ ('\\n'|'\\r')
2946 +                   // Bst.g:86:11: ~ ( '\\n' | '\\r' )
2947                     {
2948 -                   if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFE') ) {
2949 +                   if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
2950                         input.consume();
2951
2952                     }
2953                     else {
2954 -                       MismatchedSetException mse =
2955 -                           new MismatchedSetException(null,input);
2956 -                       recover(mse);    throw mse;
2957 -                   }
2958 +                       MismatchedSetException mse = new MismatchedSetException(null,input);
2959 +                       recover(mse);
2960 +                       throw mse;}
2961
2962
2963                     }
2964 @@ -1017,15 +796,16 @@
2965                  }
2966              } while (true);
2967
2968 -            // Bst.g:90:25: ( '\\r' )?
2969 +            // Bst.g:86:25: ( '\\r' )?
2970              int alt7=2;
2971              int LA7_0 = input.LA(1);
2972 +
2973              if ( (LA7_0=='\r') ) {
2974                  alt7=1;
2975              }
2976              switch (alt7) {
2977                  case 1 :
2978 -                    // Bst.g:90:25: '\\r'
2979 +                    // Bst.g:86:25: '\\r'
2980                      {
2981                      match('\r');
2982
2983 @@ -1035,619 +815,193 @@
2984              }
2985
2986              match('\n');
2987 -             _channel=HIDDEN;
2988 +            _channel=99;
2989
2990              }
2991
2992 -
2993 -
2994 -                    if ( token==null && ruleNestingLevel==1 ) {
2995 -                        emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1);
2996 -                    }
2997 -
2998 -                        }
2999 +            state.type = _type;
3000 +            state.channel = _channel;
3001 +        }
3002          finally {
3003 -            ruleNestingLevel--;
3004          }
3005      }
3006 -    // $ANTLR end LINE_COMMENT
3007 +    // $ANTLR end "LINE_COMMENT"
3008
3009      public void mTokens() throws RecognitionException {
3010 -        // Bst.g:1:10: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | STRINGS | INTEGERS | FUNCTION | EXECUTE | SORT | ITERATE | REVERSE | ENTRY | READ | MACRO | QUOTED | IDENTIFIER | STRING | INTEGER | WS | LINE_COMMENT )
3011 +        // Bst.g:1:8: ( T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | STRINGS | INTEGERS | FUNCTION | EXECUTE | SORT | ITERATE | REVERSE | ENTRY | READ | MACRO | QUOTED | IDENTIFIER | STRING | INTEGER | WS | LINE_COMMENT )
3012          int alt8=25;
3013 -        switch ( input.LA(1) ) {
3014 -        case '{':
3015 -            alt8=1;
3016 -            break;
3017 -        case '}':
3018 -            alt8=2;
3019 -            break;
3020 -        case '<':
3021 -            alt8=3;
3022 -            break;
3023 -        case '>':
3024 -            alt8=4;
3025 -            break;
3026 -        case '=':
3027 -            alt8=5;
3028 -            break;
3029 -        case '+':
3030 -            alt8=6;
3031 -            break;
3032 -        case '-':
3033 -            alt8=7;
3034 -            break;
3035 -        case ':':
3036 -            alt8=8;
3037 -            break;
3038 -        case '*':
3039 -            alt8=9;
3040 -            break;
3041 -        case 'S':
3042 -            switch ( input.LA(2) ) {
3043 -            case 'T':
3044 -                int LA8_22 = input.LA(3);
3045 -                if ( (LA8_22=='R') ) {
3046 -                    int LA8_31 = input.LA(4);
3047 -                    if ( (LA8_31=='I') ) {
3048 -                        int LA8_41 = input.LA(5);
3049 -                        if ( (LA8_41=='N') ) {
3050 -                            int LA8_51 = input.LA(6);
3051 -                            if ( (LA8_51=='G') ) {
3052 -                                int LA8_61 = input.LA(7);
3053 -                                if ( (LA8_61=='S') ) {
3054 -                                    int LA8_69 = input.LA(8);
3055 -                                    if ( (LA8_69=='$'||LA8_69=='.'||(LA8_69>='0' && LA8_69<='9')||(LA8_69>='A' && LA8_69<='Z')||(LA8_69>='a' && LA8_69<='z')) ) {
3056 -                                        alt8=21;
3057 -                                    }
3058 -                                    else {
3059 -                                        alt8=10;}
3060 -                                }
3061 -                                else {
3062 -                                    alt8=21;}
3063 -                            }
3064 -                            else {
3065 -                                alt8=21;}
3066 -                        }
3067 -                        else {
3068 -                            alt8=21;}
3069 -                    }
3070 -                    else {
3071 -                        alt8=21;}
3072 -                }
3073 -                else {
3074 -                    alt8=21;}
3075 -                break;
3076 -            case 'O':
3077 -                int LA8_23 = input.LA(3);
3078 -                if ( (LA8_23=='R') ) {
3079 -                    int LA8_32 = input.LA(4);
3080 -                    if ( (LA8_32=='T') ) {
3081 -                        int LA8_42 = input.LA(5);
3082 -                        if ( (LA8_42=='$'||LA8_42=='.'||(LA8_42>='0' && LA8_42<='9')||(LA8_42>='A' && LA8_42<='Z')||(LA8_42>='a' && LA8_42<='z')) ) {
3083 -                            alt8=21;
3084 -                        }
3085 -                        else {
3086 -                            alt8=14;}
3087 -                    }
3088 -                    else {
3089 -                        alt8=21;}
3090 -                }
3091 -                else {
3092 -                    alt8=21;}
3093 -                break;
3094 -            default:
3095 -                alt8=21;}
3096 -
3097 -            break;
3098 -        case 'I':
3099 -            switch ( input.LA(2) ) {
3100 -            case 'T':
3101 -                int LA8_24 = input.LA(3);
3102 -                if ( (LA8_24=='E') ) {
3103 -                    int LA8_33 = input.LA(4);
3104 -                    if ( (LA8_33=='R') ) {
3105 -                        int LA8_43 = input.LA(5);
3106 -                        if ( (LA8_43=='A') ) {
3107 -                            int LA8_53 = input.LA(6);
3108 -                            if ( (LA8_53=='T') ) {
3109 -                                int LA8_62 = input.LA(7);
3110 -                                if ( (LA8_62=='E') ) {
3111 -                                    int LA8_70 = input.LA(8);
3112 -                                    if ( (LA8_70=='$'||LA8_70=='.'||(LA8_70>='0' && LA8_70<='9')||(LA8_70>='A' && LA8_70<='Z')||(LA8_70>='a' && LA8_70<='z')) ) {
3113 -                                        alt8=21;
3114 -                                    }
3115 -                                    else {
3116 -                                        alt8=15;}
3117 -                                }
3118 -                                else {
3119 -                                    alt8=21;}
3120 -                            }
3121 -                            else {
3122 -                                alt8=21;}
3123 -                        }
3124 -                        else {
3125 -                            alt8=21;}
3126 -                    }
3127 -                    else {
3128 -                        alt8=21;}
3129 -                }
3130 -                else {
3131 -                    alt8=21;}
3132 -                break;
3133 -            case 'N':
3134 -                int LA8_25 = input.LA(3);
3135 -                if ( (LA8_25=='T') ) {
3136 -                    int LA8_34 = input.LA(4);
3137 -                    if ( (LA8_34=='E') ) {
3138 -                        int LA8_44 = input.LA(5);
3139 -                        if ( (LA8_44=='G') ) {
3140 -                            int LA8_54 = input.LA(6);
3141 -                            if ( (LA8_54=='E') ) {
3142 -                                int LA8_63 = input.LA(7);
3143 -                                if ( (LA8_63=='R') ) {
3144 -                                    int LA8_71 = input.LA(8);
3145 -                                    if ( (LA8_71=='S') ) {
3146 -                                        int LA8_77 = input.LA(9);
3147 -                                        if ( (LA8_77=='$'||LA8_77=='.'||(LA8_77>='0' && LA8_77<='9')||(LA8_77>='A' && LA8_77<='Z')||(LA8_77>='a' && LA8_77<='z')) ) {
3148 -                                            alt8=21;
3149 -                                        }
3150 -                                        else {
3151 -                                            alt8=11;}
3152 -                                    }
3153 -                                    else {
3154 -                                        alt8=21;}
3155 -                                }
3156 -                                else {
3157 -                                    alt8=21;}
3158 -                            }
3159 -                            else {
3160 -                                alt8=21;}
3161 -                        }
3162 -                        else {
3163 -                            alt8=21;}
3164 -                    }
3165 -                    else {
3166 -                        alt8=21;}
3167 -                }
3168 -                else {
3169 -                    alt8=21;}
3170 -                break;
3171 -            default:
3172 -                alt8=21;}
3173 -
3174 -            break;
3175 -        case 'F':
3176 -            int LA8_12 = input.LA(2);
3177 -            if ( (LA8_12=='U') ) {
3178 -                int LA8_26 = input.LA(3);
3179 -                if ( (LA8_26=='N') ) {
3180 -                    int LA8_35 = input.LA(4);
3181 -                    if ( (LA8_35=='C') ) {
3182 -                        int LA8_45 = input.LA(5);
3183 -                        if ( (LA8_45=='T') ) {
3184 -                            int LA8_55 = input.LA(6);
3185 -                            if ( (LA8_55=='I') ) {
3186 -                                int LA8_64 = input.LA(7);
3187 -                                if ( (LA8_64=='O') ) {
3188 -                                    int LA8_72 = input.LA(8);
3189 -                                    if ( (LA8_72=='N') ) {
3190 -                                        int LA8_78 = input.LA(9);
3191 -                                        if ( (LA8_78=='$'||LA8_78=='.'||(LA8_78>='0' && LA8_78<='9')||(LA8_78>='A' && LA8_78<='Z')||(LA8_78>='a' && LA8_78<='z')) ) {
3192 -                                            alt8=21;
3193 -                                        }
3194 -                                        else {
3195 -                                            alt8=12;}
3196 -                                    }
3197 -                                    else {
3198 -                                        alt8=21;}
3199 -                                }
3200 -                                else {
3201 -                                    alt8=21;}
3202 -                            }
3203 -                            else {
3204 -                                alt8=21;}
3205 -                        }
3206 -                        else {
3207 -                            alt8=21;}
3208 -                    }
3209 -                    else {
3210 -                        alt8=21;}
3211 -                }
3212 -                else {
3213 -                    alt8=21;}
3214 -            }
3215 -            else {
3216 -                alt8=21;}
3217 -            break;
3218 -        case 'E':
3219 -            switch ( input.LA(2) ) {
3220 -            case 'N':
3221 -                int LA8_27 = input.LA(3);
3222 -                if ( (LA8_27=='T') ) {
3223 -                    int LA8_36 = input.LA(4);
3224 -                    if ( (LA8_36=='R') ) {
3225 -                        int LA8_46 = input.LA(5);
3226 -                        if ( (LA8_46=='Y') ) {
3227 -                            int LA8_56 = input.LA(6);
3228 -                            if ( (LA8_56=='$'||LA8_56=='.'||(LA8_56>='0' && LA8_56<='9')||(LA8_56>='A' && LA8_56<='Z')||(LA8_56>='a' && LA8_56<='z')) ) {
3229 -                                alt8=21;
3230 -                            }
3231 -                            else {
3232 -                                alt8=17;}
3233 -                        }
3234 -                        else {
3235 -                            alt8=21;}
3236 -                    }
3237 -                    else {
3238 -                        alt8=21;}
3239 -                }
3240 -                else {
3241 -                    alt8=21;}
3242 -                break;
3243 -            case 'X':
3244 -                int LA8_28 = input.LA(3);
3245 -                if ( (LA8_28=='E') ) {
3246 -                    int LA8_37 = input.LA(4);
3247 -                    if ( (LA8_37=='C') ) {
3248 -                        int LA8_47 = input.LA(5);
3249 -                        if ( (LA8_47=='U') ) {
3250 -                            int LA8_57 = input.LA(6);
3251 -                            if ( (LA8_57=='T') ) {
3252 -                                int LA8_66 = input.LA(7);
3253 -                                if ( (LA8_66=='E') ) {
3254 -                                    int LA8_73 = input.LA(8);
3255 -                                    if ( (LA8_73=='$'||LA8_73=='.'||(LA8_73>='0' && LA8_73<='9')||(LA8_73>='A' && LA8_73<='Z')||(LA8_73>='a' && LA8_73<='z')) ) {
3256 -                                        alt8=21;
3257 -                                    }
3258 -                                    else {
3259 -                                        alt8=13;}
3260 -                                }
3261 -                                else {
3262 -                                    alt8=21;}
3263 -                            }
3264 -                            else {
3265 -                                alt8=21;}
3266 -                        }
3267 -                        else {
3268 -                            alt8=21;}
3269 -                    }
3270 -                    else {
3271 -                        alt8=21;}
3272 -                }
3273 -                else {
3274 -                    alt8=21;}
3275 -                break;
3276 -            default:
3277 -                alt8=21;}
3278 -
3279 -            break;
3280 -        case 'R':
3281 -            int LA8_14 = input.LA(2);
3282 -            if ( (LA8_14=='E') ) {
3283 -                switch ( input.LA(3) ) {
3284 -                case 'A':
3285 -                    int LA8_38 = input.LA(4);
3286 -                    if ( (LA8_38=='D') ) {
3287 -                        int LA8_48 = input.LA(5);
3288 -                        if ( (LA8_48=='$'||LA8_48=='.'||(LA8_48>='0' && LA8_48<='9')||(LA8_48>='A' && LA8_48<='Z')||(LA8_48>='a' && LA8_48<='z')) ) {
3289 -                            alt8=21;
3290 -                        }
3291 -                        else {
3292 -                            alt8=18;}
3293 -                    }
3294 -                    else {
3295 -                        alt8=21;}
3296 -                    break;
3297 -                case 'V':
3298 -                    int LA8_39 = input.LA(4);
3299 -                    if ( (LA8_39=='E') ) {
3300 -                        int LA8_49 = input.LA(5);
3301 -                        if ( (LA8_49=='R') ) {
3302 -                            int LA8_59 = input.LA(6);
3303 -                            if ( (LA8_59=='S') ) {
3304 -                                int LA8_67 = input.LA(7);
3305 -                                if ( (LA8_67=='E') ) {
3306 -                                    int LA8_74 = input.LA(8);
3307 -                                    if ( (LA8_74=='$'||LA8_74=='.'||(LA8_74>='0' && LA8_74<='9')||(LA8_74>='A' && LA8_74<='Z')||(LA8_74>='a' && LA8_74<='z')) ) {
3308 -                                        alt8=21;
3309 -                                    }
3310 -                                    else {
3311 -                                        alt8=16;}
3312 -                                }
3313 -                                else {
3314 -                                    alt8=21;}
3315 -                            }
3316 -                            else {
3317 -                                alt8=21;}
3318 -                        }
3319 -                        else {
3320 -                            alt8=21;}
3321 -                    }
3322 -                    else {
3323 -                        alt8=21;}
3324 -                    break;
3325 -                default:
3326 -                    alt8=21;}
3327 -
3328 -            }
3329 -            else {
3330 -                alt8=21;}
3331 -            break;
3332 -        case 'M':
3333 -            int LA8_15 = input.LA(2);
3334 -            if ( (LA8_15=='A') ) {
3335 -                int LA8_30 = input.LA(3);
3336 -                if ( (LA8_30=='C') ) {
3337 -                    int LA8_40 = input.LA(4);
3338 -                    if ( (LA8_40=='R') ) {
3339 -                        int LA8_50 = input.LA(5);
3340 -                        if ( (LA8_50=='O') ) {
3341 -                            int LA8_60 = input.LA(6);
3342 -                            if ( (LA8_60=='$'||LA8_60=='.'||(LA8_60>='0' && LA8_60<='9')||(LA8_60>='A' && LA8_60<='Z')||(LA8_60>='a' && LA8_60<='z')) ) {
3343 -                                alt8=21;
3344 -                            }
3345 -                            else {
3346 -                                alt8=19;}
3347 -                        }
3348 -                        else {
3349 -                            alt8=21;}
3350 -                    }
3351 -                    else {
3352 -                        alt8=21;}
3353 -                }
3354 -                else {
3355 -                    alt8=21;}
3356 -            }
3357 -            else {
3358 -                alt8=21;}
3359 -            break;
3360 -        case '\'':
3361 -            alt8=20;
3362 -            break;
3363 -        case '$':
3364 -        case '.':
3365 -        case 'A':
3366 -        case 'B':
3367 -        case 'C':
3368 -        case 'D':
3369 -        case 'G':
3370 -        case 'H':
3371 -        case 'J':
3372 -        case 'K':
3373 -        case 'L':
3374 -        case 'N':
3375 -        case 'O':
3376 -        case 'P':
3377 -        case 'Q':
3378 -        case 'T':
3379 -        case 'U':
3380 -        case 'V':
3381 -        case 'W':
3382 -        case 'X':
3383 -        case 'Y':
3384 -        case 'Z':
3385 -        case 'a':
3386 -        case 'b':
3387 -        case 'c':
3388 -        case 'd':
3389 -        case 'e':
3390 -        case 'f':
3391 -        case 'g':
3392 -        case 'h':
3393 -        case 'i':
3394 -        case 'j':
3395 -        case 'k':
3396 -        case 'l':
3397 -        case 'm':
3398 -        case 'n':
3399 -        case 'o':
3400 -        case 'p':
3401 -        case 'q':
3402 -        case 'r':
3403 -        case 's':
3404 -        case 't':
3405 -        case 'u':
3406 -        case 'v':
3407 -        case 'w':
3408 -        case 'x':
3409 -        case 'y':
3410 -        case 'z':
3411 -            alt8=21;
3412 -            break;
3413 -        case '\"':
3414 -            alt8=22;
3415 -            break;
3416 -        case '#':
3417 -            alt8=23;
3418 -            break;
3419 -        case '\t':
3420 -        case '\n':
3421 -        case '\r':
3422 -        case ' ':
3423 -            alt8=24;
3424 -            break;
3425 -        case '%':
3426 -            alt8=25;
3427 -            break;
3428 -        default:
3429 -            NoViableAltException nvae =
3430 -                new NoViableAltException("1:1: Tokens : ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | STRINGS | INTEGERS | FUNCTION | EXECUTE | SORT | ITERATE | REVERSE | ENTRY | READ | MACRO | QUOTED | IDENTIFIER | STRING | INTEGER | WS | LINE_COMMENT );", 8, 0, input);
3431 -
3432 -            throw nvae;
3433 -        }
3434 -
3435 +        alt8 = dfa8.predict(input);
3436          switch (alt8) {
3437              case 1 :
3438 -                // Bst.g:1:10: T25
3439 +                // Bst.g:1:10: T__25
3440                  {
3441 -                mT25();
3442 +                mT__25();
3443
3444                  }
3445                  break;
3446              case 2 :
3447 -                // Bst.g:1:14: T26
3448 +                // Bst.g:1:16: T__26
3449                  {
3450 -                mT26();
3451 +                mT__26();
3452
3453                  }
3454                  break;
3455              case 3 :
3456 -                // Bst.g:1:18: T27
3457 +                // Bst.g:1:22: T__27
3458                  {
3459 -                mT27();
3460 +                mT__27();
3461
3462                  }
3463                  break;
3464              case 4 :
3465 -                // Bst.g:1:22: T28
3466 +                // Bst.g:1:28: T__28
3467                  {
3468 -                mT28();
3469 +                mT__28();
3470
3471                  }
3472                  break;
3473              case 5 :
3474 -                // Bst.g:1:26: T29
3475 +                // Bst.g:1:34: T__29
3476                  {
3477 -                mT29();
3478 +                mT__29();
3479
3480                  }
3481                  break;
3482              case 6 :
3483 -                // Bst.g:1:30: T30
3484 +                // Bst.g:1:40: T__30
3485                  {
3486 -                mT30();
3487 +                mT__30();
3488
3489                  }
3490                  break;
3491              case 7 :
3492 -                // Bst.g:1:34: T31
3493 +                // Bst.g:1:46: T__31
3494                  {
3495 -                mT31();
3496 +                mT__31();
3497
3498                  }
3499                  break;
3500              case 8 :
3501 -                // Bst.g:1:38: T32
3502 +                // Bst.g:1:52: T__32
3503                  {
3504 -                mT32();
3505 +                mT__32();
3506
3507                  }
3508                  break;
3509              case 9 :
3510 -                // Bst.g:1:42: T33
3511 +                // Bst.g:1:58: T__33
3512                  {
3513 -                mT33();
3514 +                mT__33();
3515
3516                  }
3517                  break;
3518              case 10 :
3519 -                // Bst.g:1:46: STRINGS
3520 +                // Bst.g:1:64: STRINGS
3521                  {
3522                  mSTRINGS();
3523
3524                  }
3525                  break;
3526              case 11 :
3527 -                // Bst.g:1:54: INTEGERS
3528 +                // Bst.g:1:72: INTEGERS
3529                  {
3530                  mINTEGERS();
3531
3532                  }
3533                  break;
3534              case 12 :
3535 -                // Bst.g:1:63: FUNCTION
3536 +                // Bst.g:1:81: FUNCTION
3537                  {
3538                  mFUNCTION();
3539
3540                  }
3541                  break;
3542              case 13 :
3543 -                // Bst.g:1:72: EXECUTE
3544 +                // Bst.g:1:90: EXECUTE
3545                  {
3546                  mEXECUTE();
3547
3548                  }
3549                  break;
3550              case 14 :
3551 -                // Bst.g:1:80: SORT
3552 +                // Bst.g:1:98: SORT
3553                  {
3554                  mSORT();
3555
3556                  }
3557                  break;
3558              case 15 :
3559 -                // Bst.g:1:85: ITERATE
3560 +                // Bst.g:1:103: ITERATE
3561                  {
3562                  mITERATE();
3563
3564                  }
3565                  break;
3566              case 16 :
3567 -                // Bst.g:1:93: REVERSE
3568 +                // Bst.g:1:111: REVERSE
3569                  {
3570                  mREVERSE();
3571
3572                  }
3573                  break;
3574              case 17 :
3575 -                // Bst.g:1:101: ENTRY
3576 +                // Bst.g:1:119: ENTRY
3577                  {
3578                  mENTRY();
3579
3580                  }
3581                  break;
3582              case 18 :
3583 -                // Bst.g:1:107: READ
3584 +                // Bst.g:1:125: READ
3585                  {
3586                  mREAD();
3587
3588                  }
3589                  break;
3590              case 19 :
3591 -                // Bst.g:1:112: MACRO
3592 +                // Bst.g:1:130: MACRO
3593                  {
3594                  mMACRO();
3595
3596                  }
3597                  break;
3598              case 20 :
3599 -                // Bst.g:1:118: QUOTED
3600 +                // Bst.g:1:136: QUOTED
3601                  {
3602                  mQUOTED();
3603
3604                  }
3605                  break;
3606              case 21 :
3607 -                // Bst.g:1:125: IDENTIFIER
3608 +                // Bst.g:1:143: IDENTIFIER
3609                  {
3610                  mIDENTIFIER();
3611
3612                  }
3613                  break;
3614              case 22 :
3615 -                // Bst.g:1:136: STRING
3616 +                // Bst.g:1:154: STRING
3617                  {
3618                  mSTRING();
3619
3620                  }
3621                  break;
3622              case 23 :
3623 -                // Bst.g:1:143: INTEGER
3624 +                // Bst.g:1:161: INTEGER
3625                  {
3626                  mINTEGER();
3627
3628                  }
3629                  break;
3630              case 24 :
3631 -                // Bst.g:1:151: WS
3632 +                // Bst.g:1:169: WS
3633                  {
3634                  mWS();
3635
3636                  }
3637                  break;
3638              case 25 :
3639 -                // Bst.g:1:154: LINE_COMMENT
3640 +                // Bst.g:1:172: LINE_COMMENT
3641                  {
3642                  mLINE_COMMENT();
3643
3644 @@ -1659,6 +1013,167 @@
3645      }
3646
3647
3648 +    protected DFA8 dfa8 = new DFA8(this);
3649 +    static final String DFA8_eotS =
3650 +        "\12\uffff\6\21\6\uffff\24\21\1\64\6\21\1\73\2\21\1\uffff\4\21\1"+
3651 +        "\102\1\21\1\uffff\1\104\5\21\1\uffff\1\21\1\uffff\1\113\1\21\1\115"+
3652 +        "\1\21\1\117\1\120\1\uffff\1\121\1\uffff\1\122\4\uffff";
3653 +    static final String DFA8_eofS =
3654 +        "\123\uffff";
3655 +    static final String DFA8_minS =
3656 +        "\1\11\11\uffff\1\117\1\116\1\125\1\116\1\105\1\101\6\uffff\2\122"+
3657 +        "\1\124\1\105\1\116\1\105\1\124\1\101\1\103\1\111\1\124\1\105\1\122"+
3658 +        "\2\103\1\122\1\105\1\104\1\122\1\116\1\44\1\107\1\101\1\124\1\125"+
3659 +        "\1\131\1\122\1\44\1\117\1\107\1\uffff\1\105\1\124\1\111\1\124\1"+
3660 +        "\44\1\123\1\uffff\1\44\1\123\1\122\1\105\1\117\1\105\1\uffff\1\105"+
3661 +        "\1\uffff\1\44\1\123\1\44\1\116\2\44\1\uffff\1\44\1\uffff\1\44\4"+
3662 +        "\uffff";
3663 +    static final String DFA8_maxS =
3664 +        "\1\175\11\uffff\2\124\1\125\1\130\1\105\1\101\6\uffff\2\122\1\124"+
3665 +        "\1\105\1\116\1\105\1\124\1\126\1\103\1\111\1\124\1\105\1\122\2\103"+
3666 +        "\1\122\1\105\1\104\1\122\1\116\1\172\1\107\1\101\1\124\1\125\1\131"+
3667 +        "\1\122\1\172\1\117\1\107\1\uffff\1\105\1\124\1\111\1\124\1\172\1"+
3668 +        "\123\1\uffff\1\172\1\123\1\122\1\105\1\117\1\105\1\uffff\1\105\1"+
3669 +        "\uffff\1\172\1\123\1\172\1\116\2\172\1\uffff\1\172\1\uffff\1\172"+
3670 +        "\4\uffff";
3671 +    static final String DFA8_acceptS =
3672 +        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\6\uffff\1\24\1\25"+
3673 +        "\1\26\1\27\1\30\1\31\36\uffff\1\16\6\uffff\1\22\6\uffff\1\21\1\uffff"+
3674 +        "\1\23\6\uffff\1\12\1\uffff\1\17\1\uffff\1\15\1\20\1\13\1\14";
3675 +    static final String DFA8_specialS =
3676 +        "\123\uffff}>";
3677 +    static final String[] DFA8_transitionS = {
3678 +            "\2\24\25\uffff\1\24\1\uffff\1\22\1\23\1\21\1\25\1\uffff\1\20"+
3679 +            "\2\uffff\1\11\1\6\1\uffff\1\7\1\21\13\uffff\1\10\1\uffff\1\3"+
3680 +            "\1\5\1\4\2\uffff\4\21\1\15\1\14\2\21\1\13\3\21\1\17\4\21\1\16"+
3681 +            "\1\12\7\21\6\uffff\32\21\1\1\1\uffff\1\2",
3682 +            "",
3683 +            "",
3684 +            "",
3685 +            "",
3686 +            "",
3687 +            "",
3688 +            "",
3689 +            "",
3690 +            "",
3691 +            "\1\27\4\uffff\1\26",
3692 +            "\1\30\5\uffff\1\31",
3693 +            "\1\32",
3694 +            "\1\34\11\uffff\1\33",
3695 +            "\1\35",
3696 +            "\1\36",
3697 +            "",
3698 +            "",
3699 +            "",
3700 +            "",
3701 +            "",
3702 +            "",
3703 +            "\1\37",
3704 +            "\1\40",
3705 +            "\1\41",
3706 +            "\1\42",
3707 +            "\1\43",
3708 +            "\1\44",
3709 +            "\1\45",
3710 +            "\1\47\24\uffff\1\46",
3711 +            "\1\50",
3712 +            "\1\51",
3713 +            "\1\52",
3714 +            "\1\53",
3715 +            "\1\54",
3716 +            "\1\55",
3717 +            "\1\56",
3718 +            "\1\57",
3719 +            "\1\60",
3720 +            "\1\61",
3721 +            "\1\62",
3722 +            "\1\63",
3723 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3724 +            "\21",
3725 +            "\1\65",
3726 +            "\1\66",
3727 +            "\1\67",
3728 +            "\1\70",
3729 +            "\1\71",
3730 +            "\1\72",
3731 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3732 +            "\21",
3733 +            "\1\74",
3734 +            "\1\75",
3735 +            "",
3736 +            "\1\76",
3737 +            "\1\77",
3738 +            "\1\100",
3739 +            "\1\101",
3740 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3741 +            "\21",
3742 +            "\1\103",
3743 +            "",
3744 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3745 +            "\21",
3746 +            "\1\105",
3747 +            "\1\106",
3748 +            "\1\107",
3749 +            "\1\110",
3750 +            "\1\111",
3751 +            "",
3752 +            "\1\112",
3753 +            "",
3754 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3755 +            "\21",
3756 +            "\1\114",
3757 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3758 +            "\21",
3759 +            "\1\116",
3760 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3761 +            "\21",
3762 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3763 +            "\21",
3764 +            "",
3765 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3766 +            "\21",
3767 +            "",
3768 +            "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+
3769 +            "\21",
3770 +            "",
3771 +            "",
3772 +            "",
3773 +            ""
3774 +    };
3775 +
3776 +    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
3777 +    static final short[] DFA8_eof = DFA.unpackEncoded