void c_Continuation::t_next() {
  INSTANCE_METHOD_INJECTION_BUILTIN(Continuation, Continuation::next);
  const_assert(!hhvm);
  preNext();
  m_received.setNull();
  nextImpl(fi);
}

void c_Continuation::t_send(CVarRef v) {
  INSTANCE_METHOD_INJECTION_BUILTIN(Continuation, Continuation::send);
  const_assert(!hhvm);
  nextCheck();
  m_received.assignVal(v);
  nextImpl(fi);
}

inline void c_Continuation::nextImpl(FI& fi) {
  const_assert(!hhvm);
  ASSERT(m_running);
  try {
    if (m_isMethod) {
      MethodCallPackage mcp;
      mcp.isObj = m_obj.get();
      if (mcp.isObj) {
        mcp.obj = mcp.rootObj = m_obj.get();
      } else {
        mcp.rootCls = getCalledClass().get();
      }
      fi.setStaticClassName(getCalledClass());
      (m_callInfo->getMeth1Args())(mcp, 1, this);
    } else {
      (m_callInfo->getFunc1Args())(NULL, 1, this);
    }
  } catch (Object e) {
    if (e.instanceof("exception")) {
      m_running = false;
      m_done = true;
      m_value.setNull();
      throw_exception(e);
    } else {
      throw;
    }
  }
  m_running = false;
}

HphpArray* c_GenericContinuation::getStaticLocals() {
  const_assert(hhvm);
  if (m_VMStatics.get() == NULL) {
    m_VMStatics = NEW(HphpArray)(1);
  }

  return m_VMStatics.get();
}

void Debugger::InterruptVMHook(int type /* = BreakPointReached */,
                               CVarRef e /* = null_variant */) {
  const_assert(hhvm);
  InterruptSiteVM site(type == HardBreakPoint, e);
  if (!site.valid()) {
    return;
  }
  Interrupt(type, NULL, &site);
}

bool CmdEval::onServerVM(DebuggerProxy *proxy) {
  const_assert(hhvm);
  VM::PCFilter* locSave = g_vmContext->m_lastLocFilter;
  g_vmContext->m_lastLocFilter = new VM::PCFilter();
  g_vmContext->setDebuggerBypassCheck(m_bypassAccessCheck);
  DebuggerProxyVM::ExecutePHP(m_body, m_output, !proxy->isLocal(), m_frame);
  g_vmContext->setDebuggerBypassCheck(false);
  delete g_vmContext->m_lastLocFilter;
  g_vmContext->m_lastLocFilter = locSave;
  return proxy->send(this);
}

Array CmdVariable::GetLocalVariables(FrameInjection* frame, bool &global) {
  const_assert(!hhvm);
  Array ret;
  if (!frame || FrameInjection::IsGlobalScope(frame)) {
    global = true;
    ret = GetGlobalVariables();
  } else {
    global = false;
  }
  return ret;
}

Object c_WaitHandle::t_getwaithandle() {
  const_assert(false);
}

void c_Continuation::t_raise(CVarRef v) {
  const_assert(false);
}

c_Closure::c_Closure(const ObjectStaticCallbacks *cb) : ExtObjectData(cb) {
  const_assert(!hhvm);
  throw_fatal("Cannot explicitly instantiate and/or subclass Closure");
}

// Functions with native implementation.
void c_Generator::t_next() { const_assert(false); }

ObjectData* SystemLib::AllocPinitSentinel() {
  const_assert(hhvm);
  return HPHP::VM::Instance::newInstance(SystemLib::s_pinitSentinelClass);
}

void c_Continuation::t_raise(const Variant& v) {
  const_assert(false);
}