parser.c

#include "parser.h"

llnode_t *eval_expr (mod_t *, expr_t *);
llnode_t *_sf_fcall (mod_t *, expr_t *);
llnode_t *_sf_ev_arith (mod_t *, expr_t *);
llnode_t *_sf_class_construct (mod_t *, obj_t *, expr_t *);

llnode_t *_sf_exec_compare (mod_t *, expr_t *);

void _sf_exec_block_for (mod_t *, int);
void _sf_exec_block_if (mod_t *, size_t *);
void _sf_exec_block_while (mod_t *, int);

int _sf_obj_cmp (mod_t *, obj_t *, obj_t *);
int _sf_obj_isfalse (mod_t *, obj_t *);

SF_API void
sf_parser_init (void)
{
}

SF_API parser_rt
sf_parser_exec (mod_t *mod)
{
  size_t i = 0;

  while (i < mod->body_len)
    {
      const stmt_t t = mod->body[i];
      // sf_ast_stmtprint (t);

      switch (t.type)
        {
        case STMT_VAR_DECL:
          {
            llnode_t *val_eval = eval_expr (mod, t.v.var_decl.val);
            expr_t *tvn = t.v.var_decl.name;

            switch (tvn->type)
              {
              case EXPR_VAR:
                {
                  sf_charptr vname = tvn->v.var.name;

                  sf_mod_addVar (mod, SFCPTR_TOSTR (vname), val_eval);
                }
                break;

              case EXPR_MEM_ACCESS:
                {
                  llnode_t *pl = eval_expr (mod, tvn->v.mem_access.parent);
                  obj_t *pl_o = (obj_t *)pl->val;

                  switch (pl_o->type)
                    {
                    case OBJ_CLASSOBJ:
                      {
                        expr_t *vl = tvn->v.mem_access.val;
                        class_t *co = pl_o->v.o_cobj.val;

                        switch (vl->type)
                          {
                          case EXPR_VAR:
                            {
                              sf_mod_addVar (
                                  co->mod,
                                  (char *)SFCPTR_TOSTR (vl->v.var.name),
                                  val_eval);
                            }
                            break;

                          default:
                            break;
                          }
                      }
                      break;

                    default:
                      break;
                    }
                }
                break;

              default:
                break;
              }
          }
          break;

        case STMT_FUN_CALL:
          {
            expr_t *mke_p = sfmalloc (sizeof (*mke_p));
            *mke_p = (expr_t){ .type = EXPR_FUN_CALL,
                               .v.fun_call = {
                                   .arg_count = t.v.fun_call.arg_count,
                                   .args = t.v.fun_call.args,
                                   .name = t.v.fun_call.name,
                               } };

            llnode_t *r = _sf_fcall (mod, mke_p);

            // assert (r != NULL);
            // printf ("%d\n", r->meta.ref_count);
            sffree (mke_p);

            if (r != NULL)
              sf_ll_set_meta_refcount (r, r->meta.ref_count - 1);
          }
          break;

        case STMT_FUN_DECL:
          {
            mod_t *fmod = sf_mod_new (MOD_TYPE_FUNC, NULL);

            fmod->body = t.v.fun_decl.body;
            fmod->body_len = t.v.fun_decl.body_count;

            char *fname = NULL;

            if (t.v.fun_decl.name && t.v.fun_decl.name->type == EXPR_VAR)
              {
                fname = sf_str_new_fromStr (
                    SFCPTR_TOSTR (t.v.fun_decl.name->v.var.name));
              }

            size_t argc = t.v.fun_decl.arg_count;
            char **args = sfmalloc (argc * sizeof (*args));

            for (size_t j = 0; j < argc; j++)
              {
                expr_t *ca = &t.v.fun_decl.args[j];

                switch (ca->type)
                  {
                  case EXPR_VAR:
                    {
                      args[j]
                          = sf_str_new_fromStr (SFCPTR_TOSTR (ca->v.var.name));

                      obj_t *ev = sf_ast_objnew (OBJ_CONST);

                      ev->v.o_const.type = CONST_INT;
                      ev->v.o_const.v.c_int.v = 0;

                      sf_mod_addVar (fmod, args[j], sf_ot_addobj (ev));
                    }
                    break;

                  default:
                    break;
                  }
              }

            fmod->parent = mod;

            if (fname != NULL)
              {
                fun_t *nf = sf_fun_new (fname, SF_FUN_CODED, fmod, NULL);

                nf->argc = argc;
                nf->args = args;

                nf = sf_fun_add (nf);

                obj_t *ov = sf_ast_objnew (OBJ_FUN);
                ov->v.o_fun.f = nf;

                sf_mod_addVar (mod, fname, sf_ot_addobj (ov));
              }
            else
              {
                e_printf ("Function has no name at sf_parser_exec()\n");
              }

            sffree (fname);
          }
          break;

        case STMT_FOR_BLOCK:
          {
            _sf_exec_block_for (mod, i);
          }
          break;

        case STMT_IF_BLOCK:
          {
            _sf_exec_block_if (mod, &i);
          }
          break;

        case STMT_WHILE_BLOCK:
          {
            _sf_exec_block_while (mod, i);

            /**
             * Might need to change signature in _sf_exec_block_while
             * from `_sf_exec_block_while (mod_t *, int)` to
             * `_sf_exec_block_while (mod_t *, int *)` to track
             * else blocks.
             * (same with `for` block)
             */
          }
          break;

        case STMT_CLASS_DECL:
          {
            expr_t *nam = t.v.class_decl.name;
            char *cname = NULL;

            if (nam->type == EXPR_FUN_CALL)
              {
                /* class inherits */

                assert (nam->v.fun_call.name->type == EXPR_VAR);
                cname = sfstrdup (
                    SFCPTR_TOSTR (nam->v.fun_call.name->v.var.name));
              }

            else if (nam->type == EXPR_VAR)
              {
                cname = sfstrdup (SFCPTR_TOSTR (nam->v.var.name));
              }

            assert (cname != NULL);

            mod_t *cmod = sf_mod_new (MOD_TYPE_CLASS, mod);
            cmod->body = t.v.class_decl.body;
            cmod->body_len = t.v.class_decl.body_count;

            /* for (size_t j = 0; j < cmod->body_len; j++)
              {
                sf_ast_stmtprint (cmod->body[j]);
              } */

            sf_parser_exec (cmod);

            class_t *nt = sf_class_new (cname, SF_CLASS_CODED);
            nt->mod = cmod;

            sf_class_add (nt);

            obj_t *nobj = sf_ast_objnew (OBJ_CLASS);
            nobj->v.o_class.val = nt;

            sf_mod_addVar (mod, cname, sf_ot_addobj (nobj));

            sffree (cname);
          }
          break;

        default:
          break;
        }

    loop_end:
      i++;
    }

end:
  return (parser_rt){ .i = -1 };
}

