Added script parameter system. Also refactored SourceFile info, it's no longer a tag but available as field in ScriptBlock.

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zencode.shared.ConcatMap;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final SourceFile file;
 	public final Module module;
 	public final ZSPackage pkg;
+	public final FunctionHeader scriptHeader;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(Module module, ZSPackage pkg, List<Statement> statements) {
+	public ScriptBlock(SourceFile file, Module module, ZSPackage pkg, FunctionHeader scriptHeader, List<Statement> statements) {
+		this.file = file;
 		this.module = module;
 		this.pkg = pkg;
+		this.scriptHeader = scriptHeader;
 		this.statements = statements;
 	}
 	
 	public ScriptBlock withStatements(List<Statement> newStatements) {
-		ScriptBlock result = new ScriptBlock(module, pkg, newStatements);
+		ScriptBlock result = new ScriptBlock(file, module, pkg, scriptHeader, newStatements);
 		result.addAllTagsFrom(this);
 		return result;
 	}
 		for (Statement statement : statements) {
 			normalized.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
 		}
-		ScriptBlock result = new ScriptBlock(module, pkg, normalized);
+		ScriptBlock result = new ScriptBlock(file, module, pkg, scriptHeader, normalized);
 		result.addAllTagsFrom(this);
 		return result;
 	}

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

 	
 	public final String name;
 	public final SemanticModule[] dependencies;
