- Fixed crash when classes doesn't exist + don't output debug classes if not in debug mode

- Fixed constructor support for native classes
- Added project for maven build
- Added missing StdLibs.zip

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

 	}
 	
 	public InvalidExpression(StoredType type, CompileException cause) {
-		this(cause.position, type, cause.code, cause.getMessage());
+		this(cause.position, type, cause.code, cause.message);
 	}
 
 	@Override

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

 	public void dump(File directory) {
 		writeScripts();
 		
+		if (!directory.exists())
+			directory.mkdirs();
+		
 		for (Map.Entry<String, byte[]> classEntry : classes.entrySet()) {
 			File output = new File(directory, classEntry.getKey() + ".class");
 			try (FileOutputStream outputStream = new FileOutputStream(output)) {

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

 			return "generatedBlock" + (generatedScriptBlockCounter++);
 		} else {
 			// TODO: remove special characters
-			System.out.println("Writing script: " + filename);
 			return filename.substring(0, filename.lastIndexOf('.')).replace("/", "_");
 		}
 	}

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

 			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
 		}
 		
-		for (Method method : cls.getDeclaredMethods()) {
-			ZenCodeType.Constructor constructorAnnotation = method.getAnnotation(ZenCodeType.Constructor.class);
-			if (constructorAnnotation != null || (!annotated && method.getName().equals("<init>"))) {
-				ConstructorMember member = asConstructor(definition, method);
+		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
+			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor)constructor.getAnnotation(ZenCodeType.Constructor.class);
+			if (constructorAnnotation != null || !annotated) {
+				ConstructorMember member = asConstructor(definition, constructor);
 				definition.addMember(member);
-				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
+				compiled.setMethodInfo(member, getMethod(javaClass, constructor));
 			}
-			
+		}
+		
+		for (Method method : cls.getDeclaredMethods()) {
 			ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);
 			if (methodAnnotation != null) {
 				MethodMember member = asMethod(definition, method, methodAnnotation);
 		return name;
 	}
 	
-	private ConstructorMember asConstructor(HighLevelDefinition definition, Method method) {
+	private ConstructorMember asConstructor(HighLevelDefinition definition, java.lang.reflect.Constructor method) {
 		FunctionHeader header = getHeader(method);
 		return new ConstructorMember(
 				CodePosition.NATIVE,
 				definition,
-				getMethodModifiers(method),
+				Modifiers.PUBLIC,
 				header,
 				null);
 	}
 		return new CasterMember(CodePosition.NATIVE, definition, modifiers, toType, null);
 	}
 	
+	private FunctionHeader getHeader(java.lang.reflect.Constructor constructor) {
+		return getHeader(
+				null,
+				constructor.getAnnotatedParameterTypes(),
+				constructor.getTypeParameters(),
+				constructor.getAnnotatedExceptionTypes());
+	}
+	
 	private FunctionHeader getHeader(Method method) {
-		StoredType returnType = loadStoredType(method.getAnnotatedReturnType());
-		
-		FunctionParameter[] parameters = new FunctionParameter[method.getParameterCount()];
-		AnnotatedType[] parameterTypes = method.getAnnotatedParameterTypes();
+		return getHeader(
+				method.getAnnotatedReturnType(),
+				method.getAnnotatedParameterTypes(),
+				method.getTypeParameters(),
+				method.getAnnotatedExceptionTypes());
+	}
+	
+	private FunctionHeader getHeader(
+			AnnotatedType javaReturnType,
+			AnnotatedType[] parameterTypes,
+			TypeVariable<Method>[] javaTypeParameters,
+			AnnotatedType[] exceptionTypes)
+	{
+		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(javaReturnType);
+		
+		FunctionParameter[] parameters = new FunctionParameter[parameterTypes.length];
 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = new FunctionParameter(loadStoredType(parameterTypes[i]));
 		}
 		
-		TypeVariable<Method>[] javaTypeParameters = method.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
 				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(bound)));
 		}
 		
-		AnnotatedType[] exceptionTypes = method.getAnnotatedExceptionTypes();
 		if (exceptionTypes.length > 1)
 			throw new IllegalArgumentException("A method can only throw a single exception type!");
 		
 		return org.objectweb.asm.Type.getDescriptor(cls);
 	}
 	
