diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/doer.c | 106 | ||||
| -rw-r--r-- | src/include/doer.h | 1 | ||||
| -rw-r--r-- | src/include/tree.h | 3 | ||||
| -rw-r--r-- | src/main.c | 39 | ||||
| -rw-r--r-- | src/tree.c | 57 |
5 files changed, 162 insertions, 44 deletions
@@ -351,66 +351,84 @@ void doer_do_call(doer_t* doer) { if (!resolved) { doer->tree = the_call; - target_def = doer_find_target_from_call(doer); // Is def. - - tree_t* darg = target_def->data.def.arg; - LOG_DBGF("------------------------------"); - tree_print(darg, 0); + resolved = doer_do_call_target(doer); + } + + target_print(doer->targets); + + tree_swp_call(the_call, resolved); + tree_destroy(the_call); + doer->tree = resolved; +} +tree_t* doer_do_call_target(doer_t* doer) { + tree_t* the_call = doer->tree; + tree_t* target_def = doer_find_target_from_call(doer); // Is def. - tree_t* carg = the_call->data.call.arg; + tree_t* resolution; - target_t - * targs = NULL, // Pointer to first target. - * targ = targs; // Pointer to where new targets will be added. + tree_t* darg = target_def->data.def.arg; + tree_t* carg = the_call->data.call.arg; - // Evaluate arguments. - while (darg) { - doer->tree = carg->data.carg.val; - // HACK: Assume already a primitive. - tree_t* carg_resolved = doer->tree; //doer_eval_prim(doer); + LOG_DBG("DARG:\n"); + tree_print(darg, 0); - char - * darg_type = darg->data.darg.tag->data.tag.val, - * carg_type = tree_type2str(carg_resolved->type); + LOG_DBG("CARG:\n"); + tree_print(carg, 0); - if (strcmp(darg_type, carg_type)) DIE("Type mismatch."); + target_t + * targs = NULL, // Pointer to first target. + * targ = targs; // Pointer to where new targets will be added. - targ = target_init( - "This field doesn't actually do anything but I can't be bothered to remove it :P", - carg_resolved - ); + // Evaluate arguments. + while (darg) { + doer->tree = carg->data.carg.val; + // HACK: Assume already a primitive. + tree_t* carg_resolved = doer->tree; //doer_eval_prim(doer); - targ = targ->nxt; - darg = darg->data.darg.nxt; + char + * darg_type = darg->data.darg.tag->data.tag.val, + * carg_type = tree_type2str(carg_resolved->type); - printf("\n\n[---\n"); - for (target_t* t = doer->targets; t; printf("%s\n", t->tree->data.def.tag->data.tag.nxt->data.tag.val) && (t = t->nxt)); - printf("---]\n"); - } + if (strcmp(darg_type, carg_type)) DIE("Type mismatch."); + + tree_t* carg_tree_def = tree_init(TREE_TYPE_DEF, NULL); + tree_t* carg_tree_def_arg1 = carg_tree_def->data.def.tag = tree_init(TREE_TYPE_TAG, carg_tree_def); // Type. + carg_tree_def_arg1->data.tag.val = darg_type; // Get type of the definition arg. + tree_t* carg_tree_def_arg2 = carg_tree_def_arg1->data.tag.nxt = tree_init(TREE_TYPE_TAG, carg_tree_def_arg1); // Name. + carg_tree_def_arg2->data.tag.val = darg->data.darg.tag->data.tag.nxt->data.tag.val; // Get the name of the definition arg. - target_t* old_ltarget = doer->ltarget; + targ = target_init( + "This field doesn't actually do anything but I can't be bothered to remove it :P", + carg_tree_def + ); - // Append the new targets from the args. - doer->ltarget->nxt = targs; - doer->ltarget = targ; + targ = targ->nxt; + darg = darg->data.darg.nxt; - // Execute the call. - doer->tree = target_def->data.def.val; - printf("[---\n"); + printf("\n\n[---\n"); for (target_t* t = doer->targets; t; printf("%s\n", t->tree->data.def.tag->data.tag.nxt->data.tag.val) && (t = t->nxt)); printf("---]\n"); - resolved = doer_eval_prim(doer); - - // Clean up temporary targets. - target_destroy(targs); - old_ltarget->nxt = NULL; - doer->ltarget = old_ltarget; } - tree_swp_call(the_call, resolved); - tree_destroy(the_call); - doer->tree = resolved; + target_t* old_ltarget = doer->ltarget; + + // Append the new targets from the args. + doer->ltarget->nxt = targs; + doer->ltarget = targ; + + // Execute the call. + doer->tree = target_def->data.def.val; + printf("[---\n"); + for (target_t* t = doer->targets; t; printf("%s\n", t->tree->data.def.tag->data.tag.nxt->data.tag.val) && (t = t->nxt)); + printf("---]\n"); + + // Clean up temporary targets. + target_destroy(targs); + old_ltarget->nxt = NULL; + doer->ltarget = old_ltarget; + + return doer_eval_prim(doer); } tree_t* doer_do_call_blin(doer_t* doer) { diff --git a/src/include/doer.h b/src/include/doer.h index 24f3911..4cc2391 100644 --- a/src/include/doer.h +++ b/src/include/doer.h @@ -82,6 +82,7 @@ static tree_type_t blin_mul_args[] = { TREE_TYPE_LINT, TREE_TYPE_LINT }; void doer_do_call(doer_t* doer); tree_t* doer_do_call_blin(doer_t* doer); tree_t* doer_do_call_def(doer_t* doer); +tree_t* doer_do_call_target(doer_t* doer); tree_t* doer_do_carg(doer_t* doer); void doer_do_block(doer_t* tree); void doer_do_expr(doer_t* tree); diff --git a/src/include/tree.h b/src/include/tree.h index d22efc1..5208080 100644 --- a/src/include/tree.h +++ b/src/include/tree.h @@ -92,6 +92,9 @@ void tree_rm(tree_t* t); tree_t* tree_copy_out(tree_t* tree); +// Copies a tree to `dest`. +void tree_cpy(tree_t** dest, tree_t* src); + /* Compare two trees. For testing. Returns 1 if the same, otherwise 0. @@ -1,8 +1,47 @@ #include "include/main.h" #include "include/doer.h" +#include "../test/include/test.h" + +void test_tree_cpy() { + tree_t* tree_block = tree_init(TREE_TYPE_BLOCK, NULL); + tree_t* tree_lstr = tree_block->data.block.val = tree_init(TREE_TYPE_LSTR, tree_block); + char* char_lstr = tree_lstr->data.lstr.val = calloc(12, sizeof(char)); + strcpy(char_lstr, "hello world"); + tree_lstr->data.lstr.len = 11; + tree_t* tree_block2 = tree_block->data.block.nxt = tree_init(TREE_TYPE_BLOCK, tree_block); + tree_t* tree_def = tree_block2->data.block.val = tree_init(TREE_TYPE_DEF, tree_block2); + tree_t* tree_tag = tree_def->data.def.tag = tree_init(TREE_TYPE_TAG, tree_def); + char* char_tag = tree_tag->data.tag.val = calloc(4, sizeof(char)); + strcpy(char_tag, "int"); + tree_tag->data.tag.nxt = NULL; + tree_t* tree_darg = tree_def->data.def.arg = tree_init(TREE_TYPE_DARG, tree_def); + tree_t* tree_tag2 = tree_darg->data.darg.tag = tree_init(TREE_TYPE_TAG, tree_darg); + char* char_tag2 = tree_tag2->data.tag.val = calloc(4, sizeof(char)); + strcpy(char_tag2, "int"); + tree_tag2->data.tag.nxt = NULL; + tree_darg->data.darg.nxt = NULL; + tree_t* tree_lint = tree_def->data.def.val = tree_init(TREE_TYPE_LINT, tree_def); + tree_lint->data.lint.val = 42; + tree_block2->data.block.nxt = NULL; + + tree_t* t2 = malloc(sizeof(tree_t)); + + tree_cpy(&t2, tree_block); + + printf(tree_cmp(tree_block, t2)?"yes":"no"); + + tree_print(tree_block, 0); + tree_print(t2, 0); + + + printf(&t2 != &tree_block ?"yes":"no"); +} + /* FIXME: Segfaults ~30% of the time. No idea why. Thx future self <3. */ int main(int argc, char* argv[]) { + test_tree_cpy(); + return 0; char* src; pp_t* pp; lexer_t* lexer; @@ -113,11 +113,68 @@ void tree_destroy(tree_t* tree) { free(tree); } +void tree_cpy(tree_t** dest, tree_t* src) { + if (!src) { *dest = NULL; return; } + + *dest = malloc(sizeof(tree_t)); + + memcpy(&(*dest)->data, &src->data, sizeof(union TREE_DATA)); + + switch (src->type) { + case TREE_TYPE_BLOCK: + tree_cpy(&(*dest)->data.block.val, src->data.block.val); + tree_cpy(&(*dest)->data.block.nxt, src->data.block.nxt); + break; + case TREE_TYPE_EXPR: + // TODO: fix. + DIE("this shouldn't be here"); + tree_cpy(&(*dest)->data.expr.val, src->data.expr.val); + break; + case TREE_TYPE_LINT: + break; + case TREE_TYPE_LSTR: + (*dest)->data.lstr.val = malloc( + (src->data.lstr.len + 1) * sizeof(char) + ); + + strcpy((*dest)->data.lstr.val, src->data.lstr.val); + break; + case TREE_TYPE_TAG: + (*dest)->data.tag.val = malloc(sizeof(src->data.tag.val)); + strcpy((*dest)->data.tag.val, src->data.tag.val); + + tree_cpy(&(*dest)->data.tag.nxt, src->data.tag.nxt); + break; + case TREE_TYPE_DARG: + tree_cpy(&(*dest)->data.darg.tag, src->data.darg.tag); + tree_cpy(&(*dest)->data.darg.nxt, src->data.darg.nxt); + break; + case TREE_TYPE_CARG: + tree_cpy(&(*dest)->data.carg.val, src->data.carg.val); + tree_cpy(&(*dest)->data.carg.nxt, src->data.carg.nxt); + break; + case TREE_TYPE_DEF: + tree_cpy(&(*dest)->data.def.tag, src->data.def.tag); + tree_cpy(&(*dest)->data.def.arg, src->data.def.arg); + tree_cpy(&(*dest)->data.def.val, src->data.def.val); + break; + case TREE_TYPE_CALL: + (*dest)->data.call.target = malloc(sizeof(src->data.call.target)); + strcpy((*dest)->data.call.target, src->data.call.target); + + tree_cpy(&(*dest)->data.call.arg, src->data.call.arg); + break; + } +} + +// TODO: Does this function actually do anything?? +#if 0 tree_t* tree_copy_out(tree_t* tree) { tree_t* newt = tree_init(tree->type, tree->parent); memcpy(&newt->data, &tree->data, sizeof(newt->data)); return newt; } +#endif int tree_cmp(tree_t* tree_0, tree_t* tree_1) { if ((tree_0 && !tree_1) || (!tree_0 && tree_1)) { return 0; } /* Only 1 is defined (failure). */ |