src/proc.c

   1 /*
   2 ** proc.c - Proc class
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/class.h>
   9 #include <mruby/proc.h>
  10 #include <mruby/opcode.h>
  11 #include <mruby/data.h>
  12 #include <mruby/array.h>
  13 #include <mruby/hash.h>
  14 #include <mruby/internal.h>
  15 #include <mruby/presym.h>
  16
  17 static const mrb_code call_iseq[] = {
  18   OP_CALL,
  19 };
  20
  21 static const mrb_irep call_irep = {
  22   0,                                   /* nlocals */
  23   2,                                   /* nregs */
  24   0,                                   /* clen */
  25   MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
  26   call_iseq,                           /* iseq */
  27   NULL,                                /* pool */
  28   NULL,                                /* syms */
  29   NULL,                                /* reps */
  30   NULL,                                /* lv */
  31   NULL,                                /* debug_info */
  32   1,                                   /* ilen */
  33   0,                                   /* plen */
  34   0,                                   /* slen */
  35   1,                                   /* rlen */
  36   0,                                   /* refcnt */
  37 };
  38
  39 static const struct RProc call_proc = {
  40   NULL, NULL, MRB_TT_PROC, MRB_GC_RED, MRB_FL_OBJ_IS_FROZEN | MRB_PROC_SCOPE | MRB_PROC_STRICT,
  41   { &call_irep }, NULL, { NULL }
  42 };
  43
  44 struct RProc*
  45 mrb_proc_new(mrb_state *mrb, const mrb_irep *irep)
  46 {
  47   struct RProc *p;
  48   mrb_callinfo *ci = mrb->c->ci;
  49
  50   p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
  51   if (ci) {
  52     struct RClass *tc = NULL;
  53
  54     if (ci->proc) {
  55       tc = MRB_PROC_TARGET_CLASS(ci->proc);
  56     }
  57     if (tc == NULL) {
  58       tc = mrb_vm_ci_target_class(ci);
  59     }
  60     p->upper = ci->proc;
  61     p->e.target_class = tc;
  62   }
  63   if (irep) {
  64     mrb_irep_incref(mrb, (mrb_irep*)irep);
  65   }
  66   p->body.irep = irep;
  67
  68   return p;
  69 }
  70
  71 struct REnv*
  72 mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks, mrb_value *stack, struct RClass *tc)
  73 {
  74   struct REnv *e;
  75   mrb_int bidx = 1;
  76   int n = ci->n;
  77   int nk = ci->nk;
  78
  79   e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL);
  80   e->c = tc;
  81   MRB_ENV_SET_LEN(e, nstacks);
  82   bidx += (n == 15) ? 1 : n;
  83   bidx += (nk == 15) ? 1 : (2*nk);
  84   MRB_ENV_SET_BIDX(e, bidx);
  85   e->mid = ci->mid;
  86   e->stack = stack;
  87   e->cxt = c;
  88
  89   return e;
  90 }
  91
  92 static void
  93 closure_setup(mrb_state *mrb, struct RProc *p)
  94 {
  95   mrb_callinfo *ci = mrb->c->ci;
  96   const struct RProc *up = p->upper;
  97   struct REnv *e = NULL;
  98
  99   mrb_assert(ci != NULL);
 100   if ((e = mrb_vm_ci_env(ci)) != NULL) {
 101     /* do nothing, because e is assigned already */
 102   }
 103   else if (up) {
 104     struct RClass *tc = ci->u.target_class;
 105
 106     if (MRB_PROC_ALIAS_P(up)) { /* alias */
 107       up = up->upper;
 108     }
 109     e = mrb_env_new(mrb, mrb->c, ci, up->body.irep->nlocals, ci->stack, tc);
 110     ci->u.env = e;
 111     if (MRB_PROC_ENV_P(up) && MRB_PROC_ENV(up)->cxt == NULL) {
 112       e->mid = MRB_PROC_ENV(up)->mid;
 113     }
 114   }
 115   if (e) {
 116     p->e.env = e;
 117     p->flags |= MRB_PROC_ENVSET;
 118     mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
 119   }
 120 }
 121
 122 struct RProc*
 123 mrb_closure_new(mrb_state *mrb, const mrb_irep *irep)
 124 {
 125   struct RProc *p = mrb_proc_new(mrb, irep);
 126
 127   closure_setup(mrb, p);
 128   return p;
 129 }
 130
 131 MRB_API struct RProc*
 132 mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func)
 133 {
 134   struct RProc *p;
 135
 136   p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
 137   p->body.func = func;
 138   p->flags |= MRB_PROC_CFUNC_FL;
 139   p->upper = 0;
 140   p->e.target_class = 0;
 141
 142   return p;
 143 }
 144
 145 MRB_API struct RProc*
 146 mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv)
 147 {
 148   struct RProc *p = mrb_proc_new_cfunc(mrb, func);
 149   struct REnv *e;
 150   int i;
 151
 152   p->e.env = e = mrb_env_new(mrb, mrb->c, mrb->c->ci, 0, NULL, NULL);
 153   p->flags |= MRB_PROC_ENVSET;
 154   mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
 155   MRB_ENV_CLOSE(e);
 156
 157   e->stack = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * argc);
 158   MRB_ENV_SET_LEN(e, argc);
 159
 160   if (argv) {
 161     for (i = 0; i < argc; i++) {
 162       e->stack[i] = argv[i];
 163     }
 164   }
 165   else {
 166     for (i = 0; i < argc; i++) {
 167       SET_NIL_VALUE(e->stack[i]);
 168     }
 169   }
 170   return p;
 171 }
 172
 173 MRB_API struct RProc*
 174 mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
 175 {
 176   return mrb_proc_new_cfunc_with_env(mrb, func, nlocals, NULL);
 177 }
 178
 179 MRB_API mrb_value
 180 mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx)
 181 {
 182   const struct RProc *p = mrb->c->ci->proc;
 183   struct REnv *e;
 184
 185   if (!p || !MRB_PROC_CFUNC_P(p)) {
 186     mrb_raise(mrb, E_TYPE_ERROR, "Can't get cfunc env from non-cfunc proc");
 187   }
 188   e = MRB_PROC_ENV(p);
 189   if (!e) {
 190     mrb_raise(mrb, E_TYPE_ERROR, "Can't get cfunc env from cfunc Proc without REnv");
 191   }
 192   if (idx < 0 || MRB_ENV_LEN(e) <= idx) {
 193     mrb_raisef(mrb, E_INDEX_ERROR, "Env index out of range: %i (expected: 0 <= index < %i)",
 194                idx, MRB_ENV_LEN(e));
 195   }
 196
 197   return e->stack[idx];
 198 }
 199
 200 mrb_value
 201 mrb_proc_get_self(mrb_state *mrb, struct RProc *p, struct RClass **target_class_p)
 202 {
 203   if (MRB_PROC_CFUNC_P(p)) {
 204     *target_class_p = mrb->object_class;
 205     return mrb_nil_value();
 206   }
 207   else {
 208     struct REnv *e = p->e.env;
 209
 210     if (!e || e->tt != MRB_TT_ENV) {
 211       *target_class_p = mrb->object_class;
 212       return mrb_top_self(mrb);
 213     }
 214     else if (MRB_ENV_LEN(e) < 1) {
 215       mrb_raise(mrb, E_ARGUMENT_ERROR, "self is lost (probably ran out of memory when the block became independent)");
 216     }
 217
 218     *target_class_p = e->c;
 219     return e->stack[0];
 220   }
 221 }
 222
 223 void
 224 mrb_proc_copy(mrb_state *mrb, struct RProc *a, struct RProc *b)
 225 {
 226   if (a->body.irep) {
 227     /* already initialized proc */
 228     return;
 229   }
 230   if (!MRB_PROC_CFUNC_P(b) && b->body.irep) {
 231     mrb_irep_incref(mrb, (mrb_irep*)b->body.irep);
 232   }
 233   a->flags = b->flags;
 234   a->body = b->body;
 235   a->upper = b->upper;
 236   a->e.env = b->e.env;
 237   /* a->e.target_class = a->e.target_class; */
 238 }
 239
 240 static mrb_value
 241 mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class)
 242 {
 243   mrb_value blk;
 244   mrb_value proc;
 245   struct RProc *p;
 246
 247   /* Calling Proc.new without a block is not implemented yet */
 248   mrb_get_args(mrb, "&!", &blk);
 249   p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class));
 250   mrb_proc_copy(mrb, p, mrb_proc_ptr(blk));
 251   proc = mrb_obj_value(p);
 252   mrb_funcall_with_block(mrb, proc, MRB_SYM(initialize), 0, NULL, proc);
 253   if (!MRB_PROC_STRICT_P(p) &&
 254       mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].u.env) {
 255     p->flags |= MRB_PROC_ORPHAN;
 256   }
 257   return proc;
 258 }
 259
 260 static void
 261 check_proc(mrb_state *mrb, mrb_value proc)
 262 {
 263   if (!mrb_proc_p(proc)) {
 264     mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc");
 265   }
 266 }
 267
 268 static mrb_value
 269 mrb_proc_init_copy(mrb_state *mrb, mrb_value self)
 270 {
 271   mrb_value proc = mrb_get_arg1(mrb);
 272
 273   check_proc(mrb, proc);
 274   mrb_proc_copy(mrb, mrb_proc_ptr(self), mrb_proc_ptr(proc));
 275   return self;
 276 }
 277
 278 static mrb_value
 279 proc_arity(mrb_state *mrb, mrb_value self)
 280 {
 281   return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self)));
 282 }
 283
 284 mrb_bool
 285 mrb_proc_eql(mrb_state *mrb, mrb_value self, mrb_value other)
 286 {
 287   if (mrb_type(self) != MRB_TT_PROC) return FALSE;
 288   if (mrb_type(other) != MRB_TT_PROC) return FALSE;
 289
 290   struct RProc *p1 = mrb_proc_ptr(self);
 291   struct RProc *p2 = mrb_proc_ptr(other);
 292   if (MRB_PROC_CFUNC_P(p1)) {
 293     if (!MRB_PROC_CFUNC_P(p1)) return FALSE;
 294     if (p1->body.func != p2->body.func) return FALSE;
 295   }
 296   else if (MRB_PROC_CFUNC_P(p2)) return FALSE;
 297   else if (p1->body.irep != p2->body.irep) return FALSE;
 298   return TRUE;
 299 }
 300
 301 static mrb_value
 302 proc_eql(mrb_state *mrb, mrb_value self)
 303 {
 304   return mrb_bool_value(mrb_proc_eql(mrb, self, mrb_get_arg1(mrb)));
 305 }
 306
 307 static mrb_value
 308 proc_hash(mrb_state *mrb, mrb_value self)
 309 {
 310   struct RProc *p = mrb_proc_ptr(self);
 311   return mrb_int_value(mrb, (mrb_int)(((intptr_t)p->body.irep)^MRB_TT_PROC));
 312 }
 313
 314 /* 15.3.1.2.6  */
 315 /* 15.3.1.3.27 */
 316 /*
 317  * call-seq:
 318  *   lambda { |...| block }  -> a_proc
 319  *
 320  * Equivalent to <code>Proc.new</code>, except the resulting Proc objects
 321  * check the number of parameters passed when called.
 322  */
 323 static mrb_value
 324 proc_lambda(mrb_state *mrb, mrb_value self)
 325 {
 326   mrb_value blk;
 327   struct RProc *p;
 328
 329   mrb_get_args(mrb, "&", &blk);
 330   if (mrb_nil_p(blk)) {
 331     mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
 332   }
 333   check_proc(mrb, blk);
 334   p = mrb_proc_ptr(blk);
 335   if (!MRB_PROC_STRICT_P(p)) {
 336     struct RProc *p2 = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, p->c);
 337     mrb_proc_copy(mrb, p2, p);
 338     p2->flags |= MRB_PROC_STRICT;
 339     return mrb_obj_value(p2);
 340   }
 341   return blk;
 342 }
 343
 344 mrb_int
 345 mrb_proc_arity(const struct RProc *p)
 346 {
 347   const mrb_irep *irep;
 348   const mrb_code *pc;
 349   mrb_aspec aspec;
 350   int ma, op, ra, pa, arity;
 351
 352   if (MRB_PROC_CFUNC_P(p)) {
 353     /* TODO cfunc aspec not implemented yet */
 354     return -1;
 355   }
 356
 357   irep = p->body.irep;
 358   if (!irep) {
 359     return 0;
 360   }
 361
 362   pc = irep->iseq;
 363   /* arity is depend on OP_ENTER */
 364   if (*pc != OP_ENTER) {
 365     return 0;
 366   }
 367
 368   aspec = PEEK_W(pc+1);
 369   ma = MRB_ASPEC_REQ(aspec);
 370   op = MRB_ASPEC_OPT(aspec);
 371   ra = MRB_ASPEC_REST(aspec);
 372   pa = MRB_ASPEC_POST(aspec);
 373   arity = ra || (MRB_PROC_STRICT_P(p) && op) ? -(ma + pa + 1) : ma + pa;
 374
 375   return arity;
 376 }
 377
 378 mrb_value
 379 mrb_proc_local_variables(mrb_state *mrb, const struct RProc *proc)
 380 {
 381   const mrb_irep *irep;
 382   mrb_value vars;
 383   size_t i;
 384
 385   if (proc == NULL || MRB_PROC_CFUNC_P(proc)) {
 386     return mrb_ary_new(mrb);
 387   }
 388   vars = mrb_hash_new(mrb);
 389   while (proc) {
 390     if (MRB_PROC_CFUNC_P(proc)) break;
 391     irep = proc->body.irep;
 392     if (irep->lv) {
 393       for (i = 0; i + 1 < irep->nlocals; i++) {
 394         if (irep->lv[i]) {
 395           mrb_sym sym = irep->lv[i];
 396           const char *name = mrb_sym_name(mrb, sym);
 397           switch (name[0]) {
 398           case '*': case '&':
 399             break;
 400           default:
 401             mrb_hash_set(mrb, vars, mrb_symbol_value(sym), mrb_true_value());
 402             break;
 403           }
 404         }
 405       }
 406     }
 407     if (MRB_PROC_SCOPE_P(proc)) break;
 408     proc = proc->upper;
 409   }
 410
 411   return mrb_hash_keys(mrb, vars);
 412 }
 413
 414 const struct RProc *
 415 mrb_proc_get_caller(mrb_state *mrb, struct REnv **envp)
 416 {
 417   struct mrb_context *c = mrb->c;
 418   mrb_callinfo *ci = (c->ci > c->cibase) ? c->ci - 1 : c->cibase;
 419   const struct RProc *proc = ci->proc;
 420
 421   if (!proc || MRB_PROC_CFUNC_P(proc)) {
 422     if (envp) *envp = NULL;
 423   }
 424   else {
 425     struct REnv *e = mrb_vm_ci_env(ci);
 426
 427     if (e == NULL) {
 428       int nstacks = proc->body.irep->nlocals;
 429       e = mrb_env_new(mrb, c, ci, nstacks, ci->stack, mrb_vm_ci_target_class(ci));
 430       ci->u.env = e;
 431     }
 432     if (envp) *envp = e;
 433   }
 434
 435   return proc;
 436 }
 437
 438 #define IREP_LVAR_MERGE_DEFAULT  50
 439 #define IREP_LVAR_MERGE_MINIMUM   8
 440 #define IREP_LVAR_MERGE_MAXIMUM 240
 441
 442 #ifdef MRB_IREP_LVAR_MERGE_LIMIT
 443 # define IREP_LVAR_MERGE_LIMIT \
 444   ((MRB_IREP_LVAR_MERGE_LIMIT) < IREP_LVAR_MERGE_MINIMUM ? IREP_LVAR_MERGE_MINIMUM : \
 445    (MRB_IREP_LVAR_MERGE_LIMIT) > IREP_LVAR_MERGE_MAXIMUM ? IREP_LVAR_MERGE_MAXIMUM : \
 446    (MRB_IREP_LVAR_MERGE_LIMIT))
 447 #else
 448 # define IREP_LVAR_MERGE_LIMIT IREP_LVAR_MERGE_DEFAULT
 449 #endif
 450
 451 void
 452 mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack)
 453 {
 454   mrb_assert(!(irep->flags & MRB_IREP_NO_FREE));
 455
 456   if ((irep->nlocals + num) > IREP_LVAR_MERGE_LIMIT) {
 457     mrb_raise(mrb, E_RUNTIME_ERROR, "too many local variables for binding (mruby limitation)");
 458   }
 459
 460   if (!lv) {
 461     mrb_raise(mrb, E_RUNTIME_ERROR, "unavailable local variable names");
 462   }
 463
 464   irep->lv = (mrb_sym*)mrb_realloc(mrb, (mrb_sym*)irep->lv, sizeof(mrb_sym) * (irep->nlocals - 1 /* self */ + num));
 465   env->stack = (mrb_value*)mrb_realloc(mrb, env->stack, sizeof(mrb_value) * (irep->nlocals + num));
 466
 467   mrb_sym *destlv = (mrb_sym*)irep->lv + irep->nlocals - 1 /* self */;
 468   mrb_value *destst = env->stack + irep->nlocals;
 469   memmove(destlv, lv, sizeof(mrb_sym) * num);
 470   if (stack) {
 471     memmove(destst, stack, sizeof(mrb_value) * num);
 472     for (int i = 0; i < num; i++) {
 473       if (!mrb_immediate_p(stack[i])) {
 474         mrb_field_write_barrier(mrb, (struct RBasic*)env, (struct RBasic*)mrb_obj_ptr(stack[i]));
 475       }
 476     }
 477   }
 478   else {
 479     for (int i = num; i > 0; i--, destst++) {
 480       *destst = mrb_nil_value();
 481     }
 482   }
 483   irep->nlocals += num;
 484   irep->nregs = irep->nlocals;
 485   MRB_ENV_SET_LEN(env, irep->nlocals);
 486 }
 487
 488 void
 489 mrb_init_proc(mrb_state *mrb)
 490 {
 491   mrb_method_t m;
 492   struct RClass *pc = mrb->proc_class = mrb_define_class_id(mrb, MRB_SYM(Proc), mrb->object_class); /* 15.2.17 */
 493
 494   MRB_SET_INSTANCE_TT(pc, MRB_TT_PROC);
 495   MRB_UNDEF_ALLOCATOR(pc);
 496   mrb_define_class_method_id(mrb, pc, MRB_SYM(new), mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
 497   mrb_define_method_id(mrb, pc, MRB_SYM(initialize_copy), mrb_proc_init_copy, MRB_ARGS_REQ(1));
 498   mrb_define_method_id(mrb, pc, MRB_SYM(arity), proc_arity, MRB_ARGS_NONE()); /* 15.2.17.4.2 */
 499   mrb_define_method_id(mrb, pc, MRB_OPSYM(eq), proc_eql, MRB_ARGS_REQ(1));
 500   mrb_define_method_id(mrb, pc, MRB_SYM_Q(eql), proc_eql, MRB_ARGS_REQ(1));
 501   mrb_define_method_id(mrb, pc, MRB_SYM(hash), proc_hash, MRB_ARGS_NONE()); /* 15.2.17.4.2 */
 502
 503   MRB_METHOD_FROM_PROC(m, &call_proc);
 504   mrb_define_method_raw(mrb, pc, MRB_SYM(call), m);   /* 15.2.17.4.3 */
 505   mrb_define_method_raw(mrb, pc, MRB_OPSYM(aref), m); /* 15.2.17.4.1 */
 506
 507   mrb_define_method(mrb, mrb->kernel_module,       "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
 508 }