Ruby 3.4.1p0 (2024-12-25 revision 48d4efcb85000e1ebae42004e963b5d0cedddcf2)
vm_eval.c
1/**********************************************************************
2
3 vm_eval.c -
4
5 $Author$
6 created at: Sat May 24 16:02:32 JST 2008
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9 Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
10 Copyright (C) 2000 Information-technology Promotion Agency, Japan
11
12**********************************************************************/
13
14#include "internal/thread.h"
16 VALUE tbl;
17};
18
19static inline VALUE method_missing(rb_execution_context_t *ec, VALUE obj, ID id, int argc, const VALUE *argv, enum method_missing_reason call_status, int kw_splat);
20static inline VALUE vm_yield_with_cref(rb_execution_context_t *ec, int argc, const VALUE *argv, int kw_splat, const rb_cref_t *cref, int is_lambda);
21static inline VALUE vm_yield(rb_execution_context_t *ec, int argc, const VALUE *argv, int kw_splat);
22static inline VALUE vm_yield_with_block(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE block_handler, int kw_splat);
23static inline VALUE vm_yield_force_blockarg(rb_execution_context_t *ec, VALUE args);
24VALUE vm_exec(rb_execution_context_t *ec);
25static void vm_set_eval_stack(rb_execution_context_t * th, const rb_iseq_t *iseq, const rb_cref_t *cref, const struct rb_block *base_block);
26static int vm_collect_local_variables_in_heap(const VALUE *dfp, const struct local_var_list *vars);
27
28static VALUE rb_eUncaughtThrow;
29static ID id_result, id_tag, id_value;
30#define id_mesg idMesg
31
32static VALUE send_internal(int argc, const VALUE *argv, VALUE recv, call_type scope);
33static VALUE vm_call0_body(rb_execution_context_t* ec, struct rb_calling_info *calling, const VALUE *argv);
34
35static VALUE *
36vm_argv_ruby_array(VALUE *av, const VALUE *argv, int *flags, int *argc, int kw_splat)
37{
38 *flags |= VM_CALL_ARGS_SPLAT;
39 VALUE argv_ary = rb_ary_hidden_new(*argc);
40 rb_ary_cat(argv_ary, argv, *argc);
41 *argc = 2;
42 av[0] = argv_ary;
43 if (kw_splat) {
44 av[1] = rb_ary_pop(argv_ary);
45 }
46 else {
47 // Make sure flagged keyword hash passed as regular argument
48 // isn't treated as keywords
49 *flags |= VM_CALL_KW_SPLAT;
50 av[1] = rb_hash_new();
51 }
52 return av;
53}
54
55static inline VALUE vm_call0_cc(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, const struct rb_callcache *cc, int kw_splat);
56
58rb_vm_call0(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, const rb_callable_method_entry_t *cme, int kw_splat)
59{
60 const struct rb_callcache cc = VM_CC_ON_STACK(Qfalse, vm_call_general, {{ 0 }}, cme);
61 return vm_call0_cc(ec, recv, id, argc, argv, &cc, kw_splat);
62}
63
65rb_vm_call_with_refinements(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, int kw_splat)
66{
67 const rb_callable_method_entry_t *me =
68 rb_callable_method_entry_with_refinements(CLASS_OF(recv), id, NULL);
69 if (me) {
70 return rb_vm_call0(ec, recv, id, argc, argv, me, kw_splat);
71 }
72 else {
73 /* fallback to funcall (e.g. method_missing) */
74 return rb_funcallv(recv, id, argc, argv);
75 }
76}
77
78static inline VALUE
79vm_call0_cc(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, const struct rb_callcache *cc, int kw_splat)
80{
81 int flags = kw_splat ? VM_CALL_KW_SPLAT : 0;
82 VALUE *use_argv = (VALUE *)argv;
83 VALUE av[2];
84
85 if (UNLIKELY(vm_cc_cme(cc)->def->type == VM_METHOD_TYPE_ISEQ && argc > VM_ARGC_STACK_MAX)) {
86 use_argv = vm_argv_ruby_array(av, argv, &flags, &argc, kw_splat);
87 }
88
89 struct rb_calling_info calling = {
90 .cd = &(struct rb_call_data) {
91 .ci = &VM_CI_ON_STACK(id, flags, argc, NULL),
92 .cc = NULL,
93 },
94 .cc = cc,
95 .block_handler = vm_passed_block_handler(ec),
96 .recv = recv,
97 .argc = argc,
98 .kw_splat = kw_splat,
99 };
100
101 return vm_call0_body(ec, &calling, use_argv);
102}
103
104static VALUE
105vm_call0_cme(rb_execution_context_t *ec, struct rb_calling_info *calling, const VALUE *argv, const rb_callable_method_entry_t *cme)
106{
107 calling->cc = &VM_CC_ON_STACK(Qfalse, vm_call_general, {{ 0 }}, cme);
108 return vm_call0_body(ec, calling, argv);
109}
110
111static VALUE
112vm_call0_super(rb_execution_context_t *ec, struct rb_calling_info *calling, const VALUE *argv, VALUE klass, enum method_missing_reason ex)
113{
114 ID mid = vm_ci_mid(calling->cd->ci);
115 klass = RCLASS_SUPER(klass);
116
117 if (klass) {
118 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
119
120 if (cme) {
121 RUBY_VM_CHECK_INTS(ec);
122 return vm_call0_cme(ec, calling, argv, cme);
123 }
124 }
125
126 vm_passed_block_handler_set(ec, calling->block_handler);
127 return method_missing(ec, calling->recv, mid, calling->argc, argv, ex, calling->kw_splat);
128}
129
130static VALUE
131vm_call0_cfunc_with_frame(rb_execution_context_t* ec, struct rb_calling_info *calling, const VALUE *argv)
132{
133 const struct rb_callinfo *ci = calling->cd->ci;
134 VALUE val;
135 const rb_callable_method_entry_t *me = vm_cc_cme(calling->cc);
136 const rb_method_cfunc_t *cfunc = UNALIGNED_MEMBER_PTR(me->def, body.cfunc);
137 int len = cfunc->argc;
138 VALUE recv = calling->recv;
139 int argc = calling->argc;
140 ID mid = vm_ci_mid(ci);
141 VALUE block_handler = calling->block_handler;
142 int frame_flags = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
143
144 if (calling->kw_splat) {
145 if (argc > 0 && RB_TYPE_P(argv[argc-1], T_HASH) && RHASH_EMPTY_P(argv[argc-1])) {
146 argc--;
147 }
148 else {
149 frame_flags |= VM_FRAME_FLAG_CFRAME_KW;
150 }
151 }
152
153 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
154 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, recv, me->def->original_id, mid, me->owner, Qnil);
155 {
156 rb_control_frame_t *reg_cfp = ec->cfp;
157
158 vm_push_frame(ec, 0, frame_flags, recv,
159 block_handler, (VALUE)me,
160 0, reg_cfp->sp, 0, 0);
161
162 if (len >= 0) rb_check_arity(argc, len, len);
163
164 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
165
166 CHECK_CFP_CONSISTENCY("vm_call0_cfunc_with_frame");
167 rb_vm_pop_frame(ec);
168 }
169 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, recv, me->def->original_id, mid, me->owner, val);
170 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
171
172 return val;
173}
174
175static VALUE
176vm_call0_cfunc(rb_execution_context_t *ec, struct rb_calling_info *calling, const VALUE *argv)
177{
178 return vm_call0_cfunc_with_frame(ec, calling, argv);
179}
180
181static void
182vm_call_check_arity(struct rb_calling_info *calling, int argc, const VALUE *argv)
183{
184 if (calling->kw_splat &&
185 calling->argc > 0 &&
186 RB_TYPE_P(argv[calling->argc-1], T_HASH) &&
187 RHASH_EMPTY_P(argv[calling->argc-1])) {
188 calling->argc--;
189 }
190
191 rb_check_arity(calling->argc, argc, argc);
192}
193
194/* `ci' should point temporal value (on stack value) */
195static VALUE
196vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const VALUE *argv)
197{
198 const struct rb_callinfo *ci = calling->cd->ci;
199 const struct rb_callcache *cc = calling->cc;
200 VALUE ret;
201
202 retry:
203
204 switch (vm_cc_cme(cc)->def->type) {
205 case VM_METHOD_TYPE_ISEQ:
206 {
207 rb_control_frame_t *reg_cfp = ec->cfp;
208 int i;
209
210 CHECK_VM_STACK_OVERFLOW(reg_cfp, calling->argc + 1);
211 vm_check_canary(ec, reg_cfp->sp);
212
213 *reg_cfp->sp++ = calling->recv;
214 for (i = 0; i < calling->argc; i++) {
215 *reg_cfp->sp++ = argv[i];
216 }
217
218 if (ISEQ_BODY(def_iseq_ptr(vm_cc_cme(cc)->def))->param.flags.forwardable) {
219 vm_call_iseq_fwd_setup(ec, reg_cfp, calling);
220 }
221 else {
222 vm_call_iseq_setup(ec, reg_cfp, calling);
223 }
224 VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
225 return vm_exec(ec); // CHECK_INTS in this function
226 }
227 case VM_METHOD_TYPE_NOTIMPLEMENTED:
228 case VM_METHOD_TYPE_CFUNC:
229 ret = vm_call0_cfunc(ec, calling, argv);
230 goto success;
231 case VM_METHOD_TYPE_ATTRSET:
232 vm_call_check_arity(calling, 1, argv);
233 VM_CALL_METHOD_ATTR(ret,
234 rb_ivar_set(calling->recv, vm_cc_cme(cc)->def->body.attr.id, argv[0]),
235 (void)0);
236 goto success;
237 case VM_METHOD_TYPE_IVAR:
238 vm_call_check_arity(calling, 0, argv);
239 VM_CALL_METHOD_ATTR(ret,
240 rb_attr_get(calling->recv, vm_cc_cme(cc)->def->body.attr.id),
241 (void)0);
242 goto success;
243 case VM_METHOD_TYPE_BMETHOD:
244 ret = vm_call_bmethod_body(ec, calling, argv);
245 goto success;
246 case VM_METHOD_TYPE_ZSUPER:
247 {
248 VALUE klass = RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class);
249 return vm_call0_super(ec, calling, argv, klass, MISSING_SUPER);
250 }
251 case VM_METHOD_TYPE_REFINED:
252 {
253 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
254
255 if (cme->def->body.refined.orig_me) {
256 const rb_callable_method_entry_t *orig_cme = refined_method_callable_without_refinement(cme);
257 return vm_call0_cme(ec, calling, argv, orig_cme);
258 }
259
260 VALUE klass = cme->defined_class;
261 return vm_call0_super(ec, calling, argv, klass, 0);
262 }
263 case VM_METHOD_TYPE_ALIAS:
264 {
265 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
266 const rb_callable_method_entry_t *orig_cme = aliased_callable_method_entry(cme);
267
268 if (cme == orig_cme) rb_bug("same!!");
269
270 if (vm_cc_markable(cc)) {
271 return vm_call0_cme(ec, calling, argv, orig_cme);
272 }
273 else {
274 *((const rb_callable_method_entry_t **)&cc->cme_) = orig_cme;
275 goto retry;
276 }
277 }
278 case VM_METHOD_TYPE_MISSING:
279 {
280 vm_passed_block_handler_set(ec, calling->block_handler);
281 return method_missing(ec, calling->recv, vm_ci_mid(ci), calling->argc,
282 argv, MISSING_NOENTRY, calling->kw_splat);
283 }
284 case VM_METHOD_TYPE_OPTIMIZED:
285 switch (vm_cc_cme(cc)->def->body.optimized.type) {
286 case OPTIMIZED_METHOD_TYPE_SEND:
287 ret = send_internal(calling->argc, argv, calling->recv, calling->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
288 goto success;
289 case OPTIMIZED_METHOD_TYPE_CALL:
290 {
291 rb_proc_t *proc;
292 GetProcPtr(calling->recv, proc);
293 ret = rb_vm_invoke_proc(ec, proc, calling->argc, argv, calling->kw_splat, calling->block_handler);
294 goto success;
295 }
296 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
297 vm_call_check_arity(calling, 0, argv);
298 VM_CALL_METHOD_ATTR(ret,
299 vm_call_opt_struct_aref0(ec, calling),
300 (void)0);
301 goto success;
302 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET:
303 vm_call_check_arity(calling, 1, argv);
304 VM_CALL_METHOD_ATTR(ret,
305 vm_call_opt_struct_aset0(ec, calling, argv[0]),
306 (void)0);
307 goto success;
308 default:
309 rb_bug("vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
310 }
311 break;
312 case VM_METHOD_TYPE_UNDEF:
313 break;
314 }
315 rb_bug("vm_call0: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
316 return Qundef;
317
318 success:
319 RUBY_VM_CHECK_INTS(ec);
320 return ret;
321}
322
323VALUE
324rb_vm_call_kw(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc, const VALUE *argv, const rb_callable_method_entry_t *me, int kw_splat)
325{
326 return rb_vm_call0(ec, recv, id, argc, argv, me, kw_splat);
327}
328
329static inline VALUE
330vm_call_super(rb_execution_context_t *ec, int argc, const VALUE *argv, int kw_splat)
331{
332 VALUE recv = ec->cfp->self;
333 VALUE klass;
334 ID id;
335 rb_control_frame_t *cfp = ec->cfp;
336 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
337
338 if (VM_FRAME_RUBYFRAME_P(cfp)) {
339 rb_bug("vm_call_super: should not be reached");
340 }
341
342 klass = RCLASS_ORIGIN(me->defined_class);
343 klass = RCLASS_SUPER(klass);
344 id = me->def->original_id;
345 me = rb_callable_method_entry(klass, id);
346
347 if (!me) {
348 return method_missing(ec, recv, id, argc, argv, MISSING_SUPER, kw_splat);
349 }
350 return rb_vm_call_kw(ec, recv, id, argc, argv, me, kw_splat);
351}
352
353VALUE
354rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
355{
356 rb_execution_context_t *ec = GET_EC();
357 PASS_PASSED_BLOCK_HANDLER_EC(ec);
358 return vm_call_super(ec, argc, argv, kw_splat);
359}
360
361VALUE
362rb_call_super(int argc, const VALUE *argv)
363{
364 return rb_call_super_kw(argc, argv, RB_NO_KEYWORDS);
365}
366
367VALUE
369{
370 const rb_execution_context_t *ec = GET_EC();
371 rb_control_frame_t *cfp;
372 if (!ec || !(cfp = ec->cfp)) {
373 rb_raise(rb_eRuntimeError, "no self, no life");
374 }
375 return cfp->self;
376}
377
378static inline void
379stack_check(rb_execution_context_t *ec)
380{
381 if (!rb_ec_raised_p(ec, RAISED_STACKOVERFLOW) &&
382 rb_ec_stack_check(ec)) {
383 rb_ec_raised_set(ec, RAISED_STACKOVERFLOW);
384 rb_ec_stack_overflow(ec, FALSE);
385 }
386}
387
388void
389rb_check_stack_overflow(void)
390{
391#ifndef RB_THREAD_LOCAL_SPECIFIER
392 if (!ruby_current_ec_key) return;
393#endif
394 rb_execution_context_t *ec = GET_EC();
395 if (ec) stack_check(ec);
396}
397
398NORETURN(static void uncallable_object(VALUE recv, ID mid));
399static inline const rb_callable_method_entry_t *rb_search_method_entry(VALUE recv, ID mid);
400static inline enum method_missing_reason rb_method_call_status(rb_execution_context_t *ec, const rb_callable_method_entry_t *me, call_type scope, VALUE self);
401
402static VALUE
403gccct_hash(VALUE klass, ID mid)
404{
405 return (klass >> 3) ^ (VALUE)mid;
406}
407
408NOINLINE(static const struct rb_callcache *gccct_method_search_slowpath(rb_vm_t *vm, VALUE klass, unsigned int index, const struct rb_callinfo * ci));
409
410static const struct rb_callcache *
411gccct_method_search_slowpath(rb_vm_t *vm, VALUE klass, unsigned int index, const struct rb_callinfo *ci)
412{
413 struct rb_call_data cd = {
414 .ci = ci,
415 .cc = NULL
416 };
417
418 vm_search_method_slowpath0(vm->self, &cd, klass);
419
420 return vm->global_cc_cache_table[index] = cd.cc;
421}
422
423static void
424scope_to_ci(call_type scope, ID mid, int argc, struct rb_callinfo *ci)
425{
426 int flags = 0;
427
428 switch(scope) {
429 case CALL_PUBLIC:
430 break;
431 case CALL_FCALL:
432 flags |= VM_CALL_FCALL;
433 break;
434 case CALL_VCALL:
435 flags |= VM_CALL_VCALL;
436 break;
437 case CALL_PUBLIC_KW:
438 flags |= VM_CALL_KWARG;
439 break;
440 case CALL_FCALL_KW:
441 flags |= (VM_CALL_KWARG | VM_CALL_FCALL);
442 break;
443 }
444 *ci = VM_CI_ON_STACK(mid, flags, argc, NULL);
445}
446
447static inline const struct rb_callcache *
448gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci)
449{
450 VALUE klass;
451
452 if (!SPECIAL_CONST_P(recv)) {
453 klass = RBASIC_CLASS(recv);
454 if (UNLIKELY(!klass)) uncallable_object(recv, mid);
455 }
456 else {
457 klass = CLASS_OF(recv);
458 }
459
460 // search global method cache
461 unsigned int index = (unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE);
462 rb_vm_t *vm = rb_ec_vm_ptr(ec);
463 const struct rb_callcache *cc = vm->global_cc_cache_table[index];
464
465 if (LIKELY(cc)) {
466 if (LIKELY(vm_cc_class_check(cc, klass))) {
467 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
468 if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) &&
469 cme->called_id == mid)) {
470
471 VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid)));
472 RB_DEBUG_COUNTER_INC(gccct_hit);
473
474 return cc;
475 }
476 }
477 }
478 else {
479 RB_DEBUG_COUNTER_INC(gccct_null);
480 }
481
482 RB_DEBUG_COUNTER_INC(gccct_miss);
483 return gccct_method_search_slowpath(vm, klass, index, ci);
484}
485
502static inline VALUE
503rb_call0(rb_execution_context_t *ec,
504 VALUE recv, ID mid, int argc, const VALUE *argv,
505 call_type call_scope, VALUE self)
506{
507 enum method_missing_reason call_status;
508 call_type scope = call_scope;
509 int kw_splat = RB_NO_KEYWORDS;
510
511 switch (scope) {
512 case CALL_PUBLIC_KW:
513 scope = CALL_PUBLIC;
514 kw_splat = 1;
515 break;
516 case CALL_FCALL_KW:
517 scope = CALL_FCALL;
518 kw_splat = 1;
519 break;
520 default:
521 break;
522 }
523
524 struct rb_callinfo ci;
525 scope_to_ci(scope, mid, argc, &ci);
526
527 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, &ci);
528
529 if (scope == CALL_PUBLIC) {
530 RB_DEBUG_COUNTER_INC(call0_public);
531
532 const rb_callable_method_entry_t *cc_cme = cc ? vm_cc_cme(cc) : NULL;
533 const rb_callable_method_entry_t *cme = callable_method_entry_refinements0(CLASS_OF(recv), mid, NULL, true, cc_cme);
534 call_status = rb_method_call_status(ec, cme, scope, self);
535
536 if (UNLIKELY(call_status != MISSING_NONE)) {
537 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
538 }
539 else if (UNLIKELY(cc_cme != cme)) { // refinement is solved
540 stack_check(ec);
541 return rb_vm_call_kw(ec, recv, mid, argc, argv, cme, kw_splat);
542 }
543 }
544 else {
545 RB_DEBUG_COUNTER_INC(call0_other);
546 call_status = rb_method_call_status(ec, cc ? vm_cc_cme(cc) : NULL, scope, self);
547
548 if (UNLIKELY(call_status != MISSING_NONE)) {
549 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
550 }
551 }
552
553 stack_check(ec);
554 return vm_call0_cc(ec, recv, mid, argc, argv, cc, kw_splat);
555}
556
558 VALUE defined_class;
559 VALUE recv;
560 ID mid;
561 rb_execution_context_t *ec;
562 const rb_callable_method_entry_t *cme;
563 unsigned int respond: 1;
564 unsigned int respond_to_missing: 1;
565 int argc;
566 const VALUE *argv;
567 int kw_splat;
568};
569
570static VALUE
571check_funcall_exec(VALUE v)
572{
573 struct rescue_funcall_args *args = (void *)v;
574 return call_method_entry(args->ec, args->defined_class,
575 args->recv, idMethodMissing,
576 args->cme, args->argc, args->argv, args->kw_splat);
577}
578
579static VALUE
580check_funcall_failed(VALUE v, VALUE e)
581{
582 struct rescue_funcall_args *args = (void *)v;
583 int ret = args->respond;
584 if (!ret) {
585 switch (method_boundp(args->defined_class, args->mid,
586 BOUND_PRIVATE|BOUND_RESPONDS)) {
587 case 2:
588 ret = TRUE;
589 break;
590 case 0:
591 ret = args->respond_to_missing;
592 break;
593 default:
594 ret = FALSE;
595 break;
596 }
597 }
598 if (ret) {
599 rb_exc_raise(e);
600 }
601 return Qundef;
602}
603
604static int
605check_funcall_respond_to(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mid)
606{
607 return vm_respond_to(ec, klass, recv, mid, TRUE);
608}
609
610static int
611check_funcall_callable(rb_execution_context_t *ec, const rb_callable_method_entry_t *me)
612{
613 return rb_method_call_status(ec, me, CALL_FCALL, ec->cfp->self) == MISSING_NONE;
614}
615
616static VALUE
617check_funcall_missing(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mid, int argc, const VALUE *argv, int respond, VALUE def, int kw_splat)
618{
619 struct rescue_funcall_args args;
620 const rb_callable_method_entry_t *cme;
621 VALUE ret = Qundef;
622
623 ret = basic_obj_respond_to_missing(ec, klass, recv,
624 ID2SYM(mid), Qtrue);
625 if (!RTEST(ret)) return def;
626 args.respond = respond > 0;
627 args.respond_to_missing = !UNDEF_P(ret);
628 ret = def;
629 cme = callable_method_entry(klass, idMethodMissing, &args.defined_class);
630
631 if (cme && !METHOD_ENTRY_BASIC(cme)) {
632 VALUE argbuf, *new_args = ALLOCV_N(VALUE, argbuf, argc+1);
633
634 new_args[0] = ID2SYM(mid);
635 #ifdef __GLIBC__
636 if (!argv) {
637 static const VALUE buf = Qfalse;
638 VM_ASSERT(argc == 0);
639 argv = &buf;
640 }
641 #endif
642 MEMCPY(new_args+1, argv, VALUE, argc);
643 ec->method_missing_reason = MISSING_NOENTRY;
644 args.ec = ec;
645 args.recv = recv;
646 args.cme = cme;
647 args.mid = mid;
648 args.argc = argc + 1;
649 args.argv = new_args;
650 args.kw_splat = kw_splat;
651 ret = rb_rescue2(check_funcall_exec, (VALUE)&args,
652 check_funcall_failed, (VALUE)&args,
654 ALLOCV_END(argbuf);
655 }
656 return ret;
657}
658
659static VALUE rb_check_funcall_default_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE def, int kw_splat);
660
661VALUE
662rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
663{
664 return rb_check_funcall_default_kw(recv, mid, argc, argv, Qundef, kw_splat);
665}
666
667VALUE
668rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
669{
670 return rb_check_funcall_default_kw(recv, mid, argc, argv, Qundef, RB_NO_KEYWORDS);
671}
672
673static VALUE
674rb_check_funcall_default_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE def, int kw_splat)
675{
676 VM_ASSERT(ruby_thread_has_gvl_p());
677
678 VALUE klass = CLASS_OF(recv);
679 const rb_callable_method_entry_t *me;
680 rb_execution_context_t *ec = GET_EC();
681 int respond = check_funcall_respond_to(ec, klass, recv, mid);
682
683 if (!respond)
684 return def;
685
686 me = rb_search_method_entry(recv, mid);
687 if (!check_funcall_callable(ec, me)) {
688 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
689 respond, def, kw_splat);
690 if (UNDEF_P(ret)) ret = def;
691 return ret;
692 }
693 stack_check(ec);
694 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
695}
696
697VALUE
698rb_check_funcall_default(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE def)
699{
700 return rb_check_funcall_default_kw(recv, mid, argc, argv, def, RB_NO_KEYWORDS);
701}
702
703VALUE
704rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv,
705 rb_check_funcall_hook *hook, VALUE arg, int kw_splat)
706{
707 VALUE klass = CLASS_OF(recv);
708 const rb_callable_method_entry_t *me;
709 rb_execution_context_t *ec = GET_EC();
710 int respond = check_funcall_respond_to(ec, klass, recv, mid);
711
712 if (!respond) {
713 (*hook)(FALSE, recv, mid, argc, argv, arg);
714 return Qundef;
715 }
716
717 me = rb_search_method_entry(recv, mid);
718 if (!check_funcall_callable(ec, me)) {
719 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
720 respond, Qundef, kw_splat);
721 (*hook)(!UNDEF_P(ret), recv, mid, argc, argv, arg);
722 return ret;
723 }
724 stack_check(ec);
725 (*hook)(TRUE, recv, mid, argc, argv, arg);
726 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
727}
728
729const char *
730rb_type_str(enum ruby_value_type type)
731{
732#define type_case(t) t: return #t
733 switch (type) {
734 case type_case(T_NONE);
735 case type_case(T_OBJECT);
736 case type_case(T_CLASS);
737 case type_case(T_MODULE);
738 case type_case(T_FLOAT);
739 case type_case(T_STRING);
740 case type_case(T_REGEXP);
741 case type_case(T_ARRAY);
742 case type_case(T_HASH);
743 case type_case(T_STRUCT);
744 case type_case(T_BIGNUM);
745 case type_case(T_FILE);
746 case type_case(T_DATA);
747 case type_case(T_MATCH);
748 case type_case(T_COMPLEX);
749 case type_case(T_RATIONAL);
750 case type_case(T_NIL);
751 case type_case(T_TRUE);
752 case type_case(T_FALSE);
753 case type_case(T_SYMBOL);
754 case type_case(T_FIXNUM);
755 case type_case(T_IMEMO);
756 case type_case(T_UNDEF);
757 case type_case(T_NODE);
758 case type_case(T_ICLASS);
759 case type_case(T_ZOMBIE);
760 case type_case(T_MOVED);
761 case T_MASK: break;
762 }
763#undef type_case
764 return NULL;
765}
766
767static void
768uncallable_object(VALUE recv, ID mid)
769{
770 VALUE flags;
771 int type;
772 const char *typestr;
773 VALUE mname = rb_id2str(mid);
774
775 if (SPECIAL_CONST_P(recv)) {
776 rb_raise(rb_eNotImpError,
777 "method '%"PRIsVALUE"' called on unexpected immediate object (%p)",
778 mname, (void *)recv);
779 }
780 else if ((flags = RBASIC(recv)->flags) == 0) {
781 rb_raise(rb_eNotImpError,
782 "method '%"PRIsVALUE"' called on terminated object (%p)",
783 mname, (void *)recv);
784 }
785 else if (!(typestr = rb_type_str(type = BUILTIN_TYPE(recv)))) {
786 rb_raise(rb_eNotImpError,
787 "method '%"PRIsVALUE"' called on broken T_?""?""?(0x%02x) object"
788 " (%p flags=0x%"PRIxVALUE")",
789 mname, type, (void *)recv, flags);
790 }
791 else if (T_OBJECT <= type && type < T_NIL) {
792 rb_raise(rb_eNotImpError,
793 "method '%"PRIsVALUE"' called on hidden %s object"
794 " (%p flags=0x%"PRIxVALUE")",
795 mname, typestr, (void *)recv, flags);
796 }
797 else {
798 rb_raise(rb_eNotImpError,
799 "method '%"PRIsVALUE"' called on unexpected %s object"
800 " (%p flags=0x%"PRIxVALUE")",
801 mname, typestr, (void *)recv, flags);
802 }
803}
804
805static inline const rb_callable_method_entry_t *
806rb_search_method_entry(VALUE recv, ID mid)
807{
808 VALUE klass = CLASS_OF(recv);
809
810 if (!klass) uncallable_object(recv, mid);
811 return rb_callable_method_entry(klass, mid);
812}
813
814static inline enum method_missing_reason
815rb_method_call_status(rb_execution_context_t *ec, const rb_callable_method_entry_t *me, call_type scope, VALUE self)
816{
817 if (UNLIKELY(UNDEFINED_METHOD_ENTRY_P(me))) {
818 goto undefined;
819 }
820 else if (UNLIKELY(me->def->type == VM_METHOD_TYPE_REFINED)) {
821 me = rb_resolve_refined_method_callable(Qnil, me);
822 if (UNDEFINED_METHOD_ENTRY_P(me)) goto undefined;
823 }
824
825 rb_method_visibility_t visi = METHOD_ENTRY_VISI(me);
826
827 /* receiver specified form for private method */
828 if (UNLIKELY(visi != METHOD_VISI_PUBLIC)) {
829 if (me->def->original_id == idMethodMissing) {
830 return MISSING_NONE;
831 }
832 else if (visi == METHOD_VISI_PRIVATE &&
833 scope == CALL_PUBLIC) {
834 return MISSING_PRIVATE;
835 }
836 /* self must be kind of a specified form for protected method */
837 else if (visi == METHOD_VISI_PROTECTED &&
838 scope == CALL_PUBLIC) {
839
840 VALUE defined_class = me->owner;
841 if (RB_TYPE_P(defined_class, T_ICLASS)) {
842 defined_class = RBASIC(defined_class)->klass;
843 }
844
845 if (UNDEF_P(self) || !rb_obj_is_kind_of(self, defined_class)) {
846 return MISSING_PROTECTED;
847 }
848 }
849 }
850
851 return MISSING_NONE;
852
853 undefined:
854 return scope == CALL_VCALL ? MISSING_VCALL : MISSING_NOENTRY;
855}
856
857
869static inline VALUE
870rb_call(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope)
871{
872 rb_execution_context_t *ec = GET_EC();
873 return rb_call0(ec, recv, mid, argc, argv, scope, ec->cfp->self);
874}
875
876NORETURN(static void raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv,
877 VALUE obj, enum method_missing_reason call_status));
878
879/*
880 * call-seq:
881 * obj.method_missing(symbol [, *args] ) -> result
882 *
883 * Invoked by Ruby when <i>obj</i> is sent a message it cannot handle.
884 * <i>symbol</i> is the symbol for the method called, and <i>args</i>
885 * are any arguments that were passed to it. By default, the interpreter
886 * raises an error when this method is called. However, it is possible
887 * to override the method to provide more dynamic behavior.
888 * If it is decided that a particular method should not be handled, then
889 * <i>super</i> should be called, so that ancestors can pick up the
890 * missing method.
891 * The example below creates
892 * a class <code>Roman</code>, which responds to methods with names
893 * consisting of roman numerals, returning the corresponding integer
894 * values.
895 *
896 * class Roman
897 * def roman_to_int(str)
898 * # ...
899 * end
900 *
901 * def method_missing(symbol, *args)
902 * str = symbol.id2name
903 * begin
904 * roman_to_int(str)
905 * rescue
906 * super(symbol, *args)
907 * end
908 * end
909 * end
910 *
911 * r = Roman.new
912 * r.iv #=> 4
913 * r.xxiii #=> 23
914 * r.mm #=> 2000
915 * r.foo #=> NoMethodError
916 */
917
918static VALUE
919rb_method_missing(int argc, const VALUE *argv, VALUE obj)
920{
921 rb_execution_context_t *ec = GET_EC();
922 raise_method_missing(ec, argc, argv, obj, ec->method_missing_reason);
924}
925
926VALUE
927rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
928 int argc, const VALUE *argv, int priv)
929{
930 VALUE name = argv[0];
931
932 if (!format) {
933 format = rb_fstring_lit("undefined method '%1$s' for %3$s%4$s");
934 }
935 if (exc == rb_eNoMethodError) {
936 VALUE args = rb_ary_new4(argc - 1, argv + 1);
937 return rb_nomethod_err_new(format, obj, name, args, priv);
938 }
939 else {
940 return rb_name_err_new(format, obj, name);
941 }
942}
943
944static void
945raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE obj,
946 enum method_missing_reason last_call_status)
947{
949 VALUE format = 0;
950
951 if (UNLIKELY(argc == 0)) {
952 rb_raise(rb_eArgError, "no method name given");
953 }
954 else if (UNLIKELY(!SYMBOL_P(argv[0]))) {
955 const VALUE e = rb_eArgError; /* TODO: TypeError? */
956 rb_raise(e, "method name must be a Symbol but %"PRIsVALUE" is given",
957 rb_obj_class(argv[0]));
958 }
959
960 stack_check(ec);
961
962 if (last_call_status & MISSING_PRIVATE) {
963 format = rb_fstring_lit("private method '%1$s' called for %3$s%4$s");
964 }
965 else if (last_call_status & MISSING_PROTECTED) {
966 format = rb_fstring_lit("protected method '%1$s' called for %3$s%4$s");
967 }
968 else if (last_call_status & MISSING_VCALL) {
969 format = rb_fstring_lit("undefined local variable or method '%1$s' for %3$s%4$s");
970 exc = rb_eNameError;
971 }
972 else if (last_call_status & MISSING_SUPER) {
973 format = rb_fstring_lit("super: no superclass method '%1$s' for %3$s%4$s");
974 }
975
976 {
977 exc = rb_make_no_method_exception(exc, format, obj, argc, argv,
978 last_call_status & (MISSING_FCALL|MISSING_VCALL));
979 if (!(last_call_status & MISSING_MISSING)) {
980 rb_vm_pop_cfunc_frame();
981 }
982 rb_exc_raise(exc);
983 }
984}
985
986static void
987vm_raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv,
988 VALUE obj, int call_status)
989{
990 vm_passed_block_handler_set(ec, VM_BLOCK_HANDLER_NONE);
991 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
992}
993
994static inline VALUE
995method_missing(rb_execution_context_t *ec, VALUE obj, ID id, int argc, const VALUE *argv, enum method_missing_reason call_status, int kw_splat)
996{
997 VALUE *nargv, result, work, klass;
998 VALUE block_handler = vm_passed_block_handler(ec);
999 const rb_callable_method_entry_t *me;
1000
1001 ec->method_missing_reason = call_status;
1002
1003 if (id == idMethodMissing) {
1004 goto missing;
1005 }
1006
1007 nargv = ALLOCV_N(VALUE, work, argc + 1);
1008 nargv[0] = ID2SYM(id);
1009 #ifdef __GLIBC__
1010 if (!argv) {
1011 static const VALUE buf = Qfalse;
1012 VM_ASSERT(argc == 0);
1013 argv = &buf;
1014 }
1015 #endif
1016 MEMCPY(nargv + 1, argv, VALUE, argc);
1017 ++argc;
1018 argv = nargv;
1019
1020 klass = CLASS_OF(obj);
1021 if (!klass) goto missing;
1022 me = rb_callable_method_entry(klass, idMethodMissing);
1023 if (!me || METHOD_ENTRY_BASIC(me)) goto missing;
1024 vm_passed_block_handler_set(ec, block_handler);
1025 result = rb_vm_call_kw(ec, obj, idMethodMissing, argc, argv, me, kw_splat);
1026 if (work) ALLOCV_END(work);
1027 return result;
1028 missing:
1029 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
1031}
1032
1033static inline VALUE
1034rb_funcallv_scope(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope)
1035{
1036 rb_execution_context_t *ec = GET_EC();
1037
1038 struct rb_callinfo ci;
1039 scope_to_ci(scope, mid, argc, &ci);
1040
1041 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, &ci);
1042 VALUE self = ec->cfp->self;
1043
1044 if (LIKELY(cc) &&
1045 LIKELY(rb_method_call_status(ec, vm_cc_cme(cc), scope, self) == MISSING_NONE)) {
1046 // fastpath
1047 return vm_call0_cc(ec, recv, mid, argc, argv, cc, false);
1048 }
1049 else {
1050 return rb_call0(ec, recv, mid, argc, argv, scope, self);
1051 }
1052}
1053
1054#ifdef rb_funcallv
1055#undef rb_funcallv
1056#endif
1057VALUE
1058rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
1059{
1060 VM_ASSERT(ruby_thread_has_gvl_p());
1061
1062 return rb_funcallv_scope(recv, mid, argc, argv, CALL_FCALL);
1063}
1064
1065VALUE
1066rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
1067{
1068 VM_ASSERT(ruby_thread_has_gvl_p());
1069
1070 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1071}
1072
1073VALUE
1074rb_apply(VALUE recv, ID mid, VALUE args)
1075{
1076 int argc;
1077 VALUE *argv, ret;
1078
1079 argc = RARRAY_LENINT(args);
1080 if (argc >= 0x100) {
1081 args = rb_ary_subseq(args, 0, argc);
1082 RBASIC_CLEAR_CLASS(args);
1083 OBJ_FREEZE(args);
1084 ret = rb_call(recv, mid, argc, RARRAY_CONST_PTR(args), CALL_FCALL);
1085 RB_GC_GUARD(args);
1086 return ret;
1087 }
1088 argv = ALLOCA_N(VALUE, argc);
1089 MEMCPY(argv, RARRAY_CONST_PTR(args), VALUE, argc);
1090
1091 return rb_funcallv(recv, mid, argc, argv);
1092}
1093
1094#ifdef rb_funcall
1095#undef rb_funcall
1096#endif
1097
1098VALUE
1099rb_funcall(VALUE recv, ID mid, int n, ...)
1100{
1101 VALUE *argv;
1102 va_list ar;
1103
1104 if (n > 0) {
1105 long i;
1106
1107 va_start(ar, n);
1108
1109 argv = ALLOCA_N(VALUE, n);
1110
1111 for (i = 0; i < n; i++) {
1112 argv[i] = va_arg(ar, VALUE);
1113 }
1114 va_end(ar);
1115 }
1116 else {
1117 argv = 0;
1118 }
1119 return rb_funcallv(recv, mid, n, argv);
1120}
1121
1132VALUE
1133rb_check_funcall_basic_kw(VALUE recv, ID mid, VALUE ancestor, int argc, const VALUE *argv, int kw_splat)
1134{
1135 const rb_callable_method_entry_t *cme;
1136 rb_execution_context_t *ec;
1137 VALUE klass = CLASS_OF(recv);
1138 if (!klass) return Qundef; /* hidden object */
1139
1140 cme = rb_callable_method_entry(klass, mid);
1141 if (cme && METHOD_ENTRY_BASIC(cme) && RBASIC_CLASS(cme->defined_class) == ancestor) {
1142 ec = GET_EC();
1143 return rb_vm_call0(ec, recv, mid, argc, argv, cme, kw_splat);
1144 }
1145
1146 return Qundef;
1147}
1148
1149VALUE
1150rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
1151{
1152 return rb_funcallv_scope(recv, mid, argc, argv, CALL_PUBLIC);
1153}
1154
1155VALUE
1156rb_funcallv_public_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
1157{
1158 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1159}
1160
1161VALUE
1162rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv)
1163{
1164 PASS_PASSED_BLOCK_HANDLER();
1165 return rb_funcallv_public(recv, mid, argc, argv);
1166}
1167
1168VALUE
1169rb_funcall_passing_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
1170{
1171 PASS_PASSED_BLOCK_HANDLER();
1172 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1173}
1174
1175VALUE
1176rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE passed_procval)
1177{
1178 if (!NIL_P(passed_procval)) {
1179 vm_passed_block_handler_set(GET_EC(), passed_procval);
1180 }
1181
1182 return rb_funcallv_public(recv, mid, argc, argv);
1183}
1184
1185VALUE
1186rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE passed_procval, int kw_splat)
1187{
1188 if (!NIL_P(passed_procval)) {
1189 vm_passed_block_handler_set(GET_EC(), passed_procval);
1190 }
1191
1192 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1193}
1194
1195static VALUE *
1196current_vm_stack_arg(const rb_execution_context_t *ec, const VALUE *argv)
1197{
1198 rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp);
1199 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, prev_cfp)) return NULL;
1200 if (prev_cfp->sp + 1 != argv) return NULL;
1201 return prev_cfp->sp + 1;
1202}
1203
1204static VALUE
1205send_internal(int argc, const VALUE *argv, VALUE recv, call_type scope)
1206{
1207 ID id;
1208 VALUE vid;
1209 VALUE self;
1210 VALUE ret, vargv = 0;
1211 rb_execution_context_t *ec = GET_EC();
1212 int public = scope == CALL_PUBLIC || scope == CALL_PUBLIC_KW;
1213
1214 if (public) {
1215 self = Qundef;
1216 }
1217 else {
1218 self = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)->self;
1219 }
1220
1221 if (argc == 0) {
1222 rb_raise(rb_eArgError, "no method name given");
1223 }
1224
1225 vid = *argv;
1226
1227 id = rb_check_id(&vid);
1228 if (!id) {
1229 if (rb_method_basic_definition_p(CLASS_OF(recv), idMethodMissing)) {
1230 VALUE exc = rb_make_no_method_exception(rb_eNoMethodError, 0,
1231 recv, argc, argv,
1232 !public);
1233 rb_exc_raise(exc);
1234 }
1235 if (!SYMBOL_P(*argv)) {
1236 VALUE *tmp_argv = current_vm_stack_arg(ec, argv);
1237 vid = rb_str_intern(vid);
1238 if (tmp_argv) {
1239 tmp_argv[0] = vid;
1240 }
1241 else if (argc > 1) {
1242 tmp_argv = ALLOCV_N(VALUE, vargv, argc);
1243 tmp_argv[0] = vid;
1244 MEMCPY(tmp_argv+1, argv+1, VALUE, argc-1);
1245 argv = tmp_argv;
1246 }
1247 else {
1248 argv = &vid;
1249 }
1250 }
1251 id = idMethodMissing;
1252 ec->method_missing_reason = MISSING_NOENTRY;
1253 }
1254 else {
1255 argv++; argc--;
1256 }
1257 PASS_PASSED_BLOCK_HANDLER_EC(ec);
1258 ret = rb_call0(ec, recv, id, argc, argv, scope, self);
1259 ALLOCV_END(vargv);
1260 return ret;
1261}
1262
1263static VALUE
1264send_internal_kw(int argc, const VALUE *argv, VALUE recv, call_type scope)
1265{
1266 if (rb_keyword_given_p()) {
1267 switch (scope) {
1268 case CALL_PUBLIC:
1269 scope = CALL_PUBLIC_KW;
1270 break;
1271 case CALL_FCALL:
1272 scope = CALL_FCALL_KW;
1273 break;
1274 default:
1275 break;
1276 }
1277 }
1278 return send_internal(argc, argv, recv, scope);
1279}
1280
1281/*
1282 * call-seq:
1283 * foo.send(symbol [, args...]) -> obj
1284 * foo.__send__(symbol [, args...]) -> obj
1285 * foo.send(string [, args...]) -> obj
1286 * foo.__send__(string [, args...]) -> obj
1287 *
1288 * Invokes the method identified by _symbol_, passing it any
1289 * arguments specified.
1290 * When the method is identified by a string, the string is converted
1291 * to a symbol.
1292 *
1293 * BasicObject implements +__send__+, Kernel implements +send+.
1294 * <code>__send__</code> is safer than +send+
1295 * when _obj_ has the same method name like <code>Socket</code>.
1296 * See also <code>public_send</code>.
1297 *
1298 * class Klass
1299 * def hello(*args)
1300 * "Hello " + args.join(' ')
1301 * end
1302 * end
1303 * k = Klass.new
1304 * k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
1305 */
1306
1307VALUE
1308rb_f_send(int argc, VALUE *argv, VALUE recv)
1309{
1310 return send_internal_kw(argc, argv, recv, CALL_FCALL);
1311}
1312
1313/*
1314 * call-seq:
1315 * obj.public_send(symbol [, args...]) -> obj
1316 * obj.public_send(string [, args...]) -> obj
1317 *
1318 * Invokes the method identified by _symbol_, passing it any
1319 * arguments specified. Unlike send, public_send calls public
1320 * methods only.
1321 * When the method is identified by a string, the string is converted
1322 * to a symbol.
1323 *
1324 * 1.public_send(:puts, "hello") # causes NoMethodError
1325 */
1326
1327static VALUE
1328rb_f_public_send(int argc, VALUE *argv, VALUE recv)
1329{
1330 return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
1331}
1332
1333/* yield */
1334
1335static inline VALUE
1336rb_yield_0_kw(int argc, const VALUE * argv, int kw_splat)
1337{
1338 return vm_yield(GET_EC(), argc, argv, kw_splat);
1339}
1340
1341static inline VALUE
1342rb_yield_0(int argc, const VALUE * argv)
1343{
1344 return vm_yield(GET_EC(), argc, argv, RB_NO_KEYWORDS);
1345}
1346
1347VALUE
1348rb_yield_1(VALUE val)
1349{
1350 return rb_yield_0(1, &val);
1351}
1352
1353VALUE
1355{
1356 if (UNDEF_P(val)) {
1357 return rb_yield_0(0, NULL);
1358 }
1359 else {
1360 return rb_yield_0(1, &val);
1361 }
1362}
1363
1364#undef rb_yield_values
1365VALUE
1367{
1368 if (n == 0) {
1369 return rb_yield_0(0, 0);
1370 }
1371 else {
1372 int i;
1373 VALUE *argv;
1374 va_list args;
1375 argv = ALLOCA_N(VALUE, n);
1376
1377 va_start(args, n);
1378 for (i=0; i<n; i++) {
1379 argv[i] = va_arg(args, VALUE);
1380 }
1381 va_end(args);
1382
1383 return rb_yield_0(n, argv);
1384 }
1385}
1386
1387VALUE
1388rb_yield_values2(int argc, const VALUE *argv)
1389{
1390 return rb_yield_0(argc, argv);
1391}
1392
1393VALUE
1394rb_yield_values_kw(int argc, const VALUE *argv, int kw_splat)
1395{
1396 return rb_yield_0_kw(argc, argv, kw_splat);
1397}
1398
1399VALUE
1401{
1402 VALUE tmp = rb_check_array_type(values);
1403 VALUE v;
1404 if (NIL_P(tmp)) {
1405 rb_raise(rb_eArgError, "not an array");
1406 }
1407 v = rb_yield_0(RARRAY_LENINT(tmp), RARRAY_CONST_PTR(tmp));
1408 RB_GC_GUARD(tmp);
1409 return v;
1410}
1411
1412VALUE
1413rb_yield_splat_kw(VALUE values, int kw_splat)
1414{
1415 VALUE tmp = rb_check_array_type(values);
1416 VALUE v;
1417 if (NIL_P(tmp)) {
1418 rb_raise(rb_eArgError, "not an array");
1419 }
1420 v = rb_yield_0_kw(RARRAY_LENINT(tmp), RARRAY_CONST_PTR(tmp), kw_splat);
1421 RB_GC_GUARD(tmp);
1422 return v;
1423}
1424
1425VALUE
1426rb_yield_force_blockarg(VALUE values)
1427{
1428 return vm_yield_force_blockarg(GET_EC(), values);
1429}
1430
1431VALUE
1433{
1434 return vm_yield_with_block(GET_EC(), argc, argv,
1435 NIL_P(blockarg) ? VM_BLOCK_HANDLER_NONE : blockarg,
1437}
1438
1439#if VMDEBUG
1440static const char *
1441vm_frametype_name(const rb_control_frame_t *cfp);
1442#endif
1443
1444static VALUE
1445rb_iterate0(VALUE (* it_proc) (VALUE), VALUE data1,
1446 const struct vm_ifunc *const ifunc,
1447 rb_execution_context_t *ec)
1448{
1449 enum ruby_tag_type state;
1450 volatile VALUE retval = Qnil;
1451 rb_control_frame_t *const cfp = ec->cfp;
1452
1453 EC_PUSH_TAG(ec);
1454 state = EC_EXEC_TAG();
1455 if (state == 0) {
1456 iter_retry:
1457 {
1458 VALUE block_handler;
1459
1460 if (ifunc) {
1461 struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
1462 captured->code.ifunc = ifunc;
1463 block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
1464 }
1465 else {
1466 block_handler = VM_CF_BLOCK_HANDLER(cfp);
1467 }
1468 vm_passed_block_handler_set(ec, block_handler);
1469 }
1470 retval = (*it_proc) (data1);
1471 }
1472 else if (state == TAG_BREAK || state == TAG_RETRY) {
1473 const struct vm_throw_data *const err = (struct vm_throw_data *)ec->errinfo;
1474 const rb_control_frame_t *const escape_cfp = THROW_DATA_CATCH_FRAME(err);
1475
1476 if (cfp == escape_cfp) {
1477 rb_vm_rewind_cfp(ec, cfp);
1478
1479 state = 0;
1480 ec->tag->state = TAG_NONE;
1481 ec->errinfo = Qnil;
1482
1483 if (state == TAG_RETRY) goto iter_retry;
1484 retval = THROW_DATA_VAL(err);
1485 }
1486 else if (0) {
1487 SDR(); fprintf(stderr, "%p, %p\n", (void *)cfp, (void *)escape_cfp);
1488 }
1489 }
1490 EC_POP_TAG();
1491
1492 if (state) {
1493 EC_JUMP_TAG(ec, state);
1494 }
1495 return retval;
1496}
1497
1498static VALUE
1499rb_iterate_internal(VALUE (* it_proc)(VALUE), VALUE data1,
1500 rb_block_call_func_t bl_proc, VALUE data2)
1501{
1502 return rb_iterate0(it_proc, data1,
1503 bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (void *)data2) : 0,
1504 GET_EC());
1505}
1506
1507VALUE
1508rb_iterate(VALUE (* it_proc)(VALUE), VALUE data1,
1509 rb_block_call_func_t bl_proc, VALUE data2)
1510{
1511 return rb_iterate_internal(it_proc, data1, bl_proc, data2);
1512}
1513
1515 VALUE obj;
1516 ID mid;
1517 int argc;
1518 const VALUE *argv;
1519 int kw_splat;
1520};
1521
1522static VALUE
1523iterate_method(VALUE obj)
1524{
1525 const struct iter_method_arg * arg =
1526 (struct iter_method_arg *) obj;
1527
1528 return rb_call(arg->obj, arg->mid, arg->argc, arg->argv, arg->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1529}
1530
1531VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE * argv, rb_block_call_func_t bl_proc, VALUE data2, int kw_splat);
1532
1533VALUE
1534rb_block_call(VALUE obj, ID mid, int argc, const VALUE * argv,
1535 rb_block_call_func_t bl_proc, VALUE data2)
1536{
1537 return rb_block_call_kw(obj, mid, argc, argv, bl_proc, data2, RB_NO_KEYWORDS);
1538}
1539
1540VALUE
1541rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE * argv,
1542 rb_block_call_func_t bl_proc, VALUE data2, int kw_splat)
1543{
1544 struct iter_method_arg arg;
1545
1546 arg.obj = obj;
1547 arg.mid = mid;
1548 arg.argc = argc;
1549 arg.argv = argv;
1550 arg.kw_splat = kw_splat;
1551 return rb_iterate_internal(iterate_method, (VALUE)&arg, bl_proc, data2);
1552}
1553
1554/*
1555 * A flexible variant of rb_block_call and rb_block_call_kw.
1556 * This function accepts flags:
1557 *
1558 * RB_NO_KEYWORDS, RB_PASS_KEYWORDS, RB_PASS_CALLED_KEYWORDS:
1559 * Works as the same as rb_block_call_kw.
1560 *
1561 * RB_BLOCK_NO_USE_PACKED_ARGS:
1562 * The given block ("bl_proc") does not use "yielded_arg" of rb_block_call_func_t.
1563 * Instead, the block accesses the yielded arguments via "argc" and "argv".
1564 * This flag allows the called method to yield arguments without allocating an Array.
1565 */
1566VALUE
1567rb_block_call2(VALUE obj, ID mid, int argc, const VALUE *argv,
1568 rb_block_call_func_t bl_proc, VALUE data2, long flags)
1569{
1570 struct iter_method_arg arg;
1571
1572 arg.obj = obj;
1573 arg.mid = mid;
1574 arg.argc = argc;
1575 arg.argv = argv;
1576 arg.kw_splat = flags & 1;
1577
1578 struct vm_ifunc *ifunc = rb_vm_ifunc_proc_new(bl_proc, (void *)data2);
1579 if (flags & RB_BLOCK_NO_USE_PACKED_ARGS)
1580 ifunc->flags |= IFUNC_YIELD_OPTIMIZABLE;
1581
1582 return rb_iterate0(iterate_method, (VALUE)&arg, ifunc, GET_EC());
1583}
1584
1585VALUE
1586rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
1587 rb_block_call_func_t bl_proc, int min_argc, int max_argc,
1588 VALUE data2)
1589{
1590 struct iter_method_arg arg;
1591 struct vm_ifunc *block;
1592
1593 if (!bl_proc) rb_raise(rb_eArgError, "NULL lambda function");
1594 arg.obj = obj;
1595 arg.mid = mid;
1596 arg.argc = argc;
1597 arg.argv = argv;
1598 arg.kw_splat = 0;
1599 block = rb_vm_ifunc_new(bl_proc, (void *)data2, min_argc, max_argc);
1600 return rb_iterate0(iterate_method, (VALUE)&arg, block, GET_EC());
1601}
1602
1603static VALUE
1604iterate_check_method(VALUE obj)
1605{
1606 const struct iter_method_arg * arg =
1607 (struct iter_method_arg *) obj;
1608
1609 return rb_check_funcall(arg->obj, arg->mid, arg->argc, arg->argv);
1610}
1611
1612VALUE
1613rb_check_block_call(VALUE obj, ID mid, int argc, const VALUE *argv,
1614 rb_block_call_func_t bl_proc, VALUE data2)
1615{
1616 struct iter_method_arg arg;
1617
1618 arg.obj = obj;
1619 arg.mid = mid;
1620 arg.argc = argc;
1621 arg.argv = argv;
1622 arg.kw_splat = 0;
1623 return rb_iterate_internal(iterate_check_method, (VALUE)&arg, bl_proc, data2);
1624}
1625
1626VALUE
1628{
1629 return rb_call(obj, idEach, 0, 0, CALL_FCALL);
1630}
1631
1632static VALUE eval_default_path = Qfalse;
1633
1634#define EVAL_LOCATION_MARK "eval at "
1635#define EVAL_LOCATION_MARK_LEN (int)rb_strlen_lit(EVAL_LOCATION_MARK)
1636
1637static VALUE
1638get_eval_default_path(void)
1639{
1640 int location_lineno;
1641 VALUE location_path = rb_source_location(&location_lineno);
1642 if (!NIL_P(location_path)) {
1643 return rb_fstring(rb_sprintf("("EVAL_LOCATION_MARK"%"PRIsVALUE":%d)",
1644 location_path, location_lineno));
1645 }
1646
1647 if (!eval_default_path) {
1648 eval_default_path = rb_fstring_lit("(eval)");
1649 rb_vm_register_global_object(eval_default_path);
1650 }
1651 return eval_default_path;
1652}
1653
1654static const rb_iseq_t *
1655pm_eval_make_iseq(VALUE src, VALUE fname, int line,
1656 const struct rb_block *base_block)
1657{
1658 const rb_iseq_t *const parent = vm_block_iseq(base_block);
1659 const rb_iseq_t *iseq = parent;
1660 VALUE name = rb_fstring_lit("<compiled>");
1661
1662 // Conditionally enable coverage depending on the current mode:
1663 int coverage_enabled = ((rb_get_coverage_mode() & COVERAGE_TARGET_EVAL) != 0) ? 1 : 0;
1664
1665 if (!fname) {
1666 fname = rb_source_location(&line);
1667 }
1668
1669 if (!UNDEF_P(fname)) {
1670 if (!NIL_P(fname)) fname = rb_fstring(fname);
1671 }
1672 else {
1673 fname = get_eval_default_path();
1674 coverage_enabled = 0;
1675 }
1676
1677 pm_parse_result_t result = { 0 };
1678 pm_options_line_set(&result.options, line);
1679 result.node.coverage_enabled = coverage_enabled;
1680
1681 // Cout scopes, one for each parent iseq, plus one for our local scope
1682 int scopes_count = 0;
1683 do {
1684 scopes_count++;
1685 } while ((iseq = ISEQ_BODY(iseq)->parent_iseq));
1686 pm_options_scopes_init(&result.options, scopes_count + 1);
1687
1688 // Walk over the scope tree, adding known locals at the correct depths. The
1689 // scope array should be deepest -> shallowest. so lower indexes in the
1690 // scopes array refer to root nodes on the tree, and higher indexes are the
1691 // leaf nodes.
1692 iseq = parent;
1693 for (int scopes_index = 0; scopes_index < scopes_count; scopes_index++) {
1694 VALUE iseq_value = (VALUE)iseq;
1695 int locals_count = ISEQ_BODY(iseq)->local_table_size;
1696 pm_options_scope_t *options_scope = &result.options.scopes[scopes_count - scopes_index - 1];
1697 pm_options_scope_init(options_scope, locals_count);
1698
1699 for (int local_index = 0; local_index < locals_count; local_index++) {
1700 pm_string_t *scope_local = &options_scope->locals[local_index];
1701 ID local = ISEQ_BODY(iseq)->local_table[local_index];
1702
1703 if (rb_is_local_id(local)) {
1704 VALUE name_obj = rb_id2str(local);
1705 const char *name = RSTRING_PTR(name_obj);
1706 size_t length = strlen(name);
1707
1708 // Explicitly skip numbered parameters. These should not be sent
1709 // into the eval.
1710 if (length == 2 && name[0] == '_' && name[1] >= '1' && name[1] <= '9') {
1711 continue;
1712 }
1713
1714 /* We need to duplicate the string because the Ruby string may
1715 * be embedded so compaction could move the string and the pointer
1716 * will change. */
1717 char *name_dup = xmalloc(length + 1);
1718 strlcpy(name_dup, name, length + 1);
1719
1720 RB_GC_GUARD(name_obj);
1721
1722 pm_string_owned_init(scope_local, (uint8_t *)name_dup, length);
1723 }
1724 }
1725
1726 iseq = ISEQ_BODY(iseq)->parent_iseq;
1727
1728 /* We need to GC guard the iseq because the code above malloc memory
1729 * which could trigger a GC. Since we only use ISEQ_BODY, the compiler
1730 * may optimize out the iseq local variable so we need to GC guard it. */
1731 RB_GC_GUARD(iseq_value);
1732 }
1733
1734 // Add our empty local scope at the very end of the array for our eval
1735 // scope's locals.
1736 pm_options_scope_init(&result.options.scopes[scopes_count], 0);
1737
1738 VALUE script_lines;
1739 VALUE error = pm_parse_string(&result, src, fname, ruby_vm_keep_script_lines ? &script_lines : NULL);
1740
1741 // If the parse failed, clean up and raise.
1742 if (error != Qnil) {
1743 pm_parse_result_free(&result);
1744 rb_exc_raise(error);
1745 }
1746
1747 // Create one scope node for each scope passed in, initialize the local
1748 // lookup table with all the local variable information attached to the
1749 // scope used by the parser.
1750 pm_scope_node_t *node = &result.node;
1751 iseq = parent;
1752
1753 for (int scopes_index = 0; scopes_index < scopes_count; scopes_index++) {
1754 pm_scope_node_t *parent_scope = ruby_xcalloc(1, sizeof(pm_scope_node_t));
1755 RUBY_ASSERT(parent_scope != NULL);
1756
1757 pm_options_scope_t *options_scope = &result.options.scopes[scopes_count - scopes_index - 1];
1758 parent_scope->coverage_enabled = coverage_enabled;
1759 parent_scope->parser = &result.parser;
1760 parent_scope->index_lookup_table = st_init_numtable();
1761
1762 int locals_count = ISEQ_BODY(iseq)->local_table_size;
1763 parent_scope->local_table_for_iseq_size = locals_count;
1764 pm_constant_id_list_init(&parent_scope->locals);
1765
1766 for (int local_index = 0; local_index < locals_count; local_index++) {
1767 const pm_string_t *scope_local = &options_scope->locals[local_index];
1768
1769 pm_constant_id_t constant_id = 0;
1770 if (pm_string_length(scope_local) > 0) {
1771 constant_id = pm_constant_pool_insert_constant(
1772 &result.parser.constant_pool, pm_string_source(scope_local),
1773 pm_string_length(scope_local));
1774 st_insert(parent_scope->index_lookup_table, (st_data_t)constant_id, (st_data_t)local_index);
1775 }
1776 pm_constant_id_list_append(&parent_scope->locals, constant_id);
1777 }
1778
1779 node->previous = parent_scope;
1780 node = parent_scope;
1781 iseq = ISEQ_BODY(iseq)->parent_iseq;
1782 }
1783
1784 int error_state;
1785 iseq = pm_iseq_new_eval(&result.node, name, fname, Qnil, line, parent, 0, &error_state);
1786
1787 pm_scope_node_t *prev = result.node.previous;
1788 while (prev) {
1789 pm_scope_node_t *next = prev->previous;
1790 pm_constant_id_list_free(&prev->locals);
1791 pm_scope_node_destroy(prev);
1792 ruby_xfree(prev);
1793 prev = next;
1794 }
1795
1796 pm_parse_result_free(&result);
1797
1798 // If there was an error, raise it after memory has been cleaned up
1799 if (error_state) {
1800 RUBY_ASSERT(iseq == NULL);
1801 rb_jump_tag(error_state);
1802 }
1803
1804 rb_exec_event_hook_script_compiled(GET_EC(), iseq, src);
1805
1806 return iseq;
1807}
1808
1809static const rb_iseq_t *
1810eval_make_iseq(VALUE src, VALUE fname, int line,
1811 const struct rb_block *base_block)
1812{
1813 if (rb_ruby_prism_p()) {
1814 return pm_eval_make_iseq(src, fname, line, base_block);
1815 }
1816 const VALUE parser = rb_parser_new();
1817 const rb_iseq_t *const parent = vm_block_iseq(base_block);
1818 rb_iseq_t *iseq = NULL;
1819 VALUE ast_value;
1820 rb_ast_t *ast;
1821 int isolated_depth = 0;
1822
1823 // Conditionally enable coverage depending on the current mode:
1824 int coverage_enabled = (rb_get_coverage_mode() & COVERAGE_TARGET_EVAL) != 0;
1825
1826 {
1827 int depth = 1;
1828 const VALUE *ep = vm_block_ep(base_block);
1829
1830 while (1) {
1831 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ISOLATED)) {
1832 isolated_depth = depth;
1833 break;
1834 }
1835 else if (VM_ENV_LOCAL_P(ep)) {
1836 break;
1837 }
1838 ep = VM_ENV_PREV_EP(ep);
1839 depth++;
1840 }
1841 }
1842
1843 if (!fname) {
1844 fname = rb_source_location(&line);
1845 }
1846
1847 if (!UNDEF_P(fname)) {
1848 if (!NIL_P(fname)) fname = rb_fstring(fname);
1849 }
1850 else {
1851 fname = get_eval_default_path();
1852 coverage_enabled = FALSE;
1853 }
1854
1855 rb_parser_set_context(parser, parent, FALSE);
1856 if (ruby_vm_keep_script_lines) rb_parser_set_script_lines(parser);
1857 ast_value = rb_parser_compile_string_path(parser, fname, src, line);
1858
1859 ast = rb_ruby_ast_data_get(ast_value);
1860
1861 if (ast->body.root) {
1862 ast->body.coverage_enabled = coverage_enabled;
1863 iseq = rb_iseq_new_eval(ast_value,
1864 ISEQ_BODY(parent)->location.label,
1865 fname, Qnil, line,
1866 parent, isolated_depth);
1867 }
1868 rb_ast_dispose(ast);
1869
1870 if (iseq != NULL) {
1871 if (0 && iseq) { /* for debug */
1872 VALUE disasm = rb_iseq_disasm(iseq);
1873 printf("%s\n", StringValuePtr(disasm));
1874 }
1875
1876 rb_exec_event_hook_script_compiled(GET_EC(), iseq, src);
1877 }
1878
1879 return iseq;
1880}
1881
1882static VALUE
1883eval_string_with_cref(VALUE self, VALUE src, rb_cref_t *cref, VALUE file, int line)
1884{
1885 rb_execution_context_t *ec = GET_EC();
1886 struct rb_block block;
1887 const rb_iseq_t *iseq;
1888 rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
1889 if (!cfp) {
1890 rb_raise(rb_eRuntimeError, "Can't eval on top of Fiber or Thread");
1891 }
1892
1893 block.as.captured = *VM_CFP_TO_CAPTURED_BLOCK(cfp);
1894 block.as.captured.self = self;
1895 block.as.captured.code.iseq = cfp->iseq;
1896 block.type = block_type_iseq;
1897
1898 iseq = eval_make_iseq(src, file, line, &block);
1899 if (!iseq) {
1900 rb_exc_raise(ec->errinfo);
1901 }
1902
1903 /* TODO: what the code checking? */
1904 if (!cref && block.as.captured.code.val) {
1905 rb_cref_t *orig_cref = vm_get_cref(vm_block_ep(&block));
1906 cref = vm_cref_dup(orig_cref);
1907 }
1908 vm_set_eval_stack(ec, iseq, cref, &block);
1909
1910 /* kick */
1911 return vm_exec(ec);
1912}
1913
1914static VALUE
1915eval_string_with_scope(VALUE scope, VALUE src, VALUE file, int line)
1916{
1917 rb_execution_context_t *ec = GET_EC();
1918 rb_binding_t *bind = Check_TypedStruct(scope, &ruby_binding_data_type);
1919 const rb_iseq_t *iseq = eval_make_iseq(src, file, line, &bind->block);
1920 if (!iseq) {
1921 rb_exc_raise(ec->errinfo);
1922 }
1923
1924 vm_set_eval_stack(ec, iseq, NULL, &bind->block);
1925
1926 /* save new env */
1927 if (ISEQ_BODY(iseq)->local_table_size > 0) {
1928 vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->cfp));
1929 }
1930
1931 /* kick */
1932 return vm_exec(ec);
1933}
1934
1935/*
1936 * call-seq:
1937 * eval(string [, binding [, filename [,lineno]]]) -> obj
1938 *
1939 * Evaluates the Ruby expression(s) in <em>string</em>. If
1940 * <em>binding</em> is given, which must be a Binding object, the
1941 * evaluation is performed in its context. If the optional
1942 * <em>filename</em> and <em>lineno</em> parameters are present, they
1943 * will be used when reporting syntax errors.
1944 *
1945 * def get_binding(str)
1946 * return binding
1947 * end
1948 * str = "hello"
1949 * eval "str + ' Fred'" #=> "hello Fred"
1950 * eval "str + ' Fred'", get_binding("bye") #=> "bye Fred"
1951 */
1952
1953VALUE
1954rb_f_eval(int argc, const VALUE *argv, VALUE self)
1955{
1956 VALUE src, scope, vfile, vline;
1957 VALUE file = Qundef;
1958 int line = 1;
1959
1960 rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
1961 StringValue(src);
1962 if (argc >= 3) {
1963 StringValue(vfile);
1964 }
1965 if (argc >= 4) {
1966 line = NUM2INT(vline);
1967 }
1968
1969 if (!NIL_P(vfile))
1970 file = vfile;
1971
1972 if (NIL_P(scope))
1973 return eval_string_with_cref(self, src, NULL, file, line);
1974 else
1975 return eval_string_with_scope(scope, src, file, line);
1976}
1977
1979VALUE
1980ruby_eval_string_from_file(const char *str, const char *filename)
1981{
1982 VALUE file = filename ? rb_str_new_cstr(filename) : 0;
1983 rb_execution_context_t *ec = GET_EC();
1984 rb_control_frame_t *cfp = ec ? rb_vm_get_ruby_level_next_cfp(ec, ec->cfp) : NULL;
1985 VALUE self = cfp ? cfp->self : rb_vm_top_self();
1986 return eval_string_with_cref(self, rb_str_new2(str), NULL, file, 1);
1987}
1988
1989VALUE
1990rb_eval_string(const char *str)
1991{
1992 return ruby_eval_string_from_file(str, "eval");
1993}
1994
1995static VALUE
1996eval_string_protect(VALUE str)
1997{
1998 return rb_eval_string((char *)str);
1999}
2000
2001VALUE
2002rb_eval_string_protect(const char *str, int *pstate)
2003{
2004 return rb_protect(eval_string_protect, (VALUE)str, pstate);
2005}
2006
2008 VALUE top_self;
2009 VALUE klass;
2010 const char *str;
2011};
2012
2013static VALUE
2014eval_string_wrap_protect(VALUE data)
2015{
2016 const struct eval_string_wrap_arg *const arg = (struct eval_string_wrap_arg*)data;
2017 rb_cref_t *cref = rb_vm_cref_new_toplevel();
2018 cref->klass_or_self = arg->klass;
2019 return eval_string_with_cref(arg->top_self, rb_str_new_cstr(arg->str), cref, rb_str_new_cstr("eval"), 1);
2020}
2021
2022VALUE
2023rb_eval_string_wrap(const char *str, int *pstate)
2024{
2025 int state;
2026 rb_thread_t *th = GET_THREAD();
2027 VALUE self = th->top_self;
2028 VALUE wrapper = th->top_wrapper;
2029 VALUE val;
2030 struct eval_string_wrap_arg data;
2031
2032 th->top_wrapper = rb_module_new();
2033 th->top_self = rb_obj_clone(rb_vm_top_self());
2034 rb_extend_object(th->top_self, th->top_wrapper);
2035
2036 data.top_self = th->top_self;
2037 data.klass = th->top_wrapper;
2038 data.str = str;
2039
2040 val = rb_protect(eval_string_wrap_protect, (VALUE)&data, &state);
2041
2042 th->top_self = self;
2043 th->top_wrapper = wrapper;
2044
2045 if (pstate) {
2046 *pstate = state;
2047 }
2048 else if (state != TAG_NONE) {
2049 EC_JUMP_TAG(th->ec, state);
2050 }
2051 return val;
2052}
2053
2054VALUE
2055rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
2056{
2057 enum ruby_tag_type state;
2058 volatile VALUE val = Qnil; /* OK */
2059 rb_execution_context_t * volatile ec = GET_EC();
2060
2061 EC_PUSH_TAG(ec);
2062 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2063 if (!RB_TYPE_P(cmd, T_STRING)) {
2064 val = rb_funcallv_kw(cmd, idCall, RARRAY_LENINT(arg),
2065 RARRAY_CONST_PTR(arg), kw_splat);
2066 }
2067 else {
2068 val = eval_string_with_cref(rb_vm_top_self(), cmd, NULL, 0, 0);
2069 }
2070 }
2071 EC_POP_TAG();
2072
2073 if (state) EC_JUMP_TAG(ec, state);
2074 return val;
2075}
2076
2077/* block eval under the class/module context */
2078
2079static VALUE
2080yield_under(VALUE self, int singleton, int argc, const VALUE *argv, int kw_splat)
2081{
2082 rb_execution_context_t *ec = GET_EC();
2083 rb_control_frame_t *cfp = ec->cfp;
2084 VALUE block_handler = VM_CF_BLOCK_HANDLER(cfp);
2085 VALUE new_block_handler = 0;
2086 const struct rb_captured_block *captured = NULL;
2087 struct rb_captured_block new_captured;
2088 const VALUE *ep = NULL;
2089 rb_cref_t *cref;
2090 int is_lambda = FALSE;
2091
2092 if (block_handler != VM_BLOCK_HANDLER_NONE) {
2093 again:
2094 switch (vm_block_handler_type(block_handler)) {
2095 case block_handler_type_iseq:
2096 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
2097 new_captured = *captured;
2098 new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
2099 break;
2100 case block_handler_type_ifunc:
2101 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
2102 new_captured = *captured;
2103 new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
2104 break;
2105 case block_handler_type_proc:
2106 is_lambda = rb_proc_lambda_p(block_handler) != Qfalse;
2107 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
2108 goto again;
2109 case block_handler_type_symbol:
2110 return rb_sym_proc_call(SYM2ID(VM_BH_TO_SYMBOL(block_handler)),
2111 argc, argv, kw_splat,
2112 VM_BLOCK_HANDLER_NONE);
2113 }
2114
2115 new_captured.self = self;
2116 ep = captured->ep;
2117
2118 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
2119 }
2120
2121 VM_ASSERT(singleton || RB_TYPE_P(self, T_MODULE) || RB_TYPE_P(self, T_CLASS));
2122 cref = vm_cref_push(ec, self, ep, TRUE, singleton);
2123
2124 return vm_yield_with_cref(ec, argc, argv, kw_splat, cref, is_lambda);
2125}
2126
2127VALUE
2128rb_yield_refine_block(VALUE refinement, VALUE refinements)
2129{
2130 rb_execution_context_t *ec = GET_EC();
2131 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
2132
2133 if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
2134 rb_bug("rb_yield_refine_block: an iseq block is required");
2135 }
2136 else {
2137 const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
2138 struct rb_captured_block new_captured = *captured;
2139 const VALUE *const argv = &new_captured.self; /* dummy to suppress nonnull warning from gcc */
2140 VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
2141 const VALUE *ep = captured->ep;
2142 rb_cref_t *cref = vm_cref_push(ec, refinement, ep, TRUE, FALSE);
2143 CREF_REFINEMENTS_SET(cref, refinements);
2144 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
2145 new_captured.self = refinement;
2146 return vm_yield_with_cref(ec, 0, argv, RB_NO_KEYWORDS, cref, FALSE);
2147 }
2148}
2149
2150/* string eval under the class/module context */
2151static VALUE
2152eval_under(VALUE self, int singleton, VALUE src, VALUE file, int line)
2153{
2154 rb_cref_t *cref = vm_cref_push(GET_EC(), self, NULL, FALSE, singleton);
2155 StringValue(src);
2156
2157 return eval_string_with_cref(self, src, cref, file, line);
2158}
2159
2160static VALUE
2161specific_eval(int argc, const VALUE *argv, VALUE self, int singleton, int kw_splat)
2162{
2163 if (rb_block_given_p()) {
2164 rb_check_arity(argc, 0, 0);
2165 return yield_under(self, singleton, 1, &self, kw_splat);
2166 }
2167 else {
2168 VALUE file = Qnil;
2169 int line = 1;
2170 VALUE code;
2171
2172 rb_check_arity(argc, 1, 3);
2173 code = argv[0];
2174 StringValue(code);
2175 if (argc > 2)
2176 line = NUM2INT(argv[2]);
2177 if (argc > 1) {
2178 file = argv[1];
2179 if (!NIL_P(file)) StringValue(file);
2180 }
2181
2182 if (NIL_P(file)) {
2183 file = get_eval_default_path();
2184 }
2185
2186 return eval_under(self, singleton, code, file, line);
2187 }
2188}
2189
2190/*
2191 * call-seq:
2192 * obj.instance_eval(string [, filename [, lineno]] ) -> obj
2193 * obj.instance_eval {|obj| block } -> obj
2194 *
2195 * Evaluates a string containing Ruby source code, or the given block,
2196 * within the context of the receiver (_obj_). In order to set the
2197 * context, the variable +self+ is set to _obj_ while
2198 * the code is executing, giving the code access to _obj_'s
2199 * instance variables and private methods.
2200 *
2201 * When <code>instance_eval</code> is given a block, _obj_ is also
2202 * passed in as the block's only argument.
2203 *
2204 * When <code>instance_eval</code> is given a +String+, the optional
2205 * second and third parameters supply a filename and starting line number
2206 * that are used when reporting compilation errors.
2207 *
2208 * class KlassWithSecret
2209 * def initialize
2210 * @secret = 99
2211 * end
2212 * private
2213 * def the_secret
2214 * "Ssssh! The secret is #{@secret}."
2215 * end
2216 * end
2217 * k = KlassWithSecret.new
2218 * k.instance_eval { @secret } #=> 99
2219 * k.instance_eval { the_secret } #=> "Ssssh! The secret is 99."
2220 * k.instance_eval {|obj| obj == self } #=> true
2221 */
2222
2223static VALUE
2224rb_obj_instance_eval_internal(int argc, const VALUE *argv, VALUE self)
2225{
2226 return specific_eval(argc, argv, self, TRUE, RB_PASS_CALLED_KEYWORDS);
2227}
2228
2229VALUE
2230rb_obj_instance_eval(int argc, const VALUE *argv, VALUE self)
2231{
2232 return specific_eval(argc, argv, self, TRUE, RB_NO_KEYWORDS);
2233}
2234
2235/*
2236 * call-seq:
2237 * obj.instance_exec(arg...) {|var...| block } -> obj
2238 *
2239 * Executes the given block within the context of the receiver
2240 * (_obj_). In order to set the context, the variable +self+ is set
2241 * to _obj_ while the code is executing, giving the code access to
2242 * _obj_'s instance variables. Arguments are passed as block parameters.
2243 *
2244 * class KlassWithSecret
2245 * def initialize
2246 * @secret = 99
2247 * end
2248 * end
2249 * k = KlassWithSecret.new
2250 * k.instance_exec(5) {|x| @secret+x } #=> 104
2251 */
2252
2253static VALUE
2254rb_obj_instance_exec_internal(int argc, const VALUE *argv, VALUE self)
2255{
2256 return yield_under(self, TRUE, argc, argv, RB_PASS_CALLED_KEYWORDS);
2257}
2258
2259VALUE
2260rb_obj_instance_exec(int argc, const VALUE *argv, VALUE self)
2261{
2262 return yield_under(self, TRUE, argc, argv, RB_NO_KEYWORDS);
2263}
2264
2265/*
2266 * call-seq:
2267 * mod.class_eval(string [, filename [, lineno]]) -> obj
2268 * mod.class_eval {|mod| block } -> obj
2269 * mod.module_eval(string [, filename [, lineno]]) -> obj
2270 * mod.module_eval {|mod| block } -> obj
2271 *
2272 * Evaluates the string or block in the context of _mod_, except that when
2273 * a block is given, constant/class variable lookup is not affected. This
2274 * can be used to add methods to a class. <code>module_eval</code> returns
2275 * the result of evaluating its argument. The optional _filename_ and
2276 * _lineno_ parameters set the text for error messages.
2277 *
2278 * class Thing
2279 * end
2280 * a = %q{def hello() "Hello there!" end}
2281 * Thing.module_eval(a)
2282 * puts Thing.new.hello()
2283 * Thing.module_eval("invalid code", "dummy", 123)
2284 *
2285 * <em>produces:</em>
2286 *
2287 * Hello there!
2288 * dummy:123:in `module_eval': undefined local variable
2289 * or method `code' for Thing:Class
2290 */
2291
2292static VALUE
2293rb_mod_module_eval_internal(int argc, const VALUE *argv, VALUE mod)
2294{
2295 return specific_eval(argc, argv, mod, FALSE, RB_PASS_CALLED_KEYWORDS);
2296}
2297
2298VALUE
2299rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
2300{
2301 return specific_eval(argc, argv, mod, FALSE, RB_NO_KEYWORDS);
2302}
2303
2304/*
2305 * call-seq:
2306 * mod.module_exec(arg...) {|var...| block } -> obj
2307 * mod.class_exec(arg...) {|var...| block } -> obj
2308 *
2309 * Evaluates the given block in the context of the class/module.
2310 * The method defined in the block will belong to the receiver.
2311 * Any arguments passed to the method will be passed to the block.
2312 * This can be used if the block needs to access instance variables.
2313 *
2314 * class Thing
2315 * end
2316 * Thing.class_exec{
2317 * def hello() "Hello there!" end
2318 * }
2319 * puts Thing.new.hello()
2320 *
2321 * <em>produces:</em>
2322 *
2323 * Hello there!
2324 */
2325
2326static VALUE
2327rb_mod_module_exec_internal(int argc, const VALUE *argv, VALUE mod)
2328{
2329 return yield_under(mod, FALSE, argc, argv, RB_PASS_CALLED_KEYWORDS);
2330}
2331
2332VALUE
2333rb_mod_module_exec(int argc, const VALUE *argv, VALUE mod)
2334{
2335 return yield_under(mod, FALSE, argc, argv, RB_NO_KEYWORDS);
2336}
2337
2338/*
2339 * Document-class: UncaughtThrowError
2340 *
2341 * Raised when +throw+ is called with a _tag_ which does not have
2342 * corresponding +catch+ block.
2343 *
2344 * throw "foo", "bar"
2345 *
2346 * <em>raises the exception:</em>
2347 *
2348 * UncaughtThrowError: uncaught throw "foo"
2349 */
2350
2351static VALUE
2352uncaught_throw_init(int argc, const VALUE *argv, VALUE exc)
2353{
2355 rb_call_super(argc - 2, argv + 2);
2356 rb_ivar_set(exc, id_tag, argv[0]);
2357 rb_ivar_set(exc, id_value, argv[1]);
2358 return exc;
2359}
2360
2361/*
2362 * call-seq:
2363 * uncaught_throw.tag -> obj
2364 *
2365 * Return the tag object which was called for.
2366 */
2367
2368static VALUE
2369uncaught_throw_tag(VALUE exc)
2370{
2371 return rb_ivar_get(exc, id_tag);
2372}
2373
2374/*
2375 * call-seq:
2376 * uncaught_throw.value -> obj
2377 *
2378 * Return the return value which was called for.
2379 */
2380
2381static VALUE
2382uncaught_throw_value(VALUE exc)
2383{
2384 return rb_ivar_get(exc, id_value);
2385}
2386
2387/*
2388 * call-seq:
2389 * uncaught_throw.to_s -> string
2390 *
2391 * Returns formatted message with the inspected tag.
2392 */
2393
2394static VALUE
2395uncaught_throw_to_s(VALUE exc)
2396{
2397 VALUE mesg = rb_attr_get(exc, id_mesg);
2398 VALUE tag = uncaught_throw_tag(exc);
2399 return rb_str_format(1, &tag, mesg);
2400}
2401
2402/*
2403 * call-seq:
2404 * throw(tag [, obj])
2405 *
2406 * Transfers control to the end of the active +catch+ block
2407 * waiting for _tag_. Raises +UncaughtThrowError+ if there
2408 * is no +catch+ block for the _tag_. The optional second
2409 * parameter supplies a return value for the +catch+ block,
2410 * which otherwise defaults to +nil+. For examples, see
2411 * Kernel::catch.
2412 */
2413
2414static VALUE
2415rb_f_throw(int argc, VALUE *argv, VALUE _)
2416{
2417 VALUE tag, value;
2418
2419 rb_scan_args(argc, argv, "11", &tag, &value);
2420 rb_throw_obj(tag, value);
2422}
2423
2424void
2426{
2427 rb_execution_context_t *ec = GET_EC();
2428 struct rb_vm_tag *tt = ec->tag;
2429
2430 while (tt) {
2431 if (tt->tag == tag) {
2432 tt->retval = value;
2433 break;
2434 }
2435 tt = tt->prev;
2436 }
2437 if (!tt) {
2438 VALUE desc[3];
2439 desc[0] = tag;
2440 desc[1] = value;
2441 desc[2] = rb_str_new_cstr("uncaught throw %p");
2442 rb_exc_raise(rb_class_new_instance(numberof(desc), desc, rb_eUncaughtThrow));
2443 }
2444
2445 ec->errinfo = (VALUE)THROW_DATA_NEW(tag, NULL, TAG_THROW);
2446 EC_JUMP_TAG(ec, TAG_THROW);
2447}
2448
2449void
2450rb_throw(const char *tag, VALUE val)
2451{
2452 rb_throw_obj(rb_sym_intern_ascii_cstr(tag), val);
2453}
2454
2455static VALUE
2456catch_i(RB_BLOCK_CALL_FUNC_ARGLIST(tag, _))
2457{
2458 return rb_yield_0(1, &tag);
2459}
2460
2461/*
2462 * call-seq:
2463 * catch([tag]) {|tag| block } -> obj
2464 *
2465 * +catch+ executes its block. If +throw+ is not called, the block executes
2466 * normally, and +catch+ returns the value of the last expression evaluated.
2467 *
2468 * catch(1) { 123 } # => 123
2469 *
2470 * If <code>throw(tag2, val)</code> is called, Ruby searches up its stack for
2471 * a +catch+ block whose +tag+ has the same +object_id+ as _tag2_. When found,
2472 * the block stops executing and returns _val_ (or +nil+ if no second argument
2473 * was given to +throw+).
2474 *
2475 * catch(1) { throw(1, 456) } # => 456
2476 * catch(1) { throw(1) } # => nil
2477 *
2478 * When +tag+ is passed as the first argument, +catch+ yields it as the
2479 * parameter of the block.
2480 *
2481 * catch(1) {|x| x + 2 } # => 3
2482 *
2483 * When no +tag+ is given, +catch+ yields a new unique object (as from
2484 * +Object.new+) as the block parameter. This object can then be used as the
2485 * argument to +throw+, and will match the correct +catch+ block.
2486 *
2487 * catch do |obj_A|
2488 * catch do |obj_B|
2489 * throw(obj_B, 123)
2490 * puts "This puts is not reached"
2491 * end
2492 *
2493 * puts "This puts is displayed"
2494 * 456
2495 * end
2496 *
2497 * # => 456
2498 *
2499 * catch do |obj_A|
2500 * catch do |obj_B|
2501 * throw(obj_A, 123)
2502 * puts "This puts is still not reached"
2503 * end
2504 *
2505 * puts "Now this puts is also not reached"
2506 * 456
2507 * end
2508 *
2509 * # => 123
2510 */
2511
2512static VALUE
2513rb_f_catch(int argc, VALUE *argv, VALUE self)
2514{
2515 VALUE tag = rb_check_arity(argc, 0, 1) ? argv[0] : rb_obj_alloc(rb_cObject);
2516 return rb_catch_obj(tag, catch_i, 0);
2517}
2518
2519VALUE
2520rb_catch(const char *tag, rb_block_call_func_t func, VALUE data)
2521{
2522 VALUE vtag = tag ? rb_sym_intern_ascii_cstr(tag) : rb_obj_alloc(rb_cObject);
2523 return rb_catch_obj(vtag, func, data);
2524}
2525
2526static VALUE
2527vm_catch_protect(VALUE tag, rb_block_call_func *func, VALUE data,
2528 enum ruby_tag_type *stateptr, rb_execution_context_t *volatile ec)
2529{
2530 enum ruby_tag_type state;
2531 VALUE val = Qnil; /* OK */
2532 rb_control_frame_t *volatile saved_cfp = ec->cfp;
2533
2534 EC_PUSH_TAG(ec);
2535
2536 _tag.tag = tag;
2537
2538 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2539 /* call with argc=1, argv = [tag], block = Qnil to insure compatibility */
2540 val = (*func)(tag, data, 1, (const VALUE *)&tag, Qnil);
2541 }
2542 else if (state == TAG_THROW && THROW_DATA_VAL((struct vm_throw_data *)ec->errinfo) == tag) {
2543 rb_vm_rewind_cfp(ec, saved_cfp);
2544 val = ec->tag->retval;
2545 ec->errinfo = Qnil;
2546 state = 0;
2547 }
2548 EC_POP_TAG();
2549 if (stateptr)
2550 *stateptr = state;
2551
2552 return val;
2553}
2554
2555VALUE
2556rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr)
2557{
2558 return vm_catch_protect(t, func, data, stateptr, GET_EC());
2559}
2560
2561VALUE
2563{
2564 enum ruby_tag_type state;
2565 rb_execution_context_t *ec = GET_EC();
2566 VALUE val = vm_catch_protect(t, (rb_block_call_func *)func, data, &state, ec);
2567 if (state) EC_JUMP_TAG(ec, state);
2568 return val;
2569}
2570
2571static void
2572local_var_list_init(struct local_var_list *vars)
2573{
2574 vars->tbl = rb_ident_hash_new();
2575 RBASIC_CLEAR_CLASS(vars->tbl);
2576}
2577
2578static VALUE
2579local_var_list_finish(struct local_var_list *vars)
2580{
2581 /* TODO: not to depend on the order of st_table */
2582 VALUE ary = rb_hash_keys(vars->tbl);
2583 rb_hash_clear(vars->tbl);
2584 vars->tbl = 0;
2585 return ary;
2586}
2587
2588static int
2589local_var_list_update(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
2590{
2591 if (existing) return ST_STOP;
2592 *value = (st_data_t)Qtrue; /* INT2FIX(arg) */
2593 return ST_CONTINUE;
2594}
2595
2596static void
2597local_var_list_add(const struct local_var_list *vars, ID lid)
2598{
2599 if (lid && rb_is_local_id(lid)) {
2600 /* should skip temporary variable */
2601 st_data_t idx = 0; /* tbl->num_entries */
2602 rb_hash_stlike_update(vars->tbl, ID2SYM(lid), local_var_list_update, idx);
2603 }
2604}
2605
2606/*
2607 * call-seq:
2608 * local_variables -> array
2609 *
2610 * Returns the names of the current local variables.
2611 *
2612 * fred = 1
2613 * for i in 1..10
2614 * # ...
2615 * end
2616 * local_variables #=> [:fred, :i]
2617 */
2618
2619static VALUE
2620rb_f_local_variables(VALUE _)
2621{
2622 struct local_var_list vars;
2623 rb_execution_context_t *ec = GET_EC();
2624 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp));
2625 unsigned int i;
2626
2627 local_var_list_init(&vars);
2628 while (cfp) {
2629 if (cfp->iseq) {
2630 for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
2631 local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
2632 }
2633 }
2634 if (!VM_ENV_LOCAL_P(cfp->ep)) {
2635 /* block */
2636 const VALUE *ep = VM_CF_PREV_EP(cfp);
2637
2638 if (vm_collect_local_variables_in_heap(ep, &vars)) {
2639 break;
2640 }
2641 else {
2642 while (cfp->ep != ep) {
2643 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2644 }
2645 }
2646 }
2647 else {
2648 break;
2649 }
2650 }
2651 return local_var_list_finish(&vars);
2652}
2653
2654/*
2655 * call-seq:
2656 * block_given? -> true or false
2657 *
2658 * Returns <code>true</code> if <code>yield</code> would execute a
2659 * block in the current context. The <code>iterator?</code> form
2660 * is mildly deprecated.
2661 *
2662 * def try
2663 * if block_given?
2664 * yield
2665 * else
2666 * "no block"
2667 * end
2668 * end
2669 * try #=> "no block"
2670 * try { "hello" } #=> "hello"
2671 * try do "hello" end #=> "hello"
2672 */
2673
2674static VALUE
2675rb_f_block_given_p(VALUE _)
2676{
2677 rb_execution_context_t *ec = GET_EC();
2678 rb_control_frame_t *cfp = ec->cfp;
2679 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2680
2681 return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);
2682}
2683
2684/*
2685 * call-seq:
2686 * iterator? -> true or false
2687 *
2688 * Deprecated. Use block_given? instead.
2689 */
2690
2691static VALUE
2692rb_f_iterator_p(VALUE self)
2693{
2694 rb_warn_deprecated("iterator?", "block_given?");
2695 return rb_f_block_given_p(self);
2696}
2697
2698VALUE
2699rb_current_realfilepath(void)
2700{
2701 const rb_execution_context_t *ec = GET_EC();
2702 rb_control_frame_t *cfp = ec->cfp;
2703 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2704 if (cfp != NULL) {
2705 VALUE path = rb_iseq_realpath(cfp->iseq);
2706 if (RTEST(path)) return path;
2707 // eval context
2708 path = rb_iseq_path(cfp->iseq);
2709 if (path == eval_default_path) {
2710 return Qnil;
2711 }
2712
2713 // [Feature #19755] implicit eval location is "(eval at #{__FILE__}:#{__LINE__})"
2714 const long len = RSTRING_LEN(path);
2715 if (len > EVAL_LOCATION_MARK_LEN+1) {
2716 const char *const ptr = RSTRING_PTR(path);
2717 if (ptr[len - 1] == ')' &&
2718 memcmp(ptr, "("EVAL_LOCATION_MARK, EVAL_LOCATION_MARK_LEN+1) == 0) {
2719 return Qnil;
2720 }
2721 }
2722
2723 return path;
2724 }
2725 return Qnil;
2726}
2727
2728// Assert that an internal function is running and return
2729// the imemo object that represents it.
2730struct vm_ifunc *
2731rb_current_ifunc(void)
2732{
2733 // Search VM_FRAME_MAGIC_IFUNC to see ifunc imemos put on the iseq field.
2734 VALUE ifunc = (VALUE)GET_EC()->cfp->iseq;
2735 RUBY_ASSERT_ALWAYS(imemo_type_p(ifunc, imemo_ifunc));
2736 return (struct vm_ifunc *)ifunc;
2737}
2738
2739void
2740Init_vm_eval(void)
2741{
2742 rb_define_global_function("eval", rb_f_eval, -1);
2743 rb_define_global_function("local_variables", rb_f_local_variables, 0);
2744 rb_define_global_function("iterator?", rb_f_iterator_p, 0);
2745 rb_define_global_function("block_given?", rb_f_block_given_p, 0);
2746
2747 rb_define_global_function("catch", rb_f_catch, -1);
2748 rb_define_global_function("throw", rb_f_throw, -1);
2749
2750 rb_define_method(rb_cBasicObject, "instance_eval", rb_obj_instance_eval_internal, -1);
2751 rb_define_method(rb_cBasicObject, "instance_exec", rb_obj_instance_exec_internal, -1);
2752 rb_define_private_method(rb_cBasicObject, "method_missing", rb_method_missing, -1);
2753
2754#if 1
2755 rb_add_method(rb_cBasicObject, id__send__,
2756 VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2757 rb_add_method(rb_mKernel, idSend,
2758 VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2759#else
2760 rb_define_method(rb_cBasicObject, "__send__", rb_f_send, -1);
2761 rb_define_method(rb_mKernel, "send", rb_f_send, -1);
2762#endif
2763 rb_define_method(rb_mKernel, "public_send", rb_f_public_send, -1);
2764
2765 rb_define_method(rb_cModule, "module_exec", rb_mod_module_exec_internal, -1);
2766 rb_define_method(rb_cModule, "class_exec", rb_mod_module_exec_internal, -1);
2767 rb_define_method(rb_cModule, "module_eval", rb_mod_module_eval_internal, -1);
2768 rb_define_method(rb_cModule, "class_eval", rb_mod_module_eval_internal, -1);
2769
2770 rb_eUncaughtThrow = rb_define_class("UncaughtThrowError", rb_eArgError);
2771 rb_define_method(rb_eUncaughtThrow, "initialize", uncaught_throw_init, -1);
2772 rb_define_method(rb_eUncaughtThrow, "tag", uncaught_throw_tag, 0);
2773 rb_define_method(rb_eUncaughtThrow, "value", uncaught_throw_value, 0);
2774 rb_define_method(rb_eUncaughtThrow, "to_s", uncaught_throw_to_s, 0);
2775
2776 id_result = rb_intern_const("result");
2777 id_tag = rb_intern_const("tag");
2778 id_value = rb_intern_const("value");
2779}
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with RUBY_DEBUG.
Definition assert.h:199
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
#define RUBY_EVENT_C_CALL
A method, written in C, is called.
Definition event.h:43
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
Definition event.h:44
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition class.c:980
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
Definition eval.c:1756
VALUE rb_module_new(void)
Creates a new, anonymous module.
Definition class.c:1076
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
Definition class.c:2635
int rb_keyword_given_p(void)
Determines if the current method is given a keyword argument.
Definition eval.c:950
int rb_block_given_p(void)
Determines if the current method is given a block.
Definition eval.c:937
#define rb_str_new2
Old name of rb_str_new_cstr.
Definition string.h:1675
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
Definition value_type.h:59
#define T_FILE
Old name of RUBY_T_FILE.
Definition value_type.h:62
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define T_MASK
Old name of RUBY_T_MASK.
Definition value_type.h:68
#define Qundef
Old name of RUBY_Qundef.
#define T_NIL
Old name of RUBY_T_NIL.
Definition value_type.h:72
#define T_FLOAT
Old name of RUBY_T_FLOAT.
Definition value_type.h:64
#define T_IMEMO
Old name of RUBY_T_IMEMO.
Definition value_type.h:67
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
Definition value_type.h:57
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
Definition value_type.h:79
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:135
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
Definition value_type.h:63
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
Definition assume.h:29
#define SYM2ID
Old name of RB_SYM2ID.
Definition symbol.h:45
#define T_DATA
Old name of RUBY_T_DATA.
Definition value_type.h:60
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:203
#define T_NONE
Old name of RUBY_T_NONE.
Definition value_type.h:74
#define T_NODE
Old name of RUBY_T_NODE.
Definition value_type.h:73
#define rb_ary_new4
Old name of rb_ary_new_from_values.
Definition array.h:659
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define T_TRUE
Old name of RUBY_T_TRUE.
Definition value_type.h:81
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
Definition value_type.h:76
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define T_FALSE
Old name of RUBY_T_FALSE.
Definition value_type.h:61
#define T_UNDEF
Old name of RUBY_T_UNDEF.
Definition value_type.h:82
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
Definition int.h:44
#define T_ZOMBIE
Old name of RUBY_T_ZOMBIE.
Definition value_type.h:83
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define T_OBJECT
Old name of RUBY_T_OBJECT.
Definition value_type.h:75
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
Definition memory.h:405
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
Definition value_type.h:80
#define T_MATCH
Old name of RUBY_T_MATCH.
Definition value_type.h:69
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
Definition value_type.h:85
#define T_MOVED
Old name of RUBY_T_MOVED.
Definition value_type.h:71
#define Check_TypedStruct(v, t)
Old name of rb_check_typeddata.
Definition rtypeddata.h:105
#define ALLOCV_END
Old name of RB_ALLOCV_END.
Definition memory.h:406
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
#define T_REGEXP
Old name of RUBY_T_REGEXP.
Definition value_type.h:77
VALUE rb_eNotImpError
NotImplementedError exception.
Definition error.c:1440
VALUE rb_eNameError
NameError exception.
Definition error.c:1435
VALUE rb_eNoMethodError
NoMethodError exception.
Definition error.c:1438
VALUE rb_eRuntimeError
RuntimeError exception.
Definition error.c:1428
VALUE rb_mKernel
Kernel module.
Definition object.c:65
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
Definition object.c:2097
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
Definition object.c:2138
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
Definition object.c:247
VALUE rb_cBasicObject
BasicObject class.
Definition object.c:64
VALUE rb_cModule
Module class.
Definition object.c:67
VALUE rb_obj_clone(VALUE obj)
Produces a shallow copy of the given object.
Definition object.c:521
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
Definition object.c:865
VALUE rb_eval_string_wrap(const char *str, int *state)
Identical to rb_eval_string_protect(), except it evaluates the given string under a module binding in...
Definition vm_eval.c:2023
VALUE rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv_public(), except you can pass the passed block.
Definition vm_eval.c:1162
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1099
VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv(), except you can specify how to handle the last element of the given array.
Definition vm_eval.c:1066
VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval)
Identical to rb_funcallv_public(), except you can pass a block.
Definition vm_eval.c:1176
VALUE rb_eval_string_protect(const char *str, int *state)
Identical to rb_eval_string(), except it avoids potential global escapes.
Definition vm_eval.c:2002
VALUE rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
Identical to rb_call_super(), except you can specify how to handle the last element of the given arra...
Definition vm_eval.c:354
VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it only takes public methods into account.
Definition vm_eval.c:1150
VALUE rb_current_receiver(void)
This resembles ruby's self.
Definition vm_eval.c:368
VALUE rb_funcall_passing_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv_passing_block(), except you can specify how to handle the last element of th...
Definition vm_eval.c:1169
VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval, int kw_splat)
Identical to rb_funcallv_with_block(), except you can specify how to handle the last element of the g...
Definition vm_eval.c:1186
VALUE rb_eval_string(const char *str)
Evaluates the given string.
Definition vm_eval.c:1990
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
Definition vm_eval.c:362
VALUE rb_funcallv_public_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv_public(), except you can specify how to handle the last element of the given...
Definition vm_eval.c:1156
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
Definition error.h:35
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
Definition error.h:284
int rb_is_local_id(ID id)
Classifies the given ID, then sees if it is a local variable.
Definition symbol.c:1093
VALUE rb_proc_lambda_p(VALUE recv)
Queries if the given object is a lambda.
Definition proc.c:244
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1514
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
Definition symbol.c:878
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1871
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1362
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
Definition vm_eval.c:668
VALUE rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_check_funcall(), except you can specify how to handle the last element of the given a...
Definition vm_eval.c:662
VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_eval(), except it evaluates within the context of module.
Definition vm_eval.c:2299
VALUE rb_mod_module_exec(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_exec(), except it evaluates within the context of module.
Definition vm_eval.c:2333
VALUE rb_obj_instance_exec(int argc, const VALUE *argv, VALUE recv)
Executes the given block within the context of the receiver.
Definition vm_eval.c:2260
VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
This API is practically a variant of rb_proc_call_kw() now.
Definition vm_eval.c:2055
VALUE rb_apply(VALUE recv, ID mid, VALUE args)
Identical to rb_funcallv(), except it takes Ruby's array instead of C's.
Definition vm_eval.c:1074
VALUE rb_obj_instance_eval(int argc, const VALUE *argv, VALUE recv)
Evaluates a string containing Ruby source code, or the given block, within the context of the receive...
Definition vm_eval.c:2230
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:284
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
Definition symbol.c:1117
int len
Length of the buffer.
Definition io.h:8
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
Definition sprintf.c:215
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
Definition iterator.h:58
VALUE rb_each(VALUE obj)
This is a shorthand of calling obj.each.
Definition vm_eval.c:1627
VALUE rb_yield_values(int n,...)
Identical to rb_yield(), except it takes variadic number of parameters and pass them to the block.
Definition vm_eval.c:1366
VALUE rb_yield_splat(VALUE ary)
Identical to rb_yield_values(), except it splats an array to generate the list of parameters.
Definition vm_eval.c:1400
void rb_throw(const char *tag, VALUE val)
Transfers control to the end of the active catch block waiting for tag.
Definition vm_eval.c:2450
VALUE rb_yield_values2(int n, const VALUE *argv)
Identical to rb_yield_values(), except it takes the parameters as a C array instead of variadic argum...
Definition vm_eval.c:1388
VALUE rb_yield(VALUE val)
Yields the block.
Definition vm_eval.c:1354
VALUE rb_yield_values_kw(int n, const VALUE *argv, int kw_splat)
Identical to rb_yield_values2(), except you can specify how to handle the last element of the given a...
Definition vm_eval.c:1394
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
Definition iterator.h:88
VALUE rb_yield_block(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
Pass a passed block.
void rb_throw_obj(VALUE tag, VALUE val)
Identical to rb_throw(), except it allows arbitrary Ruby object to become a tag.
Definition vm_eval.c:2425
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
This is the type of a function that the interpreter expect for C-backended blocks.
Definition iterator.h:83
VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t proc, VALUE data2, int kw_splat)
Identical to rb_funcallv_kw(), except it additionally passes a function as a block.
Definition vm_eval.c:1541
VALUE rb_yield_splat_kw(VALUE ary, int kw_splat)
Identical to rb_yield_splat(), except you can specify how to handle the last element of the given arr...
Definition vm_eval.c:1413
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
Definition memory.h:372
#define ALLOCA_N(type, n)
Definition memory.h:292
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
VALUE rb_catch_obj(VALUE q, type *w, VALUE e)
An equivalent of Kernel#catch.
VALUE rb_catch(const char *q, type *w, VALUE e)
An equivalent of Kernel#catch.
VALUE rb_block_call(VALUE q, ID w, int e, const VALUE *r, type *t, VALUE y)
Call a method with a block.
VALUE rb_iterate(onearg_type *q, VALUE w, type *e, VALUE r)
Old way to implement iterators.
VALUE type(ANYARGS)
ANYARGS-ed function type.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
struct pm_options_scope pm_options_scope_t
A scope of locals surrounding the code that is being parsed.
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
Definition rarray.h:281
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
Definition rbasic.h:150
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define RCLASS_SUPER
Just another name of rb_class_get_superclass.
Definition rclass.h:44
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
Definition rhash.h:79
#define StringValue(v)
Ensures that the parameter object is a String.
Definition rstring.h:66
#define StringValuePtr(v)
Identical to StringValue, except it returns a char*.
Definition rstring.h:76
#define RB_PASS_CALLED_KEYWORDS
Pass keywords if current method is called with keywords, useful for argument delegation.
Definition scan_args.h:78
#define RB_NO_KEYWORDS
Do not pass keywords.
Definition scan_args.h:69
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
Definition stdarg.h:35
pm_string_t * locals
The names of the locals in the scope.
Definition options.h:41
pm_options_scope_t * scopes
The scopes surrounding the code that is being parsed.
Definition options.h:116
pm_scope_node_t node
The resulting scope node that will hold the generated AST.
pm_parser_t parser
The parser that will do the actual parsing.
pm_options_t options
The options that will be passed to the parser.
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
Definition parser.h:786
A generic string type that can have various ownership semantics.
Definition pm_string.h:33
IFUNC (Internal FUNCtion)
Definition imemo.h:88
THROW_DATA.
Definition imemo.h:61
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376
ruby_value_type
C-level type of an object.
Definition value_type.h:113