void moduleInit() override { HHVM_ME(MCRouter, __construct); HHVM_NAMED_ME(MCRouter, get, mcr_str<mc_op_get>); HHVM_NAMED_ME(MCRouter, add, mcr_set<mc_op_add>); HHVM_NAMED_ME(MCRouter, set, mcr_set<mc_op_set>); HHVM_NAMED_ME(MCRouter, replace, mcr_set<mc_op_replace>); HHVM_NAMED_ME(MCRouter, prepend, mcr_aprepend<mc_op_prepend>); HHVM_NAMED_ME(MCRouter, append, mcr_aprepend<mc_op_append>); HHVM_NAMED_ME(MCRouter, incr, mcr_str_delta<mc_op_incr>); HHVM_NAMED_ME(MCRouter, decr, mcr_str_delta<mc_op_decr>); HHVM_NAMED_ME(MCRouter, del, mcr_str<mc_op_delete>); HHVM_NAMED_ME(MCRouter, flushAll, mcr_int<mc_op_flushall>); HHVM_NAMED_ME(MCRouter, version, mcr_void<mc_op_version>); Native::registerNativeDataInfo<MCRouter>(s_MCRouter.get()); HHVM_STATIC_ME(MCRouter, getOpName); HHVM_STATIC_ME(MCRouter, getResultName); std::string opname("mc_op_"); for (int i = 0; i < mc_nops; ++i) { std::string name; name = opname + mc_op_to_string((mc_op_t)i); // mcrouter defines op names as foo-bar, // but PHP wants constants like foo_bar for (int j = opname.size(); j < name.size(); ++j) { if (name[j] == '-') { name[j] = '_'; } } Native::registerClassConstant<KindOfInt64>( s_MCRouter.get(), makeStaticString(name), i); } for (int i = 0; i < mc_nres; ++i) { Native::registerClassConstant<KindOfInt64>( s_MCRouter.get(), makeStaticString(mc_res_to_string((mc_res_t)i)), i); } loadSystemlib(); }
Variant MethodStatement::MethInvokerFewArgs(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) { const MethodStatementWrapper *msw = (const MethodStatementWrapper*)mcp.extra; const MethodStatement *ms = msw->m_methodStatement; bool check = !ms->m_name->isame(s___invoke.get()); bool isStatic = ms->getModifiers() & ClassStatement::Static; if (isStatic || !mcp.obj) { String cn; if (UNLIKELY(!isStatic && mcp.isObj && mcp.obj == NULL)) { // this is needed for continuations where // we are passed the dummy object cn = ms->getClass()->name(); } else { cn = mcp.getClassName(); } if (ms->refReturn()) { return strongBind(ms->invokeStaticFewArgs(cn, count, INVOKE_FEW_ARGS_PASS_ARGS, msw, check)); } else { return ms->invokeStaticFewArgs(cn, count, INVOKE_FEW_ARGS_PASS_ARGS, msw, check); } } else { if (ms->refReturn()) { return strongBind(ms->invokeInstanceFewArgs(mcp.rootObj, count, INVOKE_FEW_ARGS_PASS_ARGS, msw, check)); } else { return ms->invokeInstanceFewArgs(mcp.rootObj, count, INVOKE_FEW_ARGS_PASS_ARGS, msw, check); } } }
static Object mcr_getOptionException( const std::vector<mc::McrouterOptionError>& errors) { if (!c_MCRouterOptionException) { c_MCRouterOptionException = Unit::lookupClass(s_MCRouterOptionException.get()); assert(c_MCRouterOptionException); } Array errorArray = Array::Create(); for (auto err : errors) { Array e; e.set(s_option, String(err.requestedName)); e.set(s_value, String(err.requestedValue)); e.set(s_error, String(err.errorMsg)); errorArray.append(e); } auto objdata = ObjectData::newInstance(c_MCRouterOptionException); Object obj(objdata); TypedValue ret; g_context->invokeFunc( &ret, c_MCRouterOptionException->getCtor(), make_packed_array(errorArray), objdata); return obj; }
Variant callStat(const String& path) { static Func* f = SystemLib::s_PharClass->lookupMethod(s_stat.get()); return Variant::attach( g_context->invokeFunc(f, make_packed_array(path), nullptr, SystemLib::s_PharClass) ); }
BucketBrigade::BucketBrigade(const String& data) { PackedArrayInit ai(2); ai.append(data); ai.append(data.length()); auto bucket = g_context->createObject(s_bucket_class.get(), ai.toArray()); appendBucket(Object::attach(bucket)); }
void tvCastToStringInPlace(TypedValue* tv) { assert(tvIsPlausible(*tv)); tvUnboxIfNeeded(tv); StringData* s; do { switch (tv->m_type) { case KindOfUninit: case KindOfNull: s = staticEmptyString(); goto static_string; case KindOfBoolean: s = tv->m_data.num ? s_1.get() : staticEmptyString(); goto static_string; case KindOfInt64: s = buildStringData(tv->m_data.num); continue; case KindOfDouble: s = buildStringData(tv->m_data.dbl); continue; case KindOfStaticString: case KindOfString: return; case KindOfArray: raise_notice("Array to string conversion"); s = array_string.get(); tvDecRefArr(tv); goto static_string; case KindOfObject: // For objects, we fall back on the Variant machinery tvAsVariant(tv) = tv->m_data.pobj->invokeToString(); return; case KindOfResource: // For resources, we fall back on the Variant machinery tvAsVariant(tv) = tv->m_data.pres->o_toString(); return; case KindOfRef: case KindOfClass: break; } not_reached(); } while (0); s->incRefCount(); tv->m_data.pstr = s; tv->m_type = KindOfString; return; static_string: tv->m_data.pstr = s; tv->m_type = KindOfStaticString; }
StringData* tvCastToString(const TypedValue* tv) { assert(tvIsPlausible(*tv)); if (tv->m_type == KindOfRef) { tv = tv->m_data.pref->tv(); } StringData* s; switch (tv->m_type) { case KindOfUninit: case KindOfNull: return staticEmptyString(); case KindOfBoolean: return tv->m_data.num ? s_1.get() : staticEmptyString(); case KindOfInt64: s = buildStringData(tv->m_data.num); break; case KindOfDouble: s = buildStringData(tv->m_data.dbl); break; case KindOfStaticString: return tv->m_data.pstr; case KindOfString: s = tv->m_data.pstr; break; case KindOfArray: raise_notice("Array to string conversion"); return array_string.get(); case KindOfObject: return tv->m_data.pobj->invokeToString().detach(); case KindOfResource: return tv->m_data.pres->o_toString().detach(); default: not_reached(); } s->incRefCount(); return s; }
void chainFaultObjects(ObjectData* top, ObjectData* prev) { while (true) { auto const lookup = top->getProp( top->instanceof(SystemLib::s_ExceptionClass) ? SystemLib::s_ExceptionClass : SystemLib::s_ErrorClass, s_previous.get() ); auto const top_tv = lookup.prop; assert(top_tv != nullptr); assert(top_tv->m_type != KindOfUninit && lookup.accessible); if (top_tv->m_type != KindOfObject || !top_tv->m_data.pobj->instanceof(SystemLib::s_ThrowableClass)) { // Since we are overwriting, decref. tvRefcountedDecRef(top_tv); // Objects held in m_faults are not refcounted, therefore we need to // increase the ref count here. top_tv->m_type = KindOfObject; top_tv->m_data.pobj = prev; prev->incRefCount(); break; } top = top_tv->m_data.pobj; } }
[[noreturn]] static void mcr_throwOptionException( const std::vector<mc::McrouterOptionError>& errors) { if (!c_MCRouterOptionException) { c_MCRouterOptionException = Unit::lookupClass(s_MCRouterOptionException.get()); assert(c_MCRouterOptionException); } Array errorArray = Array::Create(); for (auto err : errors) { Array e; e.set(s_option, String(err.requestedName)); e.set(s_value, String(err.requestedValue)); e.set(s_error, String(err.errorMsg)); errorArray.append(e); } Object obj{c_MCRouterOptionException}; TypedValue ret; g_context->invokeFunc( &ret, c_MCRouterOptionException->getCtor(), make_packed_array(errorArray), obj.get()); throw_object(obj); }
bool objOffsetIsset(TypedValue& tvRef, ObjectData* base, const Variant& offset, bool validate /* = true */) { auto exists = objOffsetExists(base, offset); // Unless we called ArrayObject::offsetExists, there's nothing more to do if (exists != OffsetExistsResult::IssetIfNonNull) { return (int)exists; } // For ArrayObject::offsetExists, we need to check the value at `offset`. // If it's null, then we return false. TypedValue tvResult; tvWriteUninit(&tvResult); // We can't call the offsetGet method on `base` because users aren't // expecting offsetGet to be called for `isset(...)` expressions, so call // the method on the base ArrayObject class. auto const method = SystemLib::s_ArrayObjectClass->lookupMethod(s_offsetGet.get()); assert(method != nullptr); g_context->invokeFuncFew(&tvResult, method, base, nullptr, 1, offset.asCell()); auto const result = !IS_NULL_TYPE(tvResult.m_type); tvRefcountedDecRef(&tvResult); return result; }
void c_Closure::init(int numArgs, ActRec* ar, TypedValue* sp) { auto const invokeFunc = getVMClass()->lookupMethod(s_uuinvoke.get()); m_thisOrClass = ar->m_this; if (ar->hasThis()) { if (invokeFunc->attrs() & AttrStatic) { // Only set the class for static closures. m_thisOrClass = reinterpret_cast<ObjectData*>( reinterpret_cast<intptr_t>(ar->getThis()->getVMClass()) | 1LL ); } else { ar->getThis()->incRefCount(); } } // Change my __invoke's m_cls to be the same as my creator's Class* scope = ar->m_func->cls(); m_func = invokeFunc->cloneAndSetClass(scope); // copy the props to instance variables assert(m_cls->numDeclProperties() == numArgs); TypedValue* beforeCurUseVar = sp + numArgs; TypedValue* curProperty = propVec(); for (int i = 0; i < numArgs; i++) { // teleport the references in here so we don't incref tvCopy(*--beforeCurUseVar, *curProperty++); } }
void c_Closure::init(int numArgs, ActRec* ar, TypedValue* sp) { auto const invokeFunc = getVMClass()->lookupMethod(s_uuinvoke.get()); m_ctx = ar->m_this; if (ar->hasThis()) { if (invokeFunc->isStatic()) { // Only set the class for static closures. setClass(ar->getThis()->getVMClass()); } else { ar->getThis()->incRefCount(); } } /* * Copy the use vars to instance variables, and initialize any * instance properties that are for static locals to KindOfUninit. */ auto const numDeclProperties = getVMClass()->numDeclProperties(); assert(numDeclProperties - numArgs == getInvokeFunc()->numStaticLocals()); TypedValue* beforeCurUseVar = sp + numArgs; TypedValue* curProperty = propVec(); int i = 0; assert(numArgs <= numDeclProperties); for (; i < numArgs; i++) { // teleport the references in here so we don't incref tvCopy(*--beforeCurUseVar, *curProperty++); } for (; i < numDeclProperties; ++i) { tvWriteUninit(curProperty++); } }
void c_Continuation::copyContinuationVars(ActRec* fp) { // For functions that contain only named locals, we can copy TVs // right to the local space. static const StringData* thisStr = s_this.get(); bool skipThis; if (fp->hasVarEnv()) { Stats::inc(Stats::Cont_CreateVerySlow); Array definedVariables = fp->getVarEnv()->getDefinedVariables(); skipThis = definedVariables.exists(s_this, true); for (ArrayIter iter(definedVariables); !iter.end(); iter.next()) { dupContVar(iter.first().getStringData(), const_cast<TypedValue *>(iter.secondRef().asTypedValue())); } } else { const Func *genFunc = actRec()->m_func; skipThis = genFunc->lookupVarId(thisStr) != kInvalidId; for (Id i = 0; i < genFunc->numNamedLocals(); ++i) { dupContVar(genFunc->localVarName(i), frame_local(fp, i)); } } // If $this is used as a local inside the body and is not provided // by our containing environment, just prefill it here instead of // using InitThisLoc inside the body if (!skipThis && fp->hasThis()) { Id id = actRec()->m_func->lookupVarId(thisStr); if (id != kInvalidId) { tvAsVariant(frame_local(actRec(), id)) = fp->getThis(); } } }
Object hippo_mongo_driver_server_create_from_id(mongoc_client_t *client, uint32_t server_id) { static Class* c_server; mongoc_server_description_t *sd; bson_error_t error; c_server = Unit::lookupClass(s_MongoDriverServer_className.get()); Object tmp = Object{c_server}; sd = mongoc_topology_description_server_by_id(&client->topology->description, server_id, &error); if (!sd) { throw MongoDriver::Utils::CreateAndConstruct( MongoDriver::s_MongoDriverExceptionRuntimeException_className, "Failed to get server description, server likely gone: " + HPHP::Variant(error.message).toString(), HPHP::Variant((uint64_t) 0) ); } tmp->o_set(s_MongoDriverServer___serverId, sd->host.host_and_port, s_MongoDriverServer_className); MongoDBDriverServerData* result_data = Native::data<MongoDBDriverServerData>(tmp); result_data->m_client = client; result_data->m_server_id = server_id; return tmp; }
bool TypeConstraint::checkTypeAliasObj(const Class* cls) const { assert(isObject() && m_namedEntity && m_typeName); // Look up the type alias (autoloading if necessary) // and fail if we can't find it auto const td = getTypeAliasWithAutoload(m_namedEntity, m_typeName); if (!td) { return false; } // We found the type alias, check if an object of type cls // is compatible switch (getAnnotMetaType(td->type)) { case AnnotMetaType::Precise: return td->type == AnnotType::Object && td->klass && cls->classof(td->klass); case AnnotMetaType::Mixed: return true; case AnnotMetaType::Callable: return cls->lookupMethod(s___invoke.get()) != nullptr; case AnnotMetaType::Self: case AnnotMetaType::Parent: case AnnotMetaType::Number: case AnnotMetaType::ArrayKey: case AnnotMetaType::Dict: case AnnotMetaType::Vec: // Self and Parent should never happen, because type // aliases are not allowed to use those MetaTypes return false; } not_reached(); }
DEBUG_ONLY bool throwable_has_expected_props() { auto const erCls = SystemLib::s_ErrorClass; auto const exCls = SystemLib::s_ExceptionClass; return erCls->lookupDeclProp(s_previous.get()) == s_previousIdx && exCls->lookupDeclProp(s_previous.get()) == s_previousIdx; }
void chainFaultObjects(ObjectData* top, ObjectData* prev) { static const StaticString nProp("previous"); bool visible, accessible, unset; while (true) { TypedValue* top_tv = top->getProp( SystemLib::s_ExceptionClass, nProp.get(), visible, accessible, unset ); assert(visible && accessible && !unset); if (top_tv->m_type != KindOfObject || !top_tv->m_data.pobj->instanceof( SystemLib::s_ExceptionClass)) { // Since we are overwriting, decref. tvRefcountedDecRef(top_tv); // Objects held in m_faults are not refcounted, therefore // we need to increase the ref count here. top_tv->m_type = KindOfObject; top_tv->m_data.pobj = prev; prev->incRefCount(); break; } top = top_tv->m_data.pobj; } }
void AsioExtension::initRescheduleWaitHandle() { HHVM_STATIC_MALIAS(HH\\RescheduleWaitHandle, create, RescheduleWaitHandle, create); Native::registerClassConstant<KindOfInt64>( s_HH_RescheduleWaitHandle.get(), s_QUEUE_DEFAULT.get(), AsioContext::QUEUE_DEFAULT ); Native::registerClassConstant<KindOfInt64>( s_HH_RescheduleWaitHandle.get(), s_QUEUE_NO_PENDING_IO.get(), AsioContext::QUEUE_NO_PENDING_IO ); }
String c_Continuation::t_getorigfuncname() { const Func* origFunc = actRec()->func()->getGeneratorOrigFunc(); auto const origName = origFunc->isClosureBody() ? s__closure_.get() : origFunc->name(); assert(origName->isStatic()); return String(const_cast<StringData*>(origName)); }
void ZMQExtension::initializeExceptionReferences() { s_ZMQContextClass = NamedEntity::get(s_ZMQContext.get())->clsList(); s_ZMQSocketClass = NamedEntity::get(s_ZMQSocket.get())->clsList(); s_ZMQExceptionClass = NamedEntity::get(s_ZMQException.get())->clsList(); #ifdef HAVE_LIBCZMQ s_ZMQAuthExceptionClass = NamedEntity::get(s_ZMQAuthException.get())->clsList(); s_ZMQCertExceptionClass = NamedEntity::get(s_ZMQCertException.get())->clsList(); #endif s_ZMQContextExceptionClass = NamedEntity::get(s_ZMQContextException.get())->clsList(); s_ZMQSocketExceptionClass = NamedEntity::get(s_ZMQSocketException.get())->clsList(); s_ZMQPollExceptionClass = NamedEntity::get(s_ZMQPollException.get())->clsList(); s_ZMQDeviceExceptionClass = NamedEntity::get(s_ZMQDeviceException.get())->clsList(); }
StringData* convCellToStrHelper(TypedValue tv) { switch (tv.m_type) { case KindOfUninit: case KindOfNull: return s_empty.get(); case KindOfBoolean: return tv.m_data.num ? s_1.get() : s_empty.get(); case KindOfInt64: return convIntToStrHelper(tv.m_data.num); case KindOfDouble: return convDblToStrHelper(tv.m_data.num); case KindOfStaticString: case KindOfString: // No incref, since there is also a logical decref of // our argument. return tv.m_data.pstr; case KindOfArray: tvDecRefArr(&tv); return s_Array.get(); case KindOfObject: return convObjToStrHelper(tv.m_data.pobj); case KindOfResource: return convResToStrHelper(tv.m_data.pres); default: not_reached(); } }
StringData* convCellToStrHelper(TypedValue tv) { switch (tv.m_type) { case KindOfUninit: case KindOfNull: return s_empty.get(); case KindOfBoolean: return tv.m_data.num ? s_1.get() : s_empty.get(); case KindOfInt64: return convIntToStrHelper(tv.m_data.num); case KindOfDouble: return convDblToStrHelper(tv.m_data.num); case KindOfString: tv.m_data.pstr->incRefCount(); /* fallthrough */ case KindOfStaticString: return tv.m_data.pstr; case KindOfArray: return s_Array.get(); case KindOfObject: return convObjToStrHelper(tv.m_data.pobj); case KindOfResource: return convResToStrHelper(tv.m_data.pres); default: not_reached(); } }
String HHVM_METHOD(Generator, getOrigFuncName) { Generator* gen = Native::data<Generator>(this_); const Func* origFunc = gen->actRec()->func(); auto const origName = origFunc->isClosureBody() ? s__closure_.get() : origFunc->name(); assert(origName->isStatic()); return String(const_cast<StringData*>(origName)); }
void IntlExtension::initLocale() { HHVM_STATIC_ME(Locale, acceptFromHttp); HHVM_STATIC_ME(Locale, canonicalize); HHVM_STATIC_ME(Locale, composeLocale); HHVM_STATIC_ME(Locale, getAllVariants); HHVM_STATIC_ME(Locale, getDefault); HHVM_STATIC_ME(Locale, getDisplayLanguage); HHVM_STATIC_ME(Locale, getDisplayName); HHVM_STATIC_ME(Locale, getDisplayRegion); HHVM_STATIC_ME(Locale, getDisplayScript); HHVM_STATIC_ME(Locale, getDisplayVariant); HHVM_STATIC_ME(Locale, getKeywords); HHVM_STATIC_ME(Locale, getPrimaryLanguage); HHVM_STATIC_ME(Locale, getRegion); HHVM_STATIC_ME(Locale, getScript); HHVM_STATIC_ME(Locale, lookup); HHVM_STATIC_ME(Locale, parseLocale); HHVM_STATIC_ME(Locale, setDefault); #define ULOC_CONST(nm,val) Native::registerClassConstant<KindOfStaticString>\ (s_Locale.get(), s_##nm.get(), s_##val.get()) Native::registerClassConstant<KindOfNull>(s_Locale.get(), s_DEFAULT_LOCALE.get()); ULOC_CONST(LANG_TAG, LOC_LANG); ULOC_CONST(EXTLANG_TAG, LOC_EXTLANG); ULOC_CONST(SCRIPT_TAG, LOC_SCRIPT); ULOC_CONST(REGION_TAG, LOC_REGION); ULOC_CONST(VARIANT_TAG, LOC_VARIANT); ULOC_CONST(GRANDFATHERED_LANG_TAG, GRANDFATHERED); ULOC_CONST(PRIVATE_TAG, LOC_PRIVATE); #undef ULOC_CONST #define ULOC_LOCALE_CONST(cns) \ Native::registerConstant<KindOfInt64>\ (makeStaticString("ULOC_" #cns), ULOC_##cns); \ Native::registerClassConstant<KindOfInt64>\ (s_Locale.get(), makeStaticString(#cns), ULOC_##cns); ULOC_LOCALE_CONST(ACTUAL_LOCALE); ULOC_LOCALE_CONST(VALID_LOCALE); #undef ULOC_LOCALE_CONST loadSystemlib("icu_locale"); }
void IntlExtension::initTransliterator() { HHVM_ME(Transliterator, __init); HHVM_ME(Transliterator, __createInverse); HHVM_ME(Transliterator, getErrorCode); HHVM_ME(Transliterator, getErrorMessage); HHVM_ME(Transliterator, getId); HHVM_STATIC_ME(Transliterator, listIDs); HHVM_ME(Transliterator, transliterate); Native::registerClassConstant<KindOfInt64> (s_Transliterator.get(), s_FORWARD.get(), UTRANS_FORWARD); Native::registerClassConstant<KindOfInt64> (s_Transliterator.get(), s_REVERSE.get(), UTRANS_REVERSE); Native::registerNativeDataInfo<Transliterator>(s_Transliterator.get()); loadSystemlib("icu_transliterator"); }
void StandardExtension::initClosure() { c_Closure::cls_Closure = Unit::lookupClass(s_Closure.get()); assertx(c_Closure::cls_Closure); c_Closure::cls_Closure->allocExtraData(); c_Closure::cls_Closure->m_extra.raw()->m_instanceCtor = RuntimeOption::RepoAuthoritative ? closureInstanceCtorRepoAuth : closureInstanceCtor; c_Closure::cls_Closure->m_extra.raw()->m_instanceDtor = closureInstanceDtor; }
void IntlExtension::initUcsDet() { HHVM_ME(EncodingDetector, setText); HHVM_ME(EncodingDetector, setDeclaredEncoding); HHVM_ME(EncodingDetector, detect); HHVM_ME(EncodingDetector, detectAll); HHVM_ME(EncodingMatch, isValid); HHVM_ME(EncodingMatch, getEncoding); HHVM_ME(EncodingMatch, getConfidence); HHVM_ME(EncodingMatch, getLanguage); HHVM_ME(EncodingMatch, getUTF8); Native::registerNativeDataInfo<EncodingDetector>(s_EncodingDetector.get()); Native::registerNativeDataInfo<EncodingMatch>(s_EncodingMatch.get()); loadSystemlib("icu_ucsdet"); }
void moduleInit() override { xsltSetGenericErrorFunc(nullptr, xslt_ext_error_handler); exsltRegisterAll(); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_NONE.get(), k_XSL_SECPREF_NONE ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_READ_FILE.get(), k_XSL_SECPREF_READ_FILE ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_WRITE_FILE.get(), k_XSL_SECPREF_WRITE_FILE ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_CREATE_DIRECTORY.get(), k_XSL_SECPREF_CREATE_DIRECTORY ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_READ_NETWORK.get(), k_XSL_SECPREF_READ_NETWORK ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_WRITE_NETWORK.get(), k_XSL_SECPREF_WRITE_NETWORK ); Native::registerConstant<KindOfInt64>( s_XSL_SECPREF_DEFAULT.get(), k_XSL_SECPREF_DEFAULT ); Native::registerConstant<KindOfInt64>( s_xslt_version.get(), LIBXSLT_VERSION ); Native::registerConstant<KindOfString>( s_xslt_dotted_version.get(), s_xslt_dotted_version_value.get() ); HHVM_ME(XSLTProcessor, getParameter); HHVM_ME(XSLTProcessor, getSecurityPrefs); HHVM_ME(XSLTProcessor, importStylesheet); HHVM_ME(XSLTProcessor, removeParameter); HHVM_ME(XSLTProcessor, registerPHPFunctions); HHVM_ME(XSLTProcessor, setParameter); HHVM_ME(XSLTProcessor, setSecurityPrefs); HHVM_ME(XSLTProcessor, setProfiling); HHVM_ME(XSLTProcessor, transformToDoc); HHVM_ME(XSLTProcessor, transformToURI); HHVM_ME(XSLTProcessor, transformToXML); Native:: registerNativeDataInfo<XSLTProcessorData>(s_XSLTProcessorData.get()); loadSystemlib(); }
void moduleInit() override { HHVM_RCC_INT(XMLReader, NONE, XML_READER_TYPE_NONE); HHVM_RCC_INT(XMLReader, ELEMENT, XML_READER_TYPE_ELEMENT); HHVM_RCC_INT(XMLReader, ATTRIBUTE, XML_READER_TYPE_ATTRIBUTE); HHVM_RCC_INT(XMLReader, TEXT, XML_READER_TYPE_TEXT); HHVM_RCC_INT(XMLReader, CDATA, XML_READER_TYPE_CDATA); HHVM_RCC_INT(XMLReader, ENTITY_REF, XML_READER_TYPE_ENTITY_REFERENCE); HHVM_RCC_INT(XMLReader, ENTITY, XML_READER_TYPE_ENTITY); HHVM_RCC_INT(XMLReader, PI, XML_READER_TYPE_PROCESSING_INSTRUCTION); HHVM_RCC_INT(XMLReader, COMMENT, XML_READER_TYPE_COMMENT); HHVM_RCC_INT(XMLReader, DOC, XML_READER_TYPE_DOCUMENT); HHVM_RCC_INT(XMLReader, DOC_TYPE, XML_READER_TYPE_DOCUMENT_TYPE); HHVM_RCC_INT(XMLReader, DOC_FRAGMENT, XML_READER_TYPE_DOCUMENT_FRAGMENT); HHVM_RCC_INT(XMLReader, NOTATION, XML_READER_TYPE_NOTATION); HHVM_RCC_INT(XMLReader, WHITESPACE, XML_READER_TYPE_WHITESPACE); HHVM_RCC_INT(XMLReader, SIGNIFICANT_WHITESPACE, XML_READER_TYPE_SIGNIFICANT_WHITESPACE); HHVM_RCC_INT(XMLReader, END_ELEMENT, XML_READER_TYPE_END_ELEMENT); HHVM_RCC_INT(XMLReader, END_ENTITY, XML_READER_TYPE_END_ENTITY); HHVM_RCC_INT(XMLReader, XML_DECLARATION, XML_READER_TYPE_XML_DECLARATION); HHVM_RCC_INT(XMLReader, LOADDTD, XML_PARSER_LOADDTD); HHVM_RCC_INT(XMLReader, DEFAULTATTRS, XML_PARSER_DEFAULTATTRS); HHVM_RCC_INT(XMLReader, VALIDATE, XML_PARSER_VALIDATE); HHVM_RCC_INT(XMLReader, SUBST_ENTITIES, XML_PARSER_SUBST_ENTITIES); HHVM_ME(XMLReader, open); HHVM_ME(XMLReader, XML); HHVM_ME(XMLReader, close); HHVM_ME(XMLReader, read); HHVM_ME(XMLReader, next); HHVM_ME(XMLReader, readString); HHVM_ME(XMLReader, readInnerXML); HHVM_ME(XMLReader, readOuterXML); HHVM_ME(XMLReader, moveToNextAttribute); HHVM_ME(XMLReader, getAttribute); HHVM_ME(XMLReader, getAttributeNo); HHVM_ME(XMLReader, getAttributeNs); HHVM_ME(XMLReader, moveToAttribute); HHVM_ME(XMLReader, moveToAttributeNo); HHVM_ME(XMLReader, moveToAttributeNs); HHVM_ME(XMLReader, moveToElement); HHVM_ME(XMLReader, moveToFirstAttribute); HHVM_ME(XMLReader, isValid); HHVM_ME(XMLReader, __get); HHVM_ME(XMLReader, getParserProperty); HHVM_ME(XMLReader, lookupNamespace); HHVM_ME(XMLReader, setSchema); HHVM_ME(XMLReader, setParserProperty); HHVM_ME(XMLReader, setRelaxNGSchema); HHVM_ME(XMLReader, setRelaxNGSchemaSource); HHVM_ME(XMLReader, expand); Native::registerNativeDataInfo<XMLReader>(s_XMLReader.get()); loadSystemlib(); }
void HHVM_FUNCTION(set_frame_metadata, const Variant& metadata) { VMRegAnchor _; auto fp = vmfp(); if (fp && fp->skipFrame()) fp = g_context->getPrevVMState(fp); if (UNLIKELY(!fp)) return; if (LIKELY(!(fp->func()->attrs() & AttrMayUseVV)) || LIKELY(!fp->hasVarEnv())) { auto const local = fp->func()->lookupVarId(s_86metadata.get()); if (LIKELY(local != kInvalidId)) { cellSet(*metadata.asCell(), *tvAssertCell(frame_local(fp, local))); } else { SystemLib::throwInvalidArgumentExceptionObject( "Unsupported dynamic call of set_frame_metadata()"); } } else { fp->getVarEnv()->set(s_86metadata.get(), metadata.asTypedValue()); } }