Allow value export of unsafe code by passing variable names to the native code (#70)

Author: monstermichl

README.md

@@ -418,19 +418,27 @@ panic(err)
 ```
 
 ### ⚠️ Unsafe
-It's possible to add native code directly to the output by using the *unsafe*-builtin. However, this should be avoided if possible as it can introduce unwanted side-effects. The builtin's first argument must be a string literal which contains the executable code. All other arguments can be of type *bool*, *int* or *string*. The transpiler parses the string literal and replaces all placeholders (e.g. {0}) with the corresponding positional argument. Then the code is added to the output. E.g.
+It's possible to add native code directly to the output by using the *unsafe*-builtin. However, this should be avoided if possible as it can introduce unwanted side-effects. The builtin's first argument must be a string literal which contains the executable code. All other arguments can be of type *bool*, *int* or *string*. The transpiler parses the string literal and replaces all placeholders (e.g. {0}) with the corresponding positional argument at transpile time.
+
+To pass data into the native code, placeholders with either only the positional number (e.g. "{0}") or "i:" followed by the positional number (e.g. "{i:0}") should be used.
+
+To get data out of the native code, placeholders with "o:" followed by the positional number must be used. **IMPORTANT**: The passed expression must be a variable.
+
+In the following example, the variable *file* is passed as input to the native Batch code, while the variable *date* is passed as output argument. After the execution, *date* holds the value evaluated by the native code.
 
 ```golang
 file := "test.tsh"
+var date string
 
-unsafe(`for %%U in ({0}) do (@echo %%~tU)`, file)
+unsafe(`for %%U in ({i:0}) do (set "{o:1}=%%~tU")`, file, date)
 ```
 
 Results in
 
 ```batch
 set "file_0=test.tsh"
-for %%U in (!file_0!) do (@echo %%~tU)
+set "date_0="
+for %%U in (!file_0!) do (set "date_0=%%~tU")
 ```
 
 ## Caveats

parser/parser.go

@@ -689,14 +689,14 @@ func (p *Parser) evaluateBuiltInFunction(tokenType lexer.TokenType, keyword stri
 	}
 	nextToken := p.eat()
 
-	// Make sure after the print call comes a  opening round bracket.
+	// Make sure after the builtin call comes a  opening round bracket.
 	if nextToken.Type() != lexer.OPENING_ROUND_BRACKET {
 		return nil, p.expectedError(`"("`, nextToken)
 	}
 	expressions := []Expression{}
 	nextToken = p.peek()
 
-	// Evaluate arguments if it's a print call with arguments.
+	// Evaluate arguments if it's a builtin call with arguments.
 	if nextToken.Type() != lexer.CLOSING_ROUND_BRACKET {
 		for {
 			expr, err := p.evaluateExpression(ctx)
@@ -730,7 +730,7 @@ func (p *Parser) evaluateBuiltInFunction(tokenType lexer.TokenType, keyword stri
 	}
 	nextToken = p.eat()
 
-	// Make sure print call is terminated with a closing round bracket.
+	// Make sure builtin call is terminated with a closing round bracket.
 	if nextToken.Type() != lexer.CLOSING_ROUND_BRACKET {
 		return nil, p.expectedError(`")"`, nextToken)
 	}
@@ -3956,11 +3956,21 @@ func (p *Parser) evaluateUnsafe(ctx context) (Statement, error) {
 		if len(expressions) > 1 {
 			args = expressions[1:]
 		}
+		literalValue := literal.Value()
 
-		for _, arg := range args {
+		for i, arg := range args {
 			if t := arg.ValueType(); !t.IsBool() && !t.IsInt() && !t.IsString() {
 				return nil, p.expectedType(t, keywordToken, NewValueType(NewTypeBool(), false), NewValueType(NewTypeInt(), false), NewValueType(NewTypeString(), false))
 			}
+
+			// If output-placeholders exist, the provided expression must be a variable evaluation.
+			if strings.Count(literalValue, fmt.Sprintf("{o:%d}", i)) > 0 {
+				_, ok := arg.(VariableEvaluation)
+
+				if !ok {
+					return nil, p.atError(fmt.Sprintf("argument %d must be a variable", i+1), keywordToken)
+				}
+			}
 		}
 		return Unsafe{
 			code: literal,

transpiler/transpiler.go

@@ -235,12 +235,30 @@ func (t *transpiler) evaluateUnsafe(unsafe parser.Unsafe) error {
 	literal := unsafe.Code().Value()
 
 	for i, arg := range unsafe.Args() {
-		result, err := t.evaluateExpression(arg, true)
+		inputPlaceholder := fmt.Sprintf("{%d}", i)
+		outputPlaceholder := fmt.Sprintf("{o:%d}", i)
 
-		if err != nil {
-			return err
+		// Replace all input-placeholders with regular placeholders as they are equivalent.
+		literal = strings.ReplaceAll(literal, fmt.Sprintf("{i:%d}", i), fmt.Sprintf("{%d}", i))
+
+		// Count input- and output-placeholders to only evaluate what's really needed.
+		inputsCount := strings.Count(literal, inputPlaceholder)
+		outputsCount := strings.Count(literal, outputPlaceholder)
+
+		if outputsCount > 0 {
+			variableEvaluation := arg.(parser.VariableEvaluation)
+
+			literal = strings.ReplaceAll(literal, outputPlaceholder, variableEvaluation.LayerName())
+		}
+
+		if inputsCount > 0 {
+			result, err := t.evaluateExpression(arg, true)
+
+			if err != nil {
+				return err
+			}
+			literal = strings.ReplaceAll(literal, inputPlaceholder, result.firstValue())
 		}
-		literal = strings.ReplaceAll(literal, fmt.Sprintf("{%d}", i), result.firstValue())
 	}
 	return t.converter.Unsafe(literal)
 }