自学教程：C++ uninit_null函数代码示例

Variant SSATmp::getValVariant() const {  switch (type().toDataType()) {  case KindOfUninit:    return uninit_null();  case KindOfNull:    return init_null();  case KindOfBoolean:    return getValBool();  case KindOfInt64:    return getValInt();  case KindOfDouble:    return getValDbl();  case KindOfString:  case KindOfStaticString:    return Variant(getValStr());  case KindOfArray:    return const_cast<ArrayData*>(getValArr());  default:    always_assert(false);  }}

Variant f_parse_url(const String& url, int component /* = -1 */) {  Url resource;  if (!url_parse(resource, url.data(), url.size())) {    return false;  }  if (component > -1) {    switch (component) {    case k_PHP_URL_SCHEME:   RETURN_COMPONENT(scheme);   break;    case k_PHP_URL_HOST:     RETURN_COMPONENT(host);     break;    case k_PHP_URL_USER:     RETURN_COMPONENT(user);     break;    case k_PHP_URL_PASS:     RETURN_COMPONENT(pass);     break;    case k_PHP_URL_PATH:     RETURN_COMPONENT(path);     break;    case k_PHP_URL_QUERY:    RETURN_COMPONENT(query);    break;    case k_PHP_URL_FRAGMENT: RETURN_COMPONENT(fragment); break;    case k_PHP_URL_PORT:      if (resource.port) {        return resource.port;      }      break;    default:      throw_invalid_argument("component: %d", component);      return false;    }    return uninit_null();  }  ArrayInit ret(8);  SET_COMPONENT(scheme);  SET_COMPONENT(host);  if (resource.port) {    ret.set(s_port, (int64_t)resource.port);  }  SET_COMPONENT(user);  SET_COMPONENT(pass);  SET_COMPONENT(path);  SET_COMPONENT(query);  SET_COMPONENT(fragment);  return ret.create();}

static Variant xml_call_handler(XmlParser *parser, CVarRef handler,                                CArrRef args) {  if (parser && handler) {    Variant retval;    if (handler.isString()) {      if (!parser->object.isObject()) {        retval = invoke(handler.toString().c_str(), args, -1);      } else {        retval = parser->object.toObject()->          o_invoke(handler.toString(), args);      }    } else if (handler.isArray() && handler.getArrayData()->size() == 2 &&               (handler[0].isString() || handler[0].isObject()) &&               handler[1].isString()) {      vm_call_user_func(handler, args);    } else {      raise_warning("Handler is invalid");    }    return retval;  }  return uninit_null();}

TypedValue* fg_php_check_syntax(ActRec* ar) {  TypedValue rvSpace;  TypedValue* rv = &rvSpace;  int32_t count = ar->numArgs();  TypedValue* args UNUSED = ((TypedValue*)ar) - 1;  if (count >= 1 && count <= 2) {    if (IS_STRING_TYPE((args - 0)->m_type)) {      rv->m_type = KindOfBoolean;      VRefParamValue defVal1 = uninit_null();      rv->m_data.num = (fh_php_check_syntax(&args[-0].m_data, (count > 1) ? (args-1) : (TypedValue*)(&defVal1))) ? 1LL : 0LL;    } else {      fg1_php_check_syntax(rv, ar, count);    }  } else {    throw_wrong_arguments_nr("php_check_syntax", count, 1, 2, 1);    rv->m_data.num = 0LL;    rv->m_type = KindOfNull;  }  frame_free_locals_no_this_inl(ar, 2);  memcpy(&ar->m_r, rv, sizeof(TypedValue));  return &ar->m_r;}

Variant f_socket_recv(CObjRef socket, VRefParam buf, int len, int flags) {  if (len <= 0) {    return false;  }  Socket *sock = socket.getTyped<Socket>();  char *recv_buf = (char *)malloc(len + 1);  int retval;  if ((retval = recv(sock->fd(), recv_buf, len, flags)) < 1) {    free(recv_buf);    buf = uninit_null();  } else {    recv_buf[retval] = '/0';    buf = String(recv_buf, retval, AttachString);  }  if (retval == -1) {    SOCKET_ERROR(sock, "unable to read from socket", errno);    return false;  }  return retval;}

