void raise_param_type_warning(
const char* func_name,
int param_num,
DataType expected_type,
DataType actual_type) {
// its ok to do this before munging, because it only looks at the
// end of the string
auto is_constructor = is_constructor_name(func_name);
if (!is_constructor && !warning_freq_check()) return;
// slice off fg1_
if (strncmp(func_name, "fg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "tg1_", 4) == 0) {
func_name += 4;
}
assertx(param_num > 0);
auto msg = folly::sformat(
"{}() expects parameter {} to be {}, {} given",
func_name,
param_num,
getDataTypeString(expected_type).data(),
getDataTypeString(actual_type).data());
if (is_constructor) {
SystemLib::throwExceptionObject(msg);
}
raise_warning_helper(false, msg);
}
/**
* It is important that the run time of this function is dependent
* only on the length of the user-supplied string.
*
* The only branch in the code below *should* result in non-branching
* machine code.
*
* Do not try to optimize this function.
*/
bool HHVM_FUNCTION(hash_equals, const Variant& known, const Variant& user) {
if (!known.isString()) {
raise_warning(
"hash_equals(): Expected known_string to be a string, %s given",
getDataTypeString(known.getType()).c_str()
);
return false;
}
if (!user.isString()) {
raise_warning(
"hash_equals(): Expected user_string to be a string, %s given",
getDataTypeString(user.getType()).c_str()
);
return false;
}
String known_str = known.toString();
String user_str = user.toString();
const auto known_len = known_str.size();
const auto known_limit = known_len - 1;
const auto user_len = user_str.size();
int64_t result = known_len ^ user_len;
int64_t ki = 0;
for (int64_t ui = 0; ui < user_len; ++ui) {
result |= user_str[ui] ^ known_str[ki];
if (ki < known_limit) {
++ki;
}
}
return (result == 0);
}
void VariantToBsonConverter::convert(bson_t *bson)
{
if (m_document.isObject() || m_document.isArray()) {
convertDocument(bson, NULL, m_document);
} else {
std::cout << "convert *unimplemented*: " << getDataTypeString(m_document.getType()).c_str() << "\n";
}
}
const char* giveTypeString(const TypedValue* value) {
const char* typeString;
if (value->m_type == KindOfObject){
typeString = value->m_data.pobj->o_getClassName()->data();
} else {
typeString = getDataTypeString(value->m_type).c_str();
}
return typeString;
}
void raise_param_type_warning(
const char* func_name,
int param_num,
DataType expected_type,
DataType actual_type) {
// slice off fg1_
if (strncmp(func_name, "fg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "tg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "__SystemLib\\extract", 19) == 0) {
func_name = "extract";
} else if (strncmp(func_name, "__SystemLib\\assert", 18) == 0) {
func_name = "assert";
} else if (strncmp(func_name, "__SystemLib\\parse_str", 21) == 0) {
func_name = "parse_str";
} else if (strncmp(func_name, "__SystemLib\\compact_sl", 22) == 0) {
func_name = "compact";
} else if (strncmp(func_name, "__SystemLib\\get_defined_vars", 28) == 0) {
func_name = "get_defined_vars";
} else if (strncmp(func_name, "__SystemLib\\func_get_args_sl", 28) == 0) {
func_name = "func_get_args";
} else if (strncmp(func_name, "__SystemLib\\func_get_arg_sl", 27) == 0) {
func_name = "func_get_arg";
} else if (strncmp(func_name, "__SystemLib\\func_num_arg_", 25) == 0) {
func_name = "func_num_args";
}
assert(param_num > 0);
auto msg = folly::sformat(
"{}() expects parameter {} to be {}, {} given",
func_name,
param_num,
getDataTypeString(expected_type).data(),
getDataTypeString(actual_type).data());
if (is_constructor_name(func_name)) {
SystemLib::throwExceptionObject(msg);
}
raise_warning(msg);
}
void raise_param_type_warning(
const char* func_name,
int param_num,
DataType expected_type,
DataType actual_type) {
// slice off fg1_
if (strncmp(func_name, "fg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "tg1_", 4) == 0) {
func_name += 4;
}
assert(param_num > 0);
String expected_type_str = getDataTypeString(expected_type);
String actual_type_str = getDataTypeString(actual_type);
raise_warning(
"%s() expects parameter %d to be %s, %s given",
func_name,
param_num,
expected_type_str.c_str(),
actual_type_str.c_str());
}
String HHVM_FUNCTION(gettype, const Variant& v) {
if (v.getType() == KindOfResource && v.toCResRef().isInvalid()) {
return s_unknown_type;
}
/* Although getDataTypeString also handles the null type, it returns "null"
* (lower case). Unfortunately, PHP returns "NULL" (upper case) for
* gettype(). So we make an exception here. */
if (v.isNull()) {
return s_NULL;
}
return getDataTypeString(v.getType());
}
void raise_param_type_warning(
const char* func_name,
int param_num,
DataType expected_type,
DataType actual_type) {
// slice off fg1_
if (strncmp(func_name, "fg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "tg1_", 4) == 0) {
func_name += 4;
} else if (strncmp(func_name, "__SystemLib\\extract", 19) == 0) {
func_name = "extract";
} else if (strncmp(func_name, "__SystemLib\\assert", 18) == 0) {
func_name = "assert";
} else if (strncmp(func_name, "__SystemLib\\parse_str", 21) == 0) {
func_name = "parse_str";
} else if (strncmp(func_name, "__SystemLib\\compact_sl", 22) == 0) {
func_name = "compact";
} else if (strncmp(func_name, "__SystemLib\\get_defined_vars", 28) == 0) {
func_name = "get_defined_vars";
} else if (strncmp(func_name, "__SystemLib\\func_get_args_sl", 28) == 0) {
func_name = "func_get_args";
} else if (strncmp(func_name, "__SystemLib\\func_get_arg_sl", 27) == 0) {
func_name = "func_get_arg";
} else if (strncmp(func_name, "__SystemLib\\func_num_arg_", 25) == 0) {
func_name = "func_num_args";
}
assert(param_num > 0);
auto expected_type_str = getDataTypeString(expected_type);
auto actual_type_str = getDataTypeString(actual_type);
raise_warning(
"%s() expects parameter %d to be %s, %s given",
func_name,
param_num,
expected_type_str.c_str(),
actual_type_str.c_str());
}
Variant HHVM_FUNCTION(preg_replace_callback_array,
const Variant& patterns_and_callbacks,
const Variant& subject,
int limit /* = -1 */,
VRefParam count /* = uninit_null() */) {
if (!patterns_and_callbacks.isArray()) {
raise_warning(
"%s() expects parameter 1 to be an array, %s given",
__FUNCTION__+2 /* +2 removes the "f_" prefix */,
getDataTypeString(patterns_and_callbacks.getType()).c_str()
);
return init_null();
}
// Now see if we need to raise any warnings because of not having a
// valid callback function
for (ArrayIter iter(patterns_and_callbacks.toArray()); iter; ++iter) {
if (!is_callable(iter.second())) {
raise_warning("Not a valid callback function %s",
iter.second().toString().data());
return subject.isString() ? empty_string_variant()
: Variant(empty_array());
}
}
if (subject.isString()) {
Array subject_arr = Array::Create();
subject_arr.add(0, subject.toString());
Variant ret = preg_replace_callback_array_impl(
patterns_and_callbacks, subject_arr, limit, count
);
// ret[0] could be an empty string
return ret.isArray() ? ret.toArray()[0] : init_null();
} else if (subject.isArray()) {
return preg_replace_callback_array_impl(
patterns_and_callbacks, subject.toArray(), limit, count
);
} else {
// No warning is given here, just return null
return init_null();
}
}
static Variant HHVM_METHOD(Closure, call,
const Variant& newthis,
const Array& params) {
if (newthis.isNull() || !newthis.isObject()) {
raise_warning(
"Closure::call() expects parameter 1 to be object, %s given",
getDataTypeString(newthis.getType()).c_str()
);
return init_null_variant;
}
// So, with bind/bindTo, if we are trying to bind an instance to a static
// closure, we just raise a warning and continue on. However, with call
// we are supposed to just return null (according to the PHP 7 implementation)
// Here is that speciality check, then. Do it here so we don't have to go
// through the rigormorale of binding if this is the case.
if (this_->getVMClass()->getCachedInvoke()->isStatic()) {
raise_warning("Cannot bind an instance to a static closure");
return init_null_variant;
}
auto bound = HHVM_MN(Closure, bindto)(this_, newthis, newthis);
// If something went wrong in the binding (warning, for example), then
// we can get an empty object back. And an empty object is null by
// default. Return null if that is the case.
if (bound.isNull()) {
return init_null_variant;
}
// Could call vm_user_func(bound, params) here which goes through a
// whole decode function process to get a Func*. But we know this
// is a closure, and we can get a Func* via getInvokeFunc(), so just
// bypass all that decode process to save time.
return Variant::attach(
g_context->invokeFunc(c_Closure::fromObject(this_)->getInvokeFunc(),
params, bound.toObject().get(),
nullptr, nullptr, nullptr,
ExecutionContext::InvokeCuf,
false, false)
);
}
bool WddxPacket::recursiveAddVar(const String& varName,
const Variant& varVariant,
bool hasVarTag) {
bool isArray = varVariant.isArray();
bool isObject = varVariant.isObject();
if (isArray || isObject) {
if (hasVarTag) {
m_packetString.append("<var name='");
m_packetString.append(varName.data());
m_packetString.append("'>");
}
Array varAsArray;
Object varAsObject = varVariant.toObject();
if (isArray) varAsArray = varVariant.toArray();
if (isObject) varAsArray = varAsObject.toArray();
int length = varAsArray.length();
if (length > 0) {
ArrayIter it = ArrayIter(varAsArray);
if (it.first().isString()) isObject = true;
if (isObject) {
m_packetString.append("<struct>");
if (!isArray) {
m_packetString.append("<var name='php_class_name'><string>");
m_packetString.append(varAsObject->getClassName());
m_packetString.append("</string></var>");
}
} else {
m_packetString.append("<array length='");
m_packetString.append(std::to_string(length));
m_packetString.append("'>");
}
for (ArrayIter it(varAsArray); it; ++it) {
Variant key = it.first();
Variant value = it.second();
recursiveAddVar(key.toString(), value, isObject);
}
if (isObject) {
m_packetString.append("</struct>");
}
else {
m_packetString.append("</array>");
}
}
else {
//empty object
if (isObject) {
m_packetString.append("<struct>");
if (!isArray) {
m_packetString.append("<var name='php_class_name'><string>");
m_packetString.append(varAsObject->getClassName());
m_packetString.append("</string></var>");
}
m_packetString.append("</struct>");
}
}
if (hasVarTag) {
m_packetString.append("</var>");
}
return true;
}
String varType = getDataTypeString(varVariant.getType());
if (!getWddxEncoded(varType, "", varName, false).empty()) {
String varValue;
if (varType.compare("boolean") == 0) {
varValue = varVariant.toBoolean() ? "true" : "false";
} else {
varValue = StringUtil::HtmlEncode(varVariant.toString(),
StringUtil::QuoteStyle::Double,
"UTF-8", false, false).toCppString();
}
m_packetString.append(
getWddxEncoded(varType, varValue, varName, hasVarTag));
return true;
}
return false;
}
m_packetString.append("<struct>");
if (!isArray) {
m_packetString.append("<var name='php_class_name'><string>");
m_packetString.append(varAsObject->getClassName());
m_packetString.append("</string></var>");
}
m_packetString.append("</struct>");
}
}
if (hasVarTag) {
m_packetString.append("</var>");
}
return true;
}
String varType = getDataTypeString(varVariant.getType());
if (!getWddxEncoded(varType, "", varName, false).empty()) {
String varValue;
if (varType.compare("boolean") == 0) {
varValue = varVariant.toBoolean() ? "true" : "false";
} else {
varValue = StringUtil::HtmlEncode(varVariant.toString(),
StringUtil::QuoteStyle::Double,
"UTF-8", false, false).toCppString();
}
m_packetString.append(
getWddxEncoded(varType, varValue, varName, hasVarTag));
return true;
}
return false;
String f_gettype(CVarRef v) {
if (v.getType() == KindOfResource && v.getResourceData()->isInvalid()) {
return s_unknown_type;
}
return getDataTypeString(v.getType());
}
String f_gettype(CVarRef v) {
return getDataTypeString(v.getType());
}
String HHVM_FUNCTION(gettype, const Variant& v) {
if (v.getType() == KindOfResource && v.getResourceData()->isInvalid()) {
return s_unknown_type;
}
return getDataTypeString(v.getType());
}
const char* giveTypeString(const TypedValue* value) {
if (value->m_type == KindOfObject || value->m_type == KindOfResource){
return value->m_data.pobj->o_getClassName()->data();
}
return getDataTypeString(value->m_type).c_str();
}
