Lisa CMa virtuaalmasinale funktsioonikutsete tugi, ühildamine baasprojektiga

.github/workflows/gradle.yml

@@ -14,17 +14,17 @@ jobs:
       contents: read
 
     steps:
-    - uses: actions/checkout@v4
-    - name: Set up JDK 21
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up JDK 25
       uses: actions/setup-java@v4
       with:
-        java-version: '21'
+        java-version: '25'
         distribution: 'temurin'
 
-    # Configure Gradle for optimal use in GitHub Actions, including caching of downloaded dependencies.
-    # See: https://github.com/gradle/actions/blob/main/setup-gradle/README.md
     - name: Setup Gradle
-      uses: gradle/actions/setup-gradle@af1da67850ed9a4cedd57bfd976089dd991e2582 # v4.0.0
+      uses: gradle/actions/setup-gradle@v4
 
     - name: Build with Gradle Wrapper
       run: ./gradlew build

build.gradle

@@ -1,9 +1,10 @@
 plugins {
-    id 'java'
+    id 'java-library'
+    id 'maven-publish'
 }
 
-group = 'ee.ut.cs.sws'
-version = '1.0-SNAPSHOT'
+group = 'com.github.sandersirge'
+version = 'v0.0.2-pre_release'
 
 repositories {
     mavenCentral()
@@ -17,6 +18,30 @@ dependencies {
     // testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
+java {
+    sourceCompatibility = JavaVersion.toVersion(25)
+    targetCompatibility = JavaVersion.toVersion(25)
+
+    withSourcesJar()
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8'
+    options.release = 25
+}
+
 //test {
 //    useJUnitPlatform()
 //}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+
+            groupId = project.group
+            artifactId = 'java-cma-bachelor-thesis'
+            version = project.version
+        }
+    }
+}

jitpack.yml

@@ -0,0 +1,3 @@
+before_install:
+  - sdk install java 25-tem
+  - sdk use java 25-tem

src/main/java/ee/ut/cs/sws/cma/CMaInterpreter.java

@@ -5,12 +5,18 @@
 import static ee.ut.cs.sws.cma.instruction.CMaBasicInstruction.Code.LOAD;
 import static ee.ut.cs.sws.cma.instruction.CMaBasicInstruction.Code.STORE;
 import static ee.ut.cs.sws.cma.instruction.CMaIntInstruction.Code.LOADC;
+import static ee.ut.cs.sws.cma.instruction.CMaIntInstruction.Code.LOADM;
+import static ee.ut.cs.sws.cma.instruction.CMaIntInstruction.Code.STOREM;
+import static ee.ut.cs.sws.cma.instruction.CMaIntInstruction.Code.LOADRC;
 
 public class CMaInterpreter {
 
     private final CMaProgram program;
-    private int pc = 0;
     private final CMaStack stack;
+    private int pc = 0;
+    private int fp = 0;  // Frame Pointer
+    private int ep = 0;  // Extreme Pointer
+    private int hp = Integer.MAX_VALUE;  // Heap Pointer
 
     private CMaInterpreter(CMaProgram program, CMaStack initialStack) {
         this.program = program;
@@ -79,6 +85,18 @@ case CMaBasicInstruction(CMaBasicInstruction.Code code) -> {
                         stack.set(arg, stack.peek());
                     }
                     case HALT -> pc = -1; // out of range pc halts
+                    case MARK -> {
+                        // S[SP+1] = EP; S[SP+2] = FP; SP += 2
+                        stack.push(ep);
+                        stack.push(fp);
+                    }
+                    case CALL -> {
+                        // FP = SP; tmp = PC; PC = S[FP]; S[FP] = tmp
+                        fp = stack.size() - 1;  // SP = stack.size() - 1
+                        int tmp = pc;
+                        pc = stack.get(fp);
+                        stack.set(fp, tmp);
+                    }
                 }
             }
             case CMaIntInstruction(CMaIntInstruction.Code code, int arg) -> {
@@ -92,16 +110,93 @@ case CMaIntInstruction(CMaIntInstruction.Code code, int arg) -> {
                         execute(new CMaIntInstruction(LOADC, arg));
                         execute(new CMaBasicInstruction(STORE));
                     }
+                    case ALLOC -> stack.allocate(arg);
+                    case LOADRC -> stack.push(fp + arg);
+                    case LOADM -> {
+                        // LOADM m: S[SP+i] ← S[S[SP]+i] for i=m-1..0; SP ← SP + m - 1
+                        int sp = stack.size() - 1;
+                        int target = stack.get(sp);                         // S[SP] = base address
+                        stack.allocate(arg - 1);                        // expand: new SP = sp + arg - 1
+                        for (int i = arg - 1; i >= 0; i--) {
+                            stack.set(sp + i, stack.get(target + i));       // S[SP+i] ← S[target+i]
+                        }
+                    }
+                    case STOREM -> {
+                        // STOREM m: S[S[SP]+i] ← S[SP-m+i] for i=0..m-1; eemalda aadress
+                        int sp = stack.size() - 1;
+                        int target = stack.get(sp);                         // S[SP] = destination address
+                        for (int i = 0; i < arg; i++) {
+                            stack.set(target + i, stack.get(sp - arg + i)); // S[target+i] ← S[SP-m+i]
+                        }
+                    }
+                    case ENTER -> {
+                        // EP = SP + m; kui EP >= HP, siis viga
+                        ep = stack.size() - 1 + arg;
+                        if (ep >= hp)
+                            throw new CMaException("Stack Overflow: EP(%d) >= HP(%d)".formatted(ep, hp));
+                    }
+                    case RETURN -> {
+                        // PC = S[FP]; EP = S[FP-2]; kontrolli EP >= HP;
+                        // SP = FP - q (truncate(FP - q + 1)); FP = S[FP-1]
+                        pc = stack.get(fp);                    // taasta tagastusaadress
+                        ep = stack.get(fp - 2);                // taasta vana EP
+                        if (ep >= hp)
+                            throw new CMaException("Stack Overflow: EP(%d) >= HP(%d)".formatted(ep, hp));
+                        int newSp = fp - arg;                  // SP = FP - q
+                        int newFp = stack.get(fp - 1);         // taasta vana FP
+                        stack.truncate(newSp + 1);    // kärbi stack: size = SP + 1
+                        fp = newFp;
+                    }
                 }
 
             }
