diff --git a/build.gradle b/build.gradle
index f9795a4d764e618fb537cd37a57bf6a412d8267c..f9afaaf64eb1bc07821b85b8888dd4f183918f7b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,8 @@
+
+apply plugin: 'java'
apply plugin: 'jastadd'
apply plugin: 'application'
+apply plugin: "idea"
sourceCompatibility = 1.8
@@ -20,13 +23,11 @@ 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:${jackson_version}"
- compile "com.fasterxml.jackson.core:jackson-databind:${jackson_version}"
+ 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'
- compile group: 'org.apache.logging.log4j', name: 'log4j-api', version: '2.10.0'
- compile group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.10.0'
}
sourceSets {
@@ -52,6 +53,39 @@ jar {
}
}
+task relast(type: JavaExec) {
+ group = 'Build'
+ main = "-jar"
+
+ doFirst {
+ delete "src/gen/jastadd/*.ast"
+ delete "src/gen/jastadd/Ros2Rag.jadd"
+ delete "src/gen/jastadd/Ros2RagRefResolver.jadd"
+ delete "src/gen/jastadd/Ros2RagResolverStubs.jrag"
+ mkdir "src/gen/jastadd/"
+ }
+
+ args = [
+ "../libs/relast.jar",
+ "./src/main/jastadd/RelAst.relast",
+ "./src/main/jastadd/Ros2Rag.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"),
+ file("src/main/jastadd/Ros2Rag.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 {
@@ -65,10 +99,13 @@ jastadd {
}
jastadd {
- basedir "src/main/jastadd/"
- include "**/*.ast"
- include "**/*.jadd"
- include "**/*.jrag"
+ 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 {
@@ -106,6 +143,7 @@ jastadd {
scanner.genDir = "src/gen/java/org/jastadd/ros2rag/scanner"
parser.genDir = "src/gen/java/org/jastadd/ros2rag/parser"
- jastaddOptions = ["--lineColumnNumbers", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
+ jastaddOptions = ["--lineColumnNumbers", "--List=JastAddList", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
}
+generateAst.dependsOn relast
diff --git a/src/main/jastadd/Analysis.jrag b/src/main/jastadd/Analysis.jrag
index 21456331346ac897ee8f597c52e93c1ac8edb498..118dd2373e1fb883c829cb8867cb3d898f574e07 100644
--- a/src/main/jastadd/Analysis.jrag
+++ b/src/main/jastadd/Analysis.jrag
@@ -1,277 +1,3 @@
-import java.util.*;
+aspect Analysis {
-
-aspect TypeAnalysis {
- public abstract TypeUse Component.getTypeUse();
-
- //--- lookupType ---
- syn TypeDecl TypeUse.decl() = lookupType(getID());
- inh TypeDecl TypeUse.lookupType(String name);
- inh TypeDecl TypeDecl.lookupType(String name);
- eq Program.getChild().lookupType(String name) {
- for (TypeDecl td : getTypeDecls()) {
- if (td.getID().equals(name)) {
- return td;
- }
- }
- return null;
- }
-
- //--- isAlreadyDeclared ---
- syn boolean TypeDecl.isAlreadyDeclared() = lookupType(getID()) != this;
-}
-
-aspect ComponentAnalysis {
- //--- isTargetOfDirectedRelation ---
- inh boolean Component.isTargetOfDirectedRelation();
- eq Relation.getRight().isTargetOfDirectedRelation() = getDirection() instanceof RightDirection;
- eq Program.getChild().isTargetOfDirectedRelation() = false;
-
- //--- name ---
- syn String Component.name() = getID();
-
- //--- enclosingTypeDecl ---
- inh TypeDecl Component.enclosingTypeDecl();
- eq TypeDecl.getChild().enclosingTypeDecl() = this;
- eq Program.getChild().enclosingTypeDecl() = null;
-
- //--- otherSide ---
- inh RelationComponent RelationComponent.opposite();
- eq Relation.getLeft().opposite() = getRight();
- eq Relation.getRight().opposite() = getLeft();
- eq Program.getChild().opposite() = null;
-
- //--- ofTypeDecl ---
- syn TypeDecl RelationComponent.ofTypeDecl() = opposite().getTypeUse().decl();
-
- //--- isAlreadyDeclared ---
- /**
- * Check, if role with the same name is already declared on the same nonterminal
- */
- syn boolean RelationComponent.isAlreadyDeclared()
- = !isTargetOfDirectedRelation() /* if unnamed in relation, there is no role name, so no error */
- && getTypeUse().decl() != null /* nonterminal type of role is defined */
- && findComponent(getTypeUse().decl(), name()) != this; /* there is another role defined previously with the same name */
-
- //--- findComponent ---
- /** Search for either a component on the RHS of the given type with the given name,
- * or a relation part for the given type and a role with the given name */
- inh Component Component.findComponent(TypeDecl td, String name);
- eq Program.getChild().findComponent(TypeDecl td, String name)
- = findComponentSyn(td, name);
- syn Component Program.findComponentSyn(TypeDecl td, String name) {
- for (Component c: td.getComponents()) {
- if (c.name().equals(name)) {
- return c;
- }
- }
-
- for (Relation r : getRelations()) {
- if (r.getLeft().matches(td, name))
- return r.getLeft();
- if (r.getRight().matches(td, name))
- return r.getRight();
- }
-
- return null;
- }
-
- //--- isInvalidRedefinition ---
- /**
- * Check, if a component with the same name is already declared in some supertype
- */
- syn boolean Component.isInvalidRedefinition() = invalidRedefinition() != null;
-
- /**
- * Check, if a component with the same name is already declared in some supertype, and return it, if any
- */
- syn Component Component.invalidRedefinition() = null;
- eq TokenComponent.invalidRedefinition() = invalidRedefinitionOn(enclosingTypeDecl());
- eq RelationComponent.invalidRedefinition() = invalidRedefinitionOn(getTypeUse().decl());
-
- syn Component Component.invalidRedefinitionOn(TypeDecl td) {
- if (td == null) return null;
-
- while (td.hasSuper() && td.getSuper().decl() != null) {
- td = td.getSuper().decl();
- // find a matching component on the RHS of the (current) super type
- Component c = findComponent(td, getID());
-
- if (c != null && !this.isEqual(c)) return c;
- }
- return null;
- }
-
- //--- isEqual ---
- syn boolean Component.isEqual(Component c) = this.getClass() == c.getClass() && getTypeUse().isEqual(c.getTypeUse());
-
- /**
- * TokenComponents may be specialized by NTATokenComponents and vice versa
- */
- eq TokenComponent.isEqual(Component c) = (c instanceof TokenComponent) && getTypeUse().isEqual(c.getTypeUse());
-
- syn boolean TypeUse.isEqual(TypeUse u);
- eq SimpleTypeUse.isEqual(TypeUse u) = u instanceof SimpleTypeUse && getID().equals(u.getID());
- eq ParameterizedTypeUse.isEqual(TypeUse u) {
- if (!getID().equals(u.getID())) return false;
- if (!(u instanceof ParameterizedTypeUse)) return false;
- ParameterizedTypeUse pu = (ParameterizedTypeUse) u;
- if (getNumTypeUse() != pu.getNumTypeUse()) return false;
- for (int i = 0; i < getNumTypeUse(); i++) {
- if (!getTypeUse(i).isEqual(pu.getTypeUse(i))) return false;
- }
- return true;
- }
-
- //--- matches ---
- /**
- * @return true, if the component has both type and role, its type matches the given typeDecl and its name matches the given name
- */
- syn boolean RelationComponent.matches(TypeDecl td, String name)
- = !isTargetOfDirectedRelation() && getTypeUse().decl() == td && name().equals(name);
-
- //--- relationComponents ---
- coll Set<RelationComponent> TypeDecl.relationComponents()
- [new HashSet<RelationComponent>()]
- root Program;
- RelationComponent contributes this
- when !isTargetOfDirectedRelation() && getTypeUse().decl() != null
- to TypeDecl.relationComponents()
- for getTypeUse().decl();
-
- //--- relationComponentsTransitive ---
- syn Collection<RelationComponent> TypeDecl.relationComponentsTransitive() {
- Collection<RelationComponent> list = new ArrayList<>();
- if (hasSuper() && getSuper().decl() != null) {
- list.addAll(getSuper().decl().relationComponentsTransitive());
- }
- list.addAll(relationComponents());
- return list;
- }
-
- //--- oneRelationComponents ---
- syn Set<OneRelationComponent> TypeDecl.oneRelationComponents() {
- Set<OneRelationComponent> set = new HashSet<>();
- for (RelationComponent rc: relationComponents()) {
- if (rc instanceof OneRelationComponent) {
- set.add((OneRelationComponent) rc);
- }
- }
- return set;
- }
-
- //--- needUnresolvedClass ---
- syn boolean TypeDecl.needUnresolvedClass() {
- // a TypeDecl needs an unresolved class, if it can appear in a relation
- // TODO
- return true;
- }
-
- //--- isList ---
- syn boolean Component.isList() = false;
- eq ListComponent.isList() = true;
- eq NTAListComponent.isList() = true;
- eq ManyRelationComponent.isList() = true;
-
- //--- isOpt ---
- syn boolean Component.isOpt() = false;
- eq OptComponent.isOpt() = true;
- eq NTAOptComponent.isOpt() = true;
- eq OptionalRelationComponent.isOpt() = true;
-
- //--- isNullable ---
- syn boolean Component.isNullable() = false;
- eq TokenComponent.isNullable() = !"float double int short long char byte boolean".contains(getTypeUse().getID());
-}
-
-aspect InstanceSupplier {
-
- //--- program ---
- inh Program TypeDecl.program();
- eq Program.getTypeDecl(int i).program() = this;
-
- //--- subTypeDecls ---
- syn Collection<TypeDecl> TypeDecl.subTypeDecls() {
- Collection<TypeDecl> subDecls = new ArrayList();
- for (TypeDecl decl : program().getTypeDeclList()) {
- if (decl.hasSuper() && decl.getSuper().getID().equals(getID())) {
- subDecls.add(decl);
- }
- }
- return subDecls;
- }
-
- //--- instantiableSubType ---
- syn TypeDecl TypeDecl.instantiableSubType() {
- if (getAbstract() == false) {
- return this;
- } else {
- for (TypeDecl sub : subTypeDecls()) {
- if (sub.getAbstract() == false) {
- return sub;
- } else {
- TypeDecl subInstance = sub.instantiableSubType();
- if (subInstance != null) {
- return subInstance;
- }
- }
- }
- }
- return null;
- }
-}
-
-aspect Constructors {
- //--- componentsTransitive ---
- syn Collection<Component> TypeDecl.componentsTransitive() {
- ArrayList<Component> list = new ArrayList<>();
- if (hasSuper() && getSuper().decl() != null) {
- list.addAll(getSuper().decl().componentsTransitive());
- }
- for (Component c: getComponents()) {
- if (c.inConstructor()) {
- list.add(c);
- }
- }
- return list;
- }
-
- //--- needsConstructor ---
- syn boolean TypeDecl.needsConstructor() = !componentsTransitive().isEmpty() && !relationComponentsTransitive().isEmpty();
-
- //--- inConstructor ---
- /**
- * @return true, if the component should be added to the constructor (i.e., is not an NTA)
- */
- syn boolean Component.inConstructor() = true;
- eq NTAComponent.inConstructor() = false;
- eq NTAOptComponent.inConstructor() = false;
- eq NTAListComponent.inConstructor() = false;
- eq NTATokenComponent.inConstructor() = false;
-}
-
-aspect Utils {
-
- //--- toString ---
- public String SimpleTypeUse.toString() {
- return getID();
- }
- public String ParameterizedTypeUse.toString() {
- StringBuilder sb = new StringBuilder();
- sb.append(getID()).append("<");
- boolean first = true;
- for (TypeUse u: getTypeUses()) {
- if (first) {
- first = false;
- } else {
- sb.append(", ");
- }
- sb.append(u.toString());
- }
- sb.append(">");
- return sb.toString();
- }
- public String TypeDecl.toString() {
- return getID();
- }
}
diff --git a/src/main/jastadd/DumpTree.jrag b/src/main/jastadd/DumpTree.jrag
index 2d2f3403c7c03738cd6ff6e4351d22dadc440988..0c119fd24a42983e26c16b9056611571a6e61f8a 100644
--- a/src/main/jastadd/DumpTree.jrag
+++ b/src/main/jastadd/DumpTree.jrag
@@ -33,7 +33,7 @@ aspect DumpTree {
public String ASTNode.extraDumpInfo() { return ""; }
public String ASTNode.getTokens() {
- java.util.TreeSet<java.lang.reflect.Method> methods = new java.util.TreeSet<>(Comparator.comparing(java.lang.reflect.Method::getName));
+ 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()));
diff --git a/src/main/jastadd/Errors.jrag b/src/main/jastadd/Errors.jrag
index b1ec073575e4ea6c15e924c1f6c6b95eeaba2cba..60bdf24708ed6b26bd1094bff8185ff07de62fe3 100644
--- a/src/main/jastadd/Errors.jrag
+++ b/src/main/jastadd/Errors.jrag
@@ -1,138 +1,65 @@
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.LinkedList;
-
-aspect Errors {
- coll Set<ErrorMessage> Program.errors()
- [new TreeSet<ErrorMessage>()]
- root Program;
-
- TypeUse contributes error("Type '" + getID() + "' not found")
- when decl() == null && !isToken()
- to Program.errors();
-
- TypeDecl contributes error("Type '" + getID() + "' is already declared")
- when isAlreadyDeclared()
- to Program.errors();
-
- RelationComponent contributes error("Role '" + name()
- + "' is already declared for type '" + getTypeUse().decl() + "'")
- when isAlreadyDeclared()
- to Program.errors();
-
- RelationComponent contributes error("Role '" + name()
- + "' is an invalid redefinition for type '" + getTypeUse().decl() + "', conflicts with supertype '"
- + invalidRedefinition().enclosingTypeDecl() + "'")
- when isInvalidRedefinition()
- to Program.errors();
-
- TokenComponent contributes error("Token '" + name()
- + "' is an invalid redefinition for type '" + enclosingTypeDecl() + "', conflicts with supertype '"
- + invalidRedefinition().enclosingTypeDecl() + "'")
- when isInvalidRedefinition()
- to Program.errors();
-
- RelationComponent contributes
- error("Role name missing for type '" + getTypeUse().decl() + "'")
- when !isTargetOfDirectedRelation() && name().isEmpty()
- to Program.errors();
-
- RelationComponent contributes
- error("The target of a directed relation cannot have a role name")
- when isTargetOfDirectedRelation() && !getID().isEmpty()
- to Program.errors();
-
- RelationComponent contributes
- error("The target of a directed relation may only have multiplicity 1")
- when isTargetOfDirectedRelation() && !multiplicityOne()
- to Program.errors();
-}
-
-aspect HelpAttributes {
- inh Program ASTNode.program();
- eq Program.getChild().program() = this;
-
- inh boolean TypeUse.isToken();
- eq Program.getChild().isToken() = false;
- eq TokenComponent.getTypeUse().isToken() = true;
-
- syn boolean RelationComponent.multiplicityOne() = false;
- eq OneRelationComponent.multiplicityOne() = true;
- syn boolean RelationComponent.multiplicityOpt() = false;
- eq OptionalRelationComponent.multiplicityOpt() = true;
- syn boolean RelationComponent.multiplicityMany() = false;
- eq ManyRelationComponent.multiplicityMany() = true;
-
- inh ContainedInFile Component.enclosingFileContainer();
- eq TypeDecl.getComponent().enclosingFileContainer() = this;
- eq Relation.getChild().enclosingFileContainer() = this;
- inh ContainedInFile TypeUse.enclosingFileContainer();
- eq SimpleTypeComponent.getTypeUse().enclosingFileContainer() = enclosingFileContainer();
- eq TokenComponent.getTypeUse().enclosingFileContainer() = enclosingFileContainer();
- eq TypeDecl.getSuper().enclosingFileContainer() = this;
-
- syn String ASTNode.containedFile() = "Unknown";
- eq Component.containedFile() = enclosingFileContainer() == null ? "Unknown2" : enclosingFileContainer().containedFile();
- eq TypeUse.containedFile() = enclosingFileContainer() == null ? "Unknown3" : enclosingFileContainer().containedFile();
- eq TypeDecl.containedFile() = getFileName();
- eq Relation.containedFile() = getFileName();
-}
-
-aspect ErrorMessage {
- public class ErrorMessage implements Comparable<ErrorMessage> {
- private final ASTNode node;
- private final String filename;
- private final int line;
- private final int col;
- private final String message;
-
- public ErrorMessage(ASTNode node, String message) {
- this.node = node;
- this.filename = node.containedFile();
- this.line = node.getStartLine();
- this.col = node.getStartColumn();
- this.message = message;
- }
-
- public ASTNode getNode() {
- return node;
- }
- public int getLine() {
- return line;
- }
- public int getCol() {
- return col;
- }
- public String getMessage() {
- return message;
- }
-
- public String toString() {
- return filename + " Line " + line + ", column " + col + ": " + message;
- }
-
- @Override
- public int compareTo(ErrorMessage err) {
- int n = filename.compareTo(err.filename);
- if (n != 0) {
- return n;
- }
-
- n = line - err.line;
- if (n != 0) {
- return n;
- }
-
- n = col-err.col;
- if (n != 0) {
- return n;
- }
-
- return message.compareTo(err.message);
- }
- }
-
- protected ErrorMessage ASTNode.error(String message) {
- return new ErrorMessage(this, message);
- }
-}
+//import java.util.Set;
+//import java.util.TreeSet;
+//import java.util.LinkedList;
+//
+//
+//
+//
+//aspect ErrorMessage {
+// public class ErrorMessage implements Comparable<ErrorMessage> {
+// private final ASTNode node;
+// private final String filename;
+// private final int line;
+// private final int col;
+// private final String message;
+//
+// public ErrorMessage(ASTNode node, String message) {
+// this.node = node;
+// this.filename = node.containedFile().getFileName();
+// this.line = node.getStartLine();
+// this.col = node.getStartColumn();
+// this.message = message;
+// }
+//
+// public ASTNode getNode() {
+// return node;
+// }
+// public int getLine() {
+// return line;
+// }
+// public int getCol() {
+// return col;
+// }
+// public String getMessage() {
+// return message;
+// }
+//
+// public String toString() {
+// return filename + " Line " + line + ", column " + col + ": " + message;
+// }
+//
+// @Override
+// public int compareTo(ErrorMessage err) {
+// int n = filename.compareTo(err.filename);
+// if (n != 0) {
+// return n;
+// }
+//
+// n = line - err.line;
+// if (n != 0) {
+// return n;
+// }
+//
+// n = col-err.col;
+// if (n != 0) {
+// return n;
+// }
+//
+// return message.compareTo(err.message);
+// }
+// }
+//
+// protected ErrorMessage ASTNode.error(String message) {
+// return new ErrorMessage(this, message);
+// }
+//}
diff --git a/src/main/jastadd/NameResolution.jrag b/src/main/jastadd/NameResolution.jrag
new file mode 100644
index 0000000000000000000000000000000000000000..ed0cbd6035364a52319986269807db5bcbbf6eb5
--- /dev/null
+++ b/src/main/jastadd/NameResolution.jrag
@@ -0,0 +1,15 @@
+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.");
+ }
+
+
+}
diff --git a/src/main/jastadd/Navigation.jrag b/src/main/jastadd/Navigation.jrag
new file mode 100644
index 0000000000000000000000000000000000000000..b6028726b4406353f1acb0711d69ff66c509d661
--- /dev/null
+++ b/src/main/jastadd/Navigation.jrag
@@ -0,0 +1,28 @@
+aspect Navigation {
+
+ inh Program ASTNode.program();
+ eq Program.getChild().program() = this;
+
+ coll java.util.Set<TypeDecl> Program.typeDecls() [new java.util.HashSet<>()] root Program;
+ TypeDecl contributes this
+ to Program.typeDecls()
+ for program();
+
+ coll java.util.Set<Relation> Program.relations() [new java.util.HashSet<>()] root Program;
+ Relation contributes this
+ to Program.relations()
+ for program();
+
+ inh TypeDecl Component.containingTypeDecl();
+ eq TypeDecl.getChild().containingTypeDecl() = this;
+
+// syn boolean RelationComponent.multiplicityOne() = false;
+// eq OneRelationComponent.multiplicityOne() = true;
+// syn boolean RelationComponent.multiplicityOpt() = false;
+// eq OptionalRelationComponent.multiplicityOpt() = true;
+// syn boolean RelationComponent.multiplicityMany() = false;
+// eq ManyRelationComponent.multiplicityMany() = true;
+
+ inh GrammarFile ASTNode.containedFile();
+ eq GrammarFile.getChild().containedFile() = this;
+}
diff --git a/src/main/jastadd/RelAst.ast b/src/main/jastadd/RelAst.ast
deleted file mode 100644
index 31083b99eda970809f5f61e6e44a8e4fb23d1a68..0000000000000000000000000000000000000000
--- a/src/main/jastadd/RelAst.ast
+++ /dev/null
@@ -1,28 +0,0 @@
-Program ::= TypeDecl* Relation*;
-abstract ContainedInFile ::= <FileName> ;
-TypeDecl : ContainedInFile ::= <ID> <Abstract:boolean> [Super:TypeUse] Component*;
-
-abstract Component ::= <ID>;
-abstract SimpleTypeComponent : Component ::= TypeUse:SimpleTypeUse;
-NormalComponent : SimpleTypeComponent;
-ListComponent : SimpleTypeComponent;
-OptComponent : SimpleTypeComponent;
-NTAComponent : SimpleTypeComponent;
-NTAOptComponent : SimpleTypeComponent;
-NTAListComponent : SimpleTypeComponent;
-TokenComponent : Component ::= TypeUse;
-NTATokenComponent : TokenComponent ::= TypeUse;
-
-abstract TypeUse ::= <ID>;
-SimpleTypeUse : TypeUse;
-ParameterizedTypeUse : TypeUse ::= TypeUse*;
-
-Relation : ContainedInFile ::= Left:RelationComponent Direction Right:RelationComponent;
-abstract RelationComponent : SimpleTypeComponent;
-OneRelationComponent : RelationComponent;
-OptionalRelationComponent : RelationComponent;
-ManyRelationComponent : RelationComponent;
-abstract Direction;
-RightDirection : Direction;
-LeftDirection : Direction;
-Bidirectional : Direction;
diff --git a/src/main/jastadd/RelAst.flex b/src/main/jastadd/RelAst.flex
index 4fc2773b90da327133afbeead5533ceac9fc0184..b0a3fd2e5ad19d90580960340bd7b99b35a1897a 100644
--- a/src/main/jastadd/RelAst.flex
+++ b/src/main/jastadd/RelAst.flex
@@ -44,7 +44,7 @@ ID = [a-zA-Z$_][a-zA-Z0-9$_]*
%%
{WhiteSpace} { /* ignore */ }
-{Comment} { /* ignore */ }
+{Comment} { return sym(Terminals.COMMENT); }
"abstract" { return sym(Terminals.ABSTRACT); }
"rel" { return sym(Terminals.RELATION); }
diff --git a/src/main/jastadd/RelAst.parser b/src/main/jastadd/RelAst.parser
index 12a7044e722f07ebce04c83fb4f37dc0a3f15c13..f94fbef474825bbd669f89ce070b2ce8fc406c72 100644
--- a/src/main/jastadd/RelAst.parser
+++ b/src/main/jastadd/RelAst.parser
@@ -1,123 +1,218 @@
-Program goal =
- /* empty */ {: return new Program(); :}
- | type_decl.t goal.p {: p.getTypeDeclList().insertChild(t, 0); return p; :}
- | relation.r goal.p {: p.getRelationList().insertChild(r, 0); return p; :}
- ;
+GrammarFile goal
+ = declaration.d goal.p {: p.getDeclarationList().insertChild(d, 0); return p; :}
+ | {: return new GrammarFile(); :}
+;
-TypeDecl type_decl =
- ID type_decl_super.s components_opt.c SCOL
+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.setID(ID);
+ result.setName(ID);
result.setAbstract(false);
- result.setSuperOpt(s);
result.setComponentList(c);
return result;
:}
- | ABSTRACT ID type_decl_super.s components_opt.c SCOL
- {:
- TypeDecl result = new TypeDecl();
- result.setID(ID);
- result.setAbstract(true);
- result.setSuperOpt(s);
- result.setComponentList(c);
- return result;
- :}
- ;
-
-Opt type_decl_super =
- /* empty */ {: return new Opt(); :}
- | COL s_type_use.u {: return new Opt(u); :}
- ;
-
-SimpleTypeUse s_type_use =
- ID {: return new SimpleTypeUse(ID); :}
- ;
-
-ArrayList inner_type_use
- = ID
- | inner_type_use DOT ID
- ;
-
-TypeUse type_use =
- parameterized_type_use.p {: return p; :}
- | inner_type_use.p {: return new SimpleTypeUse((String)p.stream().map( x -> ((Symbol)x).value.toString()).collect(java.util.stream.Collectors.joining("."))); :}
- ;
-ParameterizedTypeUse parameterized_type_use =
- inner_type_use.i LT type_use_list.l GT {: return new ParameterizedTypeUse((String)i.stream().map( x -> ((Symbol)x).value.toString()).collect(java.util.stream.Collectors.joining(".")), l); :}
- ;
-List type_use_list =
- type_use.u {: return new List().add(u); :}
- | type_use_list.l COMMA type_use.u {: return l.add(u); :}
- ;
-
-List components_opt =
- /* empty */ {: return new List(); :}
+ | 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; :}
- ;
+;
-List components =
- /* empty */ {: return new List(); :}
+JastAddList components
+ = /* empty */ {: return new JastAddList(); :}
| components.l component.c {: return l.add(c); :}
- ;
-
-Component component =
- ID COL s_type_use.u {: return new NormalComponent(ID, u); :}
- | s_type_use.u {: return new NormalComponent(u.getID(), u); :}
- // List
- | ID COL s_type_use.u STAR {: return new ListComponent(ID, u); :}
- | s_type_use.u STAR {: return new ListComponent(u.getID(), u); :}
- // Opt
- | LBRACKET ID COL s_type_use.u RBRACKET {: return new OptComponent(ID, u); :}
- | LBRACKET s_type_use.u RBRACKET {: return new OptComponent(u.getID(), u); :}
- // NTA list
- | SLASH ID COL s_type_use.u STAR SLASH {: return new NTAListComponent(ID, u); :}
- | SLASH s_type_use.u STAR SLASH {: return new NTAListComponent(u.getID(), u); :}
- // NTA opt
- | SLASH LBRACKET ID COL s_type_use.u RBRACKET SLASH {: return new NTAOptComponent(ID, u); :}
- | SLASH LBRACKET s_type_use.u RBRACKET SLASH {: return new NTAOptComponent(u.getID(), u); :}
- // NTA
- | SLASH ID COL s_type_use.u SLASH {: return new NTAComponent(ID, u); :}
- | SLASH s_type_use.u SLASH {: return new NTAComponent(u.getID(), u); :}
- // NTA Token (same as NTA)
- | SLASH LT ID COL s_type_use.u GT SLASH {: return new NTATokenComponent(ID, u); :}
- | SLASH LT ID GT SLASH {: return new NTATokenComponent(ID, new SimpleTypeUse("String")); :}
- // Token
- | LT ID COL type_use.u GT {: return new TokenComponent(ID, u); :}
- | LT ID GT {: return new TokenComponent(ID, new SimpleTypeUse("String")); :}
- ;
-
-Relation relation =
- RELATION relation_comp.l direction relation_comp.r SCOL
- {:
- Relation result = new Relation();
- if (direction instanceof LeftDirection) {
- result.setLeft(r);
- result.setDirection(new RightDirection());
- result.setRight(l);
- } else {
- result.setLeft(l);
- result.setDirection(direction);
- result.setRight(r);
- }
- return result;
- :}
- ;
-
-RelationComponent relation_comp =
- // One
- s_type_use.u DOT ID {: return new OneRelationComponent(ID, u); :}
- | s_type_use.u {: return new OneRelationComponent("", u); :}
- // Optional
- | s_type_use.u DOT ID QUESTION_MARK {: return new OptionalRelationComponent(ID, u); :}
- | s_type_use.u QUESTION_MARK {: return new OptionalRelationComponent("", u); :}
- // Many
- | s_type_use.u DOT ID STAR {: return new ManyRelationComponent(ID, u); :}
- | s_type_use.u STAR {: return new ManyRelationComponent("", u); :}
- ;
-
-Direction direction =
- RIGHT {: return new RightDirection(); :}
- | LEFT {: return new LeftDirection(); :}
- | BIDIRECTIONAL {: return new Bidirectional(); :}
- ;
+;
+
+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;
+ :}
+;
diff --git a/src/main/jastadd/RelAst.relast b/src/main/jastadd/RelAst.relast
new file mode 100644
index 0000000000000000000000000000000000000000..2168413aef3510a889a1a2ea3f71ea4624938f1c
--- /dev/null
+++ b/src/main/jastadd/RelAst.relast
@@ -0,0 +1,49 @@
+
+
+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>;
diff --git a/src/main/jastadd/Ros2Rag.ast b/src/main/jastadd/Ros2Rag.ast
deleted file mode 100644
index 3e88bb7e66ce2c2ecee71df70d03289ec0ca12e6..0000000000000000000000000000000000000000
--- a/src/main/jastadd/Ros2Rag.ast
+++ /dev/null
@@ -1,10 +0,0 @@
-Ros2Rag ::= MappingDefinition* SyncDefinition* Program; //MqttRoot ;
-
-abstract SyncDefinition ::= <AlwaysApply:Boolean> ;
-abstract TokenWritingSyncDefinition : SyncDefinition ::= TargetType:SimpleTypeUse <TargetChild> ;
-UpdateDefinition : TokenWritingSyncDefinition ::= <SourceAttribute> [MappingDefinitionUse] ;
-ReadFromMqttDefinition : TokenWritingSyncDefinition ::= [MappingDefinitionUse] ;
-WriteToMqttDefinition : SyncDefinition ::= SourceType:SimpleTypeUse <SourceChild> [MappingDefinitionUse] ;
-
-MappingDefinition ::= <ID> From:SimpleTypeUse To:SimpleTypeUse <Content> ;
-MappingDefinitionUse ::= <ID> ;
diff --git a/src/main/jastadd/Ros2Rag.relast b/src/main/jastadd/Ros2Rag.relast
new file mode 100644
index 0000000000000000000000000000000000000000..fb737a8cb950588c404f71181f2bb42c0077beb5
--- /dev/null
+++ b/src/main/jastadd/Ros2Rag.relast
@@ -0,0 +1,16 @@
+Ros2Rag ::= MappingDefinition* SyncDefinition* Program;
+
+abstract SyncDefinition ::= <AlwaysApply:Boolean> ;
+
+rel SyncDefinition.Mapping? -> MappingDefinition;
+
+abstract TokenSyncDefinition : SyncDefinition;
+rel TokenSyncDefinition.token -> TokenComponent;
+
+ReadFromMqttDefinition : TokenSyncDefinition;
+WriteToMqttDefinition : TokenSyncDefinition;
+
+MappingDefinition ::= <ID> <Content> ;
+
+rel MappingDefinition.from -> TypeDecl;
+rel MappingDefinition.to -> TypeDecl;
diff --git a/src/main/jastadd/backend/AbstractGrammar.jadd b/src/main/jastadd/backend/AbstractGrammar.jadd
index a196370bb8fba8baf749eee185f4193dbd3ae5fc..606be6ea329fe361b1784e88489f6e34ac81ed1b 100644
--- a/src/main/jastadd/backend/AbstractGrammar.jadd
+++ b/src/main/jastadd/backend/AbstractGrammar.jadd
@@ -11,95 +11,161 @@ aspect BackendAbstractGrammar {
return sb.toString();
}
- public void Program.generateAbstractGrammar(StringBuilder sb) {
- for (TypeDecl td: getTypeDecls()) {
- td.generateAbstractGrammar(sb);
+ public void Program.generateAbstractGrammar(StringBuilder b) {
+ for (GrammarFile file : getGrammarFileList()) {
+ file.generateAbstractGrammar(b);
}
}
- public void TypeDecl.generateAbstractGrammar(StringBuilder sb) {
+ public void GrammarFile.generateAbstractGrammar(StringBuilder b) {
+ b.append("// Grammar for file ").append(getFileName()).append("\n");
+ super.generateAbstractGrammar(b);
+ b.append("\n");
+ }
+
+ 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()) {
- sb.append("abstract ");
+ b.append("abstract ");
}
- sb.append(getID());
- if (hasSuper()) {
- sb.append(" : " + getSuper());
+ b.append(getName()).append(" ");
+ if (hasSuperType()) {
+ b.append(": ").append(getSuperType().getName()).append(" ");
}
-
- if (getNumComponent() > 0 || relationComponents().size() > 0) {
- sb.append(" ::=");
+ b.append("::=");
+ for (Component component : getComponentList()) {
+ b.append(" ");
+ component.generateAbstractGrammar(b);
}
- for (Component c: getComponents()) {
- sb.append(" ");
- sb.append(c.generateAbstractGrammar());
+ b.append(";\n");
+ }
+
+ public abstract void Component.generateAbstractGrammar(StringBuilder b);
+
+ public void NormalComponent.generateAbstractGrammar(StringBuilder b) {
+ if (getNTA()) {
+ b.append("/");
}
- sb.append(";\n");
+ if (!getName().equals("")) {
+ b.append(getName()).append(":");
+ }
+ b.append(getTypeDecl().getName());
+ if (getNTA()) {
+ b.append("/");
+ }
}
- public String Component.generateAbstractGrammar() {
- if (getID().equals(getTypeUse().toString())) {
- return getTypeUse().toString();
- } else {
- return getID() + ":" + getTypeUse();
+ 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 String ListComponent.generateAbstractGrammar() {
- return super.generateAbstractGrammar() + "*";
- }
- public String OptComponent.generateAbstractGrammar() {
- return "[" + super.generateAbstractGrammar() + "]";
- }
- public String NTAComponent.generateAbstractGrammar() {
- return "/" + super.generateAbstractGrammar() + "/";
- }
- public String NTAListComponent.generateAbstractGrammar() {
- return "/" + super.generateAbstractGrammar() + "*/";
- }
- public String NTAOptComponent.generateAbstractGrammar() {
- return "/[" + super.generateAbstractGrammar() + "]/";
- }
- public String TokenComponent.generateAbstractGrammar() {
- return "<" + getID() + ":" + getTypeUse() + ">";
+
+ 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 String NTATokenComponent.generateAbstractGrammar() {
- return "/<" + getID() + ":" + getTypeUse() + ">/";
+
+ 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("/");
+ }
}
- public String Relation.generateAbstractGrammar() {
- return "rel "
- + getLeft().generateAbstractGrammar() + " "
- + getDirection().generateAbstractGrammar() + " "
- + getRight().generateAbstractGrammar();
+ abstract public void JavaTypeUse.generateAbstractGrammar(StringBuilder b);
+
+ public void SimpleJavaTypeUse.generateAbstractGrammar(StringBuilder b) {
+ b.append(getName());
}
- public String RelationComponent.generateAbstractGrammar() {
- if (getID().isEmpty()) {
- return getTypeUse().toString();
- } else {
- return getTypeUse() + "." + getID();
+ 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(">");
}
- public String OptionalRelationComponent.generateAbstractGrammar() {
- return super.generateAbstractGrammar() + "?";
+ 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 String ManyRelationComponent.generateAbstractGrammar() {
- return super.generateAbstractGrammar() + "*";
+ public void BidirectionalRelation.generateAbstractGrammar(StringBuilder b) {
+ b.append("rel ");
+ getLeft().generateAbstractGrammar(b);
+ b.append(" <-> ");
+ getRight().generateAbstractGrammar(b);
+ b.append(";\n");
}
- abstract public String Direction.generateAbstractGrammar();
- public String RightDirection.generateAbstractGrammar() {
- return "->";
+ 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 String LeftDirection.generateAbstractGrammar() {
- return "<-";
+ public void OptRole.generateAbstractGrammar(StringBuilder b) {
+ b.append(getType().getName()).append(".").append(getName()).append("?");
}
- public String Bidirectional.generateAbstractGrammar() {
- return "<->";
+ public void UnnamedRole.generateAbstractGrammar(StringBuilder b) {
+ b.append(getType().getName());
}
+
}
diff --git a/src/main/jastadd/backend/Aspect.jadd b/src/main/jastadd/backend/Aspect.jadd
index 71491c9fb4d7dce4f70d14990f05f15c8588bd4a..c63ec13624c2c10589b070917eea9cc7fba2fa0e 100644
--- a/src/main/jastadd/backend/Aspect.jadd
+++ b/src/main/jastadd/backend/Aspect.jadd
@@ -39,10 +39,10 @@ aspect Aspect {
}
abstract void SyncDefinition.generateAspect(StringBuilder sb);
- @Override
- void UpdateDefinition.generateAspect(StringBuilder sb) {
- // TODO
- }
+// @Override
+// void UpdateDefinition.generateAspect(StringBuilder sb) {
+// // TODO
+// }
// will be "addConnectionJoint_CurrentPosition" in example
/* // see discussion in codimd (InstanceLocation), why this won't work here
@@ -60,14 +60,22 @@ aspect Aspect {
void ReadFromMqttDefinition.generateAspect(StringBuilder sb) {
sb.append("public void ").append("type").append(".connectTo(String topic) {\n")
.append(aspectIndent).append("mqttUpdater().addConnection")
- .append(getTargetType().getID()).append("_")
- .append(getTargetChild())
+ .append(getToken().containingTypeDecl().getName())
+ .append("_")
+ .append(getToken().getName())
.append("(this, topic);\n")
.append("}\n");
}
@Override
void WriteToMqttDefinition.generateAspect(StringBuilder sb) {
- // TODO
+ sb.append("public void ").append("type").append(".connectTo(String topic) {\n")
+ .append(aspectIndent).append("mqttUpdater().addConnection")
+ .append(getToken().containingTypeDecl().getName())
+ .append("_")
+ .append(getToken().getName())
+ .append("(this, topic);\n")
+ .append("}\n");
}
+
}
diff --git a/src/main/java/org/jastadd/ros2rag/compiler/Compiler.java b/src/main/java/org/jastadd/ros2rag/compiler/Compiler.java
index a56a1264c9bc071d0da9532473586d35fce49bf8..1ba4fbb8531fa35b50f676252f5731e6a6be3e0d 100644
--- a/src/main/java/org/jastadd/ros2rag/compiler/Compiler.java
+++ b/src/main/java/org/jastadd/ros2rag/compiler/Compiler.java
@@ -1,10 +1,7 @@
package org.jastadd.ros2rag.compiler;
import beaver.Parser;
-import org.jastadd.ros2rag.ast.ErrorMessage;
-import org.jastadd.ros2rag.ast.Program;
-import org.jastadd.ros2rag.ast.Relation;
-import org.jastadd.ros2rag.ast.TypeDecl;
+import org.jastadd.ros2rag.ast.*;
import org.jastadd.ros2rag.compiler.options.CommandLine;
import org.jastadd.ros2rag.compiler.options.CommandLine.CommandLineException;
import org.jastadd.ros2rag.compiler.options.Option;
@@ -46,19 +43,9 @@ public class Compiler {
List<String> filenames = commandLine.getArguments();
Program p = parseProgram(filenames);
+ writeToFile(outputDir + "/Grammar.ast", p.generateAbstractGrammar());
+ writeToFile(outputDir + "/ROS2RAG.jadd", p.generateAspect());
- if (!p.errors().isEmpty()) {
- System.err.println("Errors:");
- for (ErrorMessage e : p.errors()) {
- System.err.println(e);
- }
- System.exit(1);
- } else {
-
- writeToFile(outputDir + "/Grammar.ast", p.generateAbstractGrammar());
- writeToFile(outputDir + "/ROS2RAG.jadd", p.generateAspect());
-
- }
}
@@ -110,6 +97,7 @@ public class Compiler {
parse(program, reader, fileName);
}
+ program.treeResolveAll();
return program;
}
@@ -118,15 +106,8 @@ public class Compiler {
RelAstParser parser = new RelAstParser();
try {
- Program newProgram = (Program) parser.parse(scanner);
- for (TypeDecl typeDecl : newProgram.getTypeDeclList()) {
- typeDecl.setFileName(file);
- program.addTypeDecl(typeDecl);
- }
- for (Relation relation : newProgram.getRelationList()) {
- relation.setFileName(file);
- program.addRelation(relation);
- }
+ GrammarFile newFile = (GrammarFile) parser.parse(scanner);
+ program.addGrammarFile(newFile);
} catch (IOException e) {
error(e.getMessage());
} catch (Parser.Exception e) {
diff --git a/src/main/java/org/jastadd/ros2rag/compiler/SimpleMain.java b/src/main/java/org/jastadd/ros2rag/compiler/SimpleMain.java
index e31a423afb7367177695dac5501c807b9382e89e..ae2b4a0312f43c3c82df5ff0d1f477e8888a25b4 100644
--- a/src/main/java/org/jastadd/ros2rag/compiler/SimpleMain.java
+++ b/src/main/java/org/jastadd/ros2rag/compiler/SimpleMain.java
@@ -51,8 +51,8 @@ public class SimpleMain {
MappingDefinition mappingDefinition = new MappingDefinition();
mappingDefinition.setID("PoseToPosition");
- mappingDefinition.setFrom(new SimpleTypeUse("PBPose"));
- mappingDefinition.setTo(new SimpleTypeUse("Position"));
+ mappingDefinition.setFrom(TypeDecl.createRef("PBPose"));
+ mappingDefinition.setTo(TypeDecl.createRef("Position"));
mappingDefinition.setContent(" pose.position.x += sqrt(.5 * size.x)\n" +
" MAP round(2)\n" +
" x = x / 100\n" +
@@ -62,11 +62,12 @@ public class SimpleMain {
ReadFromMqttDefinition readFromMqttDefinition = new ReadFromMqttDefinition();
readFromMqttDefinition.setAlwaysApply(false);
- readFromMqttDefinition.setTargetType(new SimpleTypeUse("Joint"));
- readFromMqttDefinition.setTargetChild("CurrentPosition");
- readFromMqttDefinition.setMappingDefinitionUse(new MappingDefinitionUse("PoseToPosition"));
+ readFromMqttDefinition.setToken(TokenComponent.createRef("Joint.CurrentPosition"));
+ readFromMqttDefinition.setMapping(mappingDefinition);
model.addSyncDefinition(readFromMqttDefinition);
+ model.treeResolveAll();
+
System.out.println(model.generateAspect());
}