diff --git a/Parser/Makefile b/Parser/Makefile
index ec6608ba0ed3eff06d8168d56753373def4ba545..27b7fb61e9b91c25611ae7d8b9b9baedaacc189a 100644
--- a/Parser/Makefile
+++ b/Parser/Makefile
@@ -11,7 +11,7 @@ jastadd: ast
rm -f src-gen/org/tud/forty/ast/*
sed -i 's|class PrettyPrint|aspect PrettyPrint|' spec/Printing.jadd
sed -i 's|class PrettyPrint|aspect PrettyPrint|' spec/OmpPrinting.jadd
- cd src-gen; java -jar ../tools/jastadd/jastadd2.jar --package="org.tud.forty.ast" --indent='2space' --rewrite=regular ../spec-gen/*.ast ../spec/*.jadd ../spec/*.jrag
+ cd src-gen; java -jar ../tools/jastadd/jastadd2.jar --package="org.tud.forty.ast" --indent='2space' --rewrite=regular ../spec/*.ast ../spec-gen/*.ast ../spec/*.jadd ../spec/*.jrag
sed -i 's|aspect PrettyPrint|class PrettyPrint|' spec/Printing.jadd
sed -i 's|aspect PrettyPrint|class PrettyPrint|' spec/OmpPrinting.jadd
@@ -32,7 +32,7 @@ clean:
dot:
sed -i 's|class PrettyPrint|aspect PrettyPrint|' spec/Printing.jadd
sed -i 's|class PrettyPrint|aspect PrettyPrint|' spec/OmpPrinting.jadd
- cd src-gen; java -jar ../tools/jastadd/jastadd2.jar --dot --package="org.tud.forty.ast" --indent='4space' ../spec-gen/*.ast ../spec/*.jadd
+ cd src-gen; java -jar ../tools/jastadd/jastadd2.jar --dot --package="org.tud.forty.ast" --indent='4space' ../spec/*.ast ../spec-gen/*.ast ../spec/*.jadd
sed -i 's|aspect PrettyPrint|class PrettyPrint|' spec/Printing.jadd
sed -i 's|aspect PrettyPrint|class PrettyPrint|' spec/OmpPrinting.jadd
diff --git a/Parser/spec/ExprRewrites.jrag b/Parser/spec/ExprRewrites.jrag
new file mode 100644
index 0000000000000000000000000000000000000000..55ef8a0feb2e1e37e7c419ce5b208a4b2b0cf3b8
--- /dev/null
+++ b/Parser/spec/ExprRewrites.jrag
@@ -0,0 +1,110 @@
+aspect ExprRewrites {
+
+ rewrite Level6Expr {
+ when (getDefBinOpExprList().numChildren() == 0)
+ to AbstractLevel5Expr {
+ return getLevel5Expr();
+ }
+ }
+
+ // TODO check if actually can be rewritten!
+ rewrite Level5Expr {
+ when (getAbstractEquivOperandList().numChildren() == 1)
+ to AbstractAbstractEquivOperand {
+ return getAbstractEquivOperand(0).getEquivOperand();
+ }
+ }
+
+ rewrite EquivOperand {
+ when (getOrOperandList().numChildren() == 1)
+ to AbstractOrOperand {
+ return getOrOperand(0);
+ }
+ }
+
+ rewrite OrOperand {
+ when (getAndOperandList().numChildren() == 1)
+ to AbstractAndOperand {
+ return getAndOperand(0);
+ }
+ }
+
+ rewrite AndOperand {
+ when (!(this instanceof NotAndOperand))
+ to AbstractLevel4Expr {
+ return getLevel4Expr();
+ }
+ }
+
+ rewrite AtomicLevel4Expr {
+ // when (true) // condition encoded in 'Atomic'
+ to AbstractLevel3Expr {
+ return getLevel3Expr();
+ }
+ }
+
+ rewrite Level3Expr {
+ when (getLevel2ExprList().numChildren() == 1)
+ to AbstractLevel2Expr {
+ return getLevel2Expr(0);
+ }
+ }
+
+ rewrite Level2Expr {
+ when (getAbstractAddOperandList().numChildren() == 1 && (getAbstractAddOperand(0) instanceof SimpleAddOperand))
+ to AbstractAbstractAddOperand {
+ return getAbstractAddOperand(0).getAddOperand();
+ }
+ }
+
+ rewrite AddOperand {
+ when (getAbstractMultOperandList().numChildren() == 1 && (getAbstractMultOperand(0) instanceof SimpleMultOperand))
+ to AbstractAbstractMultOperand {
+ return getAbstractMultOperand(0).getMultOperand();
+ }
+ }
+
+ rewrite MultOperand {
+ when (getLevel1ExprList().numChildren() == 1)
+ to AbstractLevel1Expr {
+ return getLevel1Expr(0);
+ }
+ }
+
+ rewrite Level1Expr {
+ when (!hasDefinedUnaryOp())
+ to Primary {
+ return getPrimary();
+ }
+ }
+
+
+
+ // rewrite Level5Expr {
+ // to SimpleExpr {
+ // List<OpOp> operands = new List<OpOp>();
+ // for (AbstractEquivOperand eo : getAbstractEquivOperandList()) {
+ // if (eo instanceof SimpleEquivOperand) {
+ // operands.add(new OpOpOperand(eo.getEquivOperand()));
+ // } else if (eo instanceof EqEquivOperand) {
+ // operands.add(new OpOpPair(new EqvOp(), eo.getEquivOperand()));
+ // } else if (eo instanceof NeqEquivOperand) {
+ // operands.add(new OpOpPair(new EqvOp(), eo.getEquivOperand()));
+ // }
+ // }
+ // return new ComplexExpr(operands);
+ // }
+ // }
+//
+ // syn boolean OpOp.isOperand();
+ // eq OpOpPair.isOperand() = false;
+ // eq OpOpOperand.isOperand() = true;
+//
+ // rewrite ComplexExpr {
+ // when (getOpOpList().numChildren() == 1 && getOpOp(0).isOperand())
+ // to AbstractExpr {
+ // return getOpOp(0).getAbstractExpr();
+ // }
+ // }
+
+}
\ No newline at end of file
diff --git a/Parser/spec/Fortran2008.rats b/Parser/spec/Fortran2008.rats
index bbe8c1ed8644e97b408f07a0a50f02e47371f28a..9cc8d467a09decbea700f1569ff1434b7c1fffc5 100644
--- a/Parser/spec/Fortran2008.rats
+++ b/Parser/spec/Fortran2008.rats
@@ -131,7 +131,7 @@ ProgramUnit program_unit =
;
//// // R203
-//// ExternalSubprogram:ProgramUnit ;
+//// abstract ExternalSubprogram:ProgramUnit ;
//// FunctionSubprogram_ExternalSubprogram:ExternalSubprogram ::= FunctionSubprogram ;
//// SubroutineSubprogram_ExternalSubprogram:ExternalSubprogram ::= SubroutineSubprogram ;
ExternalSubprogram external_subprogram =
@@ -576,7 +576,8 @@ IntConstant int_constant =
//// // TODO MISSING RULE 308
//// // R309
-//// abstract IntrinsicOperator ;
+//// abstract Operator ;
+//// abstract IntrinsicOperator:Operator ;
IntrinsicOperator intrinsic_operator =
power_op
/ concat_op
@@ -590,7 +591,7 @@ IntrinsicOperator intrinsic_operator =
;
//// // R310
-//// abstract DefinedOperator ;
+//// abstract DefinedOperator:Operator ;
DefinedOperator defined_operator =
defined_unary_op
/ defined_binary_op
@@ -801,8 +802,7 @@ KindSelector kind_selector =
OrOperand oo = new OrOperand(new List().add(ao));
EquivOperand eo = new EquivOperand(new List().add(oo));
Level5Expr l5e = new Level5Expr(new List().add(new SimpleEquivOperand(eo)));
- Level6Expr l6e = new Level6Expr(l5e, new List());
- Expr e = new Level6ExprExpr(l6e);
+ Expr e = new Level6Expr(l5e, new List());
yyValue = new KindSelector(e);
}
;
@@ -3165,7 +3165,7 @@ DeallocOpt dealloc_opt =
// =============================================================================
//// // R701
-//// abstract Primary ;
+//// abstract Primary:AbstractLevel1Expr ;
//// TypeParamName_Primary:Primary ::= Name ;
//// ExprPrimary_Primary:Primary ::= Expr ;
// ! Modified!
@@ -3257,7 +3257,8 @@ GenericPrimary generic_primary =
//// // R702
-//// Level1Expr ::= [DefinedUnaryOp] Primary ;
+//// abstract AbstractLevel1Expr:AbstractAbstractMultOperand ;
+//// Level1Expr:AbstractLevel1Expr ::= [DefinedUnaryOp] Primary ;
Level1Expr level_1_expr =
u:(yyValue:defined_unary_op)? p:primary
{
@@ -3282,8 +3283,9 @@ DefinedUnaryOp defined_unary_op =
}
;
-//// // R704
-//// MultOperand ::= Level1Expr* ;
+//// // R704]
+//// abstract AbstractAbstractMultOperand:AbstractAbstractAddOperand ;
+//// MultOperand:AbstractAbstractMultOperand ::= Level1Expr:AbstractLevel1Expr* ;
MultOperand mult_operand =
l:level_1_expr POW r:mult_operand
{
@@ -3310,8 +3312,9 @@ MultOperand mult_operand_without_dot =
;
//// // R705
-//// AddOperand ::= AbstractMultOperand*;
-//// abstract AbstractMultOperand ::= MultOperand ;
+//// abstract AbstractAbstractAddOperand:AbstractLevel2Expr ;
+//// AddOperand:AbstractAbstractAddOperand ::= AbstractMultOperand*;
+//// abstract AbstractMultOperand:AbstractAbstractMultOperand ::= MultOperand:AbstractAbstractMultOperand ;
//// SimpleMultOperand:AbstractMultOperand ;
//// MultMultOperand:AbstractMultOperand ;
//// DivMultOperand:AbstractMultOperand ;
@@ -3389,8 +3392,9 @@ AddOperand add_operand_rest_without_dot =
;
//// // R706
-//// Level2Expr ::= AbstractAddOperand* ;
-//// abstract AbstractAddOperand ::= AddOperand ;
+//// abstract AbstractLevel2Expr:AbstractLevel3Expr ;
+//// Level2Expr:AbstractLevel2Expr ::= AbstractAddOperand* ;
+//// abstract AbstractAddOperand:AbstractAbstractAddOperand ::= AddOperand:AbstractAbstractAddOperand ;
//// SimpleAddOperand:AbstractAddOperand ;
//// PlusAddOperand:AbstractAddOperand ;
//// MinusAddOperand:AbstractAddOperand ;
@@ -3508,7 +3512,8 @@ AddOp add_op =
;
//// // R710
-//// Level3Expr ::= Level2Expr* ;
+//// abstract AbstractLevel3Expr:AbstractLevel4Expr ;
+//// Level3Expr:AbstractLevel3Expr ::= Level2Expr:AbstractLevel2Expr* ;
Level3Expr level_3_expr =
e:level_2_expr el:(DOUBLESLASH yyValue:level_2_expr)*
{
@@ -3538,9 +3543,10 @@ ConcatOp concat_op =
;
//// // R712
-//// abstract Level4Expr ;
-//// AtomicLevel4Expr:Level4Expr ::= Level3Expr ;
-//// abstract BinaryLevel4Expr:Level4Expr ::= Left:Level3Expr Right:Level3Expr ;
+//// abstract AbstractLevel4Expr:AbstractAndOperand ;
+//// abstract Level4Expr:AbstractLevel4Expr ;
+//// AtomicLevel4Expr:Level4Expr ::= Level3Expr:AbstractLevel3Expr ;
+//// abstract BinaryLevel4Expr:Level4Expr ::= Left:AbstractLevel3Expr Right:AbstractLevel3Expr ;
//// EQLevel4Expr:BinaryLevel4Expr ;
//// NELevel4Expr:BinaryLevel4Expr ;
//// LTLevel4Expr:BinaryLevel4Expr ;
@@ -3764,7 +3770,8 @@ RelOp rel_op =
;
//// // R714
-//// AndOperand ::= Level4Expr ;
+//// abstract AbstractAndOperand:AbstractOrOperand ;
+//// AndOperand:AbstractAndOperand ::= Level4Expr:AbstractLevel4Expr ;
//// NotAndOperand:AndOperand ;
AndOperand and_operand =
NOT o:level_4_expr
@@ -3789,7 +3796,8 @@ AndOperand and_operand_without_dot =
//// // R715
-//// OrOperand ::= AndOperand* ;
+//// abstract AbstractOrOperand:AbstractAbstractEquivOperand ;
+//// OrOperand:AbstractOrOperand ::= AndOperand:AbstractAndOperand* ;
OrOperand or_operand =
a:and_operand r:or_operand_rest
{
@@ -3865,7 +3873,8 @@ OrOperand or_operand_rest_without_dot =
//// // R716
-//// EquivOperand ::= OrOperand*;
+//// abstract AbstractAbstractEquivOperand:AbstractLevel5Expr ;
+//// EquivOperand:AbstractAbstractEquivOperand ::= OrOperand:AbstractOrOperand*;
EquivOperand equiv_operand =
o:or_operand r:equiv_operand_rest
{
@@ -3940,8 +3949,9 @@ EquivOperand equiv_operand_rest_without_dot =
;
//// // R717
-//// Level5Expr ::= AbstractEquivOperand* ;
-//// abstract AbstractEquivOperand ::= EquivOperand ;
+//// abstract AbstractLevel5Expr:AbstractLevel6Expr ;
+//// Level5Expr:AbstractLevel5Expr ::= AbstractEquivOperand* ;
+//// AbstractEquivOperand:AbstractAbstractEquivOperand ::= EquivOperand:AbstractAbstractEquivOperand ;
//// SimpleEquivOperand:AbstractEquivOperand ;
//// EqEquivOperand:AbstractEquivOperand ;
//// NeqEquivOperand:AbstractEquivOperand ;
@@ -4101,11 +4111,11 @@ EquivOp equiv_op =
;
//// // R722
-//// Level6Expr ::= Level5Expr DefBinOpExpr* ;
-//// DefBinOpExpr ::= DefinedBinaryOp Level5Expr ;
+//// abstract AbstractLevel6Expr:Expr ;
+//// Level6Expr:AbstractLevel6Expr ::= Level5Expr:AbstractLevel5Expr DefBinOpExpr* ;
+//// DefBinOpExpr ::= DefinedBinaryOp Level5Expr:AbstractLevel5Expr ;
//// // splitting Expr is necessary because of the inheritance in rules 724-731
//// abstract Expr ;
-//// Level6ExprExpr:Expr ::= Level6Expr ;
Level6Expr level_6_expr =
e:level_5_expr r:level_6_expr_rest
{
@@ -4142,10 +4152,7 @@ List<DefBinOpExpr> level_6_expr_rest =
Expr expr =
<BEGINNING>
- e:level_6_expr
- {
- yyValue = new Level6ExprExpr(e);
- }
+ yyValue:level_6_expr
;
// // R723
@@ -7039,7 +7046,8 @@ PrefixSpec prefix_spec =
;
//// // R1227
-//// FunctionSubprogram ::= FunctionStmt [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndFunctionStmt ;
+//// abstract ProcedureSubprogram ;
+//// FunctionSubprogram:ProcedureSubprogram ::= FunctionStmt [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndFunctionStmt ;
FunctionSubprogram function_subprogram =
f:function_stmt
s:specification_part
@@ -7114,7 +7122,7 @@ EndFunctionStmt end_function_stmt =
;
//// // R1233
-//// SubroutineSubprogram ::= SubroutineStmt [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndSubroutineStmt ;
+//// SubroutineSubprogram:ProcedureSubprogram ::= SubroutineStmt [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndSubroutineStmt ;
SubroutineSubprogram subroutine_subprogram =
f:subroutine_stmt
s:specification_part
@@ -7178,7 +7186,7 @@ EndSubroutineStmt end_subroutine_stmt =
;
//// // R1237
-//// SeparateModuleSubprogram ::= [MpSubprogramStmt] [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndMpSubprogramStmt ;
+//// SeparateModuleSubprogram:ProcedureSubprogram ::= [MpSubprogramStmt] [SpecificationPart] [ExecutionPart] [InternalSubprogramPart] EndMpSubprogramStmt ;
SeparateModuleSubprogram separate_module_subprogram =
p:mp_subprogram_stmt s:specification_part e:execution_part? i:internal_subprogram_part? x:end_mp_subprogram_stmt
{
diff --git a/Parser/spec/Printing.jadd b/Parser/spec/Printing.jadd
index 6c05dcd68a40762a9b9efa1990f3b9cbe34311d1..d28ebe2503f52d15817a947b6b90759600c54e31 100644
--- a/Parser/spec/Printing.jadd
+++ b/Parser/spec/Printing.jadd
@@ -2382,7 +2382,7 @@ class PrettyPrint {
// R710
public void Level3Expr.prettyPrint(PrettyPrinter s) {
boolean first = true;
- for (Level2Expr o : getLevel2ExprList()) {
+ for (AbstractLevel2Expr o : getLevel2ExprList()) {
if (first) {
first = false;
} else {
@@ -2471,7 +2471,7 @@ class PrettyPrint {
// R715
public void OrOperand.prettyPrint(PrettyPrinter s) {
boolean first = true;
- for (AndOperand o : getAndOperandList()) {
+ for (AbstractAndOperand o : getAndOperandList()) {
if (first) {
first = false;
} else {
@@ -2549,9 +2549,6 @@ class PrettyPrint {
getDefinedBinaryOp().prettyPrint(s);
getLevel5Expr().prettyPrint(s);
}
- public void Level6ExprExpr.prettyPrint(PrettyPrinter s) {
- getLevel6Expr().prettyPrint(s);
- }
// R723
// DefinedBinaryOp:DefinedOperator ::= <String> ;
diff --git a/Parser/spec/SimpleExpr.ast b/Parser/spec/SimpleExpr.ast
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Parser/spec/Types.jrag b/Parser/spec/Types.jrag
new file mode 100644
index 0000000000000000000000000000000000000000..ab95a14a4d001aa747bc659b32784350622050e8
--- /dev/null
+++ b/Parser/spec/Types.jrag
@@ -0,0 +1,220 @@
+aspect Types {
+
+
+
+ // ===============================================================================================
+ // DECLARATIONS
+ // ===============================================================================================
+
+ syn ASTNode Name.declaration();
+ eq Name.declaration() {
+ java.util.Set<ASTNode> decls = enclosingScope().localDeclarations();
+ for(ASTNode decl : decls) {
+ java.util.Set<Name> names = decl.declaredSimpleNames();
+ for (Name name : names) {
+ if (name.getString().equals(this.getString())) {
+ return decl;
+ }
+ }
+ }
+ return null;
+ }
+
+ // ===============================================================================================
+ // LOCAL DECLARATIONS
+ // ===============================================================================================
+
+ // collection attribute to collect all declarations in the local scope
+ coll java.util.Set<ASTNode> ASTNode.localDeclarations() [new java.util.HashSet<ASTNode>()] with add;
+
+ // everything that is a declared MUST have a name. Of course, the actual name of a thing can be
+ // a complex one (cf. DataRef), but the simple on has to and can be specified in a simple way.
+ syn java.util.Set<Name> ASTNode.declaredSimpleNames();
+ eq ASTNode.declaredSimpleNames() {
+ return java.util.Collections.emptySet();
+ }
+
+ // handle all declaration constructs (R207)
+
+ DerivedTypeDef contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq DerivedTypeDef.declaredSimpleNames() {
+ return java.util.Collections.singleton(getDerivedTypeStmt().getTypeName());
+ }
+
+ EntryStmt contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq EntryStmt.declaredSimpleNames() {
+ return java.util.Collections.singleton(getName());
+ }
+
+ // TODO implement EnumDef
+ // EnumDef contributes this
+ // to ASTNode.localDeclarations()
+ // for enclosingScope();
+
+ // FormatStmt is not necessary, because it declares nothing. however, it can be referenced with a
+ // label.
+
+ // not sure how to handle an InterfaceBlock. Currently, all interface bodies are used as
+ // declarations
+ InterfaceBody contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq FunctionInterfaceBody.declaredSimpleNames() {
+ return java.util.Collections.singleton(getFunctionStmt().getName());
+ }
+ eq SubroutineInterfaceBody.declaredSimpleNames() {
+ return java.util.Collections.singleton(getSubroutineStmt().getName());
+ }
+ ProcedureInterfaceSpecification contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq ProcedureInterfaceSpecification.declaredSimpleNames() {
+ java.util.Set<Name> names = new java.util.HashSet<Name>();
+ for (Name name : getProcedureStmt().getNameList()) {
+ names.add(name);
+ }
+ return names;
+ }
+
+ ParameterStmt contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq ParameterStmt.declaredSimpleNames() {
+ java.util.Set<Name> names = new java.util.HashSet<Name>();
+ for (NamedConstantDef def : getNamedConstantDefList()) {
+ names.add(def.getNamedConstant().getName());
+ }
+ return names;
+ }
+
+ ProcedureDeclarationStmt contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq ProcedureDeclarationStmt.declaredSimpleNames() {
+ java.util.Set<Name> names = new java.util.HashSet<Name>();
+ for (ProcDecl decl : getProcDeclList()) {
+ names.add(decl.getName());
+ }
+ return names;
+ }
+
+ // for the OtherSpecificationStmts, see below
+
+ TypeDeclarationStmt contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq TypeDeclarationStmt.declaredSimpleNames() {
+ java.util.Set<Name> names = new java.util.HashSet<Name>();
+ for (EntityDecl decl : getEntityDeclList()) {
+ names.add(decl.getObjectName().getName());
+ }
+ return names;
+ }
+
+ // TODO implement StmtFunctionStmt
+
+ // handle OtherSpecificationStmt (R212)
+
+ // TODO handle OtherSpecificationStmt (R212). These Stmts are not really declarations, I think
+
+ // handle subprograms
+ SubroutineSubprogram contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq SubroutineSubprogram.declaredSimpleNames() {
+ return java.util.Collections.singleton(getSubroutineStmt().getName());
+ }
+
+ FunctionSubprogram contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq FunctionSubprogram.declaredSimpleNames() {
+ return java.util.Collections.singleton(getFunctionStmt().getName());
+ }
+
+ SeparateModuleSubprogram contributes this
+ to ASTNode.localDeclarations()
+ for enclosingScope();
+ eq SeparateModuleSubprogram.declaredSimpleNames() {
+ if (hasMpSubprogramStmt()) {
+ return java.util.Collections.singleton(getMpSubprogramStmt().getName());
+ } else {
+ return java.util.Collections.emptySet();
+ }
+ }
+
+ // TODO think of other things with names
+
+ // ===============================================================================================
+ // SCOPING
+ // ===============================================================================================
+
+ inh ASTNode ASTNode.enclosingScope();
+
+ syn ASTNode Root.enclosingScope() = null;
+
+ // first, the unncessary ones
+ eq Program.getProgramUnit(int i).enclosingScope() {
+ return null; //throw new RuntimeException("Could not find enclosing scope!");
+ }
+ eq Root.getProgram().enclosingScope() {
+ return null; //throw new RuntimeException("Could not find enclosing scope!");
+ }
+ eq Root.getPreamble(int i).enclosingScope() {
+ return null; //throw new RuntimeException("Could not find enclosing scope!");
+ }
+
+ eq SubroutineSubprogram.getSubroutineStmt().enclosingScope() = this;
+ eq SubroutineSubprogram.getSpecificationPart().enclosingScope() = this;
+ eq SubroutineSubprogram.getExecutionPart().enclosingScope() = this;
+ eq SubroutineSubprogram.getInternalSubprogramPart().enclosingScope() = this;
+ eq SubroutineSubprogram.getEndSubroutineStmt().enclosingScope() = this;
+
+ eq FunctionSubprogram.getFunctionStmt().enclosingScope() = this;
+ eq FunctionSubprogram.getSpecificationPart().enclosingScope() = this;
+ eq FunctionSubprogram.getExecutionPart().enclosingScope() = this;
+ eq FunctionSubprogram.getInternalSubprogramPart().enclosingScope() = this;
+ eq FunctionSubprogram.getEndFunctionStmt().enclosingScope() = this;
+
+ eq SeparateModuleSubprogram.getMpSubprogramStmt().enclosingScope() = this;
+ eq SeparateModuleSubprogram.getSpecificationPart().enclosingScope() = this;
+ eq SeparateModuleSubprogram.getExecutionPart().enclosingScope() = this;
+ eq SeparateModuleSubprogram.getInternalSubprogramPart().enclosingScope() = this;
+ eq SeparateModuleSubprogram.getEndMpSubprogramStmt().enclosingScope() = this;
+
+ eq BlockConstruct.getBlockStmt().enclosingScope() = this;
+ eq BlockConstruct.getSpecificationPart().enclosingScope() = this;
+ eq BlockConstruct.getBlock().enclosingScope() = this;
+ eq BlockConstruct.getEndBlockStmt().enclosingScope() = this;
+
+ eq MainProgram.getProgramStmt().enclosingScope() = this;
+ eq MainProgram.getSpecificationPart().enclosingScope() = this;
+ eq MainProgram.getExecutionPart().enclosingScope() = this;
+ eq MainProgram.getInternalSubprogramPart().enclosingScope() = this;
+ eq MainProgram.getEndProgramStmt().enclosingScope() = this;
+
+ eq Module.getModuleStmt().enclosingScope() = this;
+ eq Module.getSpecificationPart().enclosingScope() = this;
+ eq Module.getModuleSubprogramPart().enclosingScope() = this;
+ eq Module.getEndModuleStmt().enclosingScope() = this;
+
+ // questionable interface stuff
+ eq FunctionInterfaceBody.getFunctionStmt().enclosingScope() = this;
+ eq FunctionInterfaceBody.getSpecificationPart().enclosingScope() = this;
+ eq FunctionInterfaceBody.getEndFunctionStmt().enclosingScope() = this;
+
+ eq SubroutineInterfaceBody.getSubroutineStmt().enclosingScope() = this;
+ eq SubroutineInterfaceBody.getSpecificationPart().enclosingScope() = this;
+ eq SubroutineInterfaceBody.getEndSubroutineStmt().enclosingScope() = this;
+
+ // COMMON block bullshit
+ eq BlockData.getBlockDataStmt().enclosingScope() = this;
+ eq BlockData.getSpecificationPart().enclosingScope() = this;
+ eq BlockData.getEndBlockDataStmt().enclosingScope() = this;
+
+ // TODO do not forget the COMMON block
+}
\ No newline at end of file
diff --git a/Parser/src/org/tud/forty/DrFort.java b/Parser/src/org/tud/forty/DrFort.java
index 835854bcc12487a88584557e93104913922e7e13..9c255ce43b25ad35435f837e66bf83d4835056e8 100644
--- a/Parser/src/org/tud/forty/DrFort.java
+++ b/Parser/src/org/tud/forty/DrFort.java
@@ -29,6 +29,7 @@ public class DrFort {
Result r = parser.proot(0);
if (r.hasValue()) {
+ ((org.tud.forty.ast.ASTNode)(r.semanticValue())).fixTreeStructure();
drast.views.gui.DrASTGUI debugger = new drast.views.gui.DrASTGUI(r.semanticValue());
debugger.run();
} else {
diff --git a/Parser/test-data/rewrites/B_Designator_OR_FunctionReference.f90 b/Parser/test-data/rewrites/B_Designator_OR_FunctionReference.f90
new file mode 100644
index 0000000000000000000000000000000000000000..43d0adf938688d4d7f1f5abe4ede60056233a495
--- /dev/null
+++ b/Parser/test-data/rewrites/B_Designator_OR_FunctionReference.f90
@@ -0,0 +1,3 @@
+real :: a(10)
+a(2) = a(1)
+end