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

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
     public static String calcClasName(CodePosition position) {
         return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
     }
-	
-	public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
-		JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
-		for (int i = 0; i < header.parameters.length; i++) {
-			FunctionParameter parameter = header.parameters[i];
-			Type parameterType = parameter.type.accept(typeVisitor);
-			parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
-		}
-	}
-	
-	public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
-		JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
-		for (int i = 0; i < header.parameters.length; i++) {
-			FunctionParameter parameter = header.parameters[i];
-			Type parameterType = parameter.type.accept(typeVisitor);
-			parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
-		}
-	}
-	
-	public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
-		JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(constructorWriter);
-		for (final IDefinitionMember definitionMember : definition.members) {
-			if (!(definitionMember instanceof FieldMember))
-				continue;
-			
-			FieldMember field = (FieldMember) definitionMember;
-			if (field.isStatic() == staticFields && field.initializer != null) {
-				constructorWriter.loadObject(0);
-				field.initializer.accept(expressionVisitor);
-				constructorWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
-			}
-		}
-	}
+
+    public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
+        JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
+        for (int i = 0; i < header.parameters.length; i++) {
+            FunctionParameter parameter = header.parameters[i];
+            Type parameterType = parameter.type.accept(typeVisitor);
+            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
+        }
+    }
+
+    public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
+        JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
+        for (int i = 0; i < header.parameters.length; i++) {
+            FunctionParameter parameter = header.parameters[i];
+            Type parameterType = parameter.type.accept(typeVisitor);
+            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
+        }
+    }
+
+    public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
+        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(constructorWriter);
+        for (final IDefinitionMember definitionMember : definition.members) {
+            if (!(definitionMember instanceof FieldMember))
+                continue;
+
+            FieldMember field = (FieldMember) definitionMember;
+            if (field.isStatic() == staticFields && field.initializer != null) {
+                if (!staticFields)
+                    constructorWriter.loadObject(0);
+                field.initializer.accept(expressionVisitor);
+                if (staticFields)
+                    constructorWriter.putStaticField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                else
+                    constructorWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+            }
+        }
+    }
+
+
+    public static int getKeyForSwitch(Expression expression) {
+        if (expression.type instanceof BasicTypeID)
+            switch ((BasicTypeID) expression.type) {
+                case BOOL:
+                    if (expression instanceof ConstantBoolExpression)
+                        return ((ConstantBoolExpression) expression).value ? 1 : 0;
+                    break;
+                case BYTE:
+                    if (expression instanceof ConstantByteExpression)
+                        return ((ConstantByteExpression) expression).value;
+                    break;
+                case SBYTE:
+                    if (expression instanceof ConstantSByteExpression)
+                        return ((ConstantSByteExpression) expression).value;
+                    break;
+                case SHORT:
+                    if(expression instanceof ConstantShortExpression)
+                        return ((ConstantShortExpression) expression).value;
+                    break;
+                case USHORT:
+                    if (expression instanceof ConstantUShortExpression)
+                        return ((ConstantUShortExpression) expression).value;
+                    break;
+                case INT:
+                    if (expression instanceof ConstantIntExpression)
+                        return ((ConstantIntExpression) expression).value;
+                    break;
+                case UINT:
+                    if (expression instanceof ConstantUIntExpression)
+                        return ((ConstantUIntExpression) expression).value;
+                    break;
+                case LONG:
+                    if(expression instanceof ConstantLongExpression)
+                        return (int)((ConstantLongExpression) expression).value;
+                    break;
+                case ULONG:
+                    if(expression instanceof ConstantULongExpression)
+                        return (int)((ConstantULongExpression) expression).value;
+                    break;
+                case CHAR:
+                    if(expression instanceof ConstantCharExpression)
+                        return ((ConstantCharExpression) expression).value;
+                    break;
+                case STRING:
+                    if(expression instanceof ConstantStringExpression)
+                        return ((ConstantStringExpression) expression).value.hashCode();
+                    break;
+            }
+            throw new RuntimeException("Cannot switch over expression " + expression);
+    }
 }

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

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+
+import java.util.Arrays;
+import java.util.List;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
     public final JavaExpressionVisitor expressionVisitor;