+	public final FunctionParameter[] parameters;
 	
 	public final State state;
 	public final Module module;
 	public SemanticModule(
 			Module module,
 			SemanticModule[] dependencies,
+			FunctionParameter[] parameters,
 			State state,
 			ZSPackage rootPackage,
 			ZSPackage modulePackage,
 		this.name = module.name;
 		this.module = module;
 		this.dependencies = dependencies;
+		this.parameters = parameters;
 		
 		this.state = state;
 		this.rootPackage = rootPackage;
 		return new SemanticModule(
 				module,
 				dependencies,
+				parameters,
 				State.NORMALIZED,
 				rootPackage,
 				modulePackage,

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.java

 	@Override
 	public ScriptBlock process(ScriptBlock block) {
 		FileScope fileScope = new FileScope(context, expansions, new HashMap<>(), member -> {});
-		StatementScope scope = new GlobalScriptScope(fileScope);
+		StatementScope scope = new GlobalScriptScope(fileScope, block.scriptHeader);
 		List<Statement> transformed = new ArrayList<>();
 		boolean unchanged = true;
 		for (Statement statement : block.statements) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/GlobalScriptScope.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
  */
 public class GlobalScriptScope extends StatementScope {
 	private final BaseScope file;
+	private final FunctionHeader header;
 	
-	public GlobalScriptScope(BaseScope file) {
+	public GlobalScriptScope(BaseScope file, FunctionHeader scriptHeader) {
 		this.file = file;
+		header = scriptHeader;
 	}
 	
 	@Override
 		if (result != null)
 			return result;
 		
+		if (name.hasNoArguments()) {
+			for (FunctionParameter parameter : header.parameters) {
+				if (parameter.name.equals(name.name)) {
+					return new GetFunctionParameterExpression(position, parameter);
+				}
+			}
+		}
+		
 		return file.get(position, name);
 	}
 
 
 	@Override
 	public FunctionHeader getFunctionHeader() {
-		return null;
+		return header;
 	}
 
 	@Override

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

 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.SemanticModule;
 			CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 			
 			ParsedFile[] parsedFiles = parsedModule.parse(compilingPackage);
-			SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaMethod;
  */
 public class JavaBytecodeModule extends JavaCompiledModule {
 	private final Map<String, byte[]> classes = new HashMap<>();
-	private final List<JavaMethod> scripts = new ArrayList<>();
+	private final List<JavaScriptMethod> scripts = new ArrayList<>();
 	
-	public JavaBytecodeModule(Module module) {
-		super(module);
+	public JavaBytecodeModule(Module module, FunctionParameter[] parameters) {
+		super(module, parameters);
 	}
 	
 	public void addClass(String name, byte[] bytecode) {
 		classes.put(name, bytecode);
 	}
 	
-	public void addScript(JavaMethod method) {
+	public void addScript(JavaScriptMethod method) {
 		scripts.add(method);
 	}
 	
 		return classes;
 	}
 	
-	public List<JavaMethod> getScripts() {
+	public List<JavaScriptMethod> getScripts() {
 		return scripts;
 	}
 }

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

 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
  *
  */
 public class JavaBytecodeRunUnit {
 	private final Map<String, byte[]> classes = new HashMap<>();
-	private final List<JavaMethod> scripts = new ArrayList<>();
+	private final List<JavaScriptMethod> scripts = new ArrayList<>();
+	private final List<FunctionParameter> scriptParameters = new ArrayList<>();
+	private final List<JavaParameterInfo> scriptParameterInfo = new ArrayList<>();
 	
 	private boolean scriptsWritten = false;
 	
 		for (Map.Entry<String, byte[]> classEntry : module.getClasses().entrySet())
 			classes.put(classEntry.getKey().replace('/', '.'), classEntry.getValue());
 		
-		scripts.addAll(module.getScripts());
+		for (JavaScriptMethod script : module.getScripts()) {
+			scripts.add(script);
+			
+			for (int i = 0; i < script.parameters.length; i++) {
+				FunctionParameter parameter = script.parameters[i];
+				if (!scriptParameters.contains(parameter)) {
+					scriptParameters.add(parameter);
+					scriptParameterInfo.add(script.parametersInfo[i]);
+				}
+			}
+		}
 	}
 	
 	public void run() {
+		run(Collections.emptyMap());
+	}
+	
+	public void run(Map<FunctionParameter, Object> arguments) {
 		writeScripts();
 		
 		ScriptClassLoader classLoader = new ScriptClassLoader();
 
+		Object[] argumentsArray = new Object[scriptParameters.size()];
+		for (int i = 0; i < scriptParameters.size(); i++) {
+			FunctionParameter parameter = scriptParameters.get(i);
+			if (!arguments.containsKey(parameter))
+				throw new IllegalArgumentException("Missing script argument for parameter " + parameter.name);
+			
+			argumentsArray[i] = arguments.get(parameter);
+		}
 		try {
-			classLoader.loadClass("Scripts").getMethod("run").invoke(null);
+			Class[] classes = new Class[scriptParameters.size()];
+			for (int i = 0; i < classes.length; i++)
+				classes[i] = loadClass(classLoader, scriptParameterInfo.get(i).typeDescriptor);
+			classLoader.loadClass("Scripts").getMethod("run", classes).invoke(null, argumentsArray);
 		} catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
 			Logger.getLogger(JavaBytecodeRunUnit.class.getName()).log(Level.SEVERE, null, ex);
 		}
 		}
 	}
 	
+	private int getParameterIndex(FunctionParameter parameter) {
+		return scriptParameters.indexOf(parameter);
+	}
+	
 	private void writeScripts() {
 		if (scriptsWritten)
 			return;
 		JavaClassWriter scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 		
-		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		FunctionHeader header = new FunctionHeader(BasicTypeID.VOID, scriptParameters.toArray(new FunctionParameter[scriptParameters.size()]));
+		StringBuilder headerBuilder = new StringBuilder();
+		headerBuilder.append('(');
+		for (int i = 0; i < scriptParameters.size(); i++) {
+			headerBuilder.append(scriptParameterInfo.get(i).typeDescriptor);
+		}
+		headerBuilder.append(")V");
+		
+		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", headerBuilder.toString(), Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
-		for (JavaMethod method : scripts)
-			runWriter.invokeStatic(method);
+		for (JavaScriptMethod method : scripts) {
+			for (int i = 0; i < method.parameters.length; i++) {
+				runWriter.load(Type.getType(method.parametersInfo[i].typeDescriptor), getParameterIndex(method.parameters[i]));
+			}
+			runWriter.invokeStatic(method.method);
+		}
 		
 		runWriter.ret();
 		runWriter.end();
 			return super.loadClass(name);
 		}
 	}
+	
+	private static Class<?> loadClass(ClassLoader classLoader, String descriptor) throws ClassNotFoundException {
+		switch (descriptor) {
+			case "Z": return boolean.class;
+			case "B": return byte.class;
+			case "S": return short.class;
+			case "I": return int.class;
+			case "J": return long.class;
+			case "F": return float.class;
+			case "D": return double.class;
+			case "C": return char.class;
+			case "Ljava/lang/Object;": return Object.class;
+			case "Ljava/lang/String;": return String.class;
+			case "[Ljava/lang/Object;": return Object[].class;
+			case "[Ljava/lang/String;": return String[].class;
+		}
+		
+		return classLoader.loadClass(getClassName(descriptor));
+	}
+	
+	private static String getClassName(String descriptor) {
+		if (descriptor.startsWith("[")) {
+			return "[" + getClassName(descriptor.substring(1));
+		} else if (descriptor.startsWith("L")) {
+			return descriptor.substring(1, descriptor.length() - 1);
+		} else {
+			throw new IllegalArgumentException("Invalid descriptor: " + descriptor);
+		}
+	}
 }

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

 import org.objectweb.asm.Opcodes;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompileSpace;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 
 	public JavaBytecodeModule compile(String packageName, SemanticModule module, JavaCompileSpace space) {
 		Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
 		
-		JavaBytecodeModule target = new JavaBytecodeModule(module.module);
+		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters);
 		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName);
 		context.addModule(module.module, target);
 		
 			target.addClass(cls.internalName, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
 		}
 		
+		FunctionHeader scriptHeader = new FunctionHeader(BasicTypeID.VOID, module.parameters);
+		String scriptDescriptor = context.getMethodDescriptor(scriptHeader);
+		JavaParameterInfo[] javaScriptParameters = new JavaParameterInfo[module.parameters.length];
+		for (int i = 0; i < module.parameters.length; i++) {
+			FunctionParameter parameter = module.parameters[i];
+			JavaParameterInfo javaParameter = new JavaParameterInfo(i, context.getDescriptor(parameter.type));
+			target.setParameterInfo(parameter, javaParameter);
+			javaScriptParameters[i] = javaParameter;
+		}
+		
 		for (ScriptBlock script : module.scripts) {
-			final SourceFile sourceFile = script.getTag(SourceFile.class);
+			final SourceFile sourceFile = script.file;
 			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
 			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, script.pkg.fullName + "/" + className);
 
 			// convert scripts into methods (add them to a Scripts class?)
 			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 			final JavaClassWriter visitor = scriptFile.classWriter;
-			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
-			scriptFile.scriptMethods.add(method);
+			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), className, JavaClass.Kind.CLASS), methodName, scriptDescriptor, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+			scriptFile.scriptMethods.add(new JavaScriptMethod(method, module.parameters, javaScriptParameters));
 
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(CodePosition.UNKNOWN, visitor, method, null, null, null));
 			statementVisitor.start();
 		}
 		
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
-			for (JavaMethod method : entry.getValue().scriptMethods)
+			for (JavaScriptMethod method : entry.getValue().scriptMethods)
 				target.addScript(method);
 
 			entry.getValue().classWriter.visitEnd();
 	}
 	
 	private String getFilename(HighLevelDefinition definition) {
-		SourceFile source = definition.getTag(SourceFile.class);
+		SourceFile source = definition.position.file;
 		if (source != null) {
 			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
 			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);

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

 		}
 
 		for (Expression argument : expression.arguments.arguments) {
-			argument.accept(this);
+			argument.accept(original);
 		}
 		String internalName = context.getInternalName(expression.objectType);
 		javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.cls.isEnum()

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

 
 import java.util.ArrayList;
 import java.util.List;
