void HHVM_METHOD(DateTime, __wakeup) { Object dtz_obj{DateTimeZoneData::getClass()}; HHVM_MN(DateTimeZone, __construct)(dtz_obj.get(), this_->o_get(s_timezone).toString()); HHVM_MN(DateTime, __construct)(this_, this_->o_get(s_date).toString(), std::move(dtz_obj)); // cleanup Class* cls = this_->getVMClass(); this_->unsetProp(cls, s_date.get()); this_->unsetProp(cls, s_timezone_type.get()); this_->unsetProp(cls, s_timezone.get()); }
void HHVM_METHOD(DateTime, __wakeup) { ObjectData* dtz_obj = ObjectData::newInstance(DateTimeZoneData::getClass()); HHVM_MN(DateTimeZone, __construct)(dtz_obj, this_->o_get(s_timezone).toString()); HHVM_MN(DateTime, __construct)(this_, this_->o_get(s_date).toString(), Object(dtz_obj)); // cleanup Class* cls = this_->getVMClass(); this_->unsetProp(cls, s_date.get()); this_->unsetProp(cls, s_timezone_type.get()); this_->unsetProp(cls, s_timezone.get()); }
Variant HHVM_METHOD(SQLite3, query, const String& sql) { auto *data = Native::data<SQLite3>(this_); SYNC_VM_REGS_SCOPED(); data->validate(); if (!sql.empty()) { Variant stmt = HHVM_MN(SQLite3, prepare)(this_, sql); if (!same(stmt, false)) { Object obj_stmt = stmt.toObject(); assert(obj_stmt.instanceof(SQLite3Stmt::getClass())); return HHVM_MN(SQLite3Stmt, execute)(obj_stmt.get()); } } return false; }
void HHVM_METHOD(SQLite3, __construct, const String& filename, int64_t flags /* = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE */, const Variant& encryption_key /* = null */) { HHVM_MN(SQLite3, open)(this_, filename, flags, encryption_key); }
Variant HHVM_FUNCTION(date_create, const Variant& time /* = null_string */, const Variant& timezone /* = uninit_variant */) { const String& str_time = time.isNull() ? null_string : time.toString(); auto tz = TimeZone::Current(); if (!timezone.isNull()) { const Object& obj_timezone = timezone.toObject(); if (!obj_timezone.instanceof(s_DateTimeZone)) { raise_argument_warning("date_create", 2, s_DateTimeZone, obj_timezone); return false; } tz = DateTimeZoneData::unwrap(obj_timezone); } Object ret{DateTimeData::getClass()}; // Don't set the time here because it will throw if it is bad HHVM_MN(DateTime, __construct)(ret.get()); if (str_time.empty()) { // zend does this, so so do we return ret; } auto dt = DateTimeData::unwrap(ret); if (!dt->fromString(str_time, tz, nullptr, false)) { return false; } return ret; }
Variant HHVM_METHOD(SQLite3, prepare, const String& sql) { auto *data = Native::data<SQLite3>(this_); data->validate(); if (!sql.empty()) { Object ret{SQLite3Stmt::getClass()}; SQLite3Stmt *stmt = Native::data<SQLite3Stmt>(ret); HHVM_MN(SQLite3Stmt, __construct)(ret.get(), this_, sql); if (stmt->m_raw_stmt) { return ret; } } return false; }
bool HHVM_FUNCTION(cancel, const Object& obj, const Object& exception) { if (!obj->instanceof(c_WaitHandle::classof())) { SystemLib::throwInvalidArgumentExceptionObject( "Cancellation unsupported for user-land Awaitable"); } auto handle = wait_handle<c_WaitHandle>(obj.get()); switch(handle->getKind()) { case c_WaitHandle::Kind::ExternalThreadEvent: return handle->asExternalThreadEvent()->cancel(exception); case c_WaitHandle::Kind::Sleep: return handle->asSleep()->cancel(exception); default: SystemLib::throwInvalidArgumentExceptionObject( "Cancellation unsupported for " + HHVM_MN(WaitHandle, getName) (handle) ); } }
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) ); }
Variant HHVM_FUNCTION(date_create, const Variant& time /* = null_string */, const Variant& timezone /* = null_variant */) { const String& str_time = time.isNull() ? null_string : time.toString(); const Object& obj_timezone = timezone.isNull() ? null_object : timezone.toObject(); ObjectData* obj = ObjectData::newInstance(DateTimeData::getClass()); Object ret(obj); // Don't set the time here because it will throw if it is bad HHVM_MN(DateTime, __construct)(obj); if (str_time.empty()) { // zend does this, so so do we return ret; } auto dt = DateTimeData::unwrap(ret); auto tz = DateTimeZoneData::unwrap(obj_timezone); if (!dt->fromString(str_time, tz, nullptr, false)) { return false; } return ret; }
Variant HHVM_METHOD(SQLite3, querysingle, const String& sql, bool entire_row /* = false */) { auto *data = Native::data<SQLite3>(this_); SYNC_VM_REGS_SCOPED(); data->validate(); if (!sql.empty()) { Variant stmt = HHVM_MN(SQLite3, prepare)(this_, sql); if (!same(stmt, false)) { Object obj_stmt = stmt.toObject(); assert(obj_stmt.instanceof(SQLite3Stmt::getClass())); sqlite3_stmt *pstmt = Native::data<SQLite3Stmt>(obj_stmt)->m_raw_stmt; switch (sqlite3_step(pstmt)) { case SQLITE_ROW: /* Valid Row */ if (entire_row) { Array ret = Array::Create(); for (int i = 0; i < sqlite3_data_count(pstmt); i++) { ret.set(String((char*)sqlite3_column_name(pstmt, i), CopyString), get_column_value(pstmt, i)); } return ret; } return get_column_value(pstmt, 0); case SQLITE_DONE: /* Valid but no results */ if (entire_row) { return empty_array(); } else { return init_null(); } default: raise_warning("Unable to execute statement: %s", sqlite3_errmsg(data->m_raw_db)); } } } return false; }
static bool HHVM_METHOD(ImagickDraw, destroy) { return HHVM_MN(ImagickDraw, clear)(this_); }
Variant HHVM_METHOD(MongoDBDriverReadPreference, bsonSerialize) { Array retval = HHVM_MN(MongoDBDriverReadPreference, __debugInfo)(this_); return Variant(Variant(retval).toObject()); }