Implement increment & decrement compilation in the bytecode compiler.

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

@@ -773,8 +773,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		
 		invert(builtin, INT_NOT, INT);
 		neg(builtin, INT_NEG, INT);
-		inc(builtin, INT_DEC, INT);
-		dec(builtin, INT_INC, INT);
+		inc(builtin, INT_INC, INT);
+		dec(builtin, INT_DEC, INT);
 
 		add(builtin, INT_ADD_INT, INT, INT);
 		add(builtin, LONG_ADD_LONG, LONG, LONG, INT_TO_LONG);
@@ -853,8 +853,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "uint", Modifiers.PUBLIC, null);
 		
 		invert(builtin, UINT_NOT, INT);
-		inc(builtin, UINT_DEC, INT);
-		dec(builtin, UINT_INC, INT);
+		inc(builtin, UINT_INC, INT);
+		dec(builtin, UINT_DEC, INT);
 
 		add(builtin, UINT_ADD_UINT, UINT, UINT);
 		add(builtin, ULONG_ADD_ULONG, USIZE, ULONG, UINT_TO_ULONG);
@@ -934,8 +934,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		
 		invert(builtin, LONG_NOT, LONG);
 		neg(builtin, LONG_NEG, LONG);
-		inc(builtin, LONG_DEC, LONG);
-		dec(builtin, LONG_INC, LONG);
+		inc(builtin, LONG_INC, LONG);
+		dec(builtin, LONG_DEC, LONG);
 
 		add(builtin, LONG_ADD_LONG, LONG, LONG);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, LONG_TO_FLOAT);
@@ -1006,8 +1006,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ulong", Modifiers.PUBLIC, null);
 		
 		invert(builtin, ULONG_NOT, ULONG);
-		inc(builtin, ULONG_DEC, ULONG);
-		dec(builtin, ULONG_INC, ULONG);
+		inc(builtin, ULONG_INC, ULONG);
+		dec(builtin, ULONG_DEC, ULONG);
 
 		add(builtin, ULONG_ADD_ULONG, ULONG, ULONG);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, ULONG_TO_FLOAT);
@@ -1078,8 +1078,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "usize", Modifiers.PUBLIC, null);
 		
 		invert(builtin, USIZE_NOT, USIZE);
-		inc(builtin, USIZE_DEC, USIZE);
-		dec(builtin, USIZE_INC, USIZE);
+		inc(builtin, USIZE_INC, USIZE);
+		dec(builtin, USIZE_DEC, USIZE);
 
 		add(builtin, USIZE_ADD_USIZE, USIZE, USIZE);
 		add(builtin, ULONG_ADD_ULONG, ULONG, ULONG, USIZE_TO_ULONG);
@@ -1155,8 +1155,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "float", Modifiers.PUBLIC, null);
 		
 		neg(builtin, FLOAT_NEG, FLOAT);
-		inc(builtin, FLOAT_DEC, FLOAT);
-		dec(builtin, FLOAT_INC, FLOAT);
+		inc(builtin, FLOAT_INC, FLOAT);
+		dec(builtin, FLOAT_DEC, FLOAT);
 
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT);
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, FLOAT_TO_DOUBLE);
@@ -1200,8 +1200,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "double", Modifiers.PUBLIC, null);
 		
 		neg(builtin, DOUBLE_NEG, DOUBLE);
-		inc(builtin, DOUBLE_DEC, DOUBLE);
-		dec(builtin, DOUBLE_INC, DOUBLE);
+		inc(builtin, DOUBLE_INC, DOUBLE);
+		dec(builtin, DOUBLE_DEC, DOUBLE);
 
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE);
 		sub(builtin, DOUBLE_SUB_DOUBLE, DOUBLE, DOUBLE);

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

