ruby/eval.c at master · abunashir/ruby

History
/**********************************************************************
  created at: Thu Jun 10 14:22:17 JST 1993
  Copyright (C) 1993-2007 Yukihiro Matsumoto
  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
  Copyright (C) 2000  Information-technology Promotion Agency, Japan
**********************************************************************/
#include "ruby/3/config.h"
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#include "eval_intern.h"
#include "gc.h"
#include "internal.h"
#include "internal/class.h"
#include "internal/error.h"
#include "internal/eval.h"
#include "internal/hash.h"
#include "internal/inits.h"
#include "internal/io.h"
#include "internal/mjit.h"
#include "internal/object.h"
#include "internal/variable.h"
#include "iseq.h"
#include "mjit.h"
#include "probes.h"
#include "probes_helper.h"
#include "ruby/vm.h"
#include "vm_core.h"
NORETURN(void rb_raise_jump(VALUE, VALUE));
void rb_ec_clear_current_thread_trace_func(const rb_execution_context_t *ec);
void rb_ec_clear_all_trace_func(const rb_execution_context_t *ec);
static int rb_ec_cleanup(rb_execution_context_t *ec, volatile int ex);
static int rb_ec_exec_node(rb_execution_context_t *ec, void *n);
VALUE rb_eLocalJumpError;
VALUE rb_eSysStackError;
ID ruby_static_id_signo, ruby_static_id_status;
extern ID ruby_static_id_cause;
#define id_cause ruby_static_id_cause
#define exception_error GET_VM()->special_exceptions[ruby_error_reenter]
#include "eval_error.c"
#include "eval_jump.c"
#define CLASS_OR_MODULE_P(obj) \
    (!SPECIAL_CONST_P(obj) && \
     (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE))
 * Initializes the VM and builtin libraries.
 * @retval 0 if succeeded.
 * @retval non-zero an error occurred.
ruby_setup(void)
    enum ruby_tag_type state;
    if (GET_VM())
    ruby_init_stack((void *)&state);
     * Disable THP early before mallocs happen because we want this to
     * affect as many future pages as possible for CoW-friendliness
#if defined(__linux__) && defined(PR_SET_THP_DISABLE)
    prctl(PR_SET_THP_DISABLE, 1, 0, 0, 0);
    Init_BareVM();
    Init_heap();
    rb_vm_encoded_insn_data_table_init();
    Init_vm_objects();
    EC_PUSH_TAG(GET_EC());
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
	rb_call_inits();
	ruby_prog_init();
	GET_VM()->running = 1;
    EC_POP_TAG();
    return state;
 * Calls ruby_setup() and check error.
 * Prints errors and calls exit(3) if an error occurred.
