Merge stan's chagnes

branch 'Stan/development' into development

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallTranslator.java

@@ -0,0 +1,31 @@
+/*
+ * 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.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface CallTranslator {
+	class Call {
+		public final CodePosition position;
+		public final Expression target;
+		public final FunctionHeader instancedHeader;
+		public final CallArguments arguments;
+		
+		public Call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+			this.position = position;
+			this.target = target;
+			this.instancedHeader = instancedHeader;
+			this.arguments = arguments;
+		}
+	}
+	
+	Expression translate(Call call);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionContext.java

@@ -0,0 +1,18 @@
+/*
+ * 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.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ExpressionContext {
+	void addStatementBefore(Statement statement);
+	
+	void addStatementAfter(Statement statement);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/FunctionalMember.java

@@ -44,6 +44,10 @@ public abstract class FunctionalMember extends DefinitionMember implements ICall
 		return new CallExpression(position, target, this, instancedHeader, arguments);
 	}
 	
+	public final Expression call(CodePosition position, Expression target, CallArguments arguments) {
+		return call(position, target, header, arguments);
+	}
+	
 	@Override
 	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
 		return new GenericCompareExpression(position, call(position, target, instancedHeader, arguments), operator);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/TranslatedOperatorMember.java

@@ -0,0 +1,32 @@
+/*
+ * 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.codemodel.member;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallTranslator;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TranslatedOperatorMember extends OperatorMember {
+	private final CallTranslator translator;
+	
+	public TranslatedOperatorMember(CodePosition position, int modifiers, OperatorType operator, FunctionHeader header, CallTranslator translator) {
+		super(position, modifiers, operator, header);
+		
+		this.translator = translator;
+	}
+
+	@Override
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+		return translator.translate(new CallTranslator.Call(position, target, instancedHeader, arguments));
+	}
+}

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

@@ -10,52 +10,168 @@ import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import static org.openzen.zenscript.codemodel.type.BasicTypeID.*;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
+import static org.openzen.zenscript.shared.CodePosition.BUILTIN;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class BuiltinTypeMembers {
+	private BuiltinTypeMembers() {}
+	
 	public static final ConstantGetterMember INT_GET_MIN_VALUE = new ConstantGetterMember("MIN_VALUE", position -> new ConstantIntExpression(position, Integer.MIN_VALUE));
 	public static final ConstantGetterMember INT_GET_MAX_VALUE = new ConstantGetterMember("MAX_VALUE", position -> new ConstantIntExpression(position, Integer.MAX_VALUE));
 	
-	public static final OperatorMember INT_ADD_INT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.ADD, new FunctionHeader(BasicTypeID.INT, new FunctionParameter(BasicTypeID.INT)));
-	public static final OperatorMember INT_ADD_LONG = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.ADD, new FunctionHeader(BasicTypeID.LONG, new FunctionParameter(BasicTypeID.LONG)));
-	public static final OperatorMember INT_ADD_FLOAT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.ADD, new FunctionHeader(BasicTypeID.FLOAT, new FunctionParameter(BasicTypeID.FLOAT)));
-	public static final OperatorMember INT_ADD_DOUBLE = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.ADD, new FunctionHeader(BasicTypeID.DOUBLE, new FunctionParameter(BasicTypeID.DOUBLE)));
-	
-	public static final OperatorMember INT_SUB_INT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.SUB, new FunctionHeader(BasicTypeID.INT, new FunctionParameter(BasicTypeID.INT)));
-	public static final OperatorMember INT_SUB_LONG = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.SUB, new FunctionHeader(BasicTypeID.LONG, new FunctionParameter(BasicTypeID.LONG)));
-	public static final OperatorMember INT_SUB_FLOAT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.SUB, new FunctionHeader(BasicTypeID.FLOAT, new FunctionParameter(BasicTypeID.FLOAT)));
-	public static final OperatorMember INT_SUB_DOUBLE = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.SUB, new FunctionHeader(BasicTypeID.DOUBLE, new FunctionParameter(BasicTypeID.DOUBLE)));
-	
-	public static final OperatorMember INT_MUL_INT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MUL, new FunctionHeader(BasicTypeID.INT, new FunctionParameter(BasicTypeID.INT)));
-	public static final OperatorMember INT_MUL_LONG = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MUL, new FunctionHeader(BasicTypeID.LONG, new FunctionParameter(BasicTypeID.LONG)));
-	public static final OperatorMember INT_MUL_FLOAT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MUL, new FunctionHeader(BasicTypeID.FLOAT, new FunctionParameter(BasicTypeID.FLOAT)));
-	public static final OperatorMember INT_MUL_DOUBLE = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MUL, new FunctionHeader(BasicTypeID.DOUBLE, new FunctionParameter(BasicTypeID.DOUBLE)));
-	
-	public static final OperatorMember INT_DIV_INT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.DIV, new FunctionHeader(BasicTypeID.INT, new FunctionParameter(BasicTypeID.INT)));
-	public static final OperatorMember INT_DIV_LONG = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.DIV, new FunctionHeader(BasicTypeID.LONG, new FunctionParameter(BasicTypeID.LONG)));
-	public static final OperatorMember INT_DIV_FLOAT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.DIV, new FunctionHeader(BasicTypeID.FLOAT, new FunctionParameter(BasicTypeID.FLOAT)));
-	public static final OperatorMember INT_DIV_DOUBLE = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.DIV, new FunctionHeader(BasicTypeID.DOUBLE, new FunctionParameter(BasicTypeID.DOUBLE)));
-	
-	public static final OperatorMember INT_MOD_INT = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MOD, new FunctionHeader(BasicTypeID.INT, new FunctionParameter(BasicTypeID.INT)));
-	public static final OperatorMember INT_MOD_LONG = new OperatorMember(CodePosition.BUILTIN, 0, OperatorType.MOD, new FunctionHeader(BasicTypeID.LONG, new FunctionParameter(BasicTypeID.LONG)));
-	
-	public static final CasterMember INT_TO_BYTE = new CasterMember(CodePosition.BUILTIN, 0, BasicTypeID.BYTE);
-	public static final CasterMember INT_TO_SBYTE = new CasterMember(CodePosition.BUILTIN, 0, BasicTypeID.SBYTE);
-	public static final CasterMember INT_TO_SHORT = new CasterMember(CodePosition.BUILTIN, 0, BasicTypeID.SHORT);
-	public static final CasterMember INT_TO_USHORT = new CasterMember(CodePosition.BUILTIN, 0, BasicTypeID.USHORT);
-	public static final CasterMember INT_TO_UINT = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.UINT);
-	public static final CasterMember INT_TO_LONG = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.LONG);
-	public static final CasterMember INT_TO_ULONG = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.ULONG);
-	public static final CasterMember INT_TO_FLOAT = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.FLOAT);
-	public static final CasterMember INT_TO_DOUBLE = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.DOUBLE);
-	public static final CasterMember INT_TO_CHAR = new CasterMember(CodePosition.BUILTIN, 0, BasicTypeID.CHAR);
-	public static final CasterMember INT_TO_STRING = new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, BasicTypeID.STRING);
+	public static final ConstantGetterMember LONG_GET_MIN_VALUE = new ConstantGetterMember("MIN_VALUE", position -> new ConstantLongExpression(position, Long.MIN_VALUE));
+	public static final ConstantGetterMember LONG_GET_MAX_VALUE = new ConstantGetterMember("MAX_VALUE", position -> new ConstantLongExpression(position, Long.MAX_VALUE));
+	
+	public static final OperatorMember BOOL_NOT = not(BOOL);
+	
+	public static final OperatorMember BYTE_NOT = not(BYTE);
+	public static final OperatorMember SBYTE_NOT = not(SBYTE);
+	public static final OperatorMember SHORT_NOT = not(SHORT);
+	public static final OperatorMember USHORT_NOT = not(USHORT);
+	public static final OperatorMember INT_NOT = not(INT);
+	public static final OperatorMember UINT_NOT = not(UINT);
+	public static final OperatorMember LONG_NOT = not(LONG);
+	public static final OperatorMember ULONG_NOT = not(ULONG);
+	
+	public static final OperatorMember BYTE_NEG = neg(BYTE);
+	public static final OperatorMember SBYTE_NEG = neg(SBYTE);
+	public static final OperatorMember SHORT_NEG = neg(SHORT);
+	public static final OperatorMember USHORT_NEG = neg(USHORT);
+	public static final OperatorMember INT_NEG = neg(INT);
+	public static final OperatorMember UINT_NEG = neg(UINT);
+	public static final OperatorMember LONG_NEG = neg(LONG);
+	public static final OperatorMember ULONG_NEG = neg(ULONG);
+	public static final OperatorMember FLOAT_NEG = neg(FLOAT);
+	public static final OperatorMember DOUBLE_NEG = neg(DOUBLE);
+	
+	public static final OperatorMember BYTE_ADD_BYTE = add(BYTE, BYTE);
+	public static final OperatorMember SBYTE_ADD_SBYTE = add(SBYTE, SBYTE);
+	public static final OperatorMember SHORT_ADD_SHORT = add(SHORT, SHORT);
+	public static final OperatorMember USHORT_ADD_USHORT = add(USHORT, USHORT);
+	public static final OperatorMember INT_ADD_INT = add(INT, INT);
+	public static final OperatorMember UINT_ADD_UINT = add(UINT, UINT);
+	public static final OperatorMember LONG_ADD_LONG = add(LONG, LONG);
+	public static final OperatorMember ULONG_ADD_ULONG = add(ULONG, ULONG);
+	public static final OperatorMember FLOAT_ADD_FLOAT = add(FLOAT, FLOAT);
+	public static final OperatorMember DOUBLE_ADD_DOUBLE = add(DOUBLE, DOUBLE);
+	public static final OperatorMember STRING_ADD_STRING = add(STRING, STRING);
+	
+	public static final OperatorMember BYTE_SUB_BYTE = sub(BYTE, BYTE);
+	public static final OperatorMember SBYTE_SUB_SBYTE = sub(SBYTE, SBYTE);
+	public static final OperatorMember SHORT_SUB_SHORT = sub(SHORT, SHORT);
+	public static final OperatorMember USHORT_SUB_USHORT = sub(USHORT, USHORT);
+	public static final OperatorMember INT_SUB_INT = sub(INT, INT);
+	public static final OperatorMember UINT_SUB_UINT = sub(UINT, UINT);
+	public static final OperatorMember LONG_SUB_LONG = sub(LONG, LONG);
+	public static final OperatorMember ULONG_SUB_ULONG = sub(ULONG, ULONG);
+	public static final OperatorMember FLOAT_SUB_FLOAT = sub(FLOAT, FLOAT);
+	public static final OperatorMember DOUBLE_SUB_DOUBLE = sub(DOUBLE, DOUBLE);
+	
+	public static final OperatorMember BYTE_MUL_BYTE = mul(BYTE, BYTE);
+	public static final OperatorMember SBYTE_MUL_SBYTE = mul(SBYTE, SBYTE);
+	public static final OperatorMember SHORT_MUL_SHORT = mul(SHORT, SHORT);
+	public static final OperatorMember USHORT_MUL_USHORT = mul(USHORT, USHORT);
+	public static final OperatorMember INT_MUL_INT = mul(INT, INT);
+	public static final OperatorMember UINT_MUL_UINT = mul(UINT, UINT);
+	public static final OperatorMember LONG_MUL_LONG = mul(LONG, LONG);
+	public static final OperatorMember ULONG_MUL_ULONG = mul(ULONG, ULONG);
+	public static final OperatorMember FLOAT_MUL_FLOAT = mul(FLOAT, FLOAT);
+	public static final OperatorMember DOUBLE_MUL_DOUBLE = mul(DOUBLE, DOUBLE);
+	
+	public static final OperatorMember BYTE_DIV_BYTE = div(BYTE, BYTE);
+	public static final OperatorMember SBYTE_DIV_SBYTE = div(SBYTE, SBYTE);
+	public static final OperatorMember SHORT_DIV_SHORT = div(SHORT, SHORT);
+	public static final OperatorMember USHORT_DIV_USHORT = div(USHORT, USHORT);
+	public static final OperatorMember INT_DIV_INT = div(INT, INT);
+	public static final OperatorMember UINT_DIV_UINT = div(UINT, UINT);
+	public static final OperatorMember LONG_DIV_LONG = div(LONG, LONG);
+	public static final OperatorMember ULONG_DIV_ULONG = div(ULONG, ULONG);
+	public static final OperatorMember FLOAT_DIV_FLOAT = div(FLOAT, FLOAT);
+	public static final OperatorMember DOUBLE_DIV_DOUBLE = div(DOUBLE, DOUBLE);
+	
+	public static final OperatorMember BYTE_MOD_BYTE = mod(BYTE, BYTE);
+	public static final OperatorMember SBYTE_MOD_SBYTE = mod(SBYTE, SBYTE);
+	public static final OperatorMember SHORT_MOD_SHORT = mod(SHORT, SHORT);
+	public static final OperatorMember USHORT_MOD_USHORT = mod(USHORT, USHORT);
+	public static final OperatorMember INT_MOD_INT = mod(INT, INT);
+	public static final OperatorMember UINT_MOD_UINT = mod(UINT, UINT);
+	public static final OperatorMember LONG_MOD_LONG = mod(LONG, LONG);
+	public static final OperatorMember ULONG_MOD_ULONG = mod(ULONG, ULONG);
+	
+	public static final CasterMember INT_TO_BYTE = castExplicit(BYTE);
+	public static final CasterMember INT_TO_SBYTE = castExplicit(SBYTE);
+	public static final CasterMember INT_TO_SHORT = castExplicit(SHORT);
+	public static final CasterMember INT_TO_USHORT = castExplicit(USHORT);
+	public static final CasterMember INT_TO_UINT = castImplicit(UINT);
+	public static final CasterMember INT_TO_LONG = castImplicit(LONG);
+	public static final CasterMember INT_TO_ULONG = castImplicit(ULONG);
+	public static final CasterMember INT_TO_FLOAT = castImplicit(FLOAT);
+	public static final CasterMember INT_TO_DOUBLE = castImplicit(DOUBLE);
+	public static final CasterMember INT_TO_CHAR = castExplicit(CHAR);
+	public static final CasterMember INT_TO_STRING = castImplicit(STRING);
+	
+	public static final CasterMember LONG_TO_BYTE = castExplicit(BYTE);
+	public static final CasterMember LONG_TO_SBYTE = castExplicit(SBYTE);
+	public static final CasterMember LONG_TO_SHORT = castExplicit(SHORT);
+	public static final CasterMember LONG_TO_USHORT = castExplicit(USHORT);
+	public static final CasterMember LONG_TO_INT = castExplicit(INT);
+	public static final CasterMember LONG_TO_UINT = castExplicit(UINT);
+	public static final CasterMember LONG_TO_ULONG = castImplicit(ULONG);
+	public static final CasterMember LONG_TO_FLOAT = castImplicit(FLOAT);
+	public static final CasterMember LONG_TO_DOUBLE = castImplicit(DOUBLE);
+	public static final CasterMember LONG_TO_CHAR = castExplicit(CHAR);
+	public static final CasterMember LONG_TO_STRING = castImplicit(STRING);
+	
+	public static final GetterMember FLOAT_BITS = new GetterMember(BUILTIN, 0, "bits", UINT);
+	public static final GetterMember DOUBLE_BITS = new GetterMember(BUILTIN, 0, "bits", ULONG);
+	public static final MethodMember FLOAT_FROMBITS = new MethodMember(BUILTIN, Modifiers.MODIFIER_STATIC, "fromBits", new FunctionHeader(FLOAT, new FunctionParameter(UINT)));
+	public static final MethodMember DOUBLE_FROMBITS = new MethodMember(BUILTIN, Modifiers.MODIFIER_STATIC, "fromBits", new FunctionHeader(DOUBLE, new FunctionParameter(ULONG)));
+	
+	private static OperatorMember not(ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.NOT, new FunctionHeader(result));
+	}
+	
+	private static OperatorMember neg(ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.NEG, new FunctionHeader(result));
+	}
+	
+	private static OperatorMember add(ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.ADD, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember sub(ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.SUB, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember mul(ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.MUL, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember div(ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.DIV, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember mod(ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, 0, OperatorType.MOD, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static CasterMember castExplicit(ITypeID result) {
+		return new CasterMember(CodePosition.BUILTIN, 0, result);
+	}
+	
+	private static CasterMember castImplicit(ITypeID result) {
+		return new CasterMember(CodePosition.BUILTIN, Modifiers.MODIFIER_IMPLICIT, result);
+	}
 }

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

@@ -16,8 +16,9 @@ import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallTranslator;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
@@ -26,10 +27,12 @@ import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.EqualsMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.TranslatedOperatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorKeyValues;
 import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorValues;
 import org.openzen.zenscript.codemodel.member.builtin.ComparatorMember;
@@ -50,6 +53,7 @@ import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
 import org.openzen.zenscript.shared.CodePosition;
 import static org.openzen.zenscript.shared.CodePosition.BUILTIN;
 
@@ -76,12 +80,17 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 			case BOOL:
 				visitBool();
 				break;
+			case BYTE:
+				visitByte();
 			case INT:
 				visitInt();
 				break;
 			case UINT:
 				visitUInt();
 				break;
+			case LONG:
+				visitLong();
+				break;
 			case CHAR:
 				visitChar();
 				break;
@@ -261,49 +270,62 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 	}
 	
 	private void visitBool() {
+		members.addOperator(BuiltinTypeMembers.BOOL_NOT);
 		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.NOT, new FunctionHeader(BOOL)), TypeMemberPriority.SPECIFIED);
 	}
 	
+	private void visitByte() {
+		
+	}
+	
 	private void visitInt() {
-		registerUnaryOperations();
+		members.addOperator(INT_NEG);
+		members.addOperator(INT_NOT);
+		
+		/*members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);*/
+
+		members.addOperator(OperatorType.COMPARE, new ComparatorMember(members.type), TypeMemberPriority.SPECIFIED);
 		
