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