--- /dev/null
+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;
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
# LocalWords: ANTLRv PrintRuleNameListRegx RuleNameListRegx RuleNameList
+# LocalWords: PrintVisitorMethod PrintVisitor SyntaxAnnotate
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
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:
#--------------------
$(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)/$*"
public class ANTLR_OUT_FL {
- // Constant for the usage message
- private static final String USAGE_MESSAGE = "Usage: java ANTLR_OUT_FL <grammar-file> " +
- "[-visitor (default)] [-no-visitor] " +
- "[-listener] [-no-listener (default)] " +
- "[-tokens] [-no-tokens (default)] " +
- "[-path <path>]";
+ private static final String USAGE_MESSAGE =
+ "Usage: ANTLR_OUT_FL <grammar-name> "
+ +" [-visitor (default)] [-no-visitor] "
+ +" [-listener] [-no-listener (default)] "
+ +" [-tokens] [-no-tokens (default)] "
+ +" [-path <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<String> 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;
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<String> generatedFiles = generateFileList(grammarFile, visitor, noListener, noTokens, outputPath);
+ List<String> generatedFiles = generateFileList(grammarName, visitor, noListener, noTokens, outputPath);
// Print the files in a space-separated format on a single line
if (!generatedFiles.isEmpty()) {
System.out.println(); // Print a newline at the end
}
- public static List<String> generateFileList(String grammarFile, boolean visitor, boolean noListener, boolean noTokens, String outputPath) {
- String baseName = new File(grammarFile).getName().replace(".g4", "");
+ public static List<String> generateFileList(String grammarName, boolean visitor, boolean noListener, boolean noTokens, String outputPath) {
+ String baseName = new File(grammarName).getName().replace(".g4", "");
List<String> fileList = new ArrayList<>();
// Determine if this is a lexer, parser, or both
--- /dev/null
+/* 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] <source-file-path>";
+
+ 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<String> 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();
+ }
+ }
+}
--- /dev/null
+/* This file synthesized by Synthesize_SyntaxAnnotate_PrintVisitor.
+*/
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
+
+public class Arithmetic2_SyntaxAnnotate_PrintVisitor extends AbstractParseTreeVisitor<String> {
+ 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();
+ }
+
+}
public class Arithmetic_Echo {
// Constant for the usage message
- private static final String USAGE_MESSAGE = "Usage: java Arithmetic_Echo <input-file> " +
- "[-version]";
+ private static final String USAGE_MESSAGE =
+ "Usage: Arithmetic_Echo [-version] <source-file-path>";
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<String> 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);
}
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<String> 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<String, Boolean> tests = new HashMap<>();
tests.put("Arithmetic_Echo_0", Arithmetic_Echo_0());
+++ /dev/null
-/*
-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] <source-file> " +
- "[-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<String> 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();
- }
- }
-}
--- /dev/null
+/*
+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] <source-file>";
+
+ 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<String> 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();
+ }
+ }
+}
--- /dev/null
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
+
+public class Arithmetic_SyntaxAnnotate_PrintVisitor extends ArithmeticBaseVisitor<String>{
+ 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();
+ }
+}
--- /dev/null
+
+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<String> 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<String, Boolean> 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);
+ }
+
+}
+
+++ /dev/null
-import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
-
-public class Arithmetic_Syntax_PrintVisitor extends ArithmeticBaseVisitor<String>{
- 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();
- }
-}
+++ /dev/null
-
-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<String, Boolean> 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);
- }
-
-}
-
public class RuleNameList {
// Constant for the usage message
- private static final String USAGE_MESSAGE = "Usage: java RuleNameList <grammar_name> " +
- "[-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)]"
+ +" <grammar-name>"
+ ;
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<String> 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
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 <path-to-g4-file> " +
- "[-version]";
+ private static final String USAGE_MESSAGE =
+ "Usage: RuleNameListRegx [-version] <path-to-g4-file>";
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<String> 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<String> ruleNames = new HashSet<>();
+ String filePath = argList.get(0);
- try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
+ try {
+ Set<String> ruleNames = new HashSet<>();
+ BufferedReader br = new BufferedReader(new FileReader(filePath));
StringBuilder content = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
+++ /dev/null
-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 <grammarFile> <outputFile> [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<String> ruleNames = extractRuleNames(parser);
-
- // Template for the PrintVisitor class
- String classTemplate = """
- import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
-
- public class PrintVisitor extends AbstractParseTreeVisitor<String> {
- 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<String> extractRuleNames(Parser parser) {
- // Extract rule names from the parser
- return List.of(parser.getRuleNames());
- }
-}
--- /dev/null
+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] <grammar-name> <output-file-path>";
+
+ 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<String> 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] <source-file-path>";
+
+ 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<String> 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
--- /dev/null
+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]"
+ +"<grammarFilePath> <outputFile> [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<String> 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<String> {
+ 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<String> extractRuleNames(Parser parser) {
+ // Extract rule names from the parser
+ return Arrays.asList(parser.getRuleNames());
+ }
+}
+
+// LocalWords: SyntaxAnnotate PrintVisitor
--- /dev/null
+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]"
+ +" <grammar-name> <g4-rule-name> <output-file>"
+ ;
+
+ 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<String> 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);
+ }
+}
+++ /dev/null
-import java.io.PrintWriter;
-
-public class Synthesize_PrintVisitorMethod {
- // Constant for the usage message
- private static final String USAGE_MESSAGE = "Usage: java Synthesize_PrintVisitorMethod <parserName> <ruleName> <outputFile> " +
- "[-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();
- }
-}
+++ /dev/null
-/*
- 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 <literalsFile> <originalFile> <outputFile> " +
- "[-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<String, String> tokenMap = loadTokenMap(literalsFile);
- List<String> originalLines = Files.readAllLines(Paths.get(originalFile));
-
- // Print categories and their terminals
- printTokenMap(tokenMap);
-
- List<String> updatedLines = new ArrayList<>();
-
- for (int i = 0; i < originalLines.size(); i++) {
- String line = originalLines.get(i);
- String updatedLine = line;
- for (Map.Entry<String, String> 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<String, String> loadTokenMap(String literalsFile) throws IOException {
- Map<String, String> tokenMap = new HashMap<>();
- List<String> 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<String, String> tokenMap) {
- for (String symbol : symbols.split("\\s+")) {
- tokenMap.put(symbol, token);
- }
- }
-
- private static void printTokenMap(Map<String, String> tokenMap) {
- Map<String, List<String>> categorizedMap = new HashMap<>();
-
- for (Map.Entry<String, String> entry : tokenMap.entrySet()) {
- categorizedMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>()).add(entry.getKey());
- }
-
- for (Map.Entry<String, List<String>> entry : categorizedMap.entrySet()) {
- System.out.println("Category: " + entry.getKey());
- System.out.println("Terminals: " + String.join(", ", entry.getValue()));
- System.out.println();
- }
- }
-}
--- /dev/null
+2 * (3 + 4)
+
--- /dev/null
+3 + 5 * (10 - 4)
+
+++ /dev/null
-2 * (3 + 4)
-
+++ /dev/null
-3 + 5 * (10 - 4)
-
--- /dev/null
+
+2024-09-06T01:27:05Z[GQL_to_Cypher] In test file names the word `Syntax` was
+changed to `SyntaxAnnotate`.
+
projects / GQL-to-Cypher / commitdiff