-import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javabytecode.JavaScriptMethod;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaScriptFile {
 	public final JavaClassWriter classWriter;
-	public final List<JavaMethod> scriptMethods;
+	public final List<JavaScriptMethod> scriptMethods;
 
 	public JavaScriptFile(JavaClassWriter classWriter) {
 		this.classWriter = classWriter;

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

 		}
 		
 		this.allowNonAnnonated = allowNonAnnotated;
-		compiled = new JavaCompiledModule(module);
+		compiled = new JavaCompiledModule(module, FunctionParameter.NONE);
 		
 		typeByClass.put(void.class, BasicTypeID.VOID);
 		typeByClass.put(boolean.class, BasicTypeID.BOOL);
 		return new SemanticModule(
 				module,
 				SemanticModule.NONE,
+				FunctionParameter.NONE,
 				SemanticModule.State.NORMALIZED,
 				space.rootPackage,
 				pkg,

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

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.SemanticModule;
 		
 		try {
 			ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.zip"));
-			SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], stdlib);
+			SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], FunctionParameter.NONE, stdlib);
 			stdlibModule = Validator.validate(stdlibModule, error -> System.out.println(error.toString()));
 			space.addModule("stdlib", stdlibModule);
 		} catch (IOException ex) {
 	}
 	
 	public SemanticModule createScriptedModule(String name, SourceFile[] sources, String... dependencies) throws ParseException {
-		return createScriptedModule(name, sources, null, dependencies);
+		return createScriptedModule(name, sources, null, FunctionParameter.NONE, dependencies);
 	}
 	
