X-Git-Url: https://code.kerkeslager.com/?a=blobdiff_plain;f=templates%2Fprogram.c;h=18d861690d109f09d07f5afab181a3f1f618e508;hb=bca87656ab93d4b99b4b007bfd54580bdb19f9dc;hp=25bb41348abf3a3454cad00da4c08e6cf51aca44;hpb=151f60b119247efb1bcf05a664f4324b71fac782;p=fur diff --git a/templates/program.c b/templates/program.c index 25bb413..18d8616 100644 --- a/templates/program.c +++ b/templates/program.c @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -34,6 +35,8 @@ struct Environment; typedef struct Environment Environment; struct EnvironmentPool; typedef struct EnvironmentPool EnvironmentPool; +struct Stack; +typedef struct Stack Stack; const char* const STRING_LITERAL_LIST[] = { {% for string_literal in string_literal_list %} @@ -55,6 +58,7 @@ enum Type LIST, STRING_CONCATENATION, STRING_LITERAL, + STRUCTURE, VOID }; @@ -63,7 +67,7 @@ typedef struct Closure Closure; struct Closure { Environment* closed; - Object (*call)(EnvironmentPool*, Environment*, size_t, Object*); + Object (*call)(EnvironmentPool*, Environment*, size_t, Stack*, jmp_buf); }; struct List; @@ -78,6 +82,16 @@ struct List struct StringConcatenation; typedef struct StringConcatenation StringConcatenation; +struct Structure; +typedef struct Structure Structure; +struct Structure +{ + size_t reference_count; + size_t length; + const char** symbol_list; + Object* value_list; +}; + union Instance { bool boolean; @@ -86,6 +100,7 @@ union Instance List list; StringConcatenation* string_concatenation; const char* string_literal; + Structure* structure; }; struct Object @@ -137,6 +152,90 @@ Object List_get(Object* list, Object index) return list->instance.list.items[index.instance.integer]; } +struct Stack +{ + uint16_t length; + Object items[256]; +}; + +void Stack_initialize(Stack* self) +{ + self->length = 0; +} + +void Stack_push(Stack* self, Object item) +{ + assert(self->length < 256); + self->items[self->length] = item; + self->length++; +} + +Object Stack_pop(Stack* self) +{ + assert(self->length > 0); + self->length--; + return self->items[self->length]; +} + +Object Object_rereference(Object self) +{ + switch(self.type) + { + case BOOLEAN: + case CLOSURE: + case INTEGER: + case STRING_LITERAL: + case VOID: + return self; + + case STRING_CONCATENATION: + self.instance.string_concatenation->referenceCount++; + return self; + + case STRUCTURE: + self.instance.structure->reference_count++; + return self; + + default: + assert(false); + } +} + +Object Structure_construct(size_t length, const char** symbol_list, Object* value_list) +{ + Structure* structure = malloc(sizeof(Structure)); + structure->reference_count = 1; + structure->length = length; + structure->symbol_list = malloc(sizeof(const char*) * length); + structure->value_list = malloc(sizeof(Object) * length); + + // TODO Don't allow assignment of mutable structures, as this screws up reference counting + for(size_t i = 0; i < length; i++) + { + structure->symbol_list[i] = symbol_list[i]; + structure->value_list[i] = Object_rereference(value_list[i]); + } + + Object result = { STRUCTURE, (Instance)structure }; + + return result; +} + +Object Structure_get(Object* self, const char* symbol) +{ + assert(self->type == STRUCTURE); + + for(size_t i = 0; i < self->instance.structure->length; i++) + { + if(self->instance.structure->symbol_list[i] == symbol) + { + return self->instance.structure->value_list[i]; + } + } + + assert(false); +} + struct EnvironmentNode { const char* key; @@ -197,6 +296,21 @@ void Object_deinitialize(Object* self) } break; + case STRUCTURE: + self->instance.structure->reference_count--; + + if(self->instance.structure->reference_count == 0) + { + for(size_t i = 0; i < self->instance.structure->length; i++) + { + Object_deinitialize(&(self->instance.structure->value_list[i])); + } + free(self->instance.structure->symbol_list); + free(self->instance.structure->value_list); + free(self->instance.structure); + } + break; + default: assert(false); } @@ -431,13 +545,13 @@ Object operator$negate(Object input) } // TODO Make this conditionally added -Object operator$concatenate(Object left, Object right) +Object operator$concatenate(Stack* stack, jmp_buf parent_jump) { + Object right = Stack_pop(stack); + Object left = Stack_pop(stack); + switch(left.type) { case STRING_CONCATENATION: - left.instance.string_concatenation->referenceCount++; - break; - case STRING_LITERAL: break; @@ -447,9 +561,6 @@ Object operator$concatenate(Object left, Object right) switch(right.type) { case STRING_CONCATENATION: - right.instance.string_concatenation->referenceCount++; - break; - case STRING_LITERAL: break; @@ -459,19 +570,30 @@ Object operator$concatenate(Object left, Object right) StringConcatenation* concatenation = malloc(sizeof(StringConcatenation)); concatenation->referenceCount = 1; - concatenation->left = left; - concatenation->right = right; + concatenation->left = Object_rereference(left); + concatenation->right = Object_rereference(right); Object result = { STRING_CONCATENATION, (Instance)concatenation }; return result; } {% for id in infix_declarations %} -Object operator${{ id.name }}(Object left, Object right) +Object operator${{ id.name }}(Stack* stack, jmp_buf parent_jump) { + Object right = Stack_pop(stack); + Object left = Stack_pop(stack); + assert(left.type == {{ id.in_type.upper() }}); assert(right.type == {{ id.in_type.upper() }}); + {% if id.name == 'integerDivide' or id.name == 'modularDivide' %} + if(right.instance.integer == 0) + { + fprintf(stderr, "DivisionByZeroError\n"); + longjmp(parent_jump, 1); + } + {% endif %} + Object result; result.type = {{ id.out_type.upper() }}; result.instance.{{ id.out_type.lower() }} = left.instance.{{ id.in_type.lower() }} {{ id.operator }} right.instance.{{ id.in_type.lower() }}; @@ -480,12 +602,11 @@ Object operator${{ id.name }}(Object left, Object right) {% endfor %} {% if 'pow' in builtins %} -Object builtin$pow$implementation(EnvironmentPool* environmentPool, Environment* parent, size_t argc, Object* args) +Object builtin$pow$implementation(EnvironmentPool* environmentPool, Environment* parent, size_t argc, Stack* stack, jmp_buf parent_jump) { - assert(argc == 2); - - Object base = args[0]; - Object exponent = args[1]; + // Must unload items in reverse order + Object exponent = Stack_pop(stack); + Object base = Stack_pop(stack); assert(base.type == INTEGER); assert(exponent.type == INTEGER); @@ -500,11 +621,19 @@ Object builtin$pow = { CLOSURE, (Instance)(Closure){ NULL, builtin$pow$implement {% endif %} {% if 'print' in builtins %} -Object builtin$print$implementation(EnvironmentPool* environmentPool, Environment* parent, size_t argc, Object* args) +Object builtin$print$implementation(EnvironmentPool* environmentPool, Environment* parent, size_t argc, Stack* stack, jmp_buf parent_jump) { + Stack reverse_stack; + Stack_initialize(&reverse_stack); + for(size_t i = 0; i < argc; i++) { - Object output = args[i]; + Stack_push(&reverse_stack, Stack_pop(stack)); + } + + while(reverse_stack.length > 0) + { + Object output = Stack_pop(&reverse_stack); switch(output.type) { case BOOLEAN: @@ -521,8 +650,10 @@ Object builtin$print$implementation(EnvironmentPool* environmentPool, Environmen break; case STRING_CONCATENATION: - builtin$print$implementation(NULL, NULL, 1, &(output.instance.string_concatenation->left)); - builtin$print$implementation(NULL, NULL, 1, &(output.instance.string_concatenation->right)); + Stack_push(stack, output.instance.string_concatenation->left); + builtin$print$implementation(NULL, NULL, 1, stack, parent_jump); + Stack_push(stack, output.instance.string_concatenation->right); + builtin$print$implementation(NULL, NULL, 1, stack, parent_jump); break; case STRING_LITERAL: @@ -556,6 +687,21 @@ int main(int argc, char** argv) Environment* environment = EnvironmentPool_allocate(environmentPool); Environment_initialize(environment, NULL); + Stack stackMemory; + Stack* stack = &stackMemory; + Stack_initialize(stack); + + jmp_buf jump; + if(setjmp(jump) != 0) + { + fprintf(stderr, "\tin __main__\n"); + Environment_setLive(environment, false); + EnvironmentPool_destruct(environmentPool); + + // TODO We would like to return something nonzero here, but that messes up Valgrind so we couldn't catch memory leaks + return 0; + } + // TODO Use the symbol from SYMBOL_LIST {% for builtin in builtins %} Environment_set(environment, "{{ builtin }}", builtin${{ builtin }});