One generated class per script file + classes

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 package org.openzen.zenscript.javabytecode;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
 
+import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 	}
 	
 	private final JavaModule target;
-	private final List<String> scriptBlockNames = new ArrayList<>();
-	private final ClassWriter scriptsClassWriter;
+	private final Map<String, JavaClassWriter> scriptBlocks = new HashMap<>();
+	private final JavaClassWriter scriptsClassWriter;
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
 	
 	public JavaCompiler(boolean debug) {
 		target = new JavaModule();
 		
-		scriptsClassWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES, true);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	}
 	
 	public void addDefinition(HighLevelDefinition definition) {
 		// convert definition into java class
-		target.register(definition.name, definition.accept(new JavaDefinitionVisitor()));
+
+		final String methodName = definition.position.filename.substring(0, definition.position.filename.lastIndexOf('.')).replace("/", "_");
+
+
+		if(!scriptBlocks.containsKey(methodName)) {
+			JavaClassWriter scriptFileWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+			scriptFileWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, methodName, null, "java/lang/Object", null);
+			scriptBlocks.put(methodName, scriptFileWriter);
+		}
+
+		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptBlocks.get(definition.position.filename))));
 
 	}
 	
 	public void addScriptBlock(ScriptBlock script) {
-		SourceFile sourceFile = script.getTag(SourceFile.class);
-		String methodName;
+		final SourceFile sourceFile = script.getTag(SourceFile.class);
+		final String methodName;
 		if (sourceFile == null) {
 			methodName = "generatedBlock" + (generatedScriptBlockCounter++);
 		} else {
 			methodName = sourceFile.filename.substring(0, sourceFile.filename.lastIndexOf('.')).replace("/", "_");
 		}
 
-		scriptBlockNames.add(methodName);
+		if(!scriptBlocks.containsKey(methodName)) {
+			JavaClassWriter scriptFileWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES, true);
+			scriptFileWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, methodName, null, "java/lang/Object", null);
+			scriptBlocks.put(methodName, scriptFileWriter);
+		}
 
 		// convert scripts into methods (add them to a Scripts class?)
 		// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
-		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(scriptsClassWriter, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, methodName, "()V", null, null));
+		final JavaClassWriter visitor = scriptBlocks.get(methodName);
+		visitor.hasRun = true;
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
 			statement.accept(statementVisitor);
 		
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null);
 		runWriter.start();
-		for (String scriptBlockName : scriptBlockNames) {
-			runWriter.invokeStatic("Scripts", scriptBlockName, "()V");
+		for (Map.Entry<String, JavaClassWriter> entry : scriptBlocks.entrySet()) {
+			final String owner = entry.getKey();
+			final JavaClassWriter classWriter = entry.getValue();
+			if(classWriter.hasRun)
+				runWriter.invokeStatic(owner, "run", "()V");
+			classWriter.visitEnd();
+			target.register(owner, classWriter.toByteArray());
 		}
 		runWriter.ret();
 		runWriter.end();

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaModule.java

  * @author Hoofdgebruiker
  */
 public class JavaModule {
-	private Map<String, byte[]> classes = new HashMap<>();
+	private final Map<String, byte[]> classes = new HashMap<>();
 	
 	public JavaModule() {
 		
 	}
 	
 	public void register(String classname, byte[] bytecode) {
+		if(bytecode == null) return;
 		classes.put(classname, bytecode);
 		try(FileOutputStream writer = new FileOutputStream(new File(classname + ".class"))) {
 			writer.write(bytecode);
 		
 		try {
 			classLoader.loadClass("Scripts").getMethod("run").invoke(null);
-		} catch (ClassNotFoundException ex) {
-			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
-		} catch (NoSuchMethodException ex) {
-			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
-		} catch (SecurityException ex) {
-			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
-		} catch (IllegalAccessException ex) {
-			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
-		} catch (IllegalArgumentException ex) {
-			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
-		} catch (InvocationTargetException ex) {
+		} catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
 			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
 		}
 	}
 	
 	private class ScriptClassLoader extends ClassLoader {
-		final Map<String, Class> customClasses = new HashMap<>();
+		private final Map<String, Class> customClasses = new HashMap<>();
 
 		@Override
 		public Class<?> loadClass(String name) throws ClassNotFoundException {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaClassWriter.java

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.ClassWriter;
+
+public class JavaClassWriter extends ClassWriter {
+
+    public boolean hasRun;
+
+    public JavaClassWriter(int flags) {
+        super(flags);
+        this.hasRun = false;
+    }
+
+    public JavaClassWriter(int flags, boolean hasRun) {
+        super(flags);
+        this.hasRun = hasRun;
+    }
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 
 
+    private final ClassWriter outerWriter;
+
+    public JavaDefinitionVisitor(ClassWriter outerWriter) {
+
+        this.outerWriter = outerWriter;
+    }
+
     @Override
     public byte[] visitClass(ClassDefinition definition) {
-
+        //Classes will always be created in a new File/Class
 
         final Type superType;
         if (definition.superType == null)

ScriptingExample/scripts/conditionals.zs

+val ternaryOperation = true ? 100 : 222;
+
+println(ternaryOperation);
+
+
+
+var coalesce_one as string? = null;
+var coalesce_tow as string? = "test";
+
+
+var coalesce = coalesce_one ?? coalesce_tow;
+
+println(coalesce);
+
+
+//if(coalesce == "test123") {
+//	println("true");
+//}
+
+if(1 == 1) {
+	println("intCompareTrue");
+}
+
+//if(1 == "1") {
+//	println("well...");
+//}
+
+
+if("1" == 1) {
+	println("...");
+}
+
+
+//var coco as int? = 10;
+//var coal as int? = 1;
+//
+//println(coal ?? coco);
+
+
+println(".....");
+println(true ? "RR" : "TT");
+
+
+println((false && true && true) ? "true" : "false");
+println((true && true) ? "true" : "false");
+println((true && false) ? "true" : "false");
+println((false && false) ? "true" : "false");
+
+println("---");
+
+println((false || true) ? "true" : "false");
+println((true || true) ? "true" : "false");
+println((true || false) ? "true" : "false");
+println((false || false) ? "true" : "false");
+
+println(":::");
+
+println((1 <= 2) ? "true" : "false");

ScriptingExample/scripts/moreHellos.zs

 
 println("");
 
-var test2 = [1, 2, 3];
+var test3 = [1, 2, 3];
 
-for item in test2 {
+for item in test3 {
 	println(item);
 }