C++ NativeMethodEnvironment::get_object方法代码示例

    VALUE rb_string_value(volatile VALUE* object_variable) {
        NativeMethodEnvironment* env = NativeMethodEnvironment::get();

        if(!kind_of<String>(env->get_object(*object_variable))) {
            *object_variable = rb_str_to_str(*object_variable);
        }

        return *object_variable;
    }

  void rb_io_check_closed(rb_io_t* iot) {
    VALUE io_handle = iot->handle;
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();
    IO* io = c_as<IO>(env->get_object(io_handle));

    if(io->descriptor()->to_native() == -1) {
      rb_raise(rb_eIOError, "closed stream");
    }
  }

  VALUE rb_ary_unshift(VALUE self, VALUE object) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Array* array = capi_get_array(env, self);
    array->unshift(env->state(), env->get_object(object));
    capi_update_array(env, self);

    return self;
  }

  VALUE rb_ary_unshift(VALUE self_handle, VALUE object_handle) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Array* self = capi_get_array(env, self_handle);
    self->unshift(env->state(), env->get_object(object_handle));
    capi_update_array(env, self_handle);

    return self_handle;
  }

 void rb_io_check_writable(rb_io_t* iot) {
   VALUE io_handle = iot->handle;
   NativeMethodEnvironment* env = NativeMethodEnvironment::get();
   IO* io = c_as<IO>(env->get_object(io_handle));
   int io_mode = io->mode()->to_native() & O_ACCMODE;
   if(!(O_WRONLY == io_mode || O_RDWR == io_mode)) {
     rb_raise(rb_eIOError, "not opened for writing");
   }
 }

  VALUE rb_ivar_defined(VALUE obj_handle, ID ivar_name) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Symbol* ivar = reinterpret_cast<Symbol*>(ivar_name);
    Object* obj = env->get_object(obj_handle);
    Object* ret = obj->ivar_defined(env->state(), ivar);

    return env->get_handle(ret);
  }

    char* rb_string_value_ptr(volatile VALUE* object_variable) {
        NativeMethodEnvironment* env = NativeMethodEnvironment::get();

        VALUE str = rb_string_value(object_variable);
        // Type check.
        (void)c_as<String>(env->get_object(str));

        return RSTRING_PTR(str);
    }

  void rb_io_check_readable(rb_io_t* iot) {
    VALUE io_handle = iot->handle;
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();
    IO* io = c_as<IO>(env->get_object(io_handle));

    if ((io->mode()->to_native() & O_ACCMODE) != O_RDONLY) {
      rb_raise(rb_eIOError, "not opened for reading");
    }
  }

  void capi_define_method(const char* file, VALUE target,
      const char* name, CApiGenericFunction fptr, int arity, CApiMethodKind kind) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    VM* state = env->state();
    Symbol* method_name = state->symbol(name);

    Module* module = NULL;

    if (kind == cCApiSingletonMethod) {
      module = c_as<Module>(env->get_object(target)->metaclass(env->state()));
    }
    else {
      module = c_as<Module>(env->get_object(target));
    }

    NativeMethod* method = NULL;
    method = NativeMethod::create(state,
                                  String::create(state, file),
                                  module,
                                  method_name,
                                  fptr,
                                  Fixnum::from(arity));

    MethodVisibility* visibility = MethodVisibility::create(state);
    visibility->method(state, method);

    switch(kind) {
    case cCApiPrivateMethod:
      visibility->visibility(state, state->symbol("private"));
      break;

    case cCApiProtectedMethod:
      visibility->visibility(state, state->symbol("protected"));
      break;

    default:  /* Also catches singletons for now. @todo Verify OK. --rue */
      visibility->visibility(state, state->symbol("public"));
      break;
    }

    module->method_table()->store(state, method_name, visibility);
    state->global_cache->clear(module, method_name);
  }

  VALUE rb_file_path_value(volatile VALUE* obj) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();
    STATE = env->state();

    if(!kind_of<String>(env->get_object(*obj))) {
      *obj = rb_funcall(env->get_handle(G(type)), rb_intern("coerce_to_path"), 1, *obj);
    }

    return *obj;
  }

  VALUE rb_call_super(int argc, const VALUE *argv) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Object** args = reinterpret_cast<Object**>(alloca(sizeof(Object*) * argc));
    for(int i = 0; i < argc; i++) {
      args[i] = env->get_object(argv[i]);
    }

    return capi_call_super_native(env, argc, args);
  }

  int rb_big_sign(VALUE obj) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Bignum* big = c_as<Bignum>(env->get_object(obj));

    if (big->mp_val()->sign == MP_NEG) {
      return -1;
    }
    return 1;
  }

  int rb_enc_get_index(VALUE obj) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Object* val = env->get_object(obj);
    Encoding* enc = Encoding::get_object_encoding(env->state(), val);

    if(enc->nil_p()) return 0;

    return Encoding::find_index(env->state(), enc->get_encoding()->name);
  }

  rb_encoding* rb_enc_get(VALUE obj) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Object* val = env->get_object(obj);
    if(!val->reference_p() && !val->symbol_p()) return 0;
    Encoding* enc = Encoding::get_object_encoding(env->state(), val);

    if(enc->nil_p()) return 0;
    return enc->get_encoding();
  }

  VALUE rb_call_super(int argc, const VALUE *argv) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Object* args[argc];
    for(int i = 0; i < argc; i++) {
      args[i] = env->get_object(argv[i]);
    }

    return capi_call_super_native(env, argc, args);
  }