bool f_define(CStrRef name, CVarRef value,
bool case_insensitive /* = false */) {
if (case_insensitive) {
raise_warning(Strings::CONSTANTS_CASE_SENSITIVE);
}
return VM::Unit::defCns(name.get(), value.getTypedAccessor());
}
bool ZendArray::exists(CVarRef k) const {
TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) return find(getIntKey(tva));
ASSERT(k.isString());
StringData *key = getStringKey(tva);
return find(key->data(), key->size(), key->hash());
}
ssize_t VectorArray::getIndex(CVarRef k) const {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
return VectorArray::getIndex(getIntKey(tva));
}
return ArrayData::invalid_index;
}
void StringBuffer::append(CVarRef v) {
Variant::TypedValueAccessor tva = v.getTypedAccessor();
if (Variant::IsString(tva)) {
append(Variant::GetAsString(tva));
} else if (IS_INT_TYPE(Variant::GetAccessorType(tva))) {
append(Variant::GetInt64(tva));
} else {
append(v.toString());
}
}
CVarRef VectorArray::get(CVarRef k, bool error /* = false */) const {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
return VectorArray::get(getIntKey(tva), error);
}
if (error) {
raise_notice("Undefined index: %s", k.toString().data());
}
return null_variant;
}
ssize_t ZendArray::getIndex(CVarRef k) const {
Bucket *p;
TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
p = find(getIntKey(tva));
} else {
ASSERT(k.isString());
StringData *key = getStringKey(tva);
p = find(key->data(), key->size(), key->hash());
}
if (p) {
return (ssize_t)p;
}
return ArrayData::invalid_index;
}
void ZendArray::load(CVarRef k, Variant &v) const {
Bucket *p;
TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
p = find(getIntKey(tva));
} else {
ASSERT(k.isString());
StringData *strkey = getStringKey(tva);
int64 prehash = strkey->hash();
p = find(strkey->data(), strkey->size(), prehash);
}
if (p) {
v.setWithRef(p->data);
}
}
HOT_FUNC
bool f_array_key_exists(CVarRef key, CVarRef search) {
const ArrayData *ad;
Variant::TypedValueAccessor sacc = search.getTypedAccessor();
DataType saccType = Variant::GetAccessorType(sacc);
if (LIKELY(saccType == KindOfArray)) {
ad = Variant::GetArrayData(sacc);
} else if (saccType == KindOfObject) {
return f_array_key_exists(key, toArray(search));
} else {
throw_bad_type_exception("array_key_exists expects an array or an object; "
"false returned.");
return false;
}
Variant::TypedValueAccessor kacc = key.getTypedAccessor();
switch (Variant::GetAccessorType(kacc)) {
case KindOfString:
case KindOfStaticString: {
int64_t n = 0;
StringData *sd = Variant::GetStringData(kacc);
if (sd->isStrictlyInteger(n)) {
return ad->exists(n);
}
return ad->exists(StrNR(sd));
}
case KindOfInt64:
return ad->exists(Variant::GetInt64(kacc));
case KindOfUninit:
case KindOfNull:
return ad->exists(empty_string);
default:
break;
}
raise_warning("Array key should be either a string or an integer");
return false;
}
CVarRef ZendArray::get(CVarRef k, bool error /* = false */) const {
Bucket *p;
TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
p = find(getIntKey(tva));
} else {
ASSERT(k.isString());
StringData *strkey = getStringKey(tva);
int64 prehash = strkey->hash();
p = find(strkey->data(), strkey->size(), prehash);
}
if (p) {
return p->data;
}
if (error) {
raise_notice("Undefined index: %s", k.toString().data());
}
return null_variant;
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
bool ret = true;
if (LIKELY(!syntax)) {
if (hhvm) {
CallerFrame cf;
ObjectData* obj = NULL;
HPHP::VM::Class* cls = NULL;
StringData* invName = NULL;
const HPHP::VM::Func* f = vm_decode_function(v, cf(), false, obj, cls,
invName, false);
if (f == NULL) {
ret = false;
}
if (invName != NULL) {
LITSTR_DECREF(invName);
}
} else {
MethodCallPackage mcp;
String classname, methodname;
bool doBind;
ret = get_user_func_handler(v, true, mcp,
classname, methodname, doBind, false);
if (ret && mcp.ci->m_flags & (CallInfo::Protected|CallInfo::Private)) {
classname = mcp.getClassName();
if (!ClassInfo::HasAccess(classname, *mcp.name,
mcp.ci->m_flags & CallInfo::StaticMethod ||
!mcp.obj,
mcp.obj)) {
ret = false;
}
}
}
if (!name.isReferenced()) return ret;
}
Variant::TypedValueAccessor tv_func = v.getTypedAccessor();
if (Variant::IsString(tv_func)) {
if (name.isReferenced()) name = Variant::GetStringData(tv_func);
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfArray) {
CArrRef arr = Variant::GetAsArray(tv_func);
CVarRef clsname = arr.rvalAtRef(0LL);
CVarRef mthname = arr.rvalAtRef(1LL);
if (arr.size() != 2 ||
&clsname == &null_variant ||
&mthname == &null_variant) {
name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_meth = mthname.getTypedAccessor();
if (!Variant::IsString(tv_meth)) {
if (name.isReferenced()) name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_cls = clsname.getTypedAccessor();
if (Variant::GetAccessorType(tv_cls) == KindOfObject) {
name = Variant::GetObjectData(tv_cls)->o_getClassName();
} else if (Variant::IsString(tv_cls)) {
name = Variant::GetStringData(tv_cls);
} else {
name = v.toString();
return false;
}
name = concat3(name, "::", Variant::GetAsString(tv_meth));
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfObject) {
ObjectData *d = Variant::GetObjectData(tv_func);
if (hhvm) {
static const StringData* sd__invoke
= StringData::GetStaticString("__invoke");
const VM::Func* invoke = d->getVMClass()->lookupMethod(sd__invoke);
if (name.isReferenced()) {
if (d->o_instanceof("closure")) {
// Hack to stop the mangled name from showing up
name = "Closure::__invoke";
} else {
name = d->o_getClassName() + "::__invoke";
}
}
return invoke != NULL;
} else {
void *extra;
if (d->t___invokeCallInfoHelper(extra)) {
name = d->o_getClassName() + "::__invoke";
return ret;
}
if (name.isReferenced()) {
name = v.toString();
}
}
}
return false;
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
bool ret = true;
if (LIKELY(!syntax)) {
CallerFrame cf;
ObjectData* obj = NULL;
HPHP::VM::Class* cls = NULL;
StringData* invName = NULL;
const HPHP::VM::Func* f = vm_decode_function(v, cf(), false, obj, cls,
invName, false);
if (f == NULL) {
ret = false;
}
if (invName != NULL) {
decRefStr(invName);
}
if (!name.isReferenced()) return ret;
}
Variant::TypedValueAccessor tv_func = v.getTypedAccessor();
if (Variant::IsString(tv_func)) {
if (name.isReferenced()) name = Variant::GetStringData(tv_func);
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfArray) {
CArrRef arr = Variant::GetAsArray(tv_func);
CVarRef clsname = arr.rvalAtRef(int64_t(0));
CVarRef mthname = arr.rvalAtRef(int64_t(1));
if (arr.size() != 2 ||
&clsname == &null_variant ||
&mthname == &null_variant) {
name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_meth = mthname.getTypedAccessor();
if (!Variant::IsString(tv_meth)) {
if (name.isReferenced()) name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_cls = clsname.getTypedAccessor();
if (Variant::GetAccessorType(tv_cls) == KindOfObject) {
name = Variant::GetObjectData(tv_cls)->o_getClassName();
} else if (Variant::IsString(tv_cls)) {
name = Variant::GetStringData(tv_cls);
} else {
name = v.toString();
return false;
}
name = concat3(name, "::", Variant::GetAsString(tv_meth));
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfObject) {
ObjectData *d = Variant::GetObjectData(tv_func);
static const StringData* sd__invoke
= StringData::GetStaticString("__invoke");
const VM::Func* invoke = d->getVMClass()->lookupMethod(sd__invoke);
if (name.isReferenced()) {
if (d->instanceof(c_Closure::s_cls)) {
// Hack to stop the mangled name from showing up
name = "Closure::__invoke";
} else {
name = d->o_getClassName() + "::__invoke";
}
}
return invoke != NULL;
}
return false;
}
bool VectorArray::exists(CVarRef k) const {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) return exists(getIntKey(tva));
return false;
}