Merge branch 'development' of git.openzen.org:kindlich/ZenScript into development

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(methodName))));
 
 	}
 	
 	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/TestIsStaticInfo.java

+package org.openzen.zenscript.javabytecode;
+
+public class TestIsStaticInfo {
+    public final boolean isStatic;
+
+    public TestIsStaticInfo(boolean isStatic) {
+        this.isStatic = isStatic;
+    }
+}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 public class CompilerUtils {
     public static String calcDesc(FunctionHeader header, boolean isEnum) {
         StringBuilder descBuilder = new StringBuilder("(");
-        if(isEnum)
+        if (isEnum)
             descBuilder.append("Ljava/lang/String;I");
         for (FunctionParameter parameter : header.parameters) {
             descBuilder.append(Type.getDescriptor(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
         signatureBuilder.append(")").append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
         return signatureBuilder.toString();
     }
+
+    public static boolean isPrimitive(ITypeID id) {
+        if (id instanceof BasicTypeID) {
+            switch ((BasicTypeID) id) {
+                case BOOL:
+                case BYTE:
+                case SBYTE:
+                case SHORT:
+                case USHORT:
+                case INT:
+                case UINT:
+                case LONG:
+                case ULONG:
+                case FLOAT:
+                case DOUBLE:
+                case CHAR:
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    public static int calcAccess(int modifiers) {
+        int out = 0;
+        if (Modifiers.isStatic(modifiers))
+            out |= Opcodes.ACC_STATIC;
+        if (Modifiers.isFinal(modifiers))
+            out |= Opcodes.ACC_FINAL;
+        if (Modifiers.isPublic(modifiers))
+            out |= Opcodes.ACC_PUBLIC;
+        if (Modifiers.isPrivate(modifiers))
+            out |= Opcodes.ACC_PRIVATE;
+        if (Modifiers.isProtected(modifiers))
+            out |= Opcodes.ACC_PROTECTED;
+        if (Modifiers.isAbstract(modifiers))
+            out |= Opcodes.ACC_ABSTRACT;
+        return out;
+    }
+
+    public static String calcClasName(CodePosition position) {
+        return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
+    }
 }

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

 
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
-
 import java.util.Map;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         this.isInit = isInit;
     }
 
+    private static Class<?> getForEquals(ITypeID id) {
+        if (CompilerUtils.isPrimitive(id))
+            return id.accept(JavaTypeClassVisitor.INSTANCE);
+        return Object.class;
+    }
+
     @Override
     public Void visitAndAnd(AndAndExpression expression) {
+        Label end = new Label();
+        Label onFalse = new Label();
+
+        expression.left.accept(this);
+
+        javaWriter.ifEQ(onFalse);
+        expression.right.accept(this);
+
+        // //these two calls are redundant but make decompiled code look better. Keep?
+        // javaWriter.ifEQ(onFalse);
+        // javaWriter.iConst1();
+
+        javaWriter.goTo(end);
+
+        javaWriter.label(onFalse);
+        javaWriter.iConst0();
+
+
+        javaWriter.label(end);
+
         return null;
     }
 
 
     @Override
     public Void visitCompare(BasicCompareExpression expression) {
+        expression.left.accept(this);
+        expression.right.accept(this);
+        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);
+
         return null;
     }
 
 
     @Override
     public Void visitCallStatic(CallStaticExpression expression) {
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        //TODO: Test with actual static method
+        final JavaMethodInfo info = expression.member.getTag(JavaMethodInfo.class);
+        javaWriter.invokeStatic(info.javaClass.internalClassName, info.name, info.signature);
         return null;
     }
 
     public Void visitCapturedThis(CapturedThisExpression expression) {
         return null;
     }
-	
-	@Override
+
+    @Override
     public Void visitCast(CastExpression expression) {
-		expression.target.accept(this);
+        expression.target.accept(this);
         if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
             throw new IllegalStateException("Call target has no method info!");
-		
+
         return null;
-	}
+    }
 
     @Override
     public Void visitCheckNull(CheckNullExpression expression) {
+        final Label end = new Label();
+        expression.value.accept(this);
+        javaWriter.dup();
+        javaWriter.ifNonNull(end);
+        javaWriter.pop();
+        javaWriter.newObject(NullPointerException.class);
+        javaWriter.dup();
+        javaWriter.constant("Tried to convert a null value to nonnull type " + expression.type.accept(JavaTypeClassVisitor.INSTANCE).getSimpleName());
+        javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
+        javaWriter.aThrow();
+        javaWriter.label(end);
+
         return null;
     }
 
     @Override
     public Void visitCoalesce(CoalesceExpression expression) {
+        final Label end = new Label();
+        expression.left.accept(this);
+        javaWriter.dup();
+        javaWriter.ifNonNull(end);
+        javaWriter.pop();
+        expression.right.accept(this);
+        javaWriter.label(end);
         return null;
     }
 
     @Override
     public Void visitConditional(ConditionalExpression expression) {
+        final Label end = new Label();
+        final Label onElse = new Label();
+        expression.condition.accept(this);
+        javaWriter.ifEQ(onElse);
+        expression.ifThen.accept(this);
+        javaWriter.goTo(end);
+        javaWriter.label(onElse);
+        expression.ifElse.accept(this);
+        javaWriter.label(end);
         return null;
     }
 
     @Override
     public Void visitConstantBool(ConstantBoolExpression expression) {
-        getJavaWriter().constant(expression.value);
+        if (expression.value)
+            javaWriter.iConst1();
+        else
+            javaWriter.iConst0();
         return null;
     }
 
 
     @Override
     public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+        javaWriter.loadObject(0);
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        //No super calls in enums possible, and that's already handled in the enum constructor itself.
+        javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.header, false));
         return null;
     }
 
     @Override
     public Void visitEnumConstant(EnumConstantExpression expression) {
+        final Type type = expression.type.accept(JavaTypeVisitor.INSTANCE);
+        javaWriter.getStaticField(type.getInternalName(), expression.value.name, type.getDescriptor());
         return null;
     }
 
 
     @Override
     public Void visitGenericCompare(GenericCompareExpression expression) {
+        //TODO: What am I supposed to do here?
         return null;
     }
 
 
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), expression.parameter.index + 1);
+        //TODO is Static?
+        final boolean isStatic = false;
+        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), isStatic ? expression.parameter.index : expression.parameter.index + 1);
         return null;
     }
 
     public Void visitGetter(GetterExpression expression) {
         return null;
     }