ruby_init(void)
    int state = ruby_setup();
    if (state) {
        if (RTEST(ruby_debug))
            error_print(GET_EC());
	exit(EXIT_FAILURE);
/*! Processes command line arguments and compiles the Ruby source to execute.
 * This function does:
 * \li Processes the given command line flags and arguments for ruby(1)
 * \li compiles the source code from the given argument, -e or stdin, and
 * \li returns the compiled source as an opaque pointer to an internal data structure
 * @return an opaque pointer to the compiled source or an internal special value.
 * @sa ruby_executable_node().
ruby_options(int argc, char **argv)
    rb_execution_context_t *ec = GET_EC();
    enum ruby_tag_type state;
    void *volatile iseq = 0;
    ruby_init_stack((void *)&iseq);
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
	SAVE_ROOT_JMPBUF(GET_THREAD(), iseq = ruby_process_options(argc, argv));
        rb_ec_clear_current_thread_trace_func(ec);
        state = error_handle(ec, state);
	iseq = (void *)INT2FIX(state);
    EC_POP_TAG();
    return iseq;
static void
rb_ec_teardown(rb_execution_context_t *ec)
    EC_PUSH_TAG(ec);
    if (EC_EXEC_TAG() == TAG_NONE) {
        rb_vm_trap_exit(rb_ec_vm_ptr(ec));
    EC_POP_TAG();
    rb_ec_exec_end_proc(ec);
    rb_ec_clear_all_trace_func(ec);
static void
rb_ec_finalize(rb_execution_context_t *ec)
    ruby_sig_finalize();
    ec->errinfo = Qnil;
    rb_objspace_call_finalizer(rb_ec_vm_ptr(ec)->objspace);
/** Runs the VM finalization processes.
 * <code>END{}</code> and procs registered by <code>Kernel.#at_exit</code> are
 * executed here. See the Ruby language spec for more details.
 * @note This function is allowed to raise an exception if an error occurred.
ruby_finalize(void)
    rb_execution_context_t *ec = GET_EC();
    rb_ec_teardown(ec);
    rb_ec_finalize(ec);
/** Destructs the VM.
 * Runs the VM finalization processes as well as ruby_finalize(), and frees
 * resources used by the VM.
 * @param ex Default value to the return value.
 * @return If an error occurred returns a non-zero. If otherwise, returns the
 *         given ex.
 * @note This function does not raise any exception.
ruby_cleanup(volatile int ex)
    return rb_ec_cleanup(GET_EC(), ex);
rb_ec_cleanup(rb_execution_context_t *ec, volatile int ex)
    int state;
    volatile VALUE errs[2] = { Qundef, Qundef };
    int nerr;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    rb_thread_t *const volatile th0 = th;
    volatile int sysex = EXIT_SUCCESS;
    volatile int step = 0;
    rb_threadptr_interrupt(th);
    rb_threadptr_check_signal(th);
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        th = th0;
        SAVE_ROOT_JMPBUF(th, { RUBY_VM_CHECK_INTS(ec); });
      step_0: step++;
        th = th0;
        errs[1] = ec->errinfo;
        if (THROW_DATA_P(ec->errinfo)) ec->errinfo = Qnil;
	ruby_init_stack(&errs[STACK_UPPER(errs, 0, 1)]);
        SAVE_ROOT_JMPBUF(th, rb_ec_teardown(ec));
      step_1: step++;
        th = th0;
	/* protect from Thread#raise */
	th->status = THREAD_KILLED;
        errs[0] = ec->errinfo;
	SAVE_ROOT_JMPBUF(th, rb_thread_terminate_all());
	switch (step) {
	  case 0: goto step_0;
	  case 1: goto step_1;
	if (ex == 0) ex = state;
    th = th0;
    ec->errinfo = errs[1];
    sysex = error_handle(ec, ex);
    state = 0;
    for (nerr = 0; nerr < numberof(errs); ++nerr) {
	VALUE err = ATOMIC_VALUE_EXCHANGE(errs[nerr], Qnil);
        VALUE sig;
	if (!RTEST(err)) continue;
        /* ec->errinfo contains a NODE while break'ing */
	if (THROW_DATA_P(err)) continue;
	if (rb_obj_is_kind_of(err, rb_eSystemExit)) {
	    sysex = sysexit_status(err);
	    break;
	else if (rb_obj_is_kind_of(err, rb_eSignal)) {
	    VALUE sig = rb_ivar_get(err, id_signo);
	    state = NUM2INT(sig);
	    break;
        else if (rb_obj_is_kind_of(err, rb_eSystemCallError) &&
                 FIXNUM_P(sig = rb_attr_get(err, id_signo))) {
	    state = NUM2INT(sig);
	    break;
	else if (sysex == EXIT_SUCCESS) {
	    sysex = EXIT_FAILURE;
    mjit_finish(true); // We still need ISeqs here.
    rb_ec_finalize(ec);
    /* unlock again if finalizer took mutexes. */
    rb_threadptr_unlock_all_locking_mutexes(th);
    EC_POP_TAG();
    rb_thread_stop_timer_thread();
    ruby_vm_destruct(th->vm);
    if (state) ruby_default_signal(state);
    return sysex;
rb_ec_exec_node(rb_execution_context_t *ec, void *n)
    volatile int state;
    rb_iseq_t *iseq = (rb_iseq_t *)n;
    if (!n) return 0;
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_thread_t *const th = rb_ec_thread_ptr(ec);
	SAVE_ROOT_JMPBUF(th, {
	    rb_iseq_eval_main(iseq);
    EC_POP_TAG();
    return state;
/*! Calls ruby_cleanup() and exits the process */
ruby_stop(int ex)
    exit(ruby_cleanup(ex));
/*! Checks the return value of ruby_options().
 * @param n return value of ruby_options().
 * @param status pointer to the exit status of this process.
 * ruby_options() sometimes returns a special value to indicate this process
 * should immediately exit. This function checks if the case. Also stores the
 * exit status that the caller have to pass to exit(3) into
 * <code>*status</code>.
 * @retval non-zero if the given opaque pointer is actually a compiled source.
 * @retval 0 if the given value is such a special value.
ruby_executable_node(void *n, int *status)
    VALUE v = (VALUE)n;
    switch (v) {
      case Qtrue:  s = EXIT_SUCCESS; break;
      case Qfalse: s = EXIT_FAILURE; break;
      default:
	if (!FIXNUM_P(v)) return TRUE;
	s = FIX2INT(v);
    if (status) *status = s;
    return FALSE;
/*! Runs the given compiled source and exits this process.
 * @retval 0 if successfully run the source
 * @retval non-zero if an error occurred.
ruby_run_node(void *n)
    rb_execution_context_t *ec = GET_EC();
    int status;
    if (!ruby_executable_node(n, &status)) {
        rb_ec_cleanup(ec, 0);
	return status;
    ruby_init_stack((void *)&status);
    return rb_ec_cleanup(ec, rb_ec_exec_node(ec, n));
/*! Runs the given compiled source */
ruby_exec_node(void *n)
    ruby_init_stack((void *)&n);
    return rb_ec_exec_node(GET_EC(), n);
 *  call-seq:
 *     Module.nesting    -> array
 *  Returns the list of +Modules+ nested at the point of call.
 *     module M1
 *       module M2
 *         $a = Module.nesting
 *       end
 *     $a           #=> [M1::M2, M1]
 *     $a[0].name   #=> "M1::M2"
static VALUE
rb_mod_nesting(VALUE _)
    VALUE ary = rb_ary_new();
    const rb_cref_t *cref = rb_vm_cref();
    while (cref && CREF_NEXT(cref)) {
	VALUE klass = CREF_CLASS(cref);
	if (!CREF_PUSHED_BY_EVAL(cref) &&
	    !NIL_P(klass)) {
	    rb_ary_push(ary, klass);
	cref = CREF_NEXT(cref);
    return ary;
 *  call-seq:
 *     Module.constants   -> array
 *     Module.constants(inherited)   -> array
 *  In the first form, returns an array of the names of all
 *  constants accessible from the point of call.
 *  This list includes the names of all modules and classes
 *  defined in the global scope.
 *     Module.constants.first(4)
 *        # => [:ARGF, :ARGV, :ArgumentError, :Array]
 *     Module.constants.include?(:SEEK_SET)   # => false
 *     class IO
 *       Module.constants.include?(:SEEK_SET) # => true
 *  The second form calls the instance method +constants+.
static VALUE
rb_mod_s_constants(int argc, VALUE *argv, VALUE mod)
    const rb_cref_t *cref = rb_vm_cref();
    VALUE klass;
    VALUE cbase = 0;
    void *data = 0;
    if (argc > 0 || mod != rb_cModule) {
	return rb_mod_constants(argc, argv, mod);
    while (cref) {
	klass = CREF_CLASS(cref);
	if (!CREF_PUSHED_BY_EVAL(cref) &&
	    !NIL_P(klass)) {
	    data = rb_mod_const_at(CREF_CLASS(cref), data);
	    if (!cbase) {
		cbase = klass;
	cref = CREF_NEXT(cref);
    if (cbase) {
	data = rb_mod_const_of(cbase, data);
    return rb_const_list(data);
 * Asserts that \a klass is not a frozen class.
 * \param[in] klass a \c Module object
 * \exception RuntimeError if \a klass is not a class or frozen.
 * \ingroup class
rb_class_modify_check(VALUE klass)
    if (SPECIAL_CONST_P(klass)) {
      noclass:
	Check_Type(klass, T_CLASS);
    if (OBJ_FROZEN(klass)) {
	const char *desc;
	if (FL_TEST(klass, FL_SINGLETON)) {
	    desc = "object";
	    klass = rb_ivar_get(klass, id__attached__);
	    if (!SPECIAL_CONST_P(klass)) {
		switch (BUILTIN_TYPE(klass)) {
		  case T_MODULE:
		  case T_ICLASS:
		    desc = "Module";
		    break;
		  case T_CLASS:
		    desc = "Class";
		    break;
                  default:
                    break;
	    switch (BUILTIN_TYPE(klass)) {
	      case T_MODULE:
	      case T_ICLASS:
		desc = "module";
	      case T_CLASS:
		desc = "class";
	      default:
		goto noclass;
        rb_frozen_error_raise(klass, "can't modify frozen %s: %"PRIsVALUE, desc, klass);
NORETURN(static void rb_longjmp(rb_execution_context_t *, int, volatile VALUE, VALUE));
static VALUE get_errinfo(void);
#define get_ec_errinfo(ec) rb_ec_get_errinfo(ec)
static VALUE
exc_setup_cause(VALUE exc, VALUE cause)
#if OPT_SUPPORT_JOKE
    if (NIL_P(cause)) {
	ID id_true_cause;
	CONST_ID(id_true_cause, "true_cause");
	cause = rb_attr_get(rb_eFatal, id_true_cause);
	if (NIL_P(cause)) {
	    cause = rb_exc_new_cstr(rb_eFatal, "because using such Ruby");
	    rb_ivar_set(cause, id_cause, INT2FIX(42)); /* the answer */
	    OBJ_FREEZE(cause);
	    rb_ivar_set(rb_eFatal, id_true_cause, cause);
    if (!NIL_P(cause) && cause != exc) {
	rb_ivar_set(exc, id_cause, cause);
	if (!rb_ivar_defined(cause, id_cause)) {
	    rb_ivar_set(cause, id_cause, Qnil);
    return exc;
static inline VALUE
exc_setup_message(const rb_execution_context_t *ec, VALUE mesg, VALUE *cause)
    int nocause = 0;
    int nocircular = 0;
    if (NIL_P(mesg)) {
	mesg = ec->errinfo;
	if (INTERNAL_EXCEPTION_P(mesg)) EC_JUMP_TAG(ec, TAG_FATAL);
	nocause = 1;
    if (NIL_P(mesg)) {
	mesg = rb_exc_new(rb_eRuntimeError, 0, 0);
	nocause = 0;
        nocircular = 1;
    if (*cause == Qundef) {
	if (nocause) {
	    *cause = Qnil;
            nocircular = 1;
	else if (!rb_ivar_defined(mesg, id_cause)) {
	    *cause = get_ec_errinfo(ec);
        else {
            nocircular = 1;
    else if (!NIL_P(*cause) && !rb_obj_is_kind_of(*cause, rb_eException)) {
        rb_raise(rb_eTypeError, "exception object expected");
    if (!nocircular && !NIL_P(*cause) && *cause != Qundef && *cause != mesg) {
        VALUE c = *cause;
        while (!NIL_P(c = rb_attr_get(c, id_cause))) {
            if (c == mesg) {
                rb_raise(rb_eArgError, "circular causes");
    return mesg;
static void
setup_exception(rb_execution_context_t *ec, int tag, volatile VALUE mesg, VALUE cause)
    VALUE e;
    int line;
    const char *file = rb_source_location_cstr(&line);
    const char *const volatile file0 = file;
    if ((file && !NIL_P(mesg)) || (cause != Qundef))  {
	volatile int state = 0;
	EC_PUSH_TAG(ec);
	if (EC_EXEC_TAG() == TAG_NONE && !(state = rb_ec_set_raised(ec))) {
	    VALUE bt = rb_get_backtrace(mesg);
	    if (!NIL_P(bt) || cause == Qundef) {
		if (OBJ_FROZEN(mesg)) {
		    mesg = rb_obj_dup(mesg);
            if (cause != Qundef && !THROW_DATA_P(cause)) {
		exc_setup_cause(mesg, cause);
	    if (NIL_P(bt)) {
		VALUE at = rb_ec_backtrace_object(ec);
		rb_ivar_set(mesg, idBt_locations, at);
		set_backtrace(mesg, at);
	    rb_ec_reset_raised(ec);
	EC_POP_TAG();
        file = file0;
	if (state) goto fatal;
    if (!NIL_P(mesg)) {
	ec->errinfo = mesg;
    if (RTEST(ruby_debug) && !NIL_P(e = ec->errinfo) &&
	!rb_obj_is_kind_of(e, rb_eSystemExit)) {
	enum ruby_tag_type state;
	EC_PUSH_TAG(ec);
	if ((state = EC_EXEC_TAG()) == TAG_NONE) {
	    ec->errinfo = Qnil;
	    e = rb_obj_as_string(mesg);
	    ec->errinfo = mesg;
	    if (file && line) {
		e = rb_sprintf("Exception `%"PRIsVALUE"' at %s:%d - %"PRIsVALUE"\n",
			       rb_obj_class(mesg), file, line, e);
	    else if (file) {
		e = rb_sprintf("Exception `%"PRIsVALUE"' at %s - %"PRIsVALUE"\n",
			       rb_obj_class(mesg), file, e);
	    else {
		e = rb_sprintf("Exception `%"PRIsVALUE"' - %"PRIsVALUE"\n",
			       rb_obj_class(mesg), e);
	    warn_print_str(e);
	EC_POP_TAG();
	if (state == TAG_FATAL && ec->errinfo == exception_error) {
	    ec->errinfo = mesg;
	else if (state) {
	    rb_ec_reset_raised(ec);
	    EC_JUMP_TAG(ec, state);
    if (rb_ec_set_raised(ec)) {
      fatal:
	ec->errinfo = exception_error;
	rb_ec_reset_raised(ec);
	EC_JUMP_TAG(ec, TAG_FATAL);
    if (tag != TAG_FATAL) {
	RUBY_DTRACE_HOOK(RAISE, rb_obj_classname(ec->errinfo));
	EXEC_EVENT_HOOK(ec, RUBY_EVENT_RAISE, ec->cfp->self, 0, 0, 0, mesg);
/*! \private */
rb_ec_setup_exception(const rb_execution_context_t *ec, VALUE mesg, VALUE cause)
    if (cause == Qundef) {
	cause = get_ec_errinfo(ec);
    if (cause != mesg) {
	rb_ivar_set(mesg, id_cause, cause);
static void
rb_longjmp(rb_execution_context_t *ec, int tag, volatile VALUE mesg, VALUE cause)
    mesg = exc_setup_message(ec, mesg, &cause);
    setup_exception(ec, tag, mesg, cause);
    rb_ec_raised_clear(ec);
    EC_JUMP_TAG(ec, tag);
static VALUE make_exception(int argc, const VALUE *argv, int isstr);
 * Raises an exception in the current thread.
 * \param[in] mesg an Exception class or an \c Exception object.
 * \exception always raises an instance of the given exception class or
 *   the given \c Exception object.
 * \ingroup exception
rb_exc_raise(VALUE mesg)
    if (!NIL_P(mesg)) {
	mesg = make_exception(1, &mesg, FALSE);
    rb_longjmp(GET_EC(), TAG_RAISE, mesg, Qundef);
 * Raises a fatal error in the current thread.
 * Same as rb_exc_raise() but raises a fatal error, which Ruby codes
 * cannot rescue.
 * \ingroup exception
rb_exc_fatal(VALUE mesg)
    if (!NIL_P(mesg)) {
	mesg = make_exception(1, &mesg, FALSE);
    rb_longjmp(GET_EC(), TAG_FATAL, mesg, Qnil);
 * Raises an \c Interrupt exception.
 * \ingroup exception
rb_interrupt(void)
    rb_exc_raise(rb_exc_new(rb_eInterrupt, 0, 0));
enum {raise_opt_cause, raise_max_opt}; /*< \private */
extract_raise_opts(int argc, const VALUE *argv, VALUE *opts)
    if (argc > 0) {
	VALUE opt = argv[argc-1];
	if (RB_TYPE_P(opt, T_HASH)) {
	    if (!RHASH_EMPTY_P(opt)) {
		ID keywords[1];
		CONST_ID(keywords[0], "cause");
		rb_get_kwargs(opt, keywords, 0, -1-raise_max_opt, opts);
		if (RHASH_EMPTY_P(opt)) --argc;
		return argc;
    for (i = 0; i < raise_max_opt; ++i) {
	opts[i] = Qundef;
    return argc;
rb_f_raise(int argc, VALUE *argv)
    VALUE err;
    VALUE opts[raise_max_opt], *const cause = &opts[raise_opt_cause];
    argc = extract_raise_opts(argc, argv, opts);
    if (argc == 0) {
        if (*cause != Qundef) {
            rb_raise(rb_eArgError, "only cause is given with no arguments");
        err = get_errinfo();
        if (!NIL_P(err)) {
            argc = 1;
            argv = &err;
    rb_raise_jump(rb_make_exception(argc, argv), *cause);
    UNREACHABLE_RETURN(Qnil);
 *  call-seq:
 *     raise
 *     raise(string, cause: $!)
 *     raise(exception [, string [, array]], cause: $!)
 *     fail
 *     fail(string, cause: $!)
 *     fail(exception [, string [, array]], cause: $!)
 *  With no arguments, raises the exception in <code>$!</code> or raises
 *  a RuntimeError if <code>$!</code> is +nil+.  With a single +String+
 *  argument, raises a +RuntimeError+ with the string as a message. Otherwise,
 *  the first parameter should be an +Exception+ class (or another
 *  object that returns an +Exception+ object when sent an +exception+
 *  message).  The optional second parameter sets the message associated with
 *  the exception (accessible via Exception#message), and the third parameter
 *  is an array of callback information (accessible via Exception#backtrace).
 *  The +cause+ of the generated exception (accessible via Exception#cause)
 *  is automatically set to the "current" exception (<code>$!</code>), if any.
 *  An alternative value, either an +Exception+ object or +nil+, can be
 *  specified via the +:cause+ argument.
 *  Exceptions are caught by the +rescue+ clause of
 *  <code>begin...end</code> blocks.
 *     raise "Failed to create socket"
 *     raise ArgumentError, "No parameters", caller
static VALUE
f_raise(int c, VALUE *v, VALUE _)
    return rb_f_raise(c, v);
static VALUE
make_exception(int argc, const VALUE *argv, int isstr)
    VALUE mesg, exc;
    mesg = Qnil;
    switch (argc) {
      case 0:
      case 1:
	exc = argv[0];
	if (NIL_P(exc))
	    break;
	if (isstr) {
	    mesg = rb_check_string_type(exc);
	    if (!NIL_P(mesg)) {
		mesg = rb_exc_new3(rb_eRuntimeError, mesg);
	goto exception_call;
      case 2:
      case 3:
	exc = argv[0];
      exception_call:
	mesg = rb_check_funcall(exc, idException, n, argv+1);
	if (mesg == Qundef) {
	    rb_raise(rb_eTypeError, "exception class/object expected");
      default:
        rb_error_arity(argc, 0, 3);
    if (argc > 0) {
	if (!rb_obj_is_kind_of(mesg, rb_eException))
	    rb_raise(rb_eTypeError, "exception object expected");
	if (argc > 2)
	    set_backtrace(mesg, argv[2]);
    return mesg;
 * Make an \c Exception object from the list of arguments in a manner
 * similar to \c Kernel\#raise.
 * \param[in] argc the number of arguments
 * \param[in] argv a pointer to the array of arguments.
 * The first form of this function takes a \c String argument. Then
 * it returns a \c RuntimeError whose error message is the given value.
 * The second from of this function takes an \c Exception object. Then
 * it just returns the given value.
 * The last form takes an exception class, an optional error message and
 * an optional array of backtrace. Then it passes the optional arguments
 * to \c #exception method of the exception class.
 * \return the exception object, or \c Qnil if \c argc is 0.
 * \ingroup exception
rb_make_exception(int argc, const VALUE *argv)
    return make_exception(argc, argv, TRUE);
/*! \private
 * \todo can be static?
rb_raise_jump(VALUE mesg, VALUE cause)
    rb_execution_context_t *ec = GET_EC();
    const rb_control_frame_t *cfp = ec->cfp;
    const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
    VALUE klass = me->owner;
    VALUE self = cfp->self;
    ID mid = me->called_id;
    rb_vm_pop_frame(ec);
    EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, self, me->def->original_id, mid, klass, Qnil);
    rb_longjmp(ec, TAG_RAISE, mesg, cause);
 * Continues the exception caught by rb_protect() and rb_eval_string_protect().
 * This function never return to the caller.
 * \param[in] the value of \c *state which the protect function has set to the
 *   their last parameter.
 * \ingroup exception
rb_jump_tag(int tag)
    if (UNLIKELY(tag < TAG_RETURN || tag > TAG_FATAL)) {
	unknown_longjmp_status(tag);
    EC_JUMP_TAG(GET_EC(), tag);
/*! Determines if the current method is given a block.
 * \retval zero if not given
 * \retval non-zero if given
 * \ingroup defmethod
rb_block_given_p(void)
    if (rb_vm_frame_block_handler(GET_EC()->cfp) == VM_BLOCK_HANDLER_NONE) {
	return FALSE;
	return TRUE;
int rb_vm_cframe_keyword_p(const rb_control_frame_t *cfp);
rb_keyword_given_p(void)
    return rb_vm_cframe_keyword_p(GET_EC()->cfp);
VALUE rb_eThreadError;
/*! Declares that the current method needs a block.
 * Raises a \c LocalJumpError if not given a block.
 * \ingroup defmethod
rb_need_block(void)
    if (!rb_block_given_p()) {
	rb_vm_localjump_error("no block given", Qnil, 0);
/*! An equivalent of \c rescue clause.
 * Equivalent to <code>begin .. rescue err_type .. end</code>
 * \param[in] b_proc a function which potentially raises an exception.
 * \param[in] data1 the argument of \a b_proc
 * \param[in] r_proc a function which rescues an exception in \a b_proc.
 * \param[in] data2 the first argument of \a r_proc
 * \param[in] ... 1 or more exception classes. Must be terminated by \c (VALUE)0.
 * First it calls the function \a b_proc, with \a data1 as the argument.
 * When \a b_proc raises an exception, it calls \a r_proc with \a data2 and
 * the exception object if the exception is a kind of one of the given
 * exception classes.
 * \return the return value of \a b_proc if no exception occurs,
 *   or the return value of \a r_proc if otherwise.
 * \sa rb_rescue
 * \sa rb_ensure
 * \sa rb_protect
 * \ingroup exception
rb_rescue2(VALUE (* b_proc) (VALUE), VALUE data1,
           VALUE (* r_proc) (VALUE, VALUE), VALUE data2, ...)
    va_list ap;
    va_start(ap, data2);
    VALUE ret = rb_vrescue2(b_proc, data1, r_proc, data2, ap);
    va_end(ap);
    return ret;
 * \copydoc rb_rescue2
 * \param[in] args exception classes,
3AAE
 terminated by (VALUE)0.
rb_vrescue2(VALUE (* b_proc) (VALUE), VALUE data1,
            VALUE (* r_proc) (VALUE, VALUE), VALUE data2,
            va_list args)
    enum ruby_tag_type state;
    rb_execution_context_t * volatile ec = GET_EC();
    rb_control_frame_t *volatile cfp = ec->cfp;
    volatile VALUE result = Qfalse;
    volatile VALUE e_info = ec->errinfo;
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
View remainder of file in raw view
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

eval.c

eval.c

Files

eval.c

Latest commit

History

eval.c

File metadata and controls
