From 965c77016beb7798f898b47a31869f4d2e182c66 Mon Sep 17 00:00:00 2001 From: nisstyre56 Date: Sun, 13 Jul 2014 00:55:23 -0400 Subject: [PATCH] updated makefile, start closure RTS code --- Makefile | 18 +++++++-- closures.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++ closures.h | 58 +++++++++++++++++++++++++++ error.h | 1 + tokenize.c | 35 ++++++++-------- 5 files changed, 206 insertions(+), 20 deletions(-) create mode 100644 closures.c create mode 100644 closures.h create mode 100644 error.h diff --git a/Makefile b/Makefile index a81c10d..9c703e3 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,15 @@ -schreammake: tokenize.c - gcc -DNDEBUG -c -fPIC -O3 -Wall -Wextra -pedantic -Wpointer-arith -Werror --std=c99 ./tokenize.c; - gcc -lmaa -shared -o tokenize.so tokenize.o; +$(CC)=clang + +default: tokenize.c closures.c + $(CC) -DNDEBUG -c -fPIC -Wall -Wextra -pedantic -Wpointer-arith -Werror --std=c99 -O3 ./tokenize.c + $(CC) -lmaa -shared -o tokenize.so tokenize.o; + + $(CC) -DNDEBUG -c -fPIC -Wall -Wextra -pedantic -Wpointer-arith -Werror --std=c99 -O3 ./closures.c; + $(CC) -shared -o closures.so closures.o; + +debug: tokenize.c closures.c + $(CC) -g -c -fPIC -Wall -Wextra -pedantic -Wpointer-arith -Werror --std=c99 ./tokenize.c; + $(CC) -lmaa -shared -o tokenize.so tokenize.o; + + $(CC) -g -c -fPIC -Wall -Wextra -pedantic -Wpointer-arith -Werror --std=c99 ./closures.c; + $(CC) -shared -o closures.so closures.o; diff --git a/closures.c b/closures.c new file mode 100644 index 0000000..49f98dd --- /dev/null +++ b/closures.c @@ -0,0 +1,114 @@ +#include +#include +#include +#include "error.h" +#include "closures.h" + +inline svalue_t * +box_value(svalue_variants_t value, + stype_t type) { + + svalue_t *val = malloc(sizeof(svalue_t)); + CHECK(val); + switch (type) { + case INT: + val->value = value; + val->type_tag = type; + break; + case FLOAT: + val->value = value; + val->type_tag = type; + break; + case DOUBLE: + val->value = value; + val->type_tag = type; + case STRING: + val->value = value; + val->type_tag = type; + } + return val; +} + +svalue_t * +box_int(int x) { + svalue_t *val = malloc(sizeof(svalue_t)); + CHECK(val); + svalue_variants_t value_val; + value_val.integer = x; + val = box_value(value_val, INT); + return val; +} + +inline svalue_t * +box_float(float x) { + svalue_t *val = malloc(sizeof(svalue_t)); + CHECK(val); + svalue_variants_t value_val; + value_val.floating = x; + val = box_value(value_val, FLOAT); + return val; +} + +inline svalue_t * +box_double(double x) { + svalue_t *val = malloc(sizeof(svalue_t)); + CHECK(val); + svalue_variants_t value_val; + value_val.doublev = x; + val = box_value(value_val, DOUBLE); + return val; +} + +inline svalue_t * +box_string(char *chars, size_t n) { + sc_string_t strval; + strval.string = chars; + strval.size = n; + + svalue_t *val = malloc(sizeof(svalue_t)); + CHECK(val); + + svalue_variants_t value_val; + value_val.string = strval; + val = box_value(value_val, STRING); + return val; +} + + +inline closure_t +make_closure(svalue_t *(*func)(svalue_t, svalue_t*), + svalue_t *fvars) { + closure_t closure; + closure.func = func; + closure.fvars = fvars; + return closure; +} + +inline svalue_t* +invoke(closure_t closure, svalue_t val) { + svalue_t *(*func)(svalue_t, svalue_t*) = closure.func; + return func(val, closure.fvars); +} + +/*static svalue_t* +make_adder_inner(svalue_t x, svalue_t *env) { + svalue_variants_t val; + val.integer = env[0].value.integer + x.value.integer; + return box_value(val, INT); +} + +static closure_t +make_adder(svalue_t *inc) { + closure_t closure = make_closure(make_adder_inner, inc); + return closure; +}*/ + +/*int +main(void) { + closure_t add2 = make_adder(box_int(2)); + printf("%d\n", invoke(add2, *box_int(5))->value.integer); + (void)box_float; + (void)box_double; + (void)box_string; + return 0; +}*/ diff --git a/closures.h b/closures.h new file mode 100644 index 0000000..6fd1a20 --- /dev/null +++ b/closures.h @@ -0,0 +1,58 @@ +typedef + struct { + size_t size; + char* string; + } sc_string_t; + +typedef + union { + sc_string_t string; + double doublev; + int integer; + float floating; + struct closure_t *closure; + } svalue_variants_t; + +typedef + enum { + INT = 0, + FLOAT = 1, + DOUBLE = 2, + STRING = 3 + } stype_t; + +typedef + struct { + stype_t type_tag; + svalue_variants_t value; + } svalue_t; + +typedef + struct { + svalue_t *(*func)(svalue_t, svalue_t*); + svalue_t *fvars; + } closure_t; + +typedef + struct { + svalue_t head; + struct cell *tail; + } + cell; + +svalue_t * +box_value(svalue_variants_t, stype_t); + +closure_t +make_closure(svalue_t* (*func)(svalue_t, svalue_t*), + svalue_t*); + +svalue_t* +invoke(closure_t, svalue_t); + +/*static svalue_t* +make_adder_inner(svalue_t, svalue_t *); + +static closure_t +make_adder(svalue_t *); +*/ diff --git a/error.h b/error.h new file mode 100644 index 0000000..24bfcc3 --- /dev/null +++ b/error.h @@ -0,0 +1 @@ +#define CHECK(ptr) if ((ptr) == NULL) { printf("Failed to allocate memory\n"); exit(EXIT_FAILURE); } diff --git a/tokenize.c b/tokenize.c index 9133076..c44a0cb 100644 --- a/tokenize.c +++ b/tokenize.c @@ -5,6 +5,7 @@ #include #include #include +#include "error.h" #include "maa.h" #include "tokenize.h" @@ -13,7 +14,7 @@ * it also tokenizes things like number, string, and symbol literals */ -static const token_t nulltok = { +const token_t nulltok = { .token_type = EMPTY, { .null_token=false @@ -61,7 +62,7 @@ string_head(uint32_t n, assert(n > 0 && n <= in_len); int iserror = snprintf(out, (size_t)n+1 , "%s", in); - assert((iserror != -1) && (iserror == in_len)); + assert((iserror != -1) && ((size_t)iserror == in_len)); if (iserror == -1) { printf("Out of memory"); @@ -89,7 +90,7 @@ push_token(token_stream *tokens, size_t len; size_t max; - assert(tokens != NULL); + CHECK(tokens); len = tokens->length; max = tokens->max_length; @@ -120,13 +121,13 @@ push_token(token_stream *tokens, bool pop_token(token_stream *tokens) { size_t len; - assert(tokens != NULL); + CHECK(tokens); len = tokens->length; assert(len != 0); len--; - assert(tokens->tokens != NULL); + CHECK(tokens->tokens); tokens->length--; return true; @@ -139,7 +140,7 @@ peek_token(token_stream *tokens) { */ size_t len = tokens->length; size_t max = tokens->max_length; - assert(tokens != NULL); + CHECK(tokens); assert(len != 0); if (len == 0 || len > max) { @@ -157,7 +158,7 @@ match_int(source_t source, */ uint32_t i = begin; uint32_t test; - assert(source != NULL); + CHECK(source); assert(length > 0); if (source[i] == '+' || @@ -192,7 +193,7 @@ match_float(source_t source, * ALWAYS returns the position + 1 to avoid confusion with false (which is a valid index) */ uint32_t i, leading_int_match, trailing_int_match; - assert(source != NULL); + CHECK(source); assert(length > 0); i = begin; @@ -242,7 +243,7 @@ match_identifier(source_t source, * return false */ uint32_t i = begin; - assert(source != NULL); + CHECK(source); assert(length > 0); while (i < length && @@ -264,7 +265,7 @@ match_symbol(source_t source, uint32_t begin, const uint32_t length) { uint32_t i; - assert(source != NULL); + CHECK(source); assert(length > 0); i = begin; @@ -316,7 +317,7 @@ tokenize(source_t source, assert(begin == 0); assert(length > 0); - assert(source != NULL); + CHECK(source); token_stack.length = 0; token_stack.max_length = STACK_SIZE; @@ -353,7 +354,7 @@ tokenize(source_t source, source[position] = lookahead; assert(position > begin); current_token_val = calloc(((position - begin) + 1), sizeof(char)); - assert(current_token_val != NULL); + CHECK(current_token_val); extract_token(position, begin, source, current_token_val); hsh_insert(token_stack.memo, current_token_val, current_token_val); current_token.floating = current_token_val; @@ -374,7 +375,7 @@ tokenize(source_t source, source[position] = lookahead; current_token_val = calloc(((position - begin) + 1), sizeof(char)); - assert(current_token_val != NULL); + CHECK(current_token_val); extract_token(position, begin, source, current_token_val); hsh_insert(token_stack.memo, current_token_val, current_token_val); current_token.integer = current_token_val; @@ -395,7 +396,7 @@ tokenize(source_t source, source[position] = lookahead; current_token_val = calloc(((position - begin) + 1), sizeof(char)); - assert(current_token_val != NULL); + CHECK(current_token_val); extract_token(position, begin, source, current_token_val); hsh_insert(token_stack.memo, current_token_val, current_token_val); current_token.symbol = current_token_val; @@ -421,7 +422,7 @@ tokenize(source_t source, source[position] = lookahead; current_token_val = calloc(((position - begin) + 1), sizeof(char)); - assert(current_token_val != NULL); + CHECK(current_token_val); extract_token(position, begin, source, current_token_val); hsh_insert(token_stack.memo, current_token_val, current_token_val); current_token.identifier = current_token_val; @@ -457,8 +458,8 @@ release_tokens(token_stream *tokens) { /* Iterate through the stack, release each token * Then release the entire stack */ - assert(tokens != NULL); - assert(tokens->tokens != NULL); + CHECK(tokens); + CHECK(tokens->tokens); assert(tokens->max_length > 0); free(tokens->tokens); hsh_iterate(tokens->memo, free_token);