-	
+
     /**
      * @param javaWriter the method writer that compiles the statement
      */
 
     @Override
     public Boolean visitBlock(BlockStatement statement) {
-		Boolean returns = false;
+        Boolean returns = false;
         for (Statement statement1 : statement.statements) {
             returns = statement1.accept(this);
         }
         javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
         return true;
     }
-	
-	@Override
-	public Boolean visitSwitch(SwitchStatement statement) {
-		throw new UnsupportedOperationException("Not yet implemented!");
-	}
+
+    @Override
+    public Boolean visitSwitch(SwitchStatement statement) {
+
+        final Label start = new Label();
+        final Label end = new Label();
+
+        if (statement.label == null)
+            statement.label = javaWriter.createLabelName() + "Switch";
+
+        javaWriter.putNamedLabel(start, statement.label + "_start");
+        javaWriter.putNamedLabel(end, statement.label + "_end");
+
+
+        javaWriter.label(start);
+        statement.value.accept(expressionVisitor);
+        if(statement.value.type == BasicTypeID.STRING)
+            javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
+        boolean out = false;
+
+        final boolean hasNoDefault = hasNoDefault(statement);
+
+        final List<SwitchCase> cases = statement.cases;
+
+        final int[] keys = new int[hasNoDefault ? cases.size() : cases.size() - 1];
+        final Label[] labels = new Label[keys.length];
+        final Label defaultLabel = new Label();
+
+        Arrays.parallelSetAll(labels, value -> new Label());
+
+        int i = 0;
+        for (final SwitchCase switchCase : cases)
+            if (switchCase.value != null)
+                keys[i++] = CompilerUtils.getKeyForSwitch(switchCase.value);
+
+        javaWriter.lookupSwitch(defaultLabel, keys, labels);
+
+        i = 0;
+        for (final SwitchCase switchCase : cases) {
+            if (hasNoDefault || switchCase.value != null) {
+                javaWriter.label(labels[i++]);
+            } else {
+                javaWriter.label(defaultLabel);
+            }
+            for (Statement statement1 : switchCase.statements) {
+                out |= statement1.accept(this);
+            }
+        }
+
+        if(hasNoDefault)
+            javaWriter.label(defaultLabel);
+
+        javaWriter.label(end);
+
+
+        //throw new UnsupportedOperationException("Not yet implemented!");
+        return out;
+    }
+
+    private boolean hasNoDefault(SwitchStatement switchStatement) {
+        for (SwitchCase switchCase : switchStatement.cases)
+            if (switchCase.value == null) return false;
+        return true;
+    }
 
     @Override
     public Boolean visitThrow(ThrowStatement statement) {

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

             visitor.visitParameter(name, modifier);
     }
 
+    public void lookupSwitch(Label defaultLabel, int[] keys, Label[] labels) {
+        visitor.visitLookupSwitchInsn(defaultLabel, keys, labels);
+    }
+
     public void addVariableInfo(JavaLocalVariableInfo info) {
         localVariableInfos.add(info);
     }

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

 
         writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
 
-        for (IDefinitionMember member : definition.members) {
-            if (member instanceof EnumConstantMember) {
-                EnumConstantMember constantMember = (EnumConstantMember) member;
-                writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, constantMember.name, "L" + definition.name + ";", null, null).visitEnd();
-            }
-        }
-
 		JavaClassInfo toClass = new JavaClassInfo(definition.name, true);
-		writeEnumStaticInitializer(definition, toClass, writer);
 
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
-		
+
+        final JavaMemberVisitor visitor = new JavaMemberVisitor(writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
-            member.accept(new JavaMemberVisitor(writer, toClass, definition));
+            member.accept(visitor);
         }
 		
 		JavaClassInfo arrayClass = new JavaClassInfo("[L" + definition.name + ";");
         writer.visitEnd();
         return writer.toByteArray();
     }