+            case CMaIntIntInstruction(CMaIntIntInstruction.Code code, int arg1, int arg2) -> {
+                switch (code) {
+                    case SLIDE -> {
+                        // SLIDE q m: nihuta m pealmist väärtust q positsiooni allapoole
+                        //   if (q > 0)
+                        //     if (m = 0) SP ← SP - q;
+                        //     else { SP ← SP-q-m; for (i←0; i<m; i++) { SP++; S[SP]←S[SP+q]; } }
+                        if (arg1 > 0) {
+                            int sp = stack.size() - 1;
+                            if (arg2 == 0) {
+                                // m = 0: lihtsalt kärbi q pesa
+                                stack.truncate(sp - arg1 + 1);  // SP = SP - q, size = SP - q + 1
+                            } else {
+                                // kopeeri m väärtust q positsiooni allapoole, siis kärbi
+                                sp = sp - arg1 - arg2;
+                                for (int i = 0; i < arg2; i++) {
+                                    sp++;
+                                    stack.set(sp, stack.get(sp + arg1)); // S[SP] ← S[SP+q]
+                                }
+                                stack.truncate(sp + 1);         // SP = SP - q, size = SP - q + 1
+                            }
+                        }
+                    }
+                    case LOADR -> {
+                        // LOADR j m = LOADRC j; LOADM m
+                        execute(new CMaIntInstruction(LOADRC, arg1));
+                        execute(new CMaIntInstruction(LOADM, arg2));
+                    }
+                    case STORER -> {
+                        // STORER j m = LOADRC j; STOREM m
+                        execute(new CMaIntInstruction(LOADRC, arg1));
+                        execute(new CMaIntInstruction(STOREM, arg2));
+                    }
+                }
+            }
             case CMaLabelInstruction(CMaLabelInstruction.Code code, CMaLabel label) -> {
                 switch (code) {
+                    case LOADLC -> stack.push(getLabelTarget(label));
                     case JUMP -> pc = getLabelTarget(label);
                     case JUMPZ -> {
                         if (!CMaUtils.int2bool(stack.pop()))
                             pc = getLabelTarget(label);
                     }
+                    case JUMPI -> {
+                        // PC = target(label) + S[SP]; SP--
+                        pc = getLabelTarget(label) + stack.pop();
+                    }
                 }
             }
         }

src/main/java/ee/ut/cs/sws/cma/CMaProgramWriter.java

@@ -3,6 +3,7 @@
 import ee.ut.cs.sws.cma.instruction.CMaBasicInstruction;
 import ee.ut.cs.sws.cma.instruction.CMaInstruction;
 import ee.ut.cs.sws.cma.instruction.CMaIntInstruction;