@@ -9,6 +9,7 @@ import org.openzen.zenscript.codemodel.expression.switchvalue.*;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
@@ -16,6 +17,7 @@ import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 
 public class CompilerUtils {
+
 	private CompilerUtils() {}
 
 	public static boolean isPrimitive(TypeID id) {
@@ -23,6 +25,10 @@ public class CompilerUtils {
 				|| (id.isOptional() && id.withoutOptional() == BasicTypeID.USIZE);
 	}
 
+	public static boolean isLarge(StoredType type) {
+		return type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.DOUBLE;
+	}
+	
 	public static int calcAccess(int modifiers) {
 		int out = 0;
 		if (Modifiers.isStatic(modifiers))

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

@@ -26,6 +26,7 @@ import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Objects;
 import java.util.StringJoiner;
+import org.openzen.zenscript.javabytecode.compiler.JavaModificationExpressionVisitor.PushOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
@@ -392,6 +393,132 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 			case ARRAY_INDEXGETRANGE:
 			case ARRAY_INDEXGET:
 				break;
+			case BYTE_INC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.constant(0xFF);
+					javaWriter.iAnd();
+				}, PushOption.AFTER);
+				return null;
+			case BYTE_DEC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.constant(0xFF);
+					javaWriter.iAnd();
+				}, PushOption.AFTER);
+				return null;
+			case SBYTE_INC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.i2b();
+				}, PushOption.AFTER);
+				return null;
+			case SBYTE_DEC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.i2b();
+				}, PushOption.AFTER);
+				return null;
+			case SHORT_INC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.i2s();
+				}, PushOption.AFTER);
+				return null;
+			case SHORT_DEC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.i2s();
+				}, PushOption.AFTER);
+				return null;
+			case USHORT_INC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.constant(0xFFFF);
+					javaWriter.iAnd();
+				}, PushOption.AFTER);
+				return null;
+			case USHORT_DEC:
+				modify(expression.target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.constant(0xFFFF);
+					javaWriter.iAnd();
+				}, PushOption.AFTER);
+				return null;
+			case INT_INC:
+			case UINT_INC:
+			case USIZE_INC:
+				if (expression.target instanceof GetLocalVariableExpression) {
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+					javaWriter.iinc(local.local);
+					javaWriter.load(local);
+				} else {
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+					}, PushOption.AFTER);
+				}
+				return null;
+			case INT_DEC:
+			case UINT_DEC:
+			case USIZE_DEC:
+				if (expression.target instanceof GetLocalVariableExpression) {
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+					javaWriter.iinc(local.local, -1);
+					javaWriter.load(local);
+				} else {
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+					}, PushOption.AFTER);
+				}
+				return null;
+			case LONG_INC:
+			case ULONG_INC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1l);
+					javaWriter.iAdd();
+				}, PushOption.AFTER);
+				return null;
+			case LONG_DEC:
+			case ULONG_DEC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1l);
+					javaWriter.iSub();
+				}, PushOption.AFTER);
+				return null;
+			case FLOAT_INC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1f);
+					javaWriter.iAdd();
+				}, PushOption.AFTER);
+				return null;
+			case FLOAT_DEC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1f);
+					javaWriter.iSub();
+				}, PushOption.AFTER);
+				return null;
+			case DOUBLE_INC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1d);
+					javaWriter.iAdd();
+				}, PushOption.AFTER);
+				return null;
+			case DOUBLE_DEC:
+				modify(expression.target, () -> {
+					javaWriter.constant(1d);
+					javaWriter.iSub();
+				}, PushOption.AFTER);
+				return null;
 			default:
 				expression.target.accept(this);
 				for (Expression argument : expression.arguments.arguments) {
@@ -3337,14 +3464,150 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 		javaWriter.aThrow();
 		return null;
 	}
