- Improving compilation system to have compilation targets

- Added run & build functionality to the IDE
- Fixed an error in match expressions
- WIP on compiling to Java source files

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder();
-		if (typeParameters.length > 0) {
+		if (typeParameters != null && typeParameters.length > 0) {
 			result.append("<");
 			for (int i = 0; i < typeParameters.length; i++) {
 				if (i > 0)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ZSPackage.java

  * @author Hoofdgebruiker
  */
 public class ZSPackage {
+	public final String name;
 	public final String fullName;
+	public final ZSPackage parent;
 	
-	public ZSPackage(String fullName) {
-		this.fullName = fullName;
+	public ZSPackage(ZSPackage parent, String name) {
+		this.parent = parent;
+		this.name = name;
+		this.fullName = parent == null ? name : parent.fullName + "." + name;
 	}
 	
 	private final Map<String, ZSPackage> subPackages = new HashMap<>();
 		if (subPackages.containsKey(name))
 			return subPackages.get(name);
 		
-		ZSPackage result = new ZSPackage(fullName.isEmpty() ? name : fullName + '.' + name);
+		ZSPackage result = new ZSPackage(this, name);
 		subPackages.put(name, result);
 		return result;
 	}

CompilerShared/build.gradle

+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+	compile 'org.json:json:20180130'
+	compile project(':CodeModel')
+	compile project(':Linker')
+}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/CompilerOutput.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.compiler;
+
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface CompilerOutput {
+	void info(String message);
+	
+	void warning(String message);
+	
+	void warning(CodePosition position, String message);
+	
+	void error(String message);
+	
+	void error(CodePosition position, String message);
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SemanticModule.java → CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.constructor.module;
+package org.openzen.zenscript.compiler;
 
 import java.util.HashMap;
 import java.util.List;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.javabytecode.JavaCompiler;
-import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 
 /**
 		this.scripts = scripts;
 	}
 	
-	public JavaModule compileToJava() {
-		JavaCompiler compiler = new JavaCompiler(false);
+	public void compile(ZenCodeCompiler compiler) {
 		for (HighLevelDefinition definition : definitions.getAll()) {
 			compiler.addDefinition(definition);
 		}
 		for (ScriptBlock script : scripts) {
 			compiler.addScriptBlock(script);
 		}
-		return compiler.finish();
+		compiler.finish();
 	}
 }

CompilerShared/src/main/java/org/openzen/zenscript/compiler/Target.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.compiler;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface Target {
+	public ZenCodeCompiler createCompiler(SemanticModule module);
+	
+	public String getModule();
+	
+	public String getName();
+	
+	public boolean canRun();
+	
+	public boolean canBuild();
+}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/TargetType.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.compiler;
+
+import java.io.File;
+import org.json.JSONObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface TargetType {
+	public Target create(File projectDir, JSONObject definition);
+}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ZenCodeCompiler.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.compiler;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ZenCodeCompiler {
+	void addDefinition(HighLevelDefinition definition);
+	
+	void addScriptBlock(ScriptBlock script);
+	
+	void finish();
+	
+	void run();
+}

Constructor/build.gradle

 	compile 'org.json:json:20180130'
 	compile project(':CodeModel')
 	compile project(':Parser')
+	compile project(':Linker')
 	compile project(':Validator')
+	compile project(':CompilerShared')
 	compile project(':JavaBytecodeCompiler')
+	compile project(':JavaSourceCompiler')
 }

Constructor/libraries/stdlib/src/Arrays.zs

 		return null;
 	}
 	
-	public last(predicate as function(value as T) as bool) as T? {
+	public last(predicate as function(index as int, value as T) as bool) as T? {
 		for i, value in this.reversed
-			if predicate(value)
-				return value
+			if predicate(i, value)
+				return value;
 		
 		return null;
 	}

Constructor/src/main/java/org/openzen/zenscript/constructor/ConstructorRegistry.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.constructor;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.compiler.TargetType;
+import org.openzen.zenscript.javabytecode.JavaBytecodeJarTargetType;
+import org.openzen.zenscript.javabytecode.JavaBytecodeRunTargetType;
+import org.openzen.zenscript.javasource.JavaSourceTargetType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstructorRegistry {
+	private static final Map<String, TargetType> targetTypes = new HashMap<>();
+	
+	static {
+		registerTargetType("javaSource", JavaSourceTargetType.INSTANCE);
+		registerTargetType("javaBytecodeJar", JavaBytecodeJarTargetType.INSTANCE);
+		registerTargetType("javaBytecodeRun", JavaBytecodeRunTargetType.INSTANCE);
+	}
+	
+	public static void registerTargetType(String name, TargetType type) {
+		targetTypes.put(name, type);
+	}
+	
+	public static TargetType getTargetType(String name) {
+		return targetTypes.get(name);
+	}
+
+	private ConstructorRegistry() {}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.constructor.module.ModuleSpace;
-import org.openzen.zenscript.constructor.module.SemanticModule;
+import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 import org.openzen.zenscript.parser.ParsedFile;
 import org.openzen.zenscript.shared.CompileException;

Constructor/src/main/java/org/openzen/zenscript/constructor/ModuleLoader.java

 import java.util.Map;
 import java.util.Stack;
 import org.openzen.zenscript.constructor.module.ModuleReference;
-import org.openzen.zenscript.constructor.module.SemanticModule;
+import org.openzen.zenscript.compiler.SemanticModule;
 
 /**
  *

Constructor/src/main/java/org/openzen/zenscript/constructor/Project.java

 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.TargetType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class Project {
+	public final File directory;
 	public final String name;
 	public final ModuleReference[] modules;
 	public final Library[] libraries;
+	public final Target[] targets;
 	
 	public Project(ModuleLoader loader, File directory) throws IOException {
+		this.directory = directory;
 		name = directory.getName();
 		
 		if (!directory.exists())
 				}
 			}
 		}
+		
+		JSONArray jsonTargets = json.getJSONArray("targets");
+		List<Target> targetList = new ArrayList<>();
+		for (int i = 0; i < jsonTargets.length(); i++) {
+			JSONObject jsonTarget = jsonTargets.getJSONObject(i);
+			TargetType targetType = ConstructorRegistry.getTargetType(jsonTarget.getString("type"));
+			if (targetType == null) {
+				System.out.println("Unknown target type: " + jsonTarget.getString("type"));
+				continue;
+			}
+			
+			targetList.add(targetType.create(directory, jsonTarget));
+		}
+		targets = targetList.toArray(new Target[targetList.size()]);
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleLoader.java

  */
 package org.openzen.zenscript.constructor.module;
 
+import org.openzen.zenscript.compiler.SemanticModule;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 				space.addModule(dependencyName, loader.getModule(dependencyName));
 
 			Module module = new Module(moduleName, directory, jsonFile);
-			ZSPackage pkg = new ZSPackage(module.packageName);
+			ZSPackage pkg = new ZSPackage(null, module.packageName);
 
 			ParsedFile[] parsedFiles = module.parse(pkg);
 			SemanticModule result = Module.compileSyntaxToSemantic(pkg, parsedFiles, space);

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleReference.java

  */
 package org.openzen.zenscript.constructor.module;
 
+import org.openzen.zenscript.compiler.SemanticModule;
+
 /**
  *
  * @author Hoofdgebruiker

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java

  */
 package org.openzen.zenscript.constructor.module;
 
+import org.openzen.zenscript.compiler.SemanticModule;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
  * @author Hoofdgebruiker
  */
 public class ModuleSpace {
-	private final ZSPackage rootPackage = new ZSPackage("");
-	private final ZSPackage stdlib = new ZSPackage("");
+	private final ZSPackage rootPackage = new ZSPackage(null, "");
+	private final ZSPackage stdlib = new ZSPackage(null, "stdlib");
 	public final GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry(stdlib);
-	public final ZSPackage globalsPackage = new ZSPackage("");
+	public final ZSPackage globalsPackage = new ZSPackage(null, "");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
 	

DrawableGui/src/main/java/org/openzen/drawablegui/DCompositeIcon.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.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DCompositeIcon implements DColorableIcon {
+	private final DColorableIcon base;
+	private final DColorableIcon addition;
+	private final DTransform2D additionTransform;
+	
+	public DCompositeIcon(DColorableIcon base, DColorableIcon addition, DTransform2D additionTransform) {
+		this.base = base;
+		this.addition = addition;
+		this.additionTransform = additionTransform;
+	}
+
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		base.draw(canvas, transform, color);
+		addition.draw(canvas, transform.mul(additionTransform), color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return base.getNominalWidth();
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return base.getNominalHeight();
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DInputField.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.drawablegui;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DInputField implements DComponent {
+	public final LiveString value;
+	private final ListenerHandle<LiveString.Listener> valueListener;
+	
+	private final DStyleClass styleClass;
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private DIRectangle bounds = DIRectangle.EMPTY;
+	
+	private DUIContext context;
+	private DInputFieldStyle style;
+	private DFontMetrics fontMetrics;
+	private int cursorFrom = -1;
+	private int cursorTo = -1;
+	
+	public DInputField(DStyleClass styleClass, LiveString value) {
+		this.styleClass = styleClass;
+		this.value = value;
+		valueListener = value.addListener((oldValue, newValue) -> handleValueUpdated(newValue));
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("input", styleClass);
+		style = new DInputFieldStyle(context.getStylesheets().get(context, path));
+		fontMetrics = context.getFontMetrics(style.font);
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		canvas.drawText(style.font, style.color, bounds.x + style.paddingLeft, bounds.y + style.paddingBottom, value.getValue());
+	}
+
+	@Override
+	public void close() {
+		valueListener.close();
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		context.focus(this);
+	}
+	
+	private void handleValueUpdated(String newValue) {
+		
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DInputFieldStyle.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.drawablegui;
+
+import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DInputFieldStyle {
+	public final int backgroundColor;
+	public final int paddingTop;
+	public final int paddingLeft;
+	public final int paddingRight;
+	public final int paddingBottom;
+	
+	public final int color;
+	public final DFont font;
+	
+	public final int cursorColor;
+	public final int cursorWidth;
+	
+	public final int selectionColor;
+	
+	public DInputFieldStyle(DStyleDefinition style) {
+		backgroundColor = style.getColor("backgroundColor", 0);
+		paddingTop = style.getDimension("paddingTop", new DDpDimension(2));
+		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(2));
+		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(2));
+		paddingRight = style.getDimension("paddingRight", new DDpDimension(2));
+		
+		color = style.getColor("color", 0xFF000000);
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getScale())));
+		
+		cursorColor = style.getColor("cursorColor", 0xFF000000);
+		cursorWidth = style.getDimension("cursorWidth", new DDpDimension(1));
+		
+		selectionColor = style.getColor("selectionColor", 0xFFB0C5E3);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DUIWindow.java

  * @author Hoofdgebruiker
  */
 public interface DUIWindow {
-	public boolean hasTitleBar();
+	boolean hasTitleBar();
 	
-	public void close();
+	void close();
 	
-	public void maximize();
+	void maximize();
 	
-	public void restore();
+	void restore();
 	
-	public void minimize();
+	void minimize();
 	
 	LiveObject<State> getWindowState();
 	
 	LiveBool getActive();
 	
+	DUIWindow openModal(String title, DComponent root);
+	
 	enum State {
 		NORMAL,
 		MAXIMIZED,

DrawableGui/src/main/java/org/openzen/drawablegui/form/DForm.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.drawablegui.form;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DForm implements DComponent {
+	private final DFormComponent[] components;
+	private final DStyleClass styleClass;
+	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	
+	private DIRectangle bounds;
+	private DUIContext context;
+	private DFormStyle style;
+	private DFontMetrics fontMetrics;
+	
+	public DForm(DStyleClass styleClass, DFormComponent... components) {
+		this.styleClass = styleClass;
+		this.components = components;
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("form", styleClass);
+		style = new DFormStyle(context.getStylesheets().get(context, path));
+		fontMetrics = context.getFontMetrics(style.labelFont);
+		for (DFormComponent component : components)
+			component.component.setContext(path, context);
+		
+		int height = style.paddingBottom + style.paddingTop;
+		int maxTextWidth = style.minimumLabelSize;
+		int maxComponentWidth = style.minimumFieldSize;
+		
+		for (DFormComponent component : components) {
+			maxTextWidth = Math.max(maxTextWidth, fontMetrics.getWidth(component.label));
+			int componentWidth = component.component.getDimensionPreferences().getValue().preferredWidth;
+			maxComponentWidth = Math.max(maxComponentWidth, componentWidth);
+		}
+		
+		for (DFormComponent component : components) {
+			height += component.component.getDimensionPreferences().getValue().preferredHeight;
+			height += style.spacing;
+		}
+		
+		preferences.setValue(new DDimensionPreferences(maxTextWidth + maxComponentWidth, height));
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return preferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+		layout();
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		for (DFormComponent component : components) {
+			
+		}
+	}
+
+	@Override
+	public void close() {
+		
+	}
+	
+	private void layout() {
+		int x = bounds.x + style.paddingLeft;
+		int y = bounds.y + style.paddingBottom;
+		int maxTextWidth = style.minimumLabelSize;
+		
+		for (DFormComponent component : components)
+			maxTextWidth = Math.max(maxTextWidth, fontMetrics.getWidth(component.label));
+		
+		for (DFormComponent component : components) {
+			int preferredHeight = component.component.getDimensionPreferences().getValue().preferredHeight;
+			DIRectangle componentBounds = new DIRectangle(x + maxTextWidth, y, bounds.width - maxTextWidth, preferredHeight);
+			component.component.setBounds(componentBounds);
+			
+			y += preferredHeight + style.spacing;
+		}
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/form/DFormComponent.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.drawablegui.form;
+
+import org.openzen.drawablegui.DComponent;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DFormComponent {
+	public final String label;
+	public final DComponent component;
+	
+	public DFormComponent(String label, DComponent component) {
+		this.label = label;
+		this.component = component;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/form/DFormStyle.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.drawablegui.form;
+
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DFormStyle {
+	public final int paddingLeft;
+	public final int paddingTop;
+	public final int paddingRight;
+	public final int paddingBottom;
+	public final int spacing;
+	
+	public final int labelColor;
+	public final DFont labelFont;
+	public final int minimumLabelSize;
+	public final int minimumFieldSize;
+	
+	public DFormStyle(DStyleDefinition style) {
+		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(16));
+		paddingTop = style.getDimension("paddingTop", new DDpDimension(16));
+		paddingRight = style.getDimension("paddingRight", new DDpDimension(16));
+		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(16));
+		spacing = style.getDimension("spacing", new DDpDimension(8));
+		
+		labelColor = style.getColor("labelColor", 0xFF000000);
+		labelFont = style.getFont("labelFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(16 * context.getScale())));
+		minimumLabelSize = style.getDimension("minimumLabelSize", new DDpDimension(150));
+		minimumFieldSize = style.getDimension("minimumFieldSize", new DDpDimension(150));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveString.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.drawablegui.live;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface LiveString {
+	ListenerHandle<Listener> addListener(Listener listener);
+	
+	String getValue();
+	
+	void setValue(String value);
+	
+	interface Listener {
+		void onChanged(String oldValue, String newValue);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveString.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.drawablegui.live;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleLiveString implements LiveString {
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	
+	private String value;
+	
+	public SimpleLiveString(String value) {
+		this.value = value;
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+
+	@Override
+	public String getValue() {
+		return value;
+	}
+
+	@Override
+	public void setValue(String value) {
+		String oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onChanged(oldValue, value));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingWindow.java

 import java.awt.event.WindowStateListener;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.drawablegui.border.DCustomWindowBorder;
 	public LiveBool getActive() {
 		return active;
 	}
+	
+	@Override
+	public DUIWindow openModal(String title, DComponent component) {
+		SwingWindow result = new SwingWindow(title, component, false);
+		result.setResizable(false);
+		
+		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		result.setLocation(
+				getX() + (getWidth() - size.preferredWidth) / 2,
+				getY() + (getHeight() - size.preferredHeight) / 2);
+		result.setSize(size.preferredWidth, size.preferredHeight);
+		return result;
+	}
 
 	@Override
 	public void windowOpened(WindowEvent e) {

IDE/src/main/java/org/openzen/zenscript/ide/Main.java

 		
 		int pixelPerInch = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
 		
-		IDEWindow window = new IDEWindow();
+		IDEWindow window = new IDEWindow(host);
 		WindowView root = new WindowView(window, host);
 		
 		SwingWindow swingWindow = new SwingWindow("ZenCode IDE - " + host.getName(), root, false);

IDE/src/main/java/org/openzen/zenscript/ide/host/DevelopmentHost.java

 	public LiveList<IDEModule> getModules();
 	
 	public LiveList<IDELibrary> getLibraries();
+	
+	public LiveList<IDETarget> getTargets();
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/IDETarget.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.ide.host;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDETarget {
+	String getName();
+	
+	boolean canBuild();
+	
+	boolean canRun();
+	
+	void build();
+	
+	void run();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalProjectDevelopmentHost.java

 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.Project;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDELibrary;
+import org.openzen.zenscript.ide.host.IDETarget;
 
 /**
  *
 	private final Project project;
 	private final LiveList<IDEModule> modules;
 	private final LiveList<IDELibrary> libraries;
+	private final LiveList<IDETarget> targets;
 	
 	public LocalProjectDevelopmentHost(Project project) {
 		this.project = project;
 		libraries = new LiveArrayList<>();
 		for (Library library : project.libraries)
 			libraries.add(new LocalLibrary(library));
+		
+		targets = new LiveArrayList<>();
+		for (Target target : project.targets)
+			targets.add(new LocalTarget(project, target));
 	}
 	
 	@Override
 	public LiveList<IDELibrary> getLibraries() {
 		return libraries;
 	}
+
+	@Override
+	public LiveList<IDETarget> getTargets() {
+		return targets;
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.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.ide.host.local;
+
+import java.io.File;
+import java.io.IOException;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.Project;
+import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.ide.host.IDETarget;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalTarget implements IDETarget {
+	private final Project project;
+	private final Target target;
+	
+	public LocalTarget(Project project, Target target) {
+		this.project = project;
+		this.target = target;
+	}
+
+	@Override
+	public String getName() {
+		return target.getName();
+	}
+
+	@Override
+	public boolean canBuild() {
+		return target.canBuild();
+	}
+
+	@Override
+	public boolean canRun() {
+		return target.canRun();
+	}
+
+	@Override
+	public void build() {
+		buildInternal();
+	}
+
+	@Override
+	public void run() {
+		ZenCodeCompiler compiler = buildInternal();
+		if (compiler != null)
+			compiler.run();
+	}
+	
+	private ZenCodeCompiler buildInternal() {
+		ModuleLoader moduleLoader = new ModuleLoader();
+		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("../Constructor/libraries/stdlib"), true));
+		
+		try {
+			Project project = new Project(moduleLoader, this.project.directory);
+			for (Library library : project.libraries) {
+				for (ModuleReference module : library.modules)
+					moduleLoader.register(module.getName(), module);
+			}
+			for (ModuleReference module : project.modules) {
+				moduleLoader.register(module.getName(), module);
+			}
+
+			SemanticModule module = moduleLoader.getModule(target.getModule());
+			ZenCodeCompiler compiler = target.createCompiler(module);
+			for (HighLevelDefinition definition : module.definitions.getAll())
+				compiler.addDefinition(definition);
+			for (ScriptBlock script : module.scripts)
+				compiler.addScriptBlock(script);
+			
+			compiler.finish();
+			return compiler;
+		} catch (IOException ex) {
+			ex.printStackTrace();
+			return null;
+		}
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEWindow.java

  */
 package org.openzen.zenscript.ide.ui;
 
-import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.icons.AddBoxIcon;
 import org.openzen.zenscript.ide.ui.icons.BuildIcon;
 import org.openzen.zenscript.ide.ui.icons.PlayIcon;
-import org.openzen.zenscript.ide.ui.icons.ProjectIcon;
 import org.openzen.zenscript.ide.ui.icons.SettingsIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedProjectIcon;
 import org.openzen.zenscript.ide.ui.view.IconButtonControl;
  * @author Hoofdgebruiker
  */
 public class IDEWindow {
+	private final DevelopmentHost host;
+	
 	public final IDEAspectBar aspectBar;
 	public final IDEDockWindow dockWindow;
 	public final IDEStatusBar statusBar;
 	
 	public IDEAspectToolbar projectToolbar;
 	
-	public IDEWindow() {
+	public IDEWindow(DevelopmentHost host) {
+		this.host = host;
+		
 		aspectBar = new IDEAspectBar();
 		dockWindow = new IDEDockWindow();
 		statusBar = new IDEStatusBar();
 		init();
 	}
 	
-	public IDEWindow(IDEAspectBar aspectBar, IDEDockWindow dockWindow, IDEStatusBar statusBar) {
+	public IDEWindow(DevelopmentHost host, IDEAspectBar aspectBar, IDEDockWindow dockWindow, IDEStatusBar statusBar) {
+		this.host = host;
+		
 		this.aspectBar = aspectBar;
 		this.dockWindow = dockWindow;
 		this.statusBar = statusBar;
 		projectToolbar = new IDEAspectToolbar(0, ShadedProjectIcon.PURPLE, "Project", "Project management");
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, AddBoxIcon.ORANGE, e -> {}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, SettingsIcon.PURPLE, e -> {}));
-		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, e -> {}));
-		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, PlayIcon.GREEN, e -> {}));
+		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, e -> {
+			for (IDETarget target : host.getTargets()) {
+				if (target.canBuild())
+					target.build();
+			}
+		}));
+		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, PlayIcon.GREEN, e -> {
+			for (IDETarget target : host.getTargets()) {
+				if (target.canRun())
+					target.run();
+			}
+		}));
 		aspectBar.toolbars.add(projectToolbar);
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedView.java

 import org.openzen.drawablegui.DDimensionPreferences;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DPath;
-import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveArrayList;
 					bounds.width, bounds.height - totalTabHeight);
 				newValue.content.setBounds(contentBounds);
 			}
+			if (newValue == null && context != null && bounds != null)
+				context.repaint(bounds);
 		});
 	}
 	

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedViewStyle.java

 	public final DFont tabFont;
 	public final int tabFontColor;
 	
-	public final int tabColorNormal;
-	public final int tabColorHover;
-	public final int tabColorPress;
-	public final int tabColorActive;
-	
 	public final int paddingTop;
 	public final int paddingBottom;
 	public final int paddingLeft;
 	
 	public TabbedViewStyle(DStyleDefinition style) {
 		backgroundColor = style.getColor("backgroundColor", 0xFFEEEEEE);
-		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.CODE, false, false, false, (int)(12 * context.getScale())));
+		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(12 * context.getScale())));
 		tabFontColor = style.getColor("tabFontColor", 0xFF000000);
 		
-		tabColorNormal = style.getColor("tabColorNormal", 0xFFEEEEEE);
-		tabColorHover = style.getColor("tabColorHover", 0xFFFFFFFF);
-		tabColorPress = style.getColor("tabColorPress", 0xFFF0F0F0);
-		tabColorActive = style.getColor("tabColorActive", 0xFFFFFFFF);
-		
 		paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
 		paddingBottom = style.getDimension("paddingTop", new DDpDimension(4));
 		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(4));

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedViewTabStyle.java

 	public final int closeIconPadding;
 	
 	public TabbedViewTabStyle(DStyleDefinition style) {
-		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.CODE, false, false, false, (int)(12 * context.getScale())));
+		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(12 * context.getScale())));
 		tabFontColor = style.getColor("tabFontColor", 0xFF000000);
 		
 		tabColorNormal = style.getColor("tabColorNormal", 0xFFEEEEEE);

JavaBytecodeCompiler/build.gradle

 dependencies {
 	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
 	compile project(':CodeModel')
+	compile project(':CompilerShared')
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeJarTarget.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.javabytecode;
+
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.Target;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeJarTarget implements Target {
+	private final String module;
+	private final String name;
+	private final boolean debugCompiler;
+	
+	public JavaBytecodeJarTarget(JSONObject definition) {
+		module = definition.getString("module");
+		name = definition.optString("name", "Java Bytecode: " + module);
+		debugCompiler = definition.optBoolean("debugCompiler", false);
+	}
+	
+	@Override
+	public JavaCompiler createCompiler(SemanticModule module) {
+		return new JavaCompiler(debugCompiler);
+	}
+
+	@Override
+	public String getModule() {
+		return module;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public boolean canRun() {
+		return true;
+	}
+
+	@Override
+	public boolean canBuild() {
+		return true;
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeJarTargetType.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.javabytecode;
+
+import java.io.File;
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.TargetType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeJarTargetType implements TargetType {
+	public static final JavaBytecodeJarTargetType INSTANCE = new JavaBytecodeJarTargetType();
+	
+	private JavaBytecodeJarTargetType() {}
+
+	@Override
+	public Target create(File projectDir, JSONObject definition) {
+		return new JavaBytecodeJarTarget(definition);
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunTarget.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.javabytecode;
+
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.Target;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeRunTarget implements Target {
+	private final String module;
+	private final String name;
+	private final boolean debugCompiler;
+	
+	public JavaBytecodeRunTarget(JSONObject definition) {
+		module = definition.getString("module");
+		name = definition.optString("name", "Java Run: " + module);
+		debugCompiler = definition.optBoolean("debugCompiler", false);
+	}
+	
+	@Override
+	public JavaCompiler createCompiler(SemanticModule module) {
+		return new JavaCompiler(debugCompiler);
+	}
+
+	@Override
+	public String getModule() {
+		return module;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public boolean canRun() {
+		return true;
+	}
+
+	@Override
+	public boolean canBuild() {
+		return true;
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunTargetType.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.javabytecode;
+
+import java.io.File;
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.TargetType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeRunTargetType implements TargetType {
+	public static final JavaBytecodeRunTargetType INSTANCE = new JavaBytecodeRunTargetType();
+	
+	private JavaBytecodeRunTargetType() {}
+
+	@Override
+	public Target create(File projectDir, JSONObject definition) {
+		return new JavaBytecodeRunTarget(definition);
+	}
+}

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

 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.shared.SourceFile;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaCompiler {
+public class JavaCompiler implements ZenCodeCompiler {
 	static {
 		JavaClassInfo jInteger = new JavaClassInfo("java/lang/Integer");
 		JavaClassInfo jLong = new JavaClassInfo("java/lang/Long");
 	private final JavaClassWriter scriptsClassWriter;
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
+	private JavaModule compiled = null;
 	
 	public JavaCompiler() {
 		this(false);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	}
 	
+	@Override
 	public void addDefinition(HighLevelDefinition definition) {
 		String className = getClassName(definition.position.filename);
 		JavaScriptFile scriptFile = getScriptFile(className);
 		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
 	}
 	
+	@Override
 	public void addScriptBlock(ScriptBlock script) {
 		final SourceFile sourceFile = script.getTag(SourceFile.class);
 		final String className = getClassName(sourceFile == null ? null : sourceFile.filename);
 		return scriptBlocks.get(className);
 	}
 	
-	public JavaModule finish() {
+	@Override
+	public void finish() {
+		finishAndGetModule();
+	}
+	
+	@Override
+	public void run() {
+		if (compiled == null)
+			throw new IllegalStateException("Not yet built!");
+		
+		
+	}
+	
+	public JavaModule finishAndGetModule() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
 		finished = true;

JavaSourceCompiler/build.gradle

+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+    compile project(':CodeModel')
+	compile project(':CompilerShared')
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.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.javasource;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaDefinitionVisitor implements DefinitionVisitor<Void> {
+	private final JavaSourceFile file;
+	private final StringBuilder output;
+	
+	public JavaDefinitionVisitor(JavaSourceFile file, StringBuilder output) {
+		this.file = file;
+		this.output = output;
+	}
+
+	@Override
+	public Void visitClass(ClassDefinition definition) {
+		convertModifiers(definition.modifiers);
+		output.append("class ").append(definition.name);
+		if (definition.superType != null) {
+			output.append(" extends ");
+			output.append(definition.superType.accept(new JavaSourceTypeVisitor(file)));
+		}
+		List<ImplementationMember> mergedImplementations = new ArrayList<>();
+		for (IDefinitionMember member : definition.members) {
+			if (member instanceof ImplementationMember) {
+				if (isImplementationMergable((ImplementationMember)member))
+					mergedImplementations.add((ImplementationMember)member);
+			}
+		}
+		
+		if (mergedImplementations.size() > 0) {
+			output.append("implements ");
+			for (int i = 0; i < mergedImplementations.size(); i++) {
+				if (i > 0)
+					output.append(", ");
+				
+				ImplementationMember implementation = mergedImplementations.get(i);
+				output.append(implementation.type.accept(new JavaSourceTypeVisitor(file)));
+			}
+		}
+		
+		output.append(" {\n");
+		
+		
+		
+		output.append("}\n");
+		return null;
+	}
+
+	@Override
+	public Void visitInterface(InterfaceDefinition definition) {
+		convertModifiers(definition.modifiers);
+		output.append("interface ").append(definition.name);
+		output.append(" {\n");
+		
+		
+		
+		output.append("}\n");
+		return null;
+	}
+
+	@Override
+	public Void visitEnum(EnumDefinition definition) {
+		convertModifiers(definition.modifiers);
+		output.append("enum ").append(definition.name);
+		
+		output.append(" {\n");
+		
+		
+		
+		output.append("}\n");
+		return null;
+	}
+
+	@Override
+	public Void visitStruct(StructDefinition definition) {
+		convertModifiers(definition.modifiers | Modifiers.FINAL);
+		output.append("class ").append(definition.name);
+		output.append(" {\n");
+		
+		
+		
+		output.append("}\n");
+		return null;
+	}
+
+	@Override
+	public Void visitFunction(FunctionDefinition definition) {
+		convertModifiers(definition.modifiers | Modifiers.STATIC);
+		return null;
+	}
+
+	@Override
+	public Void visitExpansion(ExpansionDefinition definition) {
+		convertModifiers(definition.modifiers);
+		return null;
+	}
+
+	@Override
+	public Void visitAlias(AliasDefinition definition) {
+		throw new UnsupportedOperationException("Should not arrive here");
+	}
+
+	@Override
+	public Void visitVariant(VariantDefinition variant) {
+		return null;
+	}
+	
+	private void convertModifiers(int modifiers) {
+		if (Modifiers.isExport(modifiers) || Modifiers.isPublic(modifiers))
+			output.append("public ");
+		if (Modifiers.isPrivate(modifiers))
+			output.append("private ");
+		if (Modifiers.isProtected(modifiers))
+			output.append("protected ");
+		if (Modifiers.isStatic(modifiers))
+			output.append("static ");
+		if (Modifiers.isAbstract(modifiers))
+			output.append("abstract ");
+		if (!Modifiers.isVirtual(modifiers))
+			output.append("final ");
+	}
+	
+	private boolean isImplementationMergable(ImplementationMember implementation) {
+		return true; // TODO: check merging conflicts
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.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.javasource;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.shared.SourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceCompiler implements ZenCodeCompiler {
+	private final File directory;
+	private final ZSPackage pkg;
+	private final Map<File, JavaSourceFile> sourceFiles = new HashMap<>();
+	
+	public JavaSourceCompiler(File directory, ZSPackage pkg) {
+		if (!directory.exists())
+			directory.mkdirs();
+		
+		this.directory = directory;
+		this.pkg = pkg;
+	}
+	
+	@Override
+	public void addDefinition(HighLevelDefinition definition) {
+		File file = new File(getDirectory(definition.pkg), definition.name + ".java");
+		if (definition.name == null || definition instanceof FunctionDefinition) {
+			SourceFile source = definition.getTag(SourceFile.class);
+			if (source != null) {
+				int slash = Math.max(source.filename.lastIndexOf('/'), source.filename.lastIndexOf('\\'));
+				String filename = source.filename.substring(slash < 0 ? 0 : slash);
+				filename = filename.substring(0, filename.lastIndexOf('.'));
+				file = new File(getDirectory(definition.pkg), filename + ".java");
+			}
+		}
+		
+		JavaSourceFile sourceFile = sourceFiles.get(file);
+		if (sourceFile == null)
+			sourceFiles.put(file, sourceFile = new JavaSourceFile(this, file, definition.pkg.fullName));
+		
+		sourceFile.add(definition);
+	}
+	
+	@Override
+	public void addScriptBlock(ScriptBlock script) {
+		
+	}
+	
+	@Override
+	public void finish() {
+		for (JavaSourceFile sourceFile : sourceFiles.values())
+			sourceFile.write();
+	}
+	
+	@Override
+	public void run() {
+		throw new UnsupportedOperationException("Cannot run this target");
+	}
+	
+	public String getFullName(HighLevelDefinition definition) {
+		return definition.pkg.fullName + "." + definition.name;
+	}
+	
+	private File getDirectory(ZSPackage pkg) {
+		if (pkg == null)
+			throw new RuntimeException("Package not in the package directory");
+		if (pkg == this.pkg)
+			return directory;
+		
+		File base = getDirectory(pkg.parent);
+		return new File(base, pkg.name);
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceFile.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.javasource;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceFile {
+	private final JavaSourceCompiler compiler;
+	private final File file;
+	private final String packageName;
+	private final Map<String, String> imports = new HashMap<>();
+	private final StringBuilder contents = new StringBuilder();
+	
+	public JavaSourceFile(JavaSourceCompiler compiler, File file, String packageName) {
+		this.compiler = compiler;
+		this.packageName = packageName;
+		this.file = file;
+	}
+	
+	public String importType(HighLevelDefinition definition) {
+		return importType(compiler.getFullName(definition));
+	}
+	
+	public String importType(String fullName) {
+		String name = fullName.substring(fullName.lastIndexOf('.') + 1);
+		if (imports.containsKey(name))
+			return fullName;
+		
+		imports.put(name, fullName);
+		return name;
+	}
+	
+	public void add(HighLevelDefinition definition) {
+		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(this, contents);
+		definition.accept(visitor);
+	}
+	
+	public void write() {
+		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
+			writer.write("package ");
+			writer.write(packageName);
+			writer.write(";\n\n");
+			
+			if (this.imports.size() > 0) {
+				String[] imports = this.imports.values().toArray(new String[this.imports.size()]);
+				Arrays.sort(imports);
+
+				for (String importName : imports) {
+					writer.write("import ");
+					writer.write(importName);
+					writer.write(";");
+				}
+
+				writer.write("\n\n");
+			}
+			
+			writer.write(contents.toString());
+		} catch (IOException ex) {
+			ex.printStackTrace();
+		}
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceObjectTypeVisitor.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.javasource;
+
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceObjectTypeVisitor extends JavaSourceTypeVisitor {
+	public JavaSourceObjectTypeVisitor(JavaSourceFile file) {
+		super(file);
+	}
+	
+	@Override
+	public String visitBasic(BasicTypeID basic) {
+		switch (basic) {
+			case VOID: return "Void";
+			case ANY: return "Any";
+			case BOOL: return "Boolean";
+			case BYTE: return "Byte";
+			case SBYTE: return "Byte";
+			case SHORT: return "Short";
+			case USHORT: return "Short";
+			case INT: return "Integer";
+			case UINT: return "Integer";
+			case LONG: return "Long";
+			case ULONG: return "Long";
+			case FLOAT: return "Float";
+			case DOUBLE: return "Double";
+			case CHAR: return "Character";
+			case STRING: return "String";
+			default:
+				throw new IllegalArgumentException("Unknown basic type: " + basic);
+		}
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTarget.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.javasource;
+
+import java.io.File;
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceTarget implements Target {
+	private final String module;
+	private final String name;
+	private final File output;
+	
+	public JavaSourceTarget(File projectDir, JSONObject definition) {
+		module = definition.getString("module");
+		name = definition.optString("name", "Java Source: " + module);
+		output = new File(projectDir, definition.getString("output"));
+	}
+
+	@Override
+	public ZenCodeCompiler createCompiler(SemanticModule module) {
+		return new JavaSourceCompiler(output, module.pkg);
+	}
+
+	@Override
+	public String getModule() {
+		return module;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public boolean canRun() {
+		return false;
+	}
+
+	@Override
+	public boolean canBuild() {
+		return true;
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTargetType.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.javasource;
+
+import java.io.File;
+import org.json.JSONObject;
+import org.openzen.zenscript.compiler.Target;
+import org.openzen.zenscript.compiler.TargetType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceTargetType implements TargetType {
+	public static final JavaSourceTargetType INSTANCE = new JavaSourceTargetType();
+	
+	private JavaSourceTargetType() {}
+
+	@Override
+	public Target create(File projectDir, JSONObject definition) {
+		return new JavaSourceTarget(projectDir, definition);
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTypeVisitor.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.javasource;
+
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ConstTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceTypeVisitor implements ITypeVisitor<String> {
+	private final JavaSourceFile file;
+	
+	public JavaSourceTypeVisitor(JavaSourceFile file) {
+		this.file = file;
+	}
+
+	@Override
+	public String visitBasic(BasicTypeID basic) {
+		switch (basic) {
+			case VOID: return "void";
+			case ANY: return "Any";
+			case BOOL: return "boolean";
+			case BYTE: return "byte";
+			case SBYTE: return "byte";
+			case SHORT: return "short";
+			case USHORT: return "ushort";
+			case INT: return "int";
+			case UINT: return "int";
+			case LONG: return "long";
+			case ULONG: return "long";
+			case FLOAT: return "float";
+			case DOUBLE: return "double";
+			case CHAR: return "char";
+			case STRING: return "String";
+			default:
+				throw new IllegalArgumentException("Unknown basic type: " + basic);
+		}
+	}
+
+	@Override
+	public String visitArray(ArrayTypeID array) {
+		StringBuilder result = new StringBuilder();
+		result.append(array.elementType.accept(this));
+		for (int i = 0; i < array.dimension; i++)
+			result.append("[]");
+		
+		return result.toString();
+	}
+
+	@Override
+	public String visitAssoc(AssocTypeID assoc) {
+		String map = file.importType("java.util.Map");
+		return map + "<" + assoc.keyType.accept(new JavaSourceObjectTypeVisitor(file)) + ", " + assoc.valueType.accept(new JavaSourceObjectTypeVisitor(file)) + ">";
+	}
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		String javaMap = file.importType("java.util.Map");
+		if (map.keys.length > 1)
+			throw new UnsupportedOperationException("Not yet supported");
+		
+		return javaMap + "<Class<?>, " + map.value.accept(this) + ">";
+	}
+
+	@Override
+	public String visitIterator(IteratorTypeID iterator) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String visitFunction(FunctionTypeID function) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String visitDefinition(DefinitionTypeID definition) {
+		String javaType = file.importType(definition.definition);
+		StringBuilder result = new StringBuilder(javaType);
+		if (definition.typeParameters != null && definition.typeParameters.length > 0) {
+			result.append("<");
+			for (int i = 0; i < definition.typeParameters.length; i++) {
+				if (i > 0)
+					result.append(", ");
+				result.append(definition.typeParameters[i].accept(this));
+			}
+			result.append(">");
+		}
+		return result.toString();
+	}
+
+	@Override
+	public String visitGeneric(GenericTypeID generic) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String visitRange(RangeTypeID range) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String visitConst(ConstTypeID type) {
+		return type.baseType.accept(this);
+	}
+
+	@Override
+	public String visitOptional(OptionalTypeID optional) {
+		return optional.baseType.accept(new JavaSourceObjectTypeVisitor(file));
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedMatchExpression.java

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		Expression cValue = value.compileKey(scope);
+		Expression cValue = value.compile(scope).eval();
 		MatchExpression.Case[] cCases = new MatchExpression.Case[cases.size()];
 		for (int i = 0; i < cases.size(); i++) {
 			Case matchCase = cases.get(i);

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

  * @author Hoofdgebruiker
  */
 public class GlobalRegistry {
-	public final ZSPackage globals = new ZSPackage("");
-	private final ZSPackage rootPackage = new ZSPackage("");
+	public final ZSPackage globals = new ZSPackage(null, "");
+	private final ZSPackage rootPackage = new ZSPackage(null, "");
 	private final ZSPackage javaIo = rootPackage.getOrCreatePackage("java").getOrCreatePackage("io");
 	private final ZSPackage javaLang = rootPackage.getOrCreatePackage("java").getOrCreatePackage("lang");
 	

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

 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
-		ZSPackage pkg = new ZSPackage("");
+		ZSPackage pkg = new ZSPackage(null, "");
 		ParsedFile[] parsedFiles = parse(pkg, inputFiles);
 		
-		ZSPackage global = new ZSPackage("");
+		ZSPackage global = new ZSPackage(null, "");
 		GlobalRegistry registry = new GlobalRegistry(global);
 		SemanticModule module = compileSyntaxToSemantic(parsedFiles, registry);
 		
 	}
 	
 	private static SemanticModule compileSyntaxToSemantic(ParsedFile[] files, GlobalRegistry registry) {
-		ZSPackage modulePackage = new ZSPackage(null);
+		ZSPackage modulePackage = new ZSPackage(null, "");
 		
 		// We are considering all these files to be in the same package, so make
 		// a single PackageDefinition instance. If these files were in multiple
 		for (ScriptBlock script : module.scripts) {
 			compiler.addScriptBlock(script);
 		}
-		return compiler.finish();
+		return compiler.finishAndGetModule();
 	}
 }