TypedValue HHVM_FUNCTION(dummy_arraylike_builtin, const Variant& var) {
if (var.isArray()) {
auto const& arr = var.asCArrRef();
return tvReturn(arr);
}
return tvReturn(staticEmptyKeysetArray());
}
ArrayData* ArrayCommon::ToKeyset(ArrayData* a, bool) {
auto const size = a->size();
if (!size) return staticEmptyKeysetArray();
KeysetInit init{size};
IterateV(
a,
[&](const TypedValue* v) {
if (UNLIKELY(v->m_type == KindOfRef)) {
if (v->m_data.pref->isReferenced()) {
throwRefInvalidArrayValueException(init.toArray());
}
v = v->m_data.pref->tv();
assertx(v->m_type != KindOfRef);
}
if (LIKELY(isStringType(v->m_type))) {
init.add(v->m_data.pstr);
} else if (LIKELY(isIntType(v->m_type))) {
init.add(v->m_data.num);
} else {
throwInvalidArrayKeyException(v, init.toArray().get());
}
}
);
return init.create();
}
ArrayData* EmptyArray::ToKeyset(ArrayData*, bool) {
return staticEmptyKeysetArray();
}
void tvCastToKeysetInPlace(TypedValue* tv) {
assert(tvIsPlausible(*tv));
tvUnboxIfNeeded(tv);
ArrayData* a;
do {
switch (tv->m_type) {
case KindOfUninit:
case KindOfNull:
raise_warning("Null to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfBoolean:
raise_warning("Bool to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfInt64:
raise_warning("Int to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfDouble:
raise_warning("Double to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfPersistentString:
case KindOfString:
raise_warning("String to keyset conversion");
a = staticEmptyKeysetArray();
decRefStr(tv->m_data.pstr);
continue;
case KindOfResource:
raise_warning("Resource to keyset conversion");
a = staticEmptyKeysetArray();
decRefRes(tv->m_data.pres);
continue;
case KindOfPersistentVec:
case KindOfVec: {
auto* adIn = tv->m_data.parr;
assert(adIn->isVecArray());
a = PackedArray::ToKeysetVec(adIn, adIn->cowCheck());
assert(a != adIn);
decRefArr(adIn);
continue;
}
case KindOfPersistentDict:
case KindOfDict: {
auto* adIn = tv->m_data.parr;
assert(adIn->isDict());
a = MixedArray::ToKeysetDict(adIn, adIn->cowCheck());
if (a != adIn) decRefArr(adIn);
continue;
}
case KindOfPersistentArray:
case KindOfArray: {
auto* adIn = tv->m_data.parr;
assert(adIn->isPHPArray());
a = adIn->toKeyset(adIn->cowCheck());
if (a != adIn) decRefArr(adIn);
continue;
}
case KindOfPersistentKeyset:
case KindOfKeyset:
assert(tv->m_data.parr->isKeyset());
return;
case KindOfObject: {
auto* obj = tv->m_data.pobj;
if (!obj->isCollection()) {
raise_warning("Non-collection object conversion to keyset");
a = staticEmptyKeysetArray();
} else {
auto keyset = collections::toArray(obj).toKeyset();
decRefObj(obj);
a = keyset.detach();
}
continue;
}
case KindOfRef:
case KindOfClass:
break;
}
not_reached();
} while (0);
assert(!a->isRefCounted() || a->hasExactlyOneRef());
tv->m_data.parr = a;
tv->m_type = KindOfKeyset;
assert(cellIsPlausible(*tv));
}
