Add support for Fujitsu test suites 0001 and 0002

Fortran-JS/src-api/Query.test.ts

@@ -591,8 +591,6 @@ describe("Query", () => {
       lst.push(stmt.code);
     }
 
-    console.log(lst);
-
     expect(lst.length).toBe(4);
     expect(lst[0]).toEqual('PROGRAM HELLO');
     expect(lst[1]).toEqual('PRINT *, "Hello, World!"');

FortranAst/src/pt/up/fe/specs/fortran/ast/FortranContext.java

@@ -63,6 +63,9 @@ public class FortranContext extends ADataClass<FortranContext> {
     public final static DataKey<Optional<File>> LAST_PARSED_FILE = KeyFactory
             .optional("lastParsedFile");
 
+    public final static DataKey<Optional<String>> LAST_PARSED_FILE_EXT = KeyFactory.optional("lastParsedFileExt");
+
+    public final static DataKey<Boolean> FIXED_FORM = KeyFactory.bool("fixedObject").setDefault(() -> false);
 
     /**
      * A DataStore with options from {@link FortranAstOptions}.
@@ -85,5 +88,7 @@ public String toString() {
         return "FortranContext " + hashCode();
     }
 
-
+    public DataStore getFortranOptions() {
+        return get(FORTRAN_OPTIONS);
+    }
 }

FortranAst/src/pt/up/fe/specs/fortran/ast/FortranKeyword.java

@@ -6,12 +6,14 @@ public enum FortranKeyword {
     CONCURRENT,
     SUBROUTINE,
     FUNCTION,
-    WRITE,
     USE,
+    INTRINSIC,
+    NON_INTRINSIC,
+    ONLY,
     GOTO,
     EXTERNAL,
-    RETURN,
     STOP,
+    MODULE,
 
     // Execution statements
     PRINT,
@@ -22,6 +24,22 @@ public enum FortranKeyword {
     ERROR,
     QUIET,
     CALL,
+    CONTINUE,
+    CONTAINS,
+    ALLOCATE,
+    DEALLOCATE,
+    RETURN,
+    OPEN,
+    ERR,
+    WRITE,
+    UNIT,
+    FMT,
+    NML,
+    REWIND,
+    NAMELIST,
+    READ,
+    WAIT,
+    CLOSE,
 
     // Conditional statements
     IF,
@@ -39,11 +57,35 @@ public enum FortranKeyword {
     DOUBLE,
     PRECISION,
     DIMENSION,
+    COMPLEX,
 
     // Declarations
     PARAMETER,
     DATA,
     COMMON,
+    INTENT,
+    STAT,
+    LEN,
+    KIND,
+    BIND,
+    C,
+    NAME,
+    CDEFINED,
+    RESULT,
+    OPERATOR,
+    ASSIGNMENT,
+    FORMATTED,
+    UNFORMATTED,
+    IMPORT,
+    NONE,
+    ALL,
+    IMPLICIT,
+    TYPE,
+    CODIMENSION,
+    EXTENDS,
+    ABSTRACT,
+    INTERFACE,
+    PROCEDURE,
 
     OMP;
 

FortranAst/src/pt/up/fe/specs/fortran/ast/FortranKeywords.java

@@ -20,4 +20,7 @@ public String get(FortranKeyword keyword) {
         return keyword.getKeyword(lowercase);
     }
 
+    public boolean isLowercase() {
+        return lowercase;
+    }
 }

FortranAst/src/pt/up/fe/specs/fortran/ast/FortranNodeFactory.java

@@ -3,18 +3,14 @@
 import org.suikasoft.jOptions.Interfaces.DataStore;
 import org.suikasoft.jOptions.storedefinition.StoreDefinitions;
 import pt.up.fe.specs.fortran.ast.nodes.FortranNode;
-import pt.up.fe.specs.fortran.ast.nodes.decl.ExprInitialization;
 import pt.up.fe.specs.fortran.ast.nodes.decl.LabelDecl;
-import pt.up.fe.specs.fortran.ast.nodes.decl.ListInitialization;
-import pt.up.fe.specs.fortran.ast.nodes.expr.Argument;
-import pt.up.fe.specs.fortran.ast.nodes.expr.BinaryOperator;
-import pt.up.fe.specs.fortran.ast.nodes.expr.Call;
-import pt.up.fe.specs.fortran.ast.nodes.expr.DataRef;
-import pt.up.fe.specs.fortran.ast.nodes.expr.Expr;
-import pt.up.fe.specs.fortran.ast.nodes.expr.IntLiteral;
-import pt.up.fe.specs.fortran.ast.nodes.expr.Literal;
-import pt.up.fe.specs.fortran.ast.nodes.expr.StringLiteral;
+import pt.up.fe.specs.fortran.ast.nodes.decl.NamedParameter;
+import pt.up.fe.specs.fortran.ast.nodes.decl.init.ExprInitialization;
+import pt.up.fe.specs.fortran.ast.nodes.decl.init.ListInitialization;
+import pt.up.fe.specs.fortran.ast.nodes.expr.*;
 import pt.up.fe.specs.fortran.ast.nodes.expr.enums.BinaryOperatorKind;
+import pt.up.fe.specs.fortran.ast.nodes.io.Format;
+import pt.up.fe.specs.fortran.ast.nodes.io.StarFormat;
 import pt.up.fe.specs.fortran.ast.nodes.loops.LoopControl;
 import pt.up.fe.specs.fortran.ast.nodes.loops.RangeLoopControl;
 import pt.up.fe.specs.fortran.ast.nodes.omp.OmpBlockConstruct;
@@ -26,13 +22,20 @@
 import pt.up.fe.specs.fortran.ast.nodes.omp.enums.OmpClauseKind;
 import pt.up.fe.specs.fortran.ast.nodes.omp.enums.OmpDirectiveKind;
 import pt.up.fe.specs.fortran.ast.nodes.program.*;
+import pt.up.fe.specs.fortran.ast.nodes.program.construct.*;
+import pt.up.fe.specs.fortran.ast.nodes.program.unit.EndProgramStmt;
+import pt.up.fe.specs.fortran.ast.nodes.program.unit.MainProgram;
+import pt.up.fe.specs.fortran.ast.nodes.program.unit.ProgramStmt;
+import pt.up.fe.specs.fortran.ast.nodes.program.unit.ProgramUnit;
 import pt.up.fe.specs.fortran.ast.nodes.stmt.*;
+import pt.up.fe.specs.fortran.ast.nodes.stmt.implicit.IDEStmtImplicitAdapter;
+import pt.up.fe.specs.fortran.ast.nodes.stmt.implicit.ISStmtImplicitAdapter;
 import pt.up.fe.specs.fortran.ast.nodes.stmt.loop.DoConstruct;
 import pt.up.fe.specs.fortran.ast.nodes.stmt.loop.DoStmt;
 import pt.up.fe.specs.fortran.ast.nodes.stmt.loop.EndDoStmt;
-import pt.up.fe.specs.fortran.ast.nodes.utils.Format;
+import pt.up.fe.specs.fortran.ast.nodes.stmt.usestmt.UseOnlyStmt;
+import pt.up.fe.specs.fortran.ast.nodes.stmt.usestmt.UseRenameStmt;
 import pt.up.fe.specs.fortran.ast.nodes.utils.LabelRef;
-import pt.up.fe.specs.fortran.ast.nodes.utils.Star;
 import pt.up.fe.specs.util.SpecsCheck;
 import pt.up.fe.specs.util.SpecsCollections;
 
@@ -136,23 +139,33 @@ private void initComments(Stmt stmt) {
         stmt.set(Stmt.LEADING_COMMENTS, List.of());
     }
 
-    public MainProgram mainProgram(String programName, List<ExecutableStmt> execution) {
+    public MainProgram mainProgram(String programName, List<ExecPartConstruct> execution) {
         DataStore data = newDataStore(MainProgram.class);
-        data.set(MainProgram.NAME, Optional.ofNullable(programName));
 
         var programStmt = newNode(ProgramStmt.class, Collections.emptyList());
+        programStmt.set(ProgramStmt.PROGRAM_NAME, programName);
         initComments(programStmt);
+
+        var specificationBlock = newNode(Specification.class, Collections.emptyList());
         var executionBlock = execution(execution);
+
         var endProgramStmt = newNode(EndProgramStmt.class, Collections.emptyList());
         initComments(endProgramStmt);
 
-        return new MainProgram(data, List.of(programStmt, executionBlock, endProgramStmt));
+        return new MainProgram(data, List.of(programStmt, specificationBlock, executionBlock, endProgramStmt));
     }
 
-    public Execution execution(List<ExecutableStmt> statements) {
-        DataStore data = newDataStore(Execution.class);
+    public Execution execution(List<ExecPartConstruct> constructs) {
+        SpecsCheck.checkArgument(
+                constructs.isEmpty() || !(constructs.get(constructs.size() - 1) instanceof ExecConstruct),
+                () -> "The last construct of Execution must be of type ExecConstruct"
+        );
+
+        return newNode(Execution.class, constructs);
+    }
 
-        return new Execution(data, statements);
+    public ExecBlock execBlock(List<ExecPartConstruct> constructs) {
+        return newNode(ExecBlock.class, constructs);
     }
 
     // STMT
@@ -206,26 +219,16 @@ public StringLiteral stringLiteral(String literal) {
 
     public StringLiteral stringLiteral(String literal, String kindParam) {
         DataStore data = newDataStore(StringLiteral.class);
-        data.set(Literal.SOURCE_LITERAL, literal);
+        data.set(StringLiteral.CONTENTS, literal);
 
         return new StringLiteral(data, Collections.emptyList());
     }
 
     // UTIL
 
-    public Format format(FortranNode formatType) {
-        // Check if node is of allowed type
-        if (!(formatType instanceof Star)) {
-            throw new RuntimeException("Unsupported type for Format child: " + formatType.getClass());
-        }
-
+    public StarFormat starFormat() {
         DataStore data = newDataStore(Format.class);
-        return new Format(data, List.of(formatType));
-    }
-
-    public Star star() {
-        DataStore data = newDataStore(Star.class);
-        return new Star(data, Collections.emptyList());
+        return new StarFormat(data, List.of());
     }
 
     public LabelRef labelRef(LabelDecl labelDecl) {
@@ -286,20 +289,30 @@ public DataRef dataRef(String name) {
         return newNode;
     }
 
-    public UseStmt useStmt(String moduleName) {
-        DataStore data = newDataStore(UseStmt.class);
+    public UseRenameStmt useRenameStmt(String moduleName) {
+        DataStore data = newDataStore(UseRenameStmt.class);
 
-        UseStmt newNode = new UseStmt(data, Collections.emptyList());
+        UseRenameStmt newNode = new UseRenameStmt(data, Collections.emptyList());
 
-        newNode.set(UseStmt.NAME, moduleName);
+        newNode.set(UseRenameStmt.NAME, moduleName);
+
+        return newNode;
+    }
+
+    public UseOnlyStmt useOnlyStmt(String moduleName) {
+        DataStore data = newDataStore(UseOnlyStmt.class);
+
+        UseOnlyStmt newNode = new UseOnlyStmt(data, Collections.emptyList());
+
+        newNode.set(UseOnlyStmt.NAME, moduleName);
 
         return newNode;
     }
 
     public OmpReductionClause ompReductionClause(BinaryOperatorKind operator, List<DataRef> refs) {
         DataStore data = newDataStore(OmpReductionClause.class);
 
-        OmpReductionClause newNode= new OmpReductionClause(data, refs);
+        OmpReductionClause newNode = new OmpReductionClause(data, refs);
 
         newNode.set(OmpReductionClause.KIND, OmpClauseKind.REDUCTION);
 
@@ -312,8 +325,7 @@ public IntLiteral intLiteral(int value) {
         DataStore data = newDataStore(IntLiteral.class);
 
         IntLiteral newNode = new IntLiteral(data, Collections.emptyList());
-
-        newNode.set(IntLiteral.SOURCE_LITERAL, Integer.toString(value));
+        newNode.set(IntLiteral.SOURCE, Integer.toString(value));
 
         return newNode;
     }
@@ -364,4 +376,68 @@ public OmpOrderedClause ompOrderedClause(int value) {
 
         return newNode;
     }
+
+    public NamedParameter namedParameter(String name) {
+        var data = newDataStore(NamedParameter.class);
+
+        var node = new NamedParameter(data, Collections.emptyList());
+        node.set(NamedParameter.NAME, name);
+
+        return node;
+    }
+
+    public DeclStmtAdapter declStmtAdapter(DeclStmt declStmt) {
+        return newNode(DeclStmtAdapter.class, List.of(declStmt));
+    }
+
+    public IDEStmtDeclAdapter ideStmtDeclAdapter(IDEStmt ideStmt) {
+        return newNode(IDEStmtDeclAdapter.class, List.of(ideStmt));
+    }
+
+    public SpecStmtAdapter specStmtAdapter(SpecStmt specStmt) {
+        return newNode(SpecStmtAdapter.class, List.of(specStmt));
+    }
+
+    public DirectiveSpecAdapter directiveSpecAdapter(CompilerDirective compilerDirective) {
+        return newNode(DirectiveSpecAdapter.class, List.of(compilerDirective));
+    }
+
+    public ISStmtSpecAdapter isStmtSpecAdapter(ISStmt isStmt) {
+        return newNode(ISStmtSpecAdapter.class, List.of(isStmt));
+    }
+
+    private <T extends Stmt> T withInfoOf(T dest, Stmt source) {
+        dest.set(Stmt.LEADING_COMMENTS, source.getLeadingComments());
+        dest.set(Stmt.TRAILING_COMMENT, source.getTrailingComment());
+        source.getLabel().ifPresent(label -> dest.addChild(0, label));
+
+        return dest;
+    }
+
+    public IDEStmtImplicitAdapter ideStmtImplicitAdapter(IDEStmt ideStmt) {
+        return withInfoOf(newNode(IDEStmtImplicitAdapter.class, List.of(ideStmt)), ideStmt);
+    }
+
+    public ISStmtImplicitAdapter isStmtImplicitAdapter(ISStmt isStmt) {
+        return withInfoOf(newNode(ISStmtImplicitAdapter.class, List.of(isStmt)), isStmt);
+    }
+
+    public ActionStmtAdapter actionStmtAdapter(ActionStmt actionStmt) {
+        return newNode(ActionStmtAdapter.class, List.of(actionStmt));
+    }
+
+    public IDEStmtExecAdapter ideStmtExecAdapter(IDEStmt ideStmt) {
+        return newNode(IDEStmtExecAdapter.class, List.of(ideStmt));
+    }
+
+    public DirectiveExecAdapter directiveExecAdapter(CompilerDirective directive) {
+        return newNode(DirectiveExecAdapter.class, List.of(directive));
+    }
+
+    public NamedProcDesignator namedProcDesignator(String name) {
+        var data = newDataStore(NamedProcDesignator.class);
+        data.set(NamedProcDesignator.NAME, name);
+
+        return new NamedProcDesignator(data, List.of());
+    }
 }