From 91e92b2fbaa6afe5c3a80e2be671425cc739b7df0eee9eaa99ef9f5b12bbbda5 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 05:19:30 +0000 Subject: [PATCH 01/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=24 --- antlr3.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/antlr3.spec b/antlr3.spec index 4547beb..86b48ca 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -149,7 +149,7 @@ find -type f -a -name *.class -delete %endif %pom_remove_plugin :maven-source-plugin -%pom_remove_plugin :maven-javadoc-plugin +%pom_remove_plugin -r :maven-javadoc-plugin %pom_remove_plugin :maven-enforcer-plugin # compile for target 1.8 From e104451e9fe800140f765069e7f7fd80ffa7a31cc5fd9a78dd996d32cea8eaa3 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 10:03:15 +0000 Subject: [PATCH 02/16] Accepting request 1111485 from home:bmwiedemann:branches:Java:packages Override build date (boo#1047218)" OBS-URL: https://build.opensuse.org/request/show/1111485 OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=25 --- antlr3.changes | 5 +++++ antlr3.spec | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/antlr3.changes b/antlr3.changes index e38dde8..9583b3e 100644 --- a/antlr3.changes +++ b/antlr3.changes @@ -1,3 +1,8 @@ +------------------------------------------------------------------- +Fri Sep 15 08:19:19 UTC 2023 - Bernhard Wiedemann + +- Override build date (boo#1047218)" + ------------------------------------------------------------------- Fri Mar 17 06:55:33 UTC 2023 - Fridrich Strba diff --git a/antlr3.spec b/antlr3.spec index 86b48ca..c45ca35 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -128,7 +128,7 @@ BuildArch: noarch %pom_remove_plugin :antlr3-maven-plugin tool %endif -sed -i "s,\${buildNumber},`cat %{_sysconfdir}/fedora-release` `date`," tool/src/main/resources/org/antlr/antlr.properties +sed -i "s,\${buildNumber},`cat %{_sysconfdir}/fedora-release` `date -u -d@${SOURCE_DATE_EPOCH:-$(date +%%s)}`," tool/src/main/resources/org/antlr/antlr.properties %patch0 -p1 %patch1 From 94558cfa59a96139d350f6b8d2cbe8f42a13f539b3b6e3c2413f04e41d388512 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 10:08:35 +0000 Subject: [PATCH 03/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=26 --- antlr3.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/antlr3.spec b/antlr3.spec index c45ca35..9b803a0 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -128,7 +128,7 @@ BuildArch: noarch %pom_remove_plugin :antlr3-maven-plugin tool %endif -sed -i "s,\${buildNumber},`cat %{_sysconfdir}/fedora-release` `date -u -d@${SOURCE_DATE_EPOCH:-$(date +%%s)}`," tool/src/main/resources/org/antlr/antlr.properties +sed -i "s,\${buildNumber},`date -u -d@${SOURCE_DATE_EPOCH:-$(date +%%s)}`," tool/src/main/resources/org/antlr/antlr.properties %patch0 -p1 %patch1 From 2da23db509bb0e2e2ed3f09977e7f236c8a2302cb9d64a5b8dad2bff2e6a5f57 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 16:05:45 +0000 Subject: [PATCH 04/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=27 --- antlr3.changes | 9 +++++++++ antlr3.spec | 4 ++++ reproducible-order.patch | 30 ++++++++++++++++++++++++++++++ reproducible-timestamp.patch | 12 ++++++++++++ 4 files changed, 55 insertions(+) create mode 100644 reproducible-order.patch create mode 100644 reproducible-timestamp.patch diff --git a/antlr3.changes b/antlr3.changes index 9583b3e..02025dc 100644 --- a/antlr3.changes +++ b/antlr3.changes @@ -1,3 +1,12 @@ +------------------------------------------------------------------- +Fri Sep 15 16:02:58 UTC 2023 - Fridrich Strba + +- Added patches: + * reproducible-order.patch + + ensure reproducible elements order by sorting + * reproducible-timestamp.patch + + support SOURCE_DATE_EPOCH for generatedTimestamp + ------------------------------------------------------------------- Fri Sep 15 08:19:19 UTC 2023 - Bernhard Wiedemann diff --git a/antlr3.spec b/antlr3.spec index 9b803a0..66be845 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -37,6 +37,8 @@ Source0: https://github.com/antlr/antlr3/archive/%{antlr_version}.tar.gz Patch0: antlr3-java8-fix.patch # Generate OSGi metadata Patch1: antlr3-osgi-manifest.patch +Patch2: reproducible-order.patch +Patch3: reproducible-timestamp.patch Patch100: antlr3-generated_sources.patch BuildRequires: fdupes BuildRequires: java-devel >= 1.8 @@ -131,6 +133,8 @@ BuildArch: noarch sed -i "s,\${buildNumber},`date -u -d@${SOURCE_DATE_EPOCH:-$(date +%%s)}`," tool/src/main/resources/org/antlr/antlr.properties %patch0 -p1 %patch1 +%patch2 -p1 +%patch3 -p1 # remove pre-built artifacts find -type f -a -name *.jar -delete diff --git a/reproducible-order.patch b/reproducible-order.patch new file mode 100644 index 0000000..ec6787f --- /dev/null +++ b/reproducible-order.patch @@ -0,0 +1,30 @@ +--- antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 17:54:38.044172037 +0200 ++++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 17:58:10.758972706 +0200 +@@ -56,6 +56,7 @@ + import java.util.HashSet; + import java.util.Set; + import java.util.Collection; ++import java.util.Collections; + import org.antlr.runtime.BitSet; + import org.antlr.runtime.DFA; + import org.stringtemplate.v4.ST; +@@ -284,6 +285,7 @@ + } + labels.add( label ); + } ++ Collections.sort(labels); // ensure reproducible order + return labels; + } + +--- antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:38.044172037 +0200 ++++ antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:49.090915002 +0200 +@@ -1052,6 +1052,9 @@ + */ + public static String getCurrentTimeStamp() { + GregorianCalendar calendar = new java.util.GregorianCalendar(); ++ if (System.getenv("SOURCE_DATE_EPOCH") != null) { ++ calendar.setTimeInMillis(1000 * Long.parseLong(System.getenv("SOURCE_DATE_EPOCH"))); ++ } + int y = calendar.get(Calendar.YEAR); + int m = calendar.get(Calendar.MONTH) + 1; // zero-based for months + int d = calendar.get(Calendar.DAY_OF_MONTH); diff --git a/reproducible-timestamp.patch b/reproducible-timestamp.patch new file mode 100644 index 0000000..bf055c8 --- /dev/null +++ b/reproducible-timestamp.patch @@ -0,0 +1,12 @@ +--- antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:38.044172037 +0200 ++++ antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:49.090915002 +0200 +@@ -1052,6 +1052,9 @@ + */ + public static String getCurrentTimeStamp() { + GregorianCalendar calendar = new java.util.GregorianCalendar(); ++ if (System.getenv("SOURCE_DATE_EPOCH") != null) { ++ calendar.setTimeInMillis(1000 * Long.parseLong(System.getenv("SOURCE_DATE_EPOCH"))); ++ } + int y = calendar.get(Calendar.YEAR); + int m = calendar.get(Calendar.MONTH) + 1; // zero-based for months + int d = calendar.get(Calendar.DAY_OF_MONTH); From ace951642879aacdf0c050e55786a1fda087343f554132c0a8688d0c75a3a0e4 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 16:07:22 +0000 Subject: [PATCH 05/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=28 --- reproducible-order.patch | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/reproducible-order.patch b/reproducible-order.patch index ec6787f..ef3e1b7 100644 --- a/reproducible-order.patch +++ b/reproducible-order.patch @@ -16,15 +16,3 @@ return labels; } ---- antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:38.044172037 +0200 -+++ antlr3-3.5.3/tool/src/main/java/org/antlr/Tool.java 2023-09-15 17:54:49.090915002 +0200 -@@ -1052,6 +1052,9 @@ - */ - public static String getCurrentTimeStamp() { - GregorianCalendar calendar = new java.util.GregorianCalendar(); -+ if (System.getenv("SOURCE_DATE_EPOCH") != null) { -+ calendar.setTimeInMillis(1000 * Long.parseLong(System.getenv("SOURCE_DATE_EPOCH"))); -+ } - int y = calendar.get(Calendar.YEAR); - int m = calendar.get(Calendar.MONTH) + 1; // zero-based for months - int d = calendar.get(Calendar.DAY_OF_MONTH); From 327f82b53dbc65bbf09255083a207eeb820a6a7af422dc9c34fea769f90451df Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Fri, 15 Sep 2023 16:25:53 +0000 Subject: [PATCH 06/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=29 --- antlr3-generated_sources.patch | 4 +++- antlr3.changes | 3 +++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index 3345545..9c4c146 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -42549,7 +42549,7 @@ +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 +++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2019-04-04 17:22:25.476181469 +0200 -@@ -0,0 +1,5303 @@ +@@ -0,0 +1,5305 @@ +// $ANTLR 3.5.2 org/antlr/grammar/v3/CodeGenTreeWalker.g 2019-04-04 15:18:50 + +package org.antlr.grammar.v3; @@ -42562,6 +42562,7 @@ +import java.util.HashSet; +import java.util.Set; +import java.util.Collection; ++import java.util.Collections; +import org.antlr.runtime.BitSet; +import org.antlr.runtime.DFA; +import org.stringtemplate.v4.ST; @@ -42943,6 +42944,7 @@ + // must be char or String literal + label = generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText())); + } ++ Collections.sort(labels); // ensure reproducible order + labels.add( label ); + } + return labels; diff --git a/antlr3.changes b/antlr3.changes index 02025dc..48b92f0 100644 --- a/antlr3.changes +++ b/antlr3.changes @@ -6,6 +6,9 @@ Fri Sep 15 16:02:58 UTC 2023 - Fridrich Strba + ensure reproducible elements order by sorting * reproducible-timestamp.patch + support SOURCE_DATE_EPOCH for generatedTimestamp +- Modified patch: + * antlr3-generated_sources.patch + + regenerate to correspong to the reproducible-order.patch ------------------------------------------------------------------- Fri Sep 15 08:19:19 UTC 2023 - Bernhard Wiedemann From 210ddfeb3d71ab68c8ec7cf9c9eda1d95345fa9879b53a216ffdd844955bf735 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 03:31:24 +0000 Subject: [PATCH 07/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=30 --- antlr3-generated_sources.patch | 839 +++++++++++++++++++-------------- antlr3.spec | 2 +- 2 files changed, 487 insertions(+), 354 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index 9c4c146..33c4b0f 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 05:23:38.223945064 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 05:23:39.073938099 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 05:23:37.500617658 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 05:23:38.153945638 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 05:23:38.530609217 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 05:23:39.777247910 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 05:23:39.563928036 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 05:23:39.237270093 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 05:23:39.470600591 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 05:23:39.353935804 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,9 +1008,9 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 05:23:38.223945064 +0200 @@ -0,0 +1,442 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ActionAnalysis.g 2019-04-04 15:18:49 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.antlr.runtime.*; @@ -1453,9 +1453,9 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 05:23:39.073938099 +0200 @@ -0,0 +1,3600 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ActionTranslator.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.stringtemplate.v4.ST; @@ -5056,9 +5056,9 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 05:23:37.983947030 +0200 @@ -0,0 +1,3520 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLR.g 2019-04-04 15:18:49 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.antlr.tool.ErrorManager; @@ -8579,9 +8579,9 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2019-04-04 17:22:25.476181469 +0200 -@@ -0,0 +1,10497 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLR.g 2019-04-04 15:18:49 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 05:23:37.497284351 +0200 +@@ -0,0 +1,10551 @@ ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.antlr.tool.ErrorManager; @@ -9260,8 +9260,9 @@ + EOF4=(Token)match(input,EOF,FOLLOW_EOF_in_grammar_409); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_EOF.add(EOF4); + ++ + // AST REWRITE -+ // elements: r, scopes, cmt, ig, gr, a, gid, ts, optionsSpec ++ // elements: a, cmt, gid, ig, optionsSpec, r, scopes, ts, gr + // token labels: cmt + // rule labels: a, r, gid, scopes, gr, ig, retval, ts + // token list labels: @@ -9431,6 +9432,7 @@ + if ( state.backtracking==0 ) stream_GRAMMAR.add(gr); + + if ( state.backtracking==0 ) {grammarType=Grammar.LEXER; grammar.type = Grammar.LEXER;} ++ + // AST REWRITE + // elements: + // token labels: @@ -9464,6 +9466,7 @@ + if ( state.backtracking==0 ) stream_GRAMMAR.add(gr); + + if ( state.backtracking==0 ) {grammarType=Grammar.PARSER; grammar.type = Grammar.PARSER;} ++ + // AST REWRITE + // elements: + // token labels: @@ -9497,6 +9500,7 @@ + if ( state.backtracking==0 ) stream_GRAMMAR.add(gr); + + if ( state.backtracking==0 ) {grammarType=Grammar.TREE_PARSER; grammar.type = Grammar.TREE_PARSER;} ++ + // AST REWRITE + // elements: + // token labels: @@ -9527,6 +9531,7 @@ + if ( state.backtracking==0 ) stream_GRAMMAR.add(gr); + + if ( state.backtracking==0 ) {grammarType=Grammar.COMBINED; grammar.type = Grammar.COMBINED;} ++ + // AST REWRITE + // elements: + // token labels: @@ -9842,6 +9847,7 @@ + l=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName620); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_LEXER.add(l); + ++ + // AST REWRITE + // elements: + // token labels: @@ -9871,6 +9877,7 @@ + p=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName634); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_PARSER.add(p); + ++ + // AST REWRITE + // elements: + // token labels: @@ -10217,6 +10224,7 @@ + if ( state.backtracking==0 ) stream_STAR.add(ss); + + if ( state.backtracking==0 ) {retval.value = "*";} ++ + // AST REWRITE + // elements: + // token labels: @@ -11241,8 +11249,9 @@ + + } + ++ + // AST REWRITE -+ // elements: ruleAltList, scopes, throwsSpec, ex, optionsSpec, p1, ruleActions, p3, aa, p2, ruleName, p4, rt ++ // elements: aa, ex, optionsSpec, p1, p2, p4, rt, ruleActions, ruleAltList, ruleName, scopes, throwsSpec, p3 + // token labels: aa, p1, p2, rt, p3, p4 + // rule labels: ex, ruleName, scopes, retval + // token list labels: @@ -11735,8 +11744,9 @@ + } + } + ++ + // AST REWRITE -+ // elements: idList, ruleActions, ACTION ++ // elements: ACTION, idList, ruleActions + // token labels: + // rule labels: retval + // token list labels: @@ -11839,6 +11849,7 @@ + // org/antlr/grammar/v3/ANTLR.g:649:4: ( -> BLOCK[input.LT(-1),\"BLOCK\"] ) + // org/antlr/grammar/v3/ANTLR.g:649:6: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -11881,6 +11892,7 @@ + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite.add(r1.getTree()); + if ( state.backtracking==0 ) {if (LA(1)==OR||(LA(2)==QUESTION||LA(2)==PLUS||LA(2)==STAR)) prefixWithSynPred((a1!=null?((GrammarAST)a1.getTree()):null));} ++ + // AST REWRITE + // elements: a1, r1 + // token labels: @@ -11961,6 +11973,7 @@ + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite.add(r2.getTree()); + if ( state.backtracking==0 ) {if (LA(1)==OR||(LA(2)==QUESTION||LA(2)==PLUS||LA(2)==STAR)) prefixWithSynPred((a2!=null?((GrammarAST)a2.getTree()):null));} ++ + // AST REWRITE + // elements: r2, ruleAltList, a2 + // token labels: @@ -12013,6 +12026,7 @@ + + } + ++ + // AST REWRITE + // elements: ruleAltList + // token labels: @@ -12120,6 +12134,7 @@ + lp=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_block1500); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_LPAREN.add(lp); + ++ + // AST REWRITE + // elements: + // token labels: @@ -12277,8 +12292,9 @@ + rp=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_block1616); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RPAREN.add(rp); + ++ + // AST REWRITE -+ // elements: alternative, ACTION, ruleActions, optionsSpec, block ++ // elements: alternative, block, optionsSpec, ruleActions, ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -12426,6 +12442,7 @@ + cnt40++; + } + ++ + // AST REWRITE + // elements: element + // token labels: @@ -12467,6 +12484,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLR.g:713:3: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -14502,6 +14520,7 @@ + QUESTION120=(Token)match(input,QUESTION,FOLLOW_QUESTION_in_ebnf2126); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_QUESTION.add(QUESTION120); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -14538,6 +14557,7 @@ + STAR121=(Token)match(input,STAR,FOLLOW_STAR_in_ebnf2144); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_STAR.add(STAR121); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -14574,6 +14594,7 @@ + PLUS122=(Token)match(input,PLUS,FOLLOW_PLUS_in_ebnf2162); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_PLUS.add(PLUS122); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -14610,6 +14631,7 @@ + IMPLIES123=(Token)match(input,IMPLIES,FOLLOW_IMPLIES_in_ebnf2180); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_IMPLIES.add(IMPLIES123); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -14651,8 +14673,9 @@ + ROOT124=(Token)match(input,ROOT,FOLLOW_ROOT_in_ebnf2216); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ROOT.add(ROOT124); + ++ + // AST REWRITE -+ // elements: ROOT, block ++ // elements: block, ROOT + // token labels: + // rule labels: retval + // token list labels: @@ -14687,6 +14710,7 @@ + BANG125=(Token)match(input,BANG,FOLLOW_BANG_in_ebnf2233); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_BANG.add(BANG125); + ++ + // AST REWRITE + // elements: BANG, block + // token labels: @@ -14720,6 +14744,7 @@ + case 7 : + // org/antlr/grammar/v3/ANTLR.g:814:4: + { ++ + // AST REWRITE + // elements: block + // token labels: @@ -14883,6 +14908,7 @@ + c2=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_range2286); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_CHAR_LITERAL.add(c2); + ++ + // AST REWRITE + // elements: c2, c1 + // token labels: c1, c2 @@ -14993,6 +15019,7 @@ + ErrorManager.syntaxError( + ErrorManager.MSG_RANGE_OP_ILLEGAL,grammar,r,null,null); + } ++ + // AST REWRITE + // elements: t + // token labels: t @@ -15970,6 +15997,7 @@ + // org/antlr/grammar/v3/ANTLR.g:890:4: ( -> BLOCK[$elemAST.getToken(), \"BLOCK\"] ) + // org/antlr/grammar/v3/ANTLR.g:890:6: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -15997,6 +16025,7 @@ + // org/antlr/grammar/v3/ANTLR.g:893:3: ( -> ^( ALT[$elemAST.getToken(), \"ALT\"] EOA[\"\"] ) ) + // org/antlr/grammar/v3/ANTLR.g:894:4: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -16064,6 +16093,7 @@ + QUESTION155=(Token)match(input,QUESTION,FOLLOW_QUESTION_in_ebnfSuffix2700); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_QUESTION.add(QUESTION155); + ++ + // AST REWRITE + // elements: + // token labels: @@ -16093,6 +16123,7 @@ + STAR156=(Token)match(input,STAR,FOLLOW_STAR_in_ebnfSuffix2714); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_STAR.add(STAR156); + ++ + // AST REWRITE + // elements: + // token labels: @@ -16122,6 +16153,7 @@ + PLUS157=(Token)match(input,PLUS,FOLLOW_PLUS_in_ebnfSuffix2728); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_PLUS.add(PLUS157); + ++ + // AST REWRITE + // elements: + // token labels: @@ -16148,6 +16180,7 @@ + + } + ++ + // AST REWRITE + // elements: ebnfSuffix + // token labels: @@ -16401,6 +16434,7 @@ + TOKEN_REF162=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_id2809); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF162); + ++ + // AST REWRITE + // elements: + // token labels: @@ -16430,6 +16464,7 @@ + RULE_REF163=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_id2821); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RULE_REF.add(RULE_REF163); + ++ + // AST REWRITE + // elements: + // token labels: @@ -16559,8 +16594,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite_alternative.add(rewrite_alternative166.getTree()); ++ + // AST REWRITE -+ // elements: rewrite_with_sempred, REWRITE, rewrite_alternative ++ // elements: rewrite_alternative, rewrite_with_sempred, REWRITE + // token labels: + // rule labels: retval + // token list labels: @@ -16741,6 +16777,7 @@ + RPAREN172=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_rewrite_block2903); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN172); + ++ + // AST REWRITE + // elements: rewrite_alternative + // token labels: @@ -16984,6 +17021,7 @@ + cnt85++; + } + ++ + // AST REWRITE + // elements: rewrite_element + // token labels: @@ -17038,6 +17076,7 @@ + case 3 : + // org/antlr/grammar/v3/ANTLR.g:957:3: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -17175,6 +17214,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite_atom.add(t.getTree()); ++ + // AST REWRITE + // elements: t + // token labels: @@ -17214,6 +17254,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(subrule.getTree()); ++ + // AST REWRITE + // elements: subrule + // token labels: @@ -17268,6 +17309,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite_tree.add(tr.getTree()); ++ + // AST REWRITE + // elements: tr + // token labels: @@ -17307,6 +17349,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(subrule.getTree()); ++ + // AST REWRITE + // elements: subrule + // token labels: @@ -17667,6 +17710,7 @@ + TOKEN_REF185=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_label3186); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF185); + ++ + // AST REWRITE + // elements: + // token labels: @@ -17696,6 +17740,7 @@ + RULE_REF186=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_label3196); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RULE_REF.add(RULE_REF186); + ++ + // AST REWRITE + // elements: + // token labels: @@ -17809,6 +17854,7 @@ + QUESTION187=(Token)match(input,QUESTION,FOLLOW_QUESTION_in_rewrite_ebnf3220); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_QUESTION.add(QUESTION187); + ++ + // AST REWRITE + // elements: b + // token labels: @@ -17846,6 +17892,7 @@ + STAR188=(Token)match(input,STAR,FOLLOW_STAR_in_rewrite_ebnf3239); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_STAR.add(STAR188); + ++ + // AST REWRITE + // elements: b + // token labels: @@ -17883,6 +17930,7 @@ + PLUS189=(Token)match(input,PLUS,FOLLOW_PLUS_in_rewrite_ebnf3258); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_PLUS.add(PLUS189); + ++ + // AST REWRITE + // elements: b + // token labels: @@ -18118,6 +18166,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite_template_head.add(rewrite_template_head194.getTree()); ++ + // AST REWRITE + // elements: rewrite_template_head + // token labels: @@ -18292,6 +18341,7 @@ + RPAREN200=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_rewrite_template_head3417); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN200); + ++ + // AST REWRITE + // elements: rewrite_template_args, id + // token labels: @@ -18399,6 +18449,7 @@ + RPAREN205=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_rewrite_indirect_template_head3461); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN205); + ++ + // AST REWRITE + // elements: ACTION, rewrite_template_args + // token labels: @@ -18529,6 +18580,7 @@ + } + } + ++ + // AST REWRITE + // elements: rewrite_template_arg + // token labels: @@ -18569,6 +18621,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLR.g:1061:3: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -18654,8 +18707,9 @@ + ACTION210=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template_arg3531); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION210); + ++ + // AST REWRITE -+ // elements: id, ACTION ++ // elements: ACTION, id + // token labels: + // rule labels: retval + // token list labels: @@ -19079,9 +19133,9 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 05:23:38.153945638 +0200 @@ -0,0 +1,3622 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLRTreePrinter.g 2019-04-04 15:18:49 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.antlr.tool.*; @@ -22704,9 +22758,9 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 05:23:38.967272306 +0200 @@ -0,0 +1,3357 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLRv3.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + + package org.antlr.grammar.v3; + @@ -26064,9 +26118,9 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2019-04-04 17:22:25.476181469 +0200 -@@ -0,0 +1,9768 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLRv3.g 2019-04-04 15:18:50 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 05:23:38.530609217 +0200 +@@ -0,0 +1,9847 @@ ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + + package org.antlr.grammar.v3; + @@ -26498,8 +26552,9 @@ + EOF12=(Token)match(input,EOF,FOLLOW_EOF_in_grammarDef489); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_EOF.add(EOF12); + ++ + // AST REWRITE -+ // elements: action, optionsSpec, DOC_COMMENT, attrScope, rule, tokensSpec, id ++ // elements: DOC_COMMENT, attrScope, id, optionsSpec, rule, tokensSpec, action + // token labels: + // rule labels: retval + // token list labels: @@ -26652,6 +26707,7 @@ + char_literal15=(Token)match(input,92,FOLLOW_92_in_tokensSpec555); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_92.add(char_literal15); + ++ + // AST REWRITE + // elements: TOKENS, tokenSpec + // token labels: @@ -26807,8 +26863,9 @@ + + } + ++ + // AST REWRITE -+ // elements: lit, LABEL_ASSIGN, TOKEN_REF ++ // elements: TOKEN_REF, lit, LABEL_ASSIGN + // token labels: lit + // rule labels: retval + // token list labels: @@ -26842,6 +26899,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:115:16: + { ++ + // AST REWRITE + // elements: TOKEN_REF + // token labels: @@ -26933,8 +26991,9 @@ + ACTION21=(Token)match(input,ACTION,FOLLOW_ACTION_in_attrScope644); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION21); + ++ + // AST REWRITE -+ // elements: SCOPE, ACTION, id ++ // elements: ACTION, SCOPE, id + // token labels: + // rule labels: retval + // token list labels: @@ -27072,8 +27131,9 @@ + ACTION26=(Token)match(input,ACTION,FOLLOW_ACTION_in_action678); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION26); + ++ + // AST REWRITE -+ // elements: id, ACTION, AT, actionScopeName ++ // elements: AT, actionScopeName, id, ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -27200,6 +27260,7 @@ + l=(Token)match(input,84,FOLLOW_84_in_actionScopeName711); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_84.add(l); + ++ + // AST REWRITE + // elements: + // token labels: @@ -27229,6 +27290,7 @@ + p=(Token)match(input,85,FOLLOW_85_in_actionScopeName728); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_85.add(p); + ++ + // AST REWRITE + // elements: + // token labels: @@ -27346,6 +27408,7 @@ + char_literal31=(Token)match(input,92,FOLLOW_92_in_optionsSpec753); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_92.add(char_literal31); + ++ + // AST REWRITE + // elements: option, OPTIONS + // token labels: @@ -27444,8 +27507,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_optionValue.add(optionValue34.getTree()); ++ + // AST REWRITE -+ // elements: id, LABEL_ASSIGN, optionValue ++ // elements: LABEL_ASSIGN, id, optionValue + // token labels: + // rule labels: retval + // token list labels: @@ -27621,6 +27685,7 @@ + s=(Token)match(input,70,FOLLOW_70_in_optionValue851); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_70.add(s); + ++ + // AST REWRITE + // elements: + // token labels: @@ -28011,8 +28076,9 @@ + + } + ++ + // AST REWRITE -+ // elements: ruleScopeSpec, RET, arg, id, ruleAction, throwsSpec, optionsSpec, altList, rt, exceptionGroup ++ // elements: RET, altList, arg, exceptionGroup, id, optionsSpec, rt, ruleAction, ruleScopeSpec, throwsSpec + // token labels: rt, arg + // rule labels: retval + // token list labels: @@ -28164,8 +28230,9 @@ + ACTION53=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction1068); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION53); + ++ + // AST REWRITE -+ // elements: ACTION, AT, id ++ // elements: AT, id, ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -28282,6 +28349,7 @@ + } + } + ++ + // AST REWRITE + // elements: 89, id + // token labels: @@ -28452,6 +28520,7 @@ + ACTION59=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec1122); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION59); + ++ + // AST REWRITE + // elements: SCOPE, ACTION + // token labels: @@ -28525,8 +28594,9 @@ + char_literal64=(Token)match(input,76,FOLLOW_76_in_ruleScopeSpec1146); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_76.add(char_literal64); + ++ + // AST REWRITE -+ // elements: SCOPE, id ++ // elements: id, SCOPE + // token labels: + // rule labels: retval + // token list labels: @@ -28611,8 +28681,9 @@ + char_literal71=(Token)match(input,76,FOLLOW_76_in_ruleScopeSpec1177); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_76.add(char_literal71); + ++ + // AST REWRITE -+ // elements: id, SCOPE, ACTION ++ // elements: ACTION, id, SCOPE + // token labels: + // rule labels: retval + // token list labels: @@ -28787,8 +28858,9 @@ + rp=(Token)match(input,69,FOLLOW_69_in_block1250); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(rp); + ++ + // AST REWRITE -+ // elements: optionsSpec, altpair ++ // elements: altpair, optionsSpec + // token labels: + // rule labels: retval + // token list labels: @@ -28978,6 +29050,7 @@ + } + } + ++ + // AST REWRITE + // elements: altpair + // token labels: @@ -29112,6 +29185,7 @@ + cnt34++; + } + ++ + // AST REWRITE + // elements: element + // token labels: @@ -29153,6 +29227,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:218:9: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -29381,6 +29456,7 @@ + ACTION87=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1448); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION87); + ++ + // AST REWRITE + // elements: 81, ARG_ACTION, ACTION + // token labels: @@ -29465,8 +29541,9 @@ + ACTION89=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1480); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION89); + ++ + // AST REWRITE -+ // elements: ACTION, 82 ++ // elements: 82, ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -29866,8 +29943,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix92.getTree()); ++ + // AST REWRITE -+ // elements: id, atom, ebnfSuffix, labelOp ++ // elements: atom, ebnfSuffix, id, labelOp + // token labels: labelOp + // rule labels: retval + // token list labels: @@ -29924,6 +30002,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:237:8: + { ++ + // AST REWRITE + // elements: id, labelOp, atom + // token labels: labelOp @@ -30037,8 +30116,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix95.getTree()); ++ + // AST REWRITE -+ // elements: id, labelOp, ebnfSuffix, block ++ // elements: block, ebnfSuffix, id, labelOp + // token labels: labelOp + // rule labels: retval + // token list labels: @@ -30095,8 +30175,9 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:241:8: + { ++ + // AST REWRITE -+ // elements: id, block, labelOp ++ // elements: id, labelOp, block + // token labels: labelOp + // rule labels: retval + // token list labels: @@ -30166,6 +30247,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix97.getTree()); ++ + // AST REWRITE + // elements: ebnfSuffix, atom + // token labels: @@ -30215,6 +30297,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:245:8: + { ++ + // AST REWRITE + // elements: atom + // token labels: @@ -30301,6 +30384,7 @@ + g=(Token)match(input,78,FOLLOW_78_in_element1728); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_78.add(g); + ++ + // AST REWRITE + // elements: + // token labels: @@ -30327,6 +30411,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:249:46: + { ++ + // AST REWRITE + // elements: SEMPRED + // token labels: @@ -30389,8 +30474,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix102.getTree()); ++ + // AST REWRITE -+ // elements: treeSpec, ebnfSuffix ++ // elements: ebnfSuffix, treeSpec + // token labels: + // rule labels: retval + // token list labels: @@ -30438,6 +30524,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:252:8: + { ++ + // AST REWRITE + // elements: treeSpec + // token labels: @@ -30653,6 +30740,7 @@ + + } + ++ + // AST REWRITE + // elements: op, range + // token labels: op @@ -30687,6 +30775,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:259:9: + { ++ + // AST REWRITE + // elements: range + // token labels: @@ -30781,8 +30870,9 @@ + + } + ++ + // AST REWRITE -+ // elements: notSet, op ++ // elements: op, notSet + // token labels: op + // rule labels: retval + // token list labels: @@ -30815,6 +30905,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:263:9: + { ++ + // AST REWRITE + // elements: notSet + // token labels: @@ -30925,8 +31016,9 @@ + + } + ++ + // AST REWRITE -+ // elements: op, ARG_ACTION, RULE_REF ++ // elements: RULE_REF, op, ARG_ACTION + // token labels: op + // rule labels: retval + // token list labels: @@ -30965,8 +31057,9 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:267:9: + { ++ + // AST REWRITE -+ // elements: RULE_REF, ARG_ACTION ++ // elements: ARG_ACTION, RULE_REF + // token labels: + // rule labels: retval + // token list labels: @@ -31107,8 +31200,9 @@ + + } + ++ + // AST REWRITE -+ // elements: 93, elementOptions, notTerminal ++ // elements: elementOptions, notTerminal, 93 + // token labels: + // rule labels: retval + // token list labels: @@ -31171,8 +31265,9 @@ + + } + ++ + // AST REWRITE -+ // elements: elementOptions, block, 93 ++ // elements: block, elementOptions, 93 + // token labels: + // rule labels: retval + // token list labels: @@ -31421,6 +31516,7 @@ + char_literal116=(Token)match(input,79,FOLLOW_79_in_elementOptions2056); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_79.add(char_literal116); + ++ + // AST REWRITE + // elements: qid + // token labels: @@ -31494,6 +31590,7 @@ + char_literal121=(Token)match(input,79,FOLLOW_79_in_elementOptions2085); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_79.add(char_literal121); + ++ + // AST REWRITE + // elements: option + // token labels: @@ -31594,8 +31691,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_optionValue.add(optionValue124.getTree()); ++ + // AST REWRITE -+ // elements: optionValue, LABEL_ASSIGN, id ++ // elements: LABEL_ASSIGN, optionValue, id + // token labels: + // rule labels: retval + // token list labels: @@ -31717,6 +31815,7 @@ + char_literal128=(Token)match(input,69,FOLLOW_69_in_treeSpec2142); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(char_literal128); + ++ + // AST REWRITE + // elements: element + // token labels: @@ -31834,8 +31933,9 @@ + + } + ++ + // AST REWRITE -+ // elements: elementOptions, c1, c2 ++ // elements: c1, c2, elementOptions + // token labels: c1, c2 + // rule labels: retval + // token list labels: @@ -31996,8 +32096,9 @@ + + } + ++ + // AST REWRITE -+ // elements: CHAR_LITERAL, elementOptions ++ // elements: elementOptions, CHAR_LITERAL + // token labels: + // rule labels: retval + // token list labels: @@ -32075,8 +32176,9 @@ + + } + ++ + // AST REWRITE -+ // elements: elementOptions, ARG_ACTION, TOKEN_REF ++ // elements: TOKEN_REF, elementOptions, ARG_ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -32142,6 +32244,7 @@ + + } + ++ + // AST REWRITE + // elements: elementOptions, STRING_LITERAL + // token labels: @@ -32203,8 +32306,9 @@ + + } + ++ + // AST REWRITE -+ // elements: 73, elementOptions ++ // elements: elementOptions, 73 + // token labels: + // rule labels: retval + // token list labels: @@ -32257,6 +32361,7 @@ + char_literal140=(Token)match(input,ROOT,FOLLOW_ROOT_in_terminal2321); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ROOT.add(char_literal140); + ++ + // AST REWRITE + // elements: ROOT, terminal + // token labels: @@ -32293,6 +32398,7 @@ + char_literal141=(Token)match(input,BANG,FOLLOW_BANG_in_terminal2342); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_BANG.add(char_literal141); + ++ + // AST REWRITE + // elements: terminal, BANG + // token labels: @@ -32441,6 +32547,7 @@ + op=(Token)match(input,80,FOLLOW_80_in_ebnf2393); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_80.add(op); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -32477,6 +32584,7 @@ + op=(Token)match(input,70,FOLLOW_70_in_ebnf2410); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_70.add(op); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -32513,6 +32621,7 @@ + op=(Token)match(input,71,FOLLOW_71_in_ebnf2427); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_71.add(op); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -32549,6 +32658,7 @@ + string_literal143=(Token)match(input,78,FOLLOW_78_in_ebnf2444); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_78.add(string_literal143); + ++ + // AST REWRITE + // elements: block + // token labels: @@ -32588,6 +32698,7 @@ + case 5 : + // org/antlr/grammar/v3/ANTLRv3.g:334:13: + { ++ + // AST REWRITE + // elements: block + // token labels: @@ -32701,6 +32812,7 @@ + char_literal144=(Token)match(input,80,FOLLOW_80_in_ebnfSuffix2529); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_80.add(char_literal144); + ++ + // AST REWRITE + // elements: + // token labels: @@ -32730,6 +32842,7 @@ + char_literal145=(Token)match(input,70,FOLLOW_70_in_ebnfSuffix2541); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_70.add(char_literal145); + ++ + // AST REWRITE + // elements: + // token labels: @@ -32759,6 +32872,7 @@ + char_literal146=(Token)match(input,71,FOLLOW_71_in_ebnfSuffix2554); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_71.add(char_literal146); + ++ + // AST REWRITE + // elements: + // token labels: @@ -32909,8 +33023,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_rewrite_alternative.add(last.getTree()); ++ + // AST REWRITE -+ // elements: predicated, rew, rew2, preds, last ++ // elements: predicated, preds, rew, rew2, last + // token labels: rew2 + // rule labels: last, retval + // token list labels: rew, preds @@ -33376,6 +33491,7 @@ + case 3 : + // org/antlr/grammar/v3/ANTLRv3.g:365:29: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -33469,6 +33585,7 @@ + char_literal150=(Token)match(input,69,FOLLOW_69_in_rewrite_tree_block2705); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(char_literal150); + ++ + // AST REWRITE + // elements: rewrite_tree_alternative + // token labels: @@ -33574,6 +33691,7 @@ + cnt74++; + } + ++ + // AST REWRITE + // elements: rewrite_tree_element + // token labels: @@ -33943,8 +34061,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix154.getTree()); ++ + // AST REWRITE -+ // elements: rewrite_tree_atom, ebnfSuffix ++ // elements: ebnfSuffix, rewrite_tree_atom + // token labels: + // rule labels: retval + // token list labels: @@ -34023,8 +34142,9 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix156.getTree()); ++ + // AST REWRITE -+ // elements: ebnfSuffix, rewrite_tree ++ // elements: rewrite_tree, ebnfSuffix + // token labels: + // rule labels: retval + // token list labels: @@ -34072,6 +34192,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:384:5: + { ++ + // AST REWRITE + // elements: rewrite_tree + // token labels: @@ -34251,8 +34372,9 @@ + + } + ++ + // AST REWRITE -+ // elements: TOKEN_REF, ARG_ACTION ++ // elements: ARG_ACTION, TOKEN_REF + // token labels: + // rule labels: retval + // token list labels: @@ -34325,6 +34447,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_id.add(id163.getTree()); ++ + // AST REWRITE + // elements: + // token labels: @@ -34422,6 +34545,7 @@ + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix166.getTree()); ++ + // AST REWRITE + // elements: ebnfSuffix, rewrite_tree_block + // token labels: @@ -34544,6 +34668,7 @@ + char_literal170=(Token)match(input,69,FOLLOW_69_in_rewrite_tree2985); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(char_literal170); + ++ + // AST REWRITE + // elements: rewrite_tree_atom, rewrite_tree_element + // token labels: @@ -34696,8 +34821,9 @@ + + } + ++ + // AST REWRITE -+ // elements: rewrite_template_args, id, str ++ // elements: id, rewrite_template_args, str + // token labels: str + // rule labels: retval + // token list labels: @@ -34840,6 +34966,7 @@ + char_literal179=(Token)match(input,69,FOLLOW_69_in_rewrite_template_ref3105); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(char_literal179); + ++ + // AST REWRITE + // elements: id, rewrite_template_args + // token labels: @@ -34947,8 +35074,9 @@ + char_literal184=(Token)match(input,69,FOLLOW_69_in_rewrite_indirect_template_head3143); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_69.add(char_literal184); + ++ + // AST REWRITE -+ // elements: ACTION, rewrite_template_args ++ // elements: rewrite_template_args, ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -35077,6 +35205,7 @@ + } + } + ++ + // AST REWRITE + // elements: rewrite_template_arg + // token labels: @@ -35117,6 +35246,7 @@ + case 2 : + // org/antlr/grammar/v3/ANTLRv3.g:456:4: + { ++ + // AST REWRITE + // elements: + // token labels: @@ -35202,6 +35332,7 @@ + ACTION190=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template_arg3209); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ACTION.add(ACTION190); + ++ + // AST REWRITE + // elements: id, ACTION + // token labels: @@ -35390,6 +35521,7 @@ + TOKEN_REF194=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_id3247); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF194); + ++ + // AST REWRITE + // elements: + // token labels: @@ -35419,6 +35551,7 @@ + RULE_REF195=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_id3257); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RULE_REF.add(RULE_REF195); + ++ + // AST REWRITE + // elements: + // token labels: @@ -35835,9 +35968,9 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 05:23:39.777247910 +0200 @@ -0,0 +1,3771 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/ANTLRv3Tree.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; + @@ -39609,9 +39742,9 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 05:23:39.563928036 +0200 @@ -0,0 +1,2936 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; + @@ -42548,9 +42681,9 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 05:23:39.237270093 +0200 @@ -0,0 +1,5305 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/CodeGenTreeWalker.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; + @@ -42944,9 +43077,9 @@ + // must be char or String literal + label = generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText())); + } -+ Collections.sort(labels); // ensure reproducible order + labels.add( label ); + } ++ Collections.sort(labels); // ensure reproducible order + return labels; + } + @@ -42959,7 +43092,7 @@ + + + // $ANTLR start "grammar_" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:298:1: public grammar_[Grammar g,\n\t\tST recognizerST,\n\t\tST outputFileST,\n\t\tST headerFileST] : ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:300:1: public grammar_[Grammar g,\n\t\tST recognizerST,\n\t\tST outputFileST,\n\t\tST headerFileST] : ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ; + public final void grammar_(Grammar g, ST recognizerST, ST outputFileST, ST headerFileST) throws RecognitionException { + + if ( state.backtracking == 0 ) @@ -42991,10 +43124,10 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:332:2: ( ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:332:4: ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:334:2: ( ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:334:4: ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:332:4: ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:334:4: ( ^( LEXER_GRAMMAR grammarSpec ) | ^( PARSER_GRAMMAR grammarSpec ) | ^( TREE_GRAMMAR grammarSpec ) | ^( COMBINED_GRAMMAR grammarSpec ) ) + int alt1=4; + switch ( input.LA(1) ) { + case LEXER_GRAMMAR: @@ -43025,7 +43158,7 @@ + } + switch (alt1) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:332:6: ^( LEXER_GRAMMAR grammarSpec ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:334:6: ^( LEXER_GRAMMAR grammarSpec ) + { + match(input,LEXER_GRAMMAR,FOLLOW_LEXER_GRAMMAR_in_grammar_67); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -43038,7 +43171,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:333:5: ^( PARSER_GRAMMAR grammarSpec ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:335:5: ^( PARSER_GRAMMAR grammarSpec ) + { + match(input,PARSER_GRAMMAR,FOLLOW_PARSER_GRAMMAR_in_grammar_79); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -43051,7 +43184,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:334:5: ^( TREE_GRAMMAR grammarSpec ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:336:5: ^( TREE_GRAMMAR grammarSpec ) + { + match(input,TREE_GRAMMAR,FOLLOW_TREE_GRAMMAR_in_grammar_91); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -43064,7 +43197,7 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:335:5: ^( COMBINED_GRAMMAR grammarSpec ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:337:5: ^( COMBINED_GRAMMAR grammarSpec ) + { + match(input,COMBINED_GRAMMAR,FOLLOW_COMBINED_GRAMMAR_in_grammar_103); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -43095,16 +43228,16 @@ + + + // $ANTLR start "attrScope" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:339:1: attrScope : ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:341:1: attrScope : ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) ; + public final void attrScope() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:2: ( ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:4: ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:2: ( ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:4: ^( 'scope' ID ( ^( AMPERSAND ( . )* ) )* ACTION ) + { + match(input,SCOPE,FOLLOW_SCOPE_in_attrScope124); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; + match(input,ID,FOLLOW_ID_in_attrScope126); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:18: ( ^( AMPERSAND ( . )* ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:18: ( ^( AMPERSAND ( . )* ) )* + loop3: + while (true) { + int alt3=2; @@ -43115,12 +43248,12 @@ + + switch (alt3) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:20: ^( AMPERSAND ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:20: ^( AMPERSAND ( . )* ) + { + match(input,AMPERSAND,FOLLOW_AMPERSAND_in_attrScope131); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:32: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:32: ( . )* + loop2: + while (true) { + int alt2=2; @@ -43134,7 +43267,7 @@ + + switch (alt2) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:340:32: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:342:32: . + { + matchAny(input); if (state.failed) return; + } @@ -43175,17 +43308,17 @@ + + + // $ANTLR start "grammarSpec" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:343:1: grammarSpec : name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:345:1: grammarSpec : name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] ; + public final void grammarSpec() throws RecognitionException { + GrammarAST name=null; + GrammarAST cmt=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:344:2: (name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:344:6: name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:346:2: (name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:346:6: name= ID (cmt= DOC_COMMENT )? ( ^( OPTIONS ( . )* ) )? ( ^( IMPORT ( . )* ) )? ( ^( TOKENS ( . )* ) )? ( attrScope )* ( ^( AMPERSAND ( . )* ) )* rules[recognizerST] + { + name=(GrammarAST)match(input,ID,FOLLOW_ID_in_grammarSpec157); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:345:3: (cmt= DOC_COMMENT )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:347:3: (cmt= DOC_COMMENT )? + int alt4=2; + int LA4_0 = input.LA(1); + if ( (LA4_0==DOC_COMMENT) ) { @@ -43193,7 +43326,7 @@ + } + switch (alt4) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:345:5: cmt= DOC_COMMENT ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:347:5: cmt= DOC_COMMENT + { + cmt=(GrammarAST)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_grammarSpec165); if (state.failed) return; + if ( state.backtracking==0 ) { @@ -43212,7 +43345,7 @@ + recognizerST.add("scopes", grammar.getGlobalScopes()); + headerFileST.add("scopes", grammar.getGlobalScopes()); + } -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:358:3: ( ^( OPTIONS ( . )* ) )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:3: ( ^( OPTIONS ( . )* ) )? + int alt6=2; + int LA6_0 = input.LA(1); + if ( (LA6_0==OPTIONS) ) { @@ -43220,12 +43353,12 @@ + } + switch (alt6) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:358:5: ^( OPTIONS ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:5: ^( OPTIONS ( . )* ) + { + match(input,OPTIONS,FOLLOW_OPTIONS_in_grammarSpec186); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:358:15: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:15: ( . )* + loop5: + while (true) { + int alt5=2; @@ -43239,7 +43372,7 @@ + + switch (alt5) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:358:15: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:15: . + { + matchAny(input); if (state.failed) return; + } @@ -43258,7 +43391,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:359:3: ( ^( IMPORT ( . )* ) )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:3: ( ^( IMPORT ( . )* ) )? + int alt8=2; + int LA8_0 = input.LA(1); + if ( (LA8_0==IMPORT) ) { @@ -43266,12 +43399,12 @@ + } + switch (alt8) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:359:5: ^( IMPORT ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:5: ^( IMPORT ( . )* ) + { + match(input,IMPORT,FOLLOW_IMPORT_in_grammarSpec200); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:359:14: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:14: ( . )* + loop7: + while (true) { + int alt7=2; @@ -43285,7 +43418,7 @@ + + switch (alt7) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:359:14: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:14: . + { + matchAny(input); if (state.failed) return; + } @@ -43304,7 +43437,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:3: ( ^( TOKENS ( . )* ) )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:3: ( ^( TOKENS ( . )* ) )? + int alt10=2; + int LA10_0 = input.LA(1); + if ( (LA10_0==TOKENS) ) { @@ -43312,12 +43445,12 @@ + } + switch (alt10) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:5: ^( TOKENS ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:5: ^( TOKENS ( . )* ) + { + match(input,TOKENS,FOLLOW_TOKENS_in_grammarSpec214); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:14: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:14: ( . )* + loop9: + while (true) { + int alt9=2; @@ -43331,7 +43464,7 @@ + + switch (alt9) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:360:14: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:14: . + { + matchAny(input); if (state.failed) return; + } @@ -43350,7 +43483,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:3: ( attrScope )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:363:3: ( attrScope )* + loop11: + while (true) { + int alt11=2; @@ -43361,7 +43494,7 @@ + + switch (alt11) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:361:4: attrScope ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:363:4: attrScope + { + pushFollow(FOLLOW_attrScope_in_grammarSpec226); + attrScope(); @@ -43375,7 +43508,7 @@ + } + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:3: ( ^( AMPERSAND ( . )* ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:364:3: ( ^( AMPERSAND ( . )* ) )* + loop13: + while (true) { + int alt13=2; @@ -43386,12 +43519,12 @@ + + switch (alt13) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:5: ^( AMPERSAND ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:364:5: ^( AMPERSAND ( . )* ) + { + match(input,AMPERSAND,FOLLOW_AMPERSAND_in_grammarSpec235); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:17: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:364:17: ( . )* + loop12: + while (true) { + int alt12=2; @@ -43405,7 +43538,7 @@ + + switch (alt12) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:362:17: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:364:17: . + { + matchAny(input); if (state.failed) return; + } @@ -43447,7 +43580,7 @@ + + + // $ANTLR start "rules" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:366:1: rules[ST recognizerST] : ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:368:1: rules[ST recognizerST] : ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ; + public final void rules(ST recognizerST) throws RecognitionException { + TreeRuleReturnScope rST =null; + @@ -43456,10 +43589,10 @@ + boolean generated = grammar.generateMethodForRule(ruleName); + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:372:2: ( ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:372:4: ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:374:2: ( ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:374:4: ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:372:4: ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:374:4: ( ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) )+ + int cnt17=0; + loop17: + while (true) { @@ -43471,9 +43604,9 @@ + + switch (alt17) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:372:6: ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:374:6: ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:372:6: ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:374:6: ( options {k=1; } :{...}? =>rST= rule | ^( RULE ( . )* ) | ^( PREC_RULE ( . )* ) ) + int alt16=3; + int LA16_0 = input.LA(1); + if ( (LA16_0==RULE) ) { @@ -43499,7 +43632,7 @@ + + switch (alt16) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:373:5: {...}? =>rST= rule ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:375:5: {...}? =>rST= rule + { + if ( !((generated)) ) { + if (state.backtracking>0) {state.failed=true; return;} @@ -43520,12 +43653,12 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:383:6: ^( RULE ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:385:6: ^( RULE ( . )* ) + { + match(input,RULE,FOLLOW_RULE_in_rules305); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:383:13: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:385:13: ( . )* + loop14: + while (true) { + int alt14=2; @@ -43539,7 +43672,7 @@ + + switch (alt14) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:383:13: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:385:13: . + { + matchAny(input); if (state.failed) return; + } @@ -43556,12 +43689,12 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:384:6: ^( PREC_RULE ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:386:6: ^( PREC_RULE ( . )* ) + { + match(input,PREC_RULE,FOLLOW_PREC_RULE_in_rules317); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:384:18: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:386:18: ( . )* + loop15: + while (true) { + int alt15=2; @@ -43575,7 +43708,7 @@ + + switch (alt15) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:384:18: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:386:18: . + { + matchAny(input); if (state.failed) return; + } @@ -43634,7 +43767,7 @@ + + + // $ANTLR start "rule" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:397:1: rule returns [ST code=null] : ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:399:1: rule returns [ST code=null] : ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) ; + public final CodeGenTreeWalker.rule_return rule() throws RecognitionException { + CodeGenTreeWalker.rule_return retval = new CodeGenTreeWalker.rule_return(); + retval.start = input.LT(1); @@ -43665,14 +43798,14 @@ + String description = ""; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:420:2: ( ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:420:4: ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:422:2: ( ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:422:4: ^( RULE id= ID (mod= modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( throwsSpec )? ( ^( OPTIONS ( . )* ) )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* b= block[\"ruleBlock\", dfa, null] ( exceptionGroup[$code] )? EOR ) + { + match(input,RULE,FOLLOW_RULE_in_rule359); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; + id=(GrammarAST)match(input,ID,FOLLOW_ID_in_rule363); if (state.failed) return retval; + if ( state.backtracking==0 ) {assert currentRuleName == (id!=null?id.getText():null);} -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:422:4: (mod= modifier )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:424:4: (mod= modifier )? + int alt18=2; + int LA18_0 = input.LA(1); + if ( (LA18_0==FRAGMENT||(LA18_0 >= PRIVATE && LA18_0 <= PUBLIC)) ) { @@ -43680,7 +43813,7 @@ + } + switch (alt18) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:422:5: mod= modifier ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:424:5: mod= modifier + { + pushFollow(FOLLOW_modifier_in_rule376); + mod=modifier(); @@ -43694,7 +43827,7 @@ + match(input,ARG,FOLLOW_ARG_in_rule384); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:423:10: ( ARG_ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:425:10: ( ARG_ACTION )? + int alt19=2; + int LA19_0 = input.LA(1); + if ( (LA19_0==ARG_ACTION) ) { @@ -43702,7 +43835,7 @@ + } + switch (alt19) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:423:11: ARG_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:425:11: ARG_ACTION + { + match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule387); if (state.failed) return retval; + } @@ -43716,7 +43849,7 @@ + match(input,RET,FOLLOW_RET_in_rule396); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:424:10: ( ARG_ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:10: ( ARG_ACTION )? + int alt20=2; + int LA20_0 = input.LA(1); + if ( (LA20_0==ARG_ACTION) ) { @@ -43724,7 +43857,7 @@ + } + switch (alt20) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:424:11: ARG_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:11: ARG_ACTION + { + match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule399); if (state.failed) return retval; + } @@ -43735,7 +43868,7 @@ + match(input, Token.UP, null); if (state.failed) return retval; + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:425:4: ( throwsSpec )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:427:4: ( throwsSpec )? + int alt21=2; + int LA21_0 = input.LA(1); + if ( (LA21_0==THROWS) ) { @@ -43743,7 +43876,7 @@ + } + switch (alt21) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:425:5: throwsSpec ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:427:5: throwsSpec + { + pushFollow(FOLLOW_throwsSpec_in_rule408); + throwsSpec(); @@ -43754,7 +43887,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:4: ( ^( OPTIONS ( . )* ) )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:4: ( ^( OPTIONS ( . )* ) )? + int alt23=2; + int LA23_0 = input.LA(1); + if ( (LA23_0==OPTIONS) ) { @@ -43762,12 +43895,12 @@ + } + switch (alt23) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:6: ^( OPTIONS ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:6: ^( OPTIONS ( . )* ) + { + match(input,OPTIONS,FOLLOW_OPTIONS_in_rule418); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:16: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:16: ( . )* + loop22: + while (true) { + int alt22=2; @@ -43781,7 +43914,7 @@ + + switch (alt22) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:426:16: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:16: . + { + matchAny(input); if (state.failed) return retval; + } @@ -43800,7 +43933,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:427:4: ( ruleScopeSpec )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:429:4: ( ruleScopeSpec )? + int alt24=2; + int LA24_0 = input.LA(1); + if ( (LA24_0==SCOPE) ) { @@ -43808,7 +43941,7 @@ + } + switch (alt24) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:427:5: ruleScopeSpec ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:429:5: ruleScopeSpec + { + pushFollow(FOLLOW_ruleScopeSpec_in_rule431); + ruleScopeSpec(); @@ -43819,7 +43952,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:4: ( ^( AMPERSAND ( . )* ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:430:4: ( ^( AMPERSAND ( . )* ) )* + loop26: + while (true) { + int alt26=2; @@ -43830,12 +43963,12 @@ + + switch (alt26) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:6: ^( AMPERSAND ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:430:6: ^( AMPERSAND ( . )* ) + { + match(input,AMPERSAND,FOLLOW_AMPERSAND_in_rule441); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:18: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:430:18: ( . )* + loop25: + while (true) { + int alt25=2; @@ -43849,7 +43982,7 @@ + + switch (alt25) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:428:18: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:430:18: . + { + matchAny(input); if (state.failed) return retval; + } @@ -43924,7 +44057,7 @@ + retval.code.add("memoize", memo!=null && memo.equals("true")); + } + } -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:480:4: ( exceptionGroup[$code] )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:482:4: ( exceptionGroup[$code] )? + int alt27=2; + int LA27_0 = input.LA(1); + if ( (LA27_0==CATCH||LA27_0==FINALLY) ) { @@ -43932,7 +44065,7 @@ + } + switch (alt27) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:480:5: exceptionGroup[$code] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:482:5: exceptionGroup[$code] + { + pushFollow(FOLLOW_exceptionGroup_in_rule468); + exceptionGroup(retval.code); @@ -43996,13 +44129,13 @@ + + + // $ANTLR start "modifier" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:515:1: modifier : ( 'protected' | 'public' | 'private' | 'fragment' ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:517:1: modifier : ( 'protected' | 'public' | 'private' | 'fragment' ); + public final CodeGenTreeWalker.modifier_return modifier() throws RecognitionException { + CodeGenTreeWalker.modifier_return retval = new CodeGenTreeWalker.modifier_return(); + retval.start = input.LT(1); + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:516:2: ( 'protected' | 'public' | 'private' | 'fragment' ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:518:2: ( 'protected' | 'public' | 'private' | 'fragment' ) + // org/antlr/grammar/v3/CodeGenTreeWalker.g: + { + if ( input.LA(1)==FRAGMENT||(input.LA(1) >= PRIVATE && input.LA(1) <= PUBLIC) ) { @@ -44032,15 +44165,15 @@ + + + // $ANTLR start "throwsSpec" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:522:1: throwsSpec : ^( 'throws' ( ID )+ ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:524:1: throwsSpec : ^( 'throws' ( ID )+ ) ; + public final void throwsSpec() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:523:2: ( ^( 'throws' ( ID )+ ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:523:4: ^( 'throws' ( ID )+ ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:525:2: ( ^( 'throws' ( ID )+ ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:525:4: ^( 'throws' ( ID )+ ) + { + match(input,THROWS,FOLLOW_THROWS_in_throwsSpec526); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:523:15: ( ID )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:525:15: ( ID )+ + int cnt28=0; + loop28: + while (true) { @@ -44052,7 +44185,7 @@ + + switch (alt28) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:523:15: ID ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:525:15: ID + { + match(input,ID,FOLLOW_ID_in_throwsSpec528); if (state.failed) return; + } @@ -44085,16 +44218,16 @@ + + + // $ANTLR start "ruleScopeSpec" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:526:1: ruleScopeSpec : ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:528:1: ruleScopeSpec : ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) ; + public final void ruleScopeSpec() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:2: ( ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:4: ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:2: ( ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:4: ^( 'scope' ( ^( AMPERSAND ( . )* ) )* ( ACTION )? ( ID )* ) + { + match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec543); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:15: ( ^( AMPERSAND ( . )* ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:15: ( ^( AMPERSAND ( . )* ) )* + loop30: + while (true) { + int alt30=2; @@ -44105,12 +44238,12 @@ + + switch (alt30) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:17: ^( AMPERSAND ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:17: ^( AMPERSAND ( . )* ) + { + match(input,AMPERSAND,FOLLOW_AMPERSAND_in_ruleScopeSpec548); if (state.failed) return; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:29: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:29: ( . )* + loop29: + while (true) { + int alt29=2; @@ -44124,7 +44257,7 @@ + + switch (alt29) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:29: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:29: . + { + matchAny(input); if (state.failed) return; + } @@ -44146,7 +44279,7 @@ + } + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:36: ( ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:36: ( ACTION )? + int alt31=2; + int LA31_0 = input.LA(1); + if ( (LA31_0==ACTION) ) { @@ -44154,7 +44287,7 @@ + } + switch (alt31) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:37: ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:37: ACTION + { + match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec558); if (state.failed) return; + } @@ -44162,7 +44295,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:46: ( ID )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:46: ( ID )* + loop32: + while (true) { + int alt32=2; @@ -44173,7 +44306,7 @@ + + switch (alt32) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:527:48: ID ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:529:48: ID + { + match(input,ID,FOLLOW_ID_in_ruleScopeSpec564); if (state.failed) return; + } @@ -44207,7 +44340,7 @@ + + + // $ANTLR start "block" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:530:1: block[String blockTemplateName, org.antlr.analysis.DFA dfa, GrammarAST label] returns [ST code=null] options {k=1; } : ({...}? => setBlock | ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:532:1: block[String blockTemplateName, org.antlr.analysis.DFA dfa, GrammarAST label] returns [ST code=null] options {k=1; } : ({...}? => setBlock | ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) ); + public final CodeGenTreeWalker.block_return block(String blockTemplateName, org.antlr.analysis.DFA dfa, GrammarAST label) throws RecognitionException { + CodeGenTreeWalker.block_return retval = new CodeGenTreeWalker.block_return(); + retval.start = input.LT(1); @@ -44245,7 +44378,7 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:562:2: ({...}? => setBlock | ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:564:2: ({...}? => setBlock | ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) ) + int alt36=2; + int LA36_0 = input.LA(1); + if ( (LA36_0==BLOCK) ) { @@ -44268,7 +44401,7 @@ + + switch (alt36) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:562:4: {...}? => setBlock ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:564:4: {...}? => setBlock + { + if ( !((((GrammarAST)retval.start).getSetValue()!=null)) ) { + if (state.backtracking>0) {state.failed=true; return retval;} @@ -44284,11 +44417,11 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:567:4: ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:569:4: ^( BLOCK ( ^( OPTIONS ( . )* ) )? (alt= alternative[$label] rew= rewrite )+ EOB ) + { + match(input,BLOCK,FOLLOW_BLOCK_in_block618); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:568:4: ( ^( OPTIONS ( . )* ) )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:570:4: ( ^( OPTIONS ( . )* ) )? + int alt34=2; + int LA34_0 = input.LA(1); + if ( (LA34_0==OPTIONS) ) { @@ -44296,12 +44429,12 @@ + } + switch (alt34) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:568:6: ^( OPTIONS ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:570:6: ^( OPTIONS ( . )* ) + { + match(input,OPTIONS,FOLLOW_OPTIONS_in_block626); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:568:16: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:570:16: ( . )* + loop33: + while (true) { + int alt33=2; @@ -44315,7 +44448,7 @@ + + switch (alt33) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:568:16: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:570:16: . + { + matchAny(input); if (state.failed) return retval; + } @@ -44334,7 +44467,7 @@ + + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:569:4: (alt= alternative[$label] rew= rewrite )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:571:4: (alt= alternative[$label] rew= rewrite )+ + int cnt35=0; + loop35: + while (true) { @@ -44346,7 +44479,7 @@ + + switch (alt35) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:569:6: alt= alternative[$label] rew= rewrite ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:571:6: alt= alternative[$label] rew= rewrite + { + pushFollow(FOLLOW_alternative_in_block643); + alt=alternative(label); @@ -44418,7 +44551,7 @@ + + + // $ANTLR start "setBlock" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:599:1: setBlock returns [ST code=null] : ^(s= BLOCK ( . )* ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:601:1: setBlock returns [ST code=null] : ^(s= BLOCK ( . )* ) ; + public final CodeGenTreeWalker.setBlock_return setBlock() throws RecognitionException { + CodeGenTreeWalker.setBlock_return retval = new CodeGenTreeWalker.setBlock_return(); + retval.start = input.LT(1); @@ -44441,13 +44574,13 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:616:2: ( ^(s= BLOCK ( . )* ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:616:4: ^(s= BLOCK ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:618:2: ( ^(s= BLOCK ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:618:4: ^(s= BLOCK ( . )* ) + { + s=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_setBlock697); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:616:14: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:618:14: ( . )* + loop37: + while (true) { + int alt37=2; @@ -44461,7 +44594,7 @@ + + switch (alt37) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:616:14: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:618:14: . + { + matchAny(input); if (state.failed) return retval; + } @@ -44524,15 +44657,15 @@ + + + // $ANTLR start "setAlternative" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:651:1: setAlternative : ^( ALT ( setElement )+ EOA ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:653:1: setAlternative : ^( ALT ( setElement )+ EOA ) ; + public final void setAlternative() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:652:2: ( ^( ALT ( setElement )+ EOA ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:652:4: ^( ALT ( setElement )+ EOA ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:654:2: ( ^( ALT ( setElement )+ EOA ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:654:4: ^( ALT ( setElement )+ EOA ) + { + match(input,ALT,FOLLOW_ALT_in_setAlternative717); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:652:10: ( setElement )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:654:10: ( setElement )+ + int cnt38=0; + loop38: + while (true) { @@ -44544,7 +44677,7 @@ + + switch (alt38) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:652:10: setElement ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:654:10: setElement + { + pushFollow(FOLLOW_setElement_in_setAlternative719); + setElement(); @@ -44581,10 +44714,10 @@ + + + // $ANTLR start "exceptionGroup" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:655:1: exceptionGroup[ST ruleST] : ( ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? | finallyClause[$ruleST] ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:657:1: exceptionGroup[ST ruleST] : ( ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? | finallyClause[$ruleST] ); + public final void exceptionGroup(ST ruleST) throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:2: ( ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? | finallyClause[$ruleST] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:2: ( ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? | finallyClause[$ruleST] ) + int alt41=2; + int LA41_0 = input.LA(1); + if ( (LA41_0==CATCH) ) { @@ -44603,9 +44736,9 @@ + + switch (alt41) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:4: ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:4: ( exceptionHandler[$ruleST] )+ ( finallyClause[$ruleST] )? + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:4: ( exceptionHandler[$ruleST] )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:4: ( exceptionHandler[$ruleST] )+ + int cnt39=0; + loop39: + while (true) { @@ -44617,7 +44750,7 @@ + + switch (alt39) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:6: exceptionHandler[$ruleST] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:6: exceptionHandler[$ruleST] + { + pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup737); + exceptionHandler(ruleST); @@ -44635,7 +44768,7 @@ + cnt39++; + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:35: ( finallyClause[$ruleST] )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:35: ( finallyClause[$ruleST] )? + int alt40=2; + int LA40_0 = input.LA(1); + if ( (LA40_0==FINALLY) ) { @@ -44643,7 +44776,7 @@ + } + switch (alt40) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:656:36: finallyClause[$ruleST] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:658:36: finallyClause[$ruleST] + { + pushFollow(FOLLOW_finallyClause_in_exceptionGroup744); + finallyClause(ruleST); @@ -44657,7 +44790,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:657:4: finallyClause[$ruleST] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:659:4: finallyClause[$ruleST] + { + pushFollow(FOLLOW_finallyClause_in_exceptionGroup752); + finallyClause(ruleST); @@ -44681,14 +44814,14 @@ + + + // $ANTLR start "exceptionHandler" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:660:1: exceptionHandler[ST ruleST] : ^( 'catch' ARG_ACTION ACTION ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:662:1: exceptionHandler[ST ruleST] : ^( 'catch' ARG_ACTION ACTION ) ; + public final void exceptionHandler(ST ruleST) throws RecognitionException { + GrammarAST ACTION2=null; + GrammarAST ARG_ACTION3=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:661:2: ( ^( 'catch' ARG_ACTION ACTION ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:661:4: ^( 'catch' ARG_ACTION ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:663:2: ( ^( 'catch' ARG_ACTION ACTION ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:663:4: ^( 'catch' ARG_ACTION ACTION ) + { + match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler766); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -44716,13 +44849,13 @@ + + + // $ANTLR start "finallyClause" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:668:1: finallyClause[ST ruleST] : ^( 'finally' ACTION ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:670:1: finallyClause[ST ruleST] : ^( 'finally' ACTION ) ; + public final void finallyClause(ST ruleST) throws RecognitionException { + GrammarAST ACTION4=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:669:2: ( ^( 'finally' ACTION ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:669:4: ^( 'finally' ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:671:2: ( ^( 'finally' ACTION ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:671:4: ^( 'finally' ACTION ) + { + match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause788); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -44753,7 +44886,7 @@ + + + // $ANTLR start "alternative" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:676:1: alternative[GrammarAST label] returns [ST code] : ^(a= ALT (e= element[$label,null] )+ EOA ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:678:1: alternative[GrammarAST label] returns [ST code] : ^(a= ALT (e= element[$label,null] )+ EOA ) ; + public final CodeGenTreeWalker.alternative_return alternative(GrammarAST label) throws RecognitionException { + CodeGenTreeWalker.alternative_return retval = new CodeGenTreeWalker.alternative_return(); + retval.start = input.LT(1); @@ -44781,12 +44914,12 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:697:2: ( ^(a= ALT (e= element[$label,null] )+ EOA ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:697:4: ^(a= ALT (e= element[$label,null] )+ EOA ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:699:2: ( ^(a= ALT (e= element[$label,null] )+ EOA ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:699:4: ^(a= ALT (e= element[$label,null] )+ EOA ) + { + a=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_alternative820); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:698:4: (e= element[$label,null] )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:700:4: (e= element[$label,null] )+ + int cnt42=0; + loop42: + while (true) { @@ -44798,7 +44931,7 @@ + + switch (alt42) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:699:5: e= element[$label,null] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:701:5: e= element[$label,null] + { + pushFollow(FOLLOW_element_in_alternative833); + e=element(label, null); @@ -44850,7 +44983,7 @@ + + + // $ANTLR start "element" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:715:1: element[GrammarAST label, GrammarAST astSuffix] returns [ST code=null] options {k=1; } : ( ^( ROOT e= element[$label,$ROOT] ) | ^( BANG e= element[$label,$BANG] ) | ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) | ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) | ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) | ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) | ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] | atom[null, $label, $astSuffix] | tree_ | element_action | (sp= SEMPRED |sp= GATED_SEMPRED ) | SYN_SEMPRED | ^( SYNPRED ( . )* ) | ^( BACKTRACK_SEMPRED ( . )* ) | EPSILON ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:717:1: element[GrammarAST label, GrammarAST astSuffix] returns [ST code=null] options {k=1; } : ( ^( ROOT e= element[$label,$ROOT] ) | ^( BANG e= element[$label,$BANG] ) | ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) | ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) | ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) | ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) | ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] | atom[null, $label, $astSuffix] | tree_ | element_action | (sp= SEMPRED |sp= GATED_SEMPRED ) | SYN_SEMPRED | ^( SYNPRED ( . )* ) | ^( BACKTRACK_SEMPRED ( . )* ) | EPSILON ); + public final CodeGenTreeWalker.element_return element(GrammarAST label, GrammarAST astSuffix) throws RecognitionException { + CodeGenTreeWalker.element_return retval = new CodeGenTreeWalker.element_return(); + retval.start = input.LT(1); @@ -44875,7 +45008,7 @@ + GrammarAST ast = null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:722:2: ( ^( ROOT e= element[$label,$ROOT] ) | ^( BANG e= element[$label,$BANG] ) | ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) | ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) | ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) | ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) | ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] | atom[null, $label, $astSuffix] | tree_ | element_action | (sp= SEMPRED |sp= GATED_SEMPRED ) | SYN_SEMPRED | ^( SYNPRED ( . )* ) | ^( BACKTRACK_SEMPRED ( . )* ) | EPSILON ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:724:2: ( ^( ROOT e= element[$label,$ROOT] ) | ^( BANG e= element[$label,$BANG] ) | ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) | ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) | ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) | ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) | ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] | atom[null, $label, $astSuffix] | tree_ | element_action | (sp= SEMPRED |sp= GATED_SEMPRED ) | SYN_SEMPRED | ^( SYNPRED ( . )* ) | ^( BACKTRACK_SEMPRED ( . )* ) | EPSILON ) + int alt46=15; + int LA46_0 = input.LA(1); + if ( (LA46_0==ROOT) ) { @@ -44949,7 +45082,7 @@ + + switch (alt46) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:722:4: ^( ROOT e= element[$label,$ROOT] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:724:4: ^( ROOT e= element[$label,$ROOT] ) + { + ROOT5=(GrammarAST)match(input,ROOT,FOLLOW_ROOT_in_element886); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -44963,7 +45096,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:725:4: ^( BANG e= element[$label,$BANG] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:727:4: ^( BANG e= element[$label,$BANG] ) + { + BANG6=(GrammarAST)match(input,BANG,FOLLOW_BANG_in_element903); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -44977,7 +45110,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:728:4: ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:730:4: ^(n= NOT ne= notElement[$n, $label, $astSuffix] ) + { + n=(GrammarAST)match(input,NOT,FOLLOW_NOT_in_element923); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -44991,7 +45124,7 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:731:4: ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:733:4: ^( ASSIGN alabel= ID e= element[$alabel,$astSuffix] ) + { + match(input,ASSIGN,FOLLOW_ASSIGN_in_element942); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -45006,7 +45139,7 @@ + } + break; + case 5 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:734:4: ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:736:4: ^( PLUS_ASSIGN label2= ID e= element[$label2,$astSuffix] ) + { + match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_element965); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -45021,7 +45154,7 @@ + } + break; + case 6 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:737:4: ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:739:4: ^( CHAR_RANGE a= CHAR_LITERAL b= CHAR_LITERAL ) + { + match(input,CHAR_RANGE,FOLLOW_CHAR_RANGE_in_element987); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -45043,7 +45176,7 @@ + } + break; + case 7 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:750:4: ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:752:4: ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) )=> ebnf[$label] + { + pushFollow(FOLLOW_ebnf_in_element1024); + ebnf7=ebnf(label); @@ -45053,7 +45186,7 @@ + } + break; + case 8 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:753:4: atom[null, $label, $astSuffix] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:755:4: atom[null, $label, $astSuffix] + { + pushFollow(FOLLOW_atom_in_element1035); + atom8=atom(null, label, astSuffix); @@ -45063,7 +45196,7 @@ + } + break; + case 9 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:756:4: tree_ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:758:4: tree_ + { + pushFollow(FOLLOW_tree__in_element1046); + tree_9=tree_(); @@ -45073,7 +45206,7 @@ + } + break; + case 10 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:759:4: element_action ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:761:4: element_action + { + pushFollow(FOLLOW_element_action_in_element1056); + element_action10=element_action(); @@ -45083,9 +45216,9 @@ + } + break; + case 11 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:762:6: (sp= SEMPRED |sp= GATED_SEMPRED ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:764:6: (sp= SEMPRED |sp= GATED_SEMPRED ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:762:6: (sp= SEMPRED |sp= GATED_SEMPRED ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:764:6: (sp= SEMPRED |sp= GATED_SEMPRED ) + int alt43=2; + int LA43_0 = input.LA(1); + if ( (LA43_0==SEMPRED) ) { @@ -45104,13 +45237,13 @@ + + switch (alt43) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:762:7: sp= SEMPRED ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:764:7: sp= SEMPRED + { + sp=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_element1071); if (state.failed) return retval; + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:762:18: sp= GATED_SEMPRED ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:764:18: sp= GATED_SEMPRED + { + sp=(GrammarAST)match(input,GATED_SEMPRED,FOLLOW_GATED_SEMPRED_in_element1075); if (state.failed) return retval; + } @@ -45127,18 +45260,18 @@ + } + break; + case 12 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:770:4: SYN_SEMPRED ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:772:4: SYN_SEMPRED + { + match(input,SYN_SEMPRED,FOLLOW_SYN_SEMPRED_in_element1086); if (state.failed) return retval; + } + break; + case 13 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:772:4: ^( SYNPRED ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:4: ^( SYNPRED ( . )* ) + { + match(input,SYNPRED,FOLLOW_SYNPRED_in_element1094); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:772:14: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:14: ( . )* + loop44: + while (true) { + int alt44=2; @@ -45152,7 +45285,7 @@ + + switch (alt44) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:772:14: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:14: . + { + matchAny(input); if (state.failed) return retval; + } @@ -45169,12 +45302,12 @@ + } + break; + case 14 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:4: ^( BACKTRACK_SEMPRED ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:776:4: ^( BACKTRACK_SEMPRED ( . )* ) + { + match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_element1105); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:24: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:776:24: ( . )* + loop45: + while (true) { + int alt45=2; @@ -45188,7 +45321,7 @@ + + switch (alt45) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:774:24: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:776:24: . + { + matchAny(input); if (state.failed) return retval; + } @@ -45205,7 +45338,7 @@ + } + break; + case 15 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:776:6: EPSILON ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:778:6: EPSILON + { + match(input,EPSILON,FOLLOW_EPSILON_in_element1117); if (state.failed) return retval; + } @@ -45231,7 +45364,7 @@ + + + // $ANTLR start "element_action" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:779:1: element_action returns [ST code=null] : (act= ACTION |act2= FORCED_ACTION ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:781:1: element_action returns [ST code=null] : (act= ACTION |act2= FORCED_ACTION ); + public final CodeGenTreeWalker.element_action_return element_action() throws RecognitionException { + CodeGenTreeWalker.element_action_return retval = new CodeGenTreeWalker.element_action_return(); + retval.start = input.LT(1); @@ -45240,7 +45373,7 @@ + GrammarAST act2=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:780:2: (act= ACTION |act2= FORCED_ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:782:2: (act= ACTION |act2= FORCED_ACTION ) + int alt47=2; + int LA47_0 = input.LA(1); + if ( (LA47_0==ACTION) ) { @@ -45259,7 +45392,7 @@ + + switch (alt47) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:780:4: act= ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:782:4: act= ACTION + { + act=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_element_action1134); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -45269,7 +45402,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:785:4: act2= FORCED_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:787:4: act2= FORCED_ACTION + { + act2=(GrammarAST)match(input,FORCED_ACTION,FOLLOW_FORCED_ACTION_in_element_action1145); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -45295,7 +45428,7 @@ + + + // $ANTLR start "notElement" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:792:1: notElement[GrammarAST n, GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:794:1: notElement[GrammarAST n, GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ; + public final ST notElement(GrammarAST n, GrammarAST label, GrammarAST astSuffix) throws RecognitionException { + ST code = null; + @@ -45314,10 +45447,10 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:802:2: ( (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:802:4: (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:804:2: ( (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:804:4: (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:802:4: (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:804:4: (assign_c= CHAR_LITERAL |assign_s= STRING_LITERAL |assign_t= TOKEN_REF | ^(assign_st= BLOCK ( . )* ) ) + int alt49=4; + switch ( input.LA(1) ) { + case CHAR_LITERAL: @@ -45348,7 +45481,7 @@ + } + switch (alt49) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:802:6: assign_c= CHAR_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:804:6: assign_c= CHAR_LITERAL + { + assign_c=(GrammarAST)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_notElement1174); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -45366,7 +45499,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:815:5: assign_s= STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:817:5: assign_s= STRING_LITERAL + { + assign_s=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_notElement1187); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -45384,7 +45517,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:828:5: assign_t= TOKEN_REF ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:830:5: assign_t= TOKEN_REF + { + assign_t=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_notElement1200); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -45394,12 +45527,12 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:833:5: ^(assign_st= BLOCK ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:835:5: ^(assign_st= BLOCK ( . )* ) + { + assign_st=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_notElement1214); if (state.failed) return code; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return code; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:833:23: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:835:23: ( . )* + loop48: + while (true) { + int alt48=2; @@ -45413,7 +45546,7 @@ + + switch (alt48) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:833:23: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:835:23: . + { + matchAny(input); if (state.failed) return code; + } @@ -45471,7 +45604,7 @@ + + + // $ANTLR start "ebnf" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:855:1: ebnf[GrammarAST label] returns [ST code=null] : (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:857:1: ebnf[GrammarAST label] returns [ST code=null] : (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ; + public final CodeGenTreeWalker.ebnf_return ebnf(GrammarAST label) throws RecognitionException { + CodeGenTreeWalker.ebnf_return retval = new CodeGenTreeWalker.ebnf_return(); + retval.start = input.LT(1); @@ -45484,10 +45617,10 @@ + GrammarAST eob = b.getLastChild(); // loops will use EOB DFA + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:862:2: ( (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:862:4: (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:864:2: ( (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:864:4: (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:862:4: (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:864:4: (blk= block[\"block\", dfa, $label] | ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) | ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) | ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ) + int alt50=4; + switch ( input.LA(1) ) { + case BLOCK: @@ -45518,7 +45651,7 @@ + } + switch (alt50) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:862:6: blk= block[\"block\", dfa, $label] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:864:6: blk= block[\"block\", dfa, $label] + { + if ( state.backtracking==0 ) { dfa = ((GrammarAST)retval.start).getLookaheadDFA(); } + pushFollow(FOLLOW_block_in_ebnf1261); @@ -45529,7 +45662,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:865:5: ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:867:5: ^( OPTIONAL blk= block[\"optionalBlock\", dfa, $label] ) + { + if ( state.backtracking==0 ) { dfa = ((GrammarAST)retval.start).getLookaheadDFA(); } + match(input,OPTIONAL,FOLLOW_OPTIONAL_in_ebnf1280); if (state.failed) return retval; @@ -45544,7 +45677,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:868:5: ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:870:5: ^( CLOSURE blk= block[\"closureBlock\", dfa, $label] ) + { + if ( state.backtracking==0 ) { dfa = eob.getLookaheadDFA(); } + match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf1305); if (state.failed) return retval; @@ -45559,7 +45692,7 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:871:5: ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:873:5: ^( POSITIVE_CLOSURE blk= block[\"positiveClosureBlock\", dfa, $label] ) + { + if ( state.backtracking==0 ) { dfa = eob.getLookaheadDFA(); } + match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf1330); if (state.failed) return retval; @@ -45602,7 +45735,7 @@ + + + // $ANTLR start "tree_" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:882:1: tree_ returns [ST code] : ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:884:1: tree_ returns [ST code] : ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) ; + public final CodeGenTreeWalker.tree__return tree_() throws RecognitionException { + CodeGenTreeWalker.tree__return retval = new CodeGenTreeWalker.tree__return(); + retval.start = input.LT(1); @@ -45633,8 +45766,8 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:906:2: ( ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:906:4: ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:908:2: ( ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:908:4: ^( TREE_BEGIN el= element[null,rootSuffix] ( ( element_action )=>act= element_action )* (el= element[null,null] )* ) + { + match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_tree_1372); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -45649,7 +45782,7 @@ + (el!=null?((GrammarAST)el.start):null).getCharPositionInLine() + 1 + ); + } -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:918:4: ( ( element_action )=>act= element_action )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:920:4: ( ( element_action )=>act= element_action )* + loop51: + while (true) { + int alt51=2; @@ -45671,7 +45804,7 @@ + + switch (alt51) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:918:6: ( element_action )=>act= element_action ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:920:6: ( element_action )=>act= element_action + { + pushFollow(FOLLOW_element_action_in_tree_1416); + act=element_action(); @@ -45692,7 +45825,7 @@ + } + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:928:4: (el= element[null,null] )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:930:4: (el= element[null,null] )* + loop52: + while (true) { + int alt52=2; @@ -45703,7 +45836,7 @@ + + switch (alt52) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:928:7: el= element[null,null] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:930:7: el= element[null,null] + { + pushFollow(FOLLOW_element_in_tree_1438); + el=element(null, null); @@ -45748,7 +45881,7 @@ + + + // $ANTLR start "atom" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:941:1: atom[GrammarAST scope, GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : ( ^(r= RULE_REF (rarg= ARG_ACTION )? ) | ^(t= TOKEN_REF (targ= ARG_ACTION )? ) |c= CHAR_LITERAL |s= STRING_LITERAL |w= WILDCARD | ^( DOT ID a= atom[$ID, label, astSuffix] ) | set[label,astSuffix] ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:943:1: atom[GrammarAST scope, GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : ( ^(r= RULE_REF (rarg= ARG_ACTION )? ) | ^(t= TOKEN_REF (targ= ARG_ACTION )? ) |c= CHAR_LITERAL |s= STRING_LITERAL |w= WILDCARD | ^( DOT ID a= atom[$ID, label, astSuffix] ) | set[label,astSuffix] ); + public final CodeGenTreeWalker.atom_return atom(GrammarAST scope, GrammarAST label, GrammarAST astSuffix) throws RecognitionException { + CodeGenTreeWalker.atom_return retval = new CodeGenTreeWalker.atom_return(); + retval.start = input.LT(1); @@ -45790,7 +45923,7 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:969:2: ( ^(r= RULE_REF (rarg= ARG_ACTION )? ) | ^(t= TOKEN_REF (targ= ARG_ACTION )? ) |c= CHAR_LITERAL |s= STRING_LITERAL |w= WILDCARD | ^( DOT ID a= atom[$ID, label, astSuffix] ) | set[label,astSuffix] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:971:2: ( ^(r= RULE_REF (rarg= ARG_ACTION )? ) | ^(t= TOKEN_REF (targ= ARG_ACTION )? ) |c= CHAR_LITERAL |s= STRING_LITERAL |w= WILDCARD | ^( DOT ID a= atom[$ID, label, astSuffix] ) | set[label,astSuffix] ) + int alt55=7; + switch ( input.LA(1) ) { + case RULE_REF: @@ -45836,12 +45969,12 @@ + } + switch (alt55) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:969:6: ^(r= RULE_REF (rarg= ARG_ACTION )? ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:971:6: ^(r= RULE_REF (rarg= ARG_ACTION )? ) + { + r=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_atom1488); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:969:20: (rarg= ARG_ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:971:20: (rarg= ARG_ACTION )? + int alt53=2; + int LA53_0 = input.LA(1); + if ( (LA53_0==ARG_ACTION) ) { @@ -45849,7 +45982,7 @@ + } + switch (alt53) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:969:21: rarg= ARG_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:971:21: rarg= ARG_ACTION + { + rarg=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1493); if (state.failed) return retval; + } @@ -45906,12 +46039,12 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1014:4: ^(t= TOKEN_REF (targ= ARG_ACTION )? ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1016:4: ^(t= TOKEN_REF (targ= ARG_ACTION )? ) + { + t=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom1511); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1014:19: (targ= ARG_ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1016:19: (targ= ARG_ACTION )? + int alt54=2; + int LA54_0 = input.LA(1); + if ( (LA54_0==ARG_ACTION) ) { @@ -45919,7 +46052,7 @@ + } + switch (alt54) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1014:20: targ= ARG_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1016:20: targ= ARG_ACTION + { + targ=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1516); if (state.failed) return retval; + } @@ -46000,7 +46133,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1083:4: c= CHAR_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1085:4: c= CHAR_LITERAL + { + c=(GrammarAST)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom1532); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -46029,7 +46162,7 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1108:4: s= STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1110:4: s= STRING_LITERAL + { + s=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom1544); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -46063,7 +46196,7 @@ + } + break; + case 5 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1138:4: w= WILDCARD ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1140:4: w= WILDCARD + { + w=(GrammarAST)match(input,WILDCARD,FOLLOW_WILDCARD_in_atom1556); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -46073,7 +46206,7 @@ + } + break; + case 6 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1144:4: ^( DOT ID a= atom[$ID, label, astSuffix] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1146:4: ^( DOT ID a= atom[$ID, label, astSuffix] ) + { + match(input,DOT,FOLLOW_DOT_in_atom1567); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -46088,7 +46221,7 @@ + } + break; + case 7 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1147:4: set[label,astSuffix] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1149:4: set[label,astSuffix] + { + pushFollow(FOLLOW_set_in_atom1586); + set12=set(label, astSuffix); @@ -46114,10 +46247,10 @@ + + + // $ANTLR start "ast_suffix" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1151:1: ast_suffix : ( ROOT | BANG ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1153:1: ast_suffix : ( ROOT | BANG ); + public final void ast_suffix() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1152:2: ( ROOT | BANG ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1154:2: ( ROOT | BANG ) + // org/antlr/grammar/v3/CodeGenTreeWalker.g: + { + if ( input.LA(1)==BANG||input.LA(1)==ROOT ) { @@ -46146,7 +46279,7 @@ + + + // $ANTLR start "set" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1156:1: set[GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : ^(s= BLOCK ( . )* ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1158:1: set[GrammarAST label, GrammarAST astSuffix] returns [ST code=null] : ^(s= BLOCK ( . )* ) ; + public final ST set(GrammarAST label, GrammarAST astSuffix) throws RecognitionException { + ST code = null; + @@ -46161,13 +46294,13 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1165:2: ( ^(s= BLOCK ( . )* ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1165:4: ^(s= BLOCK ( . )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1167:2: ( ^(s= BLOCK ( . )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1167:4: ^(s= BLOCK ( . )* ) + { + s=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_set1631); if (state.failed) return code; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return code; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1165:14: ( . )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1167:14: ( . )* + loop56: + while (true) { + int alt56=2; @@ -46181,7 +46314,7 @@ + + switch (alt56) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1165:14: . ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1167:14: . + { + matchAny(input); if (state.failed) return code; + } @@ -46222,10 +46355,10 @@ + + + // $ANTLR start "setElement" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1178:1: setElement : ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1180:1: setElement : ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) ); + public final void setElement() throws RecognitionException { + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1179:2: ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1181:2: ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) ) + int alt57=4; + switch ( input.LA(1) ) { + case CHAR_LITERAL: @@ -46256,25 +46389,25 @@ + } + switch (alt57) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1179:4: CHAR_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1181:4: CHAR_LITERAL + { + match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_setElement1651); if (state.failed) return; + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1180:4: TOKEN_REF ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1182:4: TOKEN_REF + { + match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_setElement1656); if (state.failed) return; + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1181:4: STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1183:4: STRING_LITERAL + { + match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement1661); if (state.failed) return; + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1182:4: ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1184:4: ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ) + { + match(input,CHAR_RANGE,FOLLOW_CHAR_RANGE_in_setElement1667); if (state.failed) return; + match(input, Token.DOWN, null); if (state.failed) return; @@ -46304,7 +46437,7 @@ + + + // $ANTLR start "rewrite" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1187:1: rewrite returns [ST code=null] : ( ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) |); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1189:1: rewrite returns [ST code=null] : ( ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) |); + public final CodeGenTreeWalker.rewrite_return rewrite() throws RecognitionException { + CodeGenTreeWalker.rewrite_return retval = new CodeGenTreeWalker.rewrite_return(); + retval.start = input.LT(1); @@ -46362,7 +46495,7 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1237:2: ( ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) |) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1239:2: ( ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) |) + int alt60=2; + int LA60_0 = input.LA(1); + if ( (LA60_0==REWRITES) ) { @@ -46381,12 +46514,12 @@ + + switch (alt60) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1237:4: ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1239:4: ^( REWRITES ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ) + { + match(input,REWRITES,FOLLOW_REWRITES_in_rewrite1696); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1238:4: ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1240:4: ( ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) )* + loop59: + while (true) { + int alt59=2; @@ -46397,12 +46530,12 @@ + + switch (alt59) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1239:5: ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1241:5: ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) + { + if ( state.backtracking==0 ) {rewriteRuleRefs = new HashSet();} + r=(GrammarAST)match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1717); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1240:18: (pred= SEMPRED )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1242:18: (pred= SEMPRED )? + int alt58=2; + int LA58_0 = input.LA(1); + if ( (LA58_0==SEMPRED) ) { @@ -46410,7 +46543,7 @@ + } + switch (alt58) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1240:19: pred= SEMPRED ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1242:19: pred= SEMPRED + { + pred=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_rewrite1722); if (state.failed) return retval; + } @@ -46455,7 +46588,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1261:2: ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1263:2: + { + } + break; @@ -46476,7 +46609,7 @@ + + + // $ANTLR start "rewrite_block" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1263:1: rewrite_block[String blockTemplateName] returns [ST code=null] : ^( BLOCK alt= rewrite_alternative EOB ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1265:1: rewrite_block[String blockTemplateName] returns [ST code=null] : ^( BLOCK alt= rewrite_alternative EOB ) ; + public final ST rewrite_block(String blockTemplateName) throws RecognitionException { + ST code = null; + @@ -46495,8 +46628,8 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1275:2: ( ^( BLOCK alt= rewrite_alternative EOB ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1275:4: ^( BLOCK alt= rewrite_alternative EOB ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1277:2: ( ^( BLOCK alt= rewrite_alternative EOB ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1277:4: ^( BLOCK alt= rewrite_alternative EOB ) + { + BLOCK13=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_rewrite_block1771); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -46534,7 +46667,7 @@ + + + // $ANTLR start "rewrite_alternative" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1291:1: rewrite_alternative returns [ST code=null] : ({...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) |{...}? rewrite_template | ETC ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1293:1: rewrite_alternative returns [ST code=null] : ({...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) |{...}? rewrite_template | ETC ); + public final ST rewrite_alternative() throws RecognitionException { + ST code = null; + @@ -46544,7 +46677,7 @@ + ST rewrite_template14 =null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1292:2: ({...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) |{...}? rewrite_template | ETC ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1294:2: ({...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) |{...}? rewrite_template | ETC ) + int alt63=3; + switch ( input.LA(1) ) { + case ALT: @@ -46670,7 +46803,7 @@ + } + switch (alt63) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1292:4: {...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1294:4: {...}? ^(a= ALT ( (el= rewrite_element )+ | EPSILON ) EOA ) + { + if ( !((generator.grammar.buildAST())) ) { + if (state.backtracking>0) {state.failed=true; return code;} @@ -46679,7 +46812,7 @@ + a=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_rewrite_alternative1823); if (state.failed) return code; + if ( state.backtracking==0 ) {code =templates.getInstanceOf("rewriteElementList");} + match(input, Token.DOWN, null); if (state.failed) return code; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1294:4: ( (el= rewrite_element )+ | EPSILON ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1296:4: ( (el= rewrite_element )+ | EPSILON ) + int alt62=2; + int LA62_0 = input.LA(1); + if ( (LA62_0==ACTION||LA62_0==CHAR_LITERAL||LA62_0==CLOSURE||LA62_0==LABEL||LA62_0==OPTIONAL||LA62_0==POSITIVE_CLOSURE||LA62_0==RULE_REF||LA62_0==STRING_LITERAL||LA62_0==TOKEN_REF||LA62_0==TREE_BEGIN) ) { @@ -46698,9 +46831,9 @@ + + switch (alt62) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1294:6: (el= rewrite_element )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1296:6: (el= rewrite_element )+ + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1294:6: (el= rewrite_element )+ ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1296:6: (el= rewrite_element )+ + int cnt61=0; + loop61: + while (true) { @@ -46712,7 +46845,7 @@ + + switch (alt61) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1295:6: el= rewrite_element ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1297:6: el= rewrite_element + { + pushFollow(FOLLOW_rewrite_element_in_rewrite_alternative1841); + el=rewrite_element(); @@ -46739,7 +46872,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1303:6: EPSILON ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1305:6: EPSILON + { + match(input,EPSILON,FOLLOW_EPSILON_in_rewrite_alternative1862); if (state.failed) return code; + if ( state.backtracking==0 ) {code.addAggr("elements.{el,line,pos}", @@ -46759,7 +46892,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1314:4: {...}? rewrite_template ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1316:4: {...}? rewrite_template + { + if ( !((generator.grammar.buildTemplate())) ) { + if (state.backtracking>0) {state.failed=true; return code;} @@ -46773,7 +46906,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1318:3: ETC ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1320:3: ETC + { + match(input,ETC,FOLLOW_ETC_in_rewrite_alternative1904); if (state.failed) return code; + } @@ -46799,7 +46932,7 @@ + + + // $ANTLR start "rewrite_element" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1321:1: rewrite_element returns [ST code=null] : ( rewrite_atom[false] | rewrite_ebnf | rewrite_tree ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1323:1: rewrite_element returns [ST code=null] : ( rewrite_atom[false] | rewrite_ebnf | rewrite_tree ); + public final CodeGenTreeWalker.rewrite_element_return rewrite_element() throws RecognitionException { + CodeGenTreeWalker.rewrite_element_return retval = new CodeGenTreeWalker.rewrite_element_return(); + retval.start = input.LT(1); @@ -46813,7 +46946,7 @@ + GrammarAST ast = null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1327:2: ( rewrite_atom[false] | rewrite_ebnf | rewrite_tree ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1329:2: ( rewrite_atom[false] | rewrite_ebnf | rewrite_tree ) + int alt64=3; + switch ( input.LA(1) ) { + case ACTION: @@ -46846,7 +46979,7 @@ + } + switch (alt64) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1327:4: rewrite_atom[false] ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1329:4: rewrite_atom[false] + { + pushFollow(FOLLOW_rewrite_atom_in_rewrite_element1924); + rewrite_atom15=rewrite_atom(false); @@ -46856,7 +46989,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1329:4: rewrite_ebnf ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1331:4: rewrite_ebnf + { + pushFollow(FOLLOW_rewrite_ebnf_in_rewrite_element1934); + rewrite_ebnf16=rewrite_ebnf(); @@ -46866,7 +46999,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1331:4: rewrite_tree ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1333:4: rewrite_tree + { + pushFollow(FOLLOW_rewrite_tree_in_rewrite_element1943); + rewrite_tree17=rewrite_tree(); @@ -46896,7 +47029,7 @@ + + + // $ANTLR start "rewrite_ebnf" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1335:1: rewrite_ebnf returns [ST code=null] : ( ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) | ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) | ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1337:1: rewrite_ebnf returns [ST code=null] : ( ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) | ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) | ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) ); + public final CodeGenTreeWalker.rewrite_ebnf_return rewrite_ebnf() throws RecognitionException { + CodeGenTreeWalker.rewrite_ebnf_return retval = new CodeGenTreeWalker.rewrite_ebnf_return(); + retval.start = input.LT(1); @@ -46906,7 +47039,7 @@ + ST rewrite_block20 =null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1336:2: ( ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) | ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) | ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1338:2: ( ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) | ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) | ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) ) + int alt65=3; + switch ( input.LA(1) ) { + case OPTIONAL: @@ -46932,7 +47065,7 @@ + } + switch (alt65) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1336:4: ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1338:4: ^( OPTIONAL rewrite_block[\"rewriteOptionalBlock\"] ) + { + match(input,OPTIONAL,FOLLOW_OPTIONAL_in_rewrite_ebnf1964); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -46951,7 +47084,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1343:4: ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1345:4: ^( CLOSURE rewrite_block[\"rewriteClosureBlock\"] ) + { + match(input,CLOSURE,FOLLOW_CLOSURE_in_rewrite_ebnf1984); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -46970,7 +47103,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1350:4: ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1352:4: ^( POSITIVE_CLOSURE rewrite_block[\"rewritePositiveClosureBlock\"] ) + { + match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_rewrite_ebnf2004); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -47009,7 +47142,7 @@ + + + // $ANTLR start "rewrite_tree" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1359:1: rewrite_tree returns [ST code] : ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) ; ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1361:1: rewrite_tree returns [ST code] : ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) ; + public final CodeGenTreeWalker.rewrite_tree_return rewrite_tree() throws RecognitionException { + CodeGenTreeWalker.rewrite_tree_return retval = new CodeGenTreeWalker.rewrite_tree_return(); + retval.start = input.LT(1); @@ -47027,8 +47160,8 @@ + } + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1370:2: ( ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1370:4: ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1372:2: ( ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1372:4: ^( TREE_BEGIN r= rewrite_atom[true] (el= rewrite_element )* ) + { + match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_rewrite_tree2039); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; @@ -47043,7 +47176,7 @@ + (r!=null?((GrammarAST)r.start):null).getCharPositionInLine() + 1 + ); + } -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1379:4: (el= rewrite_element )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1381:4: (el= rewrite_element )* + loop66: + while (true) { + int alt66=2; @@ -47054,7 +47187,7 @@ + + switch (alt66) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1380:6: el= rewrite_element ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1382:6: el= rewrite_element + { + pushFollow(FOLLOW_rewrite_element_in_rewrite_tree2066); + el=rewrite_element(); @@ -47104,7 +47237,7 @@ + + + // $ANTLR start "rewrite_atom" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1398:1: rewrite_atom[boolean isRoot] returns [ST code=null] : (r= RULE_REF | ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) | LABEL | ACTION ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1400:1: rewrite_atom[boolean isRoot] returns [ST code=null] : (r= RULE_REF | ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) | LABEL | ACTION ); + public final CodeGenTreeWalker.rewrite_atom_return rewrite_atom(boolean isRoot) throws RecognitionException { + CodeGenTreeWalker.rewrite_atom_return retval = new CodeGenTreeWalker.rewrite_atom_return(); + retval.start = input.LT(1); @@ -47118,7 +47251,7 @@ + GrammarAST ACTION22=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1399:2: (r= RULE_REF | ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) | LABEL | ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1401:2: (r= RULE_REF | ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) | LABEL | ACTION ) + int alt69=4; + switch ( input.LA(1) ) { + case RULE_REF: @@ -47151,7 +47284,7 @@ + } + switch (alt69) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1399:6: r= RULE_REF ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1401:6: r= RULE_REF + { + r=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_rewrite_atom2111); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -47192,9 +47325,9 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1437:3: ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:3: ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) + { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1437:3: ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:3: ( ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) |cl= CHAR_LITERAL |sl= STRING_LITERAL ) + int alt68=3; + switch ( input.LA(1) ) { + case TOKEN_REF: @@ -47220,12 +47353,12 @@ + } + switch (alt68) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1437:5: ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:5: ^(tk= TOKEN_REF (arg= ARG_ACTION )? ) + { + tk=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_rewrite_atom2128); if (state.failed) return retval; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return retval; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1437:20: (arg= ARG_ACTION )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:20: (arg= ARG_ACTION )? + int alt67=2; + int LA67_0 = input.LA(1); + if ( (LA67_0==ARG_ACTION) ) { @@ -47233,7 +47366,7 @@ + } + switch (alt67) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1437:21: arg= ARG_ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:21: arg= ARG_ACTION + { + arg=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rewrite_atom2133); if (state.failed) return retval; + } @@ -47247,13 +47380,13 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1438:5: cl= CHAR_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1440:5: cl= CHAR_LITERAL + { + cl=(GrammarAST)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_rewrite_atom2144); if (state.failed) return retval; + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1439:5: sl= STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1441:5: sl= STRING_LITERAL + { + sl=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_rewrite_atom2152); if (state.failed) return retval; + } @@ -47303,7 +47436,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1481:4: LABEL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1483:4: LABEL + { + LABEL21=(GrammarAST)match(input,LABEL,FOLLOW_LABEL_in_rewrite_atom2166); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -47368,7 +47501,7 @@ + } + break; + case 4 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1542:4: ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1544:4: ACTION + { + ACTION22=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_rewrite_atom2176); if (state.failed) return retval; + if ( state.backtracking==0 ) { @@ -47397,7 +47530,7 @@ + + + // $ANTLR start "rewrite_template" -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1553:1: public rewrite_template returns [ST code=null] : ( ^( ALT EPSILON EOA ) | ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) |act= ACTION ); ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1555:1: public rewrite_template returns [ST code=null] : ( ^( ALT EPSILON EOA ) | ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) |act= ACTION ); + public final ST rewrite_template() throws RecognitionException { + ST code = null; + @@ -47411,7 +47544,7 @@ + GrammarAST DOUBLE_ANGLE_STRING_LITERAL24=null; + + try { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1554:2: ( ^( ALT EPSILON EOA ) | ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) |act= ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1556:2: ( ^( ALT EPSILON EOA ) | ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) |act= ACTION ) + int alt73=3; + switch ( input.LA(1) ) { + case ALT: @@ -47437,7 +47570,7 @@ + } + switch (alt73) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1554:4: ^( ALT EPSILON EOA ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1556:4: ^( ALT EPSILON EOA ) + { + match(input,ALT,FOLLOW_ALT_in_rewrite_template2199); if (state.failed) return code; + match(input, Token.DOWN, null); if (state.failed) return code; @@ -47449,11 +47582,11 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1555:4: ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1557:4: ^( TEMPLATE (id= ID |ind= ACTION ) ^( ARGLIST ( ^( ARG arg= ID a= ACTION ) )* ) ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ) + { + match(input,TEMPLATE,FOLLOW_TEMPLATE_in_rewrite_template2214); if (state.failed) return code; + match(input, Token.DOWN, null); if (state.failed) return code; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1555:16: (id= ID |ind= ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1557:16: (id= ID |ind= ACTION ) + int alt70=2; + int LA70_0 = input.LA(1); + if ( (LA70_0==ID) ) { @@ -47472,13 +47605,13 @@ + + switch (alt70) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1555:17: id= ID ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1557:17: id= ID + { + id=(GrammarAST)match(input,ID,FOLLOW_ID_in_rewrite_template2219); if (state.failed) return code; + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1555:23: ind= ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1557:23: ind= ACTION + { + ind=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template2223); if (state.failed) return code; + } @@ -47506,7 +47639,7 @@ + match(input,ARGLIST,FOLLOW_ARGLIST_in_rewrite_template2236); if (state.failed) return code; + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); if (state.failed) return code; -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1574:5: ( ^( ARG arg= ID a= ACTION ) )* ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1576:5: ( ^( ARG arg= ID a= ACTION ) )* + loop71: + while (true) { + int alt71=2; @@ -47517,7 +47650,7 @@ + + switch (alt71) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1574:7: ^( ARG arg= ID a= ACTION ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1576:7: ^( ARG arg= ID a= ACTION ) + { + match(input,ARG,FOLLOW_ARG_in_rewrite_template2246); if (state.failed) return code; + match(input, Token.DOWN, null); if (state.failed) return code; @@ -47544,7 +47677,7 @@ + match(input, Token.UP, null); if (state.failed) return code; + } + -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1586:4: ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1588:4: ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )? + int alt72=3; + int LA72_0 = input.LA(1); + if ( (LA72_0==DOUBLE_QUOTE_STRING_LITERAL) ) { @@ -47555,7 +47688,7 @@ + } + switch (alt72) { + case 1 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1586:6: DOUBLE_QUOTE_STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1588:6: DOUBLE_QUOTE_STRING_LITERAL + { + DOUBLE_QUOTE_STRING_LITERAL23=(GrammarAST)match(input,DOUBLE_QUOTE_STRING_LITERAL,FOLLOW_DOUBLE_QUOTE_STRING_LITERAL_in_rewrite_template2287); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -47567,7 +47700,7 @@ + } + break; + case 2 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1593:6: DOUBLE_ANGLE_STRING_LITERAL ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1595:6: DOUBLE_ANGLE_STRING_LITERAL + { + DOUBLE_ANGLE_STRING_LITERAL24=(GrammarAST)match(input,DOUBLE_ANGLE_STRING_LITERAL,FOLLOW_DOUBLE_ANGLE_STRING_LITERAL_in_rewrite_template2300); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -47586,7 +47719,7 @@ + } + break; + case 3 : -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1603:4: act= ACTION ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:1605:4: act= ACTION + { + act=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template2324); if (state.failed) return code; + if ( state.backtracking==0 ) { @@ -47614,8 +47747,8 @@ + + // $ANTLR start synpred1_CodeGenTreeWalker + public final void synpred1_CodeGenTreeWalker_fragment() throws RecognitionException { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:750:4: ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:750:5: {...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:752:4: ({...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:752:5: {...}? ( BLOCK | OPTIONAL | CLOSURE | POSITIVE_CLOSURE ) + { + if ( !((((GrammarAST)input.LT(1)).getSetValue()==null)) ) { + if (state.backtracking>0) {state.failed=true; return;} @@ -47638,8 +47771,8 @@ + + // $ANTLR start synpred2_CodeGenTreeWalker + public final void synpred2_CodeGenTreeWalker_fragment() throws RecognitionException { -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:918:6: ( element_action ) -+ // org/antlr/grammar/v3/CodeGenTreeWalker.g:918:7: element_action ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:920:6: ( element_action ) ++ // org/antlr/grammar/v3/CodeGenTreeWalker.g:920:7: element_action + { + pushFollow(FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405); + element_action(); @@ -47856,9 +47989,9 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 05:23:39.470600591 +0200 @@ -0,0 +1,4468 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; +import org.antlr.tool.*; @@ -52327,9 +52460,9 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2019-04-04 17:22:25.476181469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 05:23:39.350602498 +0200 @@ -0,0 +1,3240 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; + @@ -55570,9 +55703,9 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 05:23:39.683920465 +0200 @@ -0,0 +1,4395 @@ -+// $ANTLR 3.5.2 org/antlr/grammar/v3/TreeToNFAConverter.g 2019-04-04 15:18:50 ++// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + +package org.antlr.grammar.v3; + @@ -59968,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2019-04-04 17:22:25.480181488 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 05:23:39.683920465 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 diff --git a/antlr3.spec b/antlr3.spec index 66be845..7376b48 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -244,7 +244,7 @@ EOF %if %{without bootstrap} %files javadoc -f .mfiles-javadoc -%license tool/LICENSE.txt +%license tool/LICENSE.txt what %endif From 039f9695ac11a68d2fc7a9ff191c255b7d6ab075e65976ca5ef93db5fa58e0d2 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 03:39:14 +0000 Subject: [PATCH 08/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=31 --- antlr3.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/antlr3.spec b/antlr3.spec index 7376b48..66be845 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -244,7 +244,7 @@ EOF %if %{without bootstrap} %files javadoc -f .mfiles-javadoc -%license tool/LICENSE.txt what +%license tool/LICENSE.txt %endif From 480795e4872c0d17c1db9013ae2df766a3e805275a8c53494686a3c5a49f488e Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 04:08:22 +0000 Subject: [PATCH 09/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=32 --- antlr3-generated_sources.patch | 124 ++++++++++++++++----------------- reproducible-order.patch | 32 ++++++++- 2 files changed, 92 insertions(+), 64 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index 33c4b0f..4a041f3 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 05:23:38.223945064 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 05:51:02.782812914 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 05:23:39.073938099 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 05:51:03.629462714 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 05:23:37.500617658 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 05:51:02.066160525 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 05:23:38.153945638 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 05:51:02.712814309 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 05:23:38.530609217 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 05:51:03.046141001 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 05:23:39.777247910 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 05:51:04.369447971 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 05:23:39.563928036 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 05:51:04.139452554 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 05:23:39.237270093 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 05:51:03.802792594 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 05:23:39.470600591 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 05:51:04.049454346 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 05:23:39.353935804 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 05:51:03.916123669 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 05:23:38.223945064 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 05:51:02.782812914 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 05:23:39.073938099 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 05:51:03.629462714 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 05:23:37.983947030 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 05:51:02.532817895 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 05:23:37.497284351 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 05:51:02.062827258 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -9262,9 +9262,9 @@ + + + // AST REWRITE -+ // elements: a, cmt, gid, ig, optionsSpec, r, scopes, ts, gr ++ // elements: a, cmt, gid, gr, ig, optionsSpec, r, scopes, ts + // token labels: cmt -+ // rule labels: a, r, gid, scopes, gr, ig, retval, ts ++ // rule labels: a, r, gid, gr, scopes, ig, retval, ts + // token list labels: + // rule list labels: + // wildcard labels: @@ -9274,8 +9274,8 @@ + RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.getTree():null); + RewriteRuleSubtreeStream stream_r=new RewriteRuleSubtreeStream(adaptor,"rule r",r!=null?r.getTree():null); + RewriteRuleSubtreeStream stream_gid=new RewriteRuleSubtreeStream(adaptor,"rule gid",gid!=null?gid.getTree():null); -+ RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); + RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); ++ RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); + RewriteRuleSubtreeStream stream_ig=new RewriteRuleSubtreeStream(adaptor,"rule ig",ig!=null?ig.getTree():null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); + RewriteRuleSubtreeStream stream_ts=new RewriteRuleSubtreeStream(adaptor,"rule ts",ts!=null?ts.getTree():null); @@ -11251,7 +11251,7 @@ + + + // AST REWRITE -+ // elements: aa, ex, optionsSpec, p1, p2, p4, rt, ruleActions, ruleAltList, ruleName, scopes, throwsSpec, p3 ++ // elements: aa, ex, optionsSpec, p1, p2, p3, p4, rt, ruleActions, ruleAltList, ruleName, scopes, throwsSpec + // token labels: aa, p1, p2, rt, p3, p4 + // rule labels: ex, ruleName, scopes, retval + // token list labels: @@ -11975,7 +11975,7 @@ + if ( state.backtracking==0 ) {if (LA(1)==OR||(LA(2)==QUESTION||LA(2)==PLUS||LA(2)==STAR)) prefixWithSynPred((a2!=null?((GrammarAST)a2.getTree()):null));} + + // AST REWRITE -+ // elements: r2, ruleAltList, a2 ++ // elements: a2, r2, ruleAltList + // token labels: + // rule labels: r2, a2, retval + // token list labels: @@ -12294,7 +12294,7 @@ + + + // AST REWRITE -+ // elements: alternative, block, optionsSpec, ruleActions, ACTION ++ // elements: ACTION, alternative, block, optionsSpec, ruleActions + // token labels: + // rule labels: retval + // token list labels: @@ -14675,7 +14675,7 @@ + + + // AST REWRITE -+ // elements: block, ROOT ++ // elements: ROOT, block + // token labels: + // rule labels: retval + // token list labels: @@ -14910,7 +14910,7 @@ + + + // AST REWRITE -+ // elements: c2, c1 ++ // elements: c1, c2 + // token labels: c1, c2 + // rule labels: retval + // token list labels: @@ -16596,7 +16596,7 @@ + if ( state.backtracking==0 ) stream_rewrite_alternative.add(rewrite_alternative166.getTree()); + + // AST REWRITE -+ // elements: rewrite_alternative, rewrite_with_sempred, REWRITE ++ // elements: REWRITE, rewrite_alternative, rewrite_with_sempred + // token labels: + // rule labels: retval + // token list labels: @@ -18343,7 +18343,7 @@ + + + // AST REWRITE -+ // elements: rewrite_template_args, id ++ // elements: id, rewrite_template_args + // token labels: + // rule labels: retval + // token list labels: @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 05:23:38.153945638 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 05:51:02.709481042 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 05:23:38.967272306 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 05:51:03.522798172 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 05:23:38.530609217 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 05:51:03.042807735 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26554,7 +26554,7 @@ + + + // AST REWRITE -+ // elements: DOC_COMMENT, attrScope, id, optionsSpec, rule, tokensSpec, action ++ // elements: DOC_COMMENT, action, attrScope, id, optionsSpec, rule, tokensSpec + // token labels: + // rule labels: retval + // token list labels: @@ -26865,7 +26865,7 @@ + + + // AST REWRITE -+ // elements: TOKEN_REF, lit, LABEL_ASSIGN ++ // elements: LABEL_ASSIGN, TOKEN_REF, lit + // token labels: lit + // rule labels: retval + // token list labels: @@ -27133,7 +27133,7 @@ + + + // AST REWRITE -+ // elements: AT, actionScopeName, id, ACTION ++ // elements: ACTION, AT, actionScopeName, id + // token labels: + // rule labels: retval + // token list labels: @@ -27410,7 +27410,7 @@ + + + // AST REWRITE -+ // elements: option, OPTIONS ++ // elements: OPTIONS, option + // token labels: + // rule labels: retval + // token list labels: @@ -28232,7 +28232,7 @@ + + + // AST REWRITE -+ // elements: AT, id, ACTION ++ // elements: ACTION, AT, id + // token labels: + // rule labels: retval + // token list labels: @@ -28522,7 +28522,7 @@ + + + // AST REWRITE -+ // elements: SCOPE, ACTION ++ // elements: ACTION, SCOPE + // token labels: + // rule labels: retval + // token list labels: @@ -28596,7 +28596,7 @@ + + + // AST REWRITE -+ // elements: id, SCOPE ++ // elements: SCOPE, id + // token labels: + // rule labels: retval + // token list labels: @@ -28683,7 +28683,7 @@ + + + // AST REWRITE -+ // elements: ACTION, id, SCOPE ++ // elements: ACTION, SCOPE, id + // token labels: + // rule labels: retval + // token list labels: @@ -29458,7 +29458,7 @@ + + + // AST REWRITE -+ // elements: 81, ARG_ACTION, ACTION ++ // elements: 81, ACTION, ARG_ACTION + // token labels: + // rule labels: retval + // token list labels: @@ -30004,7 +30004,7 @@ + { + + // AST REWRITE -+ // elements: id, labelOp, atom ++ // elements: atom, id, labelOp + // token labels: labelOp + // rule labels: retval + // token list labels: @@ -30177,7 +30177,7 @@ + { + + // AST REWRITE -+ // elements: id, labelOp, block ++ // elements: block, id, labelOp + // token labels: labelOp + // rule labels: retval + // token list labels: @@ -30249,7 +30249,7 @@ + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix97.getTree()); + + // AST REWRITE -+ // elements: ebnfSuffix, atom ++ // elements: atom, ebnfSuffix + // token labels: + // rule labels: retval + // token list labels: @@ -30872,7 +30872,7 @@ + + + // AST REWRITE -+ // elements: op, notSet ++ // elements: notSet, op + // token labels: op + // rule labels: retval + // token list labels: @@ -31018,7 +31018,7 @@ + + + // AST REWRITE -+ // elements: RULE_REF, op, ARG_ACTION ++ // elements: ARG_ACTION, RULE_REF, op + // token labels: op + // rule labels: retval + // token list labels: @@ -31202,7 +31202,7 @@ + + + // AST REWRITE -+ // elements: elementOptions, notTerminal, 93 ++ // elements: 93, elementOptions, notTerminal + // token labels: + // rule labels: retval + // token list labels: @@ -31267,7 +31267,7 @@ + + + // AST REWRITE -+ // elements: block, elementOptions, 93 ++ // elements: 93, block, elementOptions + // token labels: + // rule labels: retval + // token list labels: @@ -31693,7 +31693,7 @@ + if ( state.backtracking==0 ) stream_optionValue.add(optionValue124.getTree()); + + // AST REWRITE -+ // elements: LABEL_ASSIGN, optionValue, id ++ // elements: LABEL_ASSIGN, id, optionValue + // token labels: + // rule labels: retval + // token list labels: @@ -32098,7 +32098,7 @@ + + + // AST REWRITE -+ // elements: elementOptions, CHAR_LITERAL ++ // elements: CHAR_LITERAL, elementOptions + // token labels: + // rule labels: retval + // token list labels: @@ -32178,7 +32178,7 @@ + + + // AST REWRITE -+ // elements: TOKEN_REF, elementOptions, ARG_ACTION ++ // elements: ARG_ACTION, TOKEN_REF, elementOptions + // token labels: + // rule labels: retval + // token list labels: @@ -32246,7 +32246,7 @@ + + + // AST REWRITE -+ // elements: elementOptions, STRING_LITERAL ++ // elements: STRING_LITERAL, elementOptions + // token labels: + // rule labels: retval + // token list labels: @@ -32308,7 +32308,7 @@ + + + // AST REWRITE -+ // elements: elementOptions, 73 ++ // elements: 73, elementOptions + // token labels: + // rule labels: retval + // token list labels: @@ -32400,7 +32400,7 @@ + + + // AST REWRITE -+ // elements: terminal, BANG ++ // elements: BANG, terminal + // token labels: + // rule labels: retval + // token list labels: @@ -33025,7 +33025,7 @@ + if ( state.backtracking==0 ) stream_rewrite_alternative.add(last.getTree()); + + // AST REWRITE -+ // elements: predicated, preds, rew, rew2, last ++ // elements: last, predicated, preds, rew, rew2 + // token labels: rew2 + // rule labels: last, retval + // token list labels: rew, preds @@ -33043,7 +33043,7 @@ + // 357:9: -> ( ^( $rew $preds $predicated) )* ^( $rew2 $last) + { + // org/antlr/grammar/v3/ANTLRv3.g:357:12: ( ^( $rew $preds $predicated) )* -+ while ( stream_predicated.hasNext()||stream_rew.hasNext()||stream_preds.hasNext() ) { ++ while ( stream_predicated.hasNext()||stream_preds.hasNext()||stream_rew.hasNext() ) { + // org/antlr/grammar/v3/ANTLRv3.g:357:12: ^( $rew $preds $predicated) + { + CommonTree root_1 = (CommonTree)adaptor.nil(); @@ -33055,8 +33055,8 @@ + + } + stream_predicated.reset(); -+ stream_rew.reset(); + stream_preds.reset(); ++ stream_rew.reset(); + + // org/antlr/grammar/v3/ANTLRv3.g:357:40: ^( $rew2 $last) + { @@ -34144,7 +34144,7 @@ + if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix156.getTree()); + + // AST REWRITE -+ // elements: rewrite_tree, ebnfSuffix ++ // elements: ebnfSuffix, rewrite_tree + // token labels: + // rule labels: retval + // token list labels: @@ -35076,7 +35076,7 @@ + + + // AST REWRITE -+ // elements: rewrite_template_args, ACTION ++ // elements: ACTION, rewrite_template_args + // token labels: + // rule labels: retval + // token list labels: @@ -35334,7 +35334,7 @@ + + + // AST REWRITE -+ // elements: id, ACTION ++ // elements: ACTION, id + // token labels: + // rule labels: retval + // token list labels: @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 05:23:39.777247910 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 05:51:04.369447971 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 05:23:39.563928036 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 05:51:04.139452554 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 05:23:39.237270093 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 05:51:03.799459327 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 05:23:39.470600591 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 05:51:04.046121079 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 05:23:39.350602498 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 05:51:03.916123669 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 05:23:39.683920465 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 05:51:04.272783231 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 05:23:39.683920465 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 05:51:04.272783231 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 diff --git a/reproducible-order.patch b/reproducible-order.patch index ef3e1b7..be22997 100644 --- a/reproducible-order.patch +++ b/reproducible-order.patch @@ -1,5 +1,5 @@ ---- antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 17:54:38.044172037 +0200 -+++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 17:58:10.758972706 +0200 +--- antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 20:06:39.620275234 +0200 ++++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 20:07:19.236138007 +0200 @@ -56,6 +56,7 @@ import java.util.HashSet; import java.util.Set; @@ -16,3 +16,31 @@ return labels; } +--- antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-15 20:06:39.623608500 +0200 ++++ antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-16 06:04:09.530338104 +0200 +@@ -33,6 +33,7 @@ + import org.stringtemplate.v4.ST; + import org.stringtemplate.v4.STGroup; + ++import java.util.Collections; + import java.util.List; + + public class ACyclicDFACodeGenerator { +@@ -114,6 +115,7 @@ + // If the template wants all the label values delineated, do that + if ( edgeST.impl.formalArguments.get("labels")!=null ) { + List labels = edge.label.getSet().toList(); ++ Collections.sort(labels); + List targetLabels = new ArrayList(labels.size()); + for (int j = 0; j < labels.size(); j++) { + Integer vI = labels.get(j); +--- antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/CodeGenerator.java 2023-09-15 20:06:39.623608500 +0200 ++++ antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/CodeGenerator.java 2023-09-16 06:02:44.522033399 +0200 +@@ -587,6 +588,7 @@ + BitSet bits = BitSet.of(follow.tokenTypeSet); + words = bits.toPackedArray(); + tokenTypeList = follow.tokenTypeSet.toList(); ++ Collections.sort(tokenTypeList); + } + // use the target to convert to hex strings (typically) + String[] wordStrings = new String[words.length]; From d37bc05ee491d90c3d7ce10cbcb4f44633b4a86b30e33389a1265ed75a74abf6 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 04:16:35 +0000 Subject: [PATCH 10/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=33 --- antlr3-generated_sources.patch | 52 +++++++++++++++++----------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index 4a041f3..a5697d9 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 05:51:02.782812914 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:12:32.370276881 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 05:51:03.629462714 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:12:33.176927225 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 05:51:02.066160525 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:12:31.633625120 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 05:51:02.712814309 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:12:32.296945031 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 05:51:03.046141001 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:12:32.643604684 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 05:51:04.369447971 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:12:33.873579794 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 05:51:04.139452554 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:12:33.660250778 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 05:51:03.802792594 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:12:33.350257051 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 05:51:04.049454346 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:12:33.573585865 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 05:51:03.916123669 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:12:33.456921559 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 05:51:02.782812914 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:12:32.366943615 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 05:51:03.629462714 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:12:33.176927225 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 05:51:02.532817895 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:12:32.113615408 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 05:51:02.062827258 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:12:31.633625120 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -9264,7 +9264,7 @@ + // AST REWRITE + // elements: a, cmt, gid, gr, ig, optionsSpec, r, scopes, ts + // token labels: cmt -+ // rule labels: a, r, gid, gr, scopes, ig, retval, ts ++ // rule labels: a, r, gid, scopes, gr, ig, retval, ts + // token list labels: + // rule list labels: + // wildcard labels: @@ -9274,8 +9274,8 @@ + RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.getTree():null); + RewriteRuleSubtreeStream stream_r=new RewriteRuleSubtreeStream(adaptor,"rule r",r!=null?r.getTree():null); + RewriteRuleSubtreeStream stream_gid=new RewriteRuleSubtreeStream(adaptor,"rule gid",gid!=null?gid.getTree():null); -+ RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); + RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); ++ RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); + RewriteRuleSubtreeStream stream_ig=new RewriteRuleSubtreeStream(adaptor,"rule ig",ig!=null?ig.getTree():null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); + RewriteRuleSubtreeStream stream_ts=new RewriteRuleSubtreeStream(adaptor,"rule ts",ts!=null?ts.getTree():null); @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 05:51:02.709481042 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:12:32.293611766 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 05:51:03.522798172 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:12:33.070262717 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 05:51:03.042807735 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:12:32.640271417 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 05:51:04.369447971 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:12:33.873579794 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 05:51:04.139452554 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:12:33.656917512 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 05:51:03.799459327 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:12:33.346923785 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 05:51:04.046121079 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:12:33.573585865 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 05:51:03.916123669 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:12:33.453588293 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 05:51:04.272783231 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:12:33.780248350 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 05:51:04.272783231 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:12:33.783581616 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 From da06c80c3cf9cca8231e5a16a26833a7ea4507d6b50ba1b9fc9a7d8246c09075 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 04:49:33 +0000 Subject: [PATCH 11/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=34 --- antlr3-generated_sources.patch | 54 +++++++++++++++++----------------- reproducible-order.patch | 28 ++++++++++++++++-- 2 files changed, 52 insertions(+), 30 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index a5697d9..32e5a9e 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:12:32.370276881 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:48:15.460663565 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:12:33.176927225 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:48:16.407311173 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:12:31.633625120 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:48:14.777343989 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:12:32.296945031 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:48:15.390664975 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:12:32.643604684 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:48:15.730658129 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:12:33.873579794 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:48:17.117296878 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:12:33.660250778 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:48:16.903967840 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:12:33.350257051 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:48:16.583974283 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:12:33.573585865 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:48:16.810636386 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:12:33.456921559 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:48:16.697305334 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:12:32.366943615 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:48:15.460663565 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:12:33.176927225 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:48:16.407311173 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:12:32.113615408 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:48:15.220668397 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:12:31.633625120 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:48:14.774010723 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:12:32.293611766 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:48:15.387331708 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:12:33.070262717 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:48:16.307313186 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:12:32.640271417 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:48:15.727324863 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:12:33.873579794 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:48:17.113963612 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:12:33.656917512 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:48:16.900634574 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:12:33.346923785 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:48:16.580641016 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -42692,7 +42692,7 @@ +import org.antlr.tool.*; +import org.antlr.codegen.*; + -+import java.util.HashSet; ++import java.util.TreeSet; +import java.util.Set; +import java.util.Collection; +import java.util.Collections; @@ -42868,7 +42868,7 @@ + protected ST currentBlockST = null; + protected boolean currentAltHasASTRewrite = false; + protected int rewriteTreeNestingLevel = 0; -+ protected HashSet rewriteRuleRefs = null; ++ protected TreeSet rewriteRuleRefs = null; + + public String getCurrentRuleName() { + return currentRuleName; @@ -46532,7 +46532,7 @@ + case 1 : + // org/antlr/grammar/v3/CodeGenTreeWalker.g:1241:5: ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) + { -+ if ( state.backtracking==0 ) {rewriteRuleRefs = new HashSet();} ++ if ( state.backtracking==0 ) {rewriteRuleRefs = new TreeSet();} + r=(GrammarAST)match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1717); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; + // org/antlr/grammar/v3/CodeGenTreeWalker.g:1242:18: (pred= SEMPRED )? @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:12:33.573585865 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:48:16.810636386 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:12:33.453588293 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:48:16.693972068 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:12:33.780248350 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:48:17.020632158 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:12:33.783581616 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:48:17.023965424 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 diff --git a/reproducible-order.patch b/reproducible-order.patch index be22997..93bbc8a 100644 --- a/reproducible-order.patch +++ b/reproducible-order.patch @@ -1,13 +1,26 @@ --- antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 20:06:39.620275234 +0200 -+++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 20:07:19.236138007 +0200 -@@ -56,6 +56,7 @@ - import java.util.HashSet; ++++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-16 06:38:17.929360459 +0200 +@@ -53,9 +53,10 @@ + import org.antlr.tool.*; + import org.antlr.codegen.*; + +-import java.util.HashSet; ++import java.util.TreeSet; import java.util.Set; import java.util.Collection; +import java.util.Collections; import org.antlr.runtime.BitSet; import org.antlr.runtime.DFA; import org.stringtemplate.v4.ST; +@@ -73,7 +74,7 @@ + protected ST currentBlockST = null; + protected boolean currentAltHasASTRewrite = false; + protected int rewriteTreeNestingLevel = 0; +-protected HashSet rewriteRuleRefs = null; ++protected TreeSet rewriteRuleRefs = null; + + public String getCurrentRuleName() { + return currentRuleName; @@ -284,6 +285,7 @@ } labels.add( label ); @@ -16,6 +29,15 @@ return labels; } +@@ -1236,7 +1236,7 @@ + } + : ^( REWRITES + ( +- {rewriteRuleRefs = new HashSet();} ++ {rewriteRuleRefs = new TreeSet();} + ^( r=REWRITE (pred=SEMPRED)? alt=rewrite_alternative) + { + rewriteBlockNestingLevel = OUTER_REWRITE_NESTING_LEVEL; --- antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-15 20:06:39.623608500 +0200 +++ antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-16 06:04:09.530338104 +0200 @@ -33,6 +33,7 @@ From 17ba13e91e06df55c06a58b150116294003be955321a2daf23504503de476caa Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 04:56:10 +0000 Subject: [PATCH 12/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=35 --- antlr3-generated_sources.patch | 52 +++++++++++++++++----------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index 32e5a9e..ec9d0eb 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:48:15.460663565 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:54:52.092708677 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:48:16.407311173 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:54:52.936025139 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:48:14.777343989 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:54:51.359390016 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:48:15.390664975 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:54:52.016043545 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:48:15.730658129 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:54:52.362703276 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:48:17.117296878 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:54:53.769341800 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:48:16.903967840 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:54:53.502680469 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:48:16.583974283 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:54:53.136021137 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:48:16.810636386 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:54:53.399349202 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:48:16.697305334 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:54:53.266018537 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:48:15.460663565 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:54:52.092708677 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:48:16.407311173 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:54:52.936025139 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:48:15.220668397 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:54:51.816047547 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:48:14.774010723 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:54:51.359390016 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -9264,7 +9264,7 @@ + // AST REWRITE + // elements: a, cmt, gid, gr, ig, optionsSpec, r, scopes, ts + // token labels: cmt -+ // rule labels: a, r, gid, scopes, gr, ig, retval, ts ++ // rule labels: a, r, gid, gr, scopes, ig, retval, ts + // token list labels: + // rule list labels: + // wildcard labels: @@ -9274,8 +9274,8 @@ + RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.getTree():null); + RewriteRuleSubtreeStream stream_r=new RewriteRuleSubtreeStream(adaptor,"rule r",r!=null?r.getTree():null); + RewriteRuleSubtreeStream stream_gid=new RewriteRuleSubtreeStream(adaptor,"rule gid",gid!=null?gid.getTree():null); -+ RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); + RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); ++ RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); + RewriteRuleSubtreeStream stream_ig=new RewriteRuleSubtreeStream(adaptor,"rule ig",ig!=null?ig.getTree():null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); + RewriteRuleSubtreeStream stream_ts=new RewriteRuleSubtreeStream(adaptor,"rule ts",ts!=null?ts.getTree():null); @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:48:15.387331708 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:54:52.012710278 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:48:16.307313186 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:54:52.799361206 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:48:15.727324863 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:54:52.362703276 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:48:17.113963612 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:54:53.766008534 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:48:16.900634574 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:54:53.502680469 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:48:16.580641016 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:54:53.132687871 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:48:16.810636386 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:54:53.396015935 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:48:16.693972068 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:54:53.266018537 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:48:17.020632158 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:54:53.649344201 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:48:17.023965424 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:54:53.649344201 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 From c20f4aaabd6014c0b92492216bc0a7f3815562451197e0ed279fcdb68c19b0f9 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 05:08:52 +0000 Subject: [PATCH 13/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=36 --- antlr3-generated_sources.patch | 54 +++++++++++++++++----------------- reproducible-order.patch | 54 ++-------------------------------- 2 files changed, 29 insertions(+), 79 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index ec9d0eb..bcfb028 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 06:54:52.092708677 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 07:07:33.484142088 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 06:54:52.936025139 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 07:07:34.314125482 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 06:54:51.359390016 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 07:07:32.747490159 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 06:54:52.016043545 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 07:07:33.407476955 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 06:54:52.362703276 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 07:07:33.787469352 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 06:54:53.769341800 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 07:07:34.994111877 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 06:54:53.502680469 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 07:07:34.787449346 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 06:54:53.136021137 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 07:07:34.480788814 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 06:54:53.399349202 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 07:07:34.704117679 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 06:54:53.266018537 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 07:07:34.587453347 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 06:54:52.092708677 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 07:07:33.484142088 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 06:54:52.936025139 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 07:07:34.314125482 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 06:54:51.816047547 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 07:07:33.220814023 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 06:54:51.359390016 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 07:07:32.744156892 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 06:54:52.012710278 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 07:07:33.404143688 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 06:54:52.799361206 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 07:07:34.207460949 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 06:54:52.362703276 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 07:07:33.784136086 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 06:54:53.766008534 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 07:07:34.994111877 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 06:54:53.502680469 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 07:07:34.787449346 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 06:54:53.132687871 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 07:07:34.477455548 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -42692,7 +42692,7 @@ +import org.antlr.tool.*; +import org.antlr.codegen.*; + -+import java.util.TreeSet; ++import java.util.HashSet; +import java.util.Set; +import java.util.Collection; +import java.util.Collections; @@ -42868,7 +42868,7 @@ + protected ST currentBlockST = null; + protected boolean currentAltHasASTRewrite = false; + protected int rewriteTreeNestingLevel = 0; -+ protected TreeSet rewriteRuleRefs = null; ++ protected HashSet rewriteRuleRefs = null; + + public String getCurrentRuleName() { + return currentRuleName; @@ -46532,7 +46532,7 @@ + case 1 : + // org/antlr/grammar/v3/CodeGenTreeWalker.g:1241:5: ^(r= REWRITE (pred= SEMPRED )? alt= rewrite_alternative ) + { -+ if ( state.backtracking==0 ) {rewriteRuleRefs = new TreeSet();} ++ if ( state.backtracking==0 ) {rewriteRuleRefs = new HashSet();} + r=(GrammarAST)match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1717); if (state.failed) return retval; + match(input, Token.DOWN, null); if (state.failed) return retval; + // org/antlr/grammar/v3/CodeGenTreeWalker.g:1242:18: (pred= SEMPRED )? @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 06:54:53.396015935 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 07:07:34.700784413 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 06:54:53.266018537 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 07:07:34.587453347 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 06:54:53.649344201 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 07:07:34.904113678 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 06:54:53.649344201 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 07:07:34.907446945 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 diff --git a/reproducible-order.patch b/reproducible-order.patch index 93bbc8a..7f6f14c 100644 --- a/reproducible-order.patch +++ b/reproducible-order.patch @@ -1,26 +1,13 @@ --- antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 20:06:39.620275234 +0200 +++ antlr3-3.5.3/tool/src/main/antlr3/org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-16 06:38:17.929360459 +0200 -@@ -53,9 +53,10 @@ - import org.antlr.tool.*; - import org.antlr.codegen.*; - --import java.util.HashSet; -+import java.util.TreeSet; +@@ -56,6 +56,7 @@ + import java.util.HashSet; import java.util.Set; import java.util.Collection; +import java.util.Collections; import org.antlr.runtime.BitSet; import org.antlr.runtime.DFA; import org.stringtemplate.v4.ST; -@@ -73,7 +74,7 @@ - protected ST currentBlockST = null; - protected boolean currentAltHasASTRewrite = false; - protected int rewriteTreeNestingLevel = 0; --protected HashSet rewriteRuleRefs = null; -+protected TreeSet rewriteRuleRefs = null; - - public String getCurrentRuleName() { - return currentRuleName; @@ -284,6 +285,7 @@ } labels.add( label ); @@ -29,40 +16,3 @@ return labels; } -@@ -1236,7 +1236,7 @@ - } - : ^( REWRITES - ( -- {rewriteRuleRefs = new HashSet();} -+ {rewriteRuleRefs = new TreeSet();} - ^( r=REWRITE (pred=SEMPRED)? alt=rewrite_alternative) - { - rewriteBlockNestingLevel = OUTER_REWRITE_NESTING_LEVEL; ---- antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-15 20:06:39.623608500 +0200 -+++ antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/ACyclicDFACodeGenerator.java 2023-09-16 06:04:09.530338104 +0200 -@@ -33,6 +33,7 @@ - import org.stringtemplate.v4.ST; - import org.stringtemplate.v4.STGroup; - -+import java.util.Collections; - import java.util.List; - - public class ACyclicDFACodeGenerator { -@@ -114,6 +115,7 @@ - // If the template wants all the label values delineated, do that - if ( edgeST.impl.formalArguments.get("labels")!=null ) { - List labels = edge.label.getSet().toList(); -+ Collections.sort(labels); - List targetLabels = new ArrayList(labels.size()); - for (int j = 0; j < labels.size(); j++) { - Integer vI = labels.get(j); ---- antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/CodeGenerator.java 2023-09-15 20:06:39.623608500 +0200 -+++ antlr3-3.5.3/tool/src/main/java/org/antlr/codegen/CodeGenerator.java 2023-09-16 06:02:44.522033399 +0200 -@@ -587,6 +588,7 @@ - BitSet bits = BitSet.of(follow.tokenTypeSet); - words = bits.toPackedArray(); - tokenTypeList = follow.tokenTypeSet.toList(); -+ Collections.sort(tokenTypeList); - } - // use the target to convert to hex strings (typically) - String[] wordStrings = new String[words.length]; From 3ae014e1f083be8bf0c454a1c32d9614b1abc8abbd6b33b0422b49a4ec82922e Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Sat, 16 Sep 2023 05:26:07 +0000 Subject: [PATCH 14/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=37 --- antlr3-generated_sources.patch | 52 +++++++++++++++++----------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/antlr3-generated_sources.patch b/antlr3-generated_sources.patch index bcfb028..57ae0fc 100644 --- a/antlr3-generated_sources.patch +++ b/antlr3-generated_sources.patch @@ -1,12 +1,12 @@ --- tool/src/main/java/ActionAnalysis.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 07:07:33.484142088 +0200 ++++ tool/src/main/java/ActionAnalysis.tokens 2023-09-16 07:24:37.353550331 +0200 @@ -0,0 +1,4 @@ +ID=4 +X=5 +X_Y=6 +Y=7 --- tool/src/main/java/ActionTranslator.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 07:07:34.314125482 +0200 ++++ tool/src/main/java/ActionTranslator.tokens 2023-09-16 07:24:38.166867305 +0200 @@ -0,0 +1,34 @@ +ACTION=4 +ARG=5 @@ -43,7 +43,7 @@ +UNKNOWN_SYNTAX=36 +WS=37 --- tool/src/main/java/ANTLR.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLR.tokens 2023-09-16 07:07:32.747490159 +0200 ++++ tool/src/main/java/ANTLR.tokens 2023-09-16 07:24:36.620231748 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -160,7 +160,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRTreePrinter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 07:07:33.407476955 +0200 ++++ tool/src/main/java/ANTLRTreePrinter.tokens 2023-09-16 07:24:37.273551941 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -277,7 +277,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/ANTLRv3.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 07:07:33.787469352 +0200 ++++ tool/src/main/java/ANTLRv3.tokens 2023-09-16 07:24:37.636877965 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -408,7 +408,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/ANTLRv3Tree.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 07:07:34.994111877 +0200 ++++ tool/src/main/java/ANTLRv3Tree.tokens 2023-09-16 07:24:38.943518349 +0200 @@ -0,0 +1,128 @@ +T__67=67 +T__68=68 @@ -539,7 +539,7 @@ +'}'=92 +'~'=93 --- tool/src/main/java/AssignTokenTypesWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 07:07:34.787449346 +0200 ++++ tool/src/main/java/AssignTokenTypesWalker.tokens 2023-09-16 07:24:38.693523378 +0200 @@ -0,0 +1,115 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -657,7 +657,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/CodeGenTreeWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 07:07:34.480788814 +0200 ++++ tool/src/main/java/CodeGenTreeWalker.tokens 2023-09-16 07:24:38.350196951 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -774,7 +774,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/DefineGrammarItemsWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 07:07:34.704117679 +0200 ++++ tool/src/main/java/DefineGrammarItemsWalker.tokens 2023-09-16 07:24:38.596858656 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -891,7 +891,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/LeftRecursiveRuleWalker.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 07:07:34.587453347 +0200 ++++ tool/src/main/java/LeftRecursiveRuleWalker.tokens 2023-09-16 07:24:38.470194537 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 @@ -1008,7 +1008,7 @@ +'throws'=92 +'tree'=95 --- tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 07:07:33.484142088 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionAnalysis.java 2023-09-16 07:24:37.353550331 +0200 @@ -0,0 +1,442 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionAnalysis.g 2023-09-15 00:00:00 + @@ -1453,7 +1453,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 07:07:34.314125482 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ActionTranslator.java 2023-09-16 07:24:38.166867305 +0200 @@ -0,0 +1,3600 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ActionTranslator.g 2023-09-15 00:00:00 + @@ -5056,7 +5056,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 07:07:33.220814023 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRLexer.java 2023-09-16 07:24:37.100222094 +0200 @@ -0,0 +1,3520 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -8579,7 +8579,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 07:07:32.744156892 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRParser.java 2023-09-16 07:24:36.616898482 +0200 @@ -0,0 +1,10551 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLR.g 2023-09-15 00:00:00 + @@ -9264,7 +9264,7 @@ + // AST REWRITE + // elements: a, cmt, gid, gr, ig, optionsSpec, r, scopes, ts + // token labels: cmt -+ // rule labels: a, r, gid, gr, scopes, ig, retval, ts ++ // rule labels: a, r, gid, scopes, gr, ig, retval, ts + // token list labels: + // rule list labels: + // wildcard labels: @@ -9274,8 +9274,8 @@ + RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.getTree():null); + RewriteRuleSubtreeStream stream_r=new RewriteRuleSubtreeStream(adaptor,"rule r",r!=null?r.getTree():null); + RewriteRuleSubtreeStream stream_gid=new RewriteRuleSubtreeStream(adaptor,"rule gid",gid!=null?gid.getTree():null); -+ RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); + RewriteRuleSubtreeStream stream_scopes=new RewriteRuleSubtreeStream(adaptor,"rule scopes",scopes!=null?scopes.getTree():null); ++ RewriteRuleSubtreeStream stream_gr=new RewriteRuleSubtreeStream(adaptor,"rule gr",gr!=null?gr.getTree():null); + RewriteRuleSubtreeStream stream_ig=new RewriteRuleSubtreeStream(adaptor,"rule ig",ig!=null?ig.getTree():null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); + RewriteRuleSubtreeStream stream_ts=new RewriteRuleSubtreeStream(adaptor,"rule ts",ts!=null?ts.getTree():null); @@ -19133,7 +19133,7 @@ + public static final BitSet FOLLOW_ruleref_in_synpred1_ANTLR1936 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 07:07:33.404143688 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRTreePrinter.java 2023-09-16 07:24:37.273551941 +0200 @@ -0,0 +1,3622 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRTreePrinter.g 2023-09-15 00:00:00 + @@ -22758,7 +22758,7 @@ + public static final BitSet FOLLOW_BANG_in_ast_suffix1807 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 07:07:34.207460949 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Lexer.java 2023-09-16 07:24:38.060202784 +0200 @@ -0,0 +1,3357 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -26118,7 +26118,7 @@ + +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 07:07:33.784136086 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Parser.java 2023-09-16 07:24:37.633544699 +0200 @@ -0,0 +1,9847 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3.g 2023-09-15 00:00:00 + @@ -35968,7 +35968,7 @@ + public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32659 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 07:07:34.994111877 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/ANTLRv3Tree.java 2023-09-16 07:24:38.943518349 +0200 @@ -0,0 +1,3771 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/ANTLRv3Tree.g 2023-09-15 00:00:00 + @@ -39742,7 +39742,7 @@ + public static final BitSet FOLLOW_ID_in_qid1436 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L}); +} --- tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 07:07:34.787449346 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/AssignTokenTypesWalker.java 2023-09-16 07:24:38.693523378 +0200 @@ -0,0 +1,2936 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/AssignTokenTypesWalker.g 2023-09-15 00:00:00 + @@ -42681,7 +42681,7 @@ + public static final BitSet FOLLOW_atom_in_atom1152 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 07:07:34.477455548 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/CodeGenTreeWalker.java 2023-09-16 07:24:38.350196951 +0200 @@ -0,0 +1,5305 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/CodeGenTreeWalker.g 2023-09-15 00:00:00 + @@ -47989,7 +47989,7 @@ + public static final BitSet FOLLOW_element_action_in_synpred2_CodeGenTreeWalker1405 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 07:07:34.700784413 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/DefineGrammarItemsWalker.java 2023-09-16 07:24:38.596858656 +0200 @@ -0,0 +1,4468 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/DefineGrammarItemsWalker.g 2023-09-15 00:00:00 + @@ -52460,7 +52460,7 @@ + public static final BitSet FOLLOW_dotLoop_in_synpred1_DefineGrammarItemsWalker1222 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 07:07:34.587453347 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/LeftRecursiveRuleWalker.java 2023-09-16 07:24:38.466861270 +0200 @@ -0,0 +1,3240 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/LeftRecursiveRuleWalker.g 2023-09-15 00:00:00 + @@ -55703,7 +55703,7 @@ + public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L}); +} --- tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 07:07:34.904113678 +0200 ++++ tool/src/main/java/org/antlr/grammar/v3/TreeToNFAConverter.java 2023-09-16 07:24:38.846853627 +0200 @@ -0,0 +1,4395 @@ +// $ANTLR 3.5.3 org/antlr/grammar/v3/TreeToNFAConverter.g 2023-09-15 00:00:00 + @@ -60101,7 +60101,7 @@ + public static final BitSet FOLLOW_testSetElement_in_testSetElement2000 = new BitSet(new long[]{0x0000000000000008L}); +} --- tool/src/main/java/TreeToNFAConverter.tokens 1970-01-01 01:00:00.000000000 +0100 -+++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 07:07:34.907446945 +0200 ++++ tool/src/main/java/TreeToNFAConverter.tokens 2023-09-16 07:24:38.846853627 +0200 @@ -0,0 +1,114 @@ +ACTION=4 +ACTION_CHAR_LITERAL=5 From 36587bb7b0d513c3bcf591e7f3ad4e6d5e7aac7ea375aee8613fde7c1e1be411 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Tue, 19 Sep 2023 17:07:35 +0000 Subject: [PATCH 15/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=38 --- antlr3.changes | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/antlr3.changes b/antlr3.changes index 48b92f0..6e16107 100644 --- a/antlr3.changes +++ b/antlr3.changes @@ -8,7 +8,8 @@ Fri Sep 15 16:02:58 UTC 2023 - Fridrich Strba + support SOURCE_DATE_EPOCH for generatedTimestamp - Modified patch: * antlr3-generated_sources.patch - + regenerate to correspong to the reproducible-order.patch + + regenerate in cycle with stringtemplate4 to correspond to + the reproducible build changes ------------------------------------------------------------------- Fri Sep 15 08:19:19 UTC 2023 - Bernhard Wiedemann From 1f213e56e3fa6828e629e83fa219f6dc519ed00532f894e82597918ccdb68f3d Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Wed, 20 Sep 2023 08:59:49 +0000 Subject: [PATCH 16/16] OBS-URL: https://build.opensuse.org/package/show/Java:packages/antlr3?expand=0&rev=39 --- antlr3.spec | 1 + 1 file changed, 1 insertion(+) diff --git a/antlr3.spec b/antlr3.spec index 66be845..f2576da 100644 --- a/antlr3.spec +++ b/antlr3.spec @@ -186,6 +186,7 @@ sed -i 's/jsr14/1.8/' antlr3-maven-archetype/src/main/resources/archetype-resour %if %{?pkg_vcmp:%pkg_vcmp java-devel >= 9}%{!?pkg_vcmp:0} -Dmaven.compiler.release=8 \ %endif + -Dproject.build.outputTimestamp=$(date -u -d @${SOURCE_DATE_EPOCH:-$(date +%%s)} +%%Y-%%m-%%dT%%H:%%M:%%SZ) \ -Dsource=8 %if %{without runtime} && %{without bootstrap}