TypedValue* fg_is_callable(ActRec* ar) {  TypedValue rvSpace;  TypedValue* rv = &rvSpace;  int32_t count = ar->numArgs();  TypedValue* args UNUSED = ((TypedValue*)ar) - 1;  if (count >= 1 && count <= 3) {    if ((count <= 1 || (args - 1)->m_type == KindOfBoolean)) {      rv->m_type = KindOfBoolean;      VRefParamValue defVal2 = uninit_null();      rv->m_data.num = (fh_is_callable((args-0), (count > 1) ? (bool)(args[-1].m_data.num) : (bool)(false), (count > 2) ? (args-2) : (TypedValue*)(&defVal2))) ? 1LL : 0LL;    } else {      fg1_is_callable(rv, ar, count);    }  } else {    throw_wrong_arguments_nr("is_callable", count, 1, 3, 1);    rv->m_data.num = 0LL;    rv->m_type = KindOfNull;  }  frame_free_locals_no_this_inl(ar, 3);  memcpy(&ar->m_r, rv, sizeof(TypedValue));  return &ar->m_r;}

Variant f_array_map(int _argc, CVarRef callback, CVarRef arr1, CArrRef _argv /* = null_array */) {  Array inputs;  if (!arr1.isArray()) {    throw_bad_array_exception();    return uninit_null();  }  inputs.append(arr1);  if (!_argv.empty()) {    inputs = inputs.merge(_argv);  }  HPHP::VM::CallCtx ctx;  ctx.func = NULL;  if (!callback.isNull()) {    CallerFrame cf;    ctx.func = vm_decode_function(callback, cf(), false, ctx.this_, ctx.cls,                                  ctx.invName);  }  if (ctx.func == NULL) {    return ArrayUtil::Map(inputs, map_func, NULL);  }  return ArrayUtil::Map(inputs, map_func, &ctx);}

bool TestExtMemcached::test_Memcached_types() {  Array list;  list.add(s_boolean_true, true);  list.add(s_boolean_false, false);  list.add(s_string, "just a string");  list.add(s_string_empty, empty_string);  list.add(s_integer_positive_integer, 10);  list.add(s_integer_negative_integer, -10);  list.add(s_integer_zero_integer, 0);  list.add(s_float_positive1, 3.912131);  list.add(s_float_positive2, 1.2131E+52);  list.add(s_float_negative, -42.123312);  list.add(s_float_zero, 0.0);  list.add(s_null, uninit_null());  list.add(s_array_empty, Array());  list.add(s_array, CREATE_VECTOR4(1, 2, 3, "foo"));  CREATE_MEMCACHED();  for (ArrayIter iter(list); iter; ++iter) {    VERIFY(memc->t_set(iter.first(), iter.second(), EXPIRATION));    VS(memc->t_get(iter.first()), iter.second());  }  for (ArrayIter iter(list); iter; ++iter) {    VERIFY(memc->t_delete(iter.first()));  }  VERIFY(memc->t_setmulti(list, EXPIRATION));  Variant res = memc->t_getmulti(list.keys());  VERIFY(res.isArray());  Array resArray = res.toArray();  VERIFY(resArray->size() == list.size());  for (ArrayIter iter(resArray); iter; ++iter) {    VS(iter.second(), list[iter.first()]);  }  return Count(true);}