-		members.addOperator(BuiltinTypeMembers.INT_ADD_INT);
-		members.addOperator(BuiltinTypeMembers.INT_ADD_LONG);
-		members.addOperator(BuiltinTypeMembers.INT_ADD_FLOAT);
-		members.addOperator(BuiltinTypeMembers.INT_ADD_DOUBLE);
+		members.addOperator(INT_ADD_INT);
+		members.addOperator(add(LONG, LONG, castedTargetCall(LONG_ADD_LONG, INT_TO_LONG)));
+		members.addOperator(add(FLOAT, FLOAT, castedTargetCall(FLOAT_ADD_FLOAT, INT_TO_FLOAT)));
+		members.addOperator(add(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_ADD_DOUBLE, INT_TO_DOUBLE)));
 		
-		members.addOperator(BuiltinTypeMembers.INT_SUB_INT);
-		members.addOperator(BuiltinTypeMembers.INT_SUB_LONG);
-		members.addOperator(BuiltinTypeMembers.INT_SUB_FLOAT);
-		members.addOperator(BuiltinTypeMembers.INT_SUB_DOUBLE);
+		members.addOperator(INT_SUB_INT);
+		members.addOperator(sub(LONG, LONG, castedTargetCall(LONG_SUB_LONG, INT_TO_LONG)));
+		members.addOperator(sub(FLOAT, FLOAT, castedTargetCall(FLOAT_SUB_FLOAT, INT_TO_FLOAT)));
+		members.addOperator(sub(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_SUB_DOUBLE, INT_TO_DOUBLE)));
 		
