Added main specialized in testing the Java Bytecode implementation.

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

  */
 public class SemanticModule {
 	public final String name;
-	public final String[] dependencies;
+	public final SemanticModule[] dependencies;
 	
 	private State state;
 	public final ZSPackage rootPackage;
 	
 	public SemanticModule(
 			String name,
-			String[] dependencies,
+			SemanticModule[] dependencies,
 			State state,
 			ZSPackage rootPackage,
 			ZSPackage modulePackage,

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

 	
 	public static SemanticModule compileSyntaxToSemantic(
 			String name,
-			String[] dependencies,
+			SemanticModule[] dependencies,
 			CompilingPackage pkg,
 			ParsedFile[] files,
 			ModuleSpace registry,

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

 
 			// TODO: annotation type registration
 			ModuleSpace space = new ModuleSpace(unit, new ArrayList<>());
-			for (String dependencyName : dependencyNames)
-				space.addModule(dependencyName, loader.getModule(dependencyName));
+			SemanticModule[] dependencies = new SemanticModule[dependencyNames.size()];
+			for (int i = 0; i < dependencies.length; i++) {
+				String dependencyName = dependencyNames.get(i);
+				SemanticModule module = loader.getModule(dependencyName);
+				dependencies[i] = module;
+				space.addModule(dependencyName, module);
+			}
 
 			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
 			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
 			CompilingPackage compilingPackage = new CompilingPackage(pkg);
 			
 			ParsedFile[] parsedFiles = module.parse(compilingPackage);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			SemanticModule result = Module.compileSyntaxToSemantic(module.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

IDE/src/main/java/org/openzen/zenscript/ide/JavaBytecodeMain.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;
+
+import java.io.File;
+import java.io.IOException;
+import org.openzen.zenscript.constructor.Project;
+import static org.openzen.zenscript.ide.Main.open;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeMain {
+	/**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) throws IOException {
+		Arguments arguments = new Arguments(args);
+		File directory = arguments.projectDirectory;
+		
+		Project project = new Project(directory);
+		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
+		open(host, "SharedJavaBytecode");
+    }
+}

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

 		
 		Project project = new Project(directory);
 		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
-		open(host);
+		open(host, "SharedJavaSource");
     }
 	
-	private static void open(DevelopmentHost host) {
+	public static void open(DevelopmentHost host, String target) {
 		IDEPropertyStore properties = host.getPropertyStore();
 		
-		IDEWindow window = new IDEWindow(host);
+		IDEWindow window = new IDEWindow(host, target);
 		WindowView root = new WindowView(window, host);
 		
 		IDEPropertyDirectory uiState = properties.getRoot().getSubdirectory("uiState");

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

 	}
 	
 	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, Stack<String> compilingModules, SemanticModule module, Consumer<ValidationLogEntry> logger) {
-		for (String dependency : module.dependencies) {
-			if (compiledModules.contains(dependency))
+		for (SemanticModule dependency : module.dependencies) {
+			if (compiledModules.contains(dependency.name))
 				continue;
-			compiledModules.add(dependency);
+			compiledModules.add(dependency.name);
 			System.out.println("== Compiling module " + dependency + " ==");
 			
-			if (compilingModules.contains(dependency)) {
+			if (compilingModules.contains(dependency.name)) {
 				StringBuilder message = new StringBuilder("Circular dependency:\n");
 				for (String s : compilingModules)
 					message.append("    ").append(s).append("\n");
 				
 				throw new IllegalStateException(message.toString());
 			}
-			compilingModules.push(dependency);
+			compilingModules.push(dependency.name);
 			
-			SemanticModule dependencyModule = loader.getModule(dependency);
-			if (!dependencyModule.isValid()) {
+			if (!dependency.isValid()) {
 				compilingModules.pop();
 				return false;
 			}
 			
-			dependencyModule = dependencyModule.normalize();
-			dependencyModule.validate(logger);
-			if (!dependencyModule.isValid()) {
+			dependency = dependency.normalize();
+			dependency.validate(logger);
+			if (!dependency.isValid()) {
 				compilingModules.pop();
 				return false;
 			}
 			
-			if (!compileDependencies(loader, compiler, compiledModules, compilingModules, dependencyModule, logger)) {
+			if (!compileDependencies(loader, compiler, compiledModules, compilingModules, dependency, logger)) {
 				compilingModules.pop();
 				return false;
 			}
 			
-			dependencyModule.compile(compiler);
+			dependency.compile(compiler);
 			compilingModules.pop();
 		}
 		

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

  */
 public class IDEWindow {
 	private final DevelopmentHost host;
+	private final String target;
 	
 	public final IDEAspectBar aspectBar;
 	public final IDEDockWindow dockWindow;
 	
 	public IDEAspectToolbar projectToolbar;
 	
-	public IDEWindow(DevelopmentHost host) {
+	public IDEWindow(DevelopmentHost host, String target) {
 		this.host = host;
+		this.target = target;
 		
 		aspectBar = new IDEAspectBar();
 		dockWindow = new IDEDockWindow();
 		init();
 	}
 	
-	public IDEWindow(DevelopmentHost host, IDEAspectBar aspectBar, IDEDockWindow dockWindow, IDEStatusBar statusBar) {
+	public IDEWindow(DevelopmentHost host, IDEAspectBar aspectBar, IDEDockWindow dockWindow, IDEStatusBar statusBar, String target) {
 		this.host = host;
+		this.target = target;
 		
 		this.aspectBar = aspectBar;
 		this.dockWindow = dockWindow;
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, new ImmutableLiveString("Build"), e -> {
 			output.clear();
 			for (IDETarget target : host.getTargets()) {
-				if (target.canBuild())
+				if (target.getName().equals(this.target) && target.canBuild())
 					target.build(line -> output.add(line));
 			}
 		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, PlayIcon.GREEN, new ImmutableLiveString("Run"), e -> {
 			for (IDETarget target : host.getTargets()) {
-				if (target.canRun())
+				if (target.getName().equals(this.target) && target.canRun())
 					target.run(line -> output.add(line));
 			}
 		}));

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import java.io.File;
 import org.json.JSONObject;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.Target;
 public class JavaBytecodeJarTarget implements Target {
 	private final String module;
 	private final String name;
+	private final File file;
 	private final boolean debugCompiler;
 	
 	public JavaBytecodeJarTarget(JSONObject definition) {
 		module = definition.getString("module");
-		name = definition.optString("name", "Java Bytecode: " + module);
+		name = definition.getString("name");
+		file = new File(definition.getString("output"));
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
 	
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(debugCompiler);
+		return new JavaCompiler(debugCompiler, file);
 	}
 
 	@Override

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

 	
 	public JavaBytecodeRunTarget(JSONObject definition) {
 		module = definition.getString("module");
-		name = definition.optString("name", "Java Run: " + module);
+		name = definition.getString("name");
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
 	
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(debugCompiler);
+		return new JavaCompiler(debugCompiler, null);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
 	private JavaModule compiled = null;
+	private final File jarFile;
 	
-	public JavaCompiler() {
-		this(false);
+	public JavaCompiler(File jarFile) {
+		this(false, jarFile);
 	}
 	
-	public JavaCompiler(boolean debug) {
+	public JavaCompiler(boolean debug, File jarFile) {
 		target = new JavaModule();
+		this.jarFile = jarFile;
 		
 		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	
 	@Override
 	public void finish() {
-		finishAndGetModule();
+		JavaModule module = finishAndGetModule();
+		
+		if (jarFile != null) {
+			// TODO: write module to a Jar file
+		}
 	}
 	
 	@Override
 		if (compiled == null)
 			throw new IllegalStateException("Not yet built!");
 		
-		
+		// TODO: execute this
 	}
 	
 	public JavaModule finishAndGetModule() {

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

 		
 		ZSPackage pkg = new ZSPackage(null, "");
 		CompilingPackage compilingPkg = new CompilingPackage(pkg);
-		ParsedFile[] parsedFiles = parse(pkg, compilingPkg, inputFiles);
+		ParsedFile[] parsedFiles = parse(compilingPkg, inputFiles);
 		
 		ZSPackage global = new ZSPackage(null, "");
 		GlobalRegistry registry = new GlobalRegistry(global);
-		SemanticModule module = compileSyntaxToSemantic(pkg, compilingPkg, parsedFiles, registry);
+		SemanticModule module = compileSyntaxToSemantic(compilingPkg, parsedFiles, registry);
 		
 		//formatFiles(pkg, module);
 		
 		}
     }
 	
-	private static ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPkg, File[] files) throws IOException {
+	private static ParsedFile[] parse(CompilingPackage compilingPkg, File[] files) throws IOException {
 		ParsedFile[] parsedFiles = new ParsedFile[files.length];
 		for (int i = 0; i < files.length; i++) {
 			parsedFiles[i] = ParsedFile.parse(compilingPkg, new TestBracketParser(), files[i]);
 		}
 	}
 	
-	private static SemanticModule compileSyntaxToSemantic(ZSPackage pkg, CompilingPackage compiling, ParsedFile[] files, GlobalRegistry registry) {
+	private static SemanticModule compileSyntaxToSemantic(CompilingPackage compiling, ParsedFile[] files, GlobalRegistry registry) {
 		ModuleSpace space = new ModuleSpace(new CompilationUnit(), new ArrayList<>());
 		for (Map.Entry<String, ISymbol> global : registry.collectGlobals().entrySet()) {
 			space.addGlobal(global.getKey(), global.getValue());
 		}
 		SemanticModule result = Module.compileSyntaxToSemantic(
 				"scripts",
-				new String[0],
+				new SemanticModule[0],
 				compiling,
 				files,
 				space,