llnode_t *
eval_expr (mod_t *mod, expr_t *e)
{
  llnode_t *r = NULL;

  switch (e->type)
    {
    case EXPR_CONSTANT:
      {
        obj_t *v = sf_ast_objnew (OBJ_CONST);
        v->v.o_const.type = e->v.e_const.type;

        switch (v->v.o_const.type)
          {
          case CONST_INT:
            {
              v->v.o_const.v.c_int.v = e->v.e_const.v.c_int.v;
            }
            break;

          case CONST_FLOAT:
            {
              v->v.o_const.v.c_float.v = e->v.e_const.v.c_float.v;
            }
            break;

          case CONST_STRING:
            {
              v->v.o_const.v.c_string.v = sf_str_new_fromStr (
                  SFCPTR_TOSTR (e->v.e_const.v.c_string.v));
            }
            break;

          case CONST_BOOL:
            {
              v->v.o_const.v.c_bool.v = e->v.e_const.v.c_bool.v;
            }
            break;

          default:
            e_printf ("Unknown constant type '%d' in eval_expr()\n",
                      v->v.o_const.type);
            break;
          }

        r = sf_ot_addobj (v);
      }
      break;

    case EXPR_VAR:
      {
        r = sf_mod_getVar (mod, e->v.var.name);
      }
      break;

    case EXPR_VAR_DECL:
      {
        size_t pres_sz = mod->body_len;
        stmt_t pres_fs = *mod->body;

        mod_t *par_pres = mod->parent;
        mod->parent = NULL;

        mod->body_len = 1;
        *mod->body = (stmt_t){ .type = STMT_VAR_DECL,
                               .v = { .var_decl = {
                                          .name = e->v.var_decl.name,
                                          .val = e->v.var_decl.val,
                                      } } };

        sf_parser_exec (mod);

        *mod->body = pres_fs;
        mod->body_len = pres_sz;

        mod->parent = par_pres;

        r = eval_expr (mod, e->v.var_decl.name);
      }
      break;

    case EXPR_ARRAY:
      {
        array_t *t = sf_array_new ();
        t->len = e->v.e_array.val_count;
        t->vals = sfmalloc (t->len * sizeof (*t->vals));

        for (size_t j = 0; j < t->len; j++)
          {
            // printf ("%d\n", e->v.e_array.vals[j].type);
            t->vals[j] = eval_expr (mod, (expr_t *)&e->v.e_array.vals[j]);

            sf_ll_set_meta_refcount (t->vals[j],
                                     t->vals[j]->meta.ref_count + 1);
          }

        array_t *rt = sf_array_add (t);

        // printf ("[%d]\n", rt - *sf_array_getStack ());

        obj_t *o = sf_ast_objnew (OBJ_ARRAY);
        o->v.o_array.v = rt;

        r = sf_ot_addobj (o);
      }
      break;

    case EXPR_IDX_ACCESS:
      {
        obj_t *name = (obj_t *)eval_expr (mod, e->v.e_idx_access.name)->val;
        obj_t *val = (obj_t *)eval_expr (mod, e->v.e_idx_access.val)->val;

        // printf ("%d %d\n", name->type, val->type);

        switch (name->type)
          {
          case OBJ_ARRAY:
            {
              array_t *t = name->v.o_array.v;

              switch (val->type)
                {
                case OBJ_CONST:
                  {
                    switch (val->v.o_const.type)
                      {
                      case CONST_INT:
                        {
                          int p = val->v.o_const.v.c_int.v;

                          while (p < 0)
                            p += t->len;
                          p %= t->len;

                          r = t->vals[p];
                        }
                        break;

                      default:
                        break;
                      }
                  }
                  break;

                default:
                  break;
                }
            }
            break;

          default:
            break;
          }
      }
      break;

    case EXPR_TOSTEPTYPE:
      {
        llnode_t *lv = eval_expr (mod, e->v.to_step.lval);
        llnode_t *rv = eval_expr (mod, e->v.to_step.rval);

        sf_ll_set_meta_refcount (lv, lv->meta.ref_count + 1);
        sf_ll_set_meta_refcount (rv, rv->meta.ref_count + 1);

        llnode_t *stp = NULL;
        int l_val, r_val, step_c = 1;

        llnode_t *tp = NULL;
        char tp_val[2] = { '[', ')' }; // default mode

        if (e->v.to_step.e_step != NULL)
          {
            stp = eval_expr (mod, e->v.to_step.e_step);

            sf_ll_set_meta_refcount (stp, stp->meta.ref_count + 1);
            obj_t *ob_o = (obj_t *)stp->val;

            assert (ob_o->type == OBJ_CONST
                    && (ob_o->v.o_const.type == CONST_INT
                        || ob_o->v.o_const.type == CONST_FLOAT));

            step_c = ob_o->v.o_const.v.c_int.v;

            if (ob_o->v.o_const.type == CONST_INT)
              {
                step_c = ob_o->v.o_const.v.c_int.v;
              }
            else
              {
                assert (ceilf (ob_o->v.o_const.v.c_float.v)
                        == ob_o->v.o_const.v.c_float.v);

                step_c = ob_o->v.o_const.v.c_float.v;
              }
          }

        if (e->v.to_step.e_type != NULL)
          {
            tp = eval_expr (mod, e->v.to_step.e_type);

            sf_ll_set_meta_refcount (tp, tp->meta.ref_count + 1);
            obj_t *tp_o = (obj_t *)tp->val;

            assert (tp_o->type == OBJ_CONST
                    && tp_o->v.o_const.type == CONST_STRING);

            char *p = SFCPTR_TOSTR (tp_o->v.o_const.v.c_string.v);

            for (size_t k = 0; p[k] != '\0'; k++)
              {
                if (p[k] == '[' || p[k] == '(')
                  tp_val[0] = p[k];

                if (p[k] == ']' || p[k] == ')')
                  tp_val[1] = p[k];
              }
          }

        obj_t *lv_o = (obj_t *)lv->val;
        obj_t *rv_o = (obj_t *)rv->val;

        assert (lv_o->type == OBJ_CONST && lv_o->v.o_const.type == CONST_INT
                || lv_o->v.o_const.type == CONST_FLOAT);

        assert (rv_o->type == OBJ_CONST && rv_o->v.o_const.type == CONST_INT
                || rv_o->v.o_const.type == CONST_FLOAT);

        if (lv_o->v.o_const.type == CONST_INT)
          {
            l_val = lv_o->v.o_const.v.c_int.v;
          }
        else
          {
            assert (ceilf (lv_o->v.o_const.v.c_float.v)
                    == lv_o->v.o_const.v.c_float.v);
            l_val = lv_o->v.o_const.v.c_float.v;
          }

        if (rv_o->v.o_const.type == CONST_INT)
          {
            r_val = rv_o->v.o_const.v.c_int.v;
          }
        else
          {
            assert (ceilf (rv_o->v.o_const.v.c_float.v)
                    == rv_o->v.o_const.v.c_float.v);
            r_val = rv_o->v.o_const.v.c_float.v;
          }

        array_t *narr = sf_array_new ();

        if (l_val + (tp_val[0] != '[') < r_val + (tp_val[1] == ']'))
          {
            // assert (step_c > 0);

            if (step_c > 0)
              {
                for (int i = l_val + (tp_val[0] != '[');
                     i < r_val + (tp_val[1] == ']'); i += step_c)
                  {
                    obj_t *v = sf_ast_objnew (OBJ_CONST);
                    v->v.o_const.type = CONST_INT;
                    v->v.o_const.v.c_int.v = i;

                    sf_array_pushVal (narr, sf_ot_addobj (v));
                  }
              }
          }

        else
          {
            // assert (step_c < 0);

            if (step_c < 0)
              {
                for (int i = l_val + (tp_val[0] != '[');
                     i > r_val + (tp_val[1] == ']'); i += step_c)
                  {
                    obj_t *v = sf_ast_objnew (OBJ_CONST);
                    v->v.o_const.type = CONST_INT;
                    v->v.o_const.v.c_int.v = i;

                    sf_array_pushVal (narr, sf_ot_addobj (v));
                  }
              }
          }

        obj_t *res = sf_ast_objnew (OBJ_ARRAY);
        res->v.o_array.v = narr;

        r = sf_ot_addobj (res);

        sf_ll_set_meta_refcount (lv, lv->meta.ref_count - 1);
        sf_ll_set_meta_refcount (rv, rv->meta.ref_count - 1);

        if (stp != NULL)
          sf_ll_set_meta_refcount (stp, stp->meta.ref_count - 1);

        if (tp != NULL)
          sf_ll_set_meta_refcount (tp, tp->meta.ref_count - 1);
      }
      break;

    case EXPR_FUN_CALL:
      {
        r = _sf_fcall (mod, e);
      }
      break;

    case EXPR_INCLAUSE:
      {
        llnode_t *lv = eval_expr (mod, e->v.in_clause.lval);
        llnode_t *rv = eval_expr (mod, e->v.in_clause.rval);

        sf_ll_set_meta_refcount (lv, lv->meta.ref_count + 1);
        sf_ll_set_meta_refcount (rv, rv->meta.ref_count + 1);

        obj_t *l_obj = (obj_t *)lv->val;
        obj_t *r_obj = (obj_t *)rv->val;

        int l_in_r = 0;

        switch (r_obj->type)
          {
          case OBJ_ARRAY:
            {
              array_t *rt = r_obj->v.o_array.v;

              for (size_t j = 0; j < rt->len; j++)
                {
                  obj_t *co = (obj_t *)rt->vals[j]->val;

                  /**
                   * This is intentional.
                   * If `_sf_obj_cmp (mod, l_obj, co)` evaluates to true,
                   * then l_in_r = true and loop breaks.
                   * This means lval is present in rval.
                   * Thus, l_val in r_val => true
                   * Break the loop and return as bool
                   */
                  if (l_in_r = _sf_obj_cmp (mod, l_obj, co))
                    break;
                }
            }
            break;

          case OBJ_CONST:
            {
              assert (
                  r_obj->v.o_const.type == CONST_STRING
                  && l_obj->v.o_const.type
                         == CONST_STRING); // the only iterable constant (yet)

              sf_charptr ls = l_obj->v.o_const.v.c_string.v;
              sf_charptr rs = r_obj->v.o_const.v.c_string.v;

              l_in_r = sf_str_inStr (rs, ls);
            }
            break;

          default:
            e_printf ("No `in` rule for rvalue of type '%d'\n", r_obj->type);
            break;
          }

        obj_t *res = sf_ast_objnew (OBJ_CONST);
        res->v.o_const.type = CONST_BOOL;
        res->v.o_const.v.c_bool.v = l_in_r;

        r = sf_ot_addobj (res);

        sf_ll_set_meta_refcount (lv, lv->meta.ref_count - 1);
        sf_ll_set_meta_refcount (rv, rv->meta.ref_count - 1);
      }
      break;

    case EXPR_ARITHMETIC:
      {
        r = _sf_ev_arith (mod, e);
      }
      break;

    case EXPR_MEM_ACCESS:
      {
        expr_t *par = e->v.mem_access.parent;
        expr_t *vl = e->v.mem_access.val;

        llnode_t *par_ll = eval_expr (mod, par);

        sf_ll_set_meta_refcount (par_ll, par_ll->meta.ref_count + 1);

        obj_t *par_obj = (obj_t *)par_ll->val;
        assert (par_obj != NULL);

        switch (par_obj->type)
          {
          case OBJ_CLASS:
            {
              class_t *cl = par_obj->v.o_class.val;

              switch (vl->type)
                {
                case EXPR_VAR:
                  {
                    sf_charptr vn = vl->v.var.name;
                    r = sf_mod_getVar (cl->mod, SFCPTR_TOSTR (vn));
                  }
                  break;

                default:
                  break;
                }
            }
            break;

          case OBJ_CLASSOBJ:
            {
              class_t *cl = par_obj->v.o_cobj.val;
              assert (cl->meta.iscobj);

              switch (vl->type)
                {
                case EXPR_VAR:
                  {
                    sf_charptr vn = vl->v.var.name;
                    r = sf_mod_getVar (cl->mod, SFCPTR_TOSTR (vn));
                  }
                  break;

                default:
                  break;
                }
            }
            break;

          default:
            break;
          }

        if (r != NULL)
          {
            obj_t *rv = (obj_t *)r->val;

            if (rv->meta.passargs != NULL)
              /*rv->meta.passargs = sfrealloc (
                  rv->meta.passargs,
                  (rv->meta.pa_size + 1) * sizeof (*rv->meta.passargs));*/
              {
                for (size_t i = 0; i < rv->meta.pa_size; i++)
                  {
                    obj_t *cr = rv->meta.passargs[i];

                    if (cr->meta.mem_ref != NULL)
                      {
                        sf_ll_set_meta_refcount (
                            cr->meta.mem_ref,
                            cr->meta.mem_ref->meta.ref_count - 1);
                      }
                  }

                sffree (rv->meta.passargs);
                rv->meta.pa_size = 0;
              }
            // else
            rv->meta.passargs = sfmalloc (sizeof (*rv->meta.passargs));

            rv->meta.passargs[rv->meta.pa_size++] = par_obj;
            par_obj->meta.mem_ref = par_ll;

            sf_ll_set_meta_refcount (par_ll, par_ll->meta.ref_count + 1);
          }

        sf_ll_set_meta_refcount (par_ll, par_ll->meta.ref_count - 1);
      }
      break;

    case EXPR_THIS:
      {
        // TODO
      }
      break;

    case EXPR_CONDITIONAL_EQEQ:
    case EXPR_CONDITIONAL_GT:
    case EXPR_CONDITIONAL_NEQ:
    case EXPR_CONDITIONAL_LT:
    case EXPR_CONDITIONAL_GTEQ:
    case EXPR_CONDITIONAL_LTEQ:
      {
        r = _sf_exec_compare (mod, e);
      }
      break;

    default:
      e_printf ("Unknown expression '%d' in eval_expr()\n", e->type);
      break;
    }

end:
  if (r == NULL)
    {
      sf_ast_exprprint (*e);

      assert (0 && "r is NULL in eval_expr");
    }

  return r;
}