-		members.addOperator(BuiltinTypeMembers.INT_MUL_INT);
-		members.addOperator(BuiltinTypeMembers.INT_MUL_LONG);
-		members.addOperator(BuiltinTypeMembers.INT_MUL_FLOAT);
-		members.addOperator(BuiltinTypeMembers.INT_MUL_DOUBLE);
+		members.addOperator(INT_MUL_INT);
+		members.addOperator(mul(LONG, LONG, castedTargetCall(LONG_MUL_LONG, INT_TO_LONG)));
+		members.addOperator(mul(FLOAT, FLOAT, castedTargetCall(FLOAT_MUL_FLOAT, INT_TO_FLOAT)));
+		members.addOperator(mul(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_MUL_DOUBLE, INT_TO_DOUBLE)));
 		
-		members.addOperator(BuiltinTypeMembers.INT_DIV_INT);
-		members.addOperator(BuiltinTypeMembers.INT_DIV_LONG);
-		members.addOperator(BuiltinTypeMembers.INT_DIV_FLOAT);
-		members.addOperator(BuiltinTypeMembers.INT_DIV_DOUBLE);
+		members.addOperator(INT_DIV_INT);
+		members.addOperator(div(LONG, LONG, castedTargetCall(LONG_DIV_LONG, INT_TO_LONG)));
+		members.addOperator(div(FLOAT, FLOAT, castedTargetCall(FLOAT_DIV_FLOAT, INT_TO_FLOAT)));
+		members.addOperator(div(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_DIV_DOUBLE, INT_TO_DOUBLE)));
 		
