Merge branch 'jvm-sandboxing-transformer'

# Conflicts:
#	Lang/src/main/java/chipmunk/compiler/codegen/TryCatchVisitor.java
#	Lang/src/main/java/chipmunk/vm/ChipmunkVM.java

Lang/src/main/java/chipmunk/compiler/codegen/Codegen.java

@@ -261,7 +261,7 @@ public boolean inIfElse(){
 	}
 
 	public TryCatchLabels pushTryCatch() {
-		TryCatchLabels labels = new TryCatchLabels(assembler.nextLabelName(), assembler.nextLabelName());
+		TryCatchLabels labels = new TryCatchLabels(assembler.nextLabelName(), assembler.nextLabelName(), assembler.nextLabelName());
 		tryCatchStack.add(labels);
 		return labels;
 	}

Lang/src/main/java/chipmunk/compiler/codegen/FinallyBlock.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2023 MyWorld, LLC
+ * All rights reserved.
+ *
+ * This file is part of Chipmunk.
+ *
+ * Chipmunk is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chipmunk is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Chipmunk.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package chipmunk.compiler.codegen;
+
+public class FinallyBlock extends BlockLabels {
+    public FinallyBlock(String start, String end) {
+        super(start, end);
+    }
+}

Lang/src/main/java/chipmunk/compiler/codegen/TryCatchLabels.java

