Performed some minor simplifications on the java writer, removed some duplicate code

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import org.objectweb.asm.Type;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaClassInfo {
+	public static JavaClassInfo get(Class<?> cls) {
+		return new JavaClassInfo(Type.getInternalName(cls));
+	}
+	
 	public final String internalClassName;
 	
 	public JavaClassInfo(String internalClassName) {

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

 import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
 
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
+import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
 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 Map<String, JavaClassWriter> scriptBlocks = new HashMap<>();
+	private final Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
 	private final JavaClassWriter scriptsClassWriter;
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
 	public JavaCompiler(boolean debug) {
 		target = new JavaModule();
 		
-		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES, true);
+		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	}
 	
 	public void addDefinition(HighLevelDefinition definition) {
-		// convert definition into java class
-
-		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(methodName))));
-
+		String className = getClassName(definition.position.filename);
+		JavaScriptFile scriptFile = getScriptFile(className);
+		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
 	}
 	
 	public void addScriptBlock(ScriptBlock script) {
 		final SourceFile sourceFile = script.getTag(SourceFile.class);
-		final String methodName;
-		if (sourceFile == null) {
-			methodName = "generatedBlock" + (generatedScriptBlockCounter++);
-		} else {
-			// TODO: remove special characters
-			System.out.println("Writing script: " + sourceFile.filename);
-			methodName = sourceFile.filename.substring(0, sourceFile.filename.lastIndexOf('.')).replace("/", "_");
-		}
-
-		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);
-		}
+		final String className = getClassName(sourceFile == null ? null : sourceFile.filename);
+		JavaScriptFile scriptFile = getScriptFile(className);
 
 		// 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 JavaClassWriter visitor = scriptBlocks.get(methodName);
-		visitor.hasRun = true;
-		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(methodName), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		final JavaClassWriter visitor = scriptFile.classWriter;
+		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(className), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		scriptFile.scriptMethods.add(method);
+		
 		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, method, null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
 		statementVisitor.end();
 	}
 	
+	private String getClassName(String filename) {
+		if (filename == null) {
+			return "generatedBlock" + (generatedScriptBlockCounter++);
+		} else {
+			// TODO: remove special characters
+			System.out.println("Writing script: " + filename);
+			return filename.substring(0, filename.lastIndexOf('.')).replace("/", "_");
+		}
+	}
+	
+	private JavaScriptFile getScriptFile(String className) {
+		if (!scriptBlocks.containsKey(className)) {
+			JavaClassWriter scriptFileWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+			scriptFileWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);
+			scriptBlocks.put(className, new JavaScriptFile(scriptFileWriter));
+		}
+		
+		return scriptBlocks.get(className);
+	}
+	
 	public JavaModule finish() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClassInfo("Scripts"), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null);
 		runWriter.start();
-		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());
+		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
+			for (JavaMethodInfo method : entry.getValue().scriptMethods)
+				runWriter.invokeStatic(method);
+			
+			entry.getValue().classWriter.visitEnd();
+			target.register(entry.getKey(), entry.getValue().classWriter.toByteArray());
 		}
 		runWriter.ret();
 		runWriter.end();

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

 package org.openzen.zenscript.javabytecode;
 
 import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaMethodInfo {
+	public static JavaMethodInfo get(int modifiers, Class owner, String name, Class result, Class... arguments) {
+        StringBuilder descriptor = new StringBuilder();
+        descriptor.append('(');
+        for (Class argument : arguments) {
+            descriptor.append(Type.getDescriptor(argument));
+        }
+        descriptor.append(')');
+        descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
+		return new JavaMethodInfo(new JavaClassInfo(Type.getInternalName(owner)), name, descriptor.toString(), modifiers);
+    }
+	
 	public final JavaClassInfo javaClass;
 	public final String name;
 	public final String descriptor;

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

 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/JavaExpressionVisitor.java

 import org.openzen.zenscript.shared.CompileExceptionCode;
 
 import java.util.Map;
+import org.objectweb.asm.Opcodes;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
+	private static final JavaMethodInfo MAP_PUT = JavaMethodInfo.get(Opcodes.ACC_PUBLIC, Map.class, "put", Object.class, Object.class, Object.class);
+	
     private final JavaWriter javaWriter;
 	
     public JavaExpressionVisitor(JavaWriter javaWriter) {
         final Type operatorType = Type.getType(CompareType.class);
         javaWriter.getStaticField(operatorType.getInternalName(), expression.operator.name(), operatorType.getDescriptor());
 
-        javaWriter.invokeStatic(ZenUtils.class, "compare", boolean.class, getForEquals(expression.left.type), getForEquals(expression.right.type), CompareType.class);
+		// TODO: should be implemented properly
+		JavaMethodInfo compareMethod = JavaMethodInfo.get(
+				0,
+				ZenUtils.class,
+				"compare",
+				boolean.class,
+				getForEquals(expression.left.type),
+				getForEquals(expression.right.type),
+				CompareType.class);
+        javaWriter.invokeStatic(compareMethod);
 
         return null;
     }
         }
         //TODO: Test with actual static method
         final JavaMethodInfo info = expression.member.getTag(JavaMethodInfo.class);
