debian/patches/05_antlr32.patch

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