Unary buildin functions, need to fix test!

src/parser/parser.go

@@ -2,7 +2,6 @@ package parser
 
 import (
 	"errors"
-	"fmt"
 	"strconv"
 	"tokenizer"
 	"types"
@@ -221,7 +220,7 @@ func (c *Compiler) parseFunction() {
 	c.expect("func")
 
 	// check for build in function
-	if buildin, _ := types.GetFunction(c.get().Token); buildin == true {
+	if buildin := types.GetFunction(c.get().Token); buildin != nil {
 		panic(errors.New(c.get().Token + " is a build in function, choose a different name"))
 	}
 
@@ -369,42 +368,27 @@ func (c *Compiler) parseFunctionCall(out bool, name string) string {
 	output := ""
 
 	c.expect("(")
-	params, paramCount := c.parseParameter(false)
+	paramsStr, params, paramCount := c.parseParameter(false)
 	c.expect(")")
 
 	// buildin function
-	exists, buildin := types.GetFunction(name)
+	buildin := types.GetFunction(name)
 
-	if exists {
+	if buildin != nil {
 		// check parameter count
-		if exists && paramCount < buildin.ArgsCount {
+		if paramCount < buildin.ArgsCount {
 			panic(errors.New("Function expected " + strconv.Itoa(buildin.ArgsCount) + " parameter but found " + strconv.Itoa(paramCount)))
 		}
 
 		if buildin.Type == types.NULL {
 			output = name
 		} else if buildin.Type == types.UNARY {
-			if paramCount == 1 {
-				output = name + " " + params
-			} else {
-				output = "[" + params + "] call " + name
-			}
+			output = c.parseUnaryFunction(name, paramsStr, paramCount)
 		} else {
-			// TODO
+			output = c.parseBinaryFunction(name, params, buildin)
 		}
-
-		fmt.Println(name)
-		/*if leftParamCount > 1 {
-			leftParams = "[" + leftParams + "]"
-		}
-
-		if leftParamCount > 0 {
-			output = leftParams + " " + name + " " + rightParams
-		} else {
-			output = name + " " + rightParams
-		}*/
 	} else {
-		output = "[" + params + "] call " + name
+		output = "[" + paramsStr + "] call " + name
 	}
 
 	if out {
@@ -414,12 +398,67 @@ func (c *Compiler) parseFunctionCall(out bool, name string) string {
 	return output
 }
 
-func (c *Compiler) parseParameter(out bool) (string, int) {
+func (c *Compiler) parseUnaryFunction(name, paramsStr string, paramCount int) string {
 	output := ""
+
+	if paramCount == 1 {
+		output = name + " " + paramsStr
+	} else {
+		output = "[" + paramsStr + "] call " + name
+	}
+
+	return output
+}
+
+func (c *Compiler) parseBinaryFunction(name string, params []string, buildin *types.FunctionType) string {
+	output := ""
+
+	if buildin.ArgsLeft == 1 {
+		output = params[0] + " "
+	} else {
+		output = "["
+
+		for i := 0; i < buildin.ArgsLeft; i++ {
+			output += params[i]
+
+			if i != buildin.ArgsLeft-1 {
+				output += ","
+			}
+		}
+
+		output += "] "
+	}
+
+	output += name
+
+	if buildin.ArgsCount-buildin.ArgsLeft == 1 {
+		output += " " + params[1]
+	} else {
+		output += " ["
+
+		for i := buildin.ArgsLeft; i < buildin.ArgsCount; i++ {
+			output += params[i]
+
+			if i != buildin.ArgsCount-1 {
+				output += ","
+			}
+		}
+
+		output += "]"
+	}
+
+	return output
+}
+
+func (c *Compiler) parseParameter(out bool) (string, []string, int) {
+	output := ""
+	params := make([]string, 0)
 	count := 0
 
 	for !c.accept(")") {
-		output += c.parseExpression(out)
+		expr := c.parseExpression(out)
+		output += expr
+		params = append(params, expr)
 		count++
 
 		if !c.accept(")") {
@@ -432,7 +471,7 @@ func (c *Compiler) parseParameter(out bool) (string, int) {
 		c.appendOut(output, false)
 	}
 
-	return output, count
+	return output, params, count
 }
 
 func (c *Compiler) parseExpression(out bool) string {

src/parser/parser_test.go

@@ -8,161 +8,161 @@ import (
 )
 
 func TestParserDeclaration(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_var.asl")
+	got := getCompiled(t, "../../test/tokenizer_var.asl")
 	want := "x = 1;\r\narray = [1,2,3];\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserAssignment(t *testing.T) {
-	got := getCompiled(t, "test/parser_assignment.asl")
+	got := getCompiled(t, "../../test/parser_assignment.asl")
 	want := "x = 1;\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserIf(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_if.asl")
+	got := getCompiled(t, "../../test/tokenizer_if.asl")
 	want := "if (a<b) then {\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserWhile(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_while.asl")
+	got := getCompiled(t, "../../test/tokenizer_while.asl")
 	want := "while {true} do {\r\n};"
 
 	equal(t, got, want)
 }
 
 func TestParserFor(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_for.asl")
+	got := getCompiled(t, "../../test/tokenizer_for.asl")
 	want := "for [{i=0}, {i<100}, {i=i+1}] do {\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserForeach(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_foreach.asl")
+	got := getCompiled(t, "../../test/tokenizer_foreach.asl")
 	want := "{\r\nunit = _x;\r\n} forEach (allUnits);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserSwitch(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_switch.asl")
+	got := getCompiled(t, "../../test/tokenizer_switch.asl")
 	want := "switch (x) do {\r\ncase 1:\r\n{\r\nx = 1;\r\n};\r\ncase 2:\r\n{\r\nx = 2;\r\n};\r\ndefault:\r\n{\r\nx = 3;\r\n};\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserFunction(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_func.asl")
+	got := getCompiled(t, "../../test/tokenizer_func.asl")
 	want := "TestFunction = {\r\nparams [\"param0\",\"param1\"];\r\nreturn true;\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserAssignResult(t *testing.T) {
-	got := getCompiled(t, "test/parser_assign_result.asl")
+	got := getCompiled(t, "../../test/parser_assign_result.asl")
 	want := "x = ([1, 2, 3] call foo);\r\ny = ([1, 2, 3] call bar);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserExpression(t *testing.T) {
-	got := getCompiled(t, "test/parser_expression.asl")
+	got := getCompiled(t, "../../test/parser_expression.asl")
 	want := "x = -(1+(2+3))/(6*(someVariable+99-100))-(20)+!anotherVariable+([] call foo);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserExpression2(t *testing.T) {
-	got := getCompiled(t, "test/parser_expression2.asl")
+	got := getCompiled(t, "../../test/parser_expression2.asl")
 	want := "x = true||(3>=4&&5<8);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserFunctionCall(t *testing.T) {
-	got := getCompiled(t, "test/parser_func_call.asl")
+	got := getCompiled(t, "../../test/parser_func_call.asl")
 	want := "myFunc = {\r\nparams [\"a\",\"b\"];\r\nreturn a>b;\r\n};\r\n[1+3/4, 2-(66*22)/3-((123))] call myFunc;\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserBuildinFunctionCall(t *testing.T) {
-	got := getCompiled(t, "test/parser_buildin_func.asl")
+	got := getCompiled(t, "../../test/parser_buildin_func.asl")
 	want := "_x = (([player, foo] getVar bar) setHit [\"head\", \"tail\"]);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserOperator(t *testing.T) {
-	got := getCompiled(t, "test/parser_operator.asl")
+	got := getCompiled(t, "../../test/parser_operator.asl")
 	want := "if (x==y&&x!=y&&x<=y&&x>=y&&x<y&&x>y) then {\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserTryCatch(t *testing.T) {
-	got := getCompiled(t, "test/parser_try_catch.asl")
+	got := getCompiled(t, "../../test/parser_try_catch.asl")
 	want := "try {\r\n} catch {\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserNegationFunctionCall(t *testing.T) {
-	got := getCompiled(t, "test/parser_negation.asl")
+	got := getCompiled(t, "../../test/parser_negation.asl")
 	want := "x = !([] call foo);\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserExitWith(t *testing.T) {
-	got := getCompiled(t, "test/parser_exitwith.asl")
+	got := getCompiled(t, "../../test/parser_exitwith.asl")
 	want := "if (true) exitWith {\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserWaitUntil(t *testing.T) {
-	got := getCompiled(t, "test/parser_waituntil.asl")
+	got := getCompiled(t, "../../test/parser_waituntil.asl")
 	want := "waitUntil {x=x+1;x<100};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserArray(t *testing.T) {
-	got := getCompiled(t, "test/parser_array.asl")
+	got := getCompiled(t, "../../test/parser_array.asl")
 	want := "x = [1,2,3];\r\ny = (x select (1));\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserFunctionParams(t *testing.T) {
-	got := getCompiled(t, "test/parser_func_params.asl")
+	got := getCompiled(t, "../../test/parser_func_params.asl")
 	want := "myFunc = {\r\nparams [[\"a\",1],[\"b\",2]];\r\nreturn a+b;\r\n};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserInlineCode(t *testing.T) {
-	got := getCompiled(t, "test/parser_code.asl")
+	got := getCompiled(t, "../../test/parser_code.asl")
 	want := "inline_code = {a = 1;b = 2;if (a<b) then {[] call foo;};};\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserPreprocessor(t *testing.T) {
-	got := getCompiled(t, "test/tokenizer_preprocessor.asl")
+	got := getCompiled(t, "../../test/tokenizer_preprocessor.asl")
 	want := "\r\n#define HELLO_WORLD \"Hello World!\"\r\nhint HELLO_WORLD;\r\n"
 
 	equal(t, got, want)
 }
 
 func TestParserExpressionArray(t *testing.T) {
-	got := getCompiled(t, "test/parser_expression_array.asl")
+	got := getCompiled(t, "../../test/parser_expression_array.asl")
 	want := "x = [1,2,3]-[2,3];\r\n"
 
 	equal(t, got, want)
@@ -176,7 +176,7 @@ func getCompiled(t *testing.T, file string) string {
 		t.FailNow()
 	}
 
-	tokens := tokenizer.Tokenize(code)
+	tokens := tokenizer.Tokenize(code, false)
 	compiler := parser.Compiler{}
 
 	return compiler.Parse(tokens, true)