Added some math utils to standard

* ceil
* floor
* max
* min
* round

repl/lib_standard.c

@@ -7,6 +7,61 @@
 #include <time.h>
 #include <ctype.h>
 
+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) {
+static int nativeCeil(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
-	//no arguments
+	if (arguments->count != 1) {
-	if (arguments->count != 0) {
+		interpreter->errorOutput("Incorrect number of arguments to ceil\n");
-		interpreter->errorOutput("Incorrect number of arguments to clock\n");
 		return -1;
 	}
 
-	//get the time from C (what a pain)
+	//get the self
-	time_t rawtime = time(NULL);
+	Toy_Literal selfLiteral = Toy_popLiteralArray(arguments);
-	struct tm* timeinfo = localtime( &rawtime );
-	char* timestr = asctime(timeinfo);
 
-	//push to the stack
+	//parse to value if needed
-	size_t len = strlen(timestr) - 1; //-1 for the newline
+	Toy_Literal selfLiteralIdn = selfLiteral;
-	Toy_Literal timeLiteral = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(timestr, len));
+	if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) {
+		Toy_freeLiteral(selfLiteralIdn);
+	}
 
-	//push to the stack
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-	Toy_pushLiteralArray(&interpreter->stack, timeLiteral);
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
 
-	//cleanup
+	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
-	Toy_freeLiteral(timeLiteral);
+		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

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 ceil(4) == 4, "ceil(int) failed";
-	assert clock().length() == 24, "clock().length() 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];