-		members.addOperator(BuiltinTypeMembers.INT_MOD_INT);
-		members.addOperator(BuiltinTypeMembers.INT_MOD_LONG);
+		members.addOperator(INT_MOD_INT);
+		members.addOperator(mod(LONG, LONG, castedTargetCall(LONG_MOD_LONG, INT_TO_LONG)));
 		
-		members.addGetter(BuiltinTypeMembers.INT_GET_MIN_VALUE, TypeMemberPriority.SPECIFIED);
-		members.addGetter(BuiltinTypeMembers.INT_GET_MAX_VALUE, TypeMemberPriority.SPECIFIED);
+		members.addGetter(INT_GET_MIN_VALUE);
+		members.addGetter(INT_GET_MAX_VALUE);
 		
-		members.addCaster(BuiltinTypeMembers.INT_TO_BYTE, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_SBYTE, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_SHORT, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_USHORT, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_UINT, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_LONG, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_ULONG, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_FLOAT, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_DOUBLE, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_CHAR, TypeMemberPriority.SPECIFIED);
-		members.addCaster(BuiltinTypeMembers.INT_TO_STRING, TypeMemberPriority.SPECIFIED);
+		members.addCaster(INT_TO_BYTE);
+		members.addCaster(INT_TO_SBYTE);
+		members.addCaster(INT_TO_SHORT);
+		members.addCaster(INT_TO_USHORT);
+		members.addCaster(INT_TO_UINT);
+		members.addCaster(INT_TO_LONG);
+		members.addCaster(INT_TO_ULONG);
+		members.addCaster(INT_TO_FLOAT);
+		members.addCaster(INT_TO_DOUBLE);
+		members.addCaster(INT_TO_CHAR);
+		members.addCaster(INT_TO_STRING);
 	}
 
 	private void visitUInt() {
@@ -315,6 +337,51 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		members.addGetter(new ConstantGetterMember("MIN_VALUE", position -> new ConstantUIntExpression(position, 0)), TypeMemberPriority.SPECIFIED);
 		members.addGetter(new ConstantGetterMember("MAX_VALUE", position -> new ConstantUIntExpression(position, 0xFFFFFFFF)), TypeMemberPriority.SPECIFIED);
 	}
