From eae96d6403b76a198363b5eb947a6bc6d0deea4c Mon Sep 17 00:00:00 2001 From: Kayne Ruse Date: Tue, 14 Feb 2023 08:00:35 +0000 Subject: [PATCH] Corrected the order of arguments to Toy_callLiteralFn() --- repl/lib_runner.c | 3 +- repl/lib_standard.c | 30 ++++++++-------- scripts/small.toy | 41 +++++++++++----------- source/toy_interpreter.c | 76 ++++++++++++++++++---------------------- 4 files changed, 71 insertions(+), 79 deletions(-) diff --git a/repl/lib_runner.c b/repl/lib_runner.c index e4c73fe..5347f17 100644 --- a/repl/lib_runner.c +++ b/repl/lib_runner.c @@ -309,7 +309,7 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar Toy_LiteralArray rest; Toy_initLiteralArray(&rest); - while (tmp.count) { //correct the order of the rest args + while (tmp.count > 0) { //correct the order of the rest args Toy_Literal lit = Toy_popLiteralArray(&tmp); Toy_pushLiteralArray(&rest, lit); Toy_freeLiteral(lit); @@ -317,7 +317,6 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar Toy_freeLiteralArray(&tmp); - //get the runner object Toy_Literal varName = Toy_popLiteralArray(arguments); Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments); diff --git a/repl/lib_standard.c b/repl/lib_standard.c index c06c8ca..62e2430 100644 --- a/repl/lib_standard.c +++ b/repl/lib_standard.c @@ -296,8 +296,8 @@ static int nativeEvery(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -337,8 +337,8 @@ static int nativeEvery(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -413,8 +413,8 @@ static int nativeFilter(Toy_Interpreter* interpreter, Toy_LiteralArray* argument Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -453,8 +453,8 @@ static int nativeFilter(Toy_Interpreter* interpreter, Toy_LiteralArray* argument Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -523,8 +523,8 @@ static int nativeForEach(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -546,8 +546,8 @@ static int nativeForEach(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -742,8 +742,8 @@ static int nativeMap(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -777,8 +777,8 @@ static int nativeMap(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -849,9 +849,9 @@ static int nativeReduce(Toy_Interpreter* interpreter, Toy_LiteralArray* argument Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); - Toy_pushLiteralArray(&arguments, indexLiteral); Toy_pushLiteralArray(&arguments, defaultLiteral); + Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -879,9 +879,9 @@ static int nativeReduce(Toy_Interpreter* interpreter, Toy_LiteralArray* argument Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); Toy_pushLiteralArray(&arguments, defaultLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -946,8 +946,8 @@ static int nativeSome(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_pushLiteralArray(&arguments, indexLiteral); + Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[i]); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -987,8 +987,8 @@ static int nativeSome(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) Toy_LiteralArray arguments; Toy_initLiteralArray(&arguments); - Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].key); + Toy_pushLiteralArray(&arguments, TOY_AS_DICTIONARY(selfLiteral)->entries[i].value); Toy_LiteralArray returns; Toy_initLiteralArray(&returns); @@ -1045,8 +1045,8 @@ static void recursiveLiteralQuicksortUtil(Toy_Interpreter* interpreter, Toy_Lite Toy_initLiteralArray(&arguments); Toy_initLiteralArray(&returns); - Toy_pushLiteralArray(&arguments, ptr[literalCount - 1]); //backwards Toy_pushLiteralArray(&arguments, ptr[checker]); + Toy_pushLiteralArray(&arguments, ptr[literalCount - 1]); Toy_callLiteralFn(interpreter, fnCompareLiteral, &arguments, &returns); diff --git a/scripts/small.toy b/scripts/small.toy index d954e85..08ff76d 100644 --- a/scripts/small.toy +++ b/scripts/small.toy @@ -1,27 +1,28 @@ -import compound; +import standard; -fn less(a, b) { - return a < b; -} +//test every +{ + var a = [1, 2, 3]; + var d = ["one": 1, "two": 2]; -fn greater(a, b) { - return a > b; -} + var counter = 0; + fn f(k, v) { + print " > " + string k + " : " + string v; + counter++; + return v; + } -var a = [7, 2, 1, 8, 6, 3, 5, 4]; -var b = [7, 2, 1, 4, 6, 3, 5, 8]; -var c = [1, 2, 3, 4, 5, 6, 7, 8]; -var d = [7, 2, 1, 8, 6, 3, 5, 4]; + assert a.every(f) == true, "array.every() == true failed"; + assert d.every(f) == true, "dictionary.every() == true failed"; -a = a.sort(less); -b = b.sort(less); -c = c.sort(less); -d = d.sort(greater); + assert counter == 5, "Unexpected number of calls for _every() == true"; -assert a == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) failed"; -assert b == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) with pivot high failed"; -assert c == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) pre-sorted array failed"; -assert d == [8, 7, 6, 5, 4, 3, 2, 1], "array.sort(greater) failed"; + counter = 0; + a[1] = false; + d["two"] = false; + assert a.every(f) == false, "array.every() == false failed"; + assert d.every(f) == false, "dictionary.every() == false failed"; -print "All good"; + assert counter == 4, "Unexpected number of calls for _every() == false"; +} \ No newline at end of file diff --git a/source/toy_interpreter.c b/source/toy_interpreter.c index ae13bb7..67db3c1 100644 --- a/source/toy_interpreter.c +++ b/source/toy_interpreter.c @@ -1089,6 +1089,8 @@ static bool execFalseJump(Toy_Interpreter* interpreter) { static void execInterpreter(Toy_Interpreter*); static void readInterpreterSections(Toy_Interpreter* interpreter); +//expect stack: identifier, arg1, arg2, arg3..., stackSize +//also supports identifier & arg1 to be other way around (looseFirstArgument) static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { //BUGFIX: depth check - don't drown! if (interpreter->depth >= 200) { @@ -1143,6 +1145,7 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { identifier = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefStringLength(buffer, length)); } + //get the function literal Toy_Literal func = identifier; if (!Toy_parseIdentifierToValue(interpreter, &func)) { @@ -1152,30 +1155,7 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { return false; } - //check for side-loaded native functions - if (TOY_IS_FUNCTION_NATIVE(func)) { - //reverse the order to the correct order - Toy_LiteralArray correct; - Toy_initLiteralArray(&correct); - - while(arguments.count) { - Toy_Literal lit = Toy_popLiteralArray(&arguments); - Toy_pushLiteralArray(&correct, lit); - Toy_freeLiteral(lit); - } - - Toy_freeLiteralArray(&arguments); - - //call the native function - TOY_AS_FUNCTION_NATIVE(func)(interpreter, &correct); - - Toy_freeLiteralArray(&correct); - Toy_freeLiteral(stackSize); - Toy_freeLiteral(identifier); - return true; - } - - if (!TOY_IS_FUNCTION(func)) { + if (!TOY_IS_FUNCTION(func) && !TOY_IS_FUNCTION_NATIVE(func)) { interpreter->errorOutput("Function not found: "); Toy_printLiteralCustom(identifier, interpreter->errorOutput); interpreter->errorOutput("\n"); @@ -1186,7 +1166,18 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { return false; } - bool ret = Toy_callLiteralFn(interpreter, func, &arguments, &interpreter->stack); + //BUGFIX: correct the argument order + Toy_LiteralArray correct; + Toy_initLiteralArray(&correct); + + while (arguments.count > 0) { + Toy_Literal lit = Toy_popLiteralArray(&arguments); + Toy_pushLiteralArray(&correct, lit); + Toy_freeLiteral(lit); + } + + //call the function literal + bool ret = Toy_callLiteralFn(interpreter, func, &correct, &interpreter->stack); if (!ret) { interpreter->errorOutput("Error encountered in function \""); @@ -1194,6 +1185,7 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { interpreter->errorOutput("\"\n"); } + Toy_freeLiteralArray(&correct); Toy_freeLiteralArray(&arguments); Toy_freeLiteral(func); Toy_freeLiteral(stackSize); @@ -1202,25 +1194,15 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) { return ret; } +//expects arguments in correct order bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns) { //check for side-loaded native functions if (TOY_IS_FUNCTION_NATIVE(func)) { - //reverse the order to the correct order - Toy_LiteralArray correct; - Toy_initLiteralArray(&correct); - - while(arguments->count) { - Toy_Literal lit = Toy_popLiteralArray(arguments); - Toy_pushLiteralArray(&correct, lit); - Toy_freeLiteral(lit); - } - //call the native function - int returnsCount = TOY_AS_FUNCTION_NATIVE(func)(interpreter, &correct); + int returnsCount = TOY_AS_FUNCTION_NATIVE(func)(interpreter, arguments); if (returnsCount < 0) { interpreter->errorOutput("Unknown error from native function\n"); - Toy_freeLiteralArray(&correct); return false; } @@ -1242,13 +1224,12 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter } Toy_freeLiteralArray(&returnsFromInner); - Toy_freeLiteralArray(&correct); return true; } //normal Toy function if (!TOY_IS_FUNCTION(func)) { - interpreter->errorOutput("Function required in Toy_callLiteralFn()\n"); + interpreter->errorOutput("Function literal required in Toy_callLiteralFn()\n"); return false; } @@ -1296,6 +1277,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter return false; } + //BUGFIX: access the arguments from the beginning + int argumentIndex = 0; + //contents is the indexes of identifier & type for (int i = 0; i < paramArray->count - (TOY_IS_NULL(restParam) ? 0 : 2); i += 2) { //don't count the rest parameter, if present //declare and define each entry in the scope @@ -1311,7 +1295,11 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter return false; } - Toy_Literal arg = Toy_popLiteralArray(arguments); + //access the arguments in order + Toy_Literal arg = TOY_TO_NULL_LITERAL; + if (argumentIndex < arguments->count) { + arg = Toy_copyLiteral(arguments->literals[argumentIndex++]); + } Toy_Literal argIdn = arg; if (TOY_IS_IDENTIFIER(arg) && Toy_parseIdentifierToValue(interpreter, &arg)) { @@ -1338,8 +1326,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter Toy_LiteralArray rest; Toy_initLiteralArray(&rest); - while (arguments->count > 0) { - Toy_Literal lit = Toy_popLiteralArray(arguments); + //access the arguments in order + while (argumentIndex < arguments->count) { + Toy_Literal lit = Toy_copyLiteral(arguments->literals[argumentIndex++]); Toy_pushLiteralArray(&rest, lit); Toy_freeLiteral(lit); } @@ -1446,6 +1435,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter Toy_freeLiteralArray(&inner.stack); Toy_freeLiteralArray(&inner.literalCache); + //BUGFIX: this function needs to eat the arguments + Toy_freeLiteralArray(arguments); + //actual bytecode persists until next call return true; }