Interpolation in BEPs

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

@@ -0,0 +1,124 @@
+/*
+ * 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.parser;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.parser.expression.ParsedExpressionBinary;
+import org.openzen.zenscript.parser.expression.ParsedExpressionString;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Hoofdgebruiker and kindlich
+ */
+public class EscapableBracketParser implements BracketExpressionParser {
+    private final FunctionalMemberRef method;
+    private final TypeID targetType;
+
+    public EscapableBracketParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
+        if (!method.isStatic())
+            throw new IllegalArgumentException("Method must be static");
+        if (method.getHeader().getNumberOfTypeParameters() > 0)
+            throw new IllegalArgumentException("Method cannot have type parameters");
+
+        this.method = method;
+        this.targetType = registry.getForDefinition(method.getTarget().definition);
+    }
+
+    @Override
+    public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) throws ParseException {
+        StringBuilder string = new StringBuilder();
+
+        //This list will contain the BEP calls
+        //If this is only a normal BEP, then it will contain exactly one String ParsedExpression.
+        final List<ParsedExpression> expressionList = new ArrayList<>();
+
+        while (tokens.optional(ZSTokenType.T_GREATER) == null) {
+            ZSToken next = tokens.next();
+
+            if (next.type != ZSTokenType.T_DOLLAR) {
+                string.append(next.content);
+                string.append(tokens.getLastWhitespace());
+                continue;
+            }
+
+            //We found a $, now check that it has a { directly after it.
+            final String ws = tokens.getLastWhitespace();
+            if (!ws.isEmpty()) {
+                //$  {..} is not ${..} so we print it as literal
+                string.append(next.content).append(ws);
+                continue;
+            }
+
+            next = tokens.next();
+            //Now we check if it is a {
+            if (next.type == ZSTokenType.T_AOPEN) {
+                if (string.length() != 0) {
+                    expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+                    string = new StringBuilder();
+                }
+                expressionList.add(ParsedExpression.parse(tokens));
+                tokens.required(ZSTokenType.T_ACLOSE, "} expected.");
+                string.append(tokens.getLastWhitespace());
+            } else {
+                //No { after the $, so we treat them both as literal
+                string.append("$").append(ws); //Technically, the whitespace here is empty, but let's be sure
+                string.append(next.content).append(tokens.getLastWhitespace());
+            }
+
+        }
+
+        if (string.length() != 0) {
+            expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+        }
+
+        return new StaticMethodCallExpression(position, expressionList);
+    }
+
+    private class StaticMethodCallExpression extends ParsedExpression {
+
+        private final ParsedExpression call;
+
+        public StaticMethodCallExpression(CodePosition position, List<ParsedExpression> expressions) {
+            super(position);
+            ParsedExpression p = null;
+            for (ParsedExpression expression : expressions) {
+                p = p == null ? expression : new ParsedExpressionBinary(expression.position, p, expression, OperatorType.ADD);
+            }
+
+            this.call = p;
+        }
+
+        @Override
+        public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+            final Expression methodCall = call.compile(scope.withHint(StringTypeID.AUTO)).eval();
+            final CallArguments arguments = new CallArguments(methodCall);
+            return new CallStaticExpression(position, targetType, method, method.getHeader(), arguments);
+        }
+
+        @Override
+        public boolean hasStrongType() {
+            return true;
+        }
+    }
+}

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

@@ -67,6 +67,10 @@ public class Globals implements ZenCodeGlobals {
 	public static TestClass bracket(String value) {
 		return new TestClass(value);
 	}
+
+	public static String staticToString(String value) {
+		return value;
+	}
 	
 	@FunctionalInterface
 	public static interface MyFunctionalInterface {

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

@@ -15,13 +15,15 @@ import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
+import org.openzen.zenscript.parser.EscapableBracketParser;
+import org.openzen.zenscript.parser.PrefixedBracketParser;
 import org.openzen.zenscript.parser.SimpleBracketParser;
 
 public class Main {
 	public static void main(String[] args) throws CompileException, ParseException, IOException, NoSuchMethodException {
 		ScriptingEngine scriptingEngine = new ScriptingEngine();
 		scriptingEngine.debug = true;
-		
+
 		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
 		example.addGlobals(Globals.class);
 		example.addClass(TestBaseInterface.class);
@@ -29,21 +31,25 @@ public class Main {
 		example.addClass(TestClass.class);
 		example.addClass(TestInterface.class);
 		scriptingEngine.registerNativeProvided(example);
-		
+
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		SourceFile[] sourceFiles = new SourceFile[inputFiles.length];
 		for (int i = 0; i < inputFiles.length; i++)
 			sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
-		
-		BracketExpressionParser bracketParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
+
+		final PrefixedBracketParser parser = new PrefixedBracketParser(null);
+		BracketExpressionParser testParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
+		parser.register("test", testParser);
+		BracketExpressionParser toStringParser = new EscapableBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("staticToString", String.class)));
+		parser.register("toString", toStringParser);
 		FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1).stored(), "args");
-		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, bracketParser, new FunctionParameter[] { parameter });
+		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, parser, new FunctionParameter[] { parameter });
 		if (!scripts.isValid())
 			return;
-		
+
 		scriptingEngine.registerCompiled(scripts);
-		
+
 		Map<FunctionParameter, Object> scriptArgs = new HashMap<>();
 		scriptArgs.put(parameter, new String[] { "hello", "world", "example" });
 		scriptingEngine.run(scriptArgs);