@@ -26,13 +26,29 @@
 public class TryCatchLabels extends BlockLabels {
 
 	protected final List<BlockLabels> catchBlocks;
+	protected final String successTarget;
+	protected boolean successMarked;
 
-	public TryCatchLabels(String start, String end) {
+	public TryCatchLabels(String start, String end, String successTarget) {
 		super(start, end);
 		catchBlocks = new ArrayList<>();
+		this.successTarget = successTarget;
+		successMarked = false;
 	}
 
 	public List<BlockLabels> getCatchBlocks(){
 		return catchBlocks;
 	}
+
+	public String getSuccessTarget(){
+		return successTarget;
+	}
+
+	public void setSuccessMarked(){
+		successMarked = true;
+	}
+
+	public boolean isSuccessMarked(){
+		return successMarked;
+	}
 }

Lang/src/main/java/chipmunk/compiler/codegen/TryCatchVisitor.java

@@ -37,7 +37,13 @@ public void visit(AstNode node) {
 			TryCatchLabels labels = codegen.pushTryCatch();
 
 			node.visitChildren(this);
-
+
+			// If no finally block exists, set the success target
+			// (this will run right after the last catch block has been assembled)
+			if(!labels.isSuccessMarked()){
+				setSuccessTarget(labels);
+			}
+
 			// Build exception table
 			ExceptionBlock block = new ExceptionBlock();
 			block.startIndex = codegen.getAssembler().getLabelTarget(labels.start);
@@ -47,15 +53,18 @@ public void visit(AstNode node) {
 
 			codegen.addExceptionBlock(block);
 			codegen.exitTryCatch();
+
 		}else if(node.getNodeType() == NodeType.TRY) {
-			codegen.getAssembler().setLabelTarget(codegen.peekClosestTryCatch().getStartLabel());
+			TryCatchLabels labels = codegen.peekClosestTryCatch();
+			codegen.getAssembler().setLabelTarget(labels.getStartLabel());
 
 			// Assemble try body
 			codegen.enterScope(node.getSymbolTable());
 			node.visitChildren(codegen);
 			codegen.exitScope();
-
-			codegen.getAssembler().setLabelTarget(codegen.peekClosestTryCatch().getEndLabel());
+
+			codegen.getAssembler()._goto(labels.getSuccessTarget());
+			codegen.getAssembler().setLabelTarget(labels.getEndLabel());
 		}else if(node.getNodeType() == NodeType.CATCH) {
 
 			CatchBlock catchLabels = new CatchBlock(codegen.getAssembler().nextLabelName(), codegen.getAssembler().nextLabelName());
@@ -74,10 +83,14 @@ public void visit(AstNode node) {
 			codegen.exitScope();
 
 			codegen.getAssembler().setLabelTarget(catchLabels.getEndLabel());
+
 		}else if(node.getNodeType() == NodeType.FINALLY) {
-			BlockLabels finallyLabels = new BlockLabels(codegen.getAssembler().nextLabelName(), codegen.getAssembler().nextLabelName());
-			codegen.peekClosestTryCatch().getCatchBlocks().add(finallyLabels);
-
+			TryCatchLabels tryCatch = codegen.peekClosestTryCatch();
+			FinallyBlock finallyLabels = new FinallyBlock(codegen.getAssembler().nextLabelName(), codegen.getAssembler().nextLabelName());
+			tryCatch.getCatchBlocks().add(finallyLabels);
+
+			setSuccessTarget(tryCatch);
+
 			codegen.getAssembler().setLabelTarget(finallyLabels.getStartLabel());
 
 			// Assemble finally body
@@ -90,4 +103,9 @@ public void visit(AstNode node) {
 
 	}
 
+	protected void setSuccessTarget(TryCatchLabels labels){
+		codegen.getAssembler().setLabelTarget(labels.getSuccessTarget());
+		labels.setSuccessMarked();
+	}
+
 }

Lang/src/main/java/chipmunk/vm/ChipmunkScript.java

@@ -48,10 +48,10 @@ public static ChipmunkScript getCurrentScript(){
         return currentScript.get();
     }
 
-    public static void trap(TrapType type){
+    public static void trap(Object payload){
         var handler = getCurrentScript().getTrapHandler();
         if(handler != null){
-            handler.trap(type);
+            handler.runtimeTrap(payload);
         }
     }
 
@@ -140,7 +140,7 @@ public void setTrapHandler(TrapHandler trapHandler){
     }
 
     public TrapHandler getTrapHandler(){
-        return trapHandler;
+        return trapHandler != null ? trapHandler : vm.getDefaultTrapHandler();
     }
 
     public void setModuleLoader(ModuleLoader loader){

Lang/src/main/java/chipmunk/vm/ChipmunkVM.java

@@ -34,10 +34,7 @@
 import chipmunk.vm.invoke.security.AllowChipmunkLinkage;
 import chipmunk.vm.invoke.security.LinkingPolicy;
 import chipmunk.vm.invoke.security.SecurityMode;
-import chipmunk.vm.jvm.CompilationUnit;
-import chipmunk.vm.jvm.JvmCompilation;
-import chipmunk.vm.jvm.JvmCompiler;
-import chipmunk.vm.jvm.JvmCompilerConfig;
+import chipmunk.vm.jvm.*;
 import chipmunk.vm.scheduler.Scheduler;
 import jdk.dynalink.linker.GuardedInvocation;
 
@@ -78,7 +75,9 @@ public ChipmunkVM(SecurityMode securityMode) {
 		scriptExecutor = Executors.newVirtualThreadPerTaskExecutor();
 		scheduler = new Scheduler();
 
-		defaultJvmCompilerConfig = new JvmCompilerConfig();
+		defaultJvmCompilerConfig = new JvmCompilerConfig(defaultLinkPolicy);
+
+		defaultTrapHandler = new TrapHandler() {};
 	}
 
 	public LinkingPolicy getDefaultLinkPolicy(){
@@ -245,7 +244,7 @@ public ChipmunkModule load(BinaryModule module) {
 	}
 
 	public ChipmunkModule load(JvmCompiler jvmCompiler, BinaryModule module) {
-		JvmCompilation compilation = new JvmCompilation(module, new ModuleLoader());
+		JvmCompilation compilation = new JvmCompilation(module, new ModuleLoader(), defaultLinkPolicy);
 		return jvmCompiler.compileModule(compilation);
 	}
 
@@ -419,4 +418,28 @@ protected boolean isSamType(Class<?> interfaceType){
 		return nonDefaults == 1;
 	}
 
+	public static void trap(Object payload){
+
+	}
+
+	public static void backJump(TrapSite site){
+
+	}
+
+	public static void trapObjectAlloc(TrapSite site, Class<?> objectType){
+
+	}
+
+	public static void trapArrayAlloc(TrapSite site, Class<?> arrayType, int dimensions, int capacity){
+
+	}
+
+	public static void trapMethodCall(TrapSite site, MethodIdentifier method){
+
+	}
+
+	public static void trapObjectInit(TrapSite site, Object object){
+
+	}
+
 }

Lang/src/main/java/chipmunk/vm/TrapHandler.java

@@ -1,7 +1,27 @@
 package chipmunk.vm;
 
+import chipmunk.vm.jvm.MethodIdentifier;
+import chipmunk.vm.jvm.TrapSite;
+
 public interface TrapHandler {
 
-    void trap(TrapType type);
+    default void runtimeTrap(Object payload){}
+
+    default void backJump(TrapSite site){}
+    default void methodCall(TrapSite site, MethodIdentifier method){}
+    default Object postMethodCall(TrapSite site, MethodIdentifier method, Object result){
+        return result;
+    }
+
+    default void arrayAlloc(TrapSite site, Class<?> arrayClass, int dimensions, int capacity){}
+    default Object postArrayAlloc(TrapSite site, Object array){
+        return array;
+    }
+
+    default void objectAlloc(TrapSite site, Class<?> type){}
+
+    default Object postObjectInit(TrapSite site, Object object){
+        return object;
+    }
 
 }

Lang/src/main/java/chipmunk/vm/jvm/ForcedYieldThrowable.java

@@ -20,5 +20,5 @@
 
 package chipmunk.vm.jvm;
 
-public class ForcedYieldThrowable extends Throwable {
+public class ForcedYieldThrowable extends Uncatchable {
 }

Lang/src/main/java/chipmunk/vm/jvm/JvmCompilation.java

@@ -22,6 +22,7 @@
 
 import chipmunk.binary.BinaryModule;
 import chipmunk.vm.ModuleLoader;
+import chipmunk.vm.invoke.security.LinkingPolicy;
 
 import java.util.ArrayDeque;
 import java.util.Deque;
@@ -38,11 +39,15 @@ public class JvmCompilation {
     protected final Set<String> bindings;
     protected final Deque<NamespaceInfo> namespaceInfo;
 
-    public JvmCompilation(BinaryModule module, ModuleLoader loader){
+    protected final LinkingPolicy policy;
+
+    public JvmCompilation(BinaryModule module, ModuleLoader loader, LinkingPolicy policy){
         this.module = module;
         this.loader = loader;
         namespaceInfo = new ArrayDeque<>();
         bindings = new HashSet<>();
+
+        this.policy = policy;
     }
 
     public BinaryModule getModule() {
@@ -53,6 +58,10 @@ public ModuleLoader getLoader(){
         return loader;
     }
 
+    public LinkingPolicy getLinkingPolicy(){
+        return policy;
+    }
+
     public String getPackagePrefix() {
         return packagePrefix;
     }