+	
+	private void modify(Expression source, Runnable modification, PushOption push) {
+		source.accept(new JavaModificationExpressionVisitor(context, module, javaWriter, this, modification, push));
+	}
 
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {
-		expression.target.accept(this);
-		javaWriter.dup(context.getType(expression.type));
-		if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
-			throw new IllegalStateException("Call target has no method info!");
-
+		if (expression.member.getBuiltin() != null) {
+			switch (expression.member.getBuiltin()) {
+				case BYTE_INC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+						javaWriter.constant(255);
+						javaWriter.iAnd();
+					}, PushOption.BEFORE);
+					return null;
+				case BYTE_DEC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+						javaWriter.constant(255);
+						javaWriter.iAnd();
+					}, PushOption.BEFORE);
+				case SBYTE_INC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+						javaWriter.i2b();
+					}, PushOption.BEFORE);
+					return null;
+				case SBYTE_DEC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+						javaWriter.i2b();
+					}, PushOption.BEFORE);
+					return null;
+				case SHORT_INC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+						javaWriter.i2s();
+					}, PushOption.BEFORE);
+					return null;
+				case SHORT_DEC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+						javaWriter.i2s();
+					}, PushOption.BEFORE);
+					return null;
+				case USHORT_INC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+						javaWriter.constant(0xFFFF);
+						javaWriter.iAnd();
+					}, PushOption.BEFORE);
+					return null;
+				case USHORT_DEC:
+					modify(expression.target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+						javaWriter.constant(0xFFFF);
+						javaWriter.iAnd();
+					}, PushOption.BEFORE);
+					return null;
+				case INT_INC:
+				case UINT_INC:
+				case USIZE_INC:
+					if (expression.target instanceof GetLocalVariableExpression) {
+						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+						javaWriter.load(local);
+						javaWriter.iinc(local.local);
+					} else {
+						modify(expression.target, () -> {
+							javaWriter.iConst1();
+							javaWriter.iAdd();
+						}, PushOption.BEFORE);
+					}
+					return null;
+				case INT_DEC:
+				case UINT_DEC:
+				case USIZE_DEC:
+					if (expression.target instanceof GetLocalVariableExpression) {
+						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+						javaWriter.load(local);
+						javaWriter.iinc(local.local, -1);
+					} else {
+						modify(expression.target, () -> {
+							javaWriter.iConst1();
+							javaWriter.iSub();
+						}, PushOption.BEFORE);
+					}
+					return null;
+				case LONG_INC:
+				case ULONG_INC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1l);
+						javaWriter.lAdd();
+					}, PushOption.BEFORE);
+					return null;
+				case LONG_DEC:
+				case ULONG_DEC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1l);
+						javaWriter.lSub();
+					}, PushOption.BEFORE);
+					return null;
+				case FLOAT_INC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1f);
+						javaWriter.fAdd();
+					}, PushOption.BEFORE);
+					return null;
+				case FLOAT_DEC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1f);
+						javaWriter.fSub();
+					}, PushOption.BEFORE);
+					return null;
+				case DOUBLE_INC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1d);
+						javaWriter.dAdd();
+					}, PushOption.BEFORE);
+					return null;
+				case DOUBLE_DEC:
+					modify(expression.target, () -> {
+						javaWriter.constant(1d);
+						javaWriter.dSub();
+					}, PushOption.BEFORE);
+					return null;
+				default:
+					throw new IllegalArgumentException("Unknown postcall builtin: " + expression.member.getBuiltin());
+			}
+		}
+		
+		modify(expression.target, () -> {
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
+				throw new IllegalStateException("Call target has no method info!");
+		}, PushOption.BEFORE);
+		
 		return null;
 	}
 

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