-	
-	private void writeEnumStaticInitializer(EnumDefinition definition, JavaClassInfo toClass, ClassWriter writer) {
-		JavaMethodInfo clinitInfo = new JavaMethodInfo(toClass, "<clinit>", "()V", Opcodes.ACC_STATIC);
-        final JavaWriter clinitWriter = new JavaWriter(writer, clinitInfo, definition, null, null);
-        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter);
-        clinitVisitor.start();
-		
-		List<EnumConstantMember> enumConstants = definition.getEnumConstants();
-		for (EnumConstantMember enumConstant : enumConstants) {
-			final String internalName = enumConstant.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
-
-			clinitWriter.newObject(internalName);
-			clinitWriter.dup();
-			clinitWriter.constant(enumConstant.name);
-			clinitWriter.constant(enumConstant.value);
-			for (Expression argument : enumConstant.constructor.arguments.arguments) {
-				argument.accept(clinitVisitor.expressionVisitor);
-			}
-			clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(enumConstant.constructor.constructor.header, true));
-			clinitWriter.putStaticField(internalName, enumConstant.name, "L" + internalName + ";");
-		}
-
-        clinitWriter.constant(enumConstants.size());
-        clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
-
-        for (EnumConstantMember enumConstant : enumConstants) {
-            clinitWriter.dup();
-            clinitWriter.constant(enumConstant.value);
-            clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
-            clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
-        }
-        clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        clinitVisitor.end();
-	}
 
     @Override
     public byte[] visitStruct(StructDefinition definition) {

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
-import java.util.ArrayList;
-import java.util.List;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
+import java.util.List;
+
 public class JavaMemberVisitor implements MemberVisitor<Void> {
 
     private final ClassWriter writer;
-	private final JavaClassInfo toClass;
-	private final HighLevelDefinition definition;
-	private final List<StaticInitializerMember> staticInitializers = new ArrayList<>();
+    private final JavaClassInfo toClass;
+    private final HighLevelDefinition definition;
+    private final JavaStatementVisitor clinitStatementVisitor;
+    private EnumDefinition enumDefinition = null;
 
     public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass, HighLevelDefinition definition) {
         this.writer = writer;
-		this.toClass = toClass;
-		this.definition = definition;
+        this.toClass = toClass;
+        this.definition = definition;
+
+        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<clinit>", "()V", 0), definition, null, null);
+        this.clinitStatementVisitor = new JavaStatementVisitor(javaWriter);
+        this.clinitStatementVisitor.start();
+        CompilerUtils.writeDefaultFieldInitializers(javaWriter, definition, true);
     }
 
     @Override
         //TODO calc signature
         String signature = null;
         final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
-        writer.visitField(member.modifiers, member.name, descriptor, signature, null).visitEnd();
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
         member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
         return null;
     }
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
-		final boolean isEnum = definition instanceof EnumDefinition;
-		String descriptor = CompilerUtils.calcDesc(member.header, isEnum);
-		final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
-		
+        final boolean isEnum = definition instanceof EnumDefinition;
+        String descriptor = CompilerUtils.calcDesc(member.header, isEnum);
+        final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
+
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
         final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, isEnum), null);
         constructorWriter.label(constructorStart);
-		CompilerUtils.tagConstructorParameters(member.header, isEnum);
+        CompilerUtils.tagConstructorParameters(member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
-					parameter.getTag(JavaParameterInfo.class).index,
-					parameter.name,
-					constructorStart,
-					constructorEnd,
-					Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                    parameter.getTag(JavaParameterInfo.class).index,
+                    parameter.name,
+                    constructorStart,
+                    constructorEnd,
+                    Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
         }
-		
+
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
         statementVisitor.start();
