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