1 files changed, 46 insertions, 25 deletions

diff --git a/src/doer.c b/src/doer.c
index 14d7d02..002b13c 100644
--- a/src/doer.c
+++ b/src/doer.c
@@ -100,9 +100,7 @@ tree_t* doer_find_target_from_call(doer_t* doer) {
       }
    }
 
-   for (target_t* t = doer->targets; t; printf("%s\n", t->tree->data.def.tag->data.tag.nxt->data.tag.val) && (t = t->nxt));
-
-   DIEF("Call to missing target: %s", call_name);
+   return NULL;
 }
 
 tree_t* doer_eval_prim(doer_t* doer) {
@@ -153,7 +151,7 @@ int doer_eval_lint(doer_t* doer) {
          // Already done \o/.
          return doer->tree->data.lint.val;
       default:
-         DIE("Wrong type, FOOL!");
+         DIEF("Wrong type, FOOL! Found a %d.", doer->tree->type);
    }
 }
 
@@ -363,28 +361,31 @@ void doer_do_call(doer_t* doer) {
 
 tree_t* doer_do_call_target(doer_t* doer) {
    tree_t* the_call = doer->tree;
+
+   LOG_DBGF("%s", the_call->data.call.target);
+
    tree_t* target_def = doer_find_target_from_call(doer);  // Is def.
 
+   if (!target_def) {
+      DIEF("Call to missing target: %s", the_call->data.call.target);
+   }
+
    tree_t* resolution;
 
+   tree_cpy(&resolution, target_def);
+   resolution->parent = the_call->parent;
+
    tree_t* darg = target_def->data.def.arg;
    tree_t* carg = the_call->data.call.arg;
 
-   LOG_DBG("DARG:\n");
-   tree_print(darg, 0);
-
-   LOG_DBG("CARG:\n");
-   tree_print(carg, 0);
-
-   target_t
-      * targs = NULL,   // Pointer to first target.
-      * targ = targs;   // Pointer to where new targets will be added.
+   target_t* targs = NULL; // Pointer to first target.
+   target_t** targp = &targs; // Pointer to where new targets will be added.
+   target_t* newt = NULL;
 
    // 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);
+      tree_t* carg_resolved = doer_eval_prim(doer);
 
       char
          * darg_type = darg->data.darg.tag->data.tag.val,
@@ -392,46 +393,66 @@ tree_t* doer_do_call_target(doer_t* doer) {
 
       if (strcmp(darg_type, carg_type)) DIE("Type mismatch.");
 
+      // Create def to put in target.
       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.
 
-      targ = target_init(
+      carg_tree_def->data.def.val = carg_resolved;
+
+      carg_tree_def->data.def.arg = NULL;
+
+      newt = target_init(
          "This field doesn't actually do anything but I can't be bothered to remove it :P",
          carg_tree_def
       );
 
-      targ = targ->nxt;
+      *targp = newt;
+      targp = &newt->nxt;
+
       darg = darg->data.darg.nxt;
 
-      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");
+      /*      printf("[");
+      for (
+         target_t* t = targs;
+         t;
+         printf("%s, ", t->tree->data.def.tag->data.tag.nxt->data.tag.val)
+            && (t = t->nxt)
+      );
+      printf("]\n");
+      */
    }
 
    target_t* old_ltarget = doer->ltarget;
 
    // Append the new targets from the args.
    doer->ltarget->nxt = targs;
-   doer->ltarget = targ;
+   doer->ltarget = newt;
 
    // 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");
+
+   /*
+   printf("[");
+   for (target_t* t = doer->targets; t; printf("%s, ", t->tree->data.def.tag->data.tag.nxt->data.tag.val) && (t = t->nxt));
+   printf("]\n");
+   */
+
+   doer->tree = resolution;
+   tree_t* r = doer_eval_prim(doer);
 
    // Clean up temporary targets.
    target_destroy(targs);
    old_ltarget->nxt = NULL;
    doer->ltarget = old_ltarget;
 
-   return doer_eval_prim(doer);
+   return r;
 }
 
 tree_t* doer_do_call_blin(doer_t* doer) {
+   LOG_DBGF("%s", doer->tree->data.call.target);
    for (int i = 0; i < sizeof(blinfs) / sizeof(blinf_t); i++)
       if (!strcmp(blinfs[i].name, doer->tree->data.call.target))
          return (blinfs[i].fp)(doer);