+	
+	private void visitLong() {
+		members.addOperator(LONG_NEG);
+		members.addOperator(LONG_NOT);
+		
+		/*members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);*/
+
+		members.addOperator(OperatorType.COMPARE, new ComparatorMember(members.type), TypeMemberPriority.SPECIFIED);
+		
+		members.addOperator(LONG_ADD_LONG);
+		members.addOperator(add(FLOAT, FLOAT, castedTargetCall(FLOAT_ADD_FLOAT, LONG_TO_FLOAT)));
+		members.addOperator(add(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_ADD_DOUBLE, LONG_TO_DOUBLE)));
+		
+		members.addOperator(LONG_SUB_LONG);
+		members.addOperator(sub(FLOAT, FLOAT, castedTargetCall(FLOAT_SUB_FLOAT, LONG_TO_FLOAT)));
+		members.addOperator(sub(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_SUB_DOUBLE, LONG_TO_DOUBLE)));
+		
+		members.addOperator(LONG_MUL_LONG);
+		members.addOperator(mul(FLOAT, FLOAT, castedTargetCall(FLOAT_MUL_FLOAT, LONG_TO_FLOAT)));
+		members.addOperator(mul(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_MUL_DOUBLE, LONG_TO_DOUBLE)));
+		
+		members.addOperator(LONG_DIV_LONG);
+		members.addOperator(div(FLOAT, FLOAT, castedTargetCall(FLOAT_DIV_FLOAT, LONG_TO_FLOAT)));
+		members.addOperator(div(DOUBLE, DOUBLE, castedTargetCall(DOUBLE_DIV_DOUBLE, LONG_TO_DOUBLE)));
+		
+		members.addOperator(LONG_MOD_LONG);
+		
+		members.addGetter(LONG_GET_MIN_VALUE);
+		members.addGetter(LONG_GET_MAX_VALUE);
+		
+		members.addCaster(LONG_TO_BYTE);
+		members.addCaster(LONG_TO_SBYTE);
+		members.addCaster(LONG_TO_SHORT);
+		members.addCaster(LONG_TO_USHORT);
+		members.addCaster(LONG_TO_INT);
+		members.addCaster(LONG_TO_UINT);
+		members.addCaster(LONG_TO_ULONG);
+		members.addCaster(LONG_TO_FLOAT);
+		members.addCaster(LONG_TO_DOUBLE);
+		members.addCaster(LONG_TO_CHAR);
+		members.addCaster(LONG_TO_STRING);
+	}
 
 	private void visitChar() {
 		registerUnaryOperations();
@@ -390,4 +457,28 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.DIV, binaryHeader), TypeMemberPriority.SPECIFIED);
 		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.MOD, binaryHeader), TypeMemberPriority.SPECIFIED);
 	}
