Made Helloworld possible

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/GetterMember.java

@@ -33,7 +33,7 @@ public class GetterMember extends FunctionalMember implements IGettableMember {
 		this.name = name;
 		this.type = type;
 	}
-	
+
 	@Override
 	public String getName() {
 		return name;

ScriptingExample/build.gradle

@@ -14,5 +14,6 @@ if (!hasProperty('mainClass')) {
 }
 
 dependencies {
+	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
 	compile project(':Parser')
 }

ScriptingExample/scripts/moreHellos.zs

@@ -0,0 +1,5 @@
+println("Hello world!");
+println("Hello world!");
+println("Hello world!");
+println("Hello world!");
+println("Hello world!");

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

@@ -66,7 +66,7 @@ public class GlobalRegistry {
 		return globals;
 	}
 	
-	private static final ClassDefinition printStream = new ClassDefinition("PrintStream", Modifiers.MODIFIER_EXPORT, null);
+	private static final ClassDefinition printStream = new ClassDefinition("Ljava/io/PrintStream;", Modifiers.MODIFIER_EXPORT, null);
 	private static final NativeMethodMember printStreamPrintln = new NativeMethodMember(
 			Modifiers.MODIFIER_EXPORT,
 			"println",

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

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.scriptingexample;
 
+import java.io.*;
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
@@ -24,6 +25,11 @@ public class JavaModule {
 	
 	public void register(String classname, byte[] bytecode) {
 		classes.put(classname, bytecode);
+		try(FileOutputStream writer = new FileOutputStream(new File(classname + ".class"))) {
+			writer.write(bytecode);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
 	}
 	
 	public void execute() {
@@ -47,6 +53,18 @@ public class JavaModule {
 	}
 	
 	private class ScriptClassLoader extends ClassLoader {
-		
+		final Map<String, Class> customClasses = new HashMap<>();
+
+		@Override
+		public Class<?> loadClass(String name) throws ClassNotFoundException {
+			if(customClasses.containsKey(name))
+				return customClasses.get(name);
+			if(classes.containsKey(name)) {
+				final byte[] bytes = classes.get(name);
+				customClasses.put(name, defineClass(name, bytes, 0, bytes.length, null));
+				return customClasses.get(name);
+			}
+			return super.loadClass(name);
+		}
 	}
 }

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

@@ -5,22 +5,31 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.StatementVisitor;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.scriptingexample.writer.JavaStatementVisitor;
+import org.openzen.zenscript.scriptingexample.writer.JavaWriter;
 
 public class Main {
     /**
      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
+		System.out.println();
 		File inputDirectory = new File("scripts");
-		File[] inputFiles = inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"));
+		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
 		ParsedFile[] parsedFiles = parse(inputFiles);
 		
@@ -77,19 +86,41 @@ public class Main {
 	
 	private static JavaModule compileSemanticToJava(SemanticModule module) {
 		JavaModule result = new JavaModule();
-		
+		final ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
+
 		// TODO: java bytecode compilation
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			// convert definitions into java classes
+
 		}
-		
+		int statementNo = 0;
 		for (ScriptBlock script : module.scripts) {
 			// 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 JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(classWriter, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, makeName(statementNo++), "()V", null, null));
+			statementVisitor.start();
+			for (Statement statement : script.statements) {
+				statement.accept(statementVisitor);
+			}
+			statementVisitor.end();
 		}
-		
+
 		// create a Scripts.run() method to run all scripts compiled above
+		final JavaWriter runWriter = new JavaWriter(classWriter, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null);
+		runWriter.start();
+		for (int i = 0; i < statementNo; i++) {
+			runWriter.invokeStatic("Scripts", makeName(i), "()V");
+		}
+		runWriter.ret();
+		runWriter.end();
+		result.register("Scripts", classWriter.toByteArray());
+
 		
 		return result;
 	}
+
+	private static String makeName(int i) {
+    	return "scriptBlock" + i;
+	}
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/writer/JavaExpressionVisitor.java

@@ -0,0 +1,320 @@
+package org.openzen.zenscript.scriptingexample.writer;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.scriptingexample.NativeFieldMember;
+import org.openzen.zenscript.scriptingexample.NativeMethodMember;
+
+public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
+
+    private final JavaWriter javaWriter;
+
+    public JavaExpressionVisitor(final JavaWriter javaWriter) {
+        this.javaWriter = javaWriter;
+    }
+
+    @Override
+    public Void visitAndAnd(AndAndExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitArray(ArrayExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCompare(BasicCompareExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCall(CallExpression expression) {
+
+        expression.target.accept(this);
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        if (expression.member instanceof NativeMethodMember) {
+            javaWriter.invokeVirtual(((NativeMethodMember) expression.member).className.replaceFirst("L", "").replace(";", ""), ((NativeMethodMember) expression.member).name, ((NativeMethodMember) expression.member).signature);
+        }
+        return null;
+    }
+
+    @Override
+    public Void visitCallStatic(CallStaticExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCapturedClosure(CapturedClosureExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCapturedDirect(CapturedDirectExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCapturedParameter(CapturedParameterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCapturedThis(CapturedThisExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCheckNull(CheckNullExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitCoalesce(CoalesceExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitConditional(ConditionalExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitConstantBool(ConstantBoolExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantByte(ConstantByteExpression expression) {
+        javaWriter.biPush(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantChar(ConstantCharExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantDouble(ConstantDoubleExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantFloat(ConstantFloatExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantInt(ConstantIntExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantLong(ConstantLongExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantSByte(ConstantSByteExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantShort(ConstantShortExpression expression) {
+        javaWriter.siPush(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantString(ConstantStringExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantUInt(ConstantUIntExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantULong(ConstantULongExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstantUShort(ConstantUShortExpression expression) {
+        javaWriter.constant(expression.value);
+        return null;
+    }
+
+    @Override
+    public Void visitConstructorCall(ConstructorCallExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitEnumConstant(EnumConstantExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitEquals(EqualsExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitFunction(FunctionExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitGenericCompare(GenericCompareExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitGetField(GetFieldExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitGetStaticField(GetStaticFieldExpression expression) {
+
+        if (expression.field instanceof NativeFieldMember)
+
+            javaWriter.getStaticField(((NativeFieldMember) expression.field).className, expression.field.name, Type.getType(expression.type.accept(new JavaTypeVisitor())).getDescriptor());
+        return null;
+    }
+
+    @Override
+    public Void visitGetter(GetterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitInterfaceCast(InterfaceCastExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitIs(IsExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitMakeConst(MakeConstExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitMap(MapExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitNew(NewExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitNot(NotExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitNull(NullExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitOrOr(OrOrExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitRange(RangeExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetField(SetFieldExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetStaticField(SetStaticFieldExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetter(SetterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitStaticGetter(StaticGetterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitStaticSetter(StaticSetterExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitStringConcat(StringConcatExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitSubstring(SubstringExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitThis(ThisExpression expression) {
+        return null;
+    }
+
+    @Override
+    public Void visitWrapOptional(WrapOptionalExpression expression) {
+        return null;
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/writer/JavaStatementVisitor.java

@@ -0,0 +1,92 @@
+package org.openzen.zenscript.scriptingexample.writer;
+
+import org.openzen.zenscript.codemodel.statement.*;
+
+public class JavaStatementVisitor implements StatementVisitor<Void> {
+    private final JavaWriter javaWriter;
+
+    public JavaStatementVisitor(final JavaWriter javaWriter) {
+
+        this.javaWriter = javaWriter;
+    }
+
+    @Override
+    public Void visitBlock(BlockStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitBreak(BreakStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitContinue(ContinueStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitDoWhile(DoWhileStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitEmpty(EmptyStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitExpression(ExpressionStatement statement) {
+        statement.expression.accept(new JavaExpressionVisitor(javaWriter));
+        return null;
+    }
+
+    @Override
+    public Void visitForeach(ForeachStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitIf(IfStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitLock(LockStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitReturn(ReturnStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitThrow(ThrowStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitTryCatch(TryCatchStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitVar(VarStatement statement) {
+        return null;
+    }
+
+    @Override
+    public Void visitWhile(WhileStatement statement) {
+        return null;
+    }
+
+    public void start() {
+        javaWriter.start();
+    }
+
+    public void end() {
+        javaWriter.ret();
+        javaWriter.end();
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/writer/JavaTypeVisitor.java

@@ -0,0 +1,86 @@
+package org.openzen.zenscript.scriptingexample.writer;
+
+import org.openzen.zenscript.codemodel.type.*;
+
+public class JavaTypeVisitor implements ITypeVisitor<String> {
+    @Override
+    public String visitBasic(BasicTypeID basic) {
+        switch (basic) {
+            case VOID:
+                return "V";
+            case NULL:
+            case ANY:
+            case UNDETERMINED:
+                return "Ljava/lang/Object;";
+            case BOOL:
+                return "Z";
+            case BYTE:
+            case SBYTE:
+                return "B";
+            case SHORT:
+            case USHORT:
+                return "S";
+            case INT:
+            case UINT:
+                return "I";
+            case LONG:
+            case ULONG:
+                return "J";
+            case FLOAT:
+                return "F";
+            case DOUBLE:
+                return "D";
+            case CHAR:
+                return "C";
+            case STRING:
+                return "Ljava/lang/String;";
+        }
+        return "";
+    }
+
+    @Override
+    public String visitArray(ArrayTypeID array) {
+        return "[" + array.elementType.accept(this);
+    }
+
+    @Override
+    public String visitAssoc(AssocTypeID assoc) {
+        return "Ljava/util/Map;";
+    }
+
+    @Override
+    public String visitIterator(IteratorTypeID iterator) {
+        return "java/lang/Iterable";
+    }
+
+    @Override
+    public String visitFunction(FunctionTypeID function) {
+        return null;
+    }
+
+    @Override
+    public String visitDefinition(DefinitionTypeID definition) {
+
+        return definition.definition.name.replaceAll("\"", "");
+    }
+
+    @Override
+    public String visitGeneric(GenericTypeID generic) {
+        return null;
+    }
+
+    @Override
+    public String visitRange(RangeTypeID range) {
+        return null;
+    }
+
+    @Override
+    public String visitConst(ConstTypeID type) {
+        return null;
+    }
+
+    @Override
+    public String visitOptional(OptionalTypeID optional) {
+        return null;
+    }
+}