This is an automated email from the git hooks/post-receive script. gregoa pushed a commit to branch master in repository jabref.
commit 7bf95e1d4fcb9d9188ff2d9ec906b2bdf38a9dbe Author: tony mancill <[email protected]> Date: Tue Aug 3 12:29:54 2010 +0000 add patch for new BstLexer/Parser generated with ANTLR 3.2 --- debian/patches/05_antlr.patch | 33 - debian/patches/05_antlr32.patch | 3908 +++++++++++++++++++++++++++++++++++++++ debian/patches/series | 2 +- 3 files changed, 3909 insertions(+), 34 deletions(-) diff --git a/debian/patches/05_antlr.patch b/debian/patches/05_antlr.patch deleted file mode 100644 index 02f3a21..0000000 --- a/debian/patches/05_antlr.patch +++ /dev/null @@ -1,33 +0,0 @@ -Author: Gerardo Curiel <[email protected]> -Author: Philip Rinn <[email protected]> -Description: Use antlr3 stable release API, missing ruleNestingLevel member on the antlr3 beta API ---- a/src/java/net/sf/jabref/bst/BstLexer.java -+++ b/src/java/net/sf/jabref/bst/BstLexer.java -@@ -9,8 +9,9 @@ import org.antlr.runtime.MismatchedSetEx - import org.antlr.runtime.NoViableAltException; - import org.antlr.runtime.RecognitionException; - import org.antlr.runtime.Token; -+import org.antlr.codegen.*; - --public class BstLexer extends Lexer { -+public class BstLexer extends ActionTranslatorLexer { - public static final int LETTER=21; - public static final int T29=29; - public static final int T33=33; -@@ -43,6 +44,9 @@ public class BstLexer extends Lexer { - public static final int IDLIST=4; - public static final int NUMERAL=22; - public static final int READ=13; -+ -+ int ruleNestingLevel = 0; -+ - public BstLexer() { - - } -@@ -1661,4 +1665,4 @@ public class BstLexer extends Lexer { - - - --} -\ No newline at end of file -+} diff --git a/debian/patches/05_antlr32.patch b/debian/patches/05_antlr32.patch new file mode 100644 index 0000000..db4a29e --- /dev/null +++ b/debian/patches/05_antlr32.patch @@ -0,0 +1,3908 @@ +Index: BstParser.java +=================================================================== +--- a/src/java/net/sf/jabref/bst/BstParser.java (revision 2214) ++++ b/src/java/net/sf/jabref/bst/BstParser.java (working copy) +@@ -1,52 +1,62 @@ + package net.sf.jabref.bst; + +-// $ANTLR 3.0b5 Bst.g 2006-11-23 23:20:24 ++// $ANTLR 3.2 debian-4 Bst.g 2010-08-02 19:59:10 + ++import org.antlr.runtime.*; ++import java.util.Stack; ++import java.util.List; + import java.util.ArrayList; +-import java.util.List; + +-import org.antlr.runtime.BitSet; +-import org.antlr.runtime.EarlyExitException; +-import org.antlr.runtime.NoViableAltException; +-import org.antlr.runtime.Parser; +-import org.antlr.runtime.ParserRuleReturnScope; +-import org.antlr.runtime.RecognitionException; +-import org.antlr.runtime.Token; +-import org.antlr.runtime.TokenStream; +-import org.antlr.runtime.tree.CommonTreeAdaptor; +-import org.antlr.runtime.tree.TreeAdaptor; + +-@SuppressWarnings({"unused", "unchecked"}) ++import org.antlr.runtime.tree.*; ++ + public class BstParser extends Parser { + public static final String[] tokenNames = new String[] { + "<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", "'{'", "'}'", "'<'", "'>'", "'='", "'+'", "'-'", "':='", "'*'" + }; ++ public static final int INTEGER=19; ++ public static final int FUNCTION=10; ++ public static final int T__29=29; ++ public static final int T__28=28; ++ public static final int T__27=27; ++ public static final int T__26=26; ++ public static final int LINE_COMMENT=24; ++ public static final int QUOTED=20; ++ public static final int T__25=25; + public static final int LETTER=21; ++ public static final int EXECUTE=14; ++ public static final int STRINGS=8; ++ public static final int SORT=17; + public static final int ENTRY=6; ++ public static final int EOF=-1; + public static final int INTEGERS=9; ++ public static final int T__30=30; ++ public static final int ITERATE=15; ++ public static final int T__31=31; ++ public static final int T__32=32; + public static final int WS=23; ++ public static final int T__33=33; + public static final int COMMANDS=7; +- public static final int STRING=12; +- public static final int EXECUTE=14; +- public static final int LINE_COMMENT=24; +- public static final int SORT=17; ++ public static final int READ=13; ++ public static final int IDENTIFIER=18; ++ public static final int IDLIST=4; ++ public static final int NUMERAL=22; + public static final int STACK=5; + public static final int REVERSE=16; +- public static final int QUOTED=20; +- public static final int INTEGER=19; +- public static final int ITERATE=15; +- public static final int FUNCTION=10; +- public static final int EOF=-1; +- public static final int STRINGS=8; +- public static final int IDENTIFIER=18; + public static final int MACRO=11; +- public static final int IDLIST=4; +- public static final int NUMERAL=22; +- public static final int READ=13; ++ public static final int STRING=12; + ++ // delegates ++ // delegators ++ ++ + public BstParser(TokenStream input) { +- super(input); ++ this(input, new RecognizerSharedState()); + } ++ public BstParser(TokenStream input, RecognizerSharedState state) { ++ super(input, state); ++ ++ } + + protected TreeAdaptor adaptor = new CommonTreeAdaptor(); + +@@ -57,29 +67,29 @@ + return adaptor; + } + +- public String[] getTokenNames() { return tokenNames; } ++ public String[] getTokenNames() { return BstParser.tokenNames; } + public String getGrammarFileName() { return "Bst.g"; } + + + public static class program_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start program ++ // $ANTLR start "program" + // Bst.g:14:1: program : ( commands )+ -> ^( COMMANDS ( commands )+ ) ; +- public program_return program() throws RecognitionException { +- program_return retval = new program_return(); ++ public final BstParser.program_return program() throws RecognitionException { ++ BstParser.program_return retval = new BstParser.program_return(); + retval.start = input.LT(1); + + Object root_0 = null; + +- commands_return commands1 = null; ++ BstParser.commands_return commands1 = null; + +- List list_commands=new ArrayList(); + ++ RewriteRuleSubtreeStream stream_commands=new RewriteRuleSubtreeStream(adaptor,"rule commands"); + try { +- // Bst.g:14:11: ( ( commands )+ -> ^( COMMANDS ( commands )+ ) ) ++ // Bst.g:14:9: ( ( commands )+ -> ^( COMMANDS ( commands )+ ) ) + // Bst.g:14:11: ( commands )+ + { + // Bst.g:14:11: ( commands )+ +@@ -88,6 +98,7 @@ + do { + int alt1=2; + int LA1_0 = input.LA(1); ++ + if ( (LA1_0==ENTRY||(LA1_0>=STRINGS && LA1_0<=MACRO)||(LA1_0>=READ && LA1_0<=SORT)) ) { + alt1=1; + } +@@ -99,10 +110,11 @@ + { + pushFollow(FOLLOW_commands_in_program45); + commands1=commands(); +- _fsp--; + +- list_commands.add(commands1.tree); ++ state._fsp--; + ++ stream_commands.add(commands1.getTree()); ++ + } + break; + +@@ -116,65 +128,69 @@ + } while (true); + + ++ + // AST REWRITE +- +- int i_0 = 0; ++ // elements: commands ++ // token labels: ++ // rule labels: retval ++ // token list labels: ++ // rule list labels: ++ // wildcard labels: + retval.tree = root_0; +- root_0 = adaptor.nil(); ++ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); ++ ++ root_0 = (Object)adaptor.nil(); + // 14:21: -> ^( COMMANDS ( commands )+ ) + { + // Bst.g:14:24: ^( COMMANDS ( commands )+ ) + { +- Object root_1 = adaptor.nil(); +- root_1 = adaptor.becomeRoot(adaptor.create(COMMANDS, "COMMANDS"), root_1); ++ Object root_1 = (Object)adaptor.nil(); ++ root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMMANDS, "COMMANDS"), root_1); + +- // Bst.g:14:35: ( commands )+ +- { +- int n_1 = list_commands == null ? 0 : list_commands.size(); +- ++ if ( !(stream_commands.hasNext()) ) { ++ throw new RewriteEarlyExitException(); ++ } ++ while ( stream_commands.hasNext() ) { ++ adaptor.addChild(root_1, stream_commands.nextTree()); + +- +- if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops"); +- for (int i_1=0; i_1<n_1; i_1++) { +- adaptor.addChild(root_1, list_commands.get(i_1)); +- + } +- } ++ stream_commands.reset(); + + adaptor.addChild(root_0, root_1); + } + + } + ++ retval.tree = root_0; ++ } + ++ retval.stop = input.LT(-1); + +- } ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end program ++ // $ANTLR end "program" + + public static class commands_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start commands +- // 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^^ ); +- public commands_return commands() throws RecognitionException { +- commands_return retval = new commands_return(); ++ // $ANTLR start "commands" ++ // 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 ); ++ public final BstParser.commands_return commands() throws RecognitionException { ++ BstParser.commands_return retval = new BstParser.commands_return(); + retval.start = input.LT(1); + + Object root_0 = null; +@@ -198,27 +214,27 @@ + Token char_literal26=null; + Token ENTRY27=null; + Token SORT31=null; +- idList_return idList3 = null; ++ BstParser.idList_return idList3 = null; + +- idList_return idList5 = null; ++ BstParser.idList_return idList5 = null; + +- id_return id7 = null; ++ BstParser.id_return id7 = null; + +- stack_return stack8 = null; ++ BstParser.stack_return stack8 = null; + +- id_return id10 = null; ++ BstParser.id_return id10 = null; + +- function_return function17 = null; ++ BstParser.function_return function17 = null; + +- function_return function21 = null; ++ BstParser.function_return function21 = null; + +- function_return function25 = null; ++ BstParser.function_return function25 = null; + +- idList0_return idList028 = null; ++ BstParser.idList0_return idList028 = null; + +- idList0_return idList029 = null; ++ BstParser.idList0_return idList029 = null; + +- idList0_return idList030 = null; ++ BstParser.idList0_return idList030 = null; + + + Object STRINGS2_tree=null; +@@ -242,280 +258,294 @@ + Object SORT31_tree=null; + + try { +- // 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^^ ) ++ // 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 ) + int alt2=10; + switch ( input.LA(1) ) { + case STRINGS: ++ { + alt2=1; ++ } + break; + case INTEGERS: ++ { + alt2=2; ++ } + break; + case FUNCTION: ++ { + alt2=3; ++ } + break; + case MACRO: ++ { + alt2=4; ++ } + break; + case READ: ++ { + alt2=5; ++ } + break; + case EXECUTE: ++ { + alt2=6; ++ } + break; + case ITERATE: ++ { + alt2=7; ++ } + break; + case REVERSE: ++ { + alt2=8; ++ } + break; + case ENTRY: ++ { + alt2=9; ++ } + break; + case SORT: ++ { + alt2=10; ++ } + break; + default: + NoViableAltException nvae = +- 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); ++ new NoViableAltException("", 2, 0, input); + + throw nvae; + } + + switch (alt2) { + case 1 : +- // Bst.g:17:4: STRINGS^^ idList ++ // Bst.g:17:4: STRINGS idList + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- STRINGS2=input.LT(1); +- match(input,STRINGS,FOLLOW_STRINGS_in_commands65); +- STRINGS2_tree = adaptor.create(STRINGS2); +- root_0 = adaptor.becomeRoot(STRINGS2_tree, root_0); ++ STRINGS2=(Token)match(input,STRINGS,FOLLOW_STRINGS_in_commands65); ++ STRINGS2_tree = (Object)adaptor.create(STRINGS2); ++ root_0 = (Object)adaptor.becomeRoot(STRINGS2_tree, root_0); + + pushFollow(FOLLOW_idList_in_commands68); + idList3=idList(); +- _fsp--; + +- adaptor.addChild(root_0, idList3.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, idList3.getTree()); ++ + } + break; + case 2 : +- // Bst.g:18:4: INTEGERS^^ idList ++ // Bst.g:18:4: INTEGERS idList + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- INTEGERS4=input.LT(1); +- match(input,INTEGERS,FOLLOW_INTEGERS_in_commands73); +- INTEGERS4_tree = adaptor.create(INTEGERS4); +- root_0 = adaptor.becomeRoot(INTEGERS4_tree, root_0); ++ INTEGERS4=(Token)match(input,INTEGERS,FOLLOW_INTEGERS_in_commands73); ++ INTEGERS4_tree = (Object)adaptor.create(INTEGERS4); ++ root_0 = (Object)adaptor.becomeRoot(INTEGERS4_tree, root_0); + + pushFollow(FOLLOW_idList_in_commands76); + idList5=idList(); +- _fsp--; + +- adaptor.addChild(root_0, idList5.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, idList5.getTree()); ++ + } + break; + case 3 : +- // Bst.g:19:4: FUNCTION^^ id stack ++ // Bst.g:19:4: FUNCTION id stack + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- FUNCTION6=input.LT(1); +- match(input,FUNCTION,FOLLOW_FUNCTION_in_commands81); +- FUNCTION6_tree = adaptor.create(FUNCTION6); +- root_0 = adaptor.becomeRoot(FUNCTION6_tree, root_0); ++ FUNCTION6=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_commands81); ++ FUNCTION6_tree = (Object)adaptor.create(FUNCTION6); ++ root_0 = (Object)adaptor.becomeRoot(FUNCTION6_tree, root_0); + + pushFollow(FOLLOW_id_in_commands84); + id7=id(); +- _fsp--; + +- adaptor.addChild(root_0, id7.tree); ++ state._fsp--; ++ ++ adaptor.addChild(root_0, id7.getTree()); + pushFollow(FOLLOW_stack_in_commands86); + stack8=stack(); +- _fsp--; + +- adaptor.addChild(root_0, stack8.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, stack8.getTree()); ++ + } + break; + case 4 : +- // Bst.g:20:4: MACRO^^ id '{'! STRING '}'! ++ // Bst.g:20:4: MACRO id '{' STRING '}' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- MACRO9=input.LT(1); +- match(input,MACRO,FOLLOW_MACRO_in_commands91); +- MACRO9_tree = adaptor.create(MACRO9); +- root_0 = adaptor.becomeRoot(MACRO9_tree, root_0); ++ MACRO9=(Token)match(input,MACRO,FOLLOW_MACRO_in_commands91); ++ MACRO9_tree = (Object)adaptor.create(MACRO9); ++ root_0 = (Object)adaptor.becomeRoot(MACRO9_tree, root_0); + + pushFollow(FOLLOW_id_in_commands94); + id10=id(); +- _fsp--; + +- adaptor.addChild(root_0, id10.tree); +- char_literal11=input.LT(1); +- match(input,25,FOLLOW_25_in_commands96); +- STRING12=input.LT(1); +- match(input,STRING,FOLLOW_STRING_in_commands99); +- STRING12_tree = adaptor.create(STRING12); ++ state._fsp--; ++ ++ adaptor.addChild(root_0, id10.getTree()); ++ char_literal11=(Token)match(input,25,FOLLOW_25_in_commands96); ++ STRING12=(Token)match(input,STRING,FOLLOW_STRING_in_commands99); ++ STRING12_tree = (Object)adaptor.create(STRING12); + adaptor.addChild(root_0, STRING12_tree); + +- char_literal13=input.LT(1); +- match(input,26,FOLLOW_26_in_commands101); ++ char_literal13=(Token)match(input,26,FOLLOW_26_in_commands101); + + } + break; + case 5 : +- // Bst.g:21:4: READ^^ ++ // Bst.g:21:4: READ + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- READ14=input.LT(1); +- match(input,READ,FOLLOW_READ_in_commands107); +- READ14_tree = adaptor.create(READ14); +- root_0 = adaptor.becomeRoot(READ14_tree, root_0); ++ READ14=(Token)match(input,READ,FOLLOW_READ_in_commands107); ++ READ14_tree = (Object)adaptor.create(READ14); ++ root_0 = (Object)adaptor.becomeRoot(READ14_tree, root_0); + + + } + break; + case 6 : +- // Bst.g:22:4: EXECUTE^^ '{'! function '}'! ++ // Bst.g:22:4: EXECUTE '{' function '}' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- EXECUTE15=input.LT(1); +- match(input,EXECUTE,FOLLOW_EXECUTE_in_commands113); +- EXECUTE15_tree = adaptor.create(EXECUTE15); +- root_0 = adaptor.becomeRoot(EXECUTE15_tree, root_0); ++ EXECUTE15=(Token)match(input,EXECUTE,FOLLOW_EXECUTE_in_commands113); ++ EXECUTE15_tree = (Object)adaptor.create(EXECUTE15); ++ root_0 = (Object)adaptor.becomeRoot(EXECUTE15_tree, root_0); + +- char_literal16=input.LT(1); +- match(input,25,FOLLOW_25_in_commands116); ++ char_literal16=(Token)match(input,25,FOLLOW_25_in_commands116); + pushFollow(FOLLOW_function_in_commands119); + function17=function(); +- _fsp--; + +- adaptor.addChild(root_0, function17.tree); +- char_literal18=input.LT(1); +- match(input,26,FOLLOW_26_in_commands121); ++ state._fsp--; + ++ adaptor.addChild(root_0, function17.getTree()); ++ char_literal18=(Token)match(input,26,FOLLOW_26_in_commands121); ++ + } + break; + case 7 : +- // Bst.g:23:4: ITERATE^^ '{'! function '}'! ++ // Bst.g:23:4: ITERATE '{' function '}' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- ITERATE19=input.LT(1); +- match(input,ITERATE,FOLLOW_ITERATE_in_commands127); +- ITERATE19_tree = adaptor.create(ITERATE19); +- root_0 = adaptor.becomeRoot(ITERATE19_tree, root_0); ++ ITERATE19=(Token)match(input,ITERATE,FOLLOW_ITERATE_in_commands127); ++ ITERATE19_tree = (Object)adaptor.create(ITERATE19); ++ root_0 = (Object)adaptor.becomeRoot(ITERATE19_tree, root_0); + +- char_literal20=input.LT(1); +- match(input,25,FOLLOW_25_in_commands130); ++ char_literal20=(Token)match(input,25,FOLLOW_25_in_commands130); + pushFollow(FOLLOW_function_in_commands133); + function21=function(); +- _fsp--; + +- adaptor.addChild(root_0, function21.tree); +- char_literal22=input.LT(1); +- match(input,26,FOLLOW_26_in_commands135); ++ state._fsp--; + ++ adaptor.addChild(root_0, function21.getTree()); ++ char_literal22=(Token)match(input,26,FOLLOW_26_in_commands135); ++ + } + break; + case 8 : +- // Bst.g:24:4: REVERSE^^ '{'! function '}'! ++ // Bst.g:24:4: REVERSE '{' function '}' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- REVERSE23=input.LT(1); +- match(input,REVERSE,FOLLOW_REVERSE_in_commands141); +- REVERSE23_tree = adaptor.create(REVERSE23); +- root_0 = adaptor.becomeRoot(REVERSE23_tree, root_0); ++ REVERSE23=(Token)match(input,REVERSE,FOLLOW_REVERSE_in_commands141); ++ REVERSE23_tree = (Object)adaptor.create(REVERSE23); ++ root_0 = (Object)adaptor.becomeRoot(REVERSE23_tree, root_0); + +- char_literal24=input.LT(1); +- match(input,25,FOLLOW_25_in_commands144); ++ char_literal24=(Token)match(input,25,FOLLOW_25_in_commands144); + pushFollow(FOLLOW_function_in_commands147); + function25=function(); +- _fsp--; + +- adaptor.addChild(root_0, function25.tree); +- char_literal26=input.LT(1); +- match(input,26,FOLLOW_26_in_commands149); ++ state._fsp--; + ++ adaptor.addChild(root_0, function25.getTree()); ++ char_literal26=(Token)match(input,26,FOLLOW_26_in_commands149); ++ + } + break; + case 9 : +- // Bst.g:25:4: ENTRY^^ idList0 idList0 idList0 ++ // Bst.g:25:4: ENTRY idList0 idList0 idList0 + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- ENTRY27=input.LT(1); +- match(input,ENTRY,FOLLOW_ENTRY_in_commands155); +- ENTRY27_tree = adaptor.create(ENTRY27); +- root_0 = adaptor.becomeRoot(ENTRY27_tree, root_0); ++ ENTRY27=(Token)match(input,ENTRY,FOLLOW_ENTRY_in_commands155); ++ ENTRY27_tree = (Object)adaptor.create(ENTRY27); ++ root_0 = (Object)adaptor.becomeRoot(ENTRY27_tree, root_0); + + pushFollow(FOLLOW_idList0_in_commands158); + idList028=idList0(); +- _fsp--; + +- adaptor.addChild(root_0, idList028.tree); ++ state._fsp--; ++ ++ adaptor.addChild(root_0, idList028.getTree()); + pushFollow(FOLLOW_idList0_in_commands160); + idList029=idList0(); +- _fsp--; + +- adaptor.addChild(root_0, idList029.tree); ++ state._fsp--; ++ ++ adaptor.addChild(root_0, idList029.getTree()); + pushFollow(FOLLOW_idList0_in_commands162); + idList030=idList0(); +- _fsp--; + +- adaptor.addChild(root_0, idList030.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, idList030.getTree()); ++ + } + break; + case 10 : +- // Bst.g:26:4: SORT^^ ++ // Bst.g:26:4: SORT + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- SORT31=input.LT(1); +- match(input,SORT,FOLLOW_SORT_in_commands167); +- SORT31_tree = adaptor.create(SORT31); +- root_0 = adaptor.becomeRoot(SORT31_tree, root_0); ++ SORT31=(Token)match(input,SORT,FOLLOW_SORT_in_commands167); ++ SORT31_tree = (Object)adaptor.create(SORT31); ++ root_0 = (Object)adaptor.becomeRoot(SORT31_tree, root_0); + + + } + break; + + } ++ retval.stop = input.LT(-1); ++ ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); ++ + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end commands ++ // $ANTLR end "commands" + + public static class identifier_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start identifier ++ // $ANTLR start "identifier" + // Bst.g:28:1: identifier : IDENTIFIER ; +- public identifier_return identifier() throws RecognitionException { +- identifier_return retval = new identifier_return(); ++ public final BstParser.identifier_return identifier() throws RecognitionException { ++ BstParser.identifier_return retval = new BstParser.identifier_return(); + retval.start = input.LT(1); + + Object root_0 = null; +@@ -525,121 +555,121 @@ + Object IDENTIFIER32_tree=null; + + try { +- // Bst.g:29:4: ( IDENTIFIER ) ++ // Bst.g:29:2: ( IDENTIFIER ) + // Bst.g:29:4: IDENTIFIER + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- IDENTIFIER32=input.LT(1); +- match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier178); +- IDENTIFIER32_tree = adaptor.create(IDENTIFIER32); ++ IDENTIFIER32=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier178); ++ IDENTIFIER32_tree = (Object)adaptor.create(IDENTIFIER32); + adaptor.addChild(root_0, IDENTIFIER32_tree); + + + } + ++ retval.stop = input.LT(-1); ++ ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); ++ + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end identifier ++ // $ANTLR end "identifier" + + public static class id_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start id +- // Bst.g:31:1: id : '{'! identifier '}'! ; +- public id_return id() throws RecognitionException { +- id_return retval = new id_return(); ++ // $ANTLR start "id" ++ // Bst.g:31:1: id : '{' identifier '}' ; ++ public final BstParser.id_return id() throws RecognitionException { ++ BstParser.id_return retval = new BstParser.id_return(); + retval.start = input.LT(1); + + Object root_0 = null; + + Token char_literal33=null; + Token char_literal35=null; +- identifier_return identifier34 = null; ++ BstParser.identifier_return identifier34 = null; + + + Object char_literal33_tree=null; + Object char_literal35_tree=null; + + try { +- // Bst.g:32:4: ( '{'! identifier '}'! ) +- // Bst.g:32:4: '{'! identifier '}'! ++ // Bst.g:32:2: ( '{' identifier '}' ) ++ // Bst.g:32:4: '{' identifier '}' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal33=input.LT(1); +- match(input,25,FOLLOW_25_in_id188); ++ char_literal33=(Token)match(input,25,FOLLOW_25_in_id188); + pushFollow(FOLLOW_identifier_in_id191); + identifier34=identifier(); +- _fsp--; + +- adaptor.addChild(root_0, identifier34.tree); +- char_literal35=input.LT(1); +- match(input,26,FOLLOW_26_in_id193); ++ state._fsp--; + ++ adaptor.addChild(root_0, identifier34.getTree()); ++ char_literal35=(Token)match(input,26,FOLLOW_26_in_id193); ++ + } + ++ retval.stop = input.LT(-1); ++ ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); ++ + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end id ++ // $ANTLR end "id" + + public static class idList_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start idList ++ // $ANTLR start "idList" + // Bst.g:34:1: idList : '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) ; +- +- public idList_return idList() throws RecognitionException { +- idList_return retval = new idList_return(); ++ public final BstParser.idList_return idList() throws RecognitionException { ++ BstParser.idList_return retval = new BstParser.idList_return(); + retval.start = input.LT(1); + + Object root_0 = null; + + Token char_literal36=null; + Token char_literal38=null; +- identifier_return identifier37 = null; ++ BstParser.identifier_return identifier37 = null; + +- List list_identifier=new ArrayList(); +- List list_26=new ArrayList(); +- List list_25=new ArrayList(); ++ + Object char_literal36_tree=null; + Object char_literal38_tree=null; +- ++ RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25"); ++ RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26"); ++ RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier"); + try { +- // Bst.g:35:4: ( '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) ) ++ // Bst.g:35:2: ( '{' ( identifier )+ '}' -> ^( IDLIST ( identifier )+ ) ) + // Bst.g:35:4: '{' ( identifier )+ '}' + { +- char_literal36=input.LT(1); +- match(input,25,FOLLOW_25_in_idList205); +- list_25.add(char_literal36); ++ char_literal36=(Token)match(input,25,FOLLOW_25_in_idList205); ++ stream_25.add(char_literal36); + + // Bst.g:35:8: ( identifier )+ + int cnt3=0; +@@ -647,6 +677,7 @@ + do { + int alt3=2; + int LA3_0 = input.LA(1); ++ + if ( (LA3_0==IDENTIFIER) ) { + alt3=1; + } +@@ -658,10 +689,11 @@ + { + pushFollow(FOLLOW_identifier_in_idList207); + identifier37=identifier(); +- _fsp--; + +- list_identifier.add(identifier37.tree); ++ state._fsp--; + ++ stream_identifier.add(identifier37.getTree()); ++ + } + break; + +@@ -674,96 +706,100 @@ + cnt3++; + } while (true); + +- char_literal38=input.LT(1); +- match(input,26,FOLLOW_26_in_idList210); +- list_26.add(char_literal38); ++ char_literal38=(Token)match(input,26,FOLLOW_26_in_idList210); ++ stream_26.add(char_literal38); + + ++ + // AST REWRITE +- int i_0 = 0; ++ // elements: identifier ++ // token labels: ++ // rule labels: retval ++ // token list labels: ++ // rule list labels: ++ // wildcard labels: + retval.tree = root_0; +- root_0 = adaptor.nil(); ++ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); ++ ++ root_0 = (Object)adaptor.nil(); + // 35:24: -> ^( IDLIST ( identifier )+ ) + { + // Bst.g:35:27: ^( IDLIST ( identifier )+ ) + { +- Object root_1 = adaptor.nil(); +- root_1 = adaptor.becomeRoot(adaptor.create(IDLIST, "IDLIST"), root_1); ++ Object root_1 = (Object)adaptor.nil(); ++ root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDLIST, "IDLIST"), root_1); + +- // Bst.g:35:36: ( identifier )+ +- { +- int n_1 = list_identifier == null ? 0 : list_identifier.size(); +- ++ if ( !(stream_identifier.hasNext()) ) { ++ throw new RewriteEarlyExitException(); ++ } ++ while ( stream_identifier.hasNext() ) { ++ adaptor.addChild(root_1, stream_identifier.nextTree()); + +- +- if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops"); +- for (int i_1=0; i_1<n_1; i_1++) { +- adaptor.addChild(root_1, list_identifier.get(i_1)); +- + } +- } ++ stream_identifier.reset(); + + adaptor.addChild(root_0, root_1); + } + + } + ++ retval.tree = root_0; ++ } + ++ retval.stop = input.LT(-1); + +- } ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end idList ++ // $ANTLR end "idList" + + public static class idList0_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start idList0 ++ // $ANTLR start "idList0" + // Bst.g:37:1: idList0 : '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) ; +- public idList0_return idList0() throws RecognitionException { +- idList0_return retval = new idList0_return(); ++ public final BstParser.idList0_return idList0() throws RecognitionException { ++ BstParser.idList0_return retval = new BstParser.idList0_return(); + retval.start = input.LT(1); + + Object root_0 = null; + + Token char_literal39=null; + Token char_literal41=null; +- identifier_return identifier40 = null; ++ BstParser.identifier_return identifier40 = null; + +- List list_identifier=new ArrayList(); +- List list_26=new ArrayList(); +- List list_25=new ArrayList(); ++ + Object char_literal39_tree=null; + Object char_literal41_tree=null; +- ++ RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25"); ++ RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26"); ++ RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier"); + try { +- // Bst.g:38:4: ( '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) ) ++ // Bst.g:38:2: ( '{' ( identifier )* '}' -> ^( IDLIST ( identifier )* ) ) + // Bst.g:38:4: '{' ( identifier )* '}' + { +- char_literal39=input.LT(1); +- match(input,25,FOLLOW_25_in_idList0230); +- list_25.add(char_literal39); ++ char_literal39=(Token)match(input,25,FOLLOW_25_in_idList0230); ++ stream_25.add(char_literal39); + + // Bst.g:38:8: ( identifier )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); ++ + if ( (LA4_0==IDENTIFIER) ) { + alt4=1; + } +@@ -775,10 +811,11 @@ + { + pushFollow(FOLLOW_identifier_in_idList0232); + identifier40=identifier(); +- _fsp--; + +- list_identifier.add(identifier40.tree); ++ state._fsp--; + ++ stream_identifier.add(identifier40.getTree()); ++ + } + break; + +@@ -787,68 +824,71 @@ + } + } while (true); + +- char_literal41=input.LT(1); +- match(input,26,FOLLOW_26_in_idList0235); +- list_26.add(char_literal41); ++ char_literal41=(Token)match(input,26,FOLLOW_26_in_idList0235); ++ stream_26.add(char_literal41); + + ++ + // AST REWRITE +- int i_0 = 0; ++ // elements: identifier ++ // token labels: ++ // rule labels: retval ++ // token list labels: ++ // rule list labels: ++ // wildcard labels: + retval.tree = root_0; +- root_0 = adaptor.nil(); ++ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); ++ ++ root_0 = (Object)adaptor.nil(); + // 38:24: -> ^( IDLIST ( identifier )* ) + { + // Bst.g:38:27: ^( IDLIST ( identifier )* ) + { +- Object root_1 = adaptor.nil(); +- root_1 = adaptor.becomeRoot(adaptor.create(IDLIST, "IDLIST"), root_1); ++ Object root_1 = (Object)adaptor.nil(); ++ root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDLIST, "IDLIST"), root_1); + + // Bst.g:38:36: ( identifier )* +- { +- int n_1 = list_identifier == null ? 0 : list_identifier.size(); +- ++ while ( stream_identifier.hasNext() ) { ++ adaptor.addChild(root_1, stream_identifier.nextTree()); + +- +- for (int i_1=0; i_1<n_1; i_1++) { +- adaptor.addChild(root_1, list_identifier.get(i_1)); +- + } +- } ++ stream_identifier.reset(); + + adaptor.addChild(root_0, root_1); + } + + } + ++ retval.tree = root_0; ++ } + ++ retval.stop = input.LT(-1); + +- } ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end idList0 ++ // $ANTLR end "idList0" + + public static class function_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start function ++ // $ANTLR start "function" + // Bst.g:40:1: function : ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier ); +- public function_return function() throws RecognitionException { +- function_return retval = new function_return(); ++ public final BstParser.function_return function() throws RecognitionException { ++ BstParser.function_return retval = new BstParser.function_return(); + retval.start = input.LT(1); + + Object root_0 = null; +@@ -860,7 +900,7 @@ + Token char_literal46=null; + Token string_literal47=null; + Token char_literal48=null; +- identifier_return identifier49 = null; ++ BstParser.identifier_return identifier49 = null; + + + Object char_literal42_tree=null; +@@ -872,36 +912,52 @@ + Object char_literal48_tree=null; + + try { +- // Bst.g:41:4: ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier ) ++ // Bst.g:41:2: ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier ) + int alt5=8; + switch ( input.LA(1) ) { + case 27: ++ { + alt5=1; ++ } + break; + case 28: ++ { + alt5=2; ++ } + break; + case 29: ++ { + alt5=3; ++ } + break; + case 30: ++ { + alt5=4; ++ } + break; + case 31: ++ { + alt5=5; ++ } + break; + case 32: ++ { + alt5=6; ++ } + break; + case 33: ++ { + alt5=7; ++ } + break; + case IDENTIFIER: ++ { + alt5=8; ++ } + break; + default: + NoViableAltException nvae = +- new NoViableAltException("40:1: function : ( '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier );", 5, 0, input); ++ new NoViableAltException("", 5, 0, input); + + throw nvae; + } +@@ -910,11 +966,10 @@ + case 1 : + // Bst.g:41:4: '<' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal42=input.LT(1); +- match(input,27,FOLLOW_27_in_function254); +- char_literal42_tree = adaptor.create(char_literal42); ++ char_literal42=(Token)match(input,27,FOLLOW_27_in_function254); ++ char_literal42_tree = (Object)adaptor.create(char_literal42); + adaptor.addChild(root_0, char_literal42_tree); + + +@@ -923,11 +978,10 @@ + case 2 : + // Bst.g:41:10: '>' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal43=input.LT(1); +- match(input,28,FOLLOW_28_in_function258); +- char_literal43_tree = adaptor.create(char_literal43); ++ char_literal43=(Token)match(input,28,FOLLOW_28_in_function258); ++ char_literal43_tree = (Object)adaptor.create(char_literal43); + adaptor.addChild(root_0, char_literal43_tree); + + +@@ -936,11 +990,10 @@ + case 3 : + // Bst.g:41:16: '=' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal44=input.LT(1); +- match(input,29,FOLLOW_29_in_function262); +- char_literal44_tree = adaptor.create(char_literal44); ++ char_literal44=(Token)match(input,29,FOLLOW_29_in_function262); ++ char_literal44_tree = (Object)adaptor.create(char_literal44); + adaptor.addChild(root_0, char_literal44_tree); + + +@@ -949,11 +1002,10 @@ + case 4 : + // Bst.g:41:22: '+' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal45=input.LT(1); +- match(input,30,FOLLOW_30_in_function266); +- char_literal45_tree = adaptor.create(char_literal45); ++ char_literal45=(Token)match(input,30,FOLLOW_30_in_function266); ++ char_literal45_tree = (Object)adaptor.create(char_literal45); + adaptor.addChild(root_0, char_literal45_tree); + + +@@ -962,11 +1014,10 @@ + case 5 : + // Bst.g:41:28: '-' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal46=input.LT(1); +- match(input,31,FOLLOW_31_in_function270); +- char_literal46_tree = adaptor.create(char_literal46); ++ char_literal46=(Token)match(input,31,FOLLOW_31_in_function270); ++ char_literal46_tree = (Object)adaptor.create(char_literal46); + adaptor.addChild(root_0, char_literal46_tree); + + +@@ -975,11 +1026,10 @@ + case 6 : + // Bst.g:41:34: ':=' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- string_literal47=input.LT(1); +- match(input,32,FOLLOW_32_in_function274); +- string_literal47_tree = adaptor.create(string_literal47); ++ string_literal47=(Token)match(input,32,FOLLOW_32_in_function274); ++ string_literal47_tree = (Object)adaptor.create(string_literal47); + adaptor.addChild(root_0, string_literal47_tree); + + +@@ -988,11 +1038,10 @@ + case 7 : + // Bst.g:41:41: '*' + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- char_literal48=input.LT(1); +- match(input,33,FOLLOW_33_in_function278); +- char_literal48_tree = adaptor.create(char_literal48); ++ char_literal48=(Token)match(input,33,FOLLOW_33_in_function278); ++ char_literal48_tree = (Object)adaptor.create(char_literal48); + adaptor.addChild(root_0, char_literal48_tree); + + +@@ -1001,64 +1050,66 @@ + case 8 : + // Bst.g:41:47: identifier + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + + pushFollow(FOLLOW_identifier_in_function282); + identifier49=identifier(); +- _fsp--; + +- adaptor.addChild(root_0, identifier49.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, identifier49.getTree()); ++ + } + break; + + } ++ retval.stop = input.LT(-1); ++ ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); ++ + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end function ++ // $ANTLR end "function" + + public static class stack_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start stack ++ // $ANTLR start "stack" + // Bst.g:43:1: stack : '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) ; +- public stack_return stack() throws RecognitionException { +- stack_return retval = new stack_return(); ++ public final BstParser.stack_return stack() throws RecognitionException { ++ BstParser.stack_return retval = new BstParser.stack_return(); + retval.start = input.LT(1); + + Object root_0 = null; + + Token char_literal50=null; + Token char_literal52=null; +- stackitem_return stackitem51 = null; ++ BstParser.stackitem_return stackitem51 = null; + +- List list_stackitem=new ArrayList(); +- List list_26=new ArrayList(); +- List list_25=new ArrayList(); ++ + Object char_literal50_tree=null; + Object char_literal52_tree=null; +- ++ RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25"); ++ RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26"); ++ RewriteRuleSubtreeStream stream_stackitem=new RewriteRuleSubtreeStream(adaptor,"rule stackitem"); + try { +- // Bst.g:44:4: ( '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) ) ++ // Bst.g:44:2: ( '{' ( stackitem )+ '}' -> ^( STACK ( stackitem )+ ) ) + // Bst.g:44:4: '{' ( stackitem )+ '}' + { +- char_literal50=input.LT(1); +- match(input,25,FOLLOW_25_in_stack293); +- list_25.add(char_literal50); ++ char_literal50=(Token)match(input,25,FOLLOW_25_in_stack293); ++ stream_25.add(char_literal50); + + // Bst.g:44:8: ( stackitem )+ + int cnt6=0; +@@ -1066,6 +1117,7 @@ + do { + int alt6=2; + int LA6_0 = input.LA(1); ++ + if ( (LA6_0==STRING||(LA6_0>=IDENTIFIER && LA6_0<=QUOTED)||LA6_0==25||(LA6_0>=27 && LA6_0<=33)) ) { + alt6=1; + } +@@ -1077,10 +1129,11 @@ + { + pushFollow(FOLLOW_stackitem_in_stack295); + stackitem51=stackitem(); +- _fsp--; + +- list_stackitem.add(stackitem51.tree); ++ state._fsp--; + ++ stream_stackitem.add(stackitem51.getTree()); ++ + } + break; + +@@ -1093,69 +1146,73 @@ + cnt6++; + } while (true); + +- char_literal52=input.LT(1); +- match(input,26,FOLLOW_26_in_stack298); +- list_26.add(char_literal52); ++ char_literal52=(Token)match(input,26,FOLLOW_26_in_stack298); ++ stream_26.add(char_literal52); + + ++ + // AST REWRITE +- int i_0 = 0; ++ // elements: stackitem ++ // token labels: ++ // rule labels: retval ++ // token list labels: ++ // rule list labels: ++ // wildcard labels: + retval.tree = root_0; +- root_0 = adaptor.nil(); ++ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); ++ ++ root_0 = (Object)adaptor.nil(); + // 44:23: -> ^( STACK ( stackitem )+ ) + { + // Bst.g:44:26: ^( STACK ( stackitem )+ ) + { +- Object root_1 = adaptor.nil(); +- root_1 = adaptor.becomeRoot(adaptor.create(STACK, "STACK"), root_1); ++ Object root_1 = (Object)adaptor.nil(); ++ root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(STACK, "STACK"), root_1); + +- // Bst.g:44:34: ( stackitem )+ +- { +- int n_1 = list_stackitem == null ? 0 : list_stackitem.size(); +- ++ if ( !(stream_stackitem.hasNext()) ) { ++ throw new RewriteEarlyExitException(); ++ } ++ while ( stream_stackitem.hasNext() ) { ++ adaptor.addChild(root_1, stream_stackitem.nextTree()); + +- +- if ( n_1==0 ) throw new RuntimeException("Must have more than one element for (...)+ loops"); +- for (int i_1=0; i_1<n_1; i_1++) { +- adaptor.addChild(root_1, list_stackitem.get(i_1)); +- + } +- } ++ stream_stackitem.reset(); + + adaptor.addChild(root_0, root_1); + } + + } + ++ retval.tree = root_0; ++ } + ++ retval.stop = input.LT(-1); + +- } ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end stack ++ // $ANTLR end "stack" + + public static class stackitem_return extends ParserRuleReturnScope { + Object tree; + public Object getTree() { return tree; } +- } ++ }; + +- // $ANTLR start stackitem ++ // $ANTLR start "stackitem" + // Bst.g:46:1: stackitem : ( function | STRING | INTEGER | QUOTED | stack ); +- public stackitem_return stackitem() throws RecognitionException { +- stackitem_return retval = new stackitem_return(); ++ public final BstParser.stackitem_return stackitem() throws RecognitionException { ++ BstParser.stackitem_return retval = new BstParser.stackitem_return(); + retval.start = input.LT(1); + + Object root_0 = null; +@@ -1163,9 +1220,9 @@ + Token STRING54=null; + Token INTEGER55=null; + Token QUOTED56=null; +- function_return function53 = null; ++ BstParser.function_return function53 = null; + +- stack_return stack57 = null; ++ BstParser.stack_return stack57 = null; + + + Object STRING54_tree=null; +@@ -1173,7 +1230,7 @@ + Object QUOTED56_tree=null; + + try { +- // Bst.g:47:4: ( function | STRING | INTEGER | QUOTED | stack ) ++ // Bst.g:47:2: ( function | STRING | INTEGER | QUOTED | stack ) + int alt7=5; + switch ( input.LA(1) ) { + case IDENTIFIER: +@@ -1184,23 +1241,33 @@ + case 31: + case 32: + case 33: ++ { + alt7=1; ++ } + break; + case STRING: ++ { + alt7=2; ++ } + break; + case INTEGER: ++ { + alt7=3; ++ } + break; + case QUOTED: ++ { + alt7=4; ++ } + break; + case 25: ++ { + alt7=5; ++ } + break; + default: + NoViableAltException nvae = +- new NoViableAltException("46:1: stackitem : ( function | STRING | INTEGER | QUOTED | stack );", 7, 0, input); ++ new NoViableAltException("", 7, 0, input); + + throw nvae; + } +@@ -1209,24 +1276,24 @@ + case 1 : + // Bst.g:47:4: function + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + + pushFollow(FOLLOW_function_in_stackitem317); + function53=function(); +- _fsp--; + +- adaptor.addChild(root_0, function53.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, function53.getTree()); ++ + } + break; + case 2 : + // Bst.g:48:4: STRING + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- STRING54=input.LT(1); +- match(input,STRING,FOLLOW_STRING_in_stackitem322); +- STRING54_tree = adaptor.create(STRING54); ++ STRING54=(Token)match(input,STRING,FOLLOW_STRING_in_stackitem322); ++ STRING54_tree = (Object)adaptor.create(STRING54); + adaptor.addChild(root_0, STRING54_tree); + + +@@ -1235,11 +1302,10 @@ + case 3 : + // Bst.g:49:4: INTEGER + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- INTEGER55=input.LT(1); +- match(input,INTEGER,FOLLOW_INTEGER_in_stackitem328); +- INTEGER55_tree = adaptor.create(INTEGER55); ++ INTEGER55=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_stackitem328); ++ INTEGER55_tree = (Object)adaptor.create(INTEGER55); + adaptor.addChild(root_0, INTEGER55_tree); + + +@@ -1248,11 +1314,10 @@ + case 4 : + // Bst.g:50:4: QUOTED + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + +- QUOTED56=input.LT(1); +- match(input,QUOTED,FOLLOW_QUOTED_in_stackitem334); +- QUOTED56_tree = adaptor.create(QUOTED56); ++ QUOTED56=(Token)match(input,QUOTED,FOLLOW_QUOTED_in_stackitem334); ++ QUOTED56_tree = (Object)adaptor.create(QUOTED56); + adaptor.addChild(root_0, QUOTED56_tree); + + +@@ -1261,35 +1326,40 @@ + case 5 : + // Bst.g:51:4: stack + { +- root_0 = adaptor.nil(); ++ root_0 = (Object)adaptor.nil(); + + pushFollow(FOLLOW_stack_in_stackitem339); + stack57=stack(); +- _fsp--; + +- adaptor.addChild(root_0, stack57.tree); ++ state._fsp--; + ++ adaptor.addChild(root_0, stack57.getTree()); ++ + } + break; + + } ++ retval.stop = input.LT(-1); ++ ++ retval.tree = (Object)adaptor.rulePostProcessing(root_0); ++ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); ++ + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); ++ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); ++ + } + finally { +- retval.stop = input.LT(-1); +- +- retval.tree = adaptor.rulePostProcessing(root_0); +- adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); +- +- } ++ } + return retval; + } +- // $ANTLR end stackitem ++ // $ANTLR end "stackitem" + ++ // Delegated rules + ++ + + + public static final BitSet FOLLOW_commands_in_program45 = new BitSet(new long[]{0x000000000003EF42L}); +@@ -1324,14 +1394,14 @@ + public static final BitSet FOLLOW_idList0_in_commands162 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_SORT_in_commands167 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_IDENTIFIER_in_identifier178 = new BitSet(new long[]{0x0000000000000002L}); +- public static final BitSet FOLLOW_25_in_id188 = new BitSet(new long[]{0x0000000000040000L}); ++ public static final BitSet FOLLOW_25_in_id188 = new BitSet(new long[]{0x00000003F8040000L}); + public static final BitSet FOLLOW_identifier_in_id191 = new BitSet(new long[]{0x0000000004000000L}); + public static final BitSet FOLLOW_26_in_id193 = new BitSet(new long[]{0x0000000000000002L}); +- public static final BitSet FOLLOW_25_in_idList205 = new BitSet(new long[]{0x0000000000040000L}); +- public static final BitSet FOLLOW_identifier_in_idList207 = new BitSet(new long[]{0x0000000004040000L}); ++ public static final BitSet FOLLOW_25_in_idList205 = new BitSet(new long[]{0x00000003F8040000L}); ++ public static final BitSet FOLLOW_identifier_in_idList207 = new BitSet(new long[]{0x00000003FC040000L}); + public static final BitSet FOLLOW_26_in_idList210 = new BitSet(new long[]{0x0000000000000002L}); +- public static final BitSet FOLLOW_25_in_idList0230 = new BitSet(new long[]{0x0000000004040000L}); +- public static final BitSet FOLLOW_identifier_in_idList0232 = new BitSet(new long[]{0x0000000004040000L}); ++ public static final BitSet FOLLOW_25_in_idList0230 = new BitSet(new long[]{0x00000003FC040000L}); ++ public static final BitSet FOLLOW_identifier_in_idList0232 = new BitSet(new long[]{0x00000003FC040000L}); + public static final BitSet FOLLOW_26_in_idList0235 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_27_in_function254 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_28_in_function258 = new BitSet(new long[]{0x0000000000000002L}); +@@ -1350,4 +1420,4 @@ + public static final BitSet FOLLOW_QUOTED_in_stackitem334 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_stack_in_stackitem339 = new BitSet(new long[]{0x0000000000000002L}); + +-} +\ No newline at end of file ++} +Index: BstLexer.java +=================================================================== +--- a/src/java/net/sf/jabref/bst/BstLexer.java (revision 2214) ++++ b/src/java/net/sf/jabref/bst/BstLexer.java (working copy) +@@ -1,328 +1,245 @@ + package net.sf.jabref.bst; + +-// $ANTLR 3.0b5 Bst.g 2006-11-23 23:20:24 ++// $ANTLR 3.2 debian-4 Bst.g 2010-08-02 19:59:11 + +-import org.antlr.runtime.CharStream; +-import org.antlr.runtime.EarlyExitException; +-import org.antlr.runtime.Lexer; +-import org.antlr.runtime.MismatchedSetException; +-import org.antlr.runtime.NoViableAltException; +-import org.antlr.runtime.RecognitionException; +-import org.antlr.runtime.Token; ++import org.antlr.runtime.*; ++import java.util.Stack; ++import java.util.List; ++import java.util.ArrayList; + + public class BstLexer extends Lexer { ++ public static final int FUNCTION=10; ++ public static final int INTEGER=19; ++ public static final int T__29=29; ++ public static final int T__28=28; ++ public static final int T__27=27; ++ public static final int T__26=26; ++ public static final int LINE_COMMENT=24; ++ public static final int QUOTED=20; ++ public static final int T__25=25; + public static final int LETTER=21; +- public static final int T29=29; +- public static final int T33=33; +- public static final int INTEGERS=9; +- public static final int ENTRY=6; +- public static final int WS=23; +- public static final int COMMANDS=7; +- public static final int STRING=12; +- public static final int T28=28; + public static final int EXECUTE=14; +- public static final int LINE_COMMENT=24; ++ public static final int STRINGS=8; + public static final int SORT=17; +- public static final int STACK=5; +- public static final int REVERSE=16; +- public static final int QUOTED=20; +- public static final int T25=25; +- public static final int INTEGER=19; +- public static final int ITERATE=15; +- public static final int FUNCTION=10; +- public static final int T26=26; ++ public static final int ENTRY=6; + public static final int EOF=-1; +- public static final int T32=32; +- public static final int Tokens=34; +- public static final int STRINGS=8; +- public static final int T31=31; +- public static final int T27=27; ++ public static final int INTEGERS=9; ++ public static final int T__30=30; ++ public static final int T__31=31; ++ public static final int ITERATE=15; ++ public static final int T__32=32; ++ public static final int T__33=33; ++ public static final int WS=23; ++ public static final int COMMANDS=7; ++ public static final int READ=13; + public static final int IDENTIFIER=18; +- public static final int MACRO=11; +- public static final int T30=30; + public static final int IDLIST=4; + public static final int NUMERAL=22; +- public static final int READ=13; +- public BstLexer() { +- +- } ++ public static final int STACK=5; ++ public static final int REVERSE=16; ++ public static final int MACRO=11; ++ public static final int STRING=12; ++ ++ // delegates ++ // delegators ++ ++ public BstLexer() {;} + public BstLexer(CharStream input) { +- super(input); ++ this(input, new RecognizerSharedState()); + } ++ public BstLexer(CharStream input, RecognizerSharedState state) { ++ super(input,state); ++ ++ } + public String getGrammarFileName() { return "Bst.g"; } + +- // $ANTLR start T25 +- public void mT25() throws RecognitionException { ++ // $ANTLR start "T__25" ++ public final void mT__25() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T25; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__25; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:3:7: ( '{' ) +- // Bst.g:3:7: '{' ++ // Bst.g:3:9: '{' + { + match('{'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T25 ++ // $ANTLR end "T__25" + +- // $ANTLR start T26 +- public void mT26() throws RecognitionException { ++ // $ANTLR start "T__26" ++ public final void mT__26() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T26; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__26; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:4:7: ( '}' ) +- // Bst.g:4:7: '}' ++ // Bst.g:4:9: '}' + { + match('}'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T26 ++ // $ANTLR end "T__26" + +- // $ANTLR start T27 +- public void mT27() throws RecognitionException { ++ // $ANTLR start "T__27" ++ public final void mT__27() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T27; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__27; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:5:7: ( '<' ) +- // Bst.g:5:7: '<' ++ // Bst.g:5:9: '<' + { + match('<'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T27 ++ // $ANTLR end "T__27" + +- // $ANTLR start T28 +- public void mT28() throws RecognitionException { ++ // $ANTLR start "T__28" ++ public final void mT__28() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T28; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__28; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:6:7: ( '>' ) +- // Bst.g:6:7: '>' ++ // Bst.g:6:9: '>' + { + match('>'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T28 ++ // $ANTLR end "T__28" + +- // $ANTLR start T29 +- public void mT29() throws RecognitionException { ++ // $ANTLR start "T__29" ++ public final void mT__29() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T29; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__29; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:7:7: ( '=' ) +- // Bst.g:7:7: '=' ++ // Bst.g:7:9: '=' + { + match('='); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T29 ++ // $ANTLR end "T__29" + +- // $ANTLR start T30 +- public void mT30() throws RecognitionException { ++ // $ANTLR start "T__30" ++ public final void mT__30() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T30; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__30; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:8:7: ( '+' ) +- // Bst.g:8:7: '+' ++ // Bst.g:8:9: '+' + { + match('+'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T30 ++ // $ANTLR end "T__30" + +- // $ANTLR start T31 +- public void mT31() throws RecognitionException { ++ // $ANTLR start "T__31" ++ public final void mT__31() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T31; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__31; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:9:7: ( '-' ) +- // Bst.g:9:7: '-' ++ // Bst.g:9:9: '-' + { + match('-'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T31 ++ // $ANTLR end "T__31" + +- // $ANTLR start T32 +- public void mT32() throws RecognitionException { ++ // $ANTLR start "T__32" ++ public final void mT__32() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T32; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__32; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:10:7: ( ':=' ) +- // Bst.g:10:7: ':=' ++ // Bst.g:10:9: ':=' + { + match(":="); + + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T32 ++ // $ANTLR end "T__32" + +- // $ANTLR start T33 +- public void mT33() throws RecognitionException { ++ // $ANTLR start "T__33" ++ public final void mT__33() throws RecognitionException { + try { +- ruleNestingLevel++; +- int _type = T33; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; ++ int _type = T__33; ++ int _channel = DEFAULT_TOKEN_CHANNEL; + // Bst.g:11:7: ( '*' ) +- // Bst.g:11:7: '*' ++ // Bst.g:11:9: '*' + { + match('*'); + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end T33 ++ // $ANTLR end "T__33" + +- // $ANTLR start STRINGS +- public void mSTRINGS() throws RecognitionException { ++ // $ANTLR start "STRINGS" ++ public final void mSTRINGS() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = STRINGS; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:53:11: ( 'STRINGS' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:53:9: ( 'STRINGS' ) + // Bst.g:53:11: 'STRINGS' + { + match("STRINGS"); +@@ -330,29 +247,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end STRINGS ++ // $ANTLR end "STRINGS" + +- // $ANTLR start INTEGERS +- public void mINTEGERS() throws RecognitionException { ++ // $ANTLR start "INTEGERS" ++ public final void mINTEGERS() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = INTEGERS; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:54:12: ( 'INTEGERS' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:54:10: ( 'INTEGERS' ) + // Bst.g:54:12: 'INTEGERS' + { + match("INTEGERS"); +@@ -360,29 +268,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end INTEGERS ++ // $ANTLR end "INTEGERS" + +- // $ANTLR start FUNCTION +- public void mFUNCTION() throws RecognitionException { ++ // $ANTLR start "FUNCTION" ++ public final void mFUNCTION() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = FUNCTION; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:55:12: ( 'FUNCTION' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:55:10: ( 'FUNCTION' ) + // Bst.g:55:12: 'FUNCTION' + { + match("FUNCTION"); +@@ -390,29 +289,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end FUNCTION ++ // $ANTLR end "FUNCTION" + +- // $ANTLR start EXECUTE +- public void mEXECUTE() throws RecognitionException { ++ // $ANTLR start "EXECUTE" ++ public final void mEXECUTE() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = EXECUTE; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:56:11: ( 'EXECUTE' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:56:9: ( 'EXECUTE' ) + // Bst.g:56:11: 'EXECUTE' + { + match("EXECUTE"); +@@ -420,29 +310,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end EXECUTE ++ // $ANTLR end "EXECUTE" + +- // $ANTLR start SORT +- public void mSORT() throws RecognitionException { ++ // $ANTLR start "SORT" ++ public final void mSORT() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = SORT; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:57:8: ( 'SORT' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:57:6: ( 'SORT' ) + // Bst.g:57:8: 'SORT' + { + match("SORT"); +@@ -450,29 +331,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end SORT ++ // $ANTLR end "SORT" + +- // $ANTLR start ITERATE +- public void mITERATE() throws RecognitionException { ++ // $ANTLR start "ITERATE" ++ public final void mITERATE() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = ITERATE; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:58:11: ( 'ITERATE' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:58:9: ( 'ITERATE' ) + // Bst.g:58:11: 'ITERATE' + { + match("ITERATE"); +@@ -480,29 +352,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end ITERATE ++ // $ANTLR end "ITERATE" + +- // $ANTLR start REVERSE +- public void mREVERSE() throws RecognitionException { ++ // $ANTLR start "REVERSE" ++ public final void mREVERSE() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = REVERSE; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:59:11: ( 'REVERSE' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:59:9: ( 'REVERSE' ) + // Bst.g:59:11: 'REVERSE' + { + match("REVERSE"); +@@ -510,29 +373,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end REVERSE ++ // $ANTLR end "REVERSE" + +- // $ANTLR start ENTRY +- public void mENTRY() throws RecognitionException { ++ // $ANTLR start "ENTRY" ++ public final void mENTRY() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = ENTRY; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:60:9: ( 'ENTRY' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:60:7: ( 'ENTRY' ) + // Bst.g:60:9: 'ENTRY' + { + match("ENTRY"); +@@ -540,29 +394,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end ENTRY ++ // $ANTLR end "ENTRY" + +- // $ANTLR start READ +- public void mREAD() throws RecognitionException { ++ // $ANTLR start "READ" ++ public final void mREAD() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = READ; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:61:8: ( 'READ' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:61:6: ( 'READ' ) + // Bst.g:61:8: 'READ' + { + match("READ"); +@@ -570,29 +415,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end READ ++ // $ANTLR end "READ" + +- // $ANTLR start MACRO +- public void mMACRO() throws RecognitionException { ++ // $ANTLR start "MACRO" ++ public final void mMACRO() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = MACRO; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:62:9: ( 'MACRO' ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:62:7: ( 'MACRO' ) + // Bst.g:62:9: 'MACRO' + { + match("MACRO"); +@@ -600,29 +436,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end MACRO ++ // $ANTLR end "MACRO" + +- // $ANTLR start QUOTED +- public void mQUOTED() throws RecognitionException { ++ // $ANTLR start "QUOTED" ++ public final void mQUOTED() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = QUOTED; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:65:4: ( '\\'' IDENTIFIER ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:65:2: ( '\\'' IDENTIFIER ) + // Bst.g:65:4: '\\'' IDENTIFIER + { + match('\''); +@@ -630,29 +457,20 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end QUOTED ++ // $ANTLR end "QUOTED" + +- // $ANTLR start IDENTIFIER +- public void mIDENTIFIER() throws RecognitionException { ++ // $ANTLR start "IDENTIFIER" ++ public final void mIDENTIFIER() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = IDENTIFIER; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:68:4: ( LETTER ( LETTER | NUMERAL )* ) ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:68:2: ( LETTER ( LETTER | NUMERAL )* ) + // Bst.g:68:4: LETTER ( LETTER | NUMERAL )* + { + mLETTER(); +@@ -661,6 +479,7 @@ + do { + int alt1=3; + int LA1_0 = input.LA(1); ++ + if ( (LA1_0=='$'||LA1_0=='.'||(LA1_0>='A' && LA1_0<='Z')||(LA1_0>='a' && LA1_0<='z')) ) { + alt1=1; + } +@@ -693,82 +512,70 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end IDENTIFIER ++ // $ANTLR end "IDENTIFIER" + +- // $ANTLR start LETTER +- public void mLETTER() throws RecognitionException { ++ // $ANTLR start "LETTER" ++ public final void mLETTER() throws RecognitionException { + try { +- ruleNestingLevel++; +- // Bst.g:71:4: ( ('a'..'z'|'A'..'Z'|'.'|'$')) +- // Bst.g:71:4: ('a'..'z'|'A'..'Z'|'.'|'$') ++ // Bst.g:71:2: ( ( 'a' .. 'z' | 'A' .. 'Z' | '.' | '$' ) ) ++ // Bst.g:71:4: ( 'a' .. 'z' | 'A' .. 'Z' | '.' | '$' ) + { + if ( input.LA(1)=='$'||input.LA(1)=='.'||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { +- MismatchedSetException mse = +- new MismatchedSetException(null,input); +- recover(mse); throw mse; +- } ++ MismatchedSetException mse = new MismatchedSetException(null,input); ++ recover(mse); ++ throw mse;} + + + } + + } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end LETTER ++ // $ANTLR end "LETTER" + +- // $ANTLR start STRING +- public void mSTRING() throws RecognitionException { ++ // $ANTLR start "STRING" ++ public final void mSTRING() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = STRING; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:74:4: ( '\"' (~ '\"' )* '\"' ) +- // Bst.g:74:4: '\"' (~ '\"' )* '\"' ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:74:2: ( '\"' (~ ( '\"' ) )* '\"' ) ++ // Bst.g:74:4: '\"' (~ ( '\"' ) )* '\"' + { + match('\"'); +- // Bst.g:74:8: (~ '\"' )* ++ // Bst.g:74:8: (~ ( '\"' ) )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); +- if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='\uFFFE')) ) { ++ ++ if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='\uFFFF')) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : +- // Bst.g:74:9: ~ '\"' ++ // Bst.g:74:9: ~ ( '\"' ) + { +- if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFE') ) { ++ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { +- MismatchedSetException mse = +- new MismatchedSetException(null,input); +- recover(mse); throw mse; +- } ++ MismatchedSetException mse = new MismatchedSetException(null,input); ++ recover(mse); ++ throw mse;} + + + } +@@ -783,51 +590,42 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end STRING ++ // $ANTLR end "STRING" + +- // $ANTLR start INTEGER +- public void mINTEGER() throws RecognitionException { ++ // $ANTLR start "INTEGER" ++ public final void mINTEGER() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = INTEGER; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:77:4: ( '#' ( ('+'|'-'))? ( NUMERAL )+ ) +- // Bst.g:77:4: '#' ( ('+'|'-'))? ( NUMERAL )+ ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:77:2: ( '#' ( '+' | '-' )? ( NUMERAL )+ ) ++ // Bst.g:77:4: '#' ( '+' | '-' )? ( NUMERAL )+ + { + match('#'); +- // Bst.g:77:8: ( ('+'|'-'))? ++ // Bst.g:77:8: ( '+' | '-' )? + int alt3=2; + int LA3_0 = input.LA(1); ++ + if ( (LA3_0=='+'||LA3_0=='-') ) { + alt3=1; + } + switch (alt3) { + case 1 : +- // Bst.g:77:9: ('+'|'-') ++ // Bst.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { +- MismatchedSetException mse = +- new MismatchedSetException(null,input); +- recover(mse); throw mse; +- } ++ MismatchedSetException mse = new MismatchedSetException(null,input); ++ recover(mse); ++ throw mse;} + + + } +@@ -841,6 +639,7 @@ + do { + int alt4=2; + int LA4_0 = input.LA(1); ++ + if ( ((LA4_0>='0' && LA4_0<='9')) ) { + alt4=1; + } +@@ -867,24 +666,18 @@ + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end INTEGER ++ // $ANTLR end "INTEGER" + +- // $ANTLR start NUMERAL +- public void mNUMERAL() throws RecognitionException { ++ // $ANTLR start "NUMERAL" ++ public final void mNUMERAL() throws RecognitionException { + try { +- ruleNestingLevel++; +- // Bst.g:80:4: ( ( '0' .. '9' ) ) ++ // Bst.g:80:2: ( ( '0' .. '9' ) ) + // Bst.g:80:4: ( '0' .. '9' ) + { + // Bst.g:80:4: ( '0' .. '9' ) +@@ -899,47 +692,42 @@ + + } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end NUMERAL ++ // $ANTLR end "NUMERAL" + +- // $ANTLR start WS +- public void mWS() throws RecognitionException { ++ // $ANTLR start "WS" ++ public final void mWS() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = WS; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:82:9: ( ( (' '|'\\t'|'\\r'|'\\n'))+ ) +- // Bst.g:82:9: ( (' '|'\\t'|'\\r'|'\\n'))+ ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:83:2: ( ( ' ' | '\\t' | '\\n' )+ ) ++ // Bst.g:83:4: ( ' ' | '\\t' | '\\n' )+ + { +- // Bst.g:82:9: ( (' '|'\\t'|'\\r'|'\\n'))+ ++ // Bst.g:83:4: ( ' ' | '\\t' | '\\n' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); +- if ( ((LA5_0>='\t' && LA5_0<='\n')||LA5_0=='\r'||LA5_0==' ') ) { ++ ++ if ( ((LA5_0>='\t' && LA5_0<='\n')||LA5_0==' ') ) { + alt5=1; + } + + + switch (alt5) { + case 1 : +- // Bst.g:82:13: (' '|'\\t'|'\\r'|'\\n') ++ // Bst.g: + { +- if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { ++ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)==' ' ) { + input.consume(); + + } + else { +- MismatchedSetException mse = +- new MismatchedSetException(null,input); +- recover(mse); throw mse; +- } ++ MismatchedSetException mse = new MismatchedSetException(null,input); ++ recover(mse); ++ throw mse;} + + + } +@@ -954,59 +742,50 @@ + cnt5++; + } while (true); + +- _channel=HIDDEN; ++ _channel=99; + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end WS ++ // $ANTLR end "WS" + +- // $ANTLR start LINE_COMMENT +- public void mLINE_COMMENT() throws RecognitionException { ++ // $ANTLR start "LINE_COMMENT" ++ public final void mLINE_COMMENT() throws RecognitionException { + try { +- ruleNestingLevel++; + int _type = LINE_COMMENT; +- int _start = getCharIndex(); +- int _line = getLine(); +- int _charPosition = getCharPositionInLine(); +- int _channel = Token.DEFAULT_CHANNEL; +- // Bst.g:90:7: ( '%' (~ ('\\n'|'\\r'))* ( '\\r' )? '\\n' ) +- // Bst.g:90:7: '%' (~ ('\\n'|'\\r'))* ( '\\r' )? '\\n' ++ int _channel = DEFAULT_TOKEN_CHANNEL; ++ // Bst.g:86:5: ( '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) ++ // Bst.g:86:7: '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' + { + match('%'); +- // Bst.g:90:11: (~ ('\\n'|'\\r'))* ++ // Bst.g:86:11: (~ ( '\\n' | '\\r' ) )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); +- if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFE')) ) { ++ ++ if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : +- // Bst.g:90:11: ~ ('\\n'|'\\r') ++ // Bst.g:86:11: ~ ( '\\n' | '\\r' ) + { +- 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') ) { ++ 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') ) { + input.consume(); + + } + else { +- MismatchedSetException mse = +- new MismatchedSetException(null,input); +- recover(mse); throw mse; +- } ++ MismatchedSetException mse = new MismatchedSetException(null,input); ++ recover(mse); ++ throw mse;} + + + } +@@ -1017,15 +796,16 @@ + } + } while (true); + +- // Bst.g:90:25: ( '\\r' )? ++ // Bst.g:86:25: ( '\\r' )? + int alt7=2; + int LA7_0 = input.LA(1); ++ + if ( (LA7_0=='\r') ) { + alt7=1; + } + switch (alt7) { + case 1 : +- // Bst.g:90:25: '\\r' ++ // Bst.g:86:25: '\\r' + { + match('\r'); + +@@ -1035,619 +815,193 @@ + } + + match('\n'); +- _channel=HIDDEN; ++ _channel=99; + + } + +- +- +- if ( token==null && ruleNestingLevel==1 ) { +- emit(_type,_line,_charPosition,_channel,_start,getCharIndex()-1); +- } +- +- } ++ state.type = _type; ++ state.channel = _channel; ++ } + finally { +- ruleNestingLevel--; + } + } +- // $ANTLR end LINE_COMMENT ++ // $ANTLR end "LINE_COMMENT" + + public void mTokens() throws RecognitionException { +- // 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 ) ++ // 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 ) + int alt8=25; +- switch ( input.LA(1) ) { +- case '{': +- alt8=1; +- break; +- case '}': +- alt8=2; +- break; +- case '<': +- alt8=3; +- break; +- case '>': +- alt8=4; +- break; +- case '=': +- alt8=5; +- break; +- case '+': +- alt8=6; +- break; +- case '-': +- alt8=7; +- break; +- case ':': +- alt8=8; +- break; +- case '*': +- alt8=9; +- break; +- case 'S': +- switch ( input.LA(2) ) { +- case 'T': +- int LA8_22 = input.LA(3); +- if ( (LA8_22=='R') ) { +- int LA8_31 = input.LA(4); +- if ( (LA8_31=='I') ) { +- int LA8_41 = input.LA(5); +- if ( (LA8_41=='N') ) { +- int LA8_51 = input.LA(6); +- if ( (LA8_51=='G') ) { +- int LA8_61 = input.LA(7); +- if ( (LA8_61=='S') ) { +- int LA8_69 = input.LA(8); +- if ( (LA8_69=='$'||LA8_69=='.'||(LA8_69>='0' && LA8_69<='9')||(LA8_69>='A' && LA8_69<='Z')||(LA8_69>='a' && LA8_69<='z')) ) { +- alt8=21; +- } +- else { +- alt8=10;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- case 'O': +- int LA8_23 = input.LA(3); +- if ( (LA8_23=='R') ) { +- int LA8_32 = input.LA(4); +- if ( (LA8_32=='T') ) { +- int LA8_42 = input.LA(5); +- if ( (LA8_42=='$'||LA8_42=='.'||(LA8_42>='0' && LA8_42<='9')||(LA8_42>='A' && LA8_42<='Z')||(LA8_42>='a' && LA8_42<='z')) ) { +- alt8=21; +- } +- else { +- alt8=14;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- default: +- alt8=21;} +- +- break; +- case 'I': +- switch ( input.LA(2) ) { +- case 'T': +- int LA8_24 = input.LA(3); +- if ( (LA8_24=='E') ) { +- int LA8_33 = input.LA(4); +- if ( (LA8_33=='R') ) { +- int LA8_43 = input.LA(5); +- if ( (LA8_43=='A') ) { +- int LA8_53 = input.LA(6); +- if ( (LA8_53=='T') ) { +- int LA8_62 = input.LA(7); +- if ( (LA8_62=='E') ) { +- int LA8_70 = input.LA(8); +- if ( (LA8_70=='$'||LA8_70=='.'||(LA8_70>='0' && LA8_70<='9')||(LA8_70>='A' && LA8_70<='Z')||(LA8_70>='a' && LA8_70<='z')) ) { +- alt8=21; +- } +- else { +- alt8=15;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- case 'N': +- int LA8_25 = input.LA(3); +- if ( (LA8_25=='T') ) { +- int LA8_34 = input.LA(4); +- if ( (LA8_34=='E') ) { +- int LA8_44 = input.LA(5); +- if ( (LA8_44=='G') ) { +- int LA8_54 = input.LA(6); +- if ( (LA8_54=='E') ) { +- int LA8_63 = input.LA(7); +- if ( (LA8_63=='R') ) { +- int LA8_71 = input.LA(8); +- if ( (LA8_71=='S') ) { +- int LA8_77 = input.LA(9); +- if ( (LA8_77=='$'||LA8_77=='.'||(LA8_77>='0' && LA8_77<='9')||(LA8_77>='A' && LA8_77<='Z')||(LA8_77>='a' && LA8_77<='z')) ) { +- alt8=21; +- } +- else { +- alt8=11;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- default: +- alt8=21;} +- +- break; +- case 'F': +- int LA8_12 = input.LA(2); +- if ( (LA8_12=='U') ) { +- int LA8_26 = input.LA(3); +- if ( (LA8_26=='N') ) { +- int LA8_35 = input.LA(4); +- if ( (LA8_35=='C') ) { +- int LA8_45 = input.LA(5); +- if ( (LA8_45=='T') ) { +- int LA8_55 = input.LA(6); +- if ( (LA8_55=='I') ) { +- int LA8_64 = input.LA(7); +- if ( (LA8_64=='O') ) { +- int LA8_72 = input.LA(8); +- if ( (LA8_72=='N') ) { +- int LA8_78 = input.LA(9); +- if ( (LA8_78=='$'||LA8_78=='.'||(LA8_78>='0' && LA8_78<='9')||(LA8_78>='A' && LA8_78<='Z')||(LA8_78>='a' && LA8_78<='z')) ) { +- alt8=21; +- } +- else { +- alt8=12;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- case 'E': +- switch ( input.LA(2) ) { +- case 'N': +- int LA8_27 = input.LA(3); +- if ( (LA8_27=='T') ) { +- int LA8_36 = input.LA(4); +- if ( (LA8_36=='R') ) { +- int LA8_46 = input.LA(5); +- if ( (LA8_46=='Y') ) { +- int LA8_56 = input.LA(6); +- if ( (LA8_56=='$'||LA8_56=='.'||(LA8_56>='0' && LA8_56<='9')||(LA8_56>='A' && LA8_56<='Z')||(LA8_56>='a' && LA8_56<='z')) ) { +- alt8=21; +- } +- else { +- alt8=17;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- case 'X': +- int LA8_28 = input.LA(3); +- if ( (LA8_28=='E') ) { +- int LA8_37 = input.LA(4); +- if ( (LA8_37=='C') ) { +- int LA8_47 = input.LA(5); +- if ( (LA8_47=='U') ) { +- int LA8_57 = input.LA(6); +- if ( (LA8_57=='T') ) { +- int LA8_66 = input.LA(7); +- if ( (LA8_66=='E') ) { +- int LA8_73 = input.LA(8); +- if ( (LA8_73=='$'||LA8_73=='.'||(LA8_73>='0' && LA8_73<='9')||(LA8_73>='A' && LA8_73<='Z')||(LA8_73>='a' && LA8_73<='z')) ) { +- alt8=21; +- } +- else { +- alt8=13;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- default: +- alt8=21;} +- +- break; +- case 'R': +- int LA8_14 = input.LA(2); +- if ( (LA8_14=='E') ) { +- switch ( input.LA(3) ) { +- case 'A': +- int LA8_38 = input.LA(4); +- if ( (LA8_38=='D') ) { +- int LA8_48 = input.LA(5); +- if ( (LA8_48=='$'||LA8_48=='.'||(LA8_48>='0' && LA8_48<='9')||(LA8_48>='A' && LA8_48<='Z')||(LA8_48>='a' && LA8_48<='z')) ) { +- alt8=21; +- } +- else { +- alt8=18;} +- } +- else { +- alt8=21;} +- break; +- case 'V': +- int LA8_39 = input.LA(4); +- if ( (LA8_39=='E') ) { +- int LA8_49 = input.LA(5); +- if ( (LA8_49=='R') ) { +- int LA8_59 = input.LA(6); +- if ( (LA8_59=='S') ) { +- int LA8_67 = input.LA(7); +- if ( (LA8_67=='E') ) { +- int LA8_74 = input.LA(8); +- if ( (LA8_74=='$'||LA8_74=='.'||(LA8_74>='0' && LA8_74<='9')||(LA8_74>='A' && LA8_74<='Z')||(LA8_74>='a' && LA8_74<='z')) ) { +- alt8=21; +- } +- else { +- alt8=16;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- default: +- alt8=21;} +- +- } +- else { +- alt8=21;} +- break; +- case 'M': +- int LA8_15 = input.LA(2); +- if ( (LA8_15=='A') ) { +- int LA8_30 = input.LA(3); +- if ( (LA8_30=='C') ) { +- int LA8_40 = input.LA(4); +- if ( (LA8_40=='R') ) { +- int LA8_50 = input.LA(5); +- if ( (LA8_50=='O') ) { +- int LA8_60 = input.LA(6); +- if ( (LA8_60=='$'||LA8_60=='.'||(LA8_60>='0' && LA8_60<='9')||(LA8_60>='A' && LA8_60<='Z')||(LA8_60>='a' && LA8_60<='z')) ) { +- alt8=21; +- } +- else { +- alt8=19;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- } +- else { +- alt8=21;} +- break; +- case '\'': +- alt8=20; +- break; +- case '$': +- case '.': +- case 'A': +- case 'B': +- case 'C': +- case 'D': +- case 'G': +- case 'H': +- case 'J': +- case 'K': +- case 'L': +- case 'N': +- case 'O': +- case 'P': +- case 'Q': +- case 'T': +- case 'U': +- case 'V': +- case 'W': +- case 'X': +- case 'Y': +- case 'Z': +- case 'a': +- case 'b': +- case 'c': +- case 'd': +- case 'e': +- case 'f': +- case 'g': +- case 'h': +- case 'i': +- case 'j': +- case 'k': +- case 'l': +- case 'm': +- case 'n': +- case 'o': +- case 'p': +- case 'q': +- case 'r': +- case 's': +- case 't': +- case 'u': +- case 'v': +- case 'w': +- case 'x': +- case 'y': +- case 'z': +- alt8=21; +- break; +- case '\"': +- alt8=22; +- break; +- case '#': +- alt8=23; +- break; +- case '\t': +- case '\n': +- case '\r': +- case ' ': +- alt8=24; +- break; +- case '%': +- alt8=25; +- break; +- default: +- NoViableAltException nvae = +- 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); +- +- throw nvae; +- } +- ++ alt8 = dfa8.predict(input); + switch (alt8) { + case 1 : +- // Bst.g:1:10: T25 ++ // Bst.g:1:10: T__25 + { +- mT25(); ++ mT__25(); + + } + break; + case 2 : +- // Bst.g:1:14: T26 ++ // Bst.g:1:16: T__26 + { +- mT26(); ++ mT__26(); + + } + break; + case 3 : +- // Bst.g:1:18: T27 ++ // Bst.g:1:22: T__27 + { +- mT27(); ++ mT__27(); + + } + break; + case 4 : +- // Bst.g:1:22: T28 ++ // Bst.g:1:28: T__28 + { +- mT28(); ++ mT__28(); + + } + break; + case 5 : +- // Bst.g:1:26: T29 ++ // Bst.g:1:34: T__29 + { +- mT29(); ++ mT__29(); + + } + break; + case 6 : +- // Bst.g:1:30: T30 ++ // Bst.g:1:40: T__30 + { +- mT30(); ++ mT__30(); + + } + break; + case 7 : +- // Bst.g:1:34: T31 ++ // Bst.g:1:46: T__31 + { +- mT31(); ++ mT__31(); + + } + break; + case 8 : +- // Bst.g:1:38: T32 ++ // Bst.g:1:52: T__32 + { +- mT32(); ++ mT__32(); + + } + break; + case 9 : +- // Bst.g:1:42: T33 ++ // Bst.g:1:58: T__33 + { +- mT33(); ++ mT__33(); + + } + break; + case 10 : +- // Bst.g:1:46: STRINGS ++ // Bst.g:1:64: STRINGS + { + mSTRINGS(); + + } + break; + case 11 : +- // Bst.g:1:54: INTEGERS ++ // Bst.g:1:72: INTEGERS + { + mINTEGERS(); + + } + break; + case 12 : +- // Bst.g:1:63: FUNCTION ++ // Bst.g:1:81: FUNCTION + { + mFUNCTION(); + + } + break; + case 13 : +- // Bst.g:1:72: EXECUTE ++ // Bst.g:1:90: EXECUTE + { + mEXECUTE(); + + } + break; + case 14 : +- // Bst.g:1:80: SORT ++ // Bst.g:1:98: SORT + { + mSORT(); + + } + break; + case 15 : +- // Bst.g:1:85: ITERATE ++ // Bst.g:1:103: ITERATE + { + mITERATE(); + + } + break; + case 16 : +- // Bst.g:1:93: REVERSE ++ // Bst.g:1:111: REVERSE + { + mREVERSE(); + + } + break; + case 17 : +- // Bst.g:1:101: ENTRY ++ // Bst.g:1:119: ENTRY + { + mENTRY(); + + } + break; + case 18 : +- // Bst.g:1:107: READ ++ // Bst.g:1:125: READ + { + mREAD(); + + } + break; + case 19 : +- // Bst.g:1:112: MACRO ++ // Bst.g:1:130: MACRO + { + mMACRO(); + + } + break; + case 20 : +- // Bst.g:1:118: QUOTED ++ // Bst.g:1:136: QUOTED + { + mQUOTED(); + + } + break; + case 21 : +- // Bst.g:1:125: IDENTIFIER ++ // Bst.g:1:143: IDENTIFIER + { + mIDENTIFIER(); + + } + break; + case 22 : +- // Bst.g:1:136: STRING ++ // Bst.g:1:154: STRING + { + mSTRING(); + + } + break; + case 23 : +- // Bst.g:1:143: INTEGER ++ // Bst.g:1:161: INTEGER + { + mINTEGER(); + + } + break; + case 24 : +- // Bst.g:1:151: WS ++ // Bst.g:1:169: WS + { + mWS(); + + } + break; + case 25 : +- // Bst.g:1:154: LINE_COMMENT ++ // Bst.g:1:172: LINE_COMMENT + { + mLINE_COMMENT(); + +@@ -1659,6 +1013,167 @@ + } + + ++ protected DFA8 dfa8 = new DFA8(this); ++ static final String DFA8_eotS = ++ "\12\uffff\6\21\6\uffff\24\21\1\64\6\21\1\73\2\21\1\uffff\4\21\1"+ ++ "\102\1\21\1\uffff\1\104\5\21\1\uffff\1\21\1\uffff\1\113\1\21\1\115"+ ++ "\1\21\1\117\1\120\1\uffff\1\121\1\uffff\1\122\4\uffff"; ++ static final String DFA8_eofS = ++ "\123\uffff"; ++ static final String DFA8_minS = ++ "\1\11\11\uffff\1\117\1\116\1\125\1\116\1\105\1\101\6\uffff\2\122"+ ++ "\1\124\1\105\1\116\1\105\1\124\1\101\1\103\1\111\1\124\1\105\1\122"+ ++ "\2\103\1\122\1\105\1\104\1\122\1\116\1\44\1\107\1\101\1\124\1\125"+ ++ "\1\131\1\122\1\44\1\117\1\107\1\uffff\1\105\1\124\1\111\1\124\1"+ ++ "\44\1\123\1\uffff\1\44\1\123\1\122\1\105\1\117\1\105\1\uffff\1\105"+ ++ "\1\uffff\1\44\1\123\1\44\1\116\2\44\1\uffff\1\44\1\uffff\1\44\4"+ ++ "\uffff"; ++ static final String DFA8_maxS = ++ "\1\175\11\uffff\2\124\1\125\1\130\1\105\1\101\6\uffff\2\122\1\124"+ ++ "\1\105\1\116\1\105\1\124\1\126\1\103\1\111\1\124\1\105\1\122\2\103"+ ++ "\1\122\1\105\1\104\1\122\1\116\1\172\1\107\1\101\1\124\1\125\1\131"+ ++ "\1\122\1\172\1\117\1\107\1\uffff\1\105\1\124\1\111\1\124\1\172\1"+ ++ "\123\1\uffff\1\172\1\123\1\122\1\105\1\117\1\105\1\uffff\1\105\1"+ ++ "\uffff\1\172\1\123\1\172\1\116\2\172\1\uffff\1\172\1\uffff\1\172"+ ++ "\4\uffff"; ++ static final String DFA8_acceptS = ++ "\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"+ ++ "\1\26\1\27\1\30\1\31\36\uffff\1\16\6\uffff\1\22\6\uffff\1\21\1\uffff"+ ++ "\1\23\6\uffff\1\12\1\uffff\1\17\1\uffff\1\15\1\20\1\13\1\14"; ++ static final String DFA8_specialS = ++ "\123\uffff}>"; ++ static final String[] DFA8_transitionS = { ++ "\2\24\25\uffff\1\24\1\uffff\1\22\1\23\1\21\1\25\1\uffff\1\20"+ ++ "\2\uffff\1\11\1\6\1\uffff\1\7\1\21\13\uffff\1\10\1\uffff\1\3"+ ++ "\1\5\1\4\2\uffff\4\21\1\15\1\14\2\21\1\13\3\21\1\17\4\21\1\16"+ ++ "\1\12\7\21\6\uffff\32\21\1\1\1\uffff\1\2", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "\1\27\4\uffff\1\26", ++ "\1\30\5\uffff\1\31", ++ "\1\32", ++ "\1\34\11\uffff\1\33", ++ "\1\35", ++ "\1\36", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++ "\1\37", ++ "\1\40", ++ "\1\41", ++ "\1\42", ++ "\1\43", ++ "\1\44", ++ "\1\45", ++ "\1\47\24\uffff\1\46", ++ "\1\50", ++ "\1\51", ++ "\1\52", ++ "\1\53", ++ "\1\54", ++ "\1\55", ++ "\1\56", ++ "\1\57", ++ "\1\60", ++ "\1\61", ++ "\1\62", ++ "\1\63", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\65", ++ "\1\66", ++ "\1\67", ++ "\1\70", ++ "\1\71", ++ "\1\72", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\74", ++ "\1\75", ++ "", ++ "\1\76", ++ "\1\77", ++ "\1\100", ++ "\1\101", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\103", ++ "", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\105", ++ "\1\106", ++ "\1\107", ++ "\1\110", ++ "\1\111", ++ "", ++ "\1\112", ++ "", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\114", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\116", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "", ++ "\1\21\11\uffff\1\21\1\uffff\12\21\7\uffff\32\21\6\uffff\32"+ ++ "\21", ++ "", ++ "", ++ "", ++ "" ++ }; ++ ++ static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS); ++ static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS); ++ static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS); ++ static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS); ++ static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS); ++ static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS); ++ static final short[][] DFA8_transition; ++ ++ static { ++ int numStates = DFA8_transitionS.length; ++ DFA8_transition = new short[numStates][]; ++ for (int i=0; i<numStates; i++) { ++ DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]); ++ } ++ } ++ ++ class DFA8 extends DFA { ++ ++ public DFA8(BaseRecognizer recognizer) { ++ this.recognizer = recognizer; ++ this.decisionNumber = 8; ++ this.eot = DFA8_eot; ++ this.eof = DFA8_eof; ++ this.min = DFA8_min; ++ this.max = DFA8_max; ++ this.accept = DFA8_accept; ++ this.special = DFA8_special; ++ this.transition = DFA8_transition; ++ } ++ public String getDescription() { ++ return "1:1: Tokens : ( 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 );"; ++ } ++ } + + +-} +\ No newline at end of file ++} +Index: Bst.g +=================================================================== +--- a/src/java/net/sf/jabref/bst/Bst.g ++++ b/src/java/net/sf/jabref/bst/Bst.g +@@ -0,0 +1,90 @@ ++grammar Bst; ++ ++header { package net.sf.jabref.bst; } ++ ++options { ++ output=AST; ++} ++ ++tokens { ++ IDLIST; ++ STACK; ++ ENTRY; ++ COMMANDS; ++} ++ ++program : commands+ -> ^(COMMANDS commands+); ++ ++commands ++ : STRINGS^ idList ++ | INTEGERS^ idList ++ | FUNCTION^ id stack ++ | MACRO^ id '{'! STRING '}'! ++ | READ^ ++ | EXECUTE^ '{'! function '}'! ++ | ITERATE^ '{'! function '}'! ++ | REVERSE^ '{'! function '}'! ++ | ENTRY^ idList0 idList0 idList0 ++ | SORT^; ++ ++identifier ++ : IDENTIFIER; ++ ++id ++ : '{'! identifier '}'!; ++ ++idList ++ : '{' identifier+ '}' -> ^(IDLIST identifier+); ++ ++idList0 ++ : '{' identifier* '}' -> ^(IDLIST identifier*); ++ ++function ++ : '<' | '>' | '=' | '+' | '-' | ':=' | '*' | identifier; ++ ++stack ++ : '{' stackitem+ '}' -> ^(STACK stackitem+); ++ ++stackitem ++ : function ++ | STRING ++ | INTEGER ++ | QUOTED ++ | stack; ++ ++STRINGS : 'STRINGS'; ++INTEGERS : 'INTEGERS'; ++FUNCTION : 'FUNCTION'; ++EXECUTE : 'EXECUTE'; ++SORT : 'SORT'; ++ITERATE : 'ITERATE'; ++REVERSE : 'REVERSE'; ++ENTRY : 'ENTRY'; ++READ : 'READ'; ++MACRO : 'MACRO'; ++ ++QUOTED ++ : '\'' IDENTIFIER; ++ ++IDENTIFIER ++ : LETTER (LETTER|NUMERAL)* ; ++ ++fragment LETTER ++ : ('a'..'z'|'A'..'Z'|'.'|'$'); ++ ++STRING ++ : '"' (~('"'))* '"'; ++ ++INTEGER ++ : '#' ('+'|'-')? NUMERAL+ ; ++ ++fragment NUMERAL ++ : ('0'..'9'); ++ ++WS ++ : (' '|'\t'|'\n')+ {channel=99;} ; ++ ++LINE_COMMENT ++ : '%' ~('\n'|'\r')* '\r'? '\n' {channel=99;} ++ ; ++ diff --git a/debian/patches/series b/debian/patches/series index 3310824..6b89451 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1,4 +1,4 @@ 01_free_javac.patch 02_libs.patch -05_antlr.patch +05_antlr32.patch 06_BibtexEntry.patch -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/jabref.git _______________________________________________ pkg-java-commits mailing list [email protected] http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-java-commits