@@ -0,0 +1,495 @@
+/*
+ * 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 org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.CompareExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.ThrowExpression;
+import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaModificationExpressionVisitor implements ExpressionVisitor<Void> {
+	public static enum PushOption {
+		NONE, // don't push result
+		BEFORE, // push result before modification (eg. i++)
+		AFTER // push result after modification (eg. ++i)
+	}
+	
+	private final JavaBytecodeContext context;
+	private final JavaCompiledModule module;
+	private final JavaWriter javaWriter;
+	private final JavaExpressionVisitor expressionVisitor;
+	private final Runnable modification;
+	private final PushOption push;
+	
+	public JavaModificationExpressionVisitor(
+			JavaBytecodeContext context,
+			JavaCompiledModule module,
+			JavaWriter javaWriter,
+			JavaExpressionVisitor expressionVisitor,
+			Runnable modification,
+			PushOption push) {
+		this.context = context;
+		this.module = module;
+		this.javaWriter = javaWriter;
+		this.expressionVisitor = expressionVisitor;
+		this.modification = modification;
+		this.push = push;
+	}
+	
+	private void modify(StoredType type) {
+		boolean large = type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.LONG;
+		modify(large);
+	}
+	
+	private void modify(boolean large) {
+		if (push == PushOption.BEFORE)
+			javaWriter.dup(large);
+		modification.run();
+		if (push == PushOption.AFTER)
+			javaWriter.dup(large);
+	}
+
+	@Override
+	public Void visitAndAnd(AndAndExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: &&");
+	}
+
+	@Override
+	public Void visitArray(ArrayExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: array");
+	}
+
+	@Override
+	public Void visitCompare(CompareExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: comparison");
+	}
+
+	@Override
+	public Void visitCall(CallExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: call");
+	}
+
+	@Override
+	public Void visitCallStatic(CallStaticExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: static call");
+	}
+
+	@Override
+	public Void visitCapturedClosure(CapturedClosureExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: captured closure");
+	}
+
+	@Override
+	public Void visitCapturedDirect(CapturedDirectExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: captured direct");
+	}
+
+	@Override
+	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: captured local variable cannot be modified");
+	}
+
+	@Override
+	public Void visitCapturedParameter(CapturedParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: captured parameter cannot be modified");
+	}
+
+	@Override
+	public Void visitCapturedThis(CapturedThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: this");
+	}
+
+	@Override
+	public Void visitCast(CastExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: cast");
+	}
+
+	@Override
+	public Void visitCheckNull(CheckNullExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: null check");
+	}
+
+	@Override
+	public Void visitCoalesce(CoalesceExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: coalesce operator");
+	}
+
+	@Override
+	public Void visitConditional(ConditionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: conditional expression");
+	}
+
+	@Override
+	public Void visitConst(ConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant cannot be modified");
+	}
+
+	@Override
+	public Void visitConstantBool(ConstantBoolExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant bool");
+	}
+
+	@Override
+	public Void visitConstantByte(ConstantByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant byte");
+	}
+
+	@Override
+	public Void visitConstantChar(ConstantCharExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant char");
+	}
+
+	@Override
+	public Void visitConstantDouble(ConstantDoubleExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant double");
+	}
+
+	@Override
+	public Void visitConstantFloat(ConstantFloatExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant float");
+	}
+
+	@Override
+	public Void visitConstantInt(ConstantIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant int");
+	}
+
+	@Override
+	public Void visitConstantLong(ConstantLongExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant long");
+	}
+
+	@Override
+	public Void visitConstantSByte(ConstantSByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant sbyte");
+	}
+
+	@Override
+	public Void visitConstantShort(ConstantShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant short");
+	}
+
+	@Override
+	public Void visitConstantString(ConstantStringExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant string");
+	}
+
+	@Override
+	public Void visitConstantUInt(ConstantUIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant uint");
+	}
+
+	@Override
+	public Void visitConstantULong(ConstantULongExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant ulong");
+	}
+
+	@Override
+	public Void visitConstantUShort(ConstantUShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant ushort");
+	}
+
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constant usize");
+	}
+
+	@Override
+	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: constructor forwarding call");
+	}
+
+	@Override
+	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: super forwarding call");
+	}
+
+	@Override
+	public Void visitEnumConstant(EnumConstantExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: enum constant");
+	}
+
+	@Override
+	public Void visitFunction(FunctionExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: function");
+	}
+
+	@Override
+	public Void visitGetField(GetFieldExpression expression) {
+		JavaField field = context.getJavaField(expression.field);
+		expression.target.accept(expressionVisitor);
+		javaWriter.getField(field);
+		modify(expression.field.getType());
+		javaWriter.putField(field);
+		return null;
+	}
+
+	@Override
+	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
+		javaWriter.load(parameter);
+		modify(expression.type);
+		javaWriter.store(parameter);
+		return null;
+	}
+
+	@Override
+	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+		JavaLocalVariableInfo variable = javaWriter.getLocalVariable(expression.variable.variable);
+		javaWriter.load(variable);
+		modify(expression.type);
+		javaWriter.store(variable);
+		return null;
+	}
+
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: matching variant field");
+	}
+
+	@Override
+	public Void visitGetStaticField(GetStaticFieldExpression expression) {
+		JavaField field = context.getJavaField(expression.field);
+		javaWriter.getStaticField(field);
+		modify(expression.type);
+		javaWriter.putStaticField(field);
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterExpression expression) {
+		// TODO: find corresponding setter
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitGlobal(GlobalExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: global");
+	}
+
+	@Override
+	public Void visitGlobalCall(GlobalCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: global call");
+	}
+
+	@Override
+	public Void visitInterfaceCast(InterfaceCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: cast");
+	}
+
+	@Override
+	public Void visitIs(IsExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: is");
+	}
+
+	@Override
+	public Void visitMakeConst(MakeConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: const");
+	}
+
+	@Override
+	public Void visitMap(MapExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: map");
+	}
+
+	@Override
+	public Void visitMatch(MatchExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: match");
+	}
+
+	@Override
+	public Void visitNew(NewExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: new");
+	}
+
+	@Override
+	public Void visitNull(NullExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: null");
+	}
+
+	@Override
+	public Void visitOrOr(OrOrExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: ||");
+	}
+
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: panic");
+	}
+
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: post call");
+	}
+
+	@Override
+	public Void visitRange(RangeExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: range");
+	}
+
+	@Override
+	public Void visitSameObject(SameObjectExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: ===");
+	}
+
+	@Override
+	public Void visitSetField(SetFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: set field");
+	}
+
+	@Override
+	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: set function parameter");
+	}
+
+	@Override
+	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: set local variable");
+	}
+
+	@Override
+	public Void visitSetStaticField(SetStaticFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: set static field");
+	}
+
+	@Override
+	public Void visitSetter(SetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: setter");
+	}
+
+	@Override
+	public Void visitStaticGetter(StaticGetterExpression expression) {
+		// TODO: find corresponding setter
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitStaticSetter(StaticSetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: static setter");
+	}
+
+	@Override
+	public Void visitStorageCast(StorageCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: cast");
+	}
+
+	@Override
+	public Void visitSupertypeCast(SupertypeCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: cast");
+	}
+
+	@Override
+	public Void visitThis(ThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: this");
+	}
+
+	@Override
+	public Void visitThrow(ThrowExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: throw");
+	}
+
+	@Override
+	public Void visitTryConvert(TryConvertExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: try conversion");
+	}
+
+	@Override
+	public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: try rethrow");
+	}
+
+	@Override
+	public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: try rethrow");
+	}
+
+	@Override
+	public Void visitVariantValue(VariantValueExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: variant value");
+	}
+
+	@Override
+	public Void visitWrapOptional(WrapOptionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid lvalue: wrap optional");
+	}
+}

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

@@ -1,394 +0,0 @@
-/*
- * 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 org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
-	private final JavaExpressionVisitor expressionCompiler;
-	private final JavaWriter javaWriter;
-	private final JavaCompiledModule module;
-	private final JavaBytecodeContext context;
-	
-	public JavaPreDecrementVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaExpressionVisitor expressionCompiler) {
-		this.expressionCompiler = expressionCompiler;
-		this.context = context;
-		this.module = module;
-		javaWriter = expressionCompiler.getJavaWriter();
-	}
-
-	@Override
-	public Void visitAndAnd(AndAndExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitArray(ArrayExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCompare(CompareExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCall(CallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCallStatic(CallStaticExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedClosure(CapturedClosureExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedDirect(CapturedDirectExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedParameter(CapturedParameterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedThis(CapturedThisExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCast(CastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCheckNull(CheckNullExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCoalesce(CoalesceExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConditional(ConditionalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitConst(ConstExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantBool(ConstantBoolExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantByte(ConstantByteExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantChar(ConstantCharExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantDouble(ConstantDoubleExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantFloat(ConstantFloatExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantInt(ConstantIntExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantLong(ConstantLongExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantSByte(ConstantSByteExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantShort(ConstantShortExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantString(ConstantStringExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUInt(ConstantUIntExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantULong(ConstantULongExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUShort(ConstantUShortExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUSize(ConstantUSizeExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitEnumConstant(EnumConstantExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitFunction(FunctionExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGetField(GetFieldExpression expression) {
-		Type objectType = context.getType(expression.target.type);
-		
-		int local = javaWriter.local(objectType);
-		expression.target.accept(expressionCompiler);
-		javaWriter.dup();
-		javaWriter.store(objectType, local);
-		
-        expressionCompiler.getField(expression.field);
-		
-		javaWriter.iConst1();
-		javaWriter.iSub();
-		
-		javaWriter.load(objectType, local);
-        expressionCompiler.putField(expression.field);
-		return null;
-	}
-
-	@Override
-	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		javaWriter.idec(module.getParameterInfo(expression.parameter).index);
-		return null;
-	}
-	
-	@Override
-	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		javaWriter.idec(javaWriter.getLocalVariable(expression.variable.variable).local);
-		return null;
-	}
-
-	@Override
-	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		expressionCompiler.getField(expression.field);
-		javaWriter.iConst1();
-		javaWriter.iAdd();
-		expressionCompiler.putField(expression.field);
-		return null;
-	}
-
-	@Override
-	public Void visitGetter(GetterExpression expression) {
-		throw new UnsupportedOperationException("Not yet supported");
-	}
-
-	@Override
-	public Void visitGlobal(GlobalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGlobalCall(GlobalCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitInterfaceCast(InterfaceCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitIs(IsExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMakeConst(MakeConstExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMap(MapExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMatch(MatchExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitNew(NewExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitNull(NullExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitOrOr(OrOrExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitPanic(PanicExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitPostCall(PostCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitRange(RangeExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitSameObject(SameObjectExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetField(SetFieldExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetStaticField(SetStaticFieldExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetter(SetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitStaticGetter(StaticGetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitStaticSetter(StaticSetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitStorageCast(StorageCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitSupertypeCast(SupertypeCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitThis(ThisExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitThrow(ThrowExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryConvert(TryConvertExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitVariantValue(VariantValueExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitWrapOptional(WrapOptionalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-}

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

@@ -1,402 +0,0 @@
-/*
- * 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 org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaParameterInfo;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
-	private final JavaExpressionVisitor expressionCompiler;
-	private final JavaBytecodeContext context;
-	private final JavaCompiledModule module;
-	private final JavaWriter javaWriter;
-	
-	public JavaPreIncrementVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaExpressionVisitor expressionCompiler) {
-		this.expressionCompiler = expressionCompiler;
-		this.context = context;
-		this.module = module;
-		javaWriter = expressionCompiler.getJavaWriter();
-	}
-
-	@Override
-	public Void visitAndAnd(AndAndExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitArray(ArrayExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCompare(CompareExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCall(CallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCallStatic(CallStaticExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedClosure(CapturedClosureExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedDirect(CapturedDirectExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedParameter(CapturedParameterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCapturedThis(CapturedThisExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCast(CastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCheckNull(CheckNullExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitCoalesce(CoalesceExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConditional(ConditionalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitConst(ConstExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantBool(ConstantBoolExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantByte(ConstantByteExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantChar(ConstantCharExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantDouble(ConstantDoubleExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantFloat(ConstantFloatExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantInt(ConstantIntExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantLong(ConstantLongExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantSByte(ConstantSByteExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantShort(ConstantShortExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantString(ConstantStringExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUInt(ConstantUIntExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantULong(ConstantULongExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUShort(ConstantUShortExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstantUSize(ConstantUSizeExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitEnumConstant(EnumConstantExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitFunction(FunctionExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGetField(GetFieldExpression expression) {
-		Type objectType = context.getType(expression.target.type);
-		
-		int local = javaWriter.local(objectType);
-		expression.target.accept(expressionCompiler);
-		javaWriter.dup();
-		javaWriter.store(objectType, local);
-		
-        expressionCompiler.getField(expression.field);
-		
-		javaWriter.iConst1();
-		javaWriter.iAdd();
-		
-		javaWriter.load(objectType, local);
-		javaWriter.dupX1();
-        expressionCompiler.putField(expression.field);
-		return null;
-	}
-
-	@Override
-	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
-		javaWriter.iinc(parameter.index);
-		javaWriter.load(parameter);
-		return null;
-	}
-
-	@Override
-	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		JavaLocalVariableInfo localVariable = javaWriter.getLocalVariable(expression.variable.variable);
-		javaWriter.iinc(localVariable.local);
-		javaWriter.load(localVariable);
-		return null;
-	}
-
-	@Override
-	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		expressionCompiler.getField(expression.field);
-		javaWriter.iConst1();
-		javaWriter.iAdd();
-		javaWriter.dup();
-		expressionCompiler.putField(expression.field);
-		return null;
-	}
-
-	@Override
-	public Void visitGetter(GetterExpression expression) {
-		throw new UnsupportedOperationException("Not yet supported");
-	}
-
-	@Override
-	public Void visitGlobal(GlobalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitGlobalCall(GlobalCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitInterfaceCast(InterfaceCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitIs(IsExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMakeConst(MakeConstExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMap(MapExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitMatch(MatchExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitNew(NewExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitNull(NullExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitOrOr(OrOrExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitPanic(PanicExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitPostCall(PostCallExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitRange(RangeExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitSameObject(SameObjectExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetField(SetFieldExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetStaticField(SetStaticFieldExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitSetter(SetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitStaticGetter(StaticGetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitStaticSetter(StaticSetterExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitStorageCast(StorageCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-	
-	@Override
-	public Void visitSupertypeCast(SupertypeCastExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitThis(ThisExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitThrow(ThrowExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryConvert(TryConvertExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitVariantValue(VariantValueExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-
-	@Override
-	public Void visitWrapOptional(WrapOptionalExpression expression) {
-		throw new UnsupportedOperationException("Invalid increment target");
-	}
-}

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

@@ -7,6 +7,7 @@ import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
@@ -80,6 +81,11 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
 	@Override
 	public Boolean visitExpression(ExpressionStatement statement) {
 		statement.expression.accept(expressionVisitor);
+		
+		// TODO: make the expression not push anything
+		if (statement.expression.type.type != BasicTypeID.VOID)
+			javaWriter.pop(CompilerUtils.isLarge(statement.expression.type));
+		
 		return false;
 	}
 

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

@@ -112,7 +112,8 @@ public class JavaWriter {
 
 		try {
 	        visitor.visitMaxs(0, 0);
-		} catch (ArrayIndexOutOfBoundsException ex) {
+		} catch (ArrayIndexOutOfBoundsException | NegativeArraySizeException ex) {
+			//ex.printStackTrace();
 			throw ex;
 		}
 		

ScriptingExample/scripts/arithmetic.zs

@@ -0,0 +1,4 @@
+var j = 0;
+println(j);
+j++;
+println(j);