+import ee.ut.cs.sws.cma.instruction.CMaIntIntInstruction;
 import ee.ut.cs.sws.cma.instruction.CMaLabelInstruction;
 
 import java.util.ArrayList;
@@ -27,6 +28,10 @@ public void visit(CMaIntInstruction.Code code, int arg) {
         visit(new CMaIntInstruction(code, arg));
     }
 
+    public void visit(CMaIntIntInstruction.Code code, int arg1, int arg2) {
+        visit(new CMaIntIntInstruction(code, arg1, arg2));
+    }
+
     public void visit(CMaLabelInstruction.Code code, CMaLabel label) {
         visit(new CMaLabelInstruction(code, label));
     }

src/main/java/ee/ut/cs/sws/cma/CMaStack.java

@@ -53,6 +53,17 @@ public int size() {
         return data.size();
     }
 
+    /** Kasvata stacki m nulliga algväärtustatud pesa võrra. SP += m */
+    public void allocate(int m) {
+        for (int i = 0; i < m; i++)
+            data.add(0);
+    }
+
+    /** Kärbi stack uuele suurusele. SP = newSize - 1 */
+    public void truncate(int newSize) {
+        data.subList(newSize, data.size()).clear();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o)

src/main/java/ee/ut/cs/sws/cma/instruction/CMaBasicInstruction.java

@@ -37,6 +37,12 @@ public enum Code {
 
         /** seiska programm */
         HALT,
+
+        /** salvesta EP ja FP stackile (täitmisraami ettevalmistus) */
+        MARK,
+
+        /** kutsu funktsioon: FP=SP, vaheta PC ja S[FP] */
+        CALL,
         //@formatter:on
     }
 

src/main/java/ee/ut/cs/sws/cma/instruction/CMaInstruction.java

@@ -1,6 +1,6 @@
 package ee.ut.cs.sws.cma.instruction;
 
-public sealed interface CMaInstruction<Code> permits CMaBasicInstruction, CMaIntInstruction, CMaLabelInstruction {
+public sealed interface CMaInstruction<Code> permits CMaBasicInstruction, CMaIntInstruction, CMaIntIntInstruction, CMaLabelInstruction {
 
     Code code();
 

src/main/java/ee/ut/cs/sws/cma/instruction/CMaIntInstruction.java

@@ -12,6 +12,24 @@ public enum Code {
 
         /** salvesta väärtus indeksile */
         STOREA,
+
+        /** eralda m nulliga algväärtustatud pesa */
+        ALLOC,
+
+        /** lisa stackile FP + j (suhteline aadress) */
+        LOADRC,
+
+        /** loe m väärtust mälust aadressil S[SP], laienda stack m-1 pesa võrra */
+        LOADM,
+
+        /** kirjuta m väärtust S[SP-m..SP-1] mällu aadressile S[SP], eemalda aadress */
+        STOREM,
+
+        /** sea piirviit EP = SP + m, kontrolli EP >= HP */
+        ENTER,
+
+        /** taasta registrid ja puhasta täitmisraam, q = org. pesade + parameetrite arv */
+        RETURN,
         //@formatter:on
     }
 

src/main/java/ee/ut/cs/sws/cma/instruction/CMaIntIntInstruction.java

@@ -0,0 +1,22 @@
+package ee.ut.cs.sws.cma.instruction;
+
+public record CMaIntIntInstruction(Code code, int arg1, int arg2) implements CMaInstruction<CMaIntIntInstruction.Code> {
+
+    public enum Code {
+        //@formatter:off
+        /** nihuta m pealmist väärtust q positsiooni võrra allapoole */
+        SLIDE,
+
+        /** loe m väärtust FP-suhteliselt aadressilt j: LOADRC j; LOADM m */
+        LOADR,
+
+        /** salvesta m väärtust FP-suhtelisele aadressile j: LOADRC j; STOREM m */
+        STORER,
+        //@formatter:on
+    }
+
+    @Override
+    public String toString() {
+        return code.name() + " " + arg1 + " " + arg2;
+    }
+}

src/main/java/ee/ut/cs/sws/cma/instruction/CMaLabelInstruction.java

@@ -6,11 +6,17 @@ public record CMaLabelInstruction(Code code, CMaLabel label) implements CMaInstr
 
     public enum Code {
         //@formatter:off
+        /** lae label väärtus pinule */
+        LOADLC,
+
         /** hüppa labelile */
         JUMP,
 
         /** hüppa labelile kui stackipealne väärtus on 0 */
         JUMPZ,
+
+        /** indekseeritud hüpe: PC = target(label) + S[SP]; SP-- */
+        JUMPI,
         //@formatter:on
     }