Functions in Java

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

 			scriptBlocks.put(methodName, scriptFileWriter);
 		}
 
-		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptBlocks.get(definition.position.filename))));
+		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptBlocks.get(methodName))));
 
 	}
 	

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

+package org.openzen.zenscript.javabytecode;
+
+public class TestIsStaticInfo {
+    public final boolean isStatic;
+
+    public TestIsStaticInfo(boolean isStatic) {
+        this.isStatic = isStatic;
+    }
+}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 public class CompilerUtils {
     public static String calcDesc(FunctionHeader header, boolean isEnum) {
         StringBuilder descBuilder = new StringBuilder("(");
-        if(isEnum)
+        if (isEnum)
             descBuilder.append("Ljava/lang/String;I");
         for (FunctionParameter parameter : header.parameters) {
             descBuilder.append(Type.getDescriptor(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
     }
 
     public static boolean isPrimitive(ITypeID id) {
-        if(id instanceof BasicTypeID) {
+        if (id instanceof BasicTypeID) {
             switch ((BasicTypeID) id) {
                 case BOOL:
                 case BYTE:
         }
         return false;
     }
+
+    public static int calcAccess(int modifiers) {
+        int out = 0;
+        if (Modifiers.isStatic(modifiers))
+            out |= Opcodes.ACC_STATIC;
+        if (Modifiers.isFinal(modifiers))
+            out |= Opcodes.ACC_FINAL;
+        if (Modifiers.isPublic(modifiers))
+            out |= Opcodes.ACC_PUBLIC;
+        if (Modifiers.isPrivate(modifiers))
+            out |= Opcodes.ACC_PRIVATE;
+        if (Modifiers.isProtected(modifiers))
+            out |= Opcodes.ACC_PROTECTED;
+        if (Modifiers.isAbstract(modifiers))
+            out |= Opcodes.ACC_ABSTRACT;
+        return out;
+    }
+
+    public static String calcClasName(CodePosition position) {
+        return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
+    }
 }

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

 
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), expression.parameter.index + 1);
+        //TODO is Static?
+        final boolean isStatic = false;
+        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), isStatic ? expression.parameter.index : expression.parameter.index + 1);
         return null;
     }
 

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

 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaEnumInfo;
-import org.openzen.zenscript.javabytecode.compiler.JavaExpressionVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaTypeClassVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.TestIsStaticInfo;
+import org.openzen.zenscript.javabytecode.compiler.*;
+
+import java.util.Iterator;
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 
 
-    private final ClassWriter outerWriter;
+    private final JavaClassWriter outerWriter;
 
-    public JavaDefinitionVisitor(ClassWriter outerWriter) {
+    public JavaDefinitionVisitor(JavaClassWriter outerWriter) {
 
         this.outerWriter = outerWriter;
     }
         else
             superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
 
-        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         //TODO: Interfaces?
         clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
 
         for (IDefinitionMember member : definition.members) {
-            if(!(member instanceof EnumConstantMember)) continue;
+            if (!(member instanceof EnumConstantMember)) continue;
             final EnumConstantMember constantMember = (EnumConstantMember) member;
             clinitWriter.dup();
             clinitWriter.constant(constantMember.value);
 
     @Override
     public byte[] visitFunction(FunctionDefinition definition) {
+        final String signature = CompilerUtils.calcSign(definition.header, false);
+        final JavaWriter writer = new JavaWriter(outerWriter, true, CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC, definition.name, CompilerUtils.calcDesc(definition.header, false), signature, null);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
+        statementVisitor.start();
+        final Iterator<Statement> statementIterator = definition.statements.iterator();
+
+        //TODO this is dirty, fix when there is a way of knowing if a parameter is static or not
+        for (FunctionParameter parameter : definition.header.parameters) {
+            parameter.index -= 1;
+        }
+        while (statementIterator.hasNext()) {
+            final Statement statement = statementIterator.next();
+            statement.accept(statementVisitor);
+            if (!statementIterator.hasNext() && !(statement instanceof ReturnStatement)) {
+                ITypeID type = definition.header.returnType;
+                if (CompilerUtils.isPrimitive(type))
+                    writer.iConst0();
+                else if (type != BasicTypeID.VOID)
+                    writer.aConstNull();
+                writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
+            }
+
+        }
+
+        statementVisitor.end();
+
+        final JavaMethodInfo methodInfo = new JavaMethodInfo(new JavaClassInfo(CompilerUtils.calcClasName(definition.position)), definition.name, signature, true);
+
+        definition.setTag(JavaMethodInfo.class, methodInfo);
+        definition.caller.setTag(JavaMethodInfo.class, methodInfo);
         return null;
     }
 

ScriptingExample/scripts/functions.zs

+function test() {
+	println("functions.zs; test1");
+}
+
+
+
+function test2() as void {
+	println("functions.zs; test2");
+}
+
+
+test();
+test2();
+println(test3(1, 3));
+
+
+function test3(a as int, b as int) as int{
+	println(a+b);
+	return a + b;
+}