From: Thomas Walker Lynch Date: Fri, 6 Sep 2024 15:17:17 +0000 (+0000) Subject: all executables use same form argument/options parsing, removes regex passed Tokens... X-Git-Url: https://git.reasoningtechnology.com/usr/lib/python2.7/_abcoll.py?a=commitdiff_plain;h=0948320c34fbeee923addf013386793e42c389ec;p=GQL-to-Cypher all executables use same form argument/options parsing, removes regex passed Tokens -> categories, 'Generate' -> 'Synthesize' --- 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_Syntax.java deleted file mode 100644 index a3c85b7..0000000 --- a/developer/javac/Arithmetic_Syntax.java +++ /dev/null @@ -1,79 +0,0 @@ -/* -Takes an 'Ariethemetic' grammar source file. Parses it. Outputs an annotated -version of the source file while labeling what parts of the grammar the syntax -objects belong to. Note the -pp option. - -*/ -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 Arithmetic_Syntax { - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: Arithmetic_Syntax [-pp] " + - "[-version]"; - - public static void main(String[] args) throws IOException { - if (args.length == 0) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - boolean pretty_print = false; - List file_arg_list = new ArrayList<>(); - boolean has_error = false; - - // Parse the options and arguments - for (int i = 0; i < args.length; i++) { - String arg = args[i]; - if (arg.startsWith("-")) { - switch (arg) { - 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; - } - } else { - file_arg_list.add(arg); - } - } - - // If there were any errors, print usage and exit - if (has_error) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - // Ensure there is exactly one input file - if (file_arg_list.size() != 1) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - String input_file = file_arg_list.get(0); - String input = Files.readString(Paths.get(input_file)); - - try { - ArithmeticLexer lexer = new ArithmeticLexer(CharStreams.fromString(input)); - CommonTokenStream tokens = new CommonTokenStream(lexer); - ArithmeticParser parser = new ArithmeticParser(tokens); - ParseTree tree = parser.program(); - - Arithmetic_Syntax_PrintVisitor visitor = new Arithmetic_Syntax_PrintVisitor(parser.getRuleNames(), pretty_print); - String output = visitor.visit(tree); - System.out.println(output); - } catch (Exception e) { - e.printStackTrace(); - } - } -} diff --git a/developer/javac/Arithmetic_SyntaxAnnotate.java b/developer/javac/Arithmetic_SyntaxAnnotate.java new file mode 100644 index 0000000..0516db6 --- /dev/null +++ b/developer/javac/Arithmetic_SyntaxAnnotate.java @@ -0,0 +1,81 @@ +/* +Takes an 'Ariethemetic' grammar source file. Parses it. Outputs an annotated +version of the source file while labeling what parts of the grammar the syntax +objects belong to. Note the -pp option. + +*/ +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 Arithmetic_SyntaxAnnotate { + // Constant for the usage message + 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 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 { + ArithmeticLexer lexer = new ArithmeticLexer(CharStreams.fromString(input)); + CommonTokenStream tokens = new CommonTokenStream(lexer); + ArithmeticParser parser = new ArithmeticParser(tokens); + ParseTree tree = parser.program(); + + Arithmetic_SyntaxAnnotate_PrintVisitor visitor = + new Arithmetic_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/Arithmetic_SyntaxAnnotate_PrintVisitor.java b/developer/javac/Arithmetic_SyntaxAnnotate_PrintVisitor.java new file mode 100644 index 0000000..9831e54 --- /dev/null +++ b/developer/javac/Arithmetic_SyntaxAnnotate_PrintVisitor.java @@ -0,0 +1,62 @@ +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +public class Arithmetic_SyntaxAnnotate_PrintVisitor extends ArithmeticBaseVisitor{ + private final String[] rule_names; + private final boolean pretty_print; + + public Arithmetic_SyntaxAnnotate_PrintVisitor(String[] rule_names, boolean pretty_print){ + this.rule_names = rule_names; + this.pretty_print = pretty_print; + } + + private String indent(int level){ + return " ".repeat(level); + } + + @Override + public String visitProgram(ArithmeticParser.ProgramContext ctx){ + if(pretty_print){ + StringBuilder result = new StringBuilder(); + result.append("program\n").append(visitExpression(ctx.expression(), 1)); + return result.toString(); + }else{ + return "program(" + visit(ctx.expression()) + ")"; + } + } + + @Override + public String visitExpression(ArithmeticParser.ExpressionContext ctx){ + return visitExpression(ctx, 0); + } + + private String visitExpression(ArithmeticParser.ExpressionContext ctx, int indent_level){ + StringBuilder result = new StringBuilder(); + if(pretty_print){ + result.append(indent(indent_level)).append("expression(\n"); + if( ctx.INT() != null ){ + result.append(indent(indent_level + 1)).append("INT(").append(ctx.INT().getText()).append(")\n"); + }else if( ctx.getChildCount() == 3 && ctx.getChild(0).getText().equals("(") ){ + result.append(indent(indent_level + 1)).append("(\n"); + result.append(visitExpression(ctx.expression(0), indent_level + 2)); + result.append(indent(indent_level + 1)).append(")\n"); + }else{ + result.append(visitExpression(ctx.expression(0), indent_level + 1)); + result.append(indent(indent_level + 1)).append("operator(").append(ctx.getChild(1).getText()).append(")\n"); + result.append(visitExpression(ctx.expression(1), indent_level + 1)); + } + result.append(indent(indent_level)).append(")\n"); + }else{ + if( ctx.INT() != null ){ + result.append("INT(").append(ctx.INT().getText()).append(")"); + }else if( ctx.getChildCount() == 3 && ctx.getChild(0).getText().equals("(") ){ + result.append("(").append(visit(ctx.expression(0))).append(")"); + }else{ + String left = visit(ctx.expression(0)); + String right = visit(ctx.expression(1)); + String operator = "operator(" + ctx.getChild(1).getText() + ")"; + result.append("expression(").append(left).append(" ").append(operator).append(" ").append(right).append(")"); + } + } + return result.toString(); + } +} 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_PrintVisitor.java b/developer/javac/Arithmetic_Syntax_PrintVisitor.java deleted file mode 100644 index 96f0b2b..0000000 --- a/developer/javac/Arithmetic_Syntax_PrintVisitor.java +++ /dev/null @@ -1,62 +0,0 @@ -import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; - -public class Arithmetic_Syntax_PrintVisitor extends ArithmeticBaseVisitor{ - private final String[] rule_names; - private final boolean pretty_print; - - public Arithmetic_Syntax_PrintVisitor(String[] rule_names, boolean pretty_print){ - this.rule_names = rule_names; - this.pretty_print = pretty_print; - } - - private String indent(int level){ - return " ".repeat(level); - } - - @Override - public String visitProgram(ArithmeticParser.ProgramContext ctx){ - if(pretty_print){ - StringBuilder result = new StringBuilder(); - result.append("program\n").append(visitExpression(ctx.expression(), 1)); - return result.toString(); - }else{ - return "program(" + visit(ctx.expression()) + ")"; - } - } - - @Override - public String visitExpression(ArithmeticParser.ExpressionContext ctx){ - return visitExpression(ctx, 0); - } - - private String visitExpression(ArithmeticParser.ExpressionContext ctx, int indent_level){ - StringBuilder result = new StringBuilder(); - if(pretty_print){ - result.append(indent(indent_level)).append("expression(\n"); - if( ctx.INT() != null ){ - result.append(indent(indent_level + 1)).append("INT(").append(ctx.INT().getText()).append(")\n"); - }else if( ctx.getChildCount() == 3 && ctx.getChild(0).getText().equals("(") ){ - result.append(indent(indent_level + 1)).append("(\n"); - result.append(visitExpression(ctx.expression(0), indent_level + 2)); - result.append(indent(indent_level + 1)).append(")\n"); - }else{ - result.append(visitExpression(ctx.expression(0), indent_level + 1)); - result.append(indent(indent_level + 1)).append("operator(").append(ctx.getChild(1).getText()).append(")\n"); - result.append(visitExpression(ctx.expression(1), indent_level + 1)); - } - result.append(indent(indent_level)).append(")\n"); - }else{ - if( ctx.INT() != null ){ - result.append("INT(").append(ctx.INT().getText()).append(")"); - }else if( ctx.getChildCount() == 3 && ctx.getChild(0).getText().equals("(") ){ - result.append("(").append(visit(ctx.expression(0))).append(")"); - }else{ - String left = visit(ctx.expression(0)); - String right = visit(ctx.expression(1)); - String operator = "operator(" + ctx.getChild(1).getText() + ")"; - result.append("expression(").append(left).append(" ").append(operator).append(" ").append(right).append(")"); - } - } - return result.toString(); - } -} 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_PrintVisitor.java b/developer/javac/Synthesize_PrintVisitor.java deleted file mode 100644 index 56ec0a8..0000000 --- a/developer/javac/Synthesize_PrintVisitor.java +++ /dev/null @@ -1,104 +0,0 @@ -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.List; -import java.io.PrintWriter; - -public class Synthesize_PrintVisitor { - // Constant for the usage message - private static final String USAGE_MESSAGE = "Usage: java Synthesize_PrintVisitor [indentLevel] " + - "[-version]"; - - public static void main(String[] args) throws IOException { - if (args.length == 0) { - System.err.println(USAGE_MESSAGE); - System.exit(1); - } - - String grammarFile = null; - String outputFile = null; - int indentLevel = 0; - - // 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 (grammarFile == null) { - grammarFile = arg; - } else if (outputFile == null) { - outputFile = arg; - } else { - indentLevel = Integer.parseInt(arg); - } - } - } - - // Ensure there are exactly two or three arguments - if (grammarFile == 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 parserName = grammarName + "Parser"; - - // Parse the .g4 file - CharStream input = CharStreams.fromFileName(grammarFile); - ANTLRv4Lexer lexer = new ANTLRv4Lexer(input); - CommonTokenStream tokens = new CommonTokenStream(lexer); - ANTLRv4Parser parser = new ANTLRv4Parser(tokens); - - // Extract rules - ParseTree tree = parser.grammarSpec(); - List ruleNames = extractRuleNames(parser); - - // Template for the PrintVisitor class - String classTemplate = """ - import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; - - public class PrintVisitor extends AbstractParseTreeVisitor { - private final String[] ruleNames; - - public PrintVisitor(String[] ruleNames) { - this.ruleNames = ruleNames; - } - - // Generated print methods - """; - - // Indent the class template - String indentedClassTemplate = StringUtils.indentString(classTemplate, indentLevel); - - // 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)); - } - } - - private static List extractRuleNames(Parser parser) { - // Extract rule names from the parser - return List.of(parser.getRuleNames()); - } -} 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_SyntaxAnnotate_PrintVisitor.java b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitor.java new file mode 100644 index 0000000..0c3bf7c --- /dev/null +++ b/developer/javac/Synthesize_SyntaxAnnotate_PrintVisitor.java @@ -0,0 +1,111 @@ +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.Arrays; +import java.util.List; +import java.io.PrintWriter; + +public class Synthesize_SyntaxAnnotate_PrintVisitor { + // Constant for the usage message + private static final String USAGE_MESSAGE = + "Usage: Synthesize_SyntaxAnnotate_PrintVisitor" + +"[-version]" + +" [indentLevel]" + ; + + public static void main(String[] args) throws IOException { + if (args.length == 0) { + System.err.println(USAGE_MESSAGE); + System.exit(1); + } + + String grammarFilePath = null; + String outputFile = null; + int indentLevel = 0; + + // 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 (grammarFilePath == null) { + grammarFilePath = arg; + } else if (outputFile == null) { + outputFile = arg; + } else { + indentLevel = Integer.parseInt(arg); + } + } + } + + // Ensure there are exactly two or three arguments + 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(grammarFilePath).getFileName().toString().replace(".g4", ""); + String parserName = grammarName + "Parser"; + String visitorClassName = grammarName + "_SyntaxAnnotate_PrintVisitor"; + + // Parse the .g4 file + CharStream input = CharStreams.fromFileName(grammarFilePath); + ANTLRv4Lexer lexer = new ANTLRv4Lexer(input); + CommonTokenStream tokens = new CommonTokenStream(lexer); + ANTLRv4Parser parser = new ANTLRv4Parser(tokens); + + // Extract rules + 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 ____0_ extends AbstractParseTreeVisitor { + private final String[] ruleNames; + + public ____0_(String[] ruleNames) { + this.ruleNames = ruleNames; + } + + ____1_ + } + """; + + classTemplate = classTemplate.replace("____0_", visitorClassName); + classTemplate = classTemplate.replace("____1_", printMethods.toString()); + + try (PrintWriter writer = new PrintWriter(outputFile)) { + writer.print(classTemplate); + } + } + + private static List extractRuleNames(Parser parser) { + // Extract rule names from the parser + 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_SyntaxAnnotate__Test_0.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_0.txt new file mode 100644 index 0000000..fe7e39e --- /dev/null +++ b/developer/test/Arithmetic_SyntaxAnnotate__Test_0.txt @@ -0,0 +1 @@ +3 + 5 diff --git a/developer/test/Arithmetic_SyntaxAnnotate__Test_1.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_1.txt new file mode 100644 index 0000000..fe7e39e --- /dev/null +++ b/developer/test/Arithmetic_SyntaxAnnotate__Test_1.txt @@ -0,0 +1 @@ +3 + 5 diff --git a/developer/test/Arithmetic_SyntaxAnnotate__Test_2.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_2.txt new file mode 100644 index 0000000..1603bfc --- /dev/null +++ b/developer/test/Arithmetic_SyntaxAnnotate__Test_2.txt @@ -0,0 +1,2 @@ +2 * (3 + 4) + diff --git a/developer/test/Arithmetic_SyntaxAnnotate__Test_3.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_3.txt new file mode 100644 index 0000000..d11b7e2 --- /dev/null +++ b/developer/test/Arithmetic_SyntaxAnnotate__Test_3.txt @@ -0,0 +1 @@ +10 / 2 diff --git a/developer/test/Arithmetic_SyntaxAnnotate__Test_4.txt b/developer/test/Arithmetic_SyntaxAnnotate__Test_4.txt new file mode 100644 index 0000000..df1f368 --- /dev/null +++ b/developer/test/Arithmetic_SyntaxAnnotate__Test_4.txt @@ -0,0 +1,2 @@ +3 + 5 * (10 - 4) + diff --git a/developer/test/Arithmetic_Syntax__Test_0.txt b/developer/test/Arithmetic_Syntax__Test_0.txt deleted file mode 100644 index fe7e39e..0000000 --- a/developer/test/Arithmetic_Syntax__Test_0.txt +++ /dev/null @@ -1 +0,0 @@ -3 + 5 diff --git a/developer/test/Arithmetic_Syntax__Test_1.txt b/developer/test/Arithmetic_Syntax__Test_1.txt deleted file mode 100644 index fe7e39e..0000000 --- a/developer/test/Arithmetic_Syntax__Test_1.txt +++ /dev/null @@ -1 +0,0 @@ -3 + 5 diff --git a/developer/test/Arithmetic_Syntax__Test_2.txt b/developer/test/Arithmetic_Syntax__Test_2.txt deleted file mode 100644 index 1603bfc..0000000 --- a/developer/test/Arithmetic_Syntax__Test_2.txt +++ /dev/null @@ -1,2 +0,0 @@ -2 * (3 + 4) - diff --git a/developer/test/Arithmetic_Syntax__Test_3.txt b/developer/test/Arithmetic_Syntax__Test_3.txt deleted file mode 100644 index d11b7e2..0000000 --- a/developer/test/Arithmetic_Syntax__Test_3.txt +++ /dev/null @@ -1 +0,0 @@ -10 / 2 diff --git a/developer/test/Arithmetic_Syntax__Test_4.txt b/developer/test/Arithmetic_Syntax__Test_4.txt deleted file mode 100644 index df1f368..0000000 --- a/developer/test/Arithmetic_Syntax__Test_4.txt +++ /dev/null @@ -1,2 +0,0 @@ -3 + 5 * (10 - 4) - 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`. +