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

static Array get_frame_args_with_ref(const ActRec* ar) {  int numNonVariadic = ar->func()->numNonVariadicParams();  int numArgs = ar->numArgs();  PackedArrayInit retArray(numArgs);  auto local = reinterpret_cast<TypedValue*>(    uintptr_t(ar) - sizeof(TypedValue)  );  int i = 0;  // The function's formal parameters are on the stack  for (; i < numArgs && i < numNonVariadic; ++i) {    retArray.appendWithRef(tvAsCVarRef(local));    --local;  }  if (i < numArgs) {    // If there are still args that haven't been accounted for, they have    // either been ... :    if (ar->func()->hasVariadicCaptureParam()) {      // ... shuffled into a packed array stored in the variadic capture      // param on the stack      for (ArrayIter iter(tvAsCVarRef(local)); iter; ++iter) {        retArray.appendWithRef(iter.secondRef());      }    } else {      // ... or moved into the ExtraArgs datastructure.      for (; i < numArgs; ++i) {        retArray.appendWithRef(          tvAsCVarRef(ar->getExtraArg(i - numNonVariadic)));      }    }  }  return retArray.toArray();}

ArrayData *VectorArray::dequeue(Variant &value) {  if (UNLIKELY(!m_size)) {    value.setNull();    return nullptr;  }  if (UNLIKELY(getCount() > 1)) {    value = tvAsCVarRef(&m_elems[0]);    if (m_size == 1) {      return StaticEmptyVectorArray::Get();    }    VectorArray *a = NEW(VectorArray)(this, 1, m_size - 1);    a->m_pos = (ssize_t)0;    return a;  }  value = tvAsCVarRef(&m_elems[0]);  m_size--;  tvAsVariant(&m_elems[0]).~Variant();  for (uint i = 0; i < m_size; i++) {    // TypedValue copy without refcounting.    m_elems[i] = m_elems[i+1];  }  // To match PHP-like semantics, the dequeue operation resets the array's  // internal iterator  m_pos = m_size ? (ssize_t)0 : ArrayData::invalid_index;  return nullptr;}

void BaseMap::addAllImpl(const Variant& iterable) {  if (iterable.isNull()) return;  VMRegGuard _;  decltype(cap()) oldCap = 0;  bool ok = IterateKV(    *iterable.asTypedValue(),    [&](ArrayData* adata) {      auto sz = adata->size();      if (!sz) return true;      if (!m_size) {        if (adata->isMixed()) {          replaceArray(adata);          updateIntLikeStrKeys();          return true;        }      } else {        oldCap = cap(); // assume minimal collisions      }      reserve(m_size + sz);      mutateAndBump();      return false;    },    [this](const TypedValue* key, const TypedValue* value) {      setRaw(tvAsCVarRef(key), tvAsCVarRef(value));    },    [this](ObjectData* coll) {      switch (coll->collectionType()) {        case CollectionType::Map:        case CollectionType::Set:        {          if (m_size) break;          auto hc = static_cast<HashCollection*>(coll);          replaceArray(hc->arrayData());          setIntLikeStrKeys(BaseMap::intLikeStrKeys(hc));          return true;        }        case CollectionType::Pair:          mutateAndBump();          break;        default:          break;      }      return false;    },    [this](const TypedValue* key, const TypedValue* value) {      set(tvAsCVarRef(key), tvAsCVarRef(value));    });  if (UNLIKELY(!ok)) {    throw_invalid_collection_parameter();  }  // ... and shrink back if that was incorrect  if (oldCap) shrinkIfCapacityTooHigh(oldCap);}

Variant HHVM_FUNCTION(get_class_vars, const String& className) {  const Class* cls = Unit::loadClass(className.get());  if (!cls) {    return false;  }  cls->initialize();  auto const propInfo = cls->declProperties();  auto const numDeclProps = cls->numDeclProperties();  auto const numSProps    = cls->numStaticProperties();  // The class' instance property initialization template is in different  // places, depending on whether it has any request-dependent initializers  // (i.e. constants)  auto const& declPropInitVec = cls->declPropInit();  auto const propVals = !cls->pinitVec().empty()    ? cls->getPropData()    : &declPropInitVec;  assert(propVals != nullptr);  assert(propVals->size() == numDeclProps);  // For visibility checks  CallerFrame cf;  auto ctx = arGetContextClass(cf());  ArrayInit arr(numDeclProps + numSProps, ArrayInit::Map{});  for (size_t i = 0; i < numDeclProps; ++i) {    auto const name = const_cast<StringData*>(propInfo[i].name.get());    // Empty names are used for invisible/private parent properties; skip them.    assert(name->size() != 0);    if (Class::IsPropAccessible(propInfo[i], ctx)) {      auto const value = &((*propVals)[i]);      arr.set(name, tvAsCVarRef(value));    }  }  for (auto const& sprop : cls->staticProperties()) {    auto const lookup = cls->getSProp(ctx, sprop.name);    if (lookup.accessible) {      arr.set(        const_cast<StringData*>(sprop.name.get()),        tvAsCVarRef(lookup.prop)      );    }  }  return arr.toArray();}

ArrayData* ProxyArray::SetInt(ArrayData* ad,                              int64_t k,                              Cell v,                              bool copy) {  if (copy) {    return innerArr(ad)->set(k, tvAsCVarRef(&v), true);  }  auto const r = innerArr(ad)->set(    k, tvAsCVarRef(&v), innerArr(ad)->cowCheck()  );  reseatable(ad, r);  return ad;}

ArrayData* ProxyArray::SetStr(ArrayData* ad,                              StringData* k,                              Cell v,                              bool copy) {  if (copy) {    return innerArr(ad)->set(k, tvAsCVarRef(&v), copy);  } else {    auto r = innerArr(ad)->set(k,        tvAsCVarRef(&v), innerArr(ad)->hasMultipleRefs());    reseatable(ad, r);    return ad;  }}

ArrayData* deepCopyDict(ArrayData* arr) {  assert(arr->isDict());  DictInit ai{arr->size()};  MixedArray::IterateKV(    MixedArray::asMixed(arr),    [&](const TypedValue* k, const TypedValue* v) {      Variant value{tvAsCVarRef(v)};      deepCopy(value.asTypedValue());      ai.setValidKey(tvAsCVarRef(k), value);      return false;    }  );  return ai.create();}

ArrayData* deepCopyArray(ArrayData* arr) {  assert(arr->isPHPArray());  ArrayInit ai(arr->size(), ArrayInit::Mixed{});  IterateKV(    arr,    [&](const TypedValue* k, const TypedValue* v) {      Variant value{tvAsCVarRef(v)};      deepCopy(value.asTypedValue());      ai.setValidKey(tvAsCVarRef(k), value);      return false;    }  );  return ai.create();}

int shuffleArgsForMagicCall(ActRec* ar) {  if (!ar->hasInvName()) {    return 0;  }  const Func* f UNUSED = ar->m_func;  f->validate();  assert(f->name()->isame(s_call.get())         || f->name()->isame(s_callStatic.get()));  assert(f->numParams() == 2);  assert(ar->hasInvName());  StringData* invName = ar->getInvName();  assert(invName);  ar->setVarEnv(nullptr);  int nargs = ar->numArgs();  // We need to make an array containing all the arguments passed by the  // caller and put it where the second argument is  PackedArrayInit aInit(nargs);  for (int i = 0; i < nargs; ++i) {    auto const tv = reinterpret_cast<TypedValue*>(      uintptr_t(ar) - (i+1) * sizeof(TypedValue)    );    aInit.append(tvAsCVarRef(tv));    tvRefcountedDecRef(tv);  }  // Put invName in the slot for first argument  setArgInActRec(ar, 0, uint64_t(invName), KindOfString);  // Put argArray in the slot for second argument  auto const argArray = aInit.toArray().detach();  setArgInActRec(ar, 1, uint64_t(argArray), KindOfArray);  // Fix up ActRec's numArgs  ar->initNumArgs(2);  return 1;}

void ArrayIter::secondHelper(Variant & v) {    if (hasVector()) {        c_Vector* vec = getVector();        if (UNLIKELY(m_versionNumber != vec->getVersionNumber())) {            throw_collection_modified();        }        v = tvAsCVarRef(vec->at(m_pos));        return;    }    if (hasMap()) {        c_Map* mp = getMap();        if (UNLIKELY(m_versionNumber != mp->getVersionNumber())) {            throw_collection_modified();        }        v = mp->iter_value(m_pos);        return;    }    if (hasStableMap()) {        c_StableMap* smp = getStableMap();        if (UNLIKELY(m_versionNumber != smp->getVersionNumber())) {            throw_collection_modified();        }        v = smp->iter_value(m_pos);        return;    }    assert(hasObject());    ObjectData* obj = getObject();    v = obj->o_invoke(s_current, Array());}

Variant BaseVector::at(CVarRef key) {  if (key.isInteger()) {    return tvAsCVarRef(at(key.toInt64()));  }  throwBadKeyType();  return uninit_null();}

TypedValue HHVM_FUNCTION(serialize_memoize_param, TypedValue param) {  // Memoize throws in the emitter if any function parameters are references, so  // we can just assert that the param is cell here  assertx(param.m_type != KindOfRef);  auto const type = param.m_type;  if (isStringType(type)) {    auto const str = param.m_data.pstr;    if (str->empty()) {      return make_tv<KindOfPersistentString>(s_emptyStrMemoKey.get());    } else if ((unsigned char)str->data()[0] < '~') {      // fb_compact_serialize always returns a string with the high-bit set in      // the first character. Furthermore, we use ~ to begin all our special      // constants, so anything less than ~ can't collide. There's no worry      // about int-like strings because we use dicts (which don't perform key      // coercion) to store the memoized values.      str->incRefCount();      return param;    }  } else if (isContainer(param) && getContainerSize(param) == 0) {    return make_tv<KindOfPersistentString>(s_emptyArrMemoKey.get());  } else if (type == KindOfUninit || type == KindOfNull) {    return make_tv<KindOfPersistentString>(s_nullMemoKey.get());  } else if (type == KindOfBoolean) {    return make_tv<KindOfPersistentString>(      param.m_data.num ? s_trueMemoKey.get() : s_falseMemoKey.get()    );  } else if (type == KindOfInt64) {    return param;  }  return tvReturn(    fb_compact_serialize(tvAsCVarRef(&param),                         FBCompactSerializeBehavior::MemoizeParam));}

void EventHook::RunUserProfiler(const ActRec* ar, int mode) {  // Don't do anything if we are running the profiling function itself  // or if we haven't set up a profiler.  if (g_vmContext->m_executingSetprofileCallback ||      g_vmContext->m_setprofileCallback.isNull()) {    return;  }  Transl::VMRegAnchor _;  ExecutingSetprofileCallbackGuard guard;  Array params;  Array frameinfo;  if (mode == ProfileEnter) {    params.append(s_enter);    frameinfo.set(s_args, hhvm_get_frame_args(ar));  } else {    params.append(s_exit);    if (!g_vmContext->m_faults.empty()) {      Fault fault = g_vmContext->m_faults.back();      if (fault.m_faultType == Fault::UserException) {        frameinfo.set(s_exception, fault.m_userException);      }    } else if (!ar->m_func->isBuiltin() &&               !ar->m_func->isGenerator()) {      // TODO (#1131400) This is wrong for builtins      frameinfo.set(s_return, tvAsCVarRef(g_vmContext->m_stack.topTV()));    }  }  params.append(VarNR(ar->m_func->fullName()));  params.append(frameinfo);  f_call_user_func_array(g_vmContext->m_setprofileCallback, params);}

Variant HHVM_FUNCTION(constant, const String& name) {  if (!name.get()) return init_null();  const char *data = name.data();  int len = name.length();  char *colon;  if ((colon = (char*)memchr(data, ':', len)) && colon[1] == ':') {    // class constant    int classNameLen = colon - data;    char *constantName = colon + 2;    Class* cls = getClassByName(data, classNameLen);    if (cls) {      String cnsName(constantName, data + len - constantName, CopyString);      Cell cns = cls->clsCnsGet(cnsName.get());      if (cns.m_type != KindOfUninit) {        return cellAsCVarRef(cns);      }    }  } else {    auto const cns = Unit::loadCns(name.get());    if (cns) return tvAsCVarRef(cns);  }  raise_warning("constant(): Couldn't find constant %s", data);  return init_null();}

RefData* staticLocInitImpl(StringData* name, ActRec* fp, TypedValue val,                           TargetCache::CacheHandle ch) {  assert(useTargetCache == (bool)ch);  HphpArray* map;  if (useTargetCache) {    // If we have a cache handle, we know the current func isn't a    // closure or generator closure so we can directly grab its static    // locals map.    const Func* func = fp->m_func;    assert(!(func->isClosureBody() || func->isGeneratorFromClosure()));    map = func->getStaticLocals();  } else {    map = get_static_locals(fp);  }  TypedValue *mapVal = map->nvGet(name);  if (!mapVal) {    map->set(name, tvAsCVarRef(&val), false);    mapVal = map->nvGet(name);  }  if (mapVal->m_type != KindOfRef) {    tvBox(mapVal);  }  assert(mapVal->m_type == KindOfRef);  RefData* ret = mapVal->m_data.pref;  if (useTargetCache) {    *TargetCache::handleToPtr<RefData*>(ch) = ret;  }  ret->incRefCount();  return ret;}

ZendArray *VectorArray::escalateToNonEmptyZendArray() const {  assert(m_size);  ZendArray *ret;  ZendArray::Bucket *p[256], **pp;  if (LIKELY(m_size < 256)) {    pp = p;  } else {    pp =      (ZendArray::Bucket **)malloc(sizeof(ZendArray::Bucket *) * (m_size + 1));  }  DECLARE_ALLOCATOR(a, ZendArray::Bucket, Bucket);  for (int64 i = 0; i < m_size; i++) {    CVarRef v = tvAsCVarRef(&m_elems[i]);    pp[i] = NEWALLOC(a) ZendArray::Bucket(i, withRefBind(v));  }  pp[m_size] = nullptr;  ret = NEW(ZendArray)(m_size, m_size, pp);  if (UNLIKELY(pp != p)) free(pp);  if (m_pos != ArrayData::invalid_index) {    ret->setPosition(ret->getIndex(m_pos));  } else {    ret->setPosition(0);  }  return ret;}

Array BaseVector::toArrayImpl() const {  PackedArrayInit ai(m_size);  uint sz = m_size;  for (uint i = 0; i < sz; ++i) {    ai.append(tvAsCVarRef(&m_data[i]));  }  return ai.toArray();}

void RepoQuery::bindTypedValue(const char* paramName, const TypedValue& tv) {  if (tv.m_type == KindOfUninit) {    bindBlob(paramName, "", 0, true);  } else {    String blob = f_serialize(tvAsCVarRef(&tv));    bindBlob(paramName, blob->data(), blob->size());  }}

ArrayData* addElemStringKeyHelper(ArrayData* ad,                                  StringData* key,                                  TypedValue value) {  // this does not re-enter  bool copy = ad->getCount() > 1;  // set will decRef any old value that may have been overwritten  // if appropriate  int64_t intkey;  ArrayData* retval = UNLIKELY(key->isStrictlyInteger(intkey)) ?                      ad->set(intkey, tvAsCVarRef(&value), copy) :                      ad->set(key, tvAsCVarRef(&value), copy);  // TODO Task #1970153: It would be great if there were set()  // methods that didn't bump up the refcount so that we didn't  // have to decrement it here  tvRefcountedDecRef(&value);  return arrayRefShuffle<false>(ad, retval, nullptr);}

Array HashCollection::toValuesArray() {  PackedArrayInit ai(m_size);  auto* eLimit = elmLimit();  for (auto* e = firstElm(); e != eLimit; e = nextElm(e, eLimit)) {    ai.append(tvAsCVarRef(&e->data));  }  return ai.toArray();}

ArrayData* ArrayCommon::ToDict(ArrayData* a, bool) {  auto const size = a->size();  if (!size) return staticEmptyDictArray();  DictInit init{size};  IterateKV(    a,    [&](const TypedValue* k, const TypedValue* v) {      if (UNLIKELY(v->m_type == KindOfRef)) {        if (v->m_data.pref->isReferenced()) {          throwRefInvalidArrayValueException(init.toArray());        }      }      init.setValidKey(tvAsCVarRef(k), tvAsCVarRef(v));    }  );  return init.create();}

ArrayData* deepCopyDict(ArrayData* arr) {  assert(arr->isDict());  Array ar(arr);  MixedArray::IterateKV(    MixedArray::asMixed(arr),    [&](const TypedValue* k, const TypedValue* v) {      if (!isRefcountedType(v->m_type)) return false;      Variant value{tvAsCVarRef(v)};      deepCopy(value.asTypedValue());      if (value.asTypedValue()->m_data.num != v->m_data.num) {        ar.set(tvAsCVarRef(k), value);      }      return false;    }  );  return ar.detach();}

int64_t BaseVector::linearsearch(CVarRef search_value) {  uint sz = m_size;  for (uint i = 0; i < sz; ++i) {    if (same(search_value, tvAsCVarRef(&m_data[i]))) {      return i;    }  }  return -1;}

HOT_FUNCCVarRef SharedMap::getValueRef(ssize_t pos) const {  SharedVariant *sv = getValueImpl(pos);  DataType t = sv->getType();  if (!IS_REFCOUNTED_TYPE(t)) return sv->asCVarRef();  if (LIKELY(m_localCache != nullptr)) {    assert(unsigned(pos) < size());    TypedValue* tv = &m_localCache[pos];    if (tv->m_type != KindOfUninit) return tvAsCVarRef(tv);  } else {    static_assert(KindOfUninit == 0, "must be 0 since we use smart_calloc");    m_localCache = (TypedValue*) smart_calloc(size(), sizeof(TypedValue));  }  TypedValue* tv = &m_localCache[pos];  tvAsVariant(tv) = sv->toLocal();  assert(tv->m_type != KindOfUninit);  return tvAsCVarRef(tv);}

StringData* prepareAnyKey(TypedValue* tv) {  if (IS_STRING_TYPE(tv->m_type)) {    StringData* str = tv->m_data.pstr;    str->incRefCount();    return str;  } else {    return tvAsCVarRef(tv).toString().detach();  }}