+	
+	private static OperatorMember add(ITypeID operand, ITypeID result, CallTranslator translator) {
+		return new TranslatedOperatorMember(BUILTIN, 0, OperatorType.ADD, new FunctionHeader(result, new FunctionParameter(operand)), translator);
+	}
+	
+	private static OperatorMember sub(ITypeID operand, ITypeID result, CallTranslator translator) {
+		return new TranslatedOperatorMember(BUILTIN, 0, OperatorType.SUB, new FunctionHeader(result, new FunctionParameter(operand)), translator);
+	}
+	
+	private static OperatorMember mul(ITypeID operand, ITypeID result, CallTranslator translator) {
+		return new TranslatedOperatorMember(BUILTIN, 0, OperatorType.MUL, new FunctionHeader(result, new FunctionParameter(operand)), translator);
+	}
+	
+	private static OperatorMember div(ITypeID operand, ITypeID result, CallTranslator translator) {
+		return new TranslatedOperatorMember(BUILTIN, 0, OperatorType.DIV, new FunctionHeader(result, new FunctionParameter(operand)), translator);
+	}
+	
+	private static OperatorMember mod(ITypeID operand, ITypeID result, CallTranslator translator) {
+		return new TranslatedOperatorMember(BUILTIN, 0, OperatorType.MOD, new FunctionHeader(result, new FunctionParameter(operand)), translator);
+	}
+	
+	private static CallTranslator castedTargetCall(FunctionalMember member, CasterMember caster) {
+		return call -> member.call(call.position, caster.call(call.position, call.target, CallArguments.EMPTY), call.arguments);
+	}
 }

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

