static Variant dateImpl(const String& format, int64_t timestamp) {
if (format.empty()) return empty_string_variant();
auto dt = req::make<DateTime>(timestamp, false);
String ret = dt->toString(format, false);
if (ret.isNull()) return false;
return ret;
}
static Variant HHVM_FUNCTION(imap_body, const Resource& imap_stream,
int64_t msg_number, int64_t options /* = 0 */) {
if (options && ((options & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
raise_warning("invalid value for the options parameter");
return false;
}
auto obj = cast<ImapStream>(imap_stream);
int msgindex;
if (options & FT_UID) {
/* This should be cached; if it causes an extra RTT to the
IMAP server, then that's the price we pay for making sure
we don't crash. */
msgindex = mail_msgno(obj->m_stream, msg_number);
} else {
msgindex = msg_number;
}
if (!obj->checkMsgNumber(msgindex)) {
return false;
}
unsigned long body_len = 0;
char *body = mail_fetchtext_full(obj->m_stream, msg_number,
&body_len, (options ? options : NIL));
if (body_len == 0) {
return empty_string_variant();
} else {
return String(body, body_len, CopyString);
}
}
static Variant date_impl(int64_t argc,
const String& format, int64_t timestamp) {
if (!gmt && format.empty()) return empty_string_variant();
if (argc < 2) timestamp = TimeStamp::Current();
String ret = req::make<DateTime>(timestamp, gmt)->toString(format, false);
if (ret.isNull()) return false;
return ret;
}
Variant HHVM_FUNCTION(preg_replace_callback, const Variant& pattern, const Variant& callback,
const Variant& subject,
int limit /* = -1 */,
VRefParam count /* = null */) {
if (!f_is_callable(callback)) {
raise_warning("Not a valid callback function %s",
callback.toString().data());
return empty_string_variant();
}
return preg_replace_impl(pattern, callback, subject,
limit, count, true, false);
}
Variant HHVM_METHOD(XMLReader, __get,
const Variant& name) {
auto* data = Native::data<XMLReader>(this_);
const xmlChar *retchar = nullptr;
int retint = 0;
XMLPropertyAccessor *propertyMap = xmlreader_properties_map.get(name);
if (!propertyMap) {
this_->raiseUndefProp(name.getStringData());
return init_null();
}
if (data->m_ptr) {
if (propertyMap->getter_char) {
retchar = propertyMap->getter_char(data->m_ptr);
} else if (propertyMap->getter_int) {
retint = propertyMap->getter_int(data->m_ptr);
}
}
switch (DataType(propertyMap->return_type)) {
case KindOfBoolean:
return retint ? true : false;
case KindOfInt64:
return retint;
case KindOfString:
if (retchar) {
return String((char*)retchar, CopyString);
} else {
return empty_string_variant();
}
case KindOfUninit:
case KindOfNull:
case KindOfDouble:
case KindOfPersistentString:
case KindOfArray:
case KindOfPersistentArray:
case KindOfVec:
case KindOfPersistentVec:
case KindOfDict:
case KindOfPersistentDict:
case KindOfKeyset:
case KindOfPersistentKeyset:
case KindOfObject:
case KindOfResource:
case KindOfRef:
return init_null();
case KindOfClass:
break;
}
not_reached();
}
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();
}
}
Variant HHVM_METHOD(XMLReader, __get,
Variant name) {
auto* data = Native::data<XMLReader>(this_);
const xmlChar *retchar = nullptr;
int retint = 0;
XMLPropertyAccessor *propertyMap = xmlreader_properties_map.get(name);
if (!propertyMap) {
this_->raiseUndefProp(name.getStringData());
return init_null();
}
if (data->m_ptr) {
if (propertyMap->getter_char) {
retchar = propertyMap->getter_char(data->m_ptr);
} else if (propertyMap->getter_int) {
retint = propertyMap->getter_int(data->m_ptr);
}
}
switch (propertyMap->return_type) {
case KindOfString:
if (retchar) {
return String((char*)retchar, CopyString);
} else {
return empty_string_variant();
}
case KindOfBoolean:
return (retint ? true : false);
case KindOfInt64:
return retint;
default:
return init_null();
}
return init_null();
}
Variant c_XMLReader::t___get(Variant name) {
const xmlChar *retchar = NULL;
int retint = 0;
XMLPropertyAccessor *propertyMap = xmlreader_properties_map.get(name);
if (!propertyMap) {
raiseUndefProp(name.getStringData());
return init_null();
}
if (m_ptr) {
if (propertyMap->getter_char) {
retchar = propertyMap->getter_char(m_ptr);
} else if (propertyMap->getter_int) {
retint = propertyMap->getter_int(m_ptr);
}
}
switch (propertyMap->return_type) {
case KindOfString:
if (retchar) {
return String((char*)retchar, CopyString);
} else {
return empty_string_variant();
}
case KindOfBoolean:
return (retint ? true : false);
case KindOfInt64:
return retint;
default:
return init_null();
}
return init_null();
}
Variant binary_deserialize(int8_t thrift_typeID, PHPInputTransport& transport,
const Array& fieldspec) {
Variant ret;
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return init_null();
case T_STRUCT: {
Variant val;
if ((val = fieldspec.rvalAt(PHPTransport::s_class)).isNull()) {
throw_tprotocolexception("no class type in spec", INVALID_DATA);
skip_element(T_STRUCT, transport);
return init_null();
}
String structType = val.toString();
ret = createObject(structType);
if (ret.isNull()) {
// unable to create class entry
skip_element(T_STRUCT, transport);
return init_null();
}
Variant spec = HHVM_FN(hphp_get_static_property)(structType, s_TSPEC,
false);
if (!spec.is(KindOfArray)) {
char errbuf[128];
snprintf(errbuf, 128, "spec for %s is wrong type: %d\n",
structType.data(), ret.getType());
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
return init_null();
}
binary_deserialize_spec(ret.toObject(), transport, spec.toArray());
return ret;
} break;
case T_BOOL: {
uint8_t c;
transport.readBytes(&c, 1);
return c != 0;
}
//case T_I08: // same numeric value as T_BYTE
case T_BYTE: {
uint8_t c;
transport.readBytes(&c, 1);
return Variant((int8_t)c);
}
case T_I16: {
uint16_t c;
transport.readBytes(&c, 2);
return Variant((int16_t)ntohs(c));
}
case T_I32: {
uint32_t c;
transport.readBytes(&c, 4);
return Variant((int32_t)ntohl(c));
}
case T_U64:
case T_I64: {
uint64_t c;
transport.readBytes(&c, 8);
return Variant((int64_t)ntohll(c));
}
case T_DOUBLE: {
union {
uint64_t c;
double d;
} a;
transport.readBytes(&(a.c), 8);
a.c = ntohll(a.c);
return a.d;
}
case T_FLOAT: {
union {
uint32_t c;
float d;
} a;
transport.readBytes(&(a.c), 4);
a.c = ntohl(a.c);
return a.d;
}
//case T_UTF7: // aliases T_STRING
case T_UTF8:
case T_UTF16:
case T_STRING: {
uint32_t size = transport.readU32();
if (size && (size + 1)) {
String s = String(size, ReserveString);
char* strbuf = s.mutableData();
transport.readBytes(strbuf, size);
s.setSize(size);
return s;
} else {
return empty_string_variant();
}
}
case T_MAP: { // array of key -> value
uint8_t types[2];
transport.readBytes(types, 2);
uint32_t size = transport.readU32();
Array keyspec = fieldspec.rvalAt(PHPTransport::s_key,
AccessFlags::Error_Key).toArray();
Array valspec = fieldspec.rvalAt(PHPTransport::s_val,
AccessFlags::Error_Key).toArray();
String format = fieldspec.rvalAt(PHPTransport::s_format,
AccessFlags::None).toString();
if (format.equal(PHPTransport::s_collection)) {
ret = newobj<c_Map>();
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(types[0], transport, keyspec);
Variant value = binary_deserialize(types[1], transport, valspec);
collectionSet(ret.getObjectData(), key.asCell(), value.asCell());
}
} else {
ret = Array::Create();
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(types[0], transport, keyspec);
Variant value = binary_deserialize(types[1], transport, valspec);
ret.toArrRef().set(key, value);
}
}
return ret; // return_value already populated
}
case T_LIST: { // array with autogenerated numeric keys
int8_t type = transport.readI8();
uint32_t size = transport.readU32();
Variant elemvar = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key);
Array elemspec = elemvar.toArray();
String format = fieldspec.rvalAt(PHPTransport::s_format,
AccessFlags::None).toString();
if (format.equal(PHPTransport::s_collection)) {
auto const pvec = newobj<c_Vector>();
ret = pvec;
for (uint32_t s = 0; s < size; ++s) {
Variant value = binary_deserialize(type, transport, elemspec);
pvec->t_add(value);
}
} else {
PackedArrayInit pai(size);
for (auto s = uint32_t{0}; s < size; ++s) {
pai.append(binary_deserialize(type, transport, elemspec));
}
ret = pai.toArray();
}
return ret;
}
case T_SET: { // array of key -> TRUE
uint8_t type;
uint32_t size;
transport.readBytes(&type, 1);
transport.readBytes(&size, 4);
size = ntohl(size);
Variant elemvar = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key);
Array elemspec = elemvar.toArray();
String format = fieldspec.rvalAt(PHPTransport::s_format,
AccessFlags::None).toString();
if (format.equal(PHPTransport::s_collection)) {
auto set_ret = makeSmartPtr<c_Set>();
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(type, transport, elemspec);
if (key.isInteger()) {
set_ret->t_add(key);
} else {
set_ret->t_add(key.toString());
}
}
ret = Variant(std::move(set_ret));
} else {
ArrayInit init(size, ArrayInit::Mixed{});
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(type, transport, elemspec);
if (key.isInteger()) {
init.set(key, true);
} else {
init.setKeyUnconverted(key, true);
}
}
ret = init.toArray();
}
return ret;
}
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
return init_null();
}
static Variant dateImpl(const String& format, int64_t timestamp) {
if (format.empty()) return empty_string_variant();
String ret = DateTime(timestamp, false).toString(format, false);
if (ret.isNull()) return false;
return ret;
}
