separate relast preprocessor from ros2rag

.gitignore

+build
+src/gen-res/
+src/gen/
+out/
+*.class

build.gradle

+
+apply plugin: 'java'
+apply plugin: 'jastadd'
+apply plugin: 'application'
+apply plugin: "idea"
+
+sourceCompatibility = 1.8
+
+mainClassName = 'org.jastadd.relast.compiler.Compiler'
+
+repositories {
+    jcenter()
+}
+
+buildscript {
+    repositories.jcenter()
+    dependencies {
+        classpath 'org.jastadd:jastaddgradle:1.13.3'
+    }
+}
+
+dependencies {
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
+    testCompile 'org.assertj:assertj-core:3.12.1'
+    compile 'com.fasterxml.jackson.core:jackson-core:2.9.8'
+    compile 'com.fasterxml.jackson.core:jackson-databind:2.9.8'
+    compile 'org.jastadd:jastadd:2.3.4'
+    runtime 'org.jastadd:jastadd:2.3.4'
+    compile group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11'
+}
+
+sourceSets {
+    main {
+        java.srcDir "src/gen/java"
+        java.srcDir "buildSrc/gen/java"
+    }
+}
+
+test {
+    useJUnitPlatform()
+
+    maxHeapSize = '1G'
+}
+
+jar {
+    manifest {
+        attributes "Main-Class": 'org.jastadd.relast.compiler.Compiler'
+    }
+
+    from {
+        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
+    }
+}
+
+task relast(type: JavaExec) {
+    group = 'Build'
+    main = "-jar"
+
+    doFirst {
+        delete "src/gen/jastadd/*.ast"
+        delete "src/gen/jastadd/RelAst.jadd"
+        delete "src/gen/jastadd/RelAstRefResolver.jadd"
+        delete "src/gen/jastadd/RelAstResolverStubs.jrag"
+        mkdir  "src/gen/jastadd/"
+    }
+
+    args = [
+            "../libs/relast.jar",
+            "./src/main/jastadd/RelAst.relast",
+            "--listClass=java.util.ArrayList",
+            "--jastAddList=JastAddList",
+            "--useJastAddNames",
+            "--file",
+            "--resolverHelper",
+            "--grammarName=./src/gen/jastadd/RelAst"
+    ]
+
+    inputs.files file("../libs/relast.jar"),
+            file("src/main/jastadd/RelAst.relast")
+    outputs.files file("./src/gen/jastadd/RelAst.ast"),
+            file("src/gen/jastadd/RelAst.jadd"),
+            file("src/gen/jastadd/RelAstRefResolver.jadd"),
+            file('src/gen/jastadd/RelAstResolverStubs.jrag')
+}
+
+jastadd {
+    configureModuleBuild()
+    modules {
+        //noinspection GroovyAssignabilityCheck
+        module("RelAst") {
+
+            java {
+                basedir "."
+                include "src/main/**/*.java"
+                include "src/gen/**/*.java"
+            }
+
+            jastadd {
+                basedir "."
+                include "src/main/jastadd/**/*.ast"
+                include "src/main/jastadd/**/*.jadd"
+                include "src/main/jastadd/**/*.jrag"
+                include "src/gen/jastadd/**/*.ast"
+                include "src/gen/jastadd/**/*.jadd"
+                include "src/gen/jastadd/**/*.jrag"
+            }
+
+            scanner {
+                include "src/main/jastadd/RelAst.flex"
+            }
+
+            parser {
+                include "src/main/jastadd/Preamble.parser"
+                include "src/main/jastadd/RelAst.parser"
+            }
+        }
+    }
+
+    cleanGen.doFirst {
+        delete "src/gen/java/org"
+        delete "src/gen-res/BuildInfo.properties"
+    }
+
+    preprocessParser.doFirst {
+
+        args += ["--no-beaver-symbol"]
+
+    }
+
+    module = "RelAst"
+
+    astPackage = 'org.jastadd.relast.ast'
+
+    parser.name = 'RelAstParser'
+
+    genDir = 'src/gen/java'
+
+    buildInfoDir = 'src/gen-res'
+
+    scanner.genDir = "src/gen/java/org/jastadd/relast/scanner"
+    parser.genDir = "src/gen/java/org/jastadd/relast/parser"
+
+    jastaddOptions = ["--lineColumnNumbers", "--List=JastAddList", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
+}
+
+generateAst.dependsOn relast

src/main/jastadd/Analysis.jrag

+aspect Analysis {
+
+}

src/main/jastadd/DumpTree.jrag

+aspect DumpTree {
+  private static final String ASTNode.DUMP_TREE_INDENT = "  ";
+
+  public String ASTNode.dumpTree() {
+    java.io.ByteArrayOutputStream bytes = new java.io.ByteArrayOutputStream();
+    dumpTree(new java.io.PrintStream(bytes));
+    return bytes.toString();
+  }
+
+  public void ASTNode.dumpTree(java.io.PrintStream out) {
+    dumpTree(out, "");
+    out.flush();
+  }
+
+  public void ASTNode.dumpTree(java.io.PrintStream out, String indent) {
+    out.print(indent + getClass().getSimpleName());
+    out.print(getTokens());
+    String extra = extraDumpInfo();
+    if (!extra.isEmpty()) {
+      out.print(" " + extra);
+    }
+    out.println();
+    String childIndent = indent + DUMP_TREE_INDENT;
+    for (ASTNode<?> child : astChildren()) {
+      if (child == null) {
+        out.println(childIndent + "null");
+      } else {
+        child.dumpTree(out, childIndent);
+      }
+    }
+  }
+
+  public String ASTNode.extraDumpInfo() { return ""; }
+
+  public String ASTNode.getTokens() {
+    java.util.TreeSet<java.lang.reflect.Method> methods = new java.util.TreeSet<>(java.util.Comparator.comparing(java.lang.reflect.Method::getName));
+
+    methods.addAll(java.util.Arrays.asList(getClass().getMethods()));
+
+    StringBuilder result = new StringBuilder();
+    for (java.lang.reflect.Method method : methods) {
+      ASTNodeAnnotation.Token token = method.getAnnotation(ASTNodeAnnotation.Token.class);
+      if (token != null) {
+        try {
+          result.append(String.format(" %s=\"%s\"", token.name(), method.invoke(this)));
+        } catch (IllegalAccessException  ignored) {
+        } catch (java.lang.reflect.InvocationTargetException ignored) {
+        }
+      }
+    }
+    return result.toString();
+  }
+}

src/main/jastadd/NameResolution.jrag

+aspect NameResolution {
+
+  refine RefResolverStubs eq ASTNode.globallyResolveTypeDeclByToken(String id) = program().resolveTypeDecl(id);
+
+  syn TypeDecl Program.resolveTypeDecl(String name) {
+    for (TypeDecl decl : typeDecls()) {
+      if (decl.getName().equals(name)) {
+        return decl;
+      }
+    }
+    throw new RuntimeException("TypeDecl " + name + " could not be resolved.");
+  }
+
+  refine RefResolverStubs eq ASTNode.globallyResolveTokenComponentByToken(String id) {
+    // return a TokenComponent. id is of the form 'type_name + "." + token_name'
+    int dotIndex = id.indexOf(".");
+    String typeName = id.substring(0, dotIndex);
+    String tokenName = id.substring(dotIndex + 1);
+    TypeDecl type = program().resolveTypeDecl(typeName);
+    // iterate over components and find the matching tokenComponent
+    for (Component comp : type.getComponentList()) {
+      if (comp.isTokenComponent() && comp.getName().equals(tokenName)) {
+        return comp.asTokenComponent();
+      }
+    }
+    System.err.println("Could not resolve TokenComponent '" + id + "'.");
+    return null;
+  }
+
+}

src/main/jastadd/Navigation.jrag

+aspect Navigation {
+
+  // --- program ---
+  inh Program ASTNode.program();
+  eq Program.getChild().program() = this;
+
+  // --- typeDecls ---
+  coll java.util.Set<TypeDecl> Program.typeDecls() [new java.util.HashSet<>()] root Program;
+  TypeDecl contributes this
+    to Program.typeDecls()
+    for program();
+
+  // --- relations ---
+  coll java.util.Set<Relation> Program.relations() [new java.util.HashSet<>()] root Program;
+  Relation contributes this
+    to Program.relations()
+    for program();
+
+  // --- containingTypeDecl ---
+  inh TypeDecl Component.containingTypeDecl();
+  eq TypeDecl.getChild().containingTypeDecl() = this;
+
+  // --- containedFile ---
+  inh GrammarFile ASTNode.containedFile();
+  eq GrammarFile.getChild().containedFile() = this;
+
+  // --- isTokenComponent ---
+  syn boolean Component.isTokenComponent() = false;
+  eq TokenComponent.isTokenComponent() = true;
+
+  // --- asTokenComponent ---
+  syn TokenComponent Component.asTokenComponent() = null;
+  eq TokenComponent.asTokenComponent() = this;
+}

src/main/jastadd/Preamble.parser

+%header {:
+package org.jastadd.relast.parser;
+import org.jastadd.relast.ast.*;
+:};
+
+%goal goal;

src/main/jastadd/RelAst.flex

+package org.jastadd.relast.scanner;
+
+import org.jastadd.relast.parser.RelAstParser.Terminals;
+
+%%
+
+%public
+%final
+%class RelAstScanner
+%extends beaver.Scanner
+
+%type beaver.Symbol
+%function nextToken
+%yylexthrow beaver.Scanner.Exception
+%scanerror RelAstScanner.ScannerError
+
+%line
+%column
+%{
+  private StringBuilder stringLitSb = new StringBuilder();
+
+  private beaver.Symbol sym(short id) {
+    return new beaver.Symbol(id, yyline + 1, yycolumn + 1, yylength(), yytext());
+  }
+
+  private beaver.Symbol sym(short id, String text) {
+    return new beaver.Symbol(id, yyline + 1, yycolumn + 1, yylength(), text);
+  }
+
+
+  public static class ScannerError extends Error {
+    public ScannerError(String message) {
+      super(message);
+    }
+  }
+%}
+
+WhiteSpace = [ ] | \t | \f | \n | \r | \r\n
+TraditionalComment   = [/][*][^*]*[*]+([^*/][^*]*[*]+)*[/]
+EndOfLineComment = "//" [^\n\r]*
+Comment = {TraditionalComment} | {EndOfLineComment}
+
+ID = [a-zA-Z$_][a-zA-Z0-9$_]*
+
+%%
+{WhiteSpace} { /* ignore */ }
+{Comment}    { return sym(Terminals.COMMENT); }
+
+"abstract"   { return sym(Terminals.ABSTRACT); }
+"rel"        { return sym(Terminals.RELATION); }
+
+";"          { return sym(Terminals.SCOL); }
+":"          { return sym(Terminals.COL); }
+"::="        { return sym(Terminals.ASSIGN); }
+"*"          { return sym(Terminals.STAR); }
+"."          { return sym(Terminals.DOT); }
+","          { return sym(Terminals.COMMA); }
+"<"          { return sym(Terminals.LT); }
+">"          { return sym(Terminals.GT); }
+"["          { return sym(Terminals.LBRACKET); }
+"]"          { return sym(Terminals.RBRACKET); }
+"/"          { return sym(Terminals.SLASH); }
+"?"          { return sym(Terminals.QUESTION_MARK); }
+"->"         { return sym(Terminals.RIGHT); }
+"<-"         { return sym(Terminals.LEFT); }
+"<->"        { return sym(Terminals.BIDIRECTIONAL); }
+
+// ID
+{ID}         { return sym(Terminals.ID); }
+<<EOF>>      { return sym(Terminals.EOF); }
+
+[^]            { throw new ScannerError((yyline+1) +"," + (yycolumn+1) + ": Illegal character <"+yytext()+">"); }

src/main/jastadd/RelAst.parser

+GrammarFile goal
+  = declaration.d goal.p     {: p.getDeclarationList().insertChild(d, 0); return p; :}
+  |                          {: return new GrammarFile(); :}
+;
+
+Declaration declaration
+  = type_decl
+  | relation
+  | comment
+;
+
+Comment comment
+  = COMMENT  {: return new Comment(COMMENT); :};
+
+TypeDecl type_decl
+  = ID components_opt.c SCOL
+    {:
+      TypeDecl result = new TypeDecl();
+      result.setName(ID);
+      result.setAbstract(false);
+      result.setComponentList(c);
+      return result;
+    :}
+  | ID COL ID.s components_opt.c SCOL
+    {:
+      TypeDecl result = new TypeDecl();
+      result.setName(ID);
+      result.setAbstract(false);
+      result.setSuperType(TypeDecl.createRef(s));
+      result.setComponentList(c);
+      return result;
+    :}
+  | ABSTRACT ID components_opt.c SCOL
+    {:
+      TypeDecl result = new TypeDecl();
+      result.setName(ID);
+      result.setAbstract(true);
+      result.setComponentList(c);
+      return result;
+    :}
+  | ABSTRACT ID COL ID.s components_opt.c SCOL
+    {:
+      TypeDecl result = new TypeDecl();
+      result.setName(ID);
+      result.setAbstract(true);
+      result.setSuperType(TypeDecl.createRef(s));
+      result.setComponentList(c);
+      return result;
+    :}
+;
+
+JastAddList components_opt
+  = /* empty */             {: return new JastAddList(); :}
+  | ASSIGN components.l     {: return l; :}
+;
+
+JastAddList components
+  = /* empty */                 {: return new JastAddList(); :}
+  | components.l component.c    {: return l.add(c); :}
+;
+
+Component component
+  = SLASH actual_component.c SLASH
+      {:
+        c.setNTA(true);
+        return c;
+      :}
+  | actual_component
+;
+
+Component actual_component
+  = ID.name COL ID.type STAR
+    {:
+      ListComponent result = new ListComponent();
+      result.setName(name);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | ID.name COL ID.type
+    {:
+      NormalComponent result = new NormalComponent();
+      result.setName(name);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | ID.type STAR
+    {:
+      ListComponent result = new ListComponent();
+      result.setName(type);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | ID.type
+    {:
+      NormalComponent result = new NormalComponent();
+      result.setName(type);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | LBRACKET ID.name COL ID.type RBRACKET
+    {:
+      OptComponent result = new OptComponent();
+      result.setName(name);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | LBRACKET ID.type RBRACKET
+    {:
+      OptComponent result = new OptComponent();
+      result.setName(type);
+      result.setTypeDecl(TypeDecl.createRef(type));
+      return result;
+    :}
+  | LT ID.name COL java_type_use.type GT
+    {:
+      TokenComponent result = new TokenComponent();
+      result.setName(name);
+      result.setJavaTypeUse(type);
+      return result;
+    :}
+  | LT ID.type GT
+    {:
+      TokenComponent result = new TokenComponent();
+      result.setName(type);
+      result.setJavaTypeUse(new SimpleJavaTypeUse(type));
+      return result;
+    :}
+;
+
+
+JavaTypeUse java_type_use
+  = parameterized_java_type_use
+  | simple_java_type_use
+;
+
+ArrayList qualified_name
+  = ID
+  | qualified_name DOT ID
+;
+
+
+JastAddList java_type_use_list
+  = java_type_use.u                                 {: return new JastAddList().add(u); :}
+  | java_type_use_list.l COMMA java_type_use.u      {: return l.add(u); :}
+;
+
+SimpleJavaTypeUse simple_java_type_use
+  = qualified_name.n
+    {:
+      return new SimpleJavaTypeUse((String)n.stream().map( x -> ((Symbol)x).value.toString()).collect(java.util.stream.Collectors.joining(".")));
+    :}
+;
+
+ParameterizedJavaTypeUse parameterized_java_type_use
+  = simple_java_type_use.i LT java_type_use_list.l GT
+    {:
+      return new ParameterizedJavaTypeUse(i.getName(), l);
+    :}
+;
+
+Relation relation
+  = RELATION unnamed_role.a LEFT navigable_role.b SCOL
+    {:
+       LeftDirectedRelation result = new LeftDirectedRelation();
+       result.setSource(b);
+       result.setTarget(a);
+       return result;
+    :}
+  | RELATION navigable_role.a RIGHT unnamed_role.b SCOL
+    {:
+       RightDirectedRelation result = new RightDirectedRelation();
+       result.setSource(a);
+       result.setTarget(b);
+       return result;
+    :}
+  | RELATION navigable_role.a BIDIRECTIONAL navigable_role.b SCOL
+    {:
+       BidirectionalRelation result = new BidirectionalRelation();
+       result.setLeft(a);
+       result.setRight(b);
+       return result;
+    :}
+;
+
+
+UnnamedRole unnamed_role
+  = ID.type
+    {:
+      UnnamedRole result = new UnnamedRole();
+      result.setType(TypeDecl.createRef(type));
+      return result;
+    :}
+  | navigable_role
+;
+
+NavigableRole navigable_role
+  = ID.type DOT ID.name
+    {:
+      NormalRole result = new NormalRole();
+      result.setName(name);
+      result.setType(TypeDecl.createRef(type));
+      return result;
+    :}
+  | ID.type DOT ID.name STAR
+    {:
+      ListRole result = new ListRole();
+      result.setName(name);
+      result.setType(TypeDecl.createRef(type));
+      return result;
+    :}
+  | ID.type DOT ID.name QUESTION_MARK
+    {:
+      OptRole result = new OptRole();
+      result.setName(name);
+      result.setType(TypeDecl.createRef(type));
+      return result;
+    :}
+;

src/main/jastadd/RelAst.relast

+
+
+Program ::= GrammarFile *;
+
+abstract Grammar ::= Declaration*;
+GrammarFile : Grammar ::= <FileName> ;
+
+abstract Declaration;
+
+TypeDecl:Declaration ::= <Name> <Abstract:boolean>  Component*;
+
+rel TypeDecl.SuperType? <-> TypeDecl.SubType*;
+
+abstract Component ::= <Name> <NTA:boolean>;
+abstract TypeComponent : Component;
+
+rel TypeComponent.TypeDecl <-> TypeDecl.PotentialParent*;
+
+NormalComponent : TypeComponent;
+ListComponent : TypeComponent;
+OptComponent : TypeComponent;
+
+TokenComponent : Component ::= JavaTypeUse;
+
+abstract JavaTypeUse ::= <Name>;
+SimpleJavaTypeUse : JavaTypeUse;
+ParameterizedJavaTypeUse : JavaTypeUse ::= JavaTypeUse*;
+
+abstract Relation : Declaration;
+// rel Source.Name -> Target;
+// rel Target <- Source.Name;
+abstract DirectedRelation : Relation ::= Source:NavigableRole Target:UnnamedRole ;
+LeftDirectedRelation : DirectedRelation;
+RightDirectedRelation : DirectedRelation;
+// rel Left.LeftName <-> Right.RightName;
+BidirectionalRelation : Relation ::= Left:NavigableRole Right:NavigableRole ;
+
+abstract Role;
+abstract NavigableRole : Role ::= <Name>;
+NormalRole : NavigableRole;
+ListRole : NavigableRole;
+OptRole : NavigableRole;
+
+UnnamedRole : Role ;
+
+rel Role.Type <-> TypeDecl.Role*;
+
+// comments
+Comment : Declaration ::= <Text>;

src/main/jastadd/backend/AbstractGrammar.jadd

+aspect BackendAbstractGrammar {
+
+  public static String ASTNode.listInterface = "java.util.List";
+  public static String ASTNode.listClass = "java.util.ArrayList";
+  public static String ASTNode.jastAddListType = "List";
+  public static String ASTNode.jastAddOptType = "Opt";
+
+  public String Program.generateAbstractGrammar() {
+    StringBuilder sb = new StringBuilder();
+    generateAbstractGrammar(sb);
+    return sb.toString();
+  }
+
+  public void Program.generateAbstractGrammar(StringBuilder b) {
+    for (GrammarFile file : getGrammarFileList()) {
+      file.generateAbstractGrammar(b);
+    }
+  }
+
+  public String GrammarFile.generateAbstractGrammar() {
+    StringBuilder sb = new StringBuilder();
+    generateAbstractGrammar(sb);
+    return sb.toString();
+  }
+
+  public void Grammar.generateAbstractGrammar(StringBuilder b) {
+    for (Declaration decl : getDeclarationList()) {
+      decl.generateAbstractGrammar(b);
+    }
+  }
+
+  abstract public void Declaration.generateAbstractGrammar(StringBuilder b);
+
+  public void Comment.generateAbstractGrammar(StringBuilder b) {
+    b.append(getText()).append("\n");
+  }
+
+  public void TypeDecl.generateAbstractGrammar(StringBuilder b) {
+    if (getAbstract()) {
+      b.append("abstract ");
+    }
+    b.append(getName()).append(" ");
+    if (hasSuperType()) {
+      b.append(": ").append(getSuperType().getName()).append(" ");
+    }
+    b.append("::=");
+    for (Component component : getComponentList()) {
+      b.append(" ");
+      component.generateAbstractGrammar(b);
+    }
+    b.append(";\n");
+  }
+
+  public abstract void Component.generateAbstractGrammar(StringBuilder b);
+
+  public void NormalComponent.generateAbstractGrammar(StringBuilder b) {
+    if (getNTA()) {
+      b.append("/");
+    }
+
+    if (!getName().equals("")) {
+      b.append(getName()).append(":");
+    }
+    b.append(getTypeDecl().getName());
+    if (getNTA()) {
+      b.append("/");
+    }
+  }
+
+  public void ListComponent.generateAbstractGrammar(StringBuilder b) {
+    if (getNTA()) {
+      b.append("/");
+    }
+
+    if (!getName().equals("")) {
+      b.append(getName()).append(":");
+    }
+    b.append(getTypeDecl().getName()).append("*");
+    if (getNTA()) {
+      b.append("/");
+    }
+  }
+
+  public void OptComponent.generateAbstractGrammar(StringBuilder b) {
+    if (getNTA()) {
+      b.append("/");
+    }
+    b.append("[");
+    if (!getName().equals("")) {
+      b.append(getName()).append(":");
+    }
+    b.append(getTypeDecl().getName()).append("]");
+    if (getNTA()) {
+      b.append("/");
+    }
+  }
+
+  public void TokenComponent.generateAbstractGrammar(StringBuilder b) {
+    if (getNTA()) {
+      b.append("/");
+    }
+    b.append("<");
+    if (!getName().equals("")) {
+      b.append(getName()).append(":");
+    }
+    getJavaTypeUse().generateAbstractGrammar(b);
+    b.append(">");
+    if (getNTA()) {
+      b.append("/");
+    }
+  }
+
+  abstract public void JavaTypeUse.generateAbstractGrammar(StringBuilder b);
+
+  public void SimpleJavaTypeUse.generateAbstractGrammar(StringBuilder b) {
+    b.append(getName());
+  }
+
+  public void ParameterizedJavaTypeUse.generateAbstractGrammar(StringBuilder b) {
+    b.append("<");
+    boolean first = true;
+    for (JavaTypeUse javaTypeUse : getJavaTypeUseList()) {
+      if (first) {
+        first = false;
+      } else {
+        b.append(", ");
+      }
+      javaTypeUse.generateAbstractGrammar(b);
+    }
+    b.append(">");
+  }
+
+  abstract public void Relation.generateAbstractGrammar(StringBuilder b);
+
+  public void DirectedRelation.generateAbstractGrammar(StringBuilder b) {
+    b.append("rel ");
+    getSource().generateAbstractGrammar(b);
+    b.append(" -> ");
+    getTarget().generateAbstractGrammar(b);
+    b.append(";\n");
+  }
+
+  public void BidirectionalRelation.generateAbstractGrammar(StringBuilder b) {
+    b.append("rel ");
+    getLeft().generateAbstractGrammar(b);
+    b.append(" <-> ");
+    getRight().generateAbstractGrammar(b);
+    b.append(";\n");
+  }
+
+  abstract public void Role.generateAbstractGrammar(StringBuilder b);
+
+  public void NormalRole.generateAbstractGrammar(StringBuilder b) {
+    b.append(getType().getName()).append(".").append(getName());
+  }
+
+  public void ListRole.generateAbstractGrammar(StringBuilder b) {
+    b.append(getType().getName()).append(".").append(getName()).append("*");
+  }
+
+  public void OptRole.generateAbstractGrammar(StringBuilder b) {
+    b.append(getType().getName()).append(".").append(getName()).append("?");
+  }
+
+  public void UnnamedRole.generateAbstractGrammar(StringBuilder b) {
+    b.append(getType().getName());
+  }
+
+
+}

src/main/java/org/jastadd/relast/compiler/Compiler.java

+package org.jastadd.relast.compiler;
+
+import beaver.Parser;
+import org.jastadd.relast.ast.GrammarFile;
+import org.jastadd.relast.ast.Program;
+import org.jastadd.relast.compiler.options.CommandLine;
+import org.jastadd.relast.compiler.options.CommandLine.CommandLineException;
+import org.jastadd.relast.compiler.options.Option;
+import org.jastadd.relast.compiler.options.StringOption;
+import org.jastadd.relast.parser.RelAstParser;
+import org.jastadd.relast.scanner.RelAstScanner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Compiler {
+
+  private StringOption optionOutputDir;
+  private StringOption optionInputDir;
+
+  private ArrayList<Option<?>> options;
+  private CommandLine commandLine;
+
+  public Compiler() {
+    options = new ArrayList<>();
+    addOptions();
+  }
+
+  public static void main(String[] args) {
+    try {
+      new Compiler().run(args);
+    } catch (CommandLineException | CompilerException e) {
+      System.err.println(e.getMessage());
+      System.exit(-1);
+    }
+  }
+
+  public int run(String[] args) throws CommandLineException, CompilerException {
+    options = new ArrayList<>();
+    addOptions();
+    commandLine = new CommandLine(options);
+    commandLine.parse(args);
+
+    Path inputPath;
+    if (optionInputDir.isSet()) {
+      inputPath = Paths.get(optionInputDir.getValue());
+    } else {
+      inputPath = Paths.get(".");
+      printMessage("No input dir is set. Assuming current directory '" + inputPath.toAbsolutePath().toString() + "'.");
+    }
+
+    if (!inputPath.toFile().exists()) {
+      printMessage("Input path '" + inputPath.toAbsolutePath().toString() + "' does not exist. Exiting...");
+      System.exit(-1);
+    } else if (!inputPath.toFile().isDirectory()) {
+      printMessage("Input path '" + inputPath.toAbsolutePath().toString() + "' is not a directory. Exiting...");
+      System.exit(-1);
+    }
+
+    Path outputPath; // should not be used, but otherwise there is a compiler warning
+    if (optionOutputDir.isSet()) {
+      outputPath = Paths.get(optionOutputDir.getValue());
+    } else {
+      outputPath = Paths.get("./gen/");
+      printMessage("No output dir is set. Assuming '" + outputPath.toAbsolutePath().toString() + "'.");
+    }
+
+    if (outputPath.toFile().exists() && !outputPath.toFile().isDirectory()) {
+      printMessage("Output path '" + inputPath.toAbsolutePath().toString() + "' exists, but is not a directory. Exiting...");
+    }
+
+    printMessage("Running RelAST Preprocessor");
+
+    List<String> otherArgs = commandLine.getArguments();
+    if (!otherArgs.isEmpty()) {
+      printMessage("Unsupported arguments will be ignored: " + otherArgs);
+    }
+
+    Program program = parseProgram(inputPath);
+
+    printMessage("Writing output files");
+
+    for (GrammarFile grammarFile : program.getGrammarFileList()) {
+      // TODO decide and document what the file name should be, the full path or a simple name?
+      writeToFile(outputPath + grammarFile.getFileName() + "/Grammar.relast", grammarFile.generateAbstractGrammar());
+    }
+
+    writeToFile(outputPath + "/Grammar.relast", program.generateAbstractGrammar());
+    return 0;
+  }
+
+  private void printMessage(String message) {
+    System.out.println(message);
+  }
+
+  private void writeToFile(String filename, String str) throws CompilerException {
+    try {
+      PrintWriter writer = new PrintWriter(filename);
+      writer.print(str);
+      writer.close();
+    } catch (Exception e) {
+      throw new CompilerException("Could not write to file " + filename, e);
+    }
+  }
+
+  private void addOptions() {
+    optionOutputDir = addOption(new StringOption("outputDir", "target directory for the generated files."));
+    optionInputDir = addOption(new StringOption("inputDir", "input directory."));
+  }
+
+  private <OptionType extends Option<?>> OptionType addOption(OptionType option) {
+    options.add(option);
+    return option;
+  }
+
+  private Program parseProgram(Path inputPath) throws CompilerException {
+    Program program = new Program();
+
+    try (DirectoryStream<Path> stream = Files.newDirectoryStream(inputPath, "*.relast")) {
+      RelAstParser parser = new RelAstParser();
+      stream.forEach(path -> {
+        try (BufferedReader reader = Files.newBufferedReader(path)) {
+          RelAstScanner scanner = new RelAstScanner(reader);
+          GrammarFile inputGrammar = (GrammarFile) parser.parse(scanner);
+          inputGrammar.dumpTree(System.out);
+          program.addGrammarFile(inputGrammar);
+          inputGrammar.treeResolveAll();
+        } catch (IOException | Parser.Exception e) {
+          printMessage("Could not parse grammar file " + path);
+          e.printStackTrace();
+        }
+      });
+    } catch (IOException e) {
+      printMessage("Unable to iterate over input path '" + inputPath.toAbsolutePath().toString() + "'. Exiting...");
+      e.printStackTrace();
+      System.exit(-1);
+    }
+
+
+    return program;
+  }
+
+  protected int error(String message) {
+    System.err.println("Error: " + message);
+    System.err.println();
+    System.err.println("Usage: java -jar relast.jar [--option1] [--option2=value] ...  <filename1> <filename2> ... ");
+    System.err.println("Options:");
+    System.err.print(commandLine.printOptionHelp());
+    return 1;
+  }
+
+  public static class CompilerException extends Exception {
+    CompilerException(String message, Throwable cause) {
+      super(message, cause);
+    }
+  }
+}
+

src/main/java/org/jastadd/relast/compiler/Utils.java

+package org.jastadd.relast.compiler;
+
+import java.util.*;
+import java.util.function.Predicate;
+
+import static java.util.stream.Collectors.toList;
+
+public class Utils {
+  public static <T> List<T> filterToList(Collection<T> collection, Predicate<T> predicate) {
+    return collection.stream().filter(predicate).collect(toList());
+  }
+
+  public static <T> Set<T> asSet(T... t) {
+    return new HashSet<T>(Arrays.asList(t));
+  }
+}

src/main/java/org/jastadd/relast/compiler/options/CommandLine.java

+package org.jastadd.relast.compiler.options;
+
+import java.util.*;
+
+public class CommandLine {
+  private final Collection<Option<?>> options;
+  private final Map<String, Option<?>> mapping;
+  private final List<String> arguments;
+
+  public CommandLine(Collection<Option<?>> options) {
+    this.options = options;
+    this.mapping = new HashMap<>();
+    for (Option<?> option : options) {
+      mapping.put(option.getName(), option);
+    }
+    this.arguments = new ArrayList<>();
+  }
+
+  public void parse(String[] args) throws CommandLineException {
+    int i = 0;
+    while (i < args.length) {
+      if (args[i].startsWith(Option.PREFIX)) {
+        int argumentIndex = args[i].indexOf("=");
+        String name;
+        String argument = null;
+        if (argumentIndex > 0) {
+          name = args[i].substring(2, argumentIndex);
+          argument = args[i].substring(argumentIndex + 1);
+        } else {
+          name = args[i].substring(2);
+        }
+        Option<?> option = mapping.get(name);
+        if (option == null) {
+          throw new CommandLineException("Option " + Option.PREFIX + name + " not found");
+        }
+        match(option, argument);
+      } else {
+        arguments.add(args[i]);
+      }
+      i++;
+    }
+  }
+
+  public void match(Option<?> option, String argument) throws CommandLineException {
+    try {
+      switch (option.hasArgument()) {
+        case NO:
+          if (argument == null) {
+            option.match(null);
+          } else {
+            throw new CommandLineException("Option " + option + " is not allowed to have an argument");
+          }
+          break;
+        case OPTIONAL:
+          option.match(argument);
+          break;
+        case YES:
+          if (argument != null) {
+            option.match(argument);
+          } else {
+            throw new CommandLineException("Option " + option + " requires an argument");
+          }
+          break;
+      }
+    } catch (Option.IllegalMatchException e) {
+      throw new CommandLineException("Invalid value for option " + option + ": " + e.getMessage());
+    }
+  }
+
+  public List<String> getArguments() {
+    return arguments;
+  }
+
+  public String printOptionHelp() {
+    StringBuilder sb = new StringBuilder();
+    int longestOption = 0;
+    for (Option<?> option : options) {
+      if (longestOption < option.getName().length()) {
+        longestOption = option.getName().length();
+      }
+    }
+    for (Option<?> option : new TreeSet<>(options)) {
+      String s = String.format("  %s%-" + (longestOption + 6) + "s %s%n",
+          Option.PREFIX, option.getName(), option.getDescription());
+      sb.append(s);
+    }
+    return sb.toString();
+  }
+
+  public static class CommandLineException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    public CommandLineException(String message) {
+      super(message);
+    }
+  }
+}

src/main/java/org/jastadd/relast/compiler/options/EnumOption.java

+package org.jastadd.relast.compiler.options;
+
+import java.util.Collection;
+import java.util.TreeSet;
+
+public class EnumOption extends Option<String> {
+  private final TreeSet<String> allowedValues;
+  private final String defaultValue;
+  private String value;
+  private boolean isSet;
+
+  public EnumOption(String name, String description, Collection<String> allowedValues, String defaultValue) {
+    super(name, description);
+    this.allowedValues = new TreeSet<>(allowedValues);
+    this.defaultValue = defaultValue;
+    this.value = defaultValue;
+    this.isSet = false;
+  }
+
+  public boolean addAllowedValue(String allowedValue) {
+    return allowedValues.add(allowedValue);
+  }
+
+  @Override
+  public String getValue() {
+    return value;
+  }
+
+  @Override
+  public Option.HasArgument hasArgument() {
+    return Option.HasArgument.OPTIONAL;
+  }
+
+  @Override
+  public void match(String argument) throws IllegalMatchException {
+    if (argument == null) {
+      isSet = true;
+      value = defaultValue;
+    } else if (allowedValues.contains(argument)) {
+      isSet = true;
+      value = argument;
+    } else {
+      throw new IllegalMatchException(argument
+          + " is not allowed, allowed values are " + allowedValues);
+    }
+  }
+
+  @Override
+  public boolean isSet() {
+    return isSet;
+  }
+
+  @Override
+  public String getDescription() {
+    String allowedValuesStr = allowedValues.toString();
+    allowedValuesStr = allowedValuesStr.substring(1);
+    allowedValuesStr = allowedValuesStr.substring(0, allowedValuesStr.length() - 1);
+    return super.getDescription() + " (allowed values: " + allowedValuesStr + ")";
+  }
+}

src/main/java/org/jastadd/relast/compiler/options/FlagOption.java

+package org.jastadd.relast.compiler.options;
+
+public class FlagOption extends Option<Boolean> {
+  private boolean value;
+
+  public FlagOption(String name, String description) {
+    super(name, description);
+    value = false;
+  }
+
+  @Override
+  public Boolean getValue() {
+    return value;
+  }
+
+  @Override
+  public Option.HasArgument hasArgument() {
+    return Option.HasArgument.NO;
+  }
+
+  @Override
+  public void match(String string) throws IllegalMatchException {
+    value = true;
+  }
+
+  @Override
+  public boolean isSet() {
+    return getValue();
+  }
+}

src/main/java/org/jastadd/relast/compiler/options/Option.java

+package org.jastadd.relast.compiler.options;
+
+abstract public class Option<ValueType> implements Comparable<Option<?>> {
+  public final static String PREFIX = "--";
+  private final String name;
+  private final String description;
+
+  public Option(String name, String description) {
+    this.name = name;
+    this.description = description;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  @Override
+  public int compareTo(Option<?> o) {
+    return name.compareTo(o.name);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other instanceof Option) {
+      return compareTo((Option<?>) other) == 0;
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return PREFIX + name;
+  }
+
+  abstract public boolean isSet();
+
+  abstract public ValueType getValue();
+
+  abstract public HasArgument hasArgument();
+
+  abstract public void match(String input) throws IllegalMatchException;
+
+  public enum HasArgument {
+    NO,
+    OPTIONAL,
+    YES
+  }
+
+  public static class IllegalMatchException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    public IllegalMatchException(String message) {
+      super(message);
+    }
+  }
+}

src/main/java/org/jastadd/relast/compiler/options/StringOption.java

+package org.jastadd.relast.compiler.options;
+
+public class StringOption extends Option<String> {
+  private String value;
+  private boolean isSet;
+
+  public StringOption(String name, String description) {
+    this(name, description, "");
+  }
+
+  public StringOption(String name, String description, String defaultValue) {
+    super(name, description);
+    value = defaultValue;
+    isSet = false;
+  }
+
+  @Override
+  public String getValue() {
+    return value;
+  }
+
+  @Override
+  public Option.HasArgument hasArgument() {
+    return Option.HasArgument.YES;
+  }
+
+  @Override
+  public void match(String value) {
+    this.value = value;
+    isSet = true;
+  }
+
+  @Override
+  public boolean isSet() {
+    return isSet;
+  }
+}

src/main/resources/log4j2.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="INFO">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </Console>
+    </Appenders>
+    <Loggers>
+        <Root level="info">
+            <AppenderRef ref="Console"/>
+        </Root>
+    </Loggers>
+</Configuration>
\ No newline at end of file

src/test/java/org/jastadd/ros2rag/tests/RelAstTest.java

+package org.jastadd.ros2rag.tests;
+
+import org.jastadd.relast.compiler.Compiler;
+import org.jastadd.relast.compiler.options.CommandLine;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.nio.file.Paths;
+import java.util.Objects;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class RelAstTest {
+
+  void transform(String inputDir, String outputDir) throws CommandLine.CommandLineException, Compiler.CompilerException {
+
+    System.out.println("Running test in directory '" + Paths.get(".").toAbsolutePath() + "'.");
+    assertTrue(Paths.get(inputDir).toFile().exists(), "input directory does not exist");
+    assertTrue(Paths.get(inputDir).toFile().isDirectory(), "input directory is not a directory");
+
+    File outputDirFile = Paths.get(outputDir).toFile();
+    if (outputDirFile.exists()) {
+      assertTrue(outputDirFile.isDirectory());
+      if (Objects.requireNonNull(outputDirFile.list(), "Could not read output directory").length != 0) {
+        System.out.println("output directory is not empty!");
+      }
+    } else {
+      assertTrue(outputDirFile.mkdir());
+    }
+
+    String[] args = {
+        "--outputDir=" + outputDir,
+        "--inputDir=" + inputDir
+    };
+
+    new Compiler().run(args);
+  }
+
+  @Test
+  void transformMinimalExample() throws CommandLine.CommandLineException, Compiler.CompilerException {
+    transform("src/test/resources/in", "src/test/resources/out");
+  }
+}