-	
-	@Override
-	public Void visitGlobal(GlobalExpression expression) {
-		return expression.resolution.accept(this);
-	}
-	
-	@Override
-	public Void visitGlobalCall(GlobalCallExpression expression) {
-		return expression.resolution.accept(this);
-	}
+
+    @Override
+    public Void visitGlobal(GlobalExpression expression) {
+        return expression.resolution.accept(this);
+    }
+
+    @Override
+    public Void visitGlobalCall(GlobalCallExpression expression) {
+        return expression.resolution.accept(this);
+    }
 
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
 
     @Override
     public Void visitMakeConst(MakeConstExpression expression) {
-
+        //TODO: What am I supposed to do here?
         return null;
     }
 
     @Override
     public Void visitNew(NewExpression expression) {
         final String type;
-        if(expression.type instanceof DefinitionTypeID)
+        if (expression.type instanceof DefinitionTypeID)
             type = ((DefinitionTypeID) expression.type).definition.name;
         else
             type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
 
     @Override
     public Void visitOrOr(OrOrExpression expression) {
+        Label end = new Label();
+        Label onTrue = new Label();
+
+        expression.left.accept(this);
+
+        javaWriter.ifNE(onTrue);
+        expression.right.accept(this);
+
+        // //these two calls are redundant but make decompiled code look better. Keep?
+        // javaWriter.ifNE(onTrue);
+        // javaWriter.iConst0();
+
+        javaWriter.goTo(end);
+
+        javaWriter.label(onTrue);
+        javaWriter.iConst1();
+
+
+        javaWriter.label(end);
+
         return null;
     }
 
 
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+        //TODO is static?
+        final boolean isStatic = false;
+        expression.value.accept(this);
+        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), isStatic ? expression.parameter.index : expression.parameter.index + 1);
         return null;
     }
 
 
     @Override
     public Void visitWrapOptional(WrapOptionalExpression expression) {
+        //TODO What am I supposed to do here?
+        expression.value.accept(this);
         return null;
     }
 

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

         visitor.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, false);
     }
 