@@ -115,6 +115,10 @@ public final class TypeMembers {
 		getOrCreateGroup(OperatorType.CALL).addMethod(caller, priority);
 	}
 	
+	public void addCaster(CasterMember caster) {
+		addCaster(caster, TypeMemberPriority.SPECIFIED);
+	}
+	
 	public void addCaster(CasterMember caster, TypeMemberPriority priority) {
 		for (int i = 0; i < casters.size(); i++) {
 			if (casters.get(i).member.getTargetType() == caster.toType) {

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

@@ -12,5 +12,5 @@ import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
  * @author Hoofdgebruiker
  */
 public interface JavaBytecodeImplementation {
-	public void compile(JavaWriter writer);
+	void compile(JavaWriter writer);
 }

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

@@ -11,8 +11,9 @@ import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers;
+import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.shared.SourceFile;
@@ -24,26 +25,107 @@ import org.openzen.zenscript.shared.SourceFile;
 public class JavaCompiler {
 	static {
 		JavaClassInfo jInteger = new JavaClassInfo("java/lang/Integer");
-		BuiltinTypeMembers.INT_GET_MIN_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jInteger, "MIN_VALUE", "I"));
-		BuiltinTypeMembers.INT_GET_MAX_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jInteger, "MAX_VALUE", "I"));
-		
-		BuiltinTypeMembers.INT_ADD_INT.setTag(JavaBytecodeImplementation.class, writer -> writer.iAdd());
-		BuiltinTypeMembers.INT_SUB_INT.setTag(JavaBytecodeImplementation.class, writer -> writer.iSub());
-		BuiltinTypeMembers.INT_MUL_INT.setTag(JavaBytecodeImplementation.class, writer -> writer.iMul());
-		BuiltinTypeMembers.INT_DIV_INT.setTag(JavaBytecodeImplementation.class, writer -> writer.iDiv());
-		BuiltinTypeMembers.INT_MOD_INT.setTag(JavaBytecodeImplementation.class, writer -> writer.iRem());
-		
-		BuiltinTypeMembers.INT_TO_BYTE.setTag(JavaBytecodeImplementation.class, writer -> writer.i2b());
-		BuiltinTypeMembers.INT_TO_SBYTE.setTag(JavaBytecodeImplementation.class, writer -> writer.i2b());
-		BuiltinTypeMembers.INT_TO_SHORT.setTag(JavaBytecodeImplementation.class, writer -> writer.i2s());
-		BuiltinTypeMembers.INT_TO_USHORT.setTag(JavaBytecodeImplementation.class, writer -> writer.i2s());
-		BuiltinTypeMembers.INT_TO_UINT.setTag(JavaBytecodeImplementation.class, writer -> {});
-		BuiltinTypeMembers.INT_TO_LONG.setTag(JavaBytecodeImplementation.class, writer -> writer.i2l());
-		BuiltinTypeMembers.INT_TO_ULONG.setTag(JavaBytecodeImplementation.class, writer -> writer.i2l());
-		BuiltinTypeMembers.INT_TO_FLOAT.setTag(JavaBytecodeImplementation.class, writer -> writer.i2f());
-		BuiltinTypeMembers.INT_TO_DOUBLE.setTag(JavaBytecodeImplementation.class, writer -> writer.i2d());
-		BuiltinTypeMembers.INT_TO_CHAR.setTag(JavaBytecodeImplementation.class, writer -> writer.i2s());
-		BuiltinTypeMembers.INT_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jInteger, "toString", "(I)Ljava/lang/String;", true));
+		JavaClassInfo jLong = new JavaClassInfo("java/lang/Long");
+		JavaClassInfo jFloat = new JavaClassInfo("java/lang/Float");
+		JavaClassInfo jDouble = new JavaClassInfo("java/lang/Double");
+		
+		INT_GET_MIN_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jInteger, "MIN_VALUE", "I"));
+		INT_GET_MAX_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jInteger, "MAX_VALUE", "I"));
+		
+		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());
+		// 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(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());
+		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_ULONG, writer -> {});
+		implement(LONG_TO_FLOAT, writer -> writer.l2f());
+		implement(LONG_TO_DOUBLE, writer -> writer.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));
+		
+		FLOAT_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "floatToRawIntBits", "(F)I", true));
+		DOUBLE_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "doubleToRawLongBits", "(D)J", true));
+		FLOAT_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "intBitsToFloat", "(I)F", true));
+		DOUBLE_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "longBitsToDouble", "(J)D", true));
+	}
+	
+	private static void implement(DefinitionMember member, JavaBytecodeImplementation implementation) {
+		member.setTag(JavaBytecodeImplementation.class, implementation);
 	}
 	
 	private final JavaModule target;

