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

# Conflicts:
#	ScriptingExample/scripts/statements.zs

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/BreakStatement.java

  * @author Hoofdgebruiker
  */
 public class BreakStatement extends Statement {
-	public final Statement target;
+	public final LoopStatement target;
 	
-	public BreakStatement(CodePosition position, Statement target) {
+	public BreakStatement(CodePosition position, LoopStatement target) {
 		super(position);
 		
 		this.target = target;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ContinueStatement.java

  * @author Hoofdgebruiker
  */
 public class ContinueStatement extends Statement {
-	public final Statement target;
+	public final LoopStatement target;
 	
-	public ContinueStatement(CodePosition position, Statement target) {
+	public ContinueStatement(CodePosition position, LoopStatement target) {
 		super(position);
 		
 		this.target = target;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ForeachStatement.java

  *
  * @author Hoofdgebruiker
  */
-public class ForeachStatement extends Statement {
+public class ForeachStatement extends LoopStatement {
 	public final VarStatement[] loopVariables;
 	public final Expression list;
 	public final IIteratorMember iterator;
 	public Statement content;
 	
 	public ForeachStatement(CodePosition position, VarStatement[] loopVariables, IIteratorMember iterator, Expression list) {
-		super(position);
+		super(position, loopVariables[0].name);
 		
 		this.loopVariables = loopVariables;
 		this.list = list;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/LoopStatement.java

  * @author Hoofdgebruiker
  */
 public abstract class LoopStatement extends Statement {
-	public final String label;
+	public String label;
 	
 	public LoopStatement(CodePosition position, String label) {
 		super(position);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/Statement.java

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.shared.Taggable;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public abstract class Statement {
+public abstract class Statement extends Taggable {
 	public final CodePosition position;
 	
 	public Statement(CodePosition position) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/implementations/IntRange.java

+package org.openzen.zenscript.implementations;
+
+public class IntRange {
+    public final int min;
+    public final int max;
+
+
+    public IntRange(int min, int max) {
+        this.min = min;
+        this.max = max;
+    }
+}

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

 		LONG_GET_MIN_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jLong, "MIN_VALUE", "J"));
 		LONG_GET_MAX_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jLong, "MAX_VALUE", "J"));
 		
-		implement(BOOL_NOT, writer -> writer.iNot());
-		
-		implement(BYTE_NOT, writer -> writer.iNot());
-		implement(SBYTE_NOT, writer -> writer.iNot());
-		implement(SHORT_NOT, writer -> writer.iNot());
-		implement(USHORT_NOT, writer -> writer.iNot());
-		implement(INT_NOT, writer -> writer.iNot());
-		implement(UINT_NOT, writer -> writer.iNot());
-		implement(LONG_NOT, writer -> writer.lNot());
-		implement(ULONG_NOT, writer -> writer.lNot());
-		
-		implement(BYTE_NEG, writer -> writer.iNeg());
-		implement(SBYTE_NEG, writer -> writer.iNeg());
-		implement(SHORT_NEG, writer -> writer.iNeg());
-		implement(USHORT_NEG, writer -> writer.iNeg());
-		implement(INT_NEG, writer -> writer.iNeg());
-		implement(UINT_NEG, writer -> writer.iNeg());
-		implement(LONG_NEG, writer -> writer.lNeg());
-		implement(ULONG_NEG, writer -> writer.lNeg());
-		implement(FLOAT_NEG, writer -> writer.fNeg());
-		implement(DOUBLE_NEG, writer -> writer.dNeg());
-		
-		implement(BYTE_ADD_BYTE, writer -> writer.iAdd());
-		implement(SBYTE_ADD_SBYTE, writer -> writer.iAdd());
-		implement(SHORT_ADD_SHORT, writer -> writer.iAdd());
-		implement(USHORT_ADD_USHORT, writer -> writer.iAdd());
-		implement(INT_ADD_INT, writer -> writer.iAdd());
-		implement(UINT_ADD_UINT, writer -> writer.iAdd());
-		implement(LONG_ADD_LONG, writer -> writer.lAdd());
-		implement(ULONG_ADD_ULONG, writer -> writer.lAdd());
-		implement(FLOAT_ADD_FLOAT, writer -> writer.fAdd());
-		implement(DOUBLE_ADD_DOUBLE, writer -> writer.dAdd());
+		implement(BOOL_NOT, JavaWriter::iNot);
+		
+		implement(BYTE_NOT, JavaWriter::iNot);
+		implement(SBYTE_NOT, JavaWriter::iNot);
+		implement(SHORT_NOT, JavaWriter::iNot);
+		implement(USHORT_NOT, JavaWriter::iNot);
+		implement(INT_NOT, JavaWriter::iNot);
+		implement(UINT_NOT, JavaWriter::iNot);
+		implement(LONG_NOT, JavaWriter::lNot);
+		implement(ULONG_NOT, JavaWriter::lNot);
+		
+		implement(BYTE_NEG, JavaWriter::iNeg);
+		implement(SBYTE_NEG, JavaWriter::iNeg);
+		implement(SHORT_NEG, JavaWriter::iNeg);
+		implement(USHORT_NEG, JavaWriter::iNeg);
+		implement(INT_NEG, JavaWriter::iNeg);
+		implement(UINT_NEG, JavaWriter::iNeg);
+		implement(LONG_NEG, JavaWriter::lNeg);
+		implement(ULONG_NEG, JavaWriter::lNeg);
+		implement(FLOAT_NEG, JavaWriter::fNeg);
+		implement(DOUBLE_NEG, JavaWriter::dNeg);
+		
+		implement(BYTE_ADD_BYTE, JavaWriter::iAdd);
+		implement(SBYTE_ADD_SBYTE, JavaWriter::iAdd);
+		implement(SHORT_ADD_SHORT, JavaWriter::iAdd);
+		implement(USHORT_ADD_USHORT, JavaWriter::iAdd);
+		implement(INT_ADD_INT, JavaWriter::iAdd);
+		implement(UINT_ADD_UINT, JavaWriter::iAdd);
+		implement(LONG_ADD_LONG, JavaWriter::lAdd);
+		implement(ULONG_ADD_ULONG, JavaWriter::lAdd);
+		implement(FLOAT_ADD_FLOAT, JavaWriter::fAdd);
+		implement(DOUBLE_ADD_DOUBLE, JavaWriter::dAdd);
 		// TODO: STRING_ADD_STRING
-		
-		implement(BYTE_SUB_BYTE, writer -> writer.iSub());
-		implement(SBYTE_SUB_SBYTE, writer -> writer.iSub());
-		implement(SHORT_SUB_SHORT, writer -> writer.iSub());
-		implement(USHORT_SUB_USHORT, writer -> writer.iSub());
-		implement(INT_SUB_INT, writer -> writer.iSub());
-		implement(UINT_SUB_UINT, writer -> writer.iSub());
-		implement(LONG_SUB_LONG, writer -> writer.lSub());
-		implement(ULONG_SUB_ULONG, writer -> writer.lSub());
-		implement(FLOAT_SUB_FLOAT, writer -> writer.fSub());
-		implement(DOUBLE_SUB_DOUBLE, writer -> writer.dSub());
-		
-		implement(BYTE_MUL_BYTE, writer -> writer.iMul());
-		implement(SBYTE_MUL_SBYTE, writer -> writer.iMul());
-		implement(SHORT_MUL_SHORT, writer -> writer.iMul());
-		implement(USHORT_MUL_USHORT, writer -> writer.iMul());
-		implement(INT_MUL_INT, writer -> writer.iMul());
-		implement(UINT_MUL_UINT, writer -> writer.iMul());
-		implement(LONG_MUL_LONG, writer -> writer.lMul());
-		implement(ULONG_MUL_ULONG, writer -> writer.lMul());
-		implement(FLOAT_MUL_FLOAT, writer -> writer.fMul());
-		implement(DOUBLE_MUL_DOUBLE, writer -> writer.dMul());
-		
-		implement(INT_DIV_INT, writer -> writer.iDiv());
-		implement(INT_MOD_INT, writer -> writer.iRem());
-		
-		implement(INT_TO_BYTE, writer -> writer.i2b());
-		implement(INT_TO_SBYTE, writer -> writer.i2b());
-		implement(INT_TO_SHORT, writer -> writer.i2s());
-		implement(INT_TO_USHORT, writer -> writer.i2s());
+
+		implement(STRING_ADD_STRING, JavaWriter::stringAdd);
+		
+		implement(BYTE_SUB_BYTE, JavaWriter::iSub);
+		implement(SBYTE_SUB_SBYTE, JavaWriter::iSub);
+		implement(SHORT_SUB_SHORT, JavaWriter::iSub);
+		implement(USHORT_SUB_USHORT, JavaWriter::iSub);
+		implement(INT_SUB_INT, JavaWriter::iSub);
+		implement(UINT_SUB_UINT, JavaWriter::iSub);
+		implement(LONG_SUB_LONG, JavaWriter::lSub);
+		implement(ULONG_SUB_ULONG, JavaWriter::lSub);
+		implement(FLOAT_SUB_FLOAT, JavaWriter::fSub);
+		implement(DOUBLE_SUB_DOUBLE, JavaWriter::dSub);
+		
+		implement(BYTE_MUL_BYTE, JavaWriter::iMul);
+		implement(SBYTE_MUL_SBYTE, JavaWriter::iMul);
+		implement(SHORT_MUL_SHORT, JavaWriter::iMul);
+		implement(USHORT_MUL_USHORT, JavaWriter::iMul);
+		implement(INT_MUL_INT, JavaWriter::iMul);
+		implement(UINT_MUL_UINT, JavaWriter::iMul);
+		implement(LONG_MUL_LONG, JavaWriter::lMul);
+		implement(ULONG_MUL_ULONG, JavaWriter::lMul);
+		implement(FLOAT_MUL_FLOAT, JavaWriter::fMul);
+		implement(DOUBLE_MUL_DOUBLE, JavaWriter::dMul);
+		
+		implement(INT_DIV_INT, JavaWriter::iDiv);
+		implement(INT_MOD_INT, JavaWriter::iRem);
+		
+		implement(INT_TO_BYTE, JavaWriter::i2b);
+		implement(INT_TO_SBYTE, JavaWriter::i2b);
+		implement(INT_TO_SHORT, JavaWriter::i2s);
+		implement(INT_TO_USHORT, JavaWriter::i2s);
 		implement(INT_TO_UINT, writer -> {});
-		implement(INT_TO_LONG, writer -> writer.i2l());
-		implement(INT_TO_ULONG, writer -> writer.i2l());
-		implement(INT_TO_FLOAT, writer -> writer.i2f());
-		implement(INT_TO_DOUBLE, writer -> writer.i2d());
-		implement(INT_TO_CHAR, writer -> writer.i2s());
+		implement(INT_TO_LONG, JavaWriter::i2l);
+		implement(INT_TO_ULONG, JavaWriter::i2l);
+		implement(INT_TO_FLOAT, JavaWriter::i2f);
+		implement(INT_TO_DOUBLE, JavaWriter::i2d);
+		implement(INT_TO_CHAR, JavaWriter::i2s);
 		INT_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jInteger, "toString", "(I)Ljava/lang/String;", true));
 		
 		implement(LONG_TO_BYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_SBYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_SHORT, writer -> { writer.l2i(); writer.i2s(); });
 		implement(LONG_TO_USHORT, writer -> { writer.l2i(); writer.i2s(); });
-		implement(LONG_TO_INT, writer -> writer.l2i());
-		implement(LONG_TO_UINT, writer -> writer.l2i());
+		implement(LONG_TO_INT, JavaWriter::l2i);
+		implement(LONG_TO_UINT, JavaWriter::l2i);
 		implement(LONG_TO_ULONG, writer -> {});
-		implement(LONG_TO_FLOAT, writer -> writer.l2f());
-		implement(LONG_TO_DOUBLE, writer -> writer.l2d());
+		implement(LONG_TO_FLOAT, JavaWriter::l2f);
+		implement(LONG_TO_DOUBLE, JavaWriter::l2d);
 		implement(LONG_TO_CHAR, writer -> { writer.l2i(); writer.i2s(); });
 		LONG_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jLong, "toString", "(J)Ljava/lang/String;", true));
 		

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

+package org.openzen.zenscript.javabytecode;
+
+import org.objectweb.asm.Type;
+
+public class JavaLocalVariableInfo {
+    public final Type type;
+    public final int local;
+
+    public JavaLocalVariableInfo(Type type, int local) {
+        this.type = type;
+        this.local = local;
+    }
+}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import com.sun.javafx.image.IntPixelGetter;
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
+import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
+
+import java.util.Map;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
-    private final JavaWriter javaWriter;
+    private JavaWriter javaWriter;
 
     public JavaExpressionVisitor(final JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 
     @Override
     public Void visitArray(ArrayExpression expression) {
+        javaWriter.constant(expression.expressions.length);
+        Type type = Type.getType(expression.type.accept(JavaTypeClassVisitor.INSTANCE).getComponentType());
+        javaWriter.newArray(type);
+        for (int i = 0; i < expression.expressions.length; i++) {
+            javaWriter.dup();
+            javaWriter.constant(i);
+            expression.expressions[i].accept(this);
+            javaWriter.arrayStore(type);
+        }
         return null;
     }
 
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
-		
-		JavaBytecodeImplementation implementation = expression.member.getTag(JavaBytecodeImplementation.class);
-		if (implementation != null) {
-			implementation.compile(javaWriter);
-			return null;
-		}
-		
-		JavaMethodInfo methodInfo = expression.member.getTag(JavaMethodInfo.class);
-		if (methodInfo == null)
-			throw new IllegalStateException("Call target has no method info!");
-		
-		if (methodInfo.isStatic) {
-			javaWriter.invokeStatic(
-					methodInfo.javaClass.internalClassName,
-					methodInfo.name,
-					methodInfo.signature);
-		} else {
-			javaWriter.invokeVirtual(
-					methodInfo.javaClass.internalClassName,
-					methodInfo.name,
-					methodInfo.signature);
-		}
-		
+        if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+            throw new IllegalStateException("Call target has no method info!");
+
         return null;
     }
 
 
     @Override
     public Void visitConstantBool(ConstantBoolExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantByte(ConstantByteExpression expression) {
-        javaWriter.biPush(expression.value);
+        getJavaWriter().biPush(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantChar(ConstantCharExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantDouble(ConstantDoubleExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantFloat(ConstantFloatExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantInt(ConstantIntExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantLong(ConstantLongExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantSByte(ConstantSByteExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantShort(ConstantShortExpression expression) {
-        javaWriter.siPush(expression.value);
+        getJavaWriter().siPush(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantString(ConstantStringExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantUInt(ConstantUIntExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantULong(ConstantULongExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantUShort(ConstantUShortExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
 
     @Override
     public Void visitGetField(GetFieldExpression expression) {
+        if (!checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     @Override
     public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+        final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+        javaWriter.load(tag.type, tag.local);
         return null;
     }
 
     @Override
     public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		JavaFieldInfo fieldInfo = expression.field.getTag(JavaFieldInfo.class);
-		if (fieldInfo == null)
-			throw new IllegalStateException("Missing field info on a field member!");
-		
-		javaWriter.getStaticField(
-				fieldInfo.javaClass.internalClassName,
-				fieldInfo.name,
-				fieldInfo.signature);
-		
+        if (!checkAndGetFieldInfo(expression.field, true))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
+        expression.value.accept(this);
+        javaWriter.checkCast(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
         return null;
     }
 
     @Override
     public Void visitIs(IsExpression expression) {
+        expression.value.accept(this);
+        javaWriter.instanceOf(Type.getDescriptor(expression.isType.accept(JavaTypeClassVisitor.INSTANCE)));
         return null;
     }
 
     @Override
-    public Void visitMakeConst(MakeConstExpression expression) {
+    public Void visitMakeConst(MakeConstExpression expression)
+    {
+
         return null;
     }
 
     @Override
     public Void visitMap(MapExpression expression) {
+        javaWriter.newObject(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        javaWriter.dup();
+        javaWriter.invokeSpecial("java/util/Map", "<init>", "()V");
+        for (int i = 0; i < expression.keys.length; i++) {
+            javaWriter.dup();
+            expression.keys[i].accept(this);
+            expression.values[i].accept(this);
+            javaWriter.invokeInterface(Map.class, "put", Object.class, Object.class, Object.class);
+            javaWriter.pop();
+        }
         return null;
     }
 
     @Override
     public Void visitNew(NewExpression expression) {
+        String type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        javaWriter.newObject(type);
+        javaWriter.dup();
+        StringBuilder signatureBuilder = new StringBuilder("(");
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+            signatureBuilder.append(Type.getDescriptor(argument.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        }
+        signatureBuilder.append(")V");
+        javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
+
         return null;
     }
 
     @Override
     public Void visitNot(NotExpression expression) {
+        expression.value.accept(this);
+        javaWriter.iNeg();
         return null;
     }
 
     @Override
     public Void visitNull(NullExpression expression) {
+        javaWriter.aConstNull();
         return null;
     }
 
 
     @Override
     public Void visitRange(RangeExpression expression) {
+        if(expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
+            throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
+        javaWriter.newObject(IntRange.class);
+        javaWriter.dup();
+        expression.from.accept(this);
+        expression.to.accept(this);
+        System.out.println(IntRange.class.getName());
+        javaWriter.invokeSpecial("org/openzen/zenscript/implementations/IntRange", "<init>", "(II)V");
+
         return null;
     }
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
+        if (expression.field.isFinal)
+            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
+        expression.value.accept(this);
+        if (!checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     @Override
     public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+        if (expression.variable.isFinal)
+            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final variable!");
+        expression.value.accept(this);
+        final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+
+        javaWriter.store(tag.type, tag.local);
+
         return null;
     }
 
     @Override
     public Void visitSetStaticField(SetStaticFieldExpression expression) {
+        if (expression.field.isFinal)
+            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
+        expression.value.accept(this);
+        if (!checkAndPutFieldInfo(expression.field, true))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
     public Void visitWrapOptional(WrapOptionalExpression expression) {
         return null;
     }
+
+    public JavaWriter getJavaWriter() {
+        return javaWriter;
+    }
+
+
+    //Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
+    private boolean checkAndExecuteByteCodeImplementation(DefinitionMember member) {
+        JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
+        if (implementation != null) {
+            implementation.compile(getJavaWriter());
+            return true;
+        }
+        return false;
+    }
+
+    //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
+    private boolean checkAndExecuteMethodInfo(DefinitionMember member) {
+        JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
+        if (methodInfo == null)
+            return false;
+        if (methodInfo.isStatic) {
+            getJavaWriter().invokeStatic(
+                    methodInfo.javaClass.internalClassName,
+                    methodInfo.name,
+                    methodInfo.signature);
+        } else {
+            getJavaWriter().invokeVirtual(
+                    methodInfo.javaClass.internalClassName,
+                    methodInfo.name,
+                    methodInfo.signature);
+        }
+        return true;
+    }
+
+
+    //TODO: Should isStatic go to the fieldInfo or stay here?
+    //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
+    private boolean checkAndPutFieldInfo(DefinitionMember field, boolean isStatic) {
+        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        if (fieldInfo == null)
+            return false;
+        if (isStatic) {
+            getJavaWriter().putStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        } else {
+            getJavaWriter().putField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        }
+        return true;
+    }
+
+    private boolean checkAndGetFieldInfo(DefinitionMember field, boolean isStatic) {
+        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        if (fieldInfo == null)
+            return false;
+        if (isStatic) {
+            getJavaWriter().getStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        } else {
+            getJavaWriter().getField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        }
+        return true;
+    }
 }

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.Label;
+import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
+import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+
+public class JavaForeachVisitor implements ForeachIteratorVisitor<Void> {
+
+    private final JavaWriter javaWriter;
+    private final VarStatement[] variables;
+    private final Statement content;
+    private final Label startLabel;
+    private final Label endLabel;
+    private final JavaStatementVisitor statementVisitor;
+
+    public JavaForeachVisitor(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
+        this.statementVisitor = statementVisitor;
+        this.javaWriter = statementVisitor.getJavaWriter();
+        this.variables = variables;
+        this.content = content;
+        this.startLabel = start;
+        this.endLabel = end;
+    }
+
+    @Override
+    public Void visitIntRange() {
+        javaWriter.dup();
+        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "max", "I");
+        javaWriter.swap();
+        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "min", "I");
+
+        final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
+        javaWriter.storeInt(z);
+        javaWriter.label(startLabel);
+        javaWriter.dup();
+        javaWriter.loadInt(z);
+        javaWriter.ifICmpLE(endLabel);
+
+        content.accept(statementVisitor);
+        javaWriter.iinc(z);
+
+
+        return null;
+    }
+
+    @Override
+    public Void visitArrayValueIterator() {
+        handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
+        return null;
+    }
+
+    @Override
+    public Void visitArrayKeyValueIterator() {
+        handleArray(variables[0].getTag(JavaLocalVariableInfo.class).local, variables[1].getTag(JavaLocalVariableInfo.class));
+        return null;
+    }
+
+    private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {
+        javaWriter.iConst0();
+        javaWriter.storeInt(z);
+
+        javaWriter.label(startLabel);
+        javaWriter.dup();
+        javaWriter.dup();
+        javaWriter.arrayLength();
+        javaWriter.loadInt(z);
+
+        javaWriter.ifICmpLE(endLabel);
+        javaWriter.loadInt(z);
+
+
+        javaWriter.arrayLoad(arrayTypeInfo.type);
+        javaWriter.store(arrayTypeInfo.type, arrayTypeInfo.local);
+        content.accept(statementVisitor);
+        javaWriter.iinc(z);
+    }
+
+    @Override
+    public Void visitCustomIterator() {
+        return null;
+    }
+}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.Label;
+import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 public class JavaStatementVisitor implements StatementVisitor<Void> {
     private final JavaWriter javaWriter;
+    private final JavaExpressionVisitor expressionVisitor;
 
     public JavaStatementVisitor(final JavaWriter javaWriter) {
 
         this.javaWriter = javaWriter;
+        this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
     }
 
     @Override
     public Void visitBlock(BlockStatement statement) {
+        for (Statement statement1 : statement.statements) {
+            statement1.accept(this);
+        }
         return null;
     }
 
     @Override
     public Void visitBreak(BreakStatement statement) {
+        javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
         return null;
     }
 
     @Override
     public Void visitContinue(ContinueStatement statement) {
+        javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
         return null;
     }
 
     @Override
     public Void visitDoWhile(DoWhileStatement statement) {
+        Label start = new Label();
+        Label end = new Label();
+        if (statement.label == null)
+            statement.label = javaWriter.createLabelName() + "DoWhile";
+        javaWriter.putNamedLabel(start, statement.label + "_start");
+        javaWriter.putNamedLabel(end, statement.label + "_end");
+        javaWriter.label(start);
+        statement.content.accept(this);
+
+        statement.condition.accept(expressionVisitor);
+        javaWriter.ifNE(start);
+
+        //Only needed for break statements, should be nop if not used
+        javaWriter.label(end);
         return null;
     }
 
     @Override
     public Void visitEmpty(EmptyStatement statement) {
+        //No-Op
         return null;
     }
 
     @Override
     public Void visitExpression(ExpressionStatement statement) {
-        statement.expression.accept(new JavaExpressionVisitor(javaWriter));
+        statement.expression.accept(expressionVisitor);
         return null;
     }
 
     @Override
     public Void visitForeach(ForeachStatement statement) {
+        //Create Labels
+        Label start = new Label();
+        Label end = new Label();
+        if (statement.label == null) {
+            statement.label = javaWriter.createLabelName() + "ForEach";
+        }
+        javaWriter.putNamedLabel(start, statement.label + "_start");
+        javaWriter.putNamedLabel(end, statement.label + "_end");
+
+
+        //Compile Array/Collection
+        statement.list.accept(expressionVisitor);
+
+        //Create local variables
+        for (VarStatement variable : statement.loopVariables) {
+            final Type type = Type.getType(variable.type.accept(JavaTypeClassVisitor.INSTANCE));
+            variable.setTag(JavaLocalVariableInfo.class, new JavaLocalVariableInfo(type, javaWriter.local(type)));
+        }
+
+        //javaWriter.label(min);
+        statement.iterator.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
+        javaWriter.goTo(start);
+        javaWriter.label(end);
         return null;
     }
 
     @Override
     public Void visitIf(IfStatement statement) {
+        statement.condition.accept(expressionVisitor);
+        Label onElse = null;
+        Label end = new Label();
+        final boolean hasElse = statement.onElse != null;
+        if (hasElse) {
+            onElse = new Label();
+            javaWriter.ifEQ(onElse);
+        } else {
+            javaWriter.ifEQ(end);
+        }
+        statement.onThen.accept(this);
+        if (hasElse) {
+            javaWriter.goTo(end);
+            javaWriter.label(onElse);
+            statement.onElse.accept(this);
+        }
+        javaWriter.label(end);
         return null;
     }
 
 
     @Override
     public Void visitReturn(ReturnStatement statement) {
+        statement.value.accept(expressionVisitor);
+        javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
         return null;
     }
 
     @Override
     public Void visitThrow(ThrowStatement statement) {
+        statement.value.accept(expressionVisitor);
+        javaWriter.aThrow();
         return null;
     }
 
 
     @Override
     public Void visitVar(VarStatement statement) {
+        Type type = Type.getType(statement.type.accept(JavaTypeClassVisitor.INSTANCE));
+        int local = javaWriter.local(type);
+        if (statement.initializer != null) {
+            statement.initializer.accept(expressionVisitor);
+            javaWriter.store(type, local);
+        }
+        statement.setTag(JavaLocalVariableInfo.class, new JavaLocalVariableInfo(type, local));
         return null;
     }
 
     @Override
     public Void visitWhile(WhileStatement statement) {
+        Label start = new Label();
+        Label end = new Label();
+
+        if (statement.label == null) {
+            statement.label = javaWriter.createLabelName() + "WhileDo";
+        }
+        javaWriter.putNamedLabel(start, statement.label + "_start");
+        javaWriter.putNamedLabel(end, statement.label + "_end");
+
+        javaWriter.label(start);
+        statement.condition.accept(expressionVisitor);
+        javaWriter.ifEQ(end);
+        statement.content.accept(this);
+        javaWriter.goTo(start);
+        javaWriter.label(end);
         return null;
     }
 
         javaWriter.ret();
         javaWriter.end();
     }
+
+    public JavaWriter getJavaWriter() {
+        return javaWriter;
+    }
 }

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.lang.reflect.Array;
+import java.util.Iterator;
+import java.util.Map;
+
+public class JavaTypeClassVisitor implements ITypeVisitor<Class> {
+
+    public static final JavaTypeClassVisitor INSTANCE = new JavaTypeClassVisitor();
+
+    @Override
+    public Class visitBasic(BasicTypeID basic) {
+        switch (basic) {
+            case VOID:
+                return void.class;
+            case ANY:
+            case NULL:
+            case UNDETERMINED:
+                return Object.class;
+            case BOOL:
+                return boolean.class;
+            case BYTE:
+            case SBYTE:
+                return byte.class;
+            case SHORT:
+            case USHORT:
+                return short.class;
+            case INT:
+            case UINT:
+                return int.class;
+            case LONG:
+            case ULONG:
+                return long.class;
+            case FLOAT:
+                return float.class;
+            case DOUBLE:
+                return double.class;
+            case CHAR:
+                return char.class;
+            case STRING:
+                return String.class;
+        }
+        return Object.class;
+    }
+
+    @Override
+    public Class visitArray(ArrayTypeID array) {
+        return Array.newInstance(array.elementType.accept(this), 0).getClass();
+    }
+
+    @Override
+    public Class visitAssoc(AssocTypeID assoc) {
+        return Map.class;
+    }
+
+    @Override
+    public Class visitIterator(IteratorTypeID iterator) {
+        return Iterator.class;
+    }
+
+    @Override
+    public Class visitFunction(FunctionTypeID function) {
+        return null;
+    }
+
+    @Override
+    public Class visitDefinition(DefinitionTypeID definition) {
+        return null;
+    }
+
+    @Override
+    public Class visitGeneric(GenericTypeID generic) {
+        return null;
+    }
+
+    @Override
+    public Class visitRange(RangeTypeID range) {
+        return null;
+    }
+
+    @Override
+    public Class visitConst(ConstTypeID type) {
+        return type.baseType.accept(this);
+    }
+
+    @Override
+    public Class visitOptional(OptionalTypeID optional) {
+        return null;
+    }
+}

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

-package org.openzen.zenscript.javabytecode.compiler;
-
-import org.openzen.zenscript.codemodel.type.*;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
-import org.openzen.zenscript.shared.CompileException;
-
-public class JavaTypeSignatureVisitor implements ITypeVisitor<String> {
-    @Override
-    public String visitBasic(BasicTypeID basic) {
-        switch (basic) {
-            case VOID:
-                return "V";
-            case NULL:
-            case ANY:
-            case UNDETERMINED:
-                return "Ljava/lang/Object;";
-            case BOOL:
-                return "Z";
-            case BYTE:
-            case SBYTE:
-                return "B";
-            case SHORT:
-            case USHORT:
-                return "S";
-            case INT:
-            case UINT:
-                return "I";
-            case LONG:
-            case ULONG:
-                return "J";
-            case FLOAT:
-                return "F";
-            case DOUBLE:
-                return "D";
-            case CHAR:
-                return "C";
-            case STRING:
-                return "Ljava/lang/String;";
-        }
-        return "";
-    }
-
-    @Override
-    public String visitArray(ArrayTypeID array) {
-        return "[" + array.elementType.accept(this);
-    }
-
-    @Override
-    public String visitAssoc(AssocTypeID assoc) {
-        return "Ljava/util/Map;";
-    }
-
-    @Override
-    public String visitIterator(IteratorTypeID iterator) {
-        return "java/lang/Iterable";
-    }
-
-    @Override
-    public String visitFunction(FunctionTypeID function) {
-        return null;
-    }
-
-    @Override
-    public String visitDefinition(DefinitionTypeID definition) {
-		JavaClassInfo classInfo = definition.definition.getTag(JavaClassInfo.class);
-		if (classInfo == null)
-			throw CompileException.internalError("Definition is missing java class tag!");
-		
-        return "L" + classInfo.internalClassName + ";";
-    }
-
-    @Override
-    public String visitGeneric(GenericTypeID generic) {
-		// TODO: type erasure
-        return null;
-    }
-
-    @Override
-    public String visitRange(RangeTypeID range) {
-        return null;
-    }
-
-    @Override
-    public String visitConst(ConstTypeID type) {
-		return type.baseType.accept(this);
-    }
-
-    @Override
-    public String visitOptional(OptionalTypeID optional) {
-        return null;
-    }
-}

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

 
 public class JavaWriter {
     final LocalVariablesSorter visitor;
-    private boolean debug = false;
+    private boolean debug = true;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
 
 
         return labelNames.get(lbl);
     }
+
+    public String createLabelName() {
+        return "L" + labelIndex++;
+    }
+
+    public void putNamedLabel(Label lbl, String name) {
+        if(labelNames == null)
+            labelNames = new HashMap<>();
+        labelNames.put(lbl, name);
+    }
+
+    public void stringAdd() {
+        invokeVirtual("java/lang/String", "concat", "(Ljava/lang/String;)Ljava/lang/String;");
+    }
+
+    public Label getNamedLabel(String label) {
+        for (Map.Entry<Label, String> entry : labelNames.entrySet()) {
+            if(entry.getValue().matches(label))
+                return entry.getKey();
+        }
+        throw new RuntimeException("Label " + label + " not found!");
+    }
 }

Linker/src/main/java/org/openzen/zenscript/linker/BaseScope.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	
 	public abstract ITypeID getType(CodePosition position, List<GenericName> name);
 	
-	public abstract Statement getLoop(String name);
+	public abstract LoopStatement getLoop(String name);
 	
 	public abstract FunctionHeader getFunctionHeader();
 	

Linker/src/main/java/org/openzen/zenscript/linker/BlockScope.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return parent.getLoop(name);
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/DefinitionScope.java

 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null;
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/ExpressionScope.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 	
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return outer.getLoop(name);
 	}
 	

Linker/src/main/java/org/openzen/zenscript/linker/FileScope.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null;
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/ForeachScope.java

 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.ForeachStatement;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		if (name == null)
 			return statement;
 		

Linker/src/main/java/org/openzen/zenscript/linker/FunctionScope.java

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null; // not in a loop
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/GenericFunctionScope.java

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return outer.getLoop(name);
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/GlobalScriptScope.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null;
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/ImplementationScope.java

 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null;
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/LambdaScope.java

 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		return null;
 	}
 

Linker/src/main/java/org/openzen/zenscript/linker/LoopScope.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	}
 
 	@Override
-	public Statement getLoop(String name) {
+	public LoopStatement getLoop(String name) {
 		if (name == null)
 			return statement;
 		

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementBreak.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
 import org.openzen.zenscript.shared.CodePosition;
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Statement target = scope.getLoop(name);
+		LoopStatement target = scope.getLoop(name);
 		if (target == null)
 			throw new CompileException(position, CompileExceptionCode.BREAK_OUTSIDE_LOOP, name == null ? "Not in a loop" : "No such loop: " + name);
 		return new BreakStatement(position, target);

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementContinue.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zenscript.codemodel.statement.ContinueStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
 import org.openzen.zenscript.shared.CodePosition;
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Statement target = scope.getLoop(name);
+		LoopStatement target = scope.getLoop(name);
 		if (target == null)
 			throw new CompileException(position, CompileExceptionCode.CONTINUE_OUTSIDE_LOOP, name == null ? "Not in a loop" : "No such loop: " + name);
 		return new ContinueStatement(position, target);

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementDoWhile.java

 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Statement content = this.content.compile(scope);
+		//Statement content = this.content.compile(scope);
 		Expression condition = this.condition
 				.compile(new ExpressionScope(scope, BasicTypeID.HINT_BOOL))
 				.eval()

ScriptingExample/scripts/moreHellos.zs

 println("Hello world!");
-println("Hello world!");
-println("Hello world!");
-println("Hello world!");
-println("Hello world!");
+println(1 as string);
+
+
+var test = "test";
+println(test);
+
+
+test = "testMore";
+println(test);
+
+test = 13;
+println(test);
+
+val test2 = 14;
+println(test2);
+
+
+if true 
+    println("ifTest");
+else
+    println("elseTest");
+
+
+if false 
+    println("testIf");
+else
+    println("testElse");
+
+
+if (true) {
+
+    while :testLable true {
+        println("trueee");
+        if true
+            break testLable;
+        else
+            println("nobreak");
+    }
+    
+    
+    do {
+        println("tru"); 
+        if(false){
+        	println("brea");
+            continue;
+        }
+        else{
+            println("");
+            break;
+        }
+    } while true;
+}
+
+var test = ["1", "2", "3"];
+
+for item in test {
+	println("test");
+	println(item);
+}
+
+println("");
+
+var test2 = [1, 2, 3];
+
+for item in test2 {
+	println(item);
+}
+
+for i, item in ["5", "ttt"] {
+	println(item + i);
+}
+
+for i, item in [1, 5, 7] {
+	println(item + i);
+}
+
+for i in 10 .. 20 {
+	println(i);
+}
+
+var lateInit as string;
+lateInit = "initialized later";
+println(lateInit);

ScriptingExample/scripts/statements.zs

-var i = 0;
-while i < 10 {
-	println("Hello!");
-	i = i + 1;
-}
+//while true
+//	println("Hello!");

Shared/out/production/resources/org/openzen/zenscript/shared/characterEntities.properties

+quot=34
+amp=38
+apos=39
+lt=60
+gt=62
+
+nbsp=160
+iexcl=161
+cent=162
+pound=163
+curren=164
+yen=165
+brvbar=166
+sect=167
+uml=168
+copy=169
+ordf=170
+laquo=171
+not=172
+shy=173
+reg=174
+macr=175
+deg=176
+plusmn=177
+sup2=178
+sup3=179
+acute=180
+micro=181
+para=182
+middot=183
+cedil=184
+sup1=185
+ordm=186
+raquo=187
+frac14=188
+frac12=189
+frac34=190
+iquest=191
+
+Agrave=192
+Aacute=193
+Acirc=194
+Atilde=195
+Auml=196
+Aring=197
+AElig=198
+Ccedil=199
+Egrave=200
+Eacute=201
+Ecirc=202
+Euml=203
+lgrave=204
+lacute=205
+lcirc=206
+luml=207
+ETH=208
+Ntilde=209
+Ograve=210
+Oacute=211
+Ocirc=212
+Otilde=213
+Ouml=214
+times=215
+Oslash=216
+Ugrave=217
+Uacute=218
+Ucirc=219
+Uuml=220
+Yacute=221
+THORN=222
+szlig=223
+agrave=224
+aacute=225
+acirc=226
+atilde=227
+auml=228
+aring=229
+aelig=230
+ccedil=231
+egrave=232
+eacute=233
+ecirc=234
+euml=235
+igrave=236
+iacute=237
+icirc=238
+iuml=239
+eth=240
+ntilde=241
+ograve=242
+oacute=243
+ocirc=244
+otilde=245
+ouml=246
+divide=247
+oslash=248
+ugrave=249
+uacute=250
+ucirc=251
+uuml=252
+yacute=253
+thorn=254
+yuml=255
+
+OElig=338
+oelig=339
+Scaron=352
+scaron=353
+Yuml=376
+
+fnof=402
+
+circ=710
+tilde=732
+
+Alpha=913
+Beta=914
+Gamma=915
+Delta=916
+Epsilon=917
+Zeta=918
+Eta=919
+Theta=920
+Iota=921
+Kappa=922
+Lambda=923
+Mu=924
+Nu=925
+Xi=926
+Omicron=927
+Pi=928
+Rho=929
+Sigma=931
+Tau=932
+Upsilon=933
+Phi=934
+Chi=935
+Psi=936
+Omega=937
+
+alpha=945
+beta=946
+gamma=947
+delta=948
+epsilon=949
+zeta=950
+eta=951
+theta=952
+iota=953
+kappa=954
+lambda=955
+mu=956
+nu=957
+xi=958
+omicron=959
+pi=960
+rho=961
+sigmaf=962
+sigma=963
+tau=964
+upsilon=965
+phi=966
+chi=967
+psi=968
+omega=969
+thetasym=977
+upsih=978
+piv=982
+
+ensp=8194
+emsp=8195
+thinsp=8201
+zwnj=8204
+zwj=8205
+lrm=8206
+rlm=8207
+ndash=8211
+mdash=8212
+lsquo=8216
+rsquo=8217
+sbquo=8218
+ldquo=8220
+rdquo=8221
+bdquo=8222
+dagger=8224
+Dagger=8225
+bull=8226
+hellip=8230
+permil=8240
+prime=8242
+Prime=8243
+lsaquo=8249
+rsaquo=8250
+oline=8254
+frasl=8260
+
+euro=8364
+
+image=8465
+weierp=8472
+real=8476
+trade=8482
+alefsym=8501
+
+larr=8592
+uarr=8593
+rarr=8594
+darr=8595
+harr=8596
+crarr=8629
+lArr=8656
+uArr=8657
+rArr=8658
+dArr=8659
+hArr=8660
+
+forall=8704
+part=8706
+exist=8707
+empty=8709
+nabla=8711
+isin=8712
+notin=8713
+ni=8715
+prod=8719
+sum=8721
+minus=8722
+lowast=8727
+radic=8730
+prop=8733
+infin=8734
+ang=8736
+and=8743
+or=8744
+cap=8745
+cup=8746
+int=8747
+there4=8756
+sim=8764
+cong=8773
+asymp=8776
+ne=8800
+equiv=8801
+le=8804
+ge=8805
+sub=8834
+sup=8835
+nsub=8836
+sube=8838
+supe=8839
+oplus=8853
+otimes=8855
+perp=8869
+sdot=8901
+
+lceil=8968
+rceil=8969
+lfloor=8970
+rfloor=8971
+lang=9001
+rang=9002
+loz=9674
+spades=9824
+clubs=8927
+hearts=9829
+diams=9830

Shared/src/main/java/org/openzen/zenscript/shared/CompileExceptionCode.java

 	RETURN_VALUE_REQUIRED,
 	RETURN_VALUE_VOID,
 	INVALID_CONDITION,
-	INTERNAL_ERROR
+	INTERNAL_ERROR,
+	CANNOT_SET_FINAL_VARIABLE
 }

Shared/src/main/java/org/openzen/zenscript/shared/TagDictionary.java

  */
 package org.openzen.zenscript.shared;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
 /**
- *
  * @author Hoofdgebruiker
  */
+@SuppressWarnings("unchecked")
 public class TagDictionary {
-	private final Map<Class<?>, Object> tags = new HashMap<>();
-	
-	public <T> void put(Class<T> cls, T tag) {
-		tags.put(cls, tag);
-	}
-	
-	public <T> T get(Class<T> cls) {
-		return (T) tags.get(cls);
-	}
+    private Map<Class<?>, Object> tags = Collections.EMPTY_MAP;
+
+    public <T> void put(Class<T> cls, T tag) {
+        if (tags == Collections.EMPTY_MAP) {
+            tags = Collections.singletonMap(cls, tag);
+        } else if (tags.size() == 1) {
+            Map<Class<?>, Object> newTags = new HashMap<>(tags);
+            newTags.put(cls, tag);
+            this.tags = newTags;
+        } else {
+            tags.put(cls, tag);
+        }
+    }
+
+    public <T> T get(Class<T> cls) {
+        return (T) tags.get(cls);
+    }
 }