void
_sf_exec_block_for (mod_t *mod, int i)
{
  stmt_t *t = &mod->body[i];
  expr_t *cn = t->v.blk_for.cond;

  stmt_t *body_pres = mod->body;
  size_t bl_pres = mod->body_len;

  mod->body = t->v.blk_for.body;
  mod->body_len = t->v.blk_for.body_count;

  int got_break_signal = 0;

  switch (cn->type)
    {
    case EXPR_INCLAUSE:
      {
        expr_t *lv = cn->v.in_clause.lval;
        llnode_t *rnode = eval_expr (mod, cn->v.in_clause.rval);

        sf_ll_set_meta_refcount (rnode, rnode->meta.ref_count + 1);

        obj_t *robj = (obj_t *)rnode->val;

        switch (robj->type)
          {
          case OBJ_ARRAY:
            {
              const array_t *rt = robj->v.o_array.v;

              for (size_t i = 0; i < rt->len; i++)
                {
                  if (lv->type == EXPR_VAR)
                    {
                      const sf_charptr vname = lv->v.var.name;

                      sf_mod_addVar (mod, SFCPTR_TOSTR (vname), rt->vals[i]);
                    }
                  else
                    {
                      // TODO
                      // ? other types of expressions
                      /*
                        for i, j = 2 in [1, [1, 3], [1]]
                               ^^^^^ -> VAR_DECL
                      */
                    }

                  sf_parser_exec (mod);
                  // TODO: check for signals like continue, break
                }
            }
            break;

          case OBJ_CONST:
            {
              switch (robj->v.o_const.type)
                {
                case CONST_STRING:
                  {
                    const char *vl
                        = SFCPTR_TOSTR (robj->v.o_const.v.c_string.v);
                    const size_t d = strlen (vl);

                    for (size_t i = 0; i < d; i++)
                      {
                        const char c = vl[i];

                        if (lv->type == EXPR_VAR)
                          {
                            const sf_charptr vname = lv->v.var.name;

                            obj_t *oref = sf_ast_objnew (OBJ_CONST);
                            oref->v.o_const.type = CONST_STRING;
                            oref->v.o_const.v.c_string.v = sf_str_new_empty ();
                            sf_str_pushchr (&oref->v.o_const.v.c_string.v, c);

                            sf_mod_addVar (mod, SFCPTR_TOSTR (vname),
                                           sf_ot_addobj (oref));
                          }
                        else
                          {
                            // TODO
                            // ? other types of expressions
                            /*
                              for i, j = 2 in [1, [1, 3], [1]]
                                     ^^^^^ -> VAR_DECL
                            */
                          }

                        sf_parser_exec (mod);
                        // TODO: check for signals like continue, break
                      }
                  }
                  break;

                default:
                  break;
                }
            }
            break;

          default:
            break;
          }

        sf_ll_set_meta_refcount (rnode, rnode->meta.ref_count - 1);
      }
      break;

    default:
      {
        /**
         * for (i = 0, i < 10, i = i + 1)
         *    <body>
         */
      }
      break;
    }

  mod->body = body_pres;
  mod->body_len = bl_pres;

  if (i + 1 < mod->body_len && !got_break_signal
      && mod->body[i + 1].type == STMT_ELSE_BLOCK)
    {
      body_pres = mod->body;
      bl_pres = mod->body_len;

      mod->body = body_pres[i + 1].v.blk_else.body;
      mod->body_len = body_pres[i + 1].v.blk_else.body_count;

      sf_parser_exec (mod);

      mod->body = body_pres;
      mod->body_len = bl_pres;
    }
}