Parser/src/main/java/org/openzen/zenscript/lexer/Token.java

@@ -11,11 +11,11 @@ import org.openzen.zenscript.shared.CodePosition;
  */
 public interface Token<TT extends TokenType>
 {
-	public CodePosition getPosition();
+	CodePosition getPosition();
 	
-	public TT getType();
+	TT getType();
 	
-	public String getContent();
+	String getContent();
 	
-	public String getWhitespaceBefore();
+	String getWhitespaceBefore();
 }

Parser/src/main/java/org/openzen/zenscript/lexer/TokenType.java

@@ -14,7 +14,7 @@ package org.openzen.zenscript.lexer;
  */
 public interface TokenType
 {
-	public String getRegexp();
+	String getRegexp();
 	
-	public boolean isWhitespace();
+	boolean isWhitespace();
 }

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

@@ -17,8 +17,8 @@ public enum ZSTokenType implements TokenType {
 	T_IDENTIFIER("[a-zA-Z_][a-zA-Z_0-9]*"),
 	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?"),
 	T_INT("\\-?(0|[1-9][0-9]*)"),
-	T_STRING_SQ("\"([^\"\\\\]|\\\\([\'\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\""),
-	T_STRING_DQ("\'([^\'\\\\]|\\\\([\'\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\'"),
+	T_STRING_SQ("\"([^\"\\\\]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
+	T_STRING_DQ("\'([^\'\\\\]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"),
 	T_AOPEN("\\{"),
 	T_ACLOSE("\\}"),
 	T_SQOPEN("\\["),

ScriptingExample/scripts/helloworld.zs

@@ -1,3 +1,5 @@
-println("Hello world!");
+println("Hello \© world!");
 println(5);
-println(1 + 3);
+println(2 + 5);
+println(1 - 2);
+println(1 + 3 as long);

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

@@ -223,7 +223,7 @@ public class StringUtils {
 	 * @param hex hex digit
 	 * @return converted value
 	 */
-	public static int readHexCharacter(char hex)
+	private static int readHexCharacter(char hex)
 	{
 		if (hex >= '0' && hex <= '9')
 			return hex - '0';
@@ -267,7 +267,7 @@ public class StringUtils {
 	 * @throws IllegalArgumentException if the given string does not contain a
 	 *	valid character entity at the given position
 	 */
-	public static CharacterEntity readCharacterEntity(String str, int offset)
+	private static CharacterEntity readCharacterEntity(String str, int offset)
 	{
 		if (offset + 3 >= str.length())
 			throw new IllegalArgumentException("Not a proper character entity");