Variant f_array_keys(CVarRef input, CVarRef search_value /* = null_variant */,                     bool strict /* = false */) {  const auto& cell_input = *input.asCell();  if (UNLIKELY(!isContainer(cell_input))) {    goto warn;  }  {    // We treat Sets differently. For Sets, we pretend the values are    // also the keys (similar to how Set::toArray() behaves).    bool isSetType =      cell_input.m_type == KindOfObject &&      cell_input.m_data.pobj->getCollectionType() == Collection::SetType;    if (UNLIKELY(isSetType)) {      return arrayKeysSetHelper(cell_input, search_value, strict);    }    ArrayIter iter(cell_input);    if (LIKELY(!search_value.isInitialized())) {      PackedArrayInit ai(getContainerSize(cell_input));      for (; iter; ++iter) {        ai.append(iter.first());      }      return ai.toArray();    }    Array ai = Array::attach(HphpArray::MakeReserve(0));    for (; iter; ++iter) {      if ((strict && HPHP::same(iter.secondRefPlus(), search_value)) ||          (!strict && HPHP::equal(iter.secondRefPlus(), search_value))) {        ai.append(iter.first());      }    }    return ai;  }warn:  raise_warning("array_keys() expects parameter 1 to be an array "                "or collection");  return uninit_null();}

TypedValue * fg1_apc_dec(TypedValue* rv, HPHP::VM::ActRec* ar, int64_t count) {  TypedValue* args UNUSED = ((TypedValue*)ar) - 1;  switch (count) {  default: // count >= 4    if ((args-3)->m_type != KindOfInt64) {      tvCastToInt64InPlace(args-3);    }  case 3:  case 2:    if ((args-1)->m_type != KindOfInt64) {      tvCastToInt64InPlace(args-1);    }  case 1:    break;  }  if (!IS_STRING_TYPE((args-0)->m_type)) {    tvCastToStringInPlace(args-0);  }  VRefParamValue defVal2 = uninit_null();  fh_apc_dec((rv), (Value*)(args-0), (count > 1) ? (long)(args[-1].m_data.num) : (long)(1), (count > 2) ? (args-2) : (TypedValue*)(&defVal2), (count > 3) ? (long)(args[-3].m_data.num) : (long)(0));  if (rv->m_type == KindOfUninit) rv->m_type = KindOfNull;  return rv;}

bool TestExtOpenssl::test_openssl_seal() {  Variant privkey = f_openssl_pkey_new();  VERIFY(!privkey.isNull());  Variant csr = f_openssl_csr_new(uninit_null(), privkey);  VERIFY(!csr.isNull());  Variant pubkey = f_openssl_csr_get_public_key(csr);  VERIFY(!pubkey.isNull());  String data = "some secret messages";  Variant sealed;  Variant ekeys;  VERIFY(f_openssl_seal(data, ref(sealed), ref(ekeys),                        CREATE_VECTOR1(pubkey)));  VERIFY(!sealed.toString().empty());  VS(ekeys.toArray().size(), 1);  VERIFY(!ekeys[0].toString().empty());  Variant open_data;  VERIFY(f_openssl_open(sealed, ref(open_data), ekeys[0], privkey));  VS(open_data, data);  return Count(true);}

TypedValue* fg_xml_parse_into_struct(ActRec* ar) {  TypedValue rvSpace;  TypedValue* rv = &rvSpace;  int32_t count = ar->numArgs();  TypedValue* args UNUSED = ((TypedValue*)ar) - 1;  if (count >= 3 && count <= 4) {    if (IS_STRING_TYPE((args - 1)->m_type) &&        (args - 0)->m_type == KindOfObject) {      rv->m_type = KindOfInt64;      VRefParamValue defVal3 = uninit_null();      rv->m_data.num = (int64_t)fh_xml_parse_into_struct(&args[-0].m_data, &args[-1].m_data, (args-2), (count > 3) ? (args-3) : (TypedValue*)(&defVal3));    } else {      fg1_xml_parse_into_struct(rv, ar, count);    }  } else {    throw_wrong_arguments_nr("xml_parse_into_struct", count, 3, 4, 1);    rv->m_data.num = 0LL;    rv->m_type = KindOfNull;  }  frame_free_locals_no_this_inl(ar, 4);  memcpy(&ar->m_r, rv, sizeof(TypedValue));  return &ar->m_r;}

Variant HHVM_FUNCTION(php_uname, const String& mode /*="" */) {  struct utsname buf;  if (uname((struct utsname *)&buf) == -1) {    return uninit_null();  }  if (mode == s_s) {    return String(buf.sysname, CopyString);  } else if (mode == s_r) {    return String(buf.release, CopyString);  } else if (mode == s_n) {    return String(buf.nodename, CopyString);  } else if (mode == s_v) {    return String(buf.version, CopyString);  } else if (mode == s_m) {    return String(buf.machine, CopyString);  } else { /* assume mode == "a" */    char tmp_uname[512];    snprintf(tmp_uname, sizeof(tmp_uname), "%s %s %s %s %s",             buf.sysname, buf.nodename, buf.release, buf.version,             buf.machine);    return String(tmp_uname, CopyString);  }}

ArrayData* PackedArray::Pop(ArrayData* adIn, Variant& value) {  assert(checkInvariants(adIn));  auto const ad = adIn->hasMultipleRefs() ? Copy(adIn) : adIn;  if (UNLIKELY(ad->m_size == 0)) {    value = uninit_null();    ad->m_pos = ArrayData::invalid_index;    return ad;  }  auto const oldSize = ad->m_size;  auto& tv = packedData(ad)[oldSize - 1];  value = tvAsCVarRef(&tv);  if (UNLIKELY(strong_iterators_exist())) {    adjustMArrayIter(ad, oldSize - 1);  }  auto const oldType = tv.m_type;  auto const oldDatum = tv.m_data.num;  ad->m_size = oldSize - 1;  ad->m_pos = oldSize - 1 > 0 ? 0 : ArrayData::invalid_index;  tvRefcountedDecRefHelper(oldType, oldDatum);  return ad;}

Variant f_array_column(CVarRef input, CVarRef val_key,                       CVarRef idx_key /* = null_variant */) {  /* Be strict about array type */  getCheckedArrayRet(input, uninit_null());  Variant val = val_key, idx = idx_key;  if (!array_column_coerce_key(val, "column") ||      !array_column_coerce_key(idx, "index")) {    return false;  }  Array ret = Array::Create();  for(auto it = arr_input.begin(); !it.end(); it.next()) {    if (!it.second().isArray()) {      continue;    }    Array sub = it.second().toArray();    Variant elem;    if (val.isNull()) {      elem = sub;    } else if (sub.exists(val)) {      elem = sub[val];    } else {      // skip subarray without named element      continue;    }    if (idx.isNull() || !sub.exists(idx)) {      ret.append(elem);    } else if (sub[idx].isObject()) {      ret.set(sub[idx].toString(), elem);    } else {      ret.set(sub[idx], elem);    }  }  return ret;}

void DummySandbox::run() {  TRACE(2, "DummySandbox::run/n");  RequestInfo *ti = RequestInfo::s_requestInfo.getNoCheck();  while (!m_stopped) {    try {      CLISession hphpSession;      DSandboxInfo sandbox = m_proxy->getSandbox();      std::string msg;      if (sandbox.valid()) {        SourceRootInfo sri(sandbox.m_user, sandbox.m_name);        if (sandbox.m_path.empty()) {          sandbox.m_path = sri.path();        }        if (!sri.sandboxOn()) {          msg = "Invalid sandbox was specified. "            "PHP files may not be loaded properly./n";        } else {          auto server = php_global_exchange(s__SERVER, init_null());          forceToArray(server);          Array arr = server.toArrRef();          server.unset();          php_global_set(s__SERVER, sri.setServerVariables(std::move(arr)));        }        Debugger::RegisterSandbox(sandbox);        g_context->setSandboxId(sandbox.id());        std::string doc = getStartupDoc(sandbox);        if (!doc.empty()) {          char cwd[PATH_MAX];          getcwd(cwd, sizeof(cwd));          Logger::Info("Start loading startup doc '%s', pwd = '%s'",                       doc.c_str(), cwd);          bool error; std::string errorMsg;          bool ret = hphp_invoke(g_context.getNoCheck(), doc, false, null_array,                                 uninit_null(), "", "", error, errorMsg, true,                                 false, true, RuntimeOption::EvalPreludePath);          if (!ret || error) {            msg += "Unable to pre-load " + doc;            if (!errorMsg.empty()) {              msg += ": " + errorMsg;            }          }          Logger::Info("Startup doc " + doc + " loaded");        }      } else {        g_context->setSandboxId(m_proxy->getDummyInfo().id());      }      if (!DebuggerHook::attach<HphpdHook>(ti)) {        const char* fail = "Could not attach hphpd to request: another debugger"                           " is already attached.";        Logger::Error("%s", fail);        Debugger::InterruptSessionStarted(nullptr, fail);        throw DebuggerClientAttachFailureException();      }      {        DebuggerDummyEnv dde;        // This is really the entire point of having the dummy sandbox. This        // fires the initial session started interrupt to the client after        // it first attaches.        Debugger::InterruptSessionStarted(nullptr, msg.c_str());      }      // Blocking until Ctrl-C is issued by end user and DebuggerProxy cannot      // find a real sandbox thread to handle it.      {        Lock lock(this);        while (!m_stopped && m_signum != CmdSignal::SignalBreak) {          wait(1);        }        if (m_stopped) {          // stopped by worker thread          break;        }        m_signum = CmdSignal::SignalNone;      }    } catch (const DebuggerClientExitException& e) {      // stopped by the dummy sandbox thread itself      break;    } catch (const DebuggerException& e) {    }  }}

Variant throw_fatal_unset_static_property(const char *s, const char *prop) {  raise_error("Attempt to unset static property %s::$%s", s, prop);  return uninit_null();}

bool TestExtJson::test_json_decode() {  Array arr = CREATE_MAP1("fbid", 101501853510151001LL);  VS(f_json_decode(f_json_encode(arr), true), arr);  VS(f_json_decode("{/"0/":{/"00/":0}}", true),     CREATE_MAP1("0", CREATE_MAP1("00", 0)));  VS(f_json_decode("{/"a/":1,/"b/":2.3,/"3/":/"test/"}", true),     CREATE_MAP3("a", 1, "b", 2.3, 3, "test"));  VS(f_json_decode("[/"a/",1,true,false,null]", true),     CREATE_VECTOR5("a", 1, true, false, uninit_null()));  Object obj = f_json_decode("{/"a/":1,/"b/":2.3,/"3/":/"test/"}");  Object obj2(SystemLib::AllocStdClassObject());  obj2->o_set("a", 1);  obj2->o_set("b", 2.3);  obj2->o_set("3", "test");  VS(obj.toArray(), obj2.toArray());  obj = f_json_decode("[/"a/",1,true,false,null]");  VS(obj.toArray(), CREATE_VECTOR5("a", 1, true, false, uninit_null()));  VS(f_json_decode("{z:1}",     true),       uninit_null());  VS(f_json_decode("{z:1}",     true, k_JSON_FB_LOOSE), CREATE_MAP1("z", 1));  VS(f_json_decode("{z:/"z/"}", true),       uninit_null());  VS(f_json_decode("{z:/"z/"}", true, k_JSON_FB_LOOSE), CREATE_MAP1("z", "z"));  VS(f_json_decode("{'x':1}",   true),       uninit_null());  VS(f_json_decode("{'x':1}",   true, k_JSON_FB_LOOSE), CREATE_MAP1("x", 1));  VS(f_json_decode("{y:1,}",    true),       uninit_null());  VS(f_json_decode("{y:1,}",    true, k_JSON_FB_LOOSE), CREATE_MAP1("y", 1));  VS(f_json_decode("{,}",       true),       uninit_null());  VS(f_json_decode("{,}",       true, k_JSON_FB_LOOSE), uninit_null());  VS(f_json_decode("[1,2,3,]",  true),       uninit_null());  VS(f_json_decode("[1,2,3,]",  true, k_JSON_FB_LOOSE), CREATE_VECTOR3(1,2,3));  VS(f_json_decode("[,]",       true),       uninit_null());  VS(f_json_decode("[,]",       true, k_JSON_FB_LOOSE), uninit_null());  VS(f_json_decode("[]",        true),       Array::Create());  VS(f_json_decode("[]",        true, k_JSON_FB_LOOSE), Array::Create());  VS(f_json_decode("{}",        true),       Array::Create());  VS(f_json_decode("{}",        true, k_JSON_FB_LOOSE), Array::Create());  VS(f_json_decode("[{/"a/":/"apple/"},{/"b/":/"banana/"}]", true),     CREATE_VECTOR2(CREATE_MAP1("a", "apple"), CREATE_MAP1("b", "banana")));  Variant a = "[{/"a/":[{/"n/":/"1st/"}]},{/"b/":[{/"n/":/"2nd/"}]}]";  VS(f_json_decode(a, true),     CREATE_VECTOR2     (CREATE_MAP1("a", CREATE_VECTOR1(CREATE_MAP1("n", "1st"))),      CREATE_MAP1("b", CREATE_VECTOR1(CREATE_MAP1("n", "2nd")))));  return Count(true);}

void DummySandbox::run() {  TRACE(2, "DummySandbox::run/n");  ThreadInfo *ti = ThreadInfo::s_threadInfo.getNoCheck();  Debugger::RegisterThread();  while (!m_stopped) {    try {      CLISession hphpSession;      DSandboxInfo sandbox = m_proxy->getSandbox();      string msg;      if (sandbox.valid()) {        GlobalVariables *g = get_global_variables();        SourceRootInfo sri(sandbox.m_user, sandbox.m_name);        if (sandbox.m_path.empty()) {          sandbox.m_path = sri.path();        }        if (!sri.sandboxOn()) {          msg = "Invalid sandbox was specified. "            "PHP files may not be loaded properly./n";        } else {          sri.setServerVariables(g->getRef(s__SERVER));        }        Debugger::RegisterSandbox(sandbox);        g_context->setSandboxId(sandbox.id());        std::string doc = getStartupDoc(sandbox);        if (!doc.empty()) {          char cwd[PATH_MAX];          getcwd(cwd, sizeof(cwd));          Logger::Info("Start loading startup doc '%s', pwd = '%s'",                       doc.c_str(), cwd);          bool error; string errorMsg;          bool ret = hphp_invoke(g_context.getNoCheck(), doc, false, null_array,                                 uninit_null(), "", "", error, errorMsg, true,                                 false, true);          if (!ret || error) {            msg += "Unable to pre-load " + doc;            if (!errorMsg.empty()) {              msg += ": " + errorMsg;            }          }          Logger::Info("Startup doc " + doc + " loaded");        }      } else {        g_context->setSandboxId(m_proxy->getDummyInfo().id());      }      ti->m_reqInjectionData.setDebugger(true);      {        DebuggerDummyEnv dde;        // This is really the entire point of having the dummy sandbox. This        // fires the initial session started interrupt to the client after        // it first attaches.        Debugger::InterruptSessionStarted(nullptr, msg.c_str());      }      // Blocking until Ctrl-C is issued by end user and DebuggerProxy cannot      // find a real sandbox thread to handle it.      {        Lock lock(this);        while (!m_stopped && m_signum != CmdSignal::SignalBreak) {          wait(1);        }        if (m_stopped) {          // stopped by worker thread          break;        }        m_signum = CmdSignal::SignalNone;      }    } catch (const DebuggerClientExitException &e) {      // stopped by the dummy sandbox thread itself      break;    } catch (const DebuggerException &e) {    }  }}

Variant MySQLResult::getField(int64_t field) const {  if (!m_localized || field < 0 || field >= (int64_t)m_current_row->size()) {    return uninit_null();  }  return (*m_current_row)[field];}

bool RPCRequestHandler::executePHPFunction(Transport *transport,                                           SourceRootInfo &sourceRootInfo) {  // reset timeout counter  ThreadInfo::s_threadInfo->m_reqInjectionData.started = time(0);  string rpcFunc = transport->getCommand();  {    ServerStatsHelper ssh("input");    RequestURI reqURI(rpcFunc);    HttpProtocol::PrepareSystemVariables(transport, reqURI, sourceRootInfo);    SystemGlobals *g = (SystemGlobals*)get_global_variables();    g->GV(_ENV).set(s_HPHP_RPC, 1);  }  bool isFile = rpcFunc.rfind('.') != string::npos;  string rpcFile;  bool error = false;  Array params;  string sparams = transport->getParam("params");  if (!sparams.empty()) {    Variant jparams = f_json_decode(String(sparams), true);    if (jparams.isArray()) {      params = jparams.toArray();    } else {      error = true;    }  } else {    vector<string> sparams;    transport->getArrayParam("p", sparams);    if (!sparams.empty()) {      for (unsigned int i = 0; i < sparams.size(); i++) {        Variant jparams = f_json_decode(String(sparams[i]), true);        if (same(jparams, false)) {          error = true;          break;        }        params.append(jparams);      }    } else {      // single string parameter, used by xbox to avoid any en/decoding      int size;      const void *data = transport->getPostData(size);      if (data && size) {        params.append(String((char*)data, size, AttachLiteral));      }    }  }  if (transport->getIntParam("reset") == 1) {    m_reset = true;  }  int output = transport->getIntParam("output");  int code;  if (!error) {    Variant funcRet;    string errorMsg = "Internal Server Error";    string reqInitFunc, reqInitDoc;    reqInitDoc = transport->getHeader("ReqInitDoc");    if (reqInitDoc.empty() && m_serverInfo) {      reqInitFunc = m_serverInfo->getReqInitFunc();      reqInitDoc = m_serverInfo->getReqInitDoc();    }    if (!reqInitDoc.empty()) {      reqInitDoc = (std::string)canonicalize_path(reqInitDoc, "", 0);    }    if (!reqInitDoc.empty()) {      reqInitDoc = getSourceFilename(reqInitDoc, sourceRootInfo);    }    bool runOnce = false;    bool ret = true;    if (isFile) {      rpcFile = rpcFunc;      rpcFunc.clear();    } else {      rpcFile = transport->getParam("include");      if (rpcFile.empty()) {        rpcFile = transport->getParam("include_once");        runOnce = true;      }    }    if (!rpcFile.empty()) {      // invoking a file through rpc      bool forbidden = false;      if (!RuntimeOption::ForbiddenFileExtensions.empty()) {        const char *ext = rpcFile.c_str() + rpcFile.rfind('.') + 1;        if (RuntimeOption::ForbiddenFileExtensions.find(ext) !=            RuntimeOption::ForbiddenFileExtensions.end()) {          forbidden = true;        }      }      if (!forbidden) {        rpcFile = (std::string) canonicalize_path(rpcFile, "", 0);        rpcFile = getSourceFilename(rpcFile, sourceRootInfo);        ret = hphp_invoke(m_context, rpcFile, false, Array(), uninit_null(),                          reqInitFunc, reqInitDoc, error, errorMsg, runOnce);      }//.........这里部分代码省略.........

Variant& lvalBlackHole() {  auto& bh = get_env_constants()->lvalProxy;  bh = uninit_null();  return bh;}

static void json_create_zval(Variant &z, StringBuffer &buf, int type,                             int64_t options) {  switch (type) {    case KindOfBoolean:      z = (buf.data() && (*buf.data() == 't'));      return;    case KindOfInt64: {      bool bigint = false;      const char *p = buf.data();      assert(p);      if (p == NULL) {        z = int64_t(0);        return;      }      bool neg = *buf.data() == '-';      int len = buf.size();      if (neg) len--;      if (len >= MAX_LENGTH_OF_LONG - 1) {        if (len == MAX_LENGTH_OF_LONG - 1) {          int cmp = strcmp(p + (neg ? 1 : 0), long_min_digits);          if (!(cmp < 0 || (cmp == 0 && neg))) {            bigint = true;          }        } else {          bigint = true;        }      }      if (bigint) {        if (!(options & k_JSON_BIGINT_AS_STRING)) {          // See KindOfDouble (below)          z = to_double(buf);        } else {          z = copy_and_clear(buf);        }      } else {        z = int64_t(strtoll(buf.data(), nullptr, 10));      }      return;    }    case KindOfDouble:      // Use zend_strtod() instead of strtod() here since JSON specifies using      // a '.' for decimal separators regardless of locale.      z = to_double(buf);      return;    case KindOfString:      z = copy_and_clear(buf);      return;    case KindOfUninit:    case KindOfNull:    case KindOfStaticString:    case KindOfArray:    case KindOfObject:    case KindOfResource:    case KindOfRef:      z = uninit_null();      return;    case KindOfClass:      break;  }  not_reached();}

Variant c_XMLReader::t___destruct() {  return uninit_null();}

static Variant warn_non_object() {  raise_notice("Cannot access property on non-object");  return uninit_null();}

Variant f_json_decode(const String& json, bool assoc /* = false */,                      CVarRef options /* = 0 */) {  json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);  if (json.empty()) {    return uninit_null();  }  int64_t json_options = options.toInt64();  if (options.isBoolean() && options.toBooleanVal()) {    json_options = k_JSON_FB_LOOSE;  }  const int64_t supported_options =    k_JSON_FB_LOOSE | k_JSON_FB_COLLECTIONS | k_JSON_FB_STABLE_MAPS;  int64_t parser_options = json_options & supported_options;  Variant z;  if (JSON_parser(z, json.data(), json.size(), assoc, parser_options)) {    return z;  }  if (json.size() == 4) {    if (!strcasecmp(json.data(), "null")) {      json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);      return uninit_null();    }    if (!strcasecmp(json.data(), "true")) {      json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);      return true;    }  } else if (json.size() == 5 && !strcasecmp(json.data(), "false")) {    json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);    return false;  }  int64_t p;  double d;  DataType type = json->isNumericWithVal(p, d, 0);  if (type == KindOfInt64) {    json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);    return p;  } else if (type == KindOfDouble) {    json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);    return d;  }  char ch0 = json.charAt(0);  if (json.size() > 1 && ch0 == '"' && json.charAt(json.size() - 1) == '"') {    json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);    // Wrap the string in an array to allow the JSON_parser to handle    // things like unicode escape sequences, then unwrap to get result    String wrapped("[");    wrapped += json + "]";    // Stick to a normal hhvm array for the wrapper    const int64_t mask = ~(k_JSON_FB_COLLECTIONS | k_JSON_FB_STABLE_MAPS);    if (JSON_parser(z, wrapped.data(), wrapped.size(), false,                    parser_options & mask) && z.isArray()) {      Array arr = z.toArray();      if ((arr.size() == 1) && arr.exists(0)) {        return arr[0];      }      // The input string could be something like: "foo","bar"      // Which will parse inside the [] wrapper, but be invalid      json_set_last_error_code(json_error_codes::JSON_ERROR_SYNTAX);    }  }  if ((json_options & k_JSON_FB_LOOSE) && json.size() > 1 &&      ch0 == '/'' && json.charAt(json.size() - 1) == '/'') {    json_set_last_error_code(json_error_codes::JSON_ERROR_NONE);    return json.substr(1, json.size() - 2);  }  if (ch0 == '{' || ch0 == '[') { /* invalid JSON string */    json_set_last_error_code(json_error_codes::JSON_ERROR_SYNTAX);  }  assert(json_get_last_error_code() != json_error_codes::JSON_ERROR_NONE);  return uninit_null();}

static Variant HHVM_FUNCTION(SystemLib_assert, const Variant& assertion,                             const Variant& message = uninit_null()) {  return impl_assert(assertion, message);}

Variant c_Normalizer::ti_normalize(const String& input,                                   int64_t form /* = q_Normalizer$$FORM_C */) {  s_intl_error->m_error.clear();  int expansion_factor = 1;  switch(form) {  case UNORM_NONE:  case UNORM_NFC:  case UNORM_NFKC:    break;  case UNORM_NFD:  case UNORM_NFKD:    expansion_factor = 3;    break;  default:    s_intl_error->m_error.code = U_ILLEGAL_ARGUMENT_ERROR;    s_intl_error->m_error.custom_error_message =      "normalizer_normalize: illegal normalization form";    return uninit_null();  }  /* First convert the string to UTF-16. */  UChar* uinput = NULL; int uinput_len = 0;  UErrorCode status = U_ZERO_ERROR;  intl_convert_utf8_to_utf16(&uinput, &uinput_len, input.data(), input.size(),                             &status);  if (U_FAILURE(status)) {    s_intl_error->m_error.code = status;    s_intl_error->m_error.custom_error_message =        "Error converting string to UTF-16.";    free(uinput);    return uninit_null();  }  /* Allocate memory for the destination buffer for normalization */  int uret_len = uinput_len * expansion_factor;  UChar *uret_buf = (UChar*)malloc((uret_len + 1) * sizeof(UChar));  /* normalize */  int size_needed = unorm_normalize(uinput, uinput_len,                                    (UNormalizationMode)form, (int32_t) 0,                                    uret_buf, uret_len, &status);  /* Bail out if an unexpected error occured.   * (U_BUFFER_OVERFLOW_ERROR means that *target buffer is not large enough).   * (U_STRING_NOT_TERMINATED_WARNING usually means that the input string   * is empty).   */  if (U_FAILURE(status) &&      status != U_BUFFER_OVERFLOW_ERROR &&      status != U_STRING_NOT_TERMINATED_WARNING) {    free(uret_buf);    free(uinput);    return uninit_null();  }  if (size_needed > uret_len) {    /* realloc does not seem to work properly - memory is corrupted     * uret_buf =  eurealloc(uret_buf, size_needed + 1); */    free(uret_buf);    uret_buf = (UChar*)malloc((size_needed + 1) * sizeof(UChar));    uret_len = size_needed;    status = U_ZERO_ERROR;    /* try normalize again */    size_needed = unorm_normalize( uinput, uinput_len,                                   (UNormalizationMode)form, (int32_t) 0,                                   uret_buf, uret_len, &status);    /* Bail out if an unexpected error occured. */    if (U_FAILURE(status)) {      /* Set error messages. */      s_intl_error->m_error.code = status;      s_intl_error->m_error.custom_error_message = "Error normalizing string";      free(uret_buf);      free(uinput);      return uninit_null();    }  }  free(uinput);  /* the buffer we actually used */  uret_len = size_needed;  /* Convert normalized string from UTF-16 to UTF-8. */  char* ret_buf = NULL; int ret_len = 0;  intl_convert_utf16_to_utf8(&ret_buf, &ret_len, uret_buf, uret_len, &status);  free(uret_buf);  if (U_FAILURE(status)) {    s_intl_error->m_error.code = status;    s_intl_error->m_error.custom_error_message =      "normalizer_normalize: error converting normalized text UTF-8";    return uninit_null();  }  return String(ret_buf, ret_len, AttachString);}

Variant c_Memcache::t___destruct() {  t_close();  return uninit_null();}

Variant c_DummyContinuation::t_current() {  throw_fatal("Tring to use a DummyContinuation");  return uninit_null();}