-	public SemanticModule createScriptedModule(String name, SourceFile[] sources, BracketExpressionParser bracketParser, String... dependencies) throws ParseException {
+	public SemanticModule createScriptedModule(
+			String name,
+			SourceFile[] sources,
+			BracketExpressionParser bracketParser,
+			FunctionParameter[] scriptParameters,
+			String... dependencies) throws ParseException
+	{
 		Module scriptModule = new Module(name);
 		CompilingPackage scriptPackage = new CompilingPackage(new ZSPackage(space.rootPackage, name), scriptModule);
 		
 				scriptPackage,
 				files,
 				space,
+				scriptParameters,
 				ex -> ex.printStackTrace());
 		if (!scripts.isValid())
 			return scripts;
 	}
 	
 	public void run() {
+		run(Collections.emptyMap());
+	}
+	
+	public void run(Map<FunctionParameter, Object> arguments) {
 		SimpleJavaCompileSpace javaSpace = new SimpleJavaCompileSpace(registry);
 		for (JavaNativeModule nativeModule : nativeModules)
 			javaSpace.register(nativeModule.getCompiled());
 			runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
 		if (debug)
 			runUnit.dump(new File("classes"));
-		runUnit.run();
+		runUnit.run(arguments);
 	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaCompiledModule.java

  */
 public class JavaCompiledModule {
 	public final Module module;
+	public final FunctionParameter[] scriptParameters;
 	
 	private final Map<HighLevelDefinition, JavaClass> classes = new HashMap<>();
 	private final Map<HighLevelDefinition, JavaClass> expansionClasses = new HashMap<>();
 	private final Map<FunctionParameter, JavaParameterInfo> parameters = new HashMap<>();
 	private final Map<VariantDefinition.Option, JavaVariantOption> variantOptions = new HashMap<>();
 	
-	public JavaCompiledModule(Module module) {
+	public JavaCompiledModule(Module module, FunctionParameter[] scriptParameters) {
 		this.module = module;
+		this.scriptParameters = scriptParameters;
 	}
 	
 	public void loadMappings(String mappings) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaMemberCompiler.java

 import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaClass;
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
+		if (member.body == null)
+			return null; // happens with default constructors
+		
 		begin(ElementType.CONSTRUCTOR);
 		
 		output.append(indent);

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.java

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 	public final JavaSourceModule helpers;
 	
 	public JavaSourceCompiler(GlobalTypeRegistry registry) {
-		helpers = new JavaSourceModule(new Module("helpers"));
+		helpers = new JavaSourceModule(new Module("helpers"), FunctionParameter.NONE);
 		settings = new JavaSourceFormattingSettings.Builder().build();
 	}
 	
 	public JavaSourceModule compile(SemanticModule module, JavaCompileSpace space, String basePackage) {
 		JavaSourceContext context = new JavaSourceContext(helpers, settings, space, module.modulePackage, basePackage);
 		
-		JavaSourceModule result = new JavaSourceModule(module.module);
+		JavaSourceModule result = new JavaSourceModule(module.module, module.parameters);
 		context.addModule(module.module, result);
 		
 		Map<String, JavaSourceFile> sourceFiles = new HashMap<>();
 	}
 	
 	private String getFilename(HighLevelDefinition definition) {
-		SourceFile source = definition.getTag(SourceFile.class);
+		SourceFile source = definition.position.file;
 		if (source != null) {
 			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
 			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceModule.java

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 
 public class JavaSourceModule extends JavaCompiledModule {
 	public final List<SourceFile> sourceFiles = new ArrayList<>();
 	
-	public JavaSourceModule(Module module) {
-		super(module);
+	public JavaSourceModule(Module module, FunctionParameter[] parameters) {
+		super(module, parameters);
 	}
 	
 	public void addFile(String filename, String content) {

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.scope.GlobalScriptScope;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.statements.ParsedStatement;
 
 			CompilingPackage pkg,
 			ParsedFile[] files,
 			ModuleSpace registry,
+			FunctionParameter[] parameters,
 			Consumer<CompileException> exceptionLogger) {
 		// We are considering all these files to be in the same package, so make
 		// a single PackageDefinition instance. If these files were in multiple
 		}
 		
 		if (failed)
-			return new SemanticModule(pkg.module, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.registry, expansions, registry.getAnnotations(), registry.getStorageTypes());
+			return new SemanticModule(pkg.module, dependencies, parameters, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.registry, expansions, registry.getAnnotations(), registry.getStorageTypes());
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 		}
 		
 		List<ScriptBlock> scripts = new ArrayList<>();
+		FunctionHeader scriptHeader = new FunctionHeader(BasicTypeID.VOID, parameters);
 		for (ParsedFile file : files) {
 			// compileCode will convert the parsed statements and expressions
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
-			file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals, exceptionLogger);
+			file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals, scriptHeader, exceptionLogger);
 		}
 		
 		return new SemanticModule(
 				pkg.module,
 				dependencies,
+				parameters,
 				SemanticModule.State.ASSEMBLED,
 				rootPackage,
 				pkg.getPackage(),
 					result.statements.add(ParsedStatement.parse(tokens, annotations));
 				} else {
 					result.definitions.add(definition);
-					definition.getCompiled().setTag(SourceFile.class, tokens.getFile());
 				}
 			}
 		}
 			List<ExpansionDefinition> expansions,
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globals,
+			FunctionHeader scriptHeader,
 			Consumer<CompileException> exceptionLogger) {
 		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		}
 		
 		if (!statements.isEmpty() || postComment != null) {
-			StatementScope statementScope = new GlobalScriptScope(scope);
+			StatementScope statementScope = new GlobalScriptScope(scope, scriptHeader);
 			List<Statement> statements = new ArrayList<>();
 			for (ParsedStatement statement : this.statements) {
 				statements.add(statement.compile(statementScope));
 			}
 			
-			ScriptBlock block = new ScriptBlock(modulePackage.module, modulePackage.getPackage(), statements);
-			block.setTag(SourceFile.class, file);
+			ScriptBlock block = new ScriptBlock(file, modulePackage.module, modulePackage.getPackage(), scriptHeader, statements);
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);
 		}