void
_sf_exec_block_while (mod_t *mod, int i)
{
  stmt_t *t = &mod->body[i];
  llnode_t *cll = eval_expr (mod, t->v.blk_while.cond);

  sf_ll_set_meta_refcount (cll, cll->meta.ref_count + 1);

  obj_t *clv = (obj_t *)cll->val;

  stmt_t *pres_st = mod->body;
  size_t pres_size = mod->body_len;

  mod->body = t->v.blk_while.body;
  mod->body_len = t->v.blk_while.body_count;

  while (!_sf_obj_isfalse (mod, clv))
    {
      sf_parser_exec (mod);

      sf_ll_set_meta_refcount (cll, cll->meta.ref_count - 1);
      cll = eval_expr (mod, t->v.blk_while.cond);
      clv = (obj_t *)cll->val;
      sf_ll_set_meta_refcount (cll, cll->meta.ref_count + 1);
    }

  mod->body = pres_st;
  mod->body_len = pres_size;

  sf_ll_set_meta_refcount (cll, cll->meta.ref_count - 1);
}

int
_sf_obj_isfalse (mod_t *mod, obj_t *o)
{
  switch (o->type)
    {
    case OBJ_CONST:
      {
        switch (o->v.o_const.type)
          {
          case CONST_INT:
            return o->v.o_const.v.c_int.v == 0;

          case CONST_FLOAT:
            return o->v.o_const.v.c_float.v == 0.0;

          case CONST_BOOL:
            return o->v.o_const.v.c_bool.v == 0;

          case CONST_STRING:
            return sf_str_eq_rCp (o->v.o_const.v.c_string.v, "");

          case CONST_NONE:
            return 1;

          default:
            break;
          }
      }
      break;

    case OBJ_ARRAY:
      {
        array_t *t = o->v.o_array.v;

        return t->len == 0;
      }
      break;

    case OBJ_FUN:
      goto end;

    default:
      break;
    }

end:
  return 0;
}

