krgamestudios/Toy
1
0
Fork 0
mirror of https://github.com/krgamestudios/Toy.git synced 2026-04-15 14:54:07 +10:00
Code Issues Packages Projects Releases Wiki Activity

WIP: Implementing arrays into the script, read more

Browse Source 
I had intended to solve the Advent of Code puzzles in Toy, but they
don't work without arrays. I wasn't able to enable arrays in time, so
I need to focus on doing things correctly.

The most immediate tasks are marked with 'URGENT', and a lot of tests
need writing.
This commit is contained in:
Kayne Ruse
2024-12-02 11:58:03 +11:00
parent 12c6ac938c
commit 62ca7a1fb7
16 changed files with 599 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
source/toy_value.c
View File

@@ -18,30 +18,42 @@ static unsigned int hashUInt(unsigned int x) {
}
//exposed functions
Toy_Value Toy_unwrapValue(Toy_Value value) {
//turns out C doesn't have actual references
if (value.type == TOY_VALUE_REFERENCE) {
return Toy_unwrapValue(*(value.as.reference));
}
else {
return value;
}
}
unsigned int Toy_hashValue(Toy_Value value) {
value = Toy_unwrapValue(value);
switch(value.type) {
case TOY_VALUE_NULL:
return 0;
case TOY_VALUE_BOOLEAN:
return TOY_VALUE_AS_BOOLEAN(value) ? 1 : 0;
return value.as.boolean ? 1 : 0;
case TOY_VALUE_INTEGER:
return hashUInt(TOY_VALUE_AS_INTEGER(value));
return hashUInt((unsigned int)value.as.integer);
case TOY_VALUE_FLOAT:
return hashUInt( *((int*)(&TOY_VALUE_AS_FLOAT(value))) );
return hashUInt( *((unsigned int*)(&value.as.number)) );
case TOY_VALUE_STRING:
return Toy_hashString(TOY_VALUE_AS_STRING(value));
return Toy_hashString(value.as.string);
case TOY_VALUE_ARRAY: {
//since array internals can change, recalc the hash each time it's needed
Toy_Array* array = TOY_VALUE_AS_ARRAY(value);
Toy_Array* ptr = value.as.array;
unsigned int hash = 0;
for (unsigned int i = 0; i < array->count; i++) {
hash ^= Toy_hashValue(array->data[i]);
for (unsigned int i = 0; i < ptr->count; i++) {
hash ^= Toy_hashValue(ptr->data[i]);
}
return hash;
@@ -52,6 +64,7 @@ unsigned int Toy_hashValue(Toy_Value value) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "ERROR: Can't hash an unknown value type, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -61,6 +74,8 @@ unsigned int Toy_hashValue(Toy_Value value) {
}
Toy_Value Toy_copyValue(Toy_Value value) {
value = Toy_unwrapValue(value);
switch(value.type) {
case TOY_VALUE_NULL:
case TOY_VALUE_BOOLEAN:
@@ -69,20 +84,20 @@ Toy_Value Toy_copyValue(Toy_Value value) {
return value;
case TOY_VALUE_STRING: {
Toy_String* string = TOY_VALUE_AS_STRING(value);
return TOY_VALUE_FROM_STRING(Toy_copyString(string));
return TOY_VALUE_FROM_STRING(Toy_copyString(value.as.string));
}
case TOY_VALUE_ARRAY: {
Toy_Array* array = TOY_VALUE_AS_ARRAY(value);
Toy_Array* result = Toy_resizeArray(NULL, array->capacity);
//arrays probably won't get copied much
Toy_Array* ptr = value.as.array;
Toy_Array* result = Toy_resizeArray(NULL, ptr->capacity);
for (unsigned int i = 0; i < array->count; i++) {
result->data[i] = Toy_copyValue(array->data[i]);
for (unsigned int i = 0; i < ptr->count; i++) {
result->data[i] = Toy_copyValue(ptr->data[i]);
}
result->capacity = array->capacity;
result->count = array->count;
result->capacity = ptr->capacity;
result->count = ptr->count;
return TOY_VALUE_FROM_ARRAY(result);
}
@@ -92,6 +107,7 @@ Toy_Value Toy_copyValue(Toy_Value value) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "ERROR: Can't copy an unknown value type, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -102,6 +118,8 @@ Toy_Value Toy_copyValue(Toy_Value value) {
}
void Toy_freeValue(Toy_Value value) {
//NOTE: do not unwrap this value, as references shouldn't be freed
switch(value.type) {
case TOY_VALUE_NULL:
case TOY_VALUE_BOOLEAN:
@@ -110,19 +128,18 @@ void Toy_freeValue(Toy_Value value) {
break;
case TOY_VALUE_STRING: {
Toy_String* string = TOY_VALUE_AS_STRING(value);
Toy_freeString(string);
Toy_freeString(value.as.string);
break;
}
case TOY_VALUE_ARRAY: {
Toy_Array* array = TOY_VALUE_AS_ARRAY(value);
Toy_Array* ptr = value.as.array;
for (unsigned int i = 0; i < array->count; i++) {
Toy_freeValue(array->data[i]);
for (unsigned int i = 0; i < ptr->count; i++) {
Toy_freeValue(ptr->data[i]);
}
TOY_ARRAY_FREE(array);
TOY_ARRAY_FREE(ptr);
break;
}
@@ -131,6 +148,7 @@ void Toy_freeValue(Toy_Value value) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "ERROR: Can't free an unknown value type, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -138,15 +156,17 @@ void Toy_freeValue(Toy_Value value) {
}
bool Toy_checkValueIsTruthy(Toy_Value value) {
value = Toy_unwrapValue(value);
//null is an error
if (TOY_VALUE_IS_NULL(value)) {
if (value.type == TOY_VALUE_NULL) {
Toy_error("'null' is neither true nor false");
return false;
}
//only 'false' is falsy
if (TOY_VALUE_IS_BOOLEAN(value)) {
return TOY_VALUE_AS_BOOLEAN(value);
if (value.type == TOY_VALUE_BOOLEAN) {
return value.as.boolean;
}
//anything else is truthy
@@ -154,57 +174,65 @@ bool Toy_checkValueIsTruthy(Toy_Value value) {
}
bool Toy_checkValuesAreEqual(Toy_Value left, Toy_Value right) {
left = Toy_unwrapValue(left);
right = Toy_unwrapValue(right);
switch(left.type) {
case TOY_VALUE_NULL:
return TOY_VALUE_IS_NULL(right);
return right.type == TOY_VALUE_NULL;
case TOY_VALUE_BOOLEAN:
return TOY_VALUE_IS_BOOLEAN(right) && TOY_VALUE_AS_BOOLEAN(left) == TOY_VALUE_AS_BOOLEAN(right);
return right.type == TOY_VALUE_NULL && left.as.boolean == right.as.boolean;
case TOY_VALUE_INTEGER:
if (TOY_VALUE_IS_INTEGER(right)) {
return TOY_VALUE_AS_INTEGER(left) == TOY_VALUE_AS_INTEGER(right);
if (right.type == TOY_VALUE_INTEGER) {
return left.as.integer == right.as.integer;
}
else if (TOY_VALUE_IS_FLOAT(right)) {
return TOY_VALUE_AS_INTEGER(left) == TOY_VALUE_AS_FLOAT(right);
else if (right.type == TOY_VALUE_FLOAT) {
return left.as.integer == right.as.number;
}
else {
break;
}
case TOY_VALUE_FLOAT:
if (TOY_VALUE_IS_INTEGER(right)) {
return TOY_VALUE_AS_FLOAT(left) == TOY_VALUE_AS_INTEGER(right);
if (right.type == TOY_VALUE_INTEGER) {
return left.as.number == right.as.integer;
}
else if (TOY_VALUE_IS_FLOAT(right)) {
return TOY_VALUE_AS_FLOAT(left) == TOY_VALUE_AS_FLOAT(right);
else if (right.type == TOY_VALUE_FLOAT) {
return left.as.number == right.as.number;
}
else {
break;
}
case TOY_VALUE_STRING:
if (TOY_VALUE_IS_STRING(right)) {
return Toy_compareStrings(TOY_VALUE_AS_STRING(left), TOY_VALUE_AS_STRING(right)) == 0;
if (right.type == TOY_VALUE_STRING) {
return Toy_compareStrings(left.as.string, right.as.string) == 0;
}
else {
break;
}
case TOY_VALUE_ARRAY: {
Toy_Array* leftArray = TOY_VALUE_AS_ARRAY(left);
Toy_Array* rightArray = TOY_VALUE_AS_ARRAY(right);
if (right.type == TOY_VALUE_ARRAY) {
Toy_Array* leftArray = left.as.array;
Toy_Array* rightArray = right.as.array;
//different lengths is an easy way to check
if (leftArray->count != rightArray->count) {
return false;
}
for (unsigned int i = 0; i < leftArray->count; i++) {
//any mismatch is an easy difference
if (Toy_checkValuesAreEqual(leftArray->data[i], rightArray->data[i])) {
//different lengths is an easy way to check
if (leftArray->count != rightArray->count) {
return false;
}
for (unsigned int i = 0; i < leftArray->count; i++) {
//any mismatch is an easy difference
if (Toy_checkValuesAreEqual(leftArray->data[i], rightArray->data[i])) {
return false;
}
}
}
else {
break;
}
//finally
@@ -216,6 +244,7 @@ bool Toy_checkValuesAreEqual(Toy_Value left, Toy_Value right) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "ERROR: Unknown types in value equality, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -225,21 +254,23 @@ bool Toy_checkValuesAreEqual(Toy_Value left, Toy_Value right) {
}
bool Toy_checkValuesAreComparable(Toy_Value left, Toy_Value right) {
//NOTE: "equal" and "comparable" are different - equal means they're identical, comparable is only possible for certain types
left = Toy_unwrapValue(left);
right = Toy_unwrapValue(right);
//NOTE: "equal" and "comparable" are different - equal means they're identical, comparable is only possible for certain types
switch(left.type) {
case TOY_VALUE_NULL:
return false;
case TOY_VALUE_BOOLEAN:
return TOY_VALUE_IS_BOOLEAN(right);
return right.type == TOY_VALUE_BOOLEAN;
case TOY_VALUE_INTEGER:
case TOY_VALUE_FLOAT:
return TOY_VALUE_IS_INTEGER(right) || TOY_VALUE_IS_FLOAT(right);
return right.type == TOY_VALUE_INTEGER || right.type == TOY_VALUE_FLOAT;
case TOY_VALUE_STRING:
return TOY_VALUE_IS_STRING(right);
return right.type == TOY_VALUE_STRING;
case TOY_VALUE_ARRAY:
//nothing is comparable with an array
@@ -250,6 +281,7 @@ bool Toy_checkValuesAreComparable(Toy_Value left, Toy_Value right) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "Unknown types in value comparison check, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -259,6 +291,9 @@ bool Toy_checkValuesAreComparable(Toy_Value left, Toy_Value right) {
}
int Toy_compareValues(Toy_Value left, Toy_Value right) {
left = Toy_unwrapValue(left);
right = Toy_unwrapValue(right);
//comparison means there's a difference in value, with some kind of quantity - so null, bool, etc. aren't comparable
switch(left.type) {
case TOY_VALUE_NULL:
@@ -266,30 +301,30 @@ int Toy_compareValues(Toy_Value left, Toy_Value right) {
break;
case TOY_VALUE_INTEGER:
if (TOY_VALUE_IS_INTEGER(right)) {
return TOY_VALUE_AS_INTEGER(left) - TOY_VALUE_AS_INTEGER(right);
if (right.type == TOY_VALUE_INTEGER) {
return left.as.integer - right.as.integer;
}
else if (TOY_VALUE_IS_FLOAT(right)) {
return TOY_VALUE_AS_INTEGER(left) - TOY_VALUE_AS_FLOAT(right);
else if (right.type == TOY_VALUE_FLOAT) {
return left.as.integer - right.as.number;
}
else {
break;
}
case TOY_VALUE_FLOAT:
if (TOY_VALUE_IS_INTEGER(right)) {
return TOY_VALUE_AS_FLOAT(left) - TOY_VALUE_AS_INTEGER(right);
if (right.type == TOY_VALUE_INTEGER) {
return left.as.number - right.as.integer;
}
else if (TOY_VALUE_IS_FLOAT(right)) {
return TOY_VALUE_AS_FLOAT(left) - TOY_VALUE_AS_FLOAT(right);
else if (right.type == TOY_VALUE_FLOAT) {
return left.as.number - right.as.number;
}
else {
break;
}
case TOY_VALUE_STRING:
if (TOY_VALUE_IS_STRING(right)) {
return Toy_compareStrings(TOY_VALUE_AS_STRING(left), TOY_VALUE_AS_STRING(right));
if (right.type == TOY_VALUE_STRING) {
return Toy_compareStrings(left.as.string, right.as.string);
}
case TOY_VALUE_ARRAY:
@@ -300,15 +335,20 @@ int Toy_compareValues(Toy_Value left, Toy_Value right) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "Unknown types in value comparison, exiting\n" TOY_CC_RESET);
exit(-1);
break;
}
return -1;
fprintf(stderr, TOY_CC_ERROR "Unknown types in value comparison, exiting\n" TOY_CC_RESET);
exit(-1);
return ~0;
}
Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) {
value = Toy_unwrapValue(value);
//TODO: could have "constant" strings that can be referenced, instead of null, true, false, etc.
switch(value.type) {
@@ -316,18 +356,18 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) {
return Toy_createString(bucketHandle, "null");
case TOY_VALUE_BOOLEAN:
return Toy_createString(bucketHandle, TOY_VALUE_AS_BOOLEAN(value) ? "true" : "false");
return Toy_createString(bucketHandle, value.as.boolean ? "true" : "false");
case TOY_VALUE_INTEGER: {
char buffer[16];
sprintf(buffer, "%d", TOY_VALUE_AS_INTEGER(value));
sprintf(buffer, "%d", value.as.integer);
return Toy_createString(bucketHandle, buffer);
}
case TOY_VALUE_FLOAT: {
//using printf
char buffer[16];
sprintf(buffer, "%f", TOY_VALUE_AS_FLOAT(value));
sprintf(buffer, "%f", value.as.number);
//BUGFIX: printf format specificer '%f' will set the precision to 6 decimal places, which means there's trailing zeroes
unsigned int length = strlen(buffer);
@@ -343,28 +383,33 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) {
}
case TOY_VALUE_STRING:
return Toy_copyString(TOY_VALUE_AS_STRING(value));
return Toy_copyString(value.as.string);
case TOY_VALUE_ARRAY: {
//TODO: concat + free is definitely a performance nightmare
Toy_Array* array = TOY_VALUE_AS_ARRAY(value);
//TODO: concat + free is definitely a performance nightmare, could make an append function?
Toy_Array* ptr = value.as.array;
Toy_String* string = Toy_createStringLength(bucketHandle, "[", 1);
Toy_String* comma = Toy_createStringLength(bucketHandle, ",", 1); //reusable
for (unsigned int i = 0; i < array->count; i++) {
for (unsigned int i = 0; i < ptr->count; i++) {
//append each element
Toy_String* tmp = Toy_concatStrings(bucketHandle, string, Toy_stringifyValue(bucketHandle, array->data[i])); //increment ref
Toy_String* tmp = Toy_concatStrings(bucketHandle, string, Toy_stringifyValue(bucketHandle, ptr->data[i])); //increment ref
Toy_freeString(string); //decrement ref
string = tmp;
//if we need a comma
if (i + 1 < array->count) {
if (i + 1 < ptr->count) {
Toy_String* tmp = Toy_concatStrings(bucketHandle, string, comma); //increment ref
Toy_freeString(string); //decrement ref
string = tmp;
}
}
//closing bracket
Toy_String* tmp = Toy_concatStrings(bucketHandle, string, Toy_createStringLength(bucketHandle, "]", 1));
Toy_freeString(string);
string = tmp;
//clean up
Toy_freeString(comma); //TODO: reusable global, or string type "permanent"
@@ -376,6 +421,7 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) {
case TOY_VALUE_OPAQUE:
case TOY_VALUE_TYPE:
case TOY_VALUE_ANY:
case TOY_VALUE_REFERENCE:
case TOY_VALUE_UNKNOWN:
fprintf(stderr, TOY_CC_ERROR "Unknown types in value stringify, exiting\n" TOY_CC_RESET);
exit(-1);
@@ -397,6 +443,7 @@ const char* Toy_private_getValueTypeAsCString(Toy_ValueType type) {
case TOY_VALUE_OPAQUE: return "opaque";
case TOY_VALUE_TYPE: return "type";
case TOY_VALUE_ANY: return "any";
case TOY_VALUE_REFERENCE: return "reference";
case TOY_VALUE_UNKNOWN: return "unknown";
}