From 2df588fb6ebc77d067e390e5c70c5da0298a47b2 Mon Sep 17 00:00:00 2001 From: Leo Tenenbaum Date: Wed, 22 Apr 2020 15:04:11 -0400 Subject: improved arr system --- allocator.c | 6 +- cgen.c | 24 +++--- copy.c | 24 +++--- data_structures.c | 222 +++++++++++++++++++++++++++++------------------------- decls_cgen.c | 6 +- eval.c | 43 ++++++----- foreign.c | 2 +- identifiers.c | 2 +- instance_table.c | 10 +-- main.c | 20 +++-- parse.c | 81 +++++++++++--------- tests/test.sh | 5 +- toc.c | 2 +- tokenizer.c | 16 ++-- types.c | 170 ++++++++++++++++++++--------------------- types.h | 9 ++- 16 files changed, 338 insertions(+), 304 deletions(-) diff --git a/allocator.c b/allocator.c index 8baedb5..98005ef 100644 --- a/allocator.c +++ b/allocator.c @@ -74,7 +74,7 @@ static void *allocr_calloc(Allocator *a, size_t n, size_t sz) { #endif if (n == 0 || sz == 0) return NULL; if (a == NULL) return err_calloc(n, sz); - /* OPTIM: use calloc */ + /* @OPTIM: use calloc */ size_t bytes = n * sz; void *data = allocr_malloc(a, bytes); memset(data, 0, bytes); @@ -88,11 +88,11 @@ static void allocr_free(Allocator *a, void *data, size_t size) { if (a == NULL) { free(data); } - /* OPTIM */ + /* @OPTIM */ (void)size; } -/* OPTIM */ +/* @OPTIM */ static void *allocr_realloc(Allocator *a, void *data, size_t old_size, size_t new_size) { #if NO_ALLOCATOR a = NULL; diff --git a/cgen.c b/cgen.c index 6511ce9..08631f5 100644 --- a/cgen.c +++ b/cgen.c @@ -265,7 +265,7 @@ static bool cgen_fn_is_direct(CGenerator *g, Declaration *d) { static bool fn_has_instances(FnExpr *f) { if (fn_has_any_const_params(f)) return true; if (!arr_len(f->params)) return false; - return type_is_builtin(&((Declaration *)arr_last(f->params))->type, BUILTIN_VARARGS); + return type_is_builtin(&arr_last(f->params).type, BUILTIN_VARARGS); } static bool cgen_uses_ptr(Type *t) { @@ -392,7 +392,7 @@ static void cgen_type_post(CGenerator *g, Type *t) { cgen_type_pre(g, x); cgen_write(g, "(*)"); cgen_type_post(g, x); - if (x != arr_last(ret_type->tuple)) { + if (x != arr_last_ptr(ret_type->tuple)) { cgen_write(g, ", "); } } @@ -509,7 +509,7 @@ static void cgen_val_ptr_pre(CGenerator *g, void *v, Type *t) { cgen_val_ptr_pre(g, (char *)s->data + (U64)i * compiler_sizeof(t->slice), t->slice); } cgen_type_pre(g, t->slice); - cgen_write(g, "(d%p_[])", v); /* TODO: improve this somehow? */ + cgen_write(g, "(d%p_[])", v); /* @TODO: improve this somehow? */ cgen_type_post(g, t->slice); cgen_write(g, " = {"); for (I64 i = 0; i < s->len; ++i) { @@ -865,7 +865,7 @@ static void cgen_set_tuple(CGenerator *g, Expression *exprs, Identifier *idents, cgen_ident_id(g, id); cgen_type_post(g, type); cgen_write(g, "; "); - *(IdentID *)arr_add(&underscore_ids) = id; + arr_add(underscore_ids, id); } } } @@ -912,7 +912,7 @@ static void cgen_set_tuple(CGenerator *g, Expression *exprs, Identifier *idents, cgen_write(g, "&(%s%d_)", prefix, i); } } - arr_clear(&underscore_ids); + arr_clear(underscore_ids); cgen_writeln(g, "); "); } break; case EXPR_IF: @@ -1155,7 +1155,7 @@ static void cgen_expr_pre(CGenerator *g, Expression *e) { cgen_nl(g); } break; case EXPR_VAL: - /* TODO: don't make a variable for this if it's not needed */ + /* @TODO: don't make a variable for this if it's not needed */ if (type_is_compileonly(&e->type)) break; if (!cgen_is_type_simple(&e->type)) { @@ -1245,7 +1245,7 @@ static void cgen_expr(CGenerator *g, Expression *e) { Value fn_val = *decl_val_at_index(d, index); FnExpr *fn = fn_val.fn; Expression fn_expr; - /* TODO: is this all really necessary? */ + /* @TODO: is this all really necessary? */ fn_expr.kind = EXPR_FN; fn_expr.fn = allocr_malloc(g->allocr, sizeof *fn_expr.fn); @@ -1784,7 +1784,7 @@ static void cgen_block(CGenerator *g, Block *b, const char *ret_name, U16 flags) --g->indent_lvl; if (!(flags & CGEN_BLOCK_NOBRACES)) { cgen_deferred_from_block(g, b); - arr_clear(&b->deferred); + arr_clear(b->deferred); cgen_write(g, "}"); if (b->c.break_lbl) { cgen_lbl(g, b->c.break_lbl); @@ -2019,7 +2019,7 @@ static void cgen_ret(CGenerator *g, Block *returning_from, Expression *ret_expr) tuple_expr.type = f->ret_type; tuple_expr.kind = EXPR_TUPLE; tuple_expr.tuple = NULL; - arr_set_len(&tuple_expr.tuple, arr_len(f->ret_type.tuple)); + arr_set_len(tuple_expr.tuple, arr_len(f->ret_type.tuple)); int idx = 0; arr_foreach(f->ret_decls, Declaration, d) { arr_foreach(d->idents, Identifier, ident) { @@ -2032,7 +2032,7 @@ static void cgen_ret(CGenerator *g, Block *returning_from, Expression *ret_expr) } } cgen_set_tuple(g, NULL, NULL, "*ret__", &tuple_expr); - arr_clear(&tuple_expr.tuple); + arr_clear(tuple_expr.tuple); } else if (cgen_uses_ptr(&f->ret_type)) { Expression expr = {0}; expr.flags = EXPR_FOUND_TYPE; @@ -2068,7 +2068,7 @@ static void cgen_ret(CGenerator *g, Block *returning_from, Expression *ret_expr) static void cgen_stmt(CGenerator *g, Statement *s) { #ifdef CGEN_EMIT_LINE_NUMBER_COMMENTS - /* TODO: add compiler option for this */ + /* @TODO: add compiler option for this */ cgen_write(g, "/* %s:%d */", s->where.ctx->filename, s->where.line); #endif switch (s->kind) { @@ -2114,7 +2114,7 @@ static void cgen_stmt(CGenerator *g, Statement *s) { cgen_writeln(g, ";"); } break; case STMT_DEFER: - *(Statement **)arr_add(&g->block->deferred) = s->defer; + arr_add(g->block->deferred, s->defer); break; case STMT_USE: case STMT_MESSAGE: diff --git a/copy.c b/copy.c index ec64f54..2c746a1 100644 --- a/copy.c +++ b/copy.c @@ -41,7 +41,7 @@ static void copy_val(Allocator *a, Value *out, Value in, Type *t) { if (t->builtin == BUILTIN_VARARGS) { size_t n = arr_len(in.varargs); out->varargs = NULL; - arr_set_lena(&out->varargs, n, a); + arr_set_lena(out->varargs, n, a); for (size_t i = 0; i < n; ++i) { Copier c = copier_create(a, NULL); /* since the type is resolved, it doesn't matter that the block is wrong */ out->varargs[i].type = copy_type_(&c, in.varargs[i].type); @@ -100,7 +100,7 @@ static void copy_struct(Copier *c, StructDef *out, StructDef *in) { size_t nfields = arr_len(in->fields); out->fields = NULL; - arr_set_lena(&out->fields, nfields, c->allocr); + arr_set_lena(out->fields, nfields, c->allocr); for (size_t i = 0; i < nfields; ++i) { Field *fout = &out->fields[i]; Field *fin = &in->fields[i]; @@ -110,7 +110,7 @@ static void copy_struct(Copier *c, StructDef *out, StructDef *in) { } size_t nparams = arr_len(in->params); out->params = NULL; - arr_set_lena(&out->params, nparams, c->allocr); + arr_set_lena(out->params, nparams, c->allocr); for (size_t i = 0; i < nparams; ++i) { copy_decl(c, &out->params[i], &in->params[i]); } @@ -131,7 +131,7 @@ static void copy_type(Copier *c, Type *out, Type *in) { case TYPE_FN: { size_t ntypes = arr_len(in->fn.types); out->fn.types = NULL; - arr_set_lena(&out->fn.types, ntypes, c->allocr); + arr_set_lena(out->fn.types, ntypes, c->allocr); for (size_t i = 0; i < ntypes; ++i) { copy_type(c, &out->fn.types[i], &in->fn.types[i]); } @@ -139,7 +139,7 @@ static void copy_type(Copier *c, Type *out, Type *in) { case TYPE_TUPLE: { size_t ntypes = arr_len(in->tuple); out->tuple = NULL; - arr_set_lena(&out->tuple, ntypes, c->allocr); + arr_set_lena(out->tuple, ntypes, c->allocr); for (size_t i = 0; i < ntypes; ++i) { copy_type(c, &out->tuple[i], &in->tuple[i]); } @@ -210,13 +210,13 @@ static void copy_fn_expr(Copier *c, FnExpr *fout, FnExpr *fin, U8 flags) { size_t i; size_t nparam_decls = arr_len(fin->params); fout->params = NULL; - arr_set_lena(&fout->params, nparam_decls, c->allocr); + arr_set_lena(fout->params, nparam_decls, c->allocr); for (i = 0; i < nparam_decls; ++i) copy_decl(c, fout->params + i, fin->params + i); size_t nret_decls = arr_len(fin->ret_decls); if (fin->ret_decls) { fout->ret_decls = NULL; - arr_set_lena(&fout->ret_decls, nret_decls, c->allocr); + arr_set_lena(fout->ret_decls, nret_decls, c->allocr); for (i = 0; i < nret_decls; ++i) copy_decl(c, fout->ret_decls + i, fin->ret_decls + i); } @@ -308,7 +308,7 @@ static void copy_expr(Copier *c, Expression *out, Expression *in) { copy_expr(c, cout->fn = allocr_malloc(a, sizeof *cout->fn), cin->fn); size_t nargs = arr_len(cin->args); cout->arg_exprs = NULL; - arr_set_lena(&cout->args, nargs, a); + arr_set_lena(cout->args, nargs, a); for (size_t i = 0; i < nargs; ++i) { Argument *arg_in = &cin->args[i]; Argument *arg_out = &cout->args[i]; @@ -322,7 +322,7 @@ static void copy_expr(Copier *c, Expression *out, Expression *in) { case EXPR_TUPLE: { size_t nexprs = arr_len(in->tuple); out->tuple = NULL; - arr_set_lena(&out->tuple, nexprs, a); + arr_set_lena(out->tuple, nexprs, a); for (size_t i = 0; i < nexprs; ++i) copy_expr(c, out->tuple + i, in->tuple + i); } break; @@ -374,7 +374,7 @@ static void copy_decl(Copier *c, Declaration *out, Declaration *in) { copy_type(c, &out->type, &in->type); out->idents = NULL; size_t nidents = arr_len(in->idents); - arr_set_lena(&out->idents, nidents, c->allocr); + arr_set_lena(out->idents, nidents, c->allocr); for (size_t i = 0; i < nidents; ++i) { out->idents[i] = in->idents[i]; assert(c->block); @@ -399,7 +399,7 @@ static void copy_stmt(Copier *c, Statement *out, Statement *in) { *out->inc = *in->inc; if (in->flags & STMT_TYPED) { size_t nstmts = arr_len(in->inc->stmts); - arr_set_lena(&out->inc->stmts, nstmts, c->allocr); + arr_set_lena(out->inc->stmts, nstmts, c->allocr); for (size_t i = 0; i < nstmts; ++i) { copy_stmt(c, &out->inc->stmts[i], &in->inc->stmts[i]); } @@ -448,7 +448,7 @@ static void copy_block(Copier *c, Block *out, Block *in, U8 flags) { out->ret_expr = copy_expr_(c, in->ret_expr); if (!(flags & COPY_BLOCK_DONT_CREATE_IDENTS)) idents_create(&out->idents, c->allocr, out); - arr_set_lena(&out->stmts, nstmts, c->allocr); + arr_set_lena(out->stmts, nstmts, c->allocr); for (size_t i = 0; i < nstmts; ++i) { copy_stmt(c, &out->stmts[i], &in->stmts[i]); } diff --git a/data_structures.c b/data_structures.c index 9bab854..e16ea0d 100644 --- a/data_structures.c +++ b/data_structures.c @@ -23,7 +23,6 @@ OTHER DEALINGS IN THE SOFTWARE. For more information, please refer to */ -/* OPTIM: is it faster to store void *end? */ typedef struct ArrHeader { size_t len; size_t cap; @@ -31,8 +30,7 @@ typedef struct ArrHeader { } ArrHeader; static inline ArrHeader *arr_hdr(void *arr) { - ArrHeader *hdr = (ArrHeader *)((char *)arr - offsetof(ArrHeader, data)); - return hdr; + return (ArrHeader *)((char *)arr - offsetof(ArrHeader, data)); } static inline size_t arr_len(void *arr) { @@ -44,96 +42,114 @@ static inline void arr_zero_(void *arr, size_t item_sz) { memset(arr, 0, item_sz * arr_len(arr)); } -static void arr_resv_(void **arr, size_t n, size_t item_sz) { - if (*arr == NULL) { - ArrHeader *hdr = err_malloc(item_sz * n + sizeof(ArrHeader) + 1); /* +1 => prevent ptr overflow */ +static WarnUnusedResult void *arr_resv_(void *arr, size_t n, size_t item_sz) { + ArrHeader *hdr; + if (arr == NULL) { + hdr = err_malloc(item_sz * n + sizeof(ArrHeader)); hdr->len = 0; hdr->cap = n; - *arr = hdr->data; } else { - ArrHeader *hdr = arr_hdr(*arr); + hdr = arr_hdr(arr); hdr->cap = n; - hdr = err_realloc(hdr, item_sz * n + sizeof(ArrHeader) + 1); + hdr = err_realloc(hdr, item_sz * n + sizeof(ArrHeader)); if (hdr->len > hdr->cap) hdr->len = hdr->cap; - *arr = hdr->data; } + return hdr->data; } -static void arr_resva_(void **arr, size_t n, size_t item_sz, Allocator *a) { - if (*arr == NULL) { - ArrHeader *hdr = allocr_malloc(a, item_sz * n + sizeof(ArrHeader)); +static WarnUnusedResult void *arr_resva_(void *arr, size_t n, size_t item_sz, Allocator *a) { + ArrHeader *hdr; + if (arr == NULL) { + hdr = allocr_malloc(a, item_sz * n + sizeof(ArrHeader)); hdr->len = 0; hdr->cap = n; - *arr = hdr->data; } else { - ArrHeader *hdr = arr_hdr(*arr); + hdr = arr_hdr(arr); hdr = allocr_realloc(a, hdr, item_sz * hdr->cap + sizeof(ArrHeader), item_sz * n + sizeof(ArrHeader)); hdr->cap = n; if (hdr->len > hdr->cap) hdr->len = hdr->cap; - *arr = hdr->data; - } + } + return hdr->data; } -static void arr_clear_(void **arr) { - if (*arr) { - free(arr_hdr(*arr)); - *arr = NULL; + +/* accommodate one more element if necessary */ +static WarnUnusedResult void *arr_grow(void *arr, size_t item_sz) { + ArrHeader *hdr; + if (arr == NULL) { + hdr = err_malloc(sizeof *hdr + item_sz); + hdr->len = 0; + hdr->cap = 1; + } else { + hdr = arr_hdr(arr); + if (hdr->len >= hdr->cap) { + size_t new_size = sizeof *hdr + item_sz * (hdr->cap *= 2); + hdr = err_realloc(hdr, new_size); + } } + return hdr->data; } -static void arr_cleara_(void **arr, size_t size, Allocator *allocr) { - if (*arr) { - ArrHeader *header = arr_hdr(*arr); +static WarnUnusedResult void *arr_growa(void *arr, size_t item_sz, Allocator *allocr) { + ArrHeader *hdr; + if (arr == NULL) { + hdr = allocr_malloc(allocr, sizeof *hdr + item_sz); + hdr->len = 0; + hdr->cap = 1; + } else { + hdr = arr_hdr(arr); + if (hdr->len >= hdr->cap) { + size_t old_size = sizeof *hdr + item_sz * hdr->cap; + size_t new_size = sizeof *hdr + item_sz * hdr->cap * 2; + hdr = allocr_realloc(allocr, hdr, old_size, new_size); + hdr->cap *= 2; + } + } + return hdr->data; +} + +static WarnUnusedResult void *arr_clear_(void *arr) { + if (arr) { + free(arr_hdr(arr)); + } + return NULL; +} + +static WarnUnusedResult void *arr_cleara_(void *arr, size_t size, Allocator *allocr) { + if (arr) { + ArrHeader *header = arr_hdr(arr); allocr_free(allocr, header, header->cap * size); - *arr = NULL; } + return NULL; } -static void arr_set_len_(void **arr, size_t n, size_t item_sz) { +static WarnUnusedResult void *arr_set_len_(void *arr, size_t n, size_t item_sz) { if (n == 0) { - arr_clear_(arr); - return; + return arr_clear_(arr); } - if (n > arr_len(*arr)) { - arr_resv_(arr, n, item_sz); + if (n > arr_len(arr)) { + arr = arr_resv_(arr, n, item_sz); } - arr_hdr(*arr)->len = n; - /* OPTIM: shrink */ + arr_hdr(arr)->len = n; + /* @OPTIM: shrink */ + return arr; } -static void arr_set_lena_(void **arr, size_t n, size_t item_sz, Allocator *a) { +static WarnUnusedResult void *arr_set_lena_(void *arr, size_t n, size_t item_sz, Allocator *a) { if (n == 0) { - arr_cleara_(arr, item_sz, a); - return; + return arr_cleara_(arr, item_sz, a); } - arr_resva_(arr, n, item_sz, a); - arr_hdr(*arr)->len = n; + arr = arr_resva_(arr, n, item_sz, a); + arr_hdr(arr)->len = n; + return arr; } -static void *arr_add_(void **arr, size_t item_sz) { - ArrHeader *hdr; - if (*arr == NULL) { - arr_resv_(arr, 1, item_sz); - hdr = arr_hdr(*arr); - } else { - hdr = arr_hdr(*arr); - if (hdr->len >= hdr->cap) { - arr_resv_(arr, hdr->len * 2 + 1, item_sz); - hdr = arr_hdr(*arr); - } - } +static void *arr_add_ptr_(void **arr, size_t item_sz) { + *arr = arr_grow(*arr, item_sz); + ArrHeader *hdr = arr_hdr(*arr); return &(((char *)hdr->data)[(hdr->len++) * item_sz]); } -static void *arr_adda_(void **arr, size_t item_sz, Allocator *a) { - ArrHeader *hdr; - if (*arr == NULL) { - arr_resva_(arr, 10, item_sz, a); - hdr = arr_hdr(*arr); - } else { - hdr = arr_hdr(*arr); - if (hdr->len >= hdr->cap) { - arr_resva_(arr, hdr->len * 2 + 1, item_sz, a); - hdr = arr_hdr(*arr); - } - } +static void *arr_adda_ptr_(void **arr, size_t item_sz, Allocator *a) { + *arr = arr_growa(*arr, item_sz, a); + ArrHeader *hdr = arr_hdr(*arr); return &(((char *)hdr->data)[(hdr->len++) * item_sz]); } @@ -156,35 +172,35 @@ static void *arr_end_(void *arr, size_t item_sz) { } } -/* OPTIM: shrink array */ -static void arr_remove_last_(void **arr) { - assert(arr_hdr(*arr)->len); - if (--arr_hdr(*arr)->len == 0) { - arr_clear_(arr); +/* @OPTIM: shrink array */ +static WarnUnusedResult void *arr_remove_last_(void *arr) { + assert(arr_hdr(arr)->len); + if (--arr_hdr(arr)->len == 0) { + return arr_clear_(arr); } + return arr; } -static void arr_remove_lasta_(void **arr, size_t item_sz, Allocator *a) { - assert(arr_hdr(*arr)->len); - if (--arr_hdr(*arr)->len == 0) { - arr_cleara_(arr, item_sz, a); +static WarnUnusedResult void *arr_remove_lasta_(void *arr, size_t item_sz, Allocator *a) { + assert(arr_hdr(arr)->len); + if (--arr_hdr(arr)->len == 0) { + return arr_cleara_(arr, item_sz, a); } + return arr; } -static void arr_copya_(void **out, void *in, size_t item_sz, Allocator *a) { +static WarnUnusedResult void *arr_copya_(void *out, void *in, size_t item_sz, Allocator *a) { size_t len = arr_len(in); - arr_resva_(out, len, item_sz, a); - memcpy(*out, in, len * item_sz); + out = arr_resva_(out, len, item_sz, a); + memcpy(out, in, len * item_sz); + return out; } -#ifdef __GNUC__ -#define typeof __typeof__ -#endif - #if defined(__GNUC__) || defined(__TINYC__) #define HAS_TYPEOF 1 +#define typeof __typeof__ #endif #if HAS_TYPEOF @@ -193,38 +209,42 @@ this is to cast the return value of arr_add so that gcc produces a warning if yo do something like: float *arr = NULL; // ... -int *x = arr_add(&arr); +int *x = arr_add_ptr(&arr); You shouldn't rely on this, though, e.g. by doing -*arr_add(&arr) = 17; +*arr_add_ptr(&arr) = 17; */ -#define arr_ptr_type(arr) __typeof__(*(arr)) +#define arr_ptr_type(arr) typeof(arr) #else #define arr_ptr_type(arr) void * #endif #define arr_zero(arr) arr_zero_(arr, sizeof *(arr)) -#define arr_add(arr) (arr_ptr_type(arr))arr_add_((void **)(arr), sizeof **(arr)) -#define arr_adda(arr, allocr) (arr_ptr_type(arr))arr_adda_((void **)(arr), sizeof **(arr), (allocr)) -#define arr_resv(arr, n) arr_resv_((void **)(arr), n, sizeof **(arr)) -#define arr_resva(arr, n, allocr) arr_resva_((void **)(arr), n, sizeof **(arr), (allocr)) -#define arr_set_len(arr, n) arr_set_len_((void **)(arr), n, sizeof **(arr)) -#define arr_set_lena(arr, n, a) arr_set_lena_((void **)(arr), n, sizeof **(arr), (a)) -#define arr_clear(arr) arr_clear_((void **)(arr)), (void)sizeof **arr /* second part makes sure most of the time that you don't accidentally call it without taking the address */ -#define arr_cleara(arr, allocr) arr_cleara_((void **)(arr), sizeof **(arr), (allocr)) -#define arr_last(arr) arr_last_((void *)(arr), sizeof *(arr)) +#define arr_add(arr, x) arr = arr_grow((arr), sizeof *(arr)), (arr)[arr_hdr(arr)->len++] = x +#define arr_add_ptr(arr) (arr_ptr_type(arr))arr_add_ptr_((void **)(&arr), sizeof *(arr)) +#define arr_adda(arr, x, allocr) arr = arr_growa((arr), sizeof *(arr), (allocr)), (arr)[arr_hdr(arr)->len++] = x +#define arr_adda_ptr(arr, allocr) (arr_ptr_type(arr))arr_adda_ptr_((void **)(&arr), sizeof *(arr), (allocr)) +#define arr_resv(arr, n) arr = arr_resv_((arr), n, sizeof *(arr)) +#define arr_resva(arr, n, allocr) arr = arr_resva_((arr), n, sizeof *(arr), (allocr)) +#define arr_set_len(arr, n) arr = arr_set_len_((arr), n, sizeof *(arr)) +#define arr_set_lena(arr, n, allocr) arr = arr_set_lena_((arr), n, sizeof *(arr), (allocr)) +#define arr_clear(arr) arr = arr_clear_(arr) +#define arr_cleara(arr, allocr) arr = arr_cleara_((arr), sizeof *(arr), (allocr)) +#define arr_last(arr) arr[arr_len(arr)-1] +#define arr_last_ptr(arr) arr_last_((arr), sizeof *(arr)) /* one past last, or NULL if empty */ -#define arr_end(arr) arr_end_((void *)(arr), sizeof *(arr)) +#define arr_end(arr) arr_end_((arr), sizeof *(arr)) #define arr_foreach(arr, type, var) for (type *var = (arr), *var##_foreach_end = arr_end(arr); var != var##_foreach_end; ++var) -#define arr_foreach_reversed(arr, type, var) for (type *var = arr_last(arr), *var##_foreach_last = arr; var; var = var == var##_foreach_last ? NULL : (var-1)) -#define arr_remove_last(arr) arr_remove_last_((void **)(arr)), (void)sizeof **(arr) -#define arr_remove_lasta(arr, a) arr_remove_lasta_((void **)(arr), sizeof **(arr), (a)) -#define arr_copya(out, in, a) do { assert(sizeof *(in) == sizeof **(out)); arr_copya_((void **)(out), (in), sizeof **(out), (a)); } while(0) +#define arr_foreach_reversed(arr, type, var) for (type *var = arr_last_ptr(arr), *var##_foreach_last = arr; var; var = var == var##_foreach_last ? NULL : (var-1)) +#define arr_remove_last(arr) arr = arr_remove_last_(arr) +#define arr_remove_lasta(arr, allocr) arr = arr_remove_lasta_((arr), sizeof *(arr), (allocr)) +#define arr_copya(out, in, allocr) do { assert(sizeof *(in) == sizeof *(out)); out = arr_copya_((out), (in), sizeof *(out), (allocr)); } while(0) -#ifdef RUN_TESTS +#if RUN_TESTS +/* @TODO(eventually): more extensive test? */ static void arr_test(void) { int *foos = NULL; for (int i = 0; i < 10; ++i) { - *(int *)arr_add(&foos) = i; + arr_add(foos, i); } for (int i = 0; i < (int)arr_len(foos); ++i) { assert(foos[i] == i); @@ -234,7 +254,7 @@ static void arr_test(void) { assert(*x == lastx + 1); lastx = *x; } - arr_clear(&foos); + arr_clear(foos); } #endif @@ -281,7 +301,7 @@ static void str_hash_table_grow(StrHashTable *t) { if (slots_cap <= 2 * t->nentries) { StrHashTableSlot **new_slots = NULL; size_t new_slots_cap = slots_cap * 2 + 10; - arr_set_lena(&new_slots, new_slots_cap, t->allocr); + arr_set_lena(new_slots, new_slots_cap, t->allocr); arr_zero(new_slots); arr_foreach(t->slots, StrHashTableSlotPtr, slotp) { StrHashTableSlot *slot = *slotp; @@ -291,7 +311,7 @@ static void str_hash_table_grow(StrHashTable *t) { *new_slot = slot; } } - arr_cleara(&t->slots, t->allocr); + arr_cleara(t->slots, t->allocr); t->slots = new_slots; } } @@ -341,7 +361,7 @@ static void str_hash_table_free(StrHashTable *t) { arr_foreach(t->slots, StrHashTableSlotPtr, slotp) { allocr_free(t->allocr, *slotp, str_hash_table_slot_size(t)); } - arr_cleara(&t->slots, t->allocr); + arr_cleara(t->slots, t->allocr); } static StrHashTableSlot *str_hash_table_get_(StrHashTable *t, const char *str, size_t len) { @@ -357,7 +377,7 @@ static inline void *str_hash_table_get(StrHashTable *t, const char *str, size_t return slot->data; } -#ifdef RUN_TESTS +#if RUN_TESTS static void str_hash_table_test(void) { StrHashTable t; str_hash_table_create(&t, sizeof(int), NULL); diff --git a/decls_cgen.c b/decls_cgen.c index 78f51a3..736df03 100644 --- a/decls_cgen.c +++ b/decls_cgen.c @@ -81,14 +81,14 @@ static void cgen_sdecls_expr(CGenerator *g, Expression *e) { case EXPR_NMS: { char *prefix_part = cgen_nms_prefix_part(g, e->nms); size_t prefix_part_len = strlen(prefix_part); - char const *prev_prefix = g->nms_prefixes ? *(char const **)arr_last(g->nms_prefixes) + char const *prev_prefix = g->nms_prefixes ? arr_last(g->nms_prefixes) : ""; size_t prev_prefix_len = strlen(prev_prefix); char *new_prefix = cgen_malloc(g, prev_prefix_len + prefix_part_len + 1); memcpy(new_prefix, prev_prefix, prev_prefix_len); memcpy(new_prefix + prev_prefix_len, prefix_part, prefix_part_len); free(prefix_part); - *(char const **)arr_add(&g->nms_prefixes) = new_prefix; + arr_add(g->nms_prefixes, new_prefix); new_prefix[prev_prefix_len + prefix_part_len] = 0; e->nms->c.prefix = new_prefix; } break; @@ -98,7 +98,7 @@ static void cgen_sdecls_expr(CGenerator *g, Expression *e) { cgen_recurse_subexprs(g, e, cgen_sdecls_expr, cgen_sdecls_block, cgen_sdecls_decl); } if (e->kind == EXPR_NMS) { - arr_remove_last(&g->nms_prefixes); + arr_remove_last(g->nms_prefixes); } } diff --git a/eval.c b/eval.c index 55c8db6..cb74e0f 100644 --- a/eval.c +++ b/eval.c @@ -205,7 +205,7 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { } break; case TYPE_FN: - fprintf(f, "", (void *)*(FnExpr **)p); + fprintf(f, "", (void *)*(FnExpr **)p); break; case TYPE_TUPLE: { Value *tuple = *(Value **)p; @@ -217,7 +217,7 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { fprintf(f, ")"); } break; case TYPE_ARR: { - fprintf(f, "["); /* TODO: change? when array initializers are added */ + fprintf(f, "["); /* @TODO: change? when array initializers are added */ size_t n = t->arr.n; if (n > 5) n = 5; for (size_t i = 0; i < n; ++i) { @@ -233,7 +233,7 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { fprintf(f, "", *(void **)p); break; case TYPE_SLICE: { - fprintf(f, "["); /* TODO: change? when slice initializers are added */ + fprintf(f, "["); /* @TODO: change? when slice initializers are added */ Slice slice = *(Slice *)p; I64 n = slice.len; if (n > 5) n = 5; @@ -247,7 +247,7 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { fprintf(f, "]"); } break; case TYPE_STRUCT: - fprintf(f, "["); /* TODO: change? when struct initializers are added */ + fprintf(f, "["); /* @TODO: change? when struct initializers are added */ arr_foreach(t->struc->fields, Field, fi) { if (fi != t->struc->fields) fprintf(f, ", "); @@ -670,7 +670,7 @@ static Value *ident_val(Evaluator *ev, Identifier i, Location where) { return NULL; /* silently fail (something went wrong when we typed this decl) */ if (decl->flags & DECL_IS_PARAM) { if (decl->val_stack) { - Value *valp = *(Value **)arr_last(decl->val_stack); + Value *valp = arr_last(decl->val_stack); if (arr_len(decl->idents) > 1) return &valp->tuple[idx]; else @@ -693,7 +693,7 @@ static Value *ident_val(Evaluator *ev, Identifier i, Location where) { } else if (decl->flags & DECL_IS_CONST) { return decl_val_at_index(decl, idx); } else if (decl->val_stack) { - Value *valp = *(Value **)arr_last(decl->val_stack); + Value *valp = arr_last(decl->val_stack); if (arr_len(decl->idents) > 1) return &valp->tuple[idx]; else @@ -1041,8 +1041,8 @@ static Status eval_ident(Evaluator *ev, Identifier ident, Value *v, Location whe } static Value *decl_add_val(Declaration *d) { - Value **valpp = arr_add(&d->val_stack); - Value *valp = *valpp = err_malloc(sizeof *valp); + Value *valp = err_malloc(sizeof *valp); + arr_add(d->val_stack, valp); if (arr_len(d->idents) > 1) { valp->tuple = err_malloc(arr_len(d->idents) * sizeof *valp->tuple); } @@ -1051,8 +1051,7 @@ static Value *decl_add_val(Declaration *d) { static void decl_remove_val(Declaration *d) { assert(arr_len(d->val_stack)); - Value **valpp = arr_last(d->val_stack); - Value *valp = *valpp; + Value *valp = arr_last(d->val_stack); if (arr_len(d->idents) == 1 || d->type.kind == TYPE_TUPLE) { val_free_ptr(valp, &d->type); } else { @@ -1062,7 +1061,7 @@ static void decl_remove_val(Declaration *d) { free(valp->tuple); free(valp); } - arr_remove_last(&d->val_stack); + arr_remove_last(d->val_stack); } static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { @@ -1252,8 +1251,8 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { case EXPR_FOR: { ForExpr *fo = e->for_; Declaration *header = &fo->header; - Value **for_valpp = arr_add(&header->val_stack); - Value *for_valp = *for_valpp = err_malloc(sizeof *for_valp); + Value *for_valp = err_malloc(sizeof *for_valp); + arr_add(header->val_stack, for_valp); /* make a tuple */ Value for_val_tuple[2]; for_valp->tuple = for_val_tuple; @@ -1353,7 +1352,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { ++index->i64; } } - arr_remove_last(&header->val_stack); + arr_remove_last(header->val_stack); free(for_valp); } break; case EXPR_BLOCK: @@ -1435,7 +1434,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { /* set varargs */ pval->varargs = NULL; for (; arg != args_end; ++arg) { - VarArg *varg = arr_add(&pval->varargs); + VarArg *varg = arr_add_ptr(pval->varargs); if (!eval_expr(ev, arg, &varg->val)) return false; varg->type = &arg->type; @@ -1495,7 +1494,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { expr.ident = *ident; if (!eval_expr(ev, &expr, &this_one)) return false; - Value *element = arr_add(&tuple); + Value *element = arr_add_ptr(tuple); Type *type = decl_type_at_index(d, i); copy_val(NULL, element, this_one, type); ++i; @@ -1503,7 +1502,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { } if (arr_len(tuple) == 1) { *v = tuple[0]; - arr_clear(&tuple); + arr_clear(tuple); } else { v->tuple = tuple; } @@ -1544,7 +1543,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { } else { to = n; } - /* TODO: is this the best check? (Go also checks if from > to) */ + /* @TODO: is this the best check? (Go also checks if from > to) */ if (to > n) { err_print(e->where, "Slice index out of bounds (to = %lu, length = %lu).", (unsigned long)to, (unsigned long)n); return false; @@ -1665,7 +1664,7 @@ static Status eval_stmt(Evaluator *ev, Statement *stmt) { break; case STMT_INCLUDE: { Include *i = stmt->inc; - Statement *last_reached = arr_last(i->stmts); + Statement *last_reached = arr_last_ptr(i->stmts); arr_foreach(i->stmts, Statement, sub) { if (!eval_stmt(ev, sub)) return false; @@ -1679,7 +1678,7 @@ static Status eval_stmt(Evaluator *ev, Statement *stmt) { case STMT_MESSAGE: break; case STMT_DEFER: - *(Statement **)arr_add(&ev->typer->block->deferred) = stmt->defer; + arr_add(ev->typer->block->deferred, stmt->defer); break; case STMT_USE: break; @@ -1692,7 +1691,7 @@ static Status eval_block(Evaluator *ev, Block *b, Value *v) { ev->typer->block = b; b->deferred = NULL; bool success = true; - Statement *last_reached = arr_last(b->stmts); + Statement *last_reached = arr_last_ptr(b->stmts); arr_foreach(b->stmts, Statement, stmt) { if (!eval_stmt(ev, stmt)) { success = false; @@ -1735,7 +1734,7 @@ static Status eval_block(Evaluator *ev, Block *b, Value *v) { if (!eval_stmt(ev, stmt)) return false; } - arr_clear(&b->deferred); + arr_clear(b->deferred); ev->returning = return_block; ev->ret_val = return_val; } diff --git a/foreign.c b/foreign.c index 6e25a77..788f87b 100644 --- a/foreign.c +++ b/foreign.c @@ -200,7 +200,7 @@ static bool arg_list_add(av_alist *arg_list, Value val, Type *type, Location whe case TYPE_VOID: case TYPE_TUPLE: case TYPE_UNKNOWN: - case TYPE_ARR: { /* TODO: maybe just pass pointer for arr? */ + case TYPE_ARR: { /* @TODO: maybe just pass pointer for arr? */ char *s = type_to_str(type); err_print(where, "Cannot pass type %s to foreign function.", s); free(s); diff --git a/identifiers.c b/identifiers.c index bb30e36..2daa112 100644 --- a/identifiers.c +++ b/identifiers.c @@ -181,7 +181,7 @@ static inline Block *ident_scope(Identifier i) { return i->idents->scope; } -#ifdef RUN_TESTS +#if RUN_TESTS static void idents_test(void) { Identifiers ids; char b[] = "foo_variable bar"; diff --git a/instance_table.c b/instance_table.c index 6a06f4b..924ac1d 100644 --- a/instance_table.c +++ b/instance_table.c @@ -4,7 +4,7 @@ You should have received a copy of the GNU General Public License along with toc. If not, see . */ /* - TODO: better hash functions, especially for integers + @TODO: better hash functions, especially for integers (right now, nearby integers are close together in hash space, which is bad with the way these hash tables are designed) @@ -22,7 +22,7 @@ static bool val_eq(Value u, Value v, Type *t); static bool type_eq_exact(Type *t1, Type *t2); static U64 f32_hash(F32 f) { - /* OPTIM */ + /* @OPTIM */ U64 hash = 0; if (f < 0) { hash = 0x9a6db29edcba8af4; @@ -48,7 +48,7 @@ static U64 f32_hash(F32 f) { } static U64 f64_hash(F64 f) { - /* OPTIM */ + /* @OPTIM */ U64 hash = 0; if (f < 0) { hash = 0x9a6db29edcba8af4; @@ -306,7 +306,7 @@ static bool val_eq(Value u, Value v, Type *t) { and set already_exists accordingly make sure v's data remains valid */ -/* OPTIM: store instances in a block array (remember that the pointers need to stay valid!) */ +/* @OPTIM: store instances in a block array (remember that the pointers need to stay valid!) */ static Instance *instance_table_adda(Allocator *a, HashTable *h, Value v, Type *t, bool *already_exists) { if (h->n * 2 >= h->cap) { @@ -318,7 +318,7 @@ static Instance *instance_table_adda(Allocator *a, HashTable *h, Value v, Type * for (U64 i = 0; i < h->cap; ++i) { /* re-hash */ if (old_occupied[i]) { - /* OPTIM: keep hashes around */ + /* @OPTIM: keep hashes around */ U64 index = val_hash(old_data[i]->val, t) % new_cap; while (new_occupied[index]) { ++index; diff --git a/main.c b/main.c index 24b1c79..38a014e 100644 --- a/main.c +++ b/main.c @@ -7,9 +7,8 @@ /* see development.md for development information */ /* -TODO: -arr_add_val -arr_last_val +@TODO: +arr_add-val test for use ... test used ret decls consider: don't do inference for function calls; get rid of was_expr -- now that we have struct params @@ -19,6 +18,9 @@ use - use with struct members (e.g. SuperPoint ::= struct { use p: Point; }) maybe change to #define check(x) do { if_unlikely(x) return 0; } while (0); always use pointers in cgen'd non-range for loops (sometimes also indices) +test: + _ := 5; + _ := 6; is there a problem where we can get TYPE_UNKNOWN in cgen, triggering an assert(0)? -simple example, but maybe try other stuff: x := #C("5"); -also make sure you can't do x:#C("5"); @@ -39,6 +41,7 @@ X ::= newtype(int); or something any odd number of "s for a string use point #except x; optional -Wshadow +format errors so that vim/emacs can jump to them --- make sure that floating point literals are exact as possible have some way of doing Infinity and s/qNaN (you can @@ -46,6 +49,8 @@ make sure that floating point literals are exact as possible once you have a bunch of test code: - analyze memory usage by secretly passing __FILE__, __LINE__ to allocr_m/c/realloc - try making more Expression members pointers +- should val_stack be on the allocator? what about temporary arrays? + -->on the contrary, should in_decls be off the allocator? - branch data: #define if(x) bool join(cond, __LINE__) = x; register_branch(__FILE__, __LINE__, cond); if (join(cond, __LINE__)) error on x ::= {return; 3} struct param inference @@ -65,9 +70,9 @@ passing untyped expressions to macros #include "toc.c" #if defined TOC_DEBUG && defined __GNU_LIBRARY__ && defined UNISTD_AVAILABLE -#define BACKTRACE +#define BACKTRACE 1 #endif -#ifdef BACKTRACE +#if BACKTRACE #include #include @@ -104,12 +109,12 @@ static void signal_handler(int num) { } #endif int main(int argc, char **argv) { -#ifdef BACKTRACE +#if BACKTRACE program_name = argv[0]; signal(SIGABRT, signal_handler); signal(SIGSEGV, signal_handler); #endif -#ifdef RUN_TESTS +#if RUN_TESTS printf("running tests...\n"); test_all(); #endif @@ -233,4 +238,3 @@ int main(int argc, char **argv) { fclose(out); return 0; } - diff --git a/parse.c b/parse.c index 8b95aa4..47ea5bf 100644 --- a/parse.c +++ b/parse.c @@ -253,7 +253,7 @@ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { if (def->params) { written += str_copy(buffer + written, bufsize - written, "("); arr_foreach(def->params, Declaration, param) { - /* TODO: val to str */ + /* @TODO: val to str */ if (param != def->params) written += str_copy(buffer + written, bufsize - written, ", "); written += str_copy(buffer + written, bufsize - written, ""); @@ -297,7 +297,7 @@ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { return written; } case TYPE_EXPR: - /* TODO: improve this... we're gonna need expr_to_str ): */ + /* @TODO: improve this... we're gonna need expr_to_str ): */ return str_copy(buffer, bufsize, ""); } @@ -330,11 +330,10 @@ static inline void parser_put_end(Parser *p, Location *l) { parser_set_end_to_token(p, l, p->tokr->token); } -static inline void *parser_arr_add_(Parser *p, void **a, size_t sz) { - return arr_adda_(a, sz, p->allocr); -} - -#define parser_arr_add(p, a) parser_arr_add_(p, (void **)(a), sizeof **(a)) +#define parser_arr_add_ptr(p, a) arr_adda_ptr(a, p->allocr) +#define parser_arr_add(p, a, x) arr_adda(a, x, p->allocr) +#define parser_arr_set_len(p, a, l) arr_set_lena(a, l, p->allocr) +#define parser_arr_remove_last(p, a) arr_remove_lasta(a, p->allocr) static inline void *parser_malloc(Parser *p, size_t bytes) { return allocr_malloc(p->allocr, bytes); @@ -424,14 +423,14 @@ static Token *expr_find_end(Parser *p, ExprEndFlags flags) { } if (token->kind == TOKEN_EOF) { if (brace_level > 0) { - tokr_err(t, "Opening brace { was never closed."); /* TODO: Find out where this is */ + tokr_err(t, "Opening brace { was never closed."); /* @TODO: Find out where this is */ } else if (paren_level > 0) { tokr_err(t, "Opening parenthesis ( was never closed."); } else if (square_level > 0) { tokr_err(t, "Opening square bracket [ was never closed."); } else { tokr_err(t, "Could not find end of expression (did you forget a semicolon?)."); - /* TODO: ? improve err message */ + /* @TODO: ? improve err message */ } t->token = token; /* don't try to continue */ return NULL; @@ -455,7 +454,7 @@ static Status parse_args(Parser *p, Argument **args) { info_print(token_location(p->file, start), "This is where the argument list starts."); return false; } - Argument *arg = parser_arr_add(p, args); + Argument *arg = parser_arr_add_ptr(p, *args); arg->where = parser_mk_loc(p); /* named arguments */ if (t->token->kind == TOKEN_IDENT && token_is_kw(t->token + 1, KW_EQ)) { @@ -485,7 +484,7 @@ static void correct_ret_type(Parser *p, Type *ret_type) { size_t ntuple_members = arr_len(tuple_members); ret_type->kind = TYPE_TUPLE; ret_type->tuple = NULL; - arr_set_lena(&ret_type->tuple, ntuple_members, p->allocr); + parser_arr_set_len(p, ret_type->tuple, ntuple_members); for (size_t i = 0; i < ntuple_members; ++i) { Type *out_type = &ret_type->tuple[i]; out_type->flags = 0; @@ -525,11 +524,11 @@ static Status parse_type(Parser *p, Type *type, Location *where) { tokr_err(t, "Expected ( to follow fn."); return false; } - parser_arr_add(p, &type->fn.types); /* add return type */ + parser_arr_add_ptr(p, type->fn.types); /* add return type */ ++t->token; if (!token_is_kw(t->token, KW_RPAREN)) { while (1) { - Type *param_type = parser_arr_add(p, &type->fn.types); + Type *param_type = parser_arr_add_ptr(p, type->fn.types); Location type_where; if (!parse_type(p, param_type, &type_where)) return false; if (token_is_kw(t->token, KW_RPAREN)) @@ -623,7 +622,7 @@ static Status parse_type(Parser *p, Type *type, Location *where) { goto struct_fail; } if ((param->flags & DECL_ANNOTATES_TYPE) && type_is_builtin(¶m->type, BUILTIN_VARARGS)) { - /* TODO(eventually) */ + /* @TODO(eventually) */ err_print(param->where, "structs cannot have varargs parameters (yet)."); goto struct_fail; } @@ -823,14 +822,14 @@ static Status parse_block(Parser *p, Block *b, U8 flags) { if (!token_is_kw(t->token, KW_RBRACE)) { /* non-empty block */ while (1) { - Statement *stmt = parser_arr_add(p, &b->stmts); + Statement *stmt = parser_arr_add_ptr(p, b->stmts); bool was_a_statement; bool success = parse_stmt(p, stmt, &was_a_statement); if (!success) { ret = false; } if (!was_a_statement) { - arr_remove_lasta(&b->stmts, p->allocr); + parser_arr_remove_last(p, b->stmts); } if (token_is_kw(t->token, KW_RBRACE)) { break; @@ -861,7 +860,7 @@ static Status parse_decl_list(Parser *p, Declaration **decls, U16 flags) { !token_is_kw(t->token - 1, KW_RPAREN) && !token_is_kw(t->token - 1, KW_LBRACE)))) { first = false; - Declaration *decl = parser_arr_add(p, decls); + Declaration *decl = parser_arr_add_ptr(p, *decls); if (!parse_decl(p, decl, flags)) { ret = false; /* skip to end of list */ @@ -873,13 +872,19 @@ static Status parse_decl_list(Parser *p, Declaration **decls, U16 flags) { /* split this declaration */ size_t nidents = arr_len(decl->idents); for (size_t i = 1; i < nidents; ++i) { - Declaration *new_decl = parser_arr_add(p, decls); + Declaration *new_decl = parser_arr_add_ptr(p, *decls); *new_decl = *decl; new_decl->idents = NULL; - arr_set_lena(&new_decl->idents, 1, p->allocr); + parser_arr_set_len(p, new_decl->idents, 1); new_decl->idents[0] = decl->idents[i]; } - arr_set_lena(&decl->idents, 1, p->allocr); + parser_arr_set_len(p, decl->idents, 1); + } + } + /* correct ident decls because the pointers to declarations might have changed */ + arr_foreach(*decls, Declaration, decl) { + arr_foreach(decl->idents, Identifier, ident) { + (*ident)->decl = decl; } } return ret; @@ -1470,8 +1475,10 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { FnType *fn_type = &fn_t->fn; fn_type->constness = NULL; fn_type->types = NULL; - Type *ret_type = parser_arr_add(p, &fn_type->types); - CType *ret_ctype = parser_arr_add(p, &fn->foreign.ctypes); + /* reserve space for return type (Type + CType) */ + parser_arr_add_ptr(p, fn_type->types); + parser_arr_add_ptr(p, fn->foreign.ctypes); + Expression *name = fn->foreign.name_expr = parser_new_expr(p); if (!parse_expr(p, name, expr_find_end(p, EXPR_CAN_END_WITH_COMMA))) @@ -1506,8 +1513,8 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { } ++t->token; while (!token_is_kw(t->token, KW_RPAREN)) { - Type *type = parser_arr_add(p, &fn_type->types); - CType *ctype = parser_arr_add(p, &fn->foreign.ctypes); + Type *type = parser_arr_add_ptr(p, fn_type->types); + CType *ctype = parser_arr_add_ptr(p, fn->foreign.ctypes); if (!parse_c_type(p, ctype, type)) { return false; } @@ -1521,6 +1528,9 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { return false; } } + + Type *ret_type = &fn_type->types[0]; + CType *ret_ctype = &fn->foreign.ctypes[0]; if (t->token == end) { /* void */ ret_ctype->kind = CTYPE_NONE; @@ -1765,14 +1775,14 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { if (lhs.kind == EXPR_TUPLE) { e->tuple = lhs.tuple; } else { - *(Expression *)parser_arr_add(p, &e->tuple) = lhs; + parser_arr_add(p, e->tuple, lhs); } if (rhs.kind == EXPR_TUPLE) { arr_foreach(rhs.tuple, Expression, r) { - *(Expression *)parser_arr_add(p, &e->tuple) = *r; + parser_arr_add(p, e->tuple, *r); } } else { - *(Expression *)parser_arr_add(p, &e->tuple) = rhs; + parser_arr_add(p, e->tuple, rhs); } goto success; } @@ -2042,7 +2052,7 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { e->kind = EXPR_BLOCK; if (!parse_block(p, e->block = parser_malloc(p, sizeof *e->block), 0)) return false; if (t->token != end) { - tokr_err(t, "Expression continues after end of block."); /* TODO: improve this err message */ + tokr_err(t, "Expression continues after end of block."); /* @TODO: improve this err message */ return false; } goto success; @@ -2114,14 +2124,13 @@ static Status parse_decl(Parser *p, Declaration *d, U16 flags) { } while (1) { - Identifier *ident = parser_arr_add(p, &d->idents); if (t->token->kind != TOKEN_IDENT) { tokr_err(t, "Cannot declare non-identifier (%s).", token_kind_to_str(t->token->kind)); goto ret_false; } - *ident = parser_ident_insert(p, t->token->ident); - if (!(flags & PARSE_DECL_DONT_SET_IDECLS) && !ident_eq_str(*ident, "_")) { - Identifier i = *ident; + Identifier i = parser_ident_insert(p, t->token->ident); + parser_arr_add(p, d->idents, i); + if (!(flags & PARSE_DECL_DONT_SET_IDECLS) && !ident_eq_str(i, "_")) { if (!check_ident_redecl(p, i)) goto ret_false; i->decl = d; @@ -2425,7 +2434,7 @@ static Status parse_stmt(Parser *p, Statement *s, bool *was_a_statement) { d->where = s->where; parser_put_end(p, &d->where); /* we haven't set s->where.end, so... */ d->flags |= DECL_HAS_EXPR|DECL_IS_CONST; - *(Identifier *)parser_arr_add(p, &d->idents) = ident; + parser_arr_add(p, d->idents, ident); if (!check_ident_redecl(p, ident)) { tokr_skip_semicolon(t); @@ -2443,7 +2452,7 @@ static Status parse_stmt(Parser *p, Statement *s, bool *was_a_statement) { body->where = s->where; body->parent = p->block; idents_create(&body->idents, p->allocr, body); - Statement *inc_stmt = parser_arr_add(p, &body->stmts); + Statement *inc_stmt = parser_arr_add_ptr(p, body->stmts); inc_stmt->kind = STMT_INCLUDE; inc_stmt->flags = STMT_INC_TO_NMS; inc_stmt->where = s->where; @@ -2533,11 +2542,11 @@ static Status parse_file(Parser *p, ParsedFile *f) { bool ret = true; while (t->token->kind != TOKEN_EOF) { bool was_a_statement; - Statement *stmt = parser_arr_add(p, &f->stmts); + Statement *stmt = parser_arr_add_ptr(p, f->stmts); if (!parse_stmt(p, stmt, &was_a_statement)) ret = false; if (!was_a_statement) - arr_remove_lasta(&f->stmts, p->allocr); + parser_arr_remove_last(p, f->stmts); if (token_is_kw(t->token, KW_RBRACE)) { tokr_err(t, "} without a matching {."); return false; diff --git a/tests/test.sh b/tests/test.sh index 8df4c46..a603767 100755 --- a/tests/test.sh +++ b/tests/test.sh @@ -51,7 +51,7 @@ do_tests() { printf '\x1b[92mpassed!\x1b[0m\n' else printf '\x1b[91mfailed!\x1b[0m\n' - failed=true + exit 1 fi done } @@ -60,6 +60,3 @@ for x in $tests; do done rm got a.out out.c -if $failed; then - exit 1 -fi diff --git a/toc.c b/toc.c index e51ed8d..5536dd8 100644 --- a/toc.c +++ b/toc.c @@ -138,7 +138,7 @@ static void cgen_sdecls_file(CGenerator *g, ParsedFile *f); #include "cgen.c" #include "decls_cgen.c" -#ifdef RUN_TESTS +#if RUN_TESTS #include "tests.c" #endif diff --git a/tokenizer.c b/tokenizer.c index f155b9f..cdbebd8 100644 --- a/tokenizer.c +++ b/tokenizer.c @@ -7,7 +7,7 @@ static inline const char *kw_to_str(Keyword k) { return keywords[k]; } /* Returns KW_COUNT if it's not a keyword */ -/* OPTIM: don't use strncmp so much */ +/* @OPTIM: don't use strncmp so much */ static Keyword tokenize_kw(char **s) { for (Keyword k = 0; k < KW_COUNT; k = k + 1) { size_t len = strlen(keywords[k]); @@ -127,7 +127,7 @@ static inline int char_as_hex_digit(char c) { /* returns -1 if escape sequence is invalid */ static int tokr_esc_seq(Tokenizer *t) { - /* TODO: octal (\032)? */ + /* @TODO: octal (\032)? */ switch (*t->s) { case '\'': tokr_nextchar(t); @@ -251,7 +251,7 @@ until everything is done */ static void tokr_create(Tokenizer *t, ErrCtx *err_ctx, Allocator *allocr) { t->tokens = NULL; - arr_resva(&t->tokens, 256, allocr); + arr_resva(t->tokens, 256, allocr); t->allocr = allocr; t->err_ctx = err_ctx; } @@ -261,7 +261,7 @@ static inline void *tokr_malloc(Tokenizer *t, size_t bytes) { } static Token *tokr_add(Tokenizer *t) { - Token *token = arr_adda(&t->tokens, t->allocr); + Token *token = arr_adda_ptr(t->tokens, t->allocr); tokr_put_start_pos(t, token); return token; } @@ -328,7 +328,7 @@ static Status tokenize_file(Tokenizer *t, File *file) { tokr_put_end_pos(t, &token); token.kind = TOKEN_DIRECT; token.direct = direct; - *(Token *)arr_adda(&t->tokens, t->allocr) = token; + arr_adda(t->tokens, token, t->allocr); continue; } --t->s; /* go back to # */ @@ -345,7 +345,7 @@ static Status tokenize_file(Tokenizer *t, File *file) { tokr_put_end_pos(t, &token); token.kind = TOKEN_KW; token.kw = kw; - *(Token *)arr_adda(&t->tokens, t->allocr) = token; + arr_adda(t->tokens, token, t->allocr); continue; } } @@ -407,7 +407,7 @@ static Status tokenize_file(Tokenizer *t, File *file) { n->kind = NUM_LITERAL_FLOAT; n->floatval = (Floating)n->intval; } - /* TODO: check if exceeding maximum exponent */ + /* @TODO: check if exceeding maximum exponent */ int exponent = 0; if (*t->s == '+') tokr_nextchar(t); /* ignore + after e */ @@ -421,7 +421,7 @@ static Status tokenize_file(Tokenizer *t, File *file) { exponent *= 10; exponent += *t->s - '0'; } - /* OPTIM: Slow for very large exponents (unlikely to happen) */ + /* @OPTIM: Slow for very large exponents (unlikely to happen) */ for (int i = 0; i < exponent; ++i) { if (negative_exponent) n->floatval /= 10; diff --git a/types.c b/types.c index 4e87ac8..7437a9c 100644 --- a/types.c +++ b/types.c @@ -19,18 +19,17 @@ static inline void *typer_calloc(Typer *tr, size_t n, size_t sz) { return allocr_calloc(tr->allocr, n, sz); } -static inline void *typer_arr_add_(Typer *tr, void **arr, size_t sz) { - return arr_adda_(arr, sz, tr->allocr); -} +#define typer_arr_add(tr, a, x) arr_adda(a, x, tr->allocr) +#define typer_arr_add_ptr(tr, a) arr_adda_ptr(a, tr->allocr) static inline void typer_block_enter(Typer *tr, Block *b) { - *(Block **)arr_adda(&tr->blocks, tr->allocr) = b; + typer_arr_add(tr, tr->blocks, b); tr->block = b; } static inline void typer_block_exit(Typer *tr) { - arr_remove_lasta(&tr->blocks, tr->allocr); - tr->block = *(Block **)arr_last(tr->blocks); + arr_remove_lasta(tr->blocks, tr->allocr); + tr->block = arr_last(tr->blocks); } static inline void construct_resolved_builtin_type(Type *t, BuiltinType builtin) { @@ -183,7 +182,6 @@ static size_t compiler_sizeof(Type *t) { } -#define typer_arr_add(tr, a) typer_arr_add_(tr, (void **)(a), sizeof **(a)) /* are a and b EXACTLY equal (not counting flags)? */ static bool type_eq_exact(Type *a, Type *b) { assert(a->flags & TYPE_IS_RESOLVED); @@ -448,7 +446,7 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { t->kind = TYPE_FN; t->fn.types = NULL; - t->fn.constness = NULL; /* OPTIM: constness doesn't need to be a dynamic array */ + t->fn.constness = NULL; /* @OPTIM: constness doesn't need to be a dynamic array */ t->flags = 0; bool success = true; bool entered_fn = false; @@ -456,7 +454,7 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { FnExpr *prev_fn = tr->fn; FnExpr fn_copy = {0}; - Declaration *last_param = arr_last(f->params); + Declaration *last_param = arr_last_ptr(f->params); bool has_varargs = last_param && (last_param->flags & DECL_ANNOTATES_TYPE) && type_is_builtin(&last_param->type, BUILTIN_VARARGS); if (has_varargs) f->flags |= FN_EXPR_HAS_VARARGS; @@ -469,7 +467,8 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { } size_t idx = 0; bool has_constant_params = false; - Type *ret_type = typer_arr_add(tr, &t->fn.types); + /* reserve space for return type */ + typer_arr_add_ptr(tr, t->fn.types); tr->fn = f; typer_block_enter(tr, &f->body); f->body.uses = NULL; @@ -516,12 +515,12 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { if (!t->fn.constness) { has_constant_params = true; for (size_t i = 0; i < idx; ++i) { - *(Constness *)typer_arr_add(tr, &t->fn.constness) = CONSTNESS_NO; + typer_arr_add(tr, t->fn.constness, CONSTNESS_NO); } } } for (size_t i = 0; i < arr_len(param->idents); ++i) { - Type *param_type = typer_arr_add(tr, &t->fn.types); + Type *param_type = typer_arr_add_ptr(tr, t->fn.types); if (param->flags & (DECL_ANNOTATES_TYPE|DECL_FOUND_TYPE)) *param_type = param->type; else @@ -535,7 +534,7 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { } else { constn = CONSTNESS_NO; } - *(Constness *)typer_arr_add(tr, &t->fn.constness) = constn; + typer_arr_add(tr, t->fn.constness, constn); } ++idx; } @@ -560,7 +559,7 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { f->ret_type.tuple = NULL; arr_foreach(f->ret_decls, Declaration, d) { arr_foreach(d->idents, Identifier, i) { - *(Type *)arr_add(&f->ret_type.tuple) = d->type; + typer_arr_add(tr, f->ret_type.tuple, d->type); } } } @@ -596,7 +595,11 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { } t->flags |= TYPE_IS_RESOLVED; } - *ret_type = f->ret_type; + + { + Type *ret_type = &t->fn.types[0]; + *ret_type = f->ret_type; + } ret: /* cleanup */ @@ -619,7 +622,8 @@ top:; Block *decl_scope = ident_scope(i); if (decl_scope->kind != BLOCK_NMS) { /* go back through scopes */ - for (Block **block = arr_last(tr->blocks); *block && *block != decl_scope; --block) { + arr_foreach_reversed(tr->blocks, BlockPtr, block) { + if (*block == NULL || *block == decl_scope) break; if ((*block)->kind == BLOCK_FN) { captured = true; break; @@ -717,7 +721,7 @@ static Status add_block_to_struct(Typer *tr, Block *b, StructDef *s, Statement * err_print(d->where, "struct members can't be inferred."); return false; } - *(Statement *)typer_arr_add(tr, new_stmts) = *stmt; + typer_arr_add(tr, *new_stmts, *stmt); } else { if (flags & DECL_SEMI_CONST) { err_print(d->where, "struct members can't be semi-constant."); @@ -729,14 +733,14 @@ static Status add_block_to_struct(Typer *tr, Block *b, StructDef *s, Statement * } int i = 0; arr_foreach(d->idents, Identifier, ident) { - Field *field = typer_arr_add(tr, &s->fields); + Field *field = typer_arr_add_ptr(tr, s->fields); field->where = d->where; field->name = *ident; field->type = decl_type_at_index(d, i); ++i; } - *(Statement *)typer_arr_add(tr, new_stmts) = *stmt; + typer_arr_add(tr, *new_stmts, *stmt); } if (b != &s->body) { /* we need to translate d's identifiers to s's scope */ @@ -861,8 +865,7 @@ static Status type_resolve(Typer *tr, Type *t, Location where) { } if (!eval_expr(tr->evalr, sub, &typeval)) return false; - Type *subtype = typer_arr_add(tr, &tuple); - *subtype = *typeval.type; + typer_arr_add(tr, tuple, *typeval.type); } if (is_tuple_of_types) { t->kind = TYPE_TUPLE; @@ -1058,7 +1061,7 @@ static CastStatus type_cast_status(Type *from, Type *to) { return CAST_STATUS_NONE; if (to->kind == TYPE_FN) return CAST_STATUS_WARN; - /* TODO: Cast from ptr to arr */ + /* @TODO: Cast from ptr to arr */ return CAST_STATUS_ERR; case TYPE_ARR: return CAST_STATUS_ERR; @@ -1239,7 +1242,7 @@ static Status call_arg_param_order(FnExpr *fn, Type *fn_type, Argument *args, Lo } } this_param = param; - if (param > (Declaration *)arr_last(fn->params)) { + if (param > (Declaration *)arr_last_ptr(fn->params)) { err_print(arg->where, "Too many arguments to function!"); info_print(fn->where, "Declaration is here."); return false; @@ -1411,7 +1414,7 @@ static Value get_builtin_val(BuiltinVal val) { case BUILTIN_SIZEOF_SIZE_T: v.i64 = (I64)sizeof(size_t); break; - /* TODO(eventually): fix these for cross compilation */ + /* @TODO(eventually): fix these for cross compilation */ case BUILTIN_TSIZEOF_SHORT: v.i64 = (I64)sizeof(short); break; @@ -1518,7 +1521,7 @@ static Status get_struct_constant(StructDef *struc, Identifier member, Expressio } static bool fn_type_has_varargs(FnType *f) { - return type_is_builtin(arr_last(f->types), BUILTIN_VARARGS); + return type_is_builtin(arr_last_ptr(f->types), BUILTIN_VARARGS); } static Status types_expr(Typer *tr, Expression *e) { @@ -1573,7 +1576,7 @@ static Status types_expr(Typer *tr, Expression *e) { ForExpr *fo = e->for_; Declaration *header = &fo->header; - *(Declaration **)typer_arr_add(tr, &tr->in_decls) = header; + typer_arr_add(tr, tr->in_decls, header); fo->body.uses = NULL; typer_block_enter(tr, &fo->body); bool annotated_index = true; @@ -1588,13 +1591,13 @@ static Status types_expr(Typer *tr, Expression *e) { annotated_index = false; assert(nidents == 1); /* turn value := arr to value, _ := arr to simplify things */ - *(Identifier *)arr_add(&header->idents) = ident_insert_with_len(typer_get_idents(tr), "_", 1); + typer_arr_add(tr, header->idents, ident_insert_with_len(typer_get_idents(tr), "_", 1)); } } Type *fo_type_tuple = NULL; /* fo_type is (val_type, index_type) */ - arr_set_lena(&fo_type_tuple, 2, tr->allocr); + arr_set_lena(fo_type_tuple, 2, tr->allocr); memset(fo_type_tuple, 0, 2*sizeof *fo_type_tuple); Type *val_type = &fo_type_tuple[0]; Type *index_type = &fo_type_tuple[1]; @@ -1741,7 +1744,7 @@ static Status types_expr(Typer *tr, Expression *e) { case BUILTIN_VARARGS: { /* exit for body */ typer_block_exit(tr); - arr_remove_lasta(&tr->in_decls, tr->allocr); + arr_remove_lasta(tr->in_decls, tr->allocr); /* create one block, containing a block for each vararg */ /* e.g. for x := varargs { total += x; } => { { x := varargs[0]; total += x; } { x := varargs[0]; total += x; } } */ assert(fo->of->kind == EXPR_IDENT); @@ -1756,7 +1759,7 @@ static Status types_expr(Typer *tr, Expression *e) { b->stmts = NULL; b->parent = tr->block; b->where = e->where; - arr_set_lena(&b->stmts, nvarargs, tr->allocr); + arr_set_lena(b->stmts, nvarargs, tr->allocr); Statement *stmt = b->stmts; size_t nstmts = arr_len(fo->body.stmts); Declaration *header_decl = &fo->header; @@ -1779,10 +1782,10 @@ static Status types_expr(Typer *tr, Expression *e) { sub->stmts = NULL; sub->where = e->where; size_t total_nstmts = nstmts + has_val + has_index; - arr_set_lena(&sub->stmts, total_nstmts, tr->allocr); + arr_set_lena(sub->stmts, total_nstmts, tr->allocr); Copier copier = copier_create(tr->allocr, sub); if (has_val) { - /* TODO(eventually): don't put a decl in each block, just put one at the start */ + /* @TODO(eventually): don't put a decl in each block, just put one at the start */ Statement *s = &sub->stmts[0]; s->flags = 0; s->kind = STMT_DECL; @@ -1792,7 +1795,7 @@ static Status types_expr(Typer *tr, Expression *e) { Declaration *decl = s->decl = typer_calloc(tr, 1, sizeof *decl); decl->where = fo->of->where; Identifier ident = ident_translate_forced(val_ident, &sub->idents); - *(Identifier *)arr_adda(&decl->idents, tr->allocr) = ident; + typer_arr_add(tr, decl->idents, ident); ident->decl = decl; decl->flags |= DECL_HAS_EXPR; @@ -1806,7 +1809,7 @@ static Status types_expr(Typer *tr, Expression *e) { index->where = fo->of->where; } if (has_index) { - /* TODO(eventually): don't put a decl in each block, just put one at the start */ + /* @TODO(eventually): don't put a decl in each block, just put one at the start */ Statement *s = &sub->stmts[has_val]; s->flags = 0; s->kind = STMT_DECL; @@ -1816,7 +1819,7 @@ static Status types_expr(Typer *tr, Expression *e) { Declaration *decl = s->decl = typer_calloc(tr, 1, sizeof *decl); decl->where = fo->of->where; Identifier ident = ident_translate_forced(index_ident, &sub->idents); - *(Identifier *)arr_adda(&decl->idents, tr->allocr) = ident; + typer_arr_add(tr, decl->idents, ident); ident->decl = decl; decl->flags |= DECL_HAS_EXPR; @@ -1870,7 +1873,7 @@ static Status types_expr(Typer *tr, Expression *e) { } else *val_type = *iter_type; } - arr_remove_lasta(&tr->in_decls, tr->allocr); + arr_remove_lasta(tr->in_decls, tr->allocr); in_header = false; assert(header->type.flags & TYPE_IS_RESOLVED); @@ -1891,7 +1894,7 @@ static Status types_expr(Typer *tr, Expression *e) { }break; for_fail: if (in_header) - arr_remove_lasta(&tr->in_decls, tr->allocr); + arr_remove_lasta(tr->in_decls, tr->allocr); typer_block_exit(tr); return false; } @@ -1900,7 +1903,7 @@ static Status types_expr(Typer *tr, Expression *e) { Identifier i = e->ident; bool undeclared = true; while (1) { /* for each block we are inside... */ - /* OPTIM: only hash once */ + /* @OPTIM: only hash once */ Identifier translated = ident_translate(i, b ? &b->idents : tr->globals); if (ident_is_declared(translated)) { #if 0 @@ -2175,7 +2178,7 @@ static Status types_expr(Typer *tr, Expression *e) { return false; } Type *arg_types = NULL; - arr_set_len(&arg_types, nparams); + arr_set_len(arg_types, nparams); Value *arg_vals = typer_malloc(tr, nparams * sizeof *arg_vals); ErrCtx *err_ctx = tr->err_ctx; size_t p = 0; @@ -2184,10 +2187,10 @@ static Status types_expr(Typer *tr, Expression *e) { bool is_tuple = arr_len(param->idents) > 1; int ident_idx = 0; /* temporarily add this instance to the stack, while we type the decl, in case you, e.g., pass t = float to struct(t::Type, u::t = "hello") */ - *(Location *)arr_add(&err_ctx->instance_stack) = e->where; + arr_add(err_ctx->instance_stack, e->where); typer_block_enter(tr, &struc.body); bool success = types_decl(tr, param); - arr_remove_last(&err_ctx->instance_stack); + arr_remove_last(err_ctx->instance_stack); typer_block_exit(tr); if (!success) return false; @@ -2211,7 +2214,7 @@ static Status types_expr(Typer *tr, Expression *e) { return false; } if (is_tuple) - *(Value *)arr_adda(¶m_val.tuple, tr->allocr) = ident_val; + typer_arr_add(tr, param_val.tuple, ident_val); else param_val = ident_val; arg_vals[p] = ident_val; @@ -2249,12 +2252,12 @@ static Status types_expr(Typer *tr, Expression *e) { Type struct_t = {0}; struct_t.kind = TYPE_STRUCT; struct_t.struc = &inst->struc; - *(Location *)arr_add(&err_ctx->instance_stack) = e->where; + arr_add(err_ctx->instance_stack, e->where); Block *prev_block = tr->block; tr->block = &inst->struc.body; bool success = type_resolve(tr, &struct_t, e->where); /* resolve the struct */ tr->block = prev_block; - arr_remove_last(&err_ctx->instance_stack); + arr_remove_last(err_ctx->instance_stack); if (!success) return false; inst->struc.instance_id = table->n; @@ -2269,7 +2272,7 @@ static Status types_expr(Typer *tr, Expression *e) { e->typeval->struc = &inst->struc; t->kind = TYPE_BUILTIN; t->builtin = BUILTIN_TYPE; - arr_clear(&arg_types); + arr_clear(arg_types); goto ret; } fn_decl = val.fn; @@ -2302,11 +2305,11 @@ static Status types_expr(Typer *tr, Expression *e) { } arg_exprs = NULL; - arr_set_lena(&arg_exprs, narg_exprs, tr->allocr); + arr_set_lena(arg_exprs, narg_exprs, tr->allocr); if (fn_decl && !is_foreign) { size_t i = 0; - Declaration *last_param = arr_last(fn_decl->params); + Declaration *last_param = arr_last_ptr(fn_decl->params); arr_foreach(fn_decl->params, Declaration, param) { if (has_varargs && param == last_param) continue; arr_foreach(param->idents, Identifier, ident) { @@ -2375,7 +2378,7 @@ static Status types_expr(Typer *tr, Expression *e) { long arg_out_idx = arg_out - arg_exprs; /* save and restore arg_out to prevent realloc from causing problems */ /* add more room (or if nvarargs_here == 0, remove room) for more varargs */ - arr_set_lena(&arg_exprs, narg_exprs, tr->allocr); + arr_set_lena(arg_exprs, narg_exprs, tr->allocr); arg_out = arg_exprs + arg_out_idx; for (size_t i = 0; i < nvarargs_here; ++i) { VarArg *vararg = &varargs_here[i]; @@ -2431,8 +2434,8 @@ static Status types_expr(Typer *tr, Expression *e) { if (has_varargs) { /* set value of varargs param decl */ VarArg *varargs = NULL; - arr_set_lena(&varargs, nvarargs, tr->allocr); - Declaration *varargs_param = arr_last(fn_copy->params); + arr_set_lena(varargs, nvarargs, tr->allocr); + Declaration *varargs_param = arr_last_ptr(fn_copy->params); DeclFlags is_const = varargs_param->flags & DECL_IS_CONST; varargs_param->val.varargs = varargs; for (int v = 0; v < (int)nvarargs; ++v) { @@ -2469,16 +2472,13 @@ static Status types_expr(Typer *tr, Expression *e) { arr_foreach(fn->params, Declaration, param) { arr_foreach(param->idents, Identifier, ident) { if (param->flags & DECL_INFER) { - *(Identifier *)arr_add(&inferred_idents) = *ident; + arr_add(inferred_idents, *ident); } else if ((param->flags & DECL_ANNOTATES_TYPE) && !type_is_builtin(¶m->type, BUILTIN_VARARGS)) { /* add to stuff infer can use */ - Type **p = arr_add(&decl_types); - *p = ¶m->type; - Type **q = arr_add(&arg_types); - *q = &arg_exprs[i].type; - Location *l = arr_add(&arg_wheres); - *l = arg_exprs[i].where; + arr_add(decl_types, ¶m->type); + arr_add(arg_types, &arg_exprs[i].type); + arr_add(arg_wheres, arg_exprs[i].where); } ++i; } @@ -2496,9 +2496,9 @@ static Status types_expr(Typer *tr, Expression *e) { } tr->block = prev; - arr_clear(&inferred_idents); - arr_clear(&arg_types); - arr_clear(&decl_types); + arr_clear(inferred_idents); + arr_clear(arg_types); + arr_clear(decl_types); { Type *type = inferred_types; @@ -2628,13 +2628,13 @@ static Status types_expr(Typer *tr, Expression *e) { table_index_type.flags = TYPE_IS_RESOLVED; table_index_type.kind = TYPE_TUPLE; table_index_type.tuple = NULL; - Type *u64t = typer_arr_add(tr, &table_index_type.tuple); + Type *u64t = typer_arr_add_ptr(tr, table_index_type.tuple); u64t->was_expr = NULL; u64t->flags = TYPE_IS_RESOLVED; u64t->kind = TYPE_BUILTIN; u64t->builtin = BUILTIN_U64; table_index.tuple = NULL; - Value *which_are_const_val = typer_arr_add(tr, &table_index.tuple); + Value *which_are_const_val = typer_arr_add_ptr(tr, table_index.tuple); U64 *which_are_const = &which_are_const_val->u64; *which_are_const = 0; int semi_const_index = 0; @@ -2645,8 +2645,8 @@ static Status types_expr(Typer *tr, Expression *e) { Copier cop = copier_create(tr->allocr, tr->block); if (is_vararg) { /* create one additional table index member for varargs */ - Value *varargs_val = typer_arr_add(tr, &table_index.tuple); - Type *varargs_type = typer_arr_add(tr, &table_index_type.tuple); + Value *varargs_val = typer_arr_add_ptr(tr, table_index.tuple); + Type *varargs_type = typer_arr_add_ptr(tr, table_index_type.tuple); memset(varargs_type, 0, sizeof *varargs_type); varargs_type->flags = TYPE_IS_RESOLVED; varargs_type->kind = TYPE_BUILTIN; @@ -2654,7 +2654,7 @@ static Status types_expr(Typer *tr, Expression *e) { varargs_val->varargs = NULL; for (; i < narg_exprs; ++i) { arg = &arg_exprs[i]; - VarArg *varg = typer_arr_add(tr, &varargs_val->varargs); + VarArg *varg = typer_arr_add_ptr(tr, varargs_val->varargs); varg->type = copy_type_(&cop, &arg->type); if (is_const) { copy_val(tr->allocr, &varg->val, arg->val, varg->type); @@ -2673,8 +2673,8 @@ static Status types_expr(Typer *tr, Expression *e) { *which_are_const |= ((U64)1) << semi_const_index; ++semi_const_index; } - Value *v = typer_arr_add(tr, &table_index.tuple); - Type *type = typer_arr_add(tr, &table_index_type.tuple); + Value *v = typer_arr_add_ptr(tr, table_index.tuple); + Type *type = typer_arr_add_ptr(tr, table_index_type.tuple); copy_type(&cop, type, &arg->type); copy_val(tr->allocr, v, arg->val, type); } @@ -2682,8 +2682,8 @@ static Status types_expr(Typer *tr, Expression *e) { bool instance_already_exists; c->instance = instance_table_adda(tr->allocr, original_fn->instances, table_index, &table_index_type, &instance_already_exists); if (instance_already_exists) { - arr_cleara(&table_index_type.tuple, tr->allocr); - arr_cleara(&table_index.tuple, tr->allocr); + arr_cleara(table_index_type.tuple, tr->allocr); + arr_cleara(table_index.tuple, tr->allocr); } else { c->instance->fn = fn_copy; /* fix parameter and return types (they were kind of problematic before, because we didn't know about the instance) */ @@ -2692,12 +2692,12 @@ static Status types_expr(Typer *tr, Expression *e) { /* if anything happens, make sure we let the user know that this happened while generating a fn */ ErrCtx *err_ctx = e->where.file->ctx; - *(Location *)typer_arr_add(tr, &err_ctx->instance_stack) = e->where; + typer_arr_add(tr, err_ctx->instance_stack, e->where); Block *prev_block = tr->block; tr->block = fn_copy->body.parent; bool success = types_fn(tr, c->instance->fn, &f->type, c->instance); tr->block = prev_block; - arr_remove_lasta(&err_ctx->instance_stack, tr->allocr); + arr_remove_lasta(err_ctx->instance_stack, tr->allocr); if (!success) return false; } @@ -3156,10 +3156,9 @@ static Status types_expr(Typer *tr, Expression *e) { t->kind = TYPE_TUPLE; t->tuple = NULL; arr_foreach(e->tuple, Expression, x) { - Type *x_type = typer_arr_add(tr, &t->tuple); if (!types_expr(tr, x)) return false; - *x_type = x->type; + typer_arr_add(tr, t->tuple, x->type); } break; case EXPR_SLICE: { @@ -3258,14 +3257,14 @@ static Status types_block(Typer *tr, Block *b) { goto ret; } } else { - if (s != (Statement *)arr_last(b->stmts)) { + if (s != (Statement *)arr_last_ptr(b->stmts)) { err_print(e->where, "Return value must be the last statement in a block."); success = false; goto ret; } b->ret_expr = typer_malloc(tr, sizeof *b->ret_expr); *b->ret_expr = *e; - arr_remove_lasta(&b->stmts, tr->allocr); + arr_remove_lasta(b->stmts, tr->allocr); } } @@ -3293,8 +3292,7 @@ static Status types_decl(Typer *tr, Declaration *d) { d->type.flags = 0; return true; } - Declaration **dptr = typer_arr_add(tr, &tr->in_decls); - *dptr = d; + typer_arr_add(tr, tr->in_decls, d); if (d->flags & DECL_ANNOTATES_TYPE) { /* type supplied */ assert(d->type.kind != TYPE_VOID); /* there's no way to annotate void */ @@ -3407,7 +3405,11 @@ static Status types_decl(Typer *tr, Declaration *d) { arr_foreach(d->idents, Identifier, ip) { Identifier i = *ip; /* add to uses */ - Use **usep = arr_add(tr->block ? &tr->block->uses : &tr->uses); + Use **usep; + if (tr->block) + usep = typer_arr_add_ptr(tr, tr->block->uses); + else + usep = typer_arr_add_ptr(tr, tr->uses); Use *use = *usep = typer_calloc(tr, 1, sizeof *use); Expression *used = &use->expr; used->kind = EXPR_IDENT; @@ -3421,7 +3423,6 @@ static Status types_decl(Typer *tr, Declaration *d) { if (n_idents == 1 && (d->flags & DECL_HAS_EXPR) && d->expr.kind == EXPR_NMS) { bool is_at_top_level = true; - typedef Block *BlockPtr; arr_foreach(tr->blocks, BlockPtr, b) { if (*b && (*b)->kind != BLOCK_NMS) { is_at_top_level = false; @@ -3448,7 +3449,7 @@ static Status types_decl(Typer *tr, Declaration *d) { d->type.was_expr = NULL; d->type.kind = TYPE_UNKNOWN; } - arr_remove_lasta(&tr->in_decls, tr->allocr); + arr_remove_lasta(tr->in_decls, tr->allocr); return success; } @@ -3644,8 +3645,10 @@ static Status types_stmt(Typer *tr, Statement *s) { err_print(e->where, "You can't use this value. You should probably assign it to a variable."); return false; } - Use **up = arr_add(tr->block ? &tr->block->uses : &tr->uses); - *up = u; + if (tr->block) + typer_arr_add(tr, tr->block->uses, u); + else + typer_arr_add(tr, tr->uses, u); } break; } s->flags |= STMT_TYPED; @@ -3663,7 +3666,7 @@ static void typer_create(Typer *tr, Evaluator *ev, File *file, ErrCtx *err_ctx, tr->in_decls = NULL; tr->allocr = allocr; tr->globals = idents; - *(Block **)arr_adda(&tr->blocks, allocr) = NULL; + typer_arr_add(tr, tr->blocks, NULL); str_hash_table_create(&tr->included_files, sizeof(IncludedFile), tr->allocr); } @@ -3676,7 +3679,6 @@ static Status types_file(Typer *tr, ParsedFile *f) { ret = false; } } - arr_clear(&tr->uses); assert(tr->block == NULL); assert(arr_len(tr->blocks) && tr->blocks[0] == NULL); return ret; diff --git a/types.h b/types.h index ed8d792..92a4a5c 100644 --- a/types.h +++ b/types.h @@ -68,11 +68,13 @@ typedef U8 bool; #endif #if defined __GNUC__ && !defined NO_WARN_UNUSED_RESULT -#define Status bool __attribute__((warn_unused_result)) +#define WarnUnusedResult __attribute__((warn_unused_result)) #else -#define Status bool +#define WarnUnusedResult #endif +#define Status bool WarnUnusedResult + typedef int8_t I8; #define I8_MAX INT8_MAX typedef int16_t I16; @@ -493,6 +495,7 @@ typedef struct Block { struct Statement **deferred; /* deferred stuff from this block; used by both eval and cgen */ struct Use **uses; /* use statements (for types.c) */ } Block; +typedef Block *BlockPtr; enum { STRUCT_DEF_FOUND_OFFSETS = 0x01, @@ -873,7 +876,7 @@ typedef struct Declaration { /* for eval, for non-constant local decls: */ /* the pointers to values need to be fixed, which is why this isn't just Value *. */ - /* OPTIM: some block array of values somewhere which we can just use a pointer to, which is freed when the block is exited? */ + /* @OPTIM: some block array of values somewhere which we can just use a pointer to, which is freed when the block is exited? */ Value **val_stack; } Declaration; typedef Declaration *DeclarationPtr; -- cgit v1.2.3