From 0948320c34fbeee923addf013386793e42c389ec Mon Sep 17 00:00:00 2001 From: Thomas Walker Lynch Date: Fri, 6 Sep 2024 15:17:17 +0000 Subject: [PATCH] all executables use same form argument/options parsing, removes regex passed Tokens -> categories, 'Generate' -> 'Synthesize' --- developer/ANTLR/Arithmetic2.g4 | 24 + developer/executor/env_build | 16 +- developer/executor/makefile-project.mk | 69 +- developer/javac/ANTLR_OUT_FL.java | 53 +- .../javac/Arithmetic2_SyntaxAnnotate.java | 81 +++ ...ithmetic2_SyntaxAnnotate_PrintVisitor.java | 663 ++++++++++++++++++ developer/javac/Arithmetic_Echo.java | 30 +- developer/javac/Arithmetic_Echo__Test.java | 38 +- ...ax.java => Arithmetic_SyntaxAnnotate.java} | 50 +- ...ithmetic_SyntaxAnnotate_PrintVisitor.java} | 4 +- .../Arithmetic_SyntaxAnnotate__Test.java | 125 ++++ developer/javac/Arithmetic_Syntax__Test.java | 104 --- developer/javac/RuleNameList.java | 66 +- developer/javac/RuleNameListRegx.java | 47 +- .../javac/Synthesize_SyntaxAnnotate.java | 166 +++++ ...nthesize_SyntaxAnnotate_PrintVisitor.java} | 57 +- ...ize_SyntaxAnnotate_PrintVisitorMethod.java | 90 +++ .../javac/Synthhesize_PrintVisitorMethod.java | 82 --- developer/javac/TerminalToCategory.java | 141 ---- ... => Arithmetic_SyntaxAnnotate__Test_0.txt} | 0 ... => Arithmetic_SyntaxAnnotate__Test_1.txt} | 0 ... => Arithmetic_SyntaxAnnotate__Test_2.txt} | 0 ... => Arithmetic_SyntaxAnnotate__Test_3.txt} | 0 ... => Arithmetic_SyntaxAnnotate__Test_4.txt} | 0 developer/test/transcript_notes.txt | 4 + 25 files changed, 1420 insertions(+), 490 deletions(-) create mode 100644 developer/ANTLR/Arithmetic2.g4 create mode 100644 developer/javac/Arithmetic2_SyntaxAnnotate.java create mode 100644 developer/javac/Arithmetic2_SyntaxAnnotate_PrintVisitor.java rename developer/javac/{Arithmetic_Syntax.java => Arithmetic_SyntaxAnnotate.java} (65%) rename developer/javac/{Arithmetic_Syntax_PrintVisitor.java => Arithmetic_SyntaxAnnotate_PrintVisitor.java} (92%) create mode 100644 developer/javac/Arithmetic_SyntaxAnnotate__Test.java delete mode 100644 developer/javac/Arithmetic_Syntax__Test.java create mode 100644 developer/javac/Synthesize_SyntaxAnnotate.java rename developer/javac/{Synthesize_PrintVisitor.java => Synthesize_SyntaxAnnotate_PrintVisitor.java} (58%) create mode 100644 developer/javac/Synthesize_SyntaxAnnotate_PrintVisitorMethod.java delete mode 100644 developer/javac/Synthhesize_PrintVisitorMethod.java delete mode 100644 developer/javac/TerminalToCategory.java rename developer/test/{Arithmetic_Syntax__Test_0.txt => Arithmetic_SyntaxAnnotate__Test_0.txt} (100%) rename developer/test/{Arithmetic_Syntax__Test_1.txt => Arithmetic_SyntaxAnnotate__Test_1.txt} (100%) rename developer/test/{Arithmetic_Syntax__Test_2.txt => Arithmetic_SyntaxAnnotate__Test_2.txt} (100%) rename developer/test/{Arithmetic_Syntax__Test_3.txt => Arithmetic_SyntaxAnnotate__Test_3.txt} (100%) rename developer/test/{Arithmetic_Syntax__Test_4.txt => Arithmetic_SyntaxAnnotate__Test_4.txt} (100%) create mode 100644 developer/test/transcript_notes.txt diff --git a/developer/ANTLR/Arithmetic2.g4 b/developer/ANTLR/Arithmetic2.g4 new file mode 100644 index 0000000..88fea64 --- /dev/null +++ b/developer/ANTLR/Arithmetic2.g4 @@ -0,0 +1,24 @@ +grammar Arithmetic2; + +program: statement+ EOF; + +statement + : expression + | variable '=' expression + ; + +expression + : expression ('*'|'/') expression + | expression ('+'|'-') expression + | '(' expression ')' + | variable + | INT + ; + +variable: VARIABLE; + +INT: [0-9]+; + +VARIABLE: [a-zA-Z]+; + +WS: [ \t\r\n]+ -> skip; diff --git a/developer/executor/env_build b/developer/executor/env_build index 67adb33..d4852b8 100755 --- a/developer/executor/env_build +++ b/developer/executor/env_build @@ -44,16 +44,17 @@ fi export EXECUTOR_IN_FL="\ RuleNameListRegx\ RuleNameList\ - GeneratePrintVisitorMethod\ - GeneratePrintVisitor\ + Synthesize_SyntaxAnnotate_PrintVisitorMethod\ + Synthesize_SyntaxAnnotate_PrintVisitor\ + Synthesize_SyntaxAnnotate\ ANTLRv4_RuleNameList\ Arithmetic_Echo\ Arithmetic_Echo__Test\ - Arithmetic_Syntax\ - Arithmetic_Syntax__Test\ - ANTLRv4_Syntax\ - GQL_20240412_Syntax\ - GQL_20240412_Syntax__Test\ + Arithmetic_SyntaxAnnotate\ + Arithmetic_SyntaxAnnotate__Test\ + Arithmetic2_SyntaxAnnotate\ + Arithmetic2_SyntaxAnnotate__Test\ + ANTLRv4_SyntaxAnnotate\ " # where make will put the programs @@ -147,3 +148,4 @@ export JAR_OUT_FPL # LocalWords: ANTLRv PrintRuleNameListRegx RuleNameListRegx RuleNameList +# LocalWords: PrintVisitorMethod PrintVisitor SyntaxAnnotate diff --git a/developer/executor/makefile-project.mk b/developer/executor/makefile-project.mk index eba37ce..277884e 100644 --- a/developer/executor/makefile-project.mk +++ b/developer/executor/makefile-project.mk @@ -37,14 +37,17 @@ all: $(EXECUTOR_IN_FPL) RuleNameListRegx: $(EXECUTOR_IN_DIR)/RuleNameListRegx RuleNameList: $(EXECUTOR_IN_DIR)/RuleNameList -GeneratePrintVisitorMethod:\ +Synthesize_SyntaxAnnotate_PrintVisitorMethod:\ $(JAVA_COMP_IN_PRIMARY_DIR)/StringUtils.java\ - $(EXECUTOR_IN_DIR)/GeneratePrintVisitorMethod -GeneratePrintVisitor:\ + $(EXECUTOR_IN_DIR)/Synthesize_SyntaxAnnotate_PrintVisitorMethod +Synthesize_SyntaxAnnotate_PrintVisitor:\ $(JAVA_COMP_IN_PRIMARY_DIR)/StringUtils.java\ - $(EXECUTOR_IN_DIR)/GeneratePrintVisitor GeneratePrintVisitorMethod - + $(JAVA_COMP_IN_PRIMARY_DIR)/Synthesize_SyntaxAnnotate_PrintVisitorMethod.java\ + $(EXECUTOR_IN_DIR)/Synthesize_SyntaxAnnotate_PrintVisitor +Synthesize_SyntaxAnnotate:\ + $(JAVA_COMP_IN_PRIMARY_DIR)/StringUtils.java\ + $(EXECUTOR_IN_DIR)/Synthesize_SyntaxAnnotate #----------------------------------------------- # Arithmetic @@ -69,61 +72,83 @@ Arithmetic_Echo__Test:\ fi $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic_Echo__Test -Arithmetic_Syntax:\ +Arithmetic_SyntaxAnnotate:\ $(ANTLR_OUT_Arithmetic_FPL)\ - $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic_Syntax_PrintVisitor.java + $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic_SyntaxAnnotate_PrintVisitor.java @if [ -z "$(ANTLR_OUT_Arithmetic_FPL)" ]; then \ echo "variable ANTLR_OUT_Arithmetic_FPL empty."; \ exit 1; \ fi - $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic_Syntax + $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic_SyntaxAnnotate -Arithmetic_Syntax__Test:\ +Arithmetic_SyntaxAnnotate__Test:\ $(ANTLR_OUT_Arithmetic_FPL)\ - $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic_Syntax_PrintVisitor.java + $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic_SyntaxAnnotate_PrintVisitor.java @if [ -z "$(ANTLR_OUT_Arithmetic_FPL)" ]; then \ echo "variable ANTLR_OUT_Arithmetic_FPL empty."; \ exit 1; \ fi - $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic_Syntax__Test + $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic_SyntaxAnnotate__Test + +#----------------------------------------------- +# Arithmetic2 +# + +ANTLR_OUT_Arithmetic2_FPL:= $(shell ANTLR_OUT_FL Arithmetic2 -path $(ANTLR_OUT_DIR)) +Arithmetic2_SyntaxAnnotate:\ + $(ANTLR_OUT_Arithmetic2_FPL)\ + $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic2_SyntaxAnnotate_PrintVisitor.java + @if [ -z "$(ANTLR_OUT_Arithmetic2_FPL)" ]; then \ + echo "variable ANTLR_OUT_Arithmetic2_FPL empty."; \ + exit 1; \ + fi + $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic2_SyntaxAnnotate +Arithmetic2_SyntaxAnnotate__Test:\ + $(ANTLR_OUT_Arithmetic2_FPL)\ + $(JAVA_COMP_IN_PRIMARY_DIR)/Arithmetic2_SyntaxAnnotate_PrintVisitor.java + @if [ -z "$(ANTLR_OUT_Arithmetic2_FPL)" ]; then \ + echo "variable ANTLR_OUT_Arithmetic2_FPL empty."; \ + exit 1; \ + fi + $(REMAKE) $(EXECUTOR_IN_DIR)/Arithmetic2_SyntaxAnnotate__Test #----------------------------------------------- # Parsing/Analyzing ANTLR grammars # ANTLR_OUT_ANTLRv4_FPL:= $(shell ANTLR_OUT_FL ANTLRv4 -path $(ANTLR_OUT_DIR)) -ANTLRv4_Syntax:\ +ANTLRv4_SyntaxAnnotate:\ $(ANTLR_OUT_ANTLRv4_FPL)\ - $(JAVA_COMP_IN_PRIMARY_DIR)/ANTLRv4_Syntax_PrintVisitor.java + $(JAVA_COMP_IN_PRIMARY_DIR)/ANTLRv4_SyntaxAnnotate_PrintVisitor.java @if [ -z "$(ANTLR_OUT_ANTLRv4_FPL)" ]; then \ echo "variable ANTLR_OUT_ANTLRv4_FPL empty."; \ exit 1; \ fi - $(REMAKE) $(EXECUTOR_IN_DIR)/ANTLRv4_Syntax + $(REMAKE) $(EXECUTOR_IN_DIR)/ANTLRv4_SyntaxAnnotate #----------------------------------------------- # GQL_20240412 ANTLR_OUT_GQL_20240412_FPL := $(shell ANTLR_OUT_FL GQL_20240412 -path $(ANTLR_OUT_DIR)) -GQL_20240412_Syntax:\ +GQL_20240412_SyntaxAnnotate:\ $(ANTLR_OUT_GQL_20240412_FPL)\ - $(JAVA_COMP_IN_PRIMARY_DIR)/GQL_20240412_Syntax_PrintVisitor.java + $(JAVA_COMP_IN_PRIMARY_DIR)/GQL_20240412_SyntaxAnnotate_PrintVisitor.java @if [ -z "$(ANTLR_OUT_GQL_20240412_FPL)" ]; then \ echo "variable ANTLR_OUT_GQL_20240412_FPL empty."; \ exit 1; \ fi - $(REMAKE) $(EXECUTOR_IN_DIR)/GQL_20240412_Syntax + $(REMAKE) $(EXECUTOR_IN_DIR)/GQL_20240412_SyntaxAnnotate -GQL_20240412_Syntax__Test: \ +GQL_20240412_SyntaxAnnotate__Test: \ $(ANTLR_OUT_GQL_20240412_FPL) \ - $(JAVA_COMP_IN_PRIMARY_DIR)/GQL_20240412_Syntax_PrintVisitor.java + $(JAVA_COMP_IN_PRIMARY_DIR)/GQL_20240412_SyntaxAnnotate_PrintVisitor.java @if [ -z "$(ANTLR_OUT_GQL_20240412_FPL)" ]; then \ echo "variable ANTLR_OUT_GQL_20240412_FPL empty."; \ exit 1; \ fi - $(REMAKE) $(EXECUTOR_IN_DIR)/GQL_20240412_Syntax__Test + $(REMAKE) $(EXECUTOR_IN_DIR)/GQL_20240412_SyntaxAnnotate__Test TerminalToCategory: @@ -207,8 +232,8 @@ $(JAVA_COMP_OUT_DIR)/%.jar: $(JAVA_COMP_OUT_DIR)/%.class #-------------------- $(EXECUTOR_IN_DIR)/%: $(JVM_IN_DIR)/%.jar - @echo "Creating script for $*..." + @echo "Creating program for $*..." @echo "#!/usr/bin/env bash" > $(EXECUTOR_IN_DIR)/$* @echo "$(JAVA_INTERP) -cp ${CLASSPATH}:${JVM_IN_DP}:$(JVM_IN_DP)/$*.jar $*" \$$\@ >> $(EXECUTOR_IN_DIR)/$* chmod +x $(EXECUTOR_IN_DIR)/$* - @echo "Created script $(EXECUTOR_IN_DIR)/$*" + @echo "Created program $(EXECUTOR_IN_DIR)/$*" diff --git a/developer/javac/ANTLR_OUT_FL.java b/developer/javac/ANTLR_OUT_FL.java index 9d1502f..365212f 100644 --- a/developer/javac/ANTLR_OUT_FL.java +++ b/developer/javac/ANTLR_OUT_FL.java @@ -17,31 +17,33 @@ import java.util.List; public class ANTLR_OUT_FL { - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java ANTLR_OUT_FL " + - "[-visitor (default)] [-no-visitor] " + - "[-listener] [-no-listener (default)] " + - "[-tokens] [-no-tokens (default)] " + - "[-path ]"; + private static final String USAGE_MESSAGE = + "Usage: ANTLR_OUT_FL " + +" [-visitor (default)] [-no-visitor] " + +" [-listener] [-no-listener (default)] " + +" [-tokens] [-no-tokens (default)] " + +" [-path ]" + ; public static void main(String[] args) { if (args.length == 0) { System.err.println(USAGE_MESSAGE); System.exit(1); } - - // Defaults + boolean error = false; + boolean version = false; boolean visitor = true; boolean noListener = true; boolean noTokens = true; - String outputPath = ""; // Default empty path + String outputPath = ""; List argList = new ArrayList<>(); - - // Parse the arguments for (int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { + case "-version": + version = true; + break; case "-visitor": visitor = true; break; @@ -68,29 +70,38 @@ public class ANTLR_OUT_FL { outputPath += "/"; // Ensure the path ends with a slash } } else { - System.err.println(USAGE_MESSAGE); - System.exit(1); + System.err.println("expected argument after option: " + args[i]); + error = true; } break; default: System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); + error = true; } } else { argList.add(arg); } } - - // Ensure there is exactly one grammar file argument + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ System.err.println(USAGE_MESSAGE); System.exit(1); } - String grammarFile = argList.get(0); + String grammarName = argList.get(0); - List generatedFiles = generateFileList(grammarFile, visitor, noListener, noTokens, outputPath); + List generatedFiles = generateFileList(grammarName, visitor, noListener, noTokens, outputPath); // Print the files in a space-separated format on a single line if (!generatedFiles.isEmpty()) { @@ -102,8 +113,8 @@ public class ANTLR_OUT_FL { System.out.println(); // Print a newline at the end } - public static List generateFileList(String grammarFile, boolean visitor, boolean noListener, boolean noTokens, String outputPath) { - String baseName = new File(grammarFile).getName().replace(".g4", ""); + public static List generateFileList(String grammarName, boolean visitor, boolean noListener, boolean noTokens, String outputPath) { + String baseName = new File(grammarName).getName().replace(".g4", ""); List fileList = new ArrayList<>(); // Determine if this is a lexer, parser, or both diff --git a/developer/javac/Arithmetic2_SyntaxAnnotate.java b/developer/javac/Arithmetic2_SyntaxAnnotate.java new file mode 100644 index 0000000..c4577ca --- /dev/null +++ b/developer/javac/Arithmetic2_SyntaxAnnotate.java @@ -0,0 +1,81 @@ +/* This file generated by Synthesize_SyntaxAnnotate given the grammar + name: Arithmetic2. + + SyntaxAnnotate programs accept a source file, then echo the source file with + syntax annotation. Synthesize_SyntaxAnnotate produces a SyntaxAnnotate program + for a specific grammar. + */ +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.tree.*; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; + +public class Arithmetic2_SyntaxAnnotate { + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: Arithmetic2_SyntaxAnnotate [-version] [-pp] "; + + public static void main(String[] args) throws IOException { + if (args.length == 0) { + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + boolean error = false; + boolean version = false; + boolean pretty_print = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; + if (arg.startsWith("-")) { + switch (arg) { + case "-version": + version = true; + break; + case "-pp": + pretty_print = true; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; + } + } else { + argList.add(arg); + } + } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + String input_file = argList.get(0); + String input = Files.readString(Paths.get(input_file)); + + try { + Arithmetic2Lexer lexer = new Arithmetic2Lexer(CharStreams.fromString(input)); + CommonTokenStream tokens = new CommonTokenStream(lexer); + Arithmetic2Parser parser = new Arithmetic2Parser(tokens); + ParseTree tree = parser.program(); + + Arithmetic2_SyntaxAnnotate_PrintVisitor visitor = new Arithmetic2_SyntaxAnnotate_PrintVisitor(parser.getRuleNames(), pretty_print); + String output = visitor.visit(tree); + System.out.println(output); + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/developer/javac/Arithmetic2_SyntaxAnnotate_PrintVisitor.java b/developer/javac/Arithmetic2_SyntaxAnnotate_PrintVisitor.java new file mode 100644 index 0000000..28a4866 --- /dev/null +++ b/developer/javac/Arithmetic2_SyntaxAnnotate_PrintVisitor.java @@ -0,0 +1,663 @@ +/* This file synthesized by Synthesize_SyntaxAnnotate_PrintVisitor. +*/ +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +public class Arithmetic2_SyntaxAnnotate_PrintVisitor extends AbstractParseTreeVisitor { + private final String[] ruleNames; + + public Arithmetic2_SyntaxAnnotate_PrintVisitor(String[] ruleNames) { + this.ruleNames = ruleNames; + } + + public String visitgrammarSpec (Arithmetic2Parser.grammarSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("grammarSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitgrammarDecl (Arithmetic2Parser.grammarDeclContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("grammarDecl("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitgrammarType (Arithmetic2Parser.grammarTypeContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("grammarType("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitprequelConstruct (Arithmetic2Parser.prequelConstructContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("prequelConstruct("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitoptionsSpec (Arithmetic2Parser.optionsSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("optionsSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitoption (Arithmetic2Parser.optionContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("option("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitoptionValue (Arithmetic2Parser.optionValueContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("optionValue("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitdelegateGrammars (Arithmetic2Parser.delegateGrammarsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("delegateGrammars("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitdelegateGrammar (Arithmetic2Parser.delegateGrammarContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("delegateGrammar("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visittokensSpec (Arithmetic2Parser.tokensSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("tokensSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitchannelsSpec (Arithmetic2Parser.channelsSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("channelsSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitidList (Arithmetic2Parser.idListContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("idList("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitaction_ (Arithmetic2Parser.action_Context ctx) { + StringBuilder result = new StringBuilder(); + result.append("action_("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitactionScopeName (Arithmetic2Parser.actionScopeNameContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("actionScopeName("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitactionBlock (Arithmetic2Parser.actionBlockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("actionBlock("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitargActionBlock (Arithmetic2Parser.argActionBlockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("argActionBlock("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitmodeSpec (Arithmetic2Parser.modeSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("modeSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitrules (Arithmetic2Parser.rulesContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("rules("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleSpec (Arithmetic2Parser.ruleSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitparserRuleSpec (Arithmetic2Parser.parserRuleSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("parserRuleSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitexceptionGroup (Arithmetic2Parser.exceptionGroupContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("exceptionGroup("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitexceptionHandler (Arithmetic2Parser.exceptionHandlerContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("exceptionHandler("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitfinallyClause (Arithmetic2Parser.finallyClauseContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("finallyClause("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitrulePrequel (Arithmetic2Parser.rulePrequelContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("rulePrequel("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleReturns (Arithmetic2Parser.ruleReturnsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleReturns("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitthrowsSpec (Arithmetic2Parser.throwsSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("throwsSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlocalsSpec (Arithmetic2Parser.localsSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("localsSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleAction (Arithmetic2Parser.ruleActionContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleAction("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleModifiers (Arithmetic2Parser.ruleModifiersContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleModifiers("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleModifier (Arithmetic2Parser.ruleModifierContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleModifier("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleBlock (Arithmetic2Parser.ruleBlockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleBlock("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleAltList (Arithmetic2Parser.ruleAltListContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleAltList("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlabeledAlt (Arithmetic2Parser.labeledAltContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("labeledAlt("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerRuleSpec (Arithmetic2Parser.lexerRuleSpecContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerRuleSpec("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerRuleBlock (Arithmetic2Parser.lexerRuleBlockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerRuleBlock("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerAltList (Arithmetic2Parser.lexerAltListContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerAltList("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerAlt (Arithmetic2Parser.lexerAltContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerAlt("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerElements (Arithmetic2Parser.lexerElementsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerElements("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerElement (Arithmetic2Parser.lexerElementContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerElement("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerBlock (Arithmetic2Parser.lexerBlockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerBlock("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerCommands (Arithmetic2Parser.lexerCommandsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerCommands("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerCommand (Arithmetic2Parser.lexerCommandContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerCommand("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerCommandName (Arithmetic2Parser.lexerCommandNameContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerCommandName("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerCommandExpr (Arithmetic2Parser.lexerCommandExprContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerCommandExpr("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitaltList (Arithmetic2Parser.altListContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("altList("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitalternative (Arithmetic2Parser.alternativeContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("alternative("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitelement (Arithmetic2Parser.elementContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("element("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitpredicateOptions (Arithmetic2Parser.predicateOptionsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("predicateOptions("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitpredicateOption (Arithmetic2Parser.predicateOptionContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("predicateOption("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlabeledElement (Arithmetic2Parser.labeledElementContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("labeledElement("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitebnf (Arithmetic2Parser.ebnfContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ebnf("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitblockSuffix (Arithmetic2Parser.blockSuffixContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("blockSuffix("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitebnfSuffix (Arithmetic2Parser.ebnfSuffixContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ebnfSuffix("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitlexerAtom (Arithmetic2Parser.lexerAtomContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("lexerAtom("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitatom (Arithmetic2Parser.atomContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("atom("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitnotSet (Arithmetic2Parser.notSetContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("notSet("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitblockSet (Arithmetic2Parser.blockSetContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("blockSet("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitsetElement (Arithmetic2Parser.setElementContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("setElement("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitblock (Arithmetic2Parser.blockContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("block("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitruleref (Arithmetic2Parser.rulerefContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("ruleref("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitcharacterRange (Arithmetic2Parser.characterRangeContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("characterRange("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitterminalDef (Arithmetic2Parser.terminalDefContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("terminalDef("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitelementOptions (Arithmetic2Parser.elementOptionsContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("elementOptions("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitelementOption (Arithmetic2Parser.elementOptionContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("elementOption("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + public String visitidentifier (Arithmetic2Parser.identifierContext ctx) { + StringBuilder result = new StringBuilder(); + result.append("identifier("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + +} diff --git a/developer/javac/Arithmetic_Echo.java b/developer/javac/Arithmetic_Echo.java index 0bb6034..8fadf28 100644 --- a/developer/javac/Arithmetic_Echo.java +++ b/developer/javac/Arithmetic_Echo.java @@ -13,39 +13,45 @@ import java.util.List; public class Arithmetic_Echo { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java Arithmetic_Echo " + - "[-version]"; + private static final String USAGE_MESSAGE = + "Usage: Arithmetic_Echo [-version] "; public static void main(String[] args) throws IOException { if (args.length == 0) { System.err.println(USAGE_MESSAGE); System.exit(1); } - - // Defaults + boolean error = false; + boolean version = false; List argList = new ArrayList<>(); - - // Parse the arguments for (int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { case "-version": - System.out.println("Version 0.1"); - System.exit(0); + version = true; break; default: System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); + error = true; } } else { argList.add(arg); } } - - // Ensure there is exactly one input file argument + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ System.err.println(USAGE_MESSAGE); System.exit(1); } diff --git a/developer/javac/Arithmetic_Echo__Test.java b/developer/javac/Arithmetic_Echo__Test.java index 5275d46..8e670b1 100644 --- a/developer/javac/Arithmetic_Echo__Test.java +++ b/developer/javac/Arithmetic_Echo__Test.java @@ -3,33 +3,53 @@ import org.antlr.v4.runtime.tree.*; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; +import java.util.ArrayList; +import java.util.List; public class Arithmetic_Echo__Test { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: Arithmetic_Echo__Test " + - "[-version]"; + private static final String USAGE_MESSAGE = + "Usage: Arithmetic_Echo__Test [-version]"; public static void main(String[] args) { // if (args.length == 0) { // System.err.println(USAGE_MESSAGE); // System.exit(1); // } - - // Parse the arguments - for (String arg : args) { + boolean error = false; + boolean version = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { case "-version": - System.out.println("Version 0.1"); - System.exit(0); + version = true; break; default: System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); + error = true; } + } else { + argList.add(arg); } } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 0) { + System.err.println("This program takes no arguments."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } Map tests = new HashMap<>(); tests.put("Arithmetic_Echo_0", Arithmetic_Echo_0()); diff --git a/developer/javac/Arithmetic_Syntax.java b/developer/javac/Arithmetic_SyntaxAnnotate.java similarity index 65% rename from developer/javac/Arithmetic_Syntax.java rename to developer/javac/Arithmetic_SyntaxAnnotate.java index a3c85b7..0516db6 100644 --- a/developer/javac/Arithmetic_Syntax.java +++ b/developer/javac/Arithmetic_SyntaxAnnotate.java @@ -12,55 +12,56 @@ import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; -public class Arithmetic_Syntax { +public class Arithmetic_SyntaxAnnotate { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: Arithmetic_Syntax [-pp] " + - "[-version]"; + private static final String USAGE_MESSAGE = + "Usage: Arithmetic_SyntaxAnnotate [-version] [-pp] "; public static void main(String[] args) throws IOException { if (args.length == 0) { System.err.println(USAGE_MESSAGE); System.exit(1); } - + boolean error = false; + boolean version = false; boolean pretty_print = false; - List file_arg_list = new ArrayList<>(); - boolean has_error = false; - - // Parse the options and arguments + List argList = new ArrayList<>(); for (int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { + case "-version": + version = true; + break; case "-pp": pretty_print = true; break; - case "-version": - System.out.println("Version 0.1"); - System.exit(0); - break; default: System.err.println("Unrecognized option: " + arg); - has_error = true; + error = true; } } else { - file_arg_list.add(arg); + argList.add(arg); } } - - // If there were any errors, print usage and exit - if (has_error) { - System.err.println(USAGE_MESSAGE); - System.exit(1); + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } } - - // Ensure there is exactly one input file - if (file_arg_list.size() != 1) { + if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ System.err.println(USAGE_MESSAGE); System.exit(1); } - String input_file = file_arg_list.get(0); + String input_file = argList.get(0); String input = Files.readString(Paths.get(input_file)); try { @@ -69,7 +70,8 @@ public class Arithmetic_Syntax { ArithmeticParser parser = new ArithmeticParser(tokens); ParseTree tree = parser.program(); - Arithmetic_Syntax_PrintVisitor visitor = new Arithmetic_Syntax_PrintVisitor(parser.getRuleNames(), pretty_print); + Arithmetic_SyntaxAnnotate_PrintVisitor visitor = + new Arithmetic_SyntaxAnnotate_PrintVisitor(parser.getRuleNames(), pretty_print); String output = visitor.visit(tree); System.out.println(output); } catch (Exception e) { diff --git a/developer/javac/Arithmetic_Syntax_PrintVisitor.java b/developer/javac/Arithmetic_SyntaxAnnotate_PrintVisitor.java similarity index 92% rename from developer/javac/Arithmetic_Syntax_PrintVisitor.java rename to developer/javac/Arithmetic_SyntaxAnnotate_PrintVisitor.java index 96f0b2b..9831e54 100644 --- a/developer/javac/Arithmetic_Syntax_PrintVisitor.java +++ b/developer/javac/Arithmetic_SyntaxAnnotate_PrintVisitor.java @@ -1,10 +1,10 @@ import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; -public class Arithmetic_Syntax_PrintVisitor extends ArithmeticBaseVisitor{ +public class Arithmetic_SyntaxAnnotate_PrintVisitor extends ArithmeticBaseVisitor{ private final String[] rule_names; private final boolean pretty_print; - public Arithmetic_Syntax_PrintVisitor(String[] rule_names, boolean pretty_print){ + public Arithmetic_SyntaxAnnotate_PrintVisitor(String[] rule_names, boolean pretty_print){ this.rule_names = rule_names; this.pretty_print = pretty_print; } diff --git a/developer/javac/Arithmetic_SyntaxAnnotate__Test.java b/developer/javac/Arithmetic_SyntaxAnnotate__Test.java new file mode 100644 index 0000000..a80b690 --- /dev/null +++ b/developer/javac/Arithmetic_SyntaxAnnotate__Test.java @@ -0,0 +1,125 @@ + +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.tree.*; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.ArrayList; +import java.util.List; + +public class Arithmetic_SyntaxAnnotate__Test { + + public static boolean Arithmetic_SyntaxAnnotate_0() { + return runTest( + "Arithmetic_SyntaxAnnotate__Test_0.txt" + ,"program(expression(INT(3) operator(+) INT(5)))" + ); + } + + public static boolean Arithmetic_SyntaxAnnotate_1() { + return runTest( + "Arithmetic_SyntaxAnnotate__Test_1.txt" + ,"program(expression(INT(3) operator(+) INT(5)))" + ); + } + + public static boolean Arithmetic_SyntaxAnnotate_2() { + return runTest( + "Arithmetic_SyntaxAnnotate__Test_2.txt" + ,"program(expression(INT(2) operator(*) (expression(INT(3) operator(+) INT(4)))))" + ); + } + + public static boolean Arithmetic_SyntaxAnnotate_3() { + return runTest( + "Arithmetic_SyntaxAnnotate__Test_3.txt" + ,"program(expression(INT(10) operator(/) INT(2)))" + ); + } + + public static boolean Arithmetic_SyntaxAnnotate_4() { + return runTest( + "Arithmetic_SyntaxAnnotate__Test_4.txt" + ,"program(expression(INT(3) operator(+) expression(INT(5) operator(*) (expression(INT(10) operator(-) INT(4))))))" + ); + } + + private static boolean runTest(String filename ,String expectedOutput) { + try { + String input = Files.readString(Paths.get(filename)); + String actualOutput = runSyntaxAnnotate(input); + return expectedOutput.equals(actualOutput); + } catch (Exception e) { + e.printStackTrace(); + return false; + } + } + + private static String runSyntaxAnnotate(String input) throws Exception { + Lexer lexer = new ArithmeticLexer(CharStreams.fromString(input)); + CommonTokenStream tokens = new CommonTokenStream(lexer); + ArithmeticParser parser = new ArithmeticParser(tokens); + ParseTree tree = parser.program(); // Directly calling the start rule method + + Arithmetic_SyntaxAnnotate_PrintVisitor visitor = new Arithmetic_SyntaxAnnotate_PrintVisitor(parser.getRuleNames() ,false); + return visitor.visit(tree); + } + + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: Arithmetic_SyntaxAnnotate__Test [-version]"; + + public static void main(String[] args) { + // if (args.length == 0) { + // System.err.println(USAGE_MESSAGE); + // System.exit(1); + // } + boolean error = false; + boolean version = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; + if (arg.startsWith("-")) { + switch (arg) { + case "-version": + version = true; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; + } + } else { + argList.add(arg); + } + } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 0) { + System.err.println("This program takes no arguments."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + // Use LinkedHashMap to maintain order of test results + Map tests = new LinkedHashMap<>(); + tests.put("Arithmetic_SyntaxAnnotate_0", Arithmetic_SyntaxAnnotate_0()); + tests.put("Arithmetic_SyntaxAnnotate_1", Arithmetic_SyntaxAnnotate_1()); + tests.put("Arithmetic_SyntaxAnnotate_2", Arithmetic_SyntaxAnnotate_2()); + tests.put("Arithmetic_SyntaxAnnotate_3", Arithmetic_SyntaxAnnotate_3()); + tests.put("Arithmetic_SyntaxAnnotate_4", Arithmetic_SyntaxAnnotate_4()); + + TestBench.runTests(tests); + } + +} + diff --git a/developer/javac/Arithmetic_Syntax__Test.java b/developer/javac/Arithmetic_Syntax__Test.java deleted file mode 100644 index 44587bd..0000000 --- a/developer/javac/Arithmetic_Syntax__Test.java +++ /dev/null @@ -1,104 +0,0 @@ - -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.tree.*; -import java.nio.file.Files; -import java.nio.file.Paths; -import java.util.LinkedHashMap; -import java.util.Map; - -public class Arithmetic_Syntax__Test { - - public static boolean Arithmetic_Syntax_0() { - return runTest( - "Arithmetic_Syntax__Test_0.txt" - ,"program(expression(INT(3) operator(+) INT(5)))" - ); - } - - public static boolean Arithmetic_Syntax_1() { - return runTest( - "Arithmetic_Syntax__Test_1.txt" - ,"program(expression(INT(3) operator(+) INT(5)))" - ); - } - - public static boolean Arithmetic_Syntax_2() { - return runTest( - "Arithmetic_Syntax__Test_2.txt" - ,"program(expression(INT(2) operator(*) (expression(INT(3) operator(+) INT(4)))))" - ); - } - - public static boolean Arithmetic_Syntax_3() { - return runTest( - "Arithmetic_Syntax__Test_3.txt" - ,"program(expression(INT(10) operator(/) INT(2)))" - ); - } - - public static boolean Arithmetic_Syntax_4() { - return runTest( - "Arithmetic_Syntax__Test_4.txt" - ,"program(expression(INT(3) operator(+) expression(INT(5) operator(*) (expression(INT(10) operator(-) INT(4))))))" - ); - } - - private static boolean runTest(String filename ,String expectedOutput) { - try { - String input = Files.readString(Paths.get(filename)); - String actualOutput = runSyntax(input); - return expectedOutput.equals(actualOutput); - } catch (Exception e) { - e.printStackTrace(); - return false; - } - } - - private static String runSyntax(String input) throws Exception { - Lexer lexer = new ArithmeticLexer(CharStreams.fromString(input)); - CommonTokenStream tokens = new CommonTokenStream(lexer); - ArithmeticParser parser = new ArithmeticParser(tokens); - ParseTree tree = parser.program(); // Directly calling the start rule method - - Arithmetic_Syntax_PrintVisitor visitor = new Arithmetic_Syntax_PrintVisitor(parser.getRuleNames() ,false); - return visitor.visit(tree); - } - - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: Arithmetic_Syntax__Test [-version]"; - - public static void main(String[] args) { - // if (args.length == 0) { - // System.err.println(USAGE_MESSAGE); - // System.exit(1); - // } - - // Parse the arguments - for (String arg : args) { - if (arg.startsWith("-")) { - switch (arg) { - case "-version": - System.out.println("Version 0.1"); - System.exit(0); - break; - default: - System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - } - } - - // Use LinkedHashMap to maintain order of test results - Map tests = new LinkedHashMap<>(); - tests.put("Arithmetic_Syntax_0", Arithmetic_Syntax_0()); - tests.put("Arithmetic_Syntax_1", Arithmetic_Syntax_1()); - tests.put("Arithmetic_Syntax_2", Arithmetic_Syntax_2()); - tests.put("Arithmetic_Syntax_3", Arithmetic_Syntax_3()); - tests.put("Arithmetic_Syntax_4", Arithmetic_Syntax_4()); - - TestBench.runTests(tests); - } - -} - diff --git a/developer/javac/RuleNameList.java b/developer/javac/RuleNameList.java index bfbf81b..c9b727c 100644 --- a/developer/javac/RuleNameList.java +++ b/developer/javac/RuleNameList.java @@ -19,55 +19,71 @@ import java.util.List; public class RuleNameList { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java RuleNameList " + - "[-rule (default)] [-no-rule] " + - "[-token] [-no-token (default)]"; + private static final String USAGE_MESSAGE = + "Usage: RuleNameList" + +" [-version]" + +" [-rule (default)] [-no-rule]" + +" [-token] [-no-token (default)]" + +" " + ; public static void main(String[] args) { if (args.length == 0) { System.err.println(USAGE_MESSAGE); System.exit(1); } - - // Defaults + boolean error = false; + boolean version = false; boolean printRules = true; boolean printTokens = false; List argList = new ArrayList<>(); - - // Parse the arguments for (int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { - case "-rule": - printRules = true; - break; - case "-no-rule": - printRules = false; - break; - case "-token": - printTokens = true; - break; - case "-no-token": - printTokens = false; - break; - default: - System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); + case "-version": + version = true; + break; + case "-rule": + printRules = true; + break; + case "-no-rule": + printRules = false; + break; + case "-token": + printTokens = true; + break; + case "-no-token": + printTokens = false; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; } } else { argList.add(arg); } } - - // Ensure there is exactly one grammar name argument + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ System.err.println(USAGE_MESSAGE); System.exit(1); } String grammarName = argList.get(0); + // in case the user provided a path instead of a name: + grammarName = Paths.get(grammarName).getFileName().toString().replace(".g4", ""); try { // Dynamically load the appropriate lexer and parser diff --git a/developer/javac/RuleNameListRegx.java b/developer/javac/RuleNameListRegx.java index 972193d..36ffb2b 100644 --- a/developer/javac/RuleNameListRegx.java +++ b/developer/javac/RuleNameListRegx.java @@ -9,48 +9,63 @@ import java.util.HashSet; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.ArrayList; +import java.util.List; public class RuleNameListRegx { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java RuleNameListRegx " + - "[-version]"; + private static final String USAGE_MESSAGE = + "Usage: RuleNameListRegx [-version] "; public static void main(String[] args) { if (args.length == 0) { System.err.println(USAGE_MESSAGE); System.exit(1); } - - String filePath = null; - - // Parse the arguments + boolean error = false; + boolean version = false; + boolean pretty_print = false; + List argList = new ArrayList<>(); for (int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-")) { switch (arg) { case "-version": - System.out.println("Version 0.1"); - System.exit(0); + version = true; + break; + case "-pp": + pretty_print = true; break; default: System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); + error = true; } } else { - filePath = arg; + argList.add(arg); } } - - // Ensure there is exactly one file path argument - if (filePath == null) { + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ System.err.println(USAGE_MESSAGE); System.exit(1); } - Set ruleNames = new HashSet<>(); + String filePath = argList.get(0); - try (BufferedReader br = new BufferedReader(new FileReader(filePath))) { + try { + Set ruleNames = new HashSet<>(); + BufferedReader br = new BufferedReader(new FileReader(filePath)); StringBuilder content = new StringBuilder(); String line; while ((line = br.readLine()) != null) { diff --git a/developer/javac/Synthesize_SyntaxAnnotate.java b/developer/javac/Synthesize_SyntaxAnnotate.java new file mode 100644 index 0000000..6f002f1 --- /dev/null +++ b/developer/javac/Synthesize_SyntaxAnnotate.java @@ -0,0 +1,166 @@ +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.tree.*; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; + +public class Synthesize_SyntaxAnnotate { + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: Synthesize_SyntaxAnnotate [-version] "; + + public static void main(String[] args) throws IOException { + if (args.length == 0) { + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + boolean error = false; + boolean version = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; + if (arg.startsWith("-")) { + switch (arg) { + case "-version": + version = true; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; + } + } else { + argList.add(arg); + } + } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 2) { + System.err.println("Expected exactly two non-option arguments."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + String grammarName = argList.get(0); + // in case the user provided a path instead of a name: + grammarName = Paths.get(grammarName).getFileName().toString().replace(".g4", ""); + + String outputFile = argList.get(1); + + synthesizeSyntaxAnnotateClass(grammarName, outputFile); + } + + private static void synthesizeSyntaxAnnotateClass(String grammarName, String outputFile) throws IOException { + String className = grammarName + "_SyntaxAnnotate"; + String lexerName = grammarName + "Lexer"; + String parserName = grammarName + "Parser"; + String visitorName = grammarName + "_SyntaxAnnotate_PrintVisitor"; + + // Template for the SyntaxAnnotate class + String classTemplate = """ + /* This file generated by Synthesize_SyntaxAnnotate given the grammar + name: ____4_. + + SyntaxAnnotate programs accept a source file, then echo the source file with + syntax annotation. Synthesize_SyntaxAnnotate produces a SyntaxAnnotate program + for a specific grammar. + */ + import org.antlr.v4.runtime.*; + import org.antlr.v4.runtime.tree.*; + import java.io.IOException; + import java.nio.file.Files; + import java.nio.file.Paths; + import java.util.ArrayList; + import java.util.List; + + public class ____0_ { + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: ____0_ [-version] [-pp] "; + + public static void main(String[] args) throws IOException { + if (args.length == 0) { + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + boolean error = false; + boolean version = false; + boolean pretty_print = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; + if (arg.startsWith("-")) { + switch (arg) { + case "-version": + version = true; + break; + case "-pp": + pretty_print = true; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; + } + } else { + argList.add(arg); + } + } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 1) { + System.err.println("Expected exactly one non-option argument."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + String input_file = argList.get(0); + String input = Files.readString(Paths.get(input_file)); + + try { + ____1_ lexer = new ____1_(CharStreams.fromString(input)); + CommonTokenStream tokens = new CommonTokenStream(lexer); + ____2_ parser = new ____2_(tokens); + ParseTree tree = parser.program(); + + ____3_ visitor = new ____3_(parser.getRuleNames(), pretty_print); + String output = visitor.visit(tree); + System.out.println(output); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + """; + + // Fill in the blanks in the template + classTemplate = classTemplate.replace("____0_", className); + classTemplate = classTemplate.replace("____1_", lexerName); + classTemplate = classTemplate.replace("____2_", parserName); + classTemplate = classTemplate.replace("____3_", visitorName); + classTemplate = classTemplate.replace("____4_", grammarName); + + // Write the synthesized class to the output file + Files.writeString(Paths.get(outputFile), classTemplate); + } +} + +// LocalWords: SyntaxAnnotate diff --git a/developer/javac/Synthesize_PrintVisitor.java b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitor.java similarity index 58% rename from developer/javac/Synthesize_PrintVisitor.java rename to developer/javac/Synthesize_SyntaxAnnotate_PrintVisitor.java index 56ec0a8..0c3bf7c 100644 --- a/developer/javac/Synthesize_PrintVisitor.java +++ b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitor.java @@ -3,13 +3,17 @@ import org.antlr.v4.runtime.tree.*; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; +import java.util.Arrays; import java.util.List; import java.io.PrintWriter; -public class Synthesize_PrintVisitor { +public class Synthesize_SyntaxAnnotate_PrintVisitor { // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java Synthesize_PrintVisitor [indentLevel] " + - "[-version]"; + private static final String USAGE_MESSAGE = + "Usage: Synthesize_SyntaxAnnotate_PrintVisitor" + +"[-version]" + +" [indentLevel]" + ; public static void main(String[] args) throws IOException { if (args.length == 0) { @@ -17,7 +21,7 @@ public class Synthesize_PrintVisitor { System.exit(1); } - String grammarFile = null; + String grammarFilePath = null; String outputFile = null; int indentLevel = 0; @@ -36,8 +40,8 @@ public class Synthesize_PrintVisitor { System.exit(1); } } else { - if (grammarFile == null) { - grammarFile = arg; + if (grammarFilePath == null) { + grammarFilePath = arg; } else if (outputFile == null) { outputFile = arg; } else { @@ -47,17 +51,18 @@ public class Synthesize_PrintVisitor { } // Ensure there are exactly two or three arguments - if (grammarFile == null || outputFile == null) { + if (grammarFilePath == null || outputFile == null) { System.err.println(USAGE_MESSAGE); System.exit(1); } // Extract the grammar name from the file name - String grammarName = Paths.get(grammarFile).getFileName().toString().replace(".g4", ""); + String grammarName = Paths.get(grammarFilePath).getFileName().toString().replace(".g4", ""); String parserName = grammarName + "Parser"; + String visitorClassName = grammarName + "_SyntaxAnnotate_PrintVisitor"; // Parse the .g4 file - CharStream input = CharStreams.fromFileName(grammarFile); + CharStream input = CharStreams.fromFileName(grammarFilePath); ANTLRv4Lexer lexer = new ANTLRv4Lexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); ANTLRv4Parser parser = new ANTLRv4Parser(tokens); @@ -66,39 +71,41 @@ public class Synthesize_PrintVisitor { ParseTree tree = parser.grammarSpec(); List ruleNames = extractRuleNames(parser); + // Synthesize the print methods + StringBuilder printMethods = new StringBuilder(); + for (String ruleName : ruleNames) { + printMethods.append(Synthesize_SyntaxAnnotate_PrintVisitorMethod.synthesizePrintMethod(parserName, ruleName, indentLevel + 1)); + } + // Template for the PrintVisitor class String classTemplate = """ + /* This file synthesized by Synthesize_SyntaxAnnotate_PrintVisitor. + */ import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; - public class PrintVisitor extends AbstractParseTreeVisitor { + public class ____0_ extends AbstractParseTreeVisitor { private final String[] ruleNames; - public PrintVisitor(String[] ruleNames) { + public ____0_(String[] ruleNames) { this.ruleNames = ruleNames; } - // Generated print methods + ____1_ + } """; - // Indent the class template - String indentedClassTemplate = StringUtils.indentString(classTemplate, indentLevel); + classTemplate = classTemplate.replace("____0_", visitorClassName); + classTemplate = classTemplate.replace("____1_", printMethods.toString()); - // Generate and output the PrintVisitor class try (PrintWriter writer = new PrintWriter(outputFile)) { - // Write the class template - writer.print(indentedClassTemplate); - - for (String ruleName : ruleNames) { - Synthesize_PrintVisitorMethod.generatePrintMethod(parserName, ruleName, writer, indentLevel + 1); - } - - // Close the class - writer.println(StringUtils.indentString("}", indentLevel)); + writer.print(classTemplate); } } private static List extractRuleNames(Parser parser) { // Extract rule names from the parser - return List.of(parser.getRuleNames()); + return Arrays.asList(parser.getRuleNames()); } } + +// LocalWords: SyntaxAnnotate PrintVisitor diff --git a/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitorMethod.java b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitorMethod.java new file mode 100644 index 0000000..35394bb --- /dev/null +++ b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitorMethod.java @@ -0,0 +1,90 @@ +import java.util.ArrayList; +import java.util.List; +import java.io.PrintWriter; + +public class Synthesize_SyntaxAnnotate_PrintVisitorMethod { + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: Synthesize_SyntaxAnnotate_PrintVisitorMethod" + + " [-version]" + +" " + ; + + public static void main(String[] args) { + if (args.length == 0) { + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + boolean error = false; + boolean version = false; + List argList = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + String arg = args[i]; + if (arg.startsWith("-")) { + switch (arg) { + case "-version": + version = true; + break; + default: + System.err.println("Unrecognized option: " + arg); + error = true; + } + } else { + argList.add(arg); + } + } + if(version){ + System.out.println("version 0.1"); + if(error){ + System.exit(1); + }else{ + System.exit(0); + } + } + if (argList.size() != 3) { + System.err.println("Expected exactly three non-option arguments."); + error = true; + } + if(error){ + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + String grammarName = argList.get(0); + String ruleName = argList.get(1); + String outputFile = argList.get(2); + + String parserName = grammarName + "Parser"; + + try { + PrintWriter writer = new PrintWriter(outputFile); + // start at indent level 0 + writer.print(synthesizePrintMethod(parserName, ruleName, 0)); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static String synthesizePrintMethod(String parserName, String ruleName, int indentLevel) { + // Template for the print method using text blocks + String template = """ + public String visit____0_ (____1_.____0_Context ctx) { + StringBuilder result = new StringBuilder(); + result.append("____0_("); + for (int i = 0; i < ctx.getChildCount(); i++) { + if (i > 0) result.append(", "); + result.append(visit(ctx.getChild(i))); + } + result.append(")"); + return result.toString(); + } + """; + + // Fill in the blanks in the template + template = template.replace("____0_", ruleName); + template = template.replace("____1_", parserName); + + // Indent the template + return StringUtils.indentString(template, indentLevel); + } +} diff --git a/developer/javac/Synthhesize_PrintVisitorMethod.java b/developer/javac/Synthhesize_PrintVisitorMethod.java deleted file mode 100644 index af1ffa1..0000000 --- a/developer/javac/Synthhesize_PrintVisitorMethod.java +++ /dev/null @@ -1,82 +0,0 @@ -import java.io.PrintWriter; - -public class Synthesize_PrintVisitorMethod { - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java Synthesize_PrintVisitorMethod " + - "[-version]"; - - public static void main(String[] args) { - if (args.length == 0) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - String parserName = null; - String ruleName = null; - String outputFile = null; - - // Parse the arguments - for (int i = 0; i < args.length; i++) { - String arg = args[i]; - if (arg.startsWith("-")) { - switch (arg) { - case "-version": - System.out.println("Version 0.1"); - System.exit(0); - break; - default: - System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - } else { - if (parserName == null) { - parserName = arg; - } else if (ruleName == null) { - ruleName = arg; - } else { - outputFile = arg; - } - } - } - - // Ensure there are exactly three arguments - if (parserName == null || ruleName == null || outputFile == null) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - try (PrintWriter writer = new PrintWriter(outputFile)) { - generatePrintMethod(parserName, ruleName, writer, 0); // Default indent level 0 - } catch (Exception e) { - e.printStackTrace(); - } - } - - public static void generatePrintMethod(String parserName, String ruleName, PrintWriter writer, int indentLevel) { - // Template for the print method using text blocks - String template = """ - public String visit____0_ (____1_. ____0_Context ctx) { - StringBuilder result = new StringBuilder(); - result.append("____0_("); - for (int i = 0; i < ctx.getChildCount(); i++) { - if (i > 0) result.append(", "); - result.append(visit(ctx.getChild(i))); - } - result.append(")"); - return result.toString(); - } - """; - - // Fill in the blanks in the template - template = template.replace("____0_", ruleName); - template = template.replace("____1_", parserName); - - // Indent the template - String indentedTemplate = StringUtils.indentString(template, indentLevel); - - // Write the template to the output file - writer.print(indentedTemplate); - writer.println(); - } -} diff --git a/developer/javac/TerminalToCategory.java b/developer/javac/TerminalToCategory.java deleted file mode 100644 index ab1b032..0000000 --- a/developer/javac/TerminalToCategory.java +++ /dev/null @@ -1,141 +0,0 @@ -/* - Helper function to simplify the GQL grammar file by categorizing terminal symbols. - - Accepts a the terminal symbols category grammar file, and the original grammar file. - - Replaces each terminal symbol in the original grammar file with a corresponding category token. -*/ -import java.io.*; -import java.nio.file.*; -import java.util.*; - -public class TerminalToCategory { - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java TerminalToCategory " + - "[-version]"; - - public static void main(String[] args) throws IOException { - if (args.length == 0) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - String literalsFile = null; - String originalFile = null; - String outputFile = null; - - // Parse the arguments - for (int i = 0; i < args.length; i++) { - String arg = args[i]; - if (arg.startsWith("-")) { - switch (arg) { - case "-version": - System.out.println("Version 0.1"); - System.exit(0); - break; - default: - System.err.println("Unrecognized option: " + arg); - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - } else { - if (literalsFile == null) { - literalsFile = arg; - } else if (originalFile == null) { - originalFile = arg; - } else { - outputFile = arg; - } - } - } - - // Ensure there are exactly three arguments - if (literalsFile == null || originalFile == null || outputFile == null) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - Map tokenMap = loadTokenMap(literalsFile); - List originalLines = Files.readAllLines(Paths.get(originalFile)); - - // Print categories and their terminals - printTokenMap(tokenMap); - - List updatedLines = new ArrayList<>(); - - for (int i = 0; i < originalLines.size(); i++) { - String line = originalLines.get(i); - String updatedLine = line; - for (Map.Entry entry : tokenMap.entrySet()) { - String terminal = entry.getKey(); - String category = entry.getValue(); - - // Use a regex to replace whole words only, and avoid replacing category names - String regex = "\\b" + terminal + "\\b"; - if (!category.equals("CONTROL_FLOW") && updatedLine.matches(".*" + regex + ".*")) { - // Print the substitution details - System.out.println("Substituting " + terminal + " with " + category + - " on line " + (i + 1) + ": " + updatedLine.trim()); - // Add a comment with the original rule - updatedLines.add("// Original: " + updatedLine.trim()); - updatedLine = updatedLine.replaceAll(regex, category); - } - } - updatedLines.add(updatedLine); - } - - Files.write(Paths.get(outputFile), updatedLines); - System.out.println("Substitution complete. Output written to " + outputFile); - } - - private static Map loadTokenMap(String literalsFile) throws IOException { - Map tokenMap = new HashMap<>(); - List lines = Files.readAllLines(Paths.get(literalsFile)); - - String currentToken = null; - StringBuilder symbolsBuilder = new StringBuilder(); - - for (String line : lines) { - line = line.trim(); - if (line.isEmpty() || line.startsWith("//")) { - continue; - } - if (line.contains(":")) { - if (currentToken != null) { - addSymbolsToMap(currentToken, symbolsBuilder.toString(), tokenMap); - } - String[] parts = line.split(":"); - currentToken = parts[0].trim(); - symbolsBuilder = new StringBuilder(parts[1].trim()); - } else if (line.endsWith(";")) { - symbolsBuilder.append(" ").append(line.replace(";", "").trim()); - addSymbolsToMap(currentToken, symbolsBuilder.toString(), tokenMap); - currentToken = null; - symbolsBuilder = new StringBuilder(); - } else { - symbolsBuilder.append(" ").append(line); - } - } - return tokenMap; - } - - private static void addSymbolsToMap(String token, String symbols, Map tokenMap) { - for (String symbol : symbols.split("\\s+")) { - tokenMap.put(symbol, token); - } - } - - private static void printTokenMap(Map tokenMap) { - Map> categorizedMap = new HashMap<>(); - - for (Map.Entry entry : tokenMap.entrySet()) { - categorizedMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>()).add(entry.getKey()); - } - - for (Map.Entry> entry : categorizedMap.entrySet()) { - System.out.println("Category: " + entry.getKey()); - System.out.println("Terminals: " + String.join(", ", entry.getValue())); - System.out.println(); - } - } -} diff --git a/developer/test/Arithmetic_Syntax__Test_0.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_0.txt similarity index 100% rename from developer/test/Arithmetic_Syntax__Test_0.txt rename to developer/test/Arithmetic_SyntaxAnnotate__Test_0.txt diff --git a/developer/test/Arithmetic_Syntax__Test_1.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_1.txt similarity index 100% rename from developer/test/Arithmetic_Syntax__Test_1.txt rename to developer/test/Arithmetic_SyntaxAnnotate__Test_1.txt diff --git a/developer/test/Arithmetic_Syntax__Test_2.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_2.txt similarity index 100% rename from developer/test/Arithmetic_Syntax__Test_2.txt rename to developer/test/Arithmetic_SyntaxAnnotate__Test_2.txt diff --git a/developer/test/Arithmetic_Syntax__Test_3.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_3.txt similarity index 100% rename from developer/test/Arithmetic_Syntax__Test_3.txt rename to developer/test/Arithmetic_SyntaxAnnotate__Test_3.txt diff --git a/developer/test/Arithmetic_Syntax__Test_4.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_4.txt similarity index 100% rename from developer/test/Arithmetic_Syntax__Test_4.txt rename to developer/test/Arithmetic_SyntaxAnnotate__Test_4.txt diff --git a/developer/test/transcript_notes.txt b/developer/test/transcript_notes.txt new file mode 100644 index 0000000..2d48a3f --- /dev/null +++ b/developer/test/transcript_notes.txt @@ -0,0 +1,4 @@ + +2024-09-06T01:27:05Z[GQL_to_Cypher] In test file names the word `Syntax` was +changed to `SyntaxAnnotate`. + -- 2.20.1