+	private static String getMethodDescriptor(java.lang.reflect.Constructor constructor) {
+		return org.objectweb.asm.Type.getConstructorDescriptor(constructor);
+	}
+	
 	private static String getMethodDescriptor(Method method) {
 		return org.objectweb.asm.Type.getMethodDescriptor(method);
 	}
 	
+	private static JavaMethod getMethod(JavaClass cls, java.lang.reflect.Constructor constructor) {
+		return new JavaMethod(
+				cls,
+				JavaMethod.Kind.CONSTRUCTOR,
+				"<init>",
+				false,
+				getMethodDescriptor(constructor),
+				constructor.getModifiers(),
+				false);
+	}
+	
 	private static JavaMethod getMethod(JavaClass cls, Method method, StoredType result) {
 		JavaMethod.Kind kind;
 		if (method.getName().equals("<init>"))

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java

 	private final List<JavaNativeModule> nativeModules = new ArrayList<>();
 	private final List<SemanticModule> compiledModules = new ArrayList<>();
 	
+	public boolean debug = false;
+	
 	public ScriptingEngine() {
 		space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
 		
 		JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit();
 		for (SemanticModule compiled : compiledModules)
 			runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
-		runUnit.dump(new File("classes"));
+		if (debug)
+			runUnit.dump(new File("classes"));
 		runUnit.run();
 	}
 }

JavaScripting/build.gradle

+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
+}
+
+def javaScriptingProjects = [':JavaIntegration',':JavaAnnotations',':JavaBytecodeCompiler', ':JavaShared', ':Validator', ':Parser', ':CodeModel', ':Shared']
+jar {
+	dependsOn javaScriptingProjects.collect{ it+":compileJava"}
+    from files(javaScriptingProjects.collect{ project(it).sourceSets.main.output })
+}
+
+install {
+	repositories.mavenInstaller {
+		pom.artifactId = 'zencode-javascripting'
+	}
+}

JavaScripting/configuration.gradle

+group='org.openzen.zencode'
+version='0.1.0'

ScriptingExample/scripts/integration.zs

+import example.TestClass;
+
+val instance = new TestClass("Instance");
+println("Name: " + instance.name);
+instance.dump();

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 	public static void main(String[] args) throws CompileException, ParseException, IOException {
 		ScriptingEngine scriptingEngine = new ScriptingEngine();
 		
-		JavaNativeModule module = scriptingEngine.createNativeModule("globals", "org.openzen.zenscript.scriptingexample");
-		module.addGlobals(Globals.class);
-		scriptingEngine.registerNativeProvided(module);
+		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
+		example.addGlobals(Globals.class);
+		example.addClass(TestClass.class);
+		scriptingEngine.registerNativeProvided(example);
 		
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

+/*
+ * 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.scriptingexample;
+
+import org.openzen.zencode.java.ZenCodeType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TestClass implements ZenCodeType {
+	private final String name;
+	
+	@Constructor
+	public TestClass(String name) {
+		this.name = name;
+	}
+	
+	@Getter
+	public String getName() {
+		return name;
+	}
+	
+	@Method
+	public void dump() {
+		System.out.println("TestClass " + name);
+	}
+}

common.gradle

 apply plugin: 'java'
 apply plugin: 'maven'
 
-String mavenGroupId = 'org.openzen.zenscript'
-String mavenVersion = '1.0-SNAPSHOT'
+String mavenGroupId = 'org.openzen.zencode'
+String mavenVersion = '0.1.2'
 
 sourceCompatibility = '1.8'
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
 
 repositories {
     mavenCentral();
-    // You may define additional repositories, or even remove "mavenCentral()".
-    // Read more about repositories here:
-    //   http://www.gradle.org/docs/current/userguide/dependency_management.html#sec:repositories
 }
 
 dependencies {
-    // Adding dependencies here will add the dependencies to each subproject.
-    testCompile group: 'junit', name: 'junit', version: '4.10'
 	compile 'net.sf.trove4j:trove4j:3.0.3'
 }
 
     from sourceSets.main.allSource
 }
 
-artifacts {
-    archives jar
-    archives sourcesJar
-}
-
 configure(install.repositories.mavenInstaller) {
     pom.project {
         groupId = mavenGroupId