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; }