void
_sf_exec_block_if (mod_t *mod, size_t *ip)
{
  int i = *ip;
  stmt_t *t = &mod->body[i];

  llnode_t *o = eval_expr (mod, t->v.blk_if.cond);
  sf_ll_set_meta_refcount (o, o->meta.ref_count + 1);

  obj_t *cval = (obj_t *)o->val;

  if (_sf_obj_isfalse (mod, cval))
    {
      // Condition is false

      if (i < mod->body_len - 1)
        {
          (*ip)++;
          stmt_t *ntok = &mod->body[*ip];

          if (ntok->type == STMT_ELSE_BLOCK)
            {
              stmt_t *body_pres = mod->body;
              size_t blen_pres = mod->body_len;

              mod->body = ntok->v.blk_else.body;
              mod->body_len = ntok->v.blk_else.body_count;

              sf_parser_exec (mod);

              mod->body = body_pres;
              mod->body_len = blen_pres;
            }

          else if (ntok->type == STMT_ELSEIF_BLOCK)
            {
              int state = 0;
              do
                {
                  if (ntok->type != STMT_ELSEIF_BLOCK)
                    break;

                  llnode_t *elo = eval_expr (mod, ntok->v.blk_elseif.cond);
                  sf_ll_set_meta_refcount (elo, elo->meta.ref_count + 1);

                  obj_t *elo_obj = (obj_t *)elo->val;

                  if (!_sf_obj_isfalse (mod, elo_obj))
                    {
                      stmt_t *body_pres = mod->body;
                      size_t blen_pres = mod->body_len;

                      mod->body = ntok->v.blk_elseif.body;
                      mod->body_len = ntok->v.blk_elseif.body_count;

                      sf_parser_exec (mod);

                      mod->body = body_pres;
                      mod->body_len = blen_pres;

                      state = 1;
                      sf_ll_set_meta_refcount (elo, elo->meta.ref_count - 1);

                      while (*ip < mod->body_len
                             && (mod->body[*ip].type == STMT_ELSEIF_BLOCK
                                 || mod->body[*ip].type == STMT_ELSE_BLOCK))
                        {
                          (*ip)++;
                        }

                      break;
                    }

                  sf_ll_set_meta_refcount (elo, elo->meta.ref_count - 1);
                  (*ip)++;
                  ntok = &mod->body[*ip];
                }
              while (*ip < mod->body_len);

              if (!state && ntok->type == STMT_ELSE_BLOCK)
                {
                  // execute else (if a block exists)

                  stmt_t *body_pres = mod->body;
                  size_t blen_pres = mod->body_len;

                  mod->body = ntok->v.blk_else.body;
                  mod->body_len = ntok->v.blk_else.body_count;

                  sf_parser_exec (mod);

                  mod->body = body_pres;
                  mod->body_len = blen_pres;
                }
              else
                (*ip)--;
            }
        }
    }

  else
    {
      // Condition is true
      stmt_t *body_pres = mod->body;
      size_t blen_pres = mod->body_len;

      mod->body = t->v.blk_if.body;
      mod->body_len = t->v.blk_if.body_count;

      sf_parser_exec (mod);

      mod->body = body_pres;
      mod->body_len = blen_pres;

      if (i < mod->body_len - 1)
        {
          stmt_t *ntok = &mod->body[i + 1];

          if (ntok->type == STMT_ELSE_BLOCK)
            {
              *ip++;
            }

          else if (ntok->type == STMT_ELSEIF_BLOCK)
            {
              do
                {
                  *ip++;
                }
              while (*ip < mod->body_len
                     && mod->body[*ip].type == STMT_ELSEIF_BLOCK);

              if (*ip < mod->body_len
                  && mod->body[*ip].type == STMT_ELSE_BLOCK)
                *ip++;
            }
        }
    }

  sf_ll_set_meta_refcount (o, o->meta.ref_count - 1);
}

