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