C++ NativeMethod::module方法代码示例

  Object* run_function(STATE) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Thread* thread = state->vm()->thread();

    NativeMethod* nm = capi::c_as<NativeMethod>(
        thread->variable_get(state, state->symbol("function")));
    Pointer* ptr = capi::c_as<Pointer>(
        thread->variable_get(state, state->symbol("argument")));

    NativeMethodFrame nmf(env, 0, nm);
    CallFrame call_frame;
    call_frame.previous = NULL;
    call_frame.lexical_scope_ = 0;
    call_frame.dispatch_data = (void*)&nmf;
    call_frame.compiled_code = 0;
    call_frame.flags = CallFrame::cNativeMethod;
    call_frame.top_scope_ = 0;
    call_frame.scope = 0;
    call_frame.arguments = 0;

    env->set_current_call_frame(&call_frame);
    env->set_current_native_frame(&nmf);

    state->vm()->set_call_frame(&call_frame);

    nmf.setup(
        env->get_handle(thread),
        env->get_handle(cNil),
        env->get_handle(nm),
        env->get_handle(nm->module()));

    ENTER_CAPI(state);

    Object* value = NULL;

    ExceptionPoint ep(env);

    PLACE_EXCEPTION_POINT(ep);

    if(unlikely(ep.jumped_to())) {
      LEAVE_CAPI(state);

      // Set exception in thread so it's raised when joining.
      state->vm()->thread()->exception(state,
          capi::c_as<Exception>(state->vm()->thread_state()->current_exception()));
    } else {
      value = env->get_object(nm->func()(ptr->pointer));
    }

    LEAVE_CAPI(state);

    env->set_current_call_frame(NULL);
    env->set_current_native_frame(NULL);
    ep.pop(env);

    return value;
  }

  NativeMethod* NativeMethod::create(State* state, String* file_name,
                                     Module* module, Symbol* method_name,
                                     void* func, Fixnum* arity)
  {
    NativeMethod* nmethod = state->new_object<NativeMethod>(G(nmethod));

    nmethod->arity(state, arity);
    nmethod->file(state, file_name);
    nmethod->name(state, method_name);
    nmethod->module(state, module);

    nmethod->func_ = func;

    switch(arity->to_native()) {
    case 0:
      nmethod->set_executor(&NativeMethod::executor_implementation<ZeroArguments>);
      break;

    case 1:
      nmethod->set_executor(&NativeMethod::executor_implementation<OneArgument>);
      break;

    case 2:
      nmethod->set_executor(&NativeMethod::executor_implementation<TwoArguments>);
      break;

    case 3:
      nmethod->set_executor(&NativeMethod::executor_implementation<ThreeArguments>);
      break;

    default:
      nmethod->set_executor(&NativeMethod::executor_implementation<GenericArguments>);
      break;
    }

    nmethod->primitive(state, state->symbol("nativemethod_call"));
    nmethod->serial(state, Fixnum::from(0));
    nmethod->inliners_ = 0;

    return nmethod;
  }

      static NativeMethod* create(VM* state,
                                  String* file_name = as<String>(Qnil),
                                  Module* module = as<Module>(Qnil),
                                  Symbol* method_name = as<Symbol>(Qnil),
                                  FunctorType functor = static_cast<GenericFunctor>(NULL),
                                  Fixnum* arity = as<Fixnum>(Qnil))
      {
        NativeMethod* nmethod = state->new_object<NativeMethod>(G(nmethod));

        nmethod->arity(state, arity);
        nmethod->file_name(state, file_name);
        nmethod->method_name(state, method_name);
        nmethod->module(state, module);

        nmethod->functor(state, MemoryPointer::create(state, reinterpret_cast<void*>(functor)));

        nmethod->set_executor(&NativeMethod::executor_implementation);

        nmethod->primitive(state, state->symbol("nativemethod_call"));
        nmethod->serial(state, Fixnum::from(0));

        return nmethod;
      }

  Object* run_function(STATE) {
    NativeMethodEnvironment* env = NativeMethodEnvironment::get();

    Thread* self = state->vm()->thread.get();

    NativeMethod* nm = capi::c_as<NativeMethod>(self->locals_aref(state, state->symbol("function")));
    Pointer* ptr = capi::c_as<Pointer>(self->locals_aref(state, state->symbol("argument")));

    self->locals_remove(state, state->symbol("function"));
    self->locals_remove(state, state->symbol("argument"));

    GCTokenImpl gct;

    NativeMethodFrame nmf(env, 0, nm);
    CallFrame cf;
    cf.previous = 0;
    cf.constant_scope_ = 0;
    cf.dispatch_data = (void*)&nmf;
    cf.compiled_code = 0;
    cf.flags = CallFrame::cNativeMethod;
    cf.optional_jit_data = 0;
    cf.top_scope_ = 0;
    cf.scope = 0;
    cf.arguments = 0;

    CallFrame* saved_frame = env->current_call_frame();
    env->set_current_call_frame(&cf);
    env->set_current_native_frame(&nmf);

    nmf.setup(
        env->get_handle(self),
        env->get_handle(cNil),
        env->get_handle(nm),
        env->get_handle(nm->module()));

    {
      OnStack<3> os(state, self, nm, ptr);
      self->hard_unlock(state, gct, &cf);
    }

    ENTER_CAPI(state);

    Object* ret = NULL;

    ExceptionPoint ep(env);

    PLACE_EXCEPTION_POINT(ep);

    if(unlikely(ep.jumped_to())) {
      // Setup exception in thread so it's raised when joining
      // Reload self because it might have been moved
      self = state->vm()->thread.get();
      CallFrame* call_frame = env->current_call_frame();

      {
        OnStack<1> os(state, self);
        self->hard_lock(state, gct, call_frame, false);
        Exception* exc = capi::c_as<Exception>(self->current_exception(state));
        self->exception(state, exc);
        self->alive(state, cFalse);
        self->hard_unlock(state, gct, call_frame);
      }
      return NULL;
    } else {
      ret = env->get_object(nm->func()(ptr->pointer));
    }

    LEAVE_CAPI(state);

    env->set_current_call_frame(saved_frame);
    env->set_current_native_frame(nmf.previous());
    ep.pop(env);

    self = state->vm()->thread.get();

    OnStack<1> os(state, self);

    self->hard_lock(state, gct, &cf, false);
    self->alive(state, cFalse);
    self->hard_unlock(state, gct, &cf);

    return ret;
  }