llnode_t *
_sf_fcall (mod_t *mod, expr_t *e)
{
  if (e->v.fun_call.name->type != -1) // function call
    {
      llnode_t *name = eval_expr (mod, e->v.fun_call.name);
      obj_t *fref = (obj_t *)name->val;

      sf_ll_set_meta_refcount (name, name->meta.ref_count + 1);

      // printf ("[%s]\n", sf_parser_objRepr (mod, fref));
      // printf ("%s\n", e->v.fun_call.name->v.var.name);

      llnode_t *res = NULL;

      mod_t *nmod = sf_mod_new (MOD_TYPE_FUNC, NULL);

      switch (fref->type)
        {
        case OBJ_FUN:
          {
            fun_t *fn = fref->v.o_fun.f;
            // mod_t *par_pres = fn->mod->parent;

            nmod->type = fn->mod->type;
            nmod->body = fn->mod->body;
            nmod->body_len = fn->mod->body_len;

            // printf ("(%d %d)\n", fn->argc,
            //         fref->meta.pa_size + e->v.fun_call.arg_count);
            assert (fn->argc == fref->meta.pa_size + e->v.fun_call.arg_count);

            for (size_t j = 0; j < fref->meta.pa_size; j++)
              {
                assert (fref->meta.passargs[j]->meta.mem_ref != NULL);
                sf_mod_addVar (nmod, fn->args[j],
                               fref->meta.passargs[j]->meta.mem_ref);
              }

            for (size_t j = 0; j < e->v.fun_call.arg_count; j++)
              {
                // expr_t *ee = sfmalloc (sizeof (*ee));
                // *ee = e->v.fun_call.args[j];

                llnode_t *on = eval_expr (mod, &e->v.fun_call.args[j]);

                // sffree (ee);
                // printf ("%s\n", fn->args[j]);
                // printf ("%d\n", on->meta.ref_count);
                sf_mod_addVar (nmod, fn->args[j + fref->meta.pa_size], on);
              }

            nmod->parent = fn->mod->parent;

            if (fn->type == SF_FUN_NATIVE)
              {
                res = fn->native.routine (nmod);
              }

            else
              {
                // printf ("%d\n", fn->mod->body_len);
                sf_parser_exec (nmod);

                if (nmod->retv != NULL)
                  {
                    res = nmod->retv;
                  }
                else
                  {
                    obj_t *rv = sf_ast_objnew (OBJ_CONST);
                    rv->v.o_const.type = CONST_NONE;

                    res = sf_ot_addobj (rv);
                  }
              }

            for (size_t j = 0; j < fref->meta.pa_size; j++)
              {
                llnode_t *c = fref->meta.passargs[j]->meta.mem_ref;

                sf_ll_set_meta_refcount (c, c->meta.ref_count - 1);
              }

            sffree (fref->meta.passargs);
            fref->meta.passargs = NULL;
            fref->meta.pa_size = 0;

            /*
             If return value is an argument (lvalue)
             and if a return reference is not counted
             then argument will lose it's object in the next step
             (acts as rvalue).
             This will return a free'd object if argument's value is not
             referenced by other symbols.
            */
            if (res != NULL)
              sf_ll_set_meta_refcount (res, res->meta.ref_count + 1);
          }
          break;

        case OBJ_CLASS:
          {
            res = _sf_class_construct (mod, fref, e);
          }
          break;

        default:
          e_printf ("Cannot call object of type %d\n", fref->type);
          break;
        }

      nmod->parent = NULL;
      nmod->body = NULL;
      nmod->body_len = 0;
      nmod->retv = NULL;

      sf_mod_free (nmod);

      sf_ll_set_meta_refcount (name, name->meta.ref_count - 1);

      /**
       * DO NOT UNCOMMENT.
       * It breaks the code
       * Causes deallocation twice
       * Source: tested it.
       * Reason for double deallocation: currently unknown
       */
      // if (res != NULL)
      //   res->meta.ref_count--;
      // printf ("[%d]\n", res->meta.ref_count);

      return res;
    }
  else
    {
      /**
       * Currently we are treating brackets as a
       * function call with no name.
       * The arguments of this function are evaluated ideally.
       * ! The first argument of arglist is returned.
       * TODO: Convert this arglist to tuple and return the tuple (if argcount
       * > 1).
       */

      llnode_t *res = NULL;
      for (size_t i = 0; i < e->v.fun_call.arg_count; i++)
        {
          llnode_t *c = eval_expr (mod, &e->v.fun_call.args[i]);

          /*
            Instead of setting ref_count to this+1 and then
            resetting it to this-1, I will just set ref_count
            as ref_count only to check for rvalues (and destroy them).
          */
          if (!i)
            res = c; // no self assignment as we are returning first index
          else
            sf_ll_set_meta_refcount (c, c->meta.ref_count); // self assignment
        }

      if (res == NULL)
        {
          obj_t *ro = sf_ast_objnew (OBJ_CONST);
          ro->v.o_const.type = CONST_NONE;

          res = sf_ot_addobj (ro);
        }

      return res;
    }

  return NULL; // unreachable code
}

llnode_t *
_sf_class_construct (mod_t *mod, obj_t *o, expr_t *e)
{
  class_t *t = o->v.o_class.val;
  class_t *nobj = sf_class_new (t->name, SF_CLASS_CODED);

  nobj->meta.iscobj = 1;
  nobj->meta.clref = t;
  nobj->mod
      = sf_mod_new (MOD_TYPE_CLASS, (t->mod != NULL ? t->mod->parent : NULL));

  nobj->mod->meta.cref = nobj;

  char **vars = sf_trie_getKeys (t->mod->vtable);
  mod_t *par_pres = nobj->mod->parent;
  nobj->mod->parent = NULL;

  for (size_t i = 0; vars[i] != NULL; i++)
    {
      sf_mod_addVar (nobj->mod, vars[i], sf_mod_getVar (t->mod, vars[i]));
      sffree (vars[i]);
    }

  nobj->mod->parent = par_pres;

  sf_class_add (nobj);

  obj_t *oj = sf_ast_objnew (OBJ_CLASSOBJ);
  oj->v.o_cobj.val = nobj;

  llnode_t *oll = sf_ot_addobj (oj);

  /**
   * We pass `oll` to _init ()
   * In order to prevent being free'd
   * We set it's reference count to 1
   * So when passed as an argument it's reference count
   * goes to 2 and upon destruction, it falls back to 1
   * thereby preventing deallocation.
   *
   * Later, we will return this same object
   * but with reference count = 0
   */
  sf_ll_set_meta_refcount (oll, oll->meta.ref_count + 1);

  /*
    Call class._init()
  */
  /*llnode_t *fr = eval_expr (
      nobj->mod,
      (expr_t *)(expr_t[]){ (expr_t){
          .type = EXPR_FUN_CALL,
          .v.fun_call = { .arg_count = e->v.fun_call.arg_count,
                          .args = e->v.fun_call.args,
                          .name = (expr_t *)(expr_t[]){ (expr_t){
                              .type = EXPR_VAR,
                              .v.var.name = (
                                  sf_charptr)SF_CLASSCONSTRUCTOR_NAME,
                          } } } } });

  sf_ll_set_meta_refcount (fr, fr->meta.ref_count - 1);*/

  llnode_t *_init_ll = sf_mod_getVar (nobj->mod, SF_CLASSCONSTRUCTOR_NAME);

  if (_init_ll != NULL)
    {
      sf_ll_set_meta_refcount (_init_ll, _init_ll->meta.ref_count + 1);
      obj_t *init_o = (obj_t *)_init_ll->val;

      if (init_o->type != OBJ_FUN)
        {
          e_printf ("_init() is not callable in _sf_class_construct.\n");
        }
      else
        {
          fun_t *f = init_o->v.o_fun.f;
          mod_t *fmd = sf_mod_new (MOD_TYPE_FUNC, NULL);
          fmd->body = f->mod->body;
          fmd->body_len = f->mod->body_len;

          assert (f->argc > 0);
          sf_mod_addVar (fmd, f->args[0], oll);

          for (size_t i = 1; i < f->argc; i++)
            {
              expr_t *ee = &e->v.fun_call.args[i - 1];
              llnode_t *t = eval_expr (mod, ee);

              sf_mod_addVar (fmd, f->args[i], t);
            }

          fmd->parent = nobj->mod;
          sf_parser_exec (fmd);

          fmd->body = NULL;
          fmd->body_len = 0;
          fmd->parent = NULL;
          sf_mod_free (fmd);
        }

      sf_ll_set_meta_refcount (_init_ll, _init_ll->meta.ref_count - 1);
    }

  // ! WARNING: Possibly unsafe
  /**
   * Manually reset flags (and not using functions)
   * because I do not wish to lose the object.
   * (Basically, reset flags but don't check if it is 0
   */
  oll->meta.ref_count = 0;

  sffree (vars);
  return oll;
}