-        javaWriter.invokeStatic(info.javaClass.internalClassName, info.name, info.descriptor);
+        javaWriter.invokeStatic(info);
         return null;
     }
 
             javaWriter.dup();
             expression.keys[i].accept(this);
             expression.values[i].accept(this);
-            javaWriter.invokeInterface(Map.class, "put", Object.class, Object.class, Object.class);
+            javaWriter.invokeInterface(MAP_PUT);
             javaWriter.pop();
         }
         return null;
         if (methodInfo == null)
             return false;
         if (methodInfo.isStatic()) {
-            getJavaWriter().invokeStatic(methodInfo.javaClass.internalClassName,
-                    methodInfo.name,
-                    methodInfo.descriptor);
+            getJavaWriter().invokeStatic(methodInfo);
         } else {
-            getJavaWriter().invokeVirtual(methodInfo.javaClass.internalClassName,
-                    methodInfo.name,
-                    methodInfo.descriptor);
+            getJavaWriter().invokeVirtual(methodInfo);
         }
         return true;
     }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode.compiler;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaScriptFile {
+	public final JavaClassWriter classWriter;
+	public final List<JavaMethodInfo> scriptMethods;
+	
+	public JavaScriptFile(JavaClassWriter classWriter) {
+		this.classWriter = classWriter;
+		this.scriptMethods = new ArrayList<>();
+	}
+}

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

 import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 public class JavaWriter {
+	private static final JavaClassInfo T_STRING = new JavaClassInfo("java/lang/String");
+	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
+			T_STRING,
+			"concat",
+			"(Ljava/lang/String;)Ljava/lang/String;",
+			Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+	
 	public final JavaMethodInfo method;
 	
     private final LocalVariablesSorter visitor;
 
         visitor.visitTypeInsn(INSTANCEOF, clsName);
     }
-
-    public void invokeStatic(String owner, String name, String descriptor) {
-        if (debug)
-            System.out.println("invokeStatic " + owner + '.' + name + descriptor);
-
-        if (owner == null)
-            throw new IllegalArgumentException("owner cannot be null");
-        if (name == null)
-            throw new IllegalArgumentException("name cannot be null");
-        if (descriptor == null)
-            throw new IllegalArgumentException("descriptor cannot be null");
-
-        visitor.visitMethodInsn(INVOKESTATIC, owner, name, descriptor, false);
-    }
-
-    public void invokeStatic(Class owner, String name, Class result, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(signature(argument));
-        }
-        descriptor.append(')');
-        descriptor.append(result == null ? 'V' : signature(result));
-
-        if (debug)
-            System.out.println("invokeStatic " + internal(owner) + '.' + name + descriptor);
-
-        visitor.visitMethodInsn(INVOKESTATIC, internal(owner), name, descriptor.toString(), false);
-    }
+	
+	public void invokeStatic(JavaMethodInfo method) {
+		visitor.visitMethodInsn(
+				INVOKESTATIC,
+				method.javaClass.internalClassName,
+				method.name,
+				method.descriptor,
+				false);
+	}
 
     public void invokeSpecial(String owner, String name, String descriptor) {
         if (debug)
     public void invokeSpecial(Class owner, String name, String descriptor) {
         invokeSpecial(Type.getInternalName(owner), name, descriptor);
     }
-
-    public void invoke(Class owner, String name, Class result, Class... arguments) {
-        if (owner.isInterface()) {
-            invokeInterface(owner, name, result, arguments);
-        } else {
-            invokeVirtual(owner, name, result, arguments);
-        }
-    }
-
-    public void invokeVirtual(String owner, String name, String descriptor) {
-        if (debug)
-            System.out.println("invokeVirtual " + owner + '.' + name + descriptor);
-
-        visitor.visitMethodInsn(INVOKEVIRTUAL, owner, name, descriptor, false);
-    }
-
-    public void invokeVirtual(Class owner, String name, Class result, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(signature(argument));
-        }
-        descriptor.append(')');
-        descriptor.append(result == null ? 'V' : signature(result));
-
-        if (debug)
-            System.out.println("invokeVirtual " + owner + '.' + name + descriptor);
-
-        visitor.visitMethodInsn(INVOKEVIRTUAL, internal(owner), name, descriptor.toString(), false);
-    }
-
-    public void invokeInterface(String owner, String name, String descriptor) {
+	
+	public void invokeVirtual(JavaMethodInfo method) {
         if (debug)
-            System.out.println("invokeInterface " + owner + '.' + name + descriptor);
-
-        visitor.visitMethodInsn(INVOKEINTERFACE, owner, name, descriptor, true);
-    }
+            System.out.println("invokeVirtual " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);
 
-    public void invokeInterface(Class owner, String name, Class result, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(signature(argument));
-        }
-        descriptor.append(')');
-        descriptor.append(result == null ? 'V' : signature(result));
+        visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalClassName, method.name, method.descriptor, false);
+	}
 
