From 348b7b8c245992304d9cbd23a98de10cf058a29e Mon Sep 17 00:00:00 2001 From: Kayne Ruse Date: Mon, 27 Feb 2023 21:32:31 +1100 Subject: [PATCH] Added some math utils to standard * ceil * floor * max * min * round --- repl/lib_standard.c | 364 +++++++++++++++++++++++++++++----- test/scripts/lib/standard.toy | 86 +++++++- 2 files changed, 393 insertions(+), 57 deletions(-) diff --git a/repl/lib_standard.c b/repl/lib_standard.c index 4375488..2b2966d 100644 --- a/repl/lib_standard.c +++ b/repl/lib_standard.c @@ -7,6 +7,61 @@ #include #include +static int nativeClock(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + //no arguments + if (arguments->count != 0) { + interpreter->errorOutput("Incorrect number of arguments to clock\n"); + return -1; + } + + //get the time from C (what a pain) + time_t rawtime = time(NULL); + struct tm* timeinfo = localtime( &rawtime ); + char* timestr = asctime(timeinfo); + + //push to the stack + size_t len = strlen(timestr) - 1; //-1 for the newline + Toy_Literal timeLiteral = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(timestr, len)); + + //push to the stack + Toy_pushLiteralArray(&interpreter->stack, timeLiteral); + + //cleanup + Toy_freeLiteral(timeLiteral); + + return 1; +} + +static int nativeHash(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + if (arguments->count != 1) { + interpreter->errorOutput("Incorrect number of arguments to hash\n"); + return -1; + } + + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); + + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } + + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } + + Toy_Literal result = TOY_TO_INTEGER_LITERAL(Toy_hashLiteral(selfLiteral)); + + Toy_pushLiteralArray(&interpreter->stack, result); + + Toy_freeLiteral(result); + Toy_freeLiteral(selfLiteral); + + return 1; +} + static int nativeAbs(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { if (arguments->count != 1) { interpreter->errorOutput("Incorrect number of arguments to abs\n"); @@ -50,27 +105,262 @@ static int nativeAbs(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) return 1; } -static int nativeClock(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { - //no arguments - if (arguments->count != 0) { - interpreter->errorOutput("Incorrect number of arguments to clock\n"); +static int nativeCeil(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + if (arguments->count != 1) { + interpreter->errorOutput("Incorrect number of arguments to ceil\n"); return -1; } - //get the time from C (what a pain) - time_t rawtime = time(NULL); - struct tm* timeinfo = localtime( &rawtime ); - char* timestr = asctime(timeinfo); + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); - //push to the stack - size_t len = strlen(timestr) - 1; //-1 for the newline - Toy_Literal timeLiteral = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(timestr, len)); + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } - //push to the stack - Toy_pushLiteralArray(&interpreter->stack, timeLiteral); + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } - //cleanup - Toy_freeLiteral(timeLiteral); + if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) { + interpreter->errorOutput("Incorrect argument type passed to ceil\n"); + Toy_freeLiteral(selfLiteral); + return -1; + } + + Toy_Literal result; + + if (TOY_IS_INTEGER(selfLiteral)) { + //NO-OP + result = Toy_copyLiteral(selfLiteral); + } + if (TOY_IS_FLOAT(selfLiteral)) { + result = TOY_TO_INTEGER_LITERAL( (int)TOY_AS_FLOAT(selfLiteral) - TOY_AS_FLOAT(selfLiteral) == 0 ? (int)TOY_AS_FLOAT(selfLiteral) : (int)TOY_AS_FLOAT(selfLiteral) + 1 ); + } + + Toy_pushLiteralArray(&interpreter->stack, result); + + Toy_freeLiteral(result); + Toy_freeLiteral(selfLiteral); + + return 1; +} + +static int nativeFloor(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + if (arguments->count != 1) { + interpreter->errorOutput("Incorrect number of arguments to floor\n"); + return -1; + } + + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); + + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } + + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } + + if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) { + interpreter->errorOutput("Incorrect argument type passed to floor\n"); + Toy_freeLiteral(selfLiteral); + return -1; + } + + Toy_Literal result; + + if (TOY_IS_INTEGER(selfLiteral)) { + //NO-OP + result = Toy_copyLiteral(selfLiteral); + } + if (TOY_IS_FLOAT(selfLiteral)) { + result = TOY_TO_INTEGER_LITERAL( (int)TOY_AS_FLOAT(selfLiteral) ); + } + + Toy_pushLiteralArray(&interpreter->stack, result); + + Toy_freeLiteral(result); + Toy_freeLiteral(selfLiteral); + + return 1; +} + +static int nativeMax(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + //return value + Toy_Literal resultLiteral = TOY_TO_NULL_LITERAL; + + //iterate over all arguments + do { + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); + + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } + + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } + + if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) { + interpreter->errorOutput("Incorrect argument type passed to max\n"); + Toy_freeLiteral(selfLiteral); + return -1; + } + + //if not comparing yet... + if (TOY_IS_NULL(resultLiteral)) { + resultLiteral = selfLiteral; + continue; + } + + //cooerce if needed + if (TOY_IS_INTEGER(resultLiteral) && TOY_IS_FLOAT(selfLiteral)) { + resultLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(resultLiteral) ); + } + + if (TOY_IS_FLOAT(resultLiteral) && TOY_IS_INTEGER(selfLiteral)) { + selfLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(selfLiteral) ); + } + + //compare + if (TOY_IS_INTEGER(resultLiteral) && TOY_AS_INTEGER(resultLiteral) < TOY_AS_INTEGER(selfLiteral)) { + //NOTE: just ints, don't free + resultLiteral = selfLiteral; + } + + else if (TOY_IS_FLOAT(resultLiteral) && TOY_AS_FLOAT(resultLiteral) < TOY_AS_FLOAT(selfLiteral)) { + //NOTE: just floats, don't free + resultLiteral = selfLiteral; + } + } + while (arguments->count > 0); + + Toy_pushLiteralArray(&interpreter->stack, resultLiteral); + + Toy_freeLiteral(resultLiteral); + + return 1; +} + +static int nativeMin(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + //return value + Toy_Literal resultLiteral = TOY_TO_NULL_LITERAL; + + //iterate over all arguments + do { + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); + + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } + + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } + + if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) { + interpreter->errorOutput("Incorrect argument type passed to min\n"); + Toy_freeLiteral(selfLiteral); + return -1; + } + + //if not comparing yet... + if (TOY_IS_NULL(resultLiteral)) { + resultLiteral = selfLiteral; + continue; + } + + //cooerce if needed + if (TOY_IS_INTEGER(resultLiteral) && TOY_IS_FLOAT(selfLiteral)) { + resultLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(resultLiteral) ); + } + + if (TOY_IS_FLOAT(resultLiteral) && TOY_IS_INTEGER(selfLiteral)) { + selfLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(selfLiteral) ); + } + + //compare + if (TOY_IS_INTEGER(resultLiteral) && TOY_AS_INTEGER(resultLiteral) > TOY_AS_INTEGER(selfLiteral)) { + //NOTE: just ints, don't free + resultLiteral = selfLiteral; + } + + else if (TOY_IS_FLOAT(resultLiteral) && TOY_AS_FLOAT(resultLiteral) > TOY_AS_FLOAT(selfLiteral)) { + //NOTE: just floats, don't free + resultLiteral = selfLiteral; + } + } + while (arguments->count > 0); + + Toy_pushLiteralArray(&interpreter->stack, resultLiteral); + + Toy_freeLiteral(resultLiteral); + + return 1; +} + +static int nativeRound(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { + if (arguments->count != 1) { + interpreter->errorOutput("Incorrect number of arguments to round\n"); + return -1; + } + + //get the self + Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); + + //parse to value if needed + Toy_Literal selfLiteralIdn = selfLiteral; + if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { + Toy_freeLiteral(selfLiteralIdn); + } + + if (TOY_IS_IDENTIFIER(selfLiteral)) { + Toy_freeLiteral(selfLiteral); + return -1; + } + + if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) { + interpreter->errorOutput("Incorrect argument type passed to round\n"); + Toy_freeLiteral(selfLiteral); + return -1; + } + + Toy_Literal result; + + if (TOY_IS_INTEGER(selfLiteral)) { + //NO-OP + result = Toy_copyLiteral(selfLiteral); + } + if (TOY_IS_FLOAT(selfLiteral)) { + //catch the already-rounded case + if (TOY_AS_FLOAT(selfLiteral) == 0) { + result = selfLiteral; + } + else { + result = TOY_TO_INTEGER_LITERAL( TOY_AS_FLOAT(selfLiteral) - (int)TOY_AS_FLOAT(selfLiteral) < 0.5 ? (int)TOY_AS_FLOAT(selfLiteral) : (int)TOY_AS_FLOAT(selfLiteral) + 1 ); + } + } + + Toy_pushLiteralArray(&interpreter->stack, result); + + Toy_freeLiteral(result); + Toy_freeLiteral(selfLiteral); return 1; } @@ -745,36 +1035,6 @@ static int nativeGetValues(Toy_Interpreter* interpreter, Toy_LiteralArray* argum return 1; } -static int nativeHash(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { - if (arguments->count != 1) { - interpreter->errorOutput("Incorrect number of arguments to hash\n"); - return -1; - } - - //get the self - Toy_Literal selfLiteral = Toy_popLiteralArray(arguments); - - //parse to value if needed - Toy_Literal selfLiteralIdn = selfLiteral; - if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) { - Toy_freeLiteral(selfLiteralIdn); - } - - if (TOY_IS_IDENTIFIER(selfLiteral)) { - Toy_freeLiteral(selfLiteral); - return -1; - } - - Toy_Literal result = TOY_TO_INTEGER_LITERAL(Toy_hashLiteral(selfLiteral)); - - Toy_pushLiteralArray(&interpreter->stack, result); - - Toy_freeLiteral(result); - Toy_freeLiteral(selfLiteral); - - return 1; -} - static int nativeIndexOf(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) { //no arguments if (arguments->count != 2) { @@ -1740,8 +2000,19 @@ typedef struct Natives { int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) { //build the natives list Natives natives[] = { - {"abs", nativeAbs}, + //misc. utils {"clock", nativeClock}, + {"hash", nativeHash}, + + //math utils + {"abs", nativeAbs}, + {"ceil", nativeCeil}, + {"floor", nativeFloor}, + {"max", nativeMax}, + {"min", nativeMin}, + {"round", nativeRound}, + + //compound utils {"concat", nativeConcat}, //array, dictionary, string {"containsKey", nativeContainsKey}, //dictionary {"containsValue", nativeContainsValue}, //array, dictionary @@ -1750,7 +2021,6 @@ int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_L {"forEach", nativeForEach}, //array, dictionary {"getKeys", nativeGetKeys}, //dictionary {"getValues", nativeGetValues}, //dictionary - {"hash", nativeHash}, {"indexOf", nativeIndexOf}, //array {"map", nativeMap}, //array, dictionary {"reduce", nativeReduce}, //array, dictionary diff --git a/test/scripts/lib/standard.toy b/test/scripts/lib/standard.toy index 117bb70..b2e0297 100644 --- a/test/scripts/lib/standard.toy +++ b/test/scripts/lib/standard.toy @@ -1,5 +1,19 @@ import standard; +//test clock +{ + //this depends on external factors, so only check the length + assert clock().length() == 24, "clock().length() failed"; +} + + +//test hash +{ + assert typeof "Hello world".hash() == int, "typeof \"Hello world\".hash() failed"; + assert "Hello world".hash() == 994097935, "\"Hello world\".hash() failed"; //NOTE: specific value based on algorithm +} + + //test abs { assert abs(-5) == 5, "abs(-integer) failed"; @@ -13,10 +27,69 @@ import standard; } -//test clock +//test ceil { - //this depends on external factors, so only check the length - assert clock().length() == 24, "clock().length() failed"; + assert ceil(4) == 4, "ceil(int) failed"; + assert ceil(4.0) == 4, "ceil(float) failed"; + assert ceil(4.1) == 5, "ceil() failed"; + + var x = 4.1; + + assert x.ceil() == 5, "var.ceil() failed"; +} + + +//test floor +{ + assert floor(4) == 4, "floor(int) failed"; + assert floor(4.0) == 4, "floor(float) failed"; + assert floor(4.1) == 4, "floor() failed"; + + var x = 4.1; + + assert x.floor() == 4, "var.floor() failed"; +} + + +//test max +{ + assert max(1, 2, 3) == 3, "max() failed"; + + var a = 1; + var b = 2; + var c = 3; + + assert max(a, b, c) == 3, "var.max() failed"; + + assert max(1, 2, 3, 4, 5, 6, 7, 8, 9, 0) == 9, "max() with many args failed"; +} + + +//test min +{ + assert min(1, 2, 3) == 1, "min() failed"; + + var a = 1; + var b = 2; + var c = 3; + + assert min(a, b, c) == 1, "var.min() failed"; + + assert min(1, 2, 3, 4, 5, 6, 7, 8, 9, 0) == 0, "min() with many args failed"; +} + + +//test round +{ + assert round(4) == 4, "round(int) failed"; + assert round(4.0) == 4, "round(float) failed"; + assert round(4.1) == 4, "round(less than half) failed"; + assert round(4.9) == 5, "round(greater than half) failed"; + assert round(4.5) == 5, "round(exactly half) failed"; + + var x = 4.1; + + assert x.round() == 4, "var.round() failed"; } @@ -175,13 +248,6 @@ import standard; } -//test hash -{ - assert typeof "Hello world".hash() == int, "typeof \"Hello world\".hash() failed"; - assert "Hello world".hash() == 994097935, "\"Hello world\".hash() failed"; //NOTE: specific value based on algorithm -} - - //test indexOf { var a = [1, 2, 42, 3];