int
_sf_obj_cmp (mod_t *mod, obj_t *o1, obj_t *o2)
{
  if (o1->type != o2->type)
    goto end;

  switch (o1->type)
    {
    case OBJ_ARRAY:
      {
        array_t *t1 = o1->v.o_array.v;
        array_t *t2 = o2->v.o_array.v;

        for (size_t i = 0; i < t1->len; i++)
          {
            if (!_sf_obj_cmp (mod, (obj_t *)t1->vals[i]->val,
                              (obj_t *)t2->vals[i]->val))
              goto end;
          }
      }
      break;

    case OBJ_CONST:
      {
        if (o1->v.o_const.type != o2->v.o_const.type)
          goto end;

        switch (o1->v.o_const.type)
          {
          case CONST_BOOL:
            return o1->v.o_const.v.c_bool.v == o2->v.o_const.v.c_bool.v;

          case CONST_FLOAT:
            return o1->v.o_const.v.c_float.v == o2->v.o_const.v.c_float.v;

          case CONST_INT:
            return o1->v.o_const.v.c_int.v == o2->v.o_const.v.c_int.v;

          case CONST_STRING:
            return sf_str_eq (o1->v.o_const.v.c_string.v,
                              o2->v.o_const.v.c_string.v);

          case CONST_NONE:
            return o2->v.o_const.type == CONST_NONE;

          default:
            e_printf ("Invalid constant type '%d' at _sf_obj_cmp()\n",
                      o1->v.o_const.type);
            break;
          }
      }
      break;

    case OBJ_FUN:
      {
        fun_t *f1 = o1->v.o_fun.f;
        fun_t *f2 = o2->v.o_fun.f;

        if (f1->argc == f2->argc && f1->type == f2->type
            && !strcmp (f1->name, f2->name))
          {
            // change one parameter of f1 temporarily
            // if the same is changed in f2, then both
            // are alike

            int f1t_pres = f1->type;
            f1->type = -1;

            if (f2->type == -1)
              {
                f1->type = f1t_pres;
                return 1;
              }

            f1->type = f1t_pres;
            goto end;
          }
        else
          goto end;
      }
      break;

    default:
      e_printf ("Invalid object type '%d' at _sf_obj_cmp()\n", o1->type);
      break;
    }

end:
  return 0;
}

llnode_t *
_sf_exec_compare (mod_t *mod, expr_t *e)
{
  int r = 0;
  llnode_t *lv = eval_expr (mod, e->v.expr_conditional.lval);
  llnode_t *rv = eval_expr (mod, e->v.expr_conditional.rval);

  sf_ll_set_meta_refcount (lv, lv->meta.ref_count + 1);
  sf_ll_set_meta_refcount (rv, rv->meta.ref_count + 1);

  /**
   * Write logic for, say, `>=` operator.
   * Now, for `<`, set swch to 1 and jump to logic of `>=` and execute
   * with switched logic.
   */
  int swch = 0; // switch logic

  obj_t *lvo = (obj_t *)lv->val;
  obj_t *rvo = (obj_t *)rv->val;

  switch (e->type)
    {
    case EXPR_CONDITIONAL_GT:
      {
      cnd_lab_gt:
        if (OBJ_IS_NUMBER (lvo) && OBJ_IS_NUMBER (rvo))
          {
            const float l1 = lvo->v.o_const.type == CONST_INT
                                 ? (float)lvo->v.o_const.v.c_int.v
                                 : lvo->v.o_const.v.c_float.v;

            const float l2 = rvo->v.o_const.type == CONST_INT
                                 ? (float)rvo->v.o_const.v.c_int.v
                                 : rvo->v.o_const.v.c_float.v;

            r = swch ? (l1 - l2 <= 0.0f) : (l1 - l2 > 0.0f);
          }
      }
      break;

    case EXPR_CONDITIONAL_LT:
      {
      cnd_lab_lt:
        if (OBJ_IS_NUMBER (lvo) && OBJ_IS_NUMBER (rvo))
          {
            const float l1 = lvo->v.o_const.type == CONST_INT
                                 ? (float)lvo->v.o_const.v.c_int.v
                                 : lvo->v.o_const.v.c_float.v;

            const float l2 = rvo->v.o_const.type == CONST_INT
                                 ? (float)rvo->v.o_const.v.c_int.v
                                 : rvo->v.o_const.v.c_float.v;

            r = swch ? (l1 - l2 >= 0.0f) : (l1 - l2 < 0.0f);
          }
      }
      break;

    case EXPR_CONDITIONAL_NEQ:
      {
        r = !_sf_obj_cmp (mod, (obj_t *)lv->val, (obj_t *)rv->val);
      }
      break;

    case EXPR_CONDITIONAL_EQEQ:
      {
        r = _sf_obj_cmp (mod, (obj_t *)lv->val, (obj_t *)rv->val);
      }
      break;

    case EXPR_CONDITIONAL_GTEQ:
      {
        swch = 1;
        goto cnd_lab_lt;
      }
      break;

    case EXPR_CONDITIONAL_LTEQ:
      {
        swch = 1;
        goto cnd_lab_gt;
      }
      break;

    default:
      {
        e_printf ("Cannot compare types '%d' and '%d'",
                  e->v.expr_conditional.lval->type,
                  e->v.expr_conditional.rval->type);
      }
      break;
    }

  sf_ll_set_meta_refcount (lv, lv->meta.ref_count - 1);
  sf_ll_set_meta_refcount (rv, rv->meta.ref_count - 1);

  obj_t *o_res = sf_ast_objnew (OBJ_CONST);
  o_res->v.o_const.type = CONST_BOOL;
  o_res->v.o_const.v.c_bool.v = r;

  return sf_ot_addobj (o_res);
}