+    public void invokeInterface(JavaMethodInfo method) {
         if (debug)
-            System.out.println("invokeInterface " + owner + '.' + name + descriptor);
+            System.out.println("invokeInterface " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEINTERFACE, internal(owner), name, descriptor.toString(), true);
+        visitor.visitMethodInsn(INVOKEINTERFACE, method.javaClass.internalClassName, method.name, method.descriptor, true);
     }
 
     public void newObject(Class type) {
     }
 
     public void stringAdd() {
-        invokeVirtual("java/lang/String", "concat", "(Ljava/lang/String;)Ljava/lang/String;");
+        invokeVirtual(STRING_CONCAT);
     }
 
     public Label getNamedLabel(String label) {

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

 import java.util.Iterator;
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-
+	private static final JavaClassInfo T_CLASS = new JavaClassInfo("java/lang/Class");
+	private static final JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
+			T_CLASS,
+			"forName",
+			"(Ljava/lang/String;)Ljava/lang/Class;",
+			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+	
+	private static final JavaClassInfo T_ENUM = new JavaClassInfo("java/lang/Enum");
+	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
+			T_ENUM,
+			"valueOf",
+			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
+			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 
     private final JavaClassWriter outerWriter;
 
 
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
+		
+		JavaClassInfo arrayClass = new JavaClassInfo("[L" + definition.name + ";");
+		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
 
 		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
         JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, null, null);
         valuesWriter.start();
         valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        valuesWriter.invokeVirtual("[L" + definition.name + ";", "clone", "()Ljava/lang/Object;");
+        valuesWriter.invokeVirtual(arrayClone);
         valuesWriter.checkCast("[L" + definition.name + ";");
         valuesWriter.returnObject();
         valuesWriter.end();
 		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
         JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, null, null);
         valueOfWriter.start();
-        valueOfWriter.invokeStatic("java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
+        valueOfWriter.invokeStatic(CLASS_FORNAME);
         valueOfWriter.loadObject(0);
-        valueOfWriter.invokeStatic("java/lang/Enum", "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
+        valueOfWriter.invokeStatic(ENUM_VALUEOF);
         valueOfWriter.checkCast("L" + definition.name + ";");
         valueOfWriter.returnObject();
         valueOfWriter.end();

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/GlobalRegistry.java

 	
 	public GlobalRegistry(ZSPackage globals) {
 		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
-		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V", Opcodes.ACC_PUBLIC));
+		JavaMethodInfo printstreamPrintln = new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V", Opcodes.ACC_PUBLIC);
+		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, printstreamPrintln);
 		
 		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
 		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
 		
 		PRINTLN.caller.setTag(JavaBytecodeImplementation.class, writer -> {
 			writer.getField(System.class, "out", PrintStream.class);
-			writer.invokeVirtual("java/io/PrintStream", "println", "(Ljava/lang/String;)V");
+			writer.invokeVirtual(printstreamPrintln);
 		});
 	}