Parser/src/main/java/org/openzen/zenscript/parser/ZippedPackage.java

 import java.util.zip.ZipInputStream;
 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.SemanticModule;
 		}
 	}
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies) throws ParseException {
-		return loadModule(space, name, bracketParser, dependencies, new ZSPackage(space.rootPackage, name));
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters) throws ParseException {
+		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name));
 	}
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, ZSPackage pkg) throws ParseException {
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg) throws ParseException {
 		List<SourceFile> sourceFiles = files.get(name);
 		if (sourceFiles == null)
 			return null; // no such module
 				scriptPackage,
 				files,
 				space,
+				scriptParameters,
 				ex -> ex.printStackTrace());
 		return scripts.normalize();
 	}

ScriptingExample/scripts/scriptparameters.zs

+println("Arguments:");
+for i, arg in args
+	println("- " + i + ": " + arg);

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

 
 import java.io.File;
 import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 import org.openzen.zencode.java.JavaNativeModule;
 import org.openzen.zencode.java.ScriptingEngine;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 		for (int i = 0; i < inputFiles.length; i++)
 			sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
 		
-		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, new TestBracketParser());
+		FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1).stored(), "args");
+		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, new TestBracketParser(), new FunctionParameter[] { parameter });
 		if (!scripts.isValid())
 			return;
 		
 		scriptingEngine.registerCompiled(scripts);
-		scriptingEngine.run();
+		
+		Map<FunctionParameter, Object> scriptArgs = new HashMap<>();
+		scriptArgs.put(parameter, new String[] { "hello", "world", "example" });
+		scriptingEngine.run(scriptArgs);
 	}
 	
 	private static class TestBracketParser implements BracketExpressionParser {

Shared/src/main/java/org/openzen/zencode/shared/SourceFile.java

 import java.io.IOException;
 import java.io.Reader;
 
-public interface SourceFile extends Tag {
+public interface SourceFile {
     String getFilename();
     
     Reader open() throws IOException;

Validator/src/main/java/org/openzen/zenscript/validator/Validator.java

 		return new SemanticModule(
 				module.module,
 				module.dependencies,
+				module.parameters,
 				state,
 				module.rootPackage,
 				module.modulePackage,