llnode_t *
_sf_ev_arith (mod_t *m, expr_t *e)
{
  tree_t *ac = e->v.e_arith.tree;
  int c = sf_tree_countNodes (ac);

  tree_t **nodes = sfmalloc (c * sizeof (*nodes));
  int nc = 0;
  nodes[nc++] = ac;

  while (nc > 0)
    {
      tree_t *last_node = nodes[--nc];

      struct _sfa_treetok_s *nval = (struct _sfa_treetok_s *)last_node->val;

      if (!nval->is_op)
        {
          nval->is_llnode = 1;
          expr_t *ecpy = nval->v.val;

          nval->node = eval_expr (m, ecpy);
          sf_ll_set_meta_refcount (nval->node, nval->node->meta.ref_count + 1);
        }

      if (last_node->left)
        nodes[nc++] = last_node->left;

      if (last_node->right)
        nodes[nc++] = last_node->right;
    }

  __sfaarith_res res = sf_arith_eval_tree (m, ac);

  obj_t *robj = sf_ast_objnew (OBJ_CONST);
  robj->v.o_const.type = CONST_FLOAT;

  llnode_t *retval;
  if (res.type == SF_ARITH_RES_DOUBLE)
    {
      robj->v.o_const.v.c_float.v = res.v.dres.v;
      retval = sf_ot_addobj (robj);
    }

  else
    {
      robj = res.v.ores.v;

      assert (robj->meta.mem_ref != NULL);
      retval = robj->meta.mem_ref;
    }

  nc = 0;
  nodes[nc++] = ac;

  while (nc > 0)
    {
      tree_t *last_node = nodes[--nc];

      struct _sfa_treetok_s *nval = (struct _sfa_treetok_s *)last_node->val;

      if (!nval->is_op)
        {
          sf_ll_set_meta_refcount (nval->node, nval->node->meta.ref_count - 1);
          nval->node = NULL;
          nval->is_llnode = 0;
        }

      if (last_node->left)
        nodes[nc++] = last_node->left;

      if (last_node->right)
        nodes[nc++] = last_node->right;
    }

  sffree (nodes);

  /* obj_t *noneobj = sfmalloc (sizeof (*noneobj));
  noneobj->type = OBJ_CONST;
  noneobj->v.o_const.type = CONST_NONE;
  llnode_t *retval = sf_ot_addobj (noneobj); */

  return retval;
}

SF_API char *
sf_parser_objRepr (mod_t *mod, obj_t *obj)
{
  sf_charptr res;

  switch (obj->type)
    {
    case OBJ_CONST:
      {
        int ot = obj->v.o_const.type;

        switch (ot)
          {
          case CONST_INT:
            {
              int i = obj->v.o_const.v.c_int.v;
              int size = 1; /* for \0 */
              int isneg = 0;

              if (i < 0)
                {
                  size++; // '-'
                  isneg = 1;
                }

              do
                {
                  size++;
                  i /= 10;
                }
              while (i);

              char *r = sfmalloc (size * sizeof (*r));
              sprintf (r, "%d", obj->v.o_const.v.c_int.v);

              res = sf_str_new_fromStr (r);

              sffree (r);
            }
            break;

          case CONST_FLOAT:
            {
              char *r = sfmalloc (32 * sizeof (*r));

              sprintf (r, "%g", obj->v.o_const.v.c_float.v);

              res = sf_str_new_fromStr (r);

              sffree (r);
            }
            break;

          case CONST_BOOL:
            {
              if (obj->v.o_const.v.c_bool.v)
                res = sf_str_new_fromStr (SF_BOOL_TRUE_REPR);

              else
                res = sf_str_new_fromStr (SF_BOOL_FALSE_REPR);
            }
            break;

          case CONST_STRING:
            {
              res = sf_str_new_fromStr (
                  SFCPTR_TOSTR (obj->v.o_const.v.c_string.v));
            }
            break;

          case CONST_NONE:
            res = sf_str_new_fromStr (SF_DTYPE_NONE_REPR);
            break;

          default:
            break;
          }
      }
      break;

    case OBJ_FUN:
      {
        char *r
            = sfmalloc ((16 + strlen (obj->v.o_fun.f->name)) * sizeof (char));

        sprintf (r, "<function '%s'>", obj->v.o_fun.f->name);

        res = sf_str_new_fromStr (r);

        sffree (r);
      }
      break;

    case OBJ_ARRAY:
      {
        array_t *t = obj->v.o_array.v;
        assert (t != NULL);

        res = sf_str_new_fromStr ("[");

        for (size_t i = 0; i < t->len; i++)
          {
            char *p;
            sf_str_push (
                &res, p = sf_parser_objRepr (mod, (obj_t *)(t->vals[i]->val)));

            sffree (p);

            if (i != t->len - 1)
              sf_str_push (&res, ", ");
          }

        sf_str_push (&res, "]");
      }
      break;

    case OBJ_CLASS:
      {
        class_t *t = obj->v.o_class.val;
        res = sf_str_new_fromSize (13 + strlen (t->name));

        sprintf (res, "<class '%s'>", t->name);
      }
      break;

    case OBJ_CLASSOBJ:
      {
        class_t *t = obj->v.o_cobj.val;
        res = sf_str_new_fromSize (22 + strlen (t->name));

        sprintf (res, "<class instance '%s'>", t->name);
      }
      break;

    default:
      e_printf ("Unknown type '%d' in sf_parser_objRepr()\n", obj->type);
      break;
    }

  return SFCPTR_TOSTR (res);
}