-		
-		if (!member.isConstructorForwarded()) {
-			if (isEnum) {
-				System.out.println("Writing enum constructor");
-				constructorWriter.getVisitor().newLocal(Type.getType(String.class));
-				constructorWriter.getVisitor().newLocal(Type.getType(int.class));
-				constructorWriter.loadObject(0);
-				constructorWriter.loadObject(1);
-				constructorWriter.loadInt(2);
-				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
-			} else if (definition.superType == null) {
-				System.out.println("Writing regular constructor");
-				constructorWriter.load(Type.getType(Object.class), 0);
-				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
-			}
-			
-			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
-		}
-		
+
+        if (!member.isConstructorForwarded()) {
+            if (isEnum) {
+                System.out.println("Writing enum constructor");
+                constructorWriter.getVisitor().newLocal(Type.getType(String.class));
+                constructorWriter.getVisitor().newLocal(Type.getType(int.class));
+                constructorWriter.loadObject(0);
+                constructorWriter.loadObject(1);
+                constructorWriter.loadInt(2);
+                constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
+            } else if (definition.superType == null) {
+                System.out.println("Writing regular constructor");
+                constructorWriter.load(Type.getType(Object.class), 0);
+                constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
+            }
+
+            CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
+        }
+
         member.body.accept(statementVisitor);
         constructorWriter.label(constructorEnd);
         statementVisitor.end();
 
     @Override
     public Void visitMethod(MethodMember member) {
-		CompilerUtils.tagMethodParameters(member.header, member.isStatic());
-		
+        CompilerUtils.tagMethodParameters(member.header, member.isStatic());
+
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
-		int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
-				| (member.isStatic() ? Opcodes.ACC_STATIC : 0)
-				| CompilerUtils.calcAccess(member.modifiers);
-		final JavaMethodInfo method = new JavaMethodInfo(
-				toClass,
-				member.name,
-				CompilerUtils.calcSign(member.header, false),
-				modifiers);
-		
+        int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
+                | (member.isStatic() ? Opcodes.ACC_STATIC : 0)
+                | CompilerUtils.calcAccess(member.modifiers);
+        final JavaMethodInfo method = new JavaMethodInfo(
+                toClass,
+                member.name,
+                CompilerUtils.calcSign(member.header, false),
+                modifiers);
+
         final Label methodStart = new Label();
         final Label methodEnd = new Label();
         final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
 
         if (!isAbstract) {
             statementVisitor.start();
-			member.body.accept(statementVisitor);
+            member.body.accept(statementVisitor);
             methodWriter.label(methodEnd);
             statementVisitor.end();
         }
 
     @Override
     public Void visitEnumConstant(EnumConstantMember member) {
+        writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, member.name, "L" + definition.name + ";", null, null).visitEnd();
+        final String internalName = member.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+        final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
+        clinitWriter.newObject(internalName);
+        clinitWriter.dup();
+        clinitWriter.constant(member.name);
+        clinitWriter.constant(member.value);
+        for (Expression argument : member.constructor.arguments.arguments) {
+            argument.accept(clinitStatementVisitor.expressionVisitor);
+        }
+
+        clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(member.constructor.constructor.header, true));
+        clinitWriter.putStaticField(internalName, member.name, "L" + internalName + ";");
+
+
+        enumDefinition = (EnumDefinition) member.definition;
+
         return null;
     }
 
         return null;
     }
 
-	@Override
-	public Void visitStaticInitializer(StaticInitializerMember member) {
-		staticInitializers.add(member);
-		return null;
-	}
-	
-	public void end() {
-		final JavaMethodInfo method = new JavaMethodInfo(toClass, "<clinit>", "()V", 0);
-		
-        final Label constructorStart = new Label();
-        final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, null, null);
-        constructorWriter.label(constructorStart);
-		
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
-        statementVisitor.start();
-		
-		CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, true);
-		
-		for (StaticInitializerMember member : staticInitializers) {
-	        member.body.accept(statementVisitor);
-		}
-		
-        constructorWriter.label(constructorEnd);
-        statementVisitor.end();
-	}
+    @Override
+    public Void visitStaticInitializer(StaticInitializerMember member) {
+        member.body.accept(clinitStatementVisitor);
+        return null;
+    }
+
+    public void end() {
+
+        if (enumDefinition != null) {
+            final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
+            final List<EnumConstantMember> enumConstants = enumDefinition.getEnumConstants();
+            clinitWriter.constant(enumConstants.size());
+            clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
+
+            for (EnumConstantMember enumConstant : enumConstants) {
+                clinitWriter.dup();
+                clinitWriter.constant(enumConstant.value);
+                clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
+                clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
+            }
+            clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+        }
+
+
+        clinitStatementVisitor.end();
+    }
 }

ScriptingExample/scripts/classes.zs

 	var nonFinalInt as int = 10;
 	val finalInt as int = 20;
 
+	static var staticNonFinalInt as int = 10;
+
 	public this() {
 
 	}
 	private val priority as int;
 	private val isCommutative as bool;
 
+	public static val test as int = 10;
+
 	this(i as int) {
 		this(i, false);
 	}

ScriptingExample/scripts/switch.zs

+val test as int = 10;
+
+
+switch test {
+	case 1 : println("yay"); break;
+	case 10 : println("yo");
+	case 100 : println("y");
+	default: println("yup");
+}
+
+
+val test2 as string = "hello";
+
+switch test2 {
+	case "bye" : println("hello");
+	case "hello" : println("goodbye");
+	default: println("hellogoodbye");
+}