+    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);

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.CompareType;
+
+import java.util.Objects;
+
+public class ZenUtils {
+
+    // ###############
+    // ### Compare ###
+    // ###############
+    public static boolean compare(Object a, Object b, CompareType type) {
+        if (type == CompareType.SAME || type == CompareType.NOTSAME) {
+            final boolean same = a == b;
+            return (type == CompareType.SAME) == same;
+        }
+
+        //TODO how to compare them?
+        if (a instanceof Comparable)
+            return checkCompareReturn(((Comparable) a).compareTo(b), type);
+        return false;
+    }
+
+
+    public static boolean compare(boolean a, boolean b, CompareType compareType) {
+        return checkCompareReturn(Boolean.compare(a, b), compareType);
+    }
+
+    public static boolean compare(int a, int b, CompareType compareType) {
+        return checkCompareReturn(Integer.compare(a, b), compareType);
+    }
+
+    public static boolean compare(char a, char b, CompareType compareType) {
+        return checkCompareReturn(Character.compare(a, b), compareType);
+    }
+
+    public static boolean compare(byte a, byte b, CompareType compareType) {
+        return checkCompareReturn(Byte.compare(a, b), compareType);
+    }
+
+    public static boolean compare(short a, short b, CompareType compareType) {
+        return checkCompareReturn(Short.compare(a, b), compareType);
+    }
+
+    public static boolean compare(long a, long b, CompareType compareType) {
+        return checkCompareReturn(Long.compare(a, b), compareType);
+    }
+
+    public static boolean compare(float a, float b, CompareType compareType) {
+        return checkCompareReturn(Float.compare(a, b), compareType);
+    }
+
+    public static boolean compare(double a, double b, CompareType compareType) {
+        return checkCompareReturn(Double.compare(a, b), compareType);
+    }
+
+    private static boolean checkCompareReturn(int compareResult, CompareType type) {
+        switch (type) {
+            case LT:
+                return compareResult < 0;
+            case GT:
+                return compareResult > 0;
+            case EQ:
+            case SAME:
+                return compareResult == 0;
+            case NOTSAME:
+            case NE:
+                return compareResult != 0;
+            case LE:
+                return compareResult <= 0;
+            case GE:
+                return compareResult >= 0;
+            default:
+                return false;
+        }
+    }
+}

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

 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaEnumInfo;
-import org.openzen.zenscript.javabytecode.compiler.JavaExpressionVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaTypeClassVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.TestIsStaticInfo;
+import org.openzen.zenscript.javabytecode.compiler.*;
+
+import java.util.Iterator;
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 
 
+    private final JavaClassWriter outerWriter;
+
+    public JavaDefinitionVisitor(JavaClassWriter 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)
         else
             superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
 
-        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         //TODO: Interfaces?
         clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
 
         for (IDefinitionMember member : definition.members) {
-            if(!(member instanceof EnumConstantMember)) continue;
+            if (!(member instanceof EnumConstantMember)) continue;
             final EnumConstantMember constantMember = (EnumConstantMember) member;
             clinitWriter.dup();
             clinitWriter.constant(constantMember.value);
 
     @Override
     public byte[] visitFunction(FunctionDefinition definition) {
+        final String signature = CompilerUtils.calcSign(definition.header, false);
+        final JavaWriter writer = new JavaWriter(outerWriter, true, CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC, definition.name, CompilerUtils.calcDesc(definition.header, false), signature, null);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
+        statementVisitor.start();
+        final Iterator<Statement> statementIterator = definition.statements.iterator();
+
+        //TODO this is dirty, fix when there is a way of knowing if a parameter is static or not
+        for (FunctionParameter parameter : definition.header.parameters) {
+            parameter.index -= 1;
+        }
+        while (statementIterator.hasNext()) {
+            final Statement statement = statementIterator.next();
+            statement.accept(statementVisitor);
+            if (!statementIterator.hasNext() && !(statement instanceof ReturnStatement)) {
+                ITypeID type = definition.header.returnType;
+                if (CompilerUtils.isPrimitive(type))
+                    writer.iConst0();
+                else if (type != BasicTypeID.VOID)
+                    writer.aConstNull();
+                writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
+            }
+
+        }
+
+        statementVisitor.end();
+
+        final JavaMethodInfo methodInfo = new JavaMethodInfo(new JavaClassInfo(CompilerUtils.calcClasName(definition.position)), definition.name, signature, true);
+
+        definition.setTag(JavaMethodInfo.class, methodInfo);
+        definition.caller.setTag(JavaMethodInfo.class, methodInfo);
         return 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/functions.zs

+function test() {
+	println("functions.zs; test1");
+}
+
+
+
+function test2() as void {
+	println("functions.zs; test2");
+}
+
+
+test();
+test2();
+println(test3(1, 3));
+
+
+function test3(a as int, b as int) as int{
+	println(a+b);
+	return a + b;
+}

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);
 }