/**
* @brief Learn the Q values from the workspace, if possible, and update
* attribute Q accordingly.
* @param workspace Matrix workspace
* @param wi selected spectrum to initialize attributes
* @param startX unused
* @param endX unused
*/
void FunctionQDepends::setMatrixWorkspace(
boost::shared_ptr<const Mantid::API::MatrixWorkspace> workspace, size_t wi,
double startX, double endX) {
UNUSED_ARG(startX);
UNUSED_ARG(endX);
// reset attributes if new workspace is passed
if (!m_vQ.empty()) {
Mantid::API::IFunction::setAttribute("WorkspaceIndex", Attr(EMPTY_INT()));
Mantid::API::IFunction::setAttribute("Q", Attr(EMPTY_DBL()));
}
// Obtain Q values from the passed workspace, if possible. m_vQ will be
// cleared if unsuccessful.
if (workspace) {
m_vQ = this->extractQValues(*workspace);
}
if (!m_vQ.empty()) {
this->setAttribute("WorkspaceIndex", Attr(static_cast<int>(wi)));
}
}
void FuncEmitter::setBuiltinFunc(const ClassInfo::MethodInfo* info,
BuiltinFunction bif, BuiltinFunction nif,
Offset base) {
ASSERT(info);
ASSERT(bif);
m_info = info;
m_builtinFuncPtr = bif;
m_nativeFuncPtr = nif;
m_base = base;
m_top = true;
m_docComment = StringData::GetStaticString(info->docComment);
m_line1 = 0;
m_line2 = 0;
m_attrs = AttrNone;
// TODO: Task #1137917: See if we can avoid marking most builtins with
// "MayUseVV" and still make things work
m_attrs = (Attr)(m_attrs | AttrMayUseVV);
if (info->attribute & (ClassInfo::RefVariableArguments |
ClassInfo::MixedVariableArguments)) {
m_attrs = Attr(m_attrs | AttrVariadicByRef);
}
if (info->attribute & ClassInfo::IsReference) {
m_attrs = (Attr)(m_attrs | AttrReference);
}
if (info->attribute & ClassInfo::NoInjection) {
m_attrs = (Attr)(m_attrs | AttrNoInjection);
}
if (pce()) {
if (info->attribute & ClassInfo::IsStatic) {
m_attrs = (Attr)(m_attrs | AttrStatic);
}
if (info->attribute & ClassInfo::IsFinal) {
m_attrs = (Attr)(m_attrs | AttrFinal);
}
if (info->attribute & ClassInfo::IsAbstract) {
m_attrs = (Attr)(m_attrs | AttrAbstract);
}
if (info->attribute & ClassInfo::IsPrivate) {
m_attrs = (Attr)(m_attrs | AttrPrivate);
} else if (info->attribute & ClassInfo::IsProtected) {
m_attrs = (Attr)(m_attrs | AttrProtected);
} else {
m_attrs = (Attr)(m_attrs | AttrPublic);
}
}
m_returnType = info->returnType;
for (unsigned i = 0; i < info->parameters.size(); ++i) {
// For builtin only, we use a dummy ParamInfo
FuncEmitter::ParamInfo pi;
pi.setRef((bool)(info->parameters[i]->attribute & ClassInfo::IsReference));
pi.setBuiltinType(info->parameters[i]->argType);
appendParam(StringData::GetStaticString(info->parameters[i]->name), pi);
}
}
PreClass* PreClassEmitter::create(Unit& unit) const {
Attr attrs = m_attrs;
if (attrs & AttrPersistent &&
!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) {
attrs = Attr(attrs & ~AttrPersistent);
}
PreClass* pc = new PreClass(&unit, m_line1, m_line2, m_offset, m_name,
attrs, m_parent, m_docComment, m_id,
m_hoistable);
pc->m_InstanceCtor = m_InstanceCtor;
pc->m_builtinPropSize = m_builtinPropSize;
pc->m_interfaces = m_interfaces;
pc->m_usedTraits = m_usedTraits;
pc->m_traitPrecRules = m_traitPrecRules;
pc->m_traitAliasRules = m_traitAliasRules;
pc->m_userAttributes = m_userAttributes;
PreClass::MethodMap::Builder methodBuild;
for (MethodVec::const_iterator it = m_methods.begin();
it != m_methods.end(); ++it) {
Func* f = (*it)->create(unit, pc);
methodBuild.add(f->name(), f);
}
pc->m_methods.create(methodBuild);
PreClass::PropMap::Builder propBuild;
for (unsigned i = 0; i < m_propMap.size(); ++i) {
const Prop& prop = m_propMap[i];
propBuild.add(prop.name(), PreClass::Prop(pc,
prop.name(),
prop.attrs(),
prop.typeConstraint(),
prop.docComment(),
prop.val(),
prop.hphpcType()));
}
pc->m_properties.create(propBuild);
PreClass::ConstMap::Builder constBuild;
for (unsigned i = 0; i < m_constMap.size(); ++i) {
const Const& const_ = m_constMap[i];
constBuild.add(const_.name(), PreClass::Const(pc,
const_.name(),
const_.typeConstraint(),
const_.val(),
const_.phpCode()));
}
pc->m_constants.create(constBuild);
return pc;
}
XmlTree& XmlTree::setAttribute( const std::string &attrName, const std::string &value )
{
list<Attr>::iterator atIt;
for( atIt = mAttributes.begin(); atIt != mAttributes.end(); ++atIt )
if( atIt->getName() == attrName )
break;
if( atIt == mAttributes.end() )
mAttributes.push_back( Attr( this, attrName, value ) );
else
atIt->setValue( value );
return *this;
}
Obj_space_virt<SPACE>::v_lookup(V_pfn const &virt, Phys_addr *phys,
Page_order *size, Attr *attribs)
{
if (size) *size = Order(0);
Entry *cap;
if (Optimize_local
&& SPACE::mem_space(this) == Mem_space::current_mem_space(current_cpu()))
cap = cap_virt(virt);
else
cap = get_cap(virt);
if (EXPECT_FALSE(!cap))
{
if (size) *size = Order(Obj::Caps_per_page_ld2);
return false;
}
if (Optimize_local)
{
Capability c = Mem_layout::read_special_safe((Capability*)cap);
if (phys) *phys = c.obj();
if (c.valid() && attribs)
*attribs = Attr(c.rights());
return c.valid();
}
else
{
Obj::set_entry(virt, cap);
if (phys) *phys = cap->obj();
if (cap->valid() && attribs)
*attribs = Attr(cap->rights());
return cap->valid();
}
}
void Func::setFullName() {
ASSERT(m_name->isStatic());
if (m_cls) {
m_fullName = StringData::GetStaticString(
std::string(m_cls->name()->data()) + "::" + m_name->data());
} else {
m_fullName = m_name;
m_namedEntity = Unit::GetNamedEntity(m_name);
}
if (RuntimeOption::DynamicInvokeFunctions.size()) {
if (RuntimeOption::DynamicInvokeFunctions.find(m_fullName->data()) !=
RuntimeOption::DynamicInvokeFunctions.end()) {
m_attrs = Attr(m_attrs | AttrDynamicInvoke);
}
}
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
Attr attrs = m_attrs;
if (attrs & AttrPersistent &&
(RuntimeOption::EvalJitEnableRenameFunction ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited))) {
attrs = Attr(attrs & ~AttrPersistent);
}
Func* f = (m_pce == NULL)
? m_ue.newFunc(this, unit, m_id, m_line1, m_line2, m_base,
m_past, m_name, attrs, m_top, m_docComment,
m_params.size())
: m_ue.newFunc(this, unit, preClass, m_line1, m_line2, m_base,
m_past, m_name, attrs, m_top, m_docComment,
m_params.size());
f->shared()->m_info = m_info;
f->shared()->m_returnType = m_returnType;
std::vector<Func::ParamInfo> pBuilder;
for (unsigned i = 0; i < m_params.size(); ++i) {
Func::ParamInfo pi;
pi.setFuncletOff(m_params[i].funcletOff());
pi.setDefaultValue(m_params[i].defaultValue());
pi.setPhpCode(m_params[i].phpCode());
pi.setTypeConstraint(m_params[i].typeConstraint());
pi.setUserAttributes(m_params[i].userAttributes());
pi.setBuiltinType(m_params[i].builtinType());
f->appendParam(m_params[i].ref(), pi, pBuilder);
}
f->shared()->m_params = pBuilder;
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = m_maxStackCells;
ASSERT(m_maxStackCells > 0 && "You probably didn't set m_maxStackCells");
f->shared()->m_staticVars = m_staticVars;
f->shared()->m_ehtab = m_ehtab;
f->shared()->m_fpitab = m_fpitab;
f->shared()->m_isClosureBody = m_isClosureBody;
f->shared()->m_isGenerator = m_isGenerator;
f->shared()->m_isGeneratorFromClosure = m_isGeneratorFromClosure;
f->shared()->m_userAttributes = m_userAttributes;
f->shared()->m_builtinFuncPtr = m_builtinFuncPtr;
f->shared()->m_nativeFuncPtr = m_nativeFuncPtr;
return f;
}
virtual IHqlExpression * loadSymbol(IAtom * modname, IAtom * attrname)
{
IHqlExpression * symbol=RemoteXmlEclRepository::loadSymbol(modname, attrname);
if(symbol)
{
if(attributes.insert(Attr(modname,attrname,0)).second)
{
StringBuffer name, buf;
name.append("Dependency").append((size32_t) attributes.size());
buf.append("<Attribute module=\"").append(*modname).append("\"");
if(attrname)
buf.append(" name=\"").append(*attrname).append("\"");
buf.append(" flags=\"").append(symbol->getObType()).append("\"/>");
workunit->setApplicationValue("SyntaxCheck",name.str(),buf.str(),true);
}
}
return symbol;
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
bool isGenerated = isdigit(name->data()[0]) ||
ParserBase::IsClosureName(name->toCppString());
Attr attrs = this->attrs;
if (preClass && preClass->attrs() & AttrInterface) {
attrs |= AttrAbstract;
}
if (attrs & AttrPersistent &&
((RuntimeOption::EvalJitEnableRenameFunction && !isGenerated) ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) ||
attrs & AttrInterceptable)) {
if (attrs & AttrBuiltin) {
SystemLib::s_anyNonPersistentBuiltins = true;
}
attrs = Attr(attrs & ~AttrPersistent);
}
if (RuntimeOption::EvalJitEnableRenameFunction &&
!name->empty() &&
!Func::isSpecial(name) &&
!isClosureBody) {
// intercepted functions need to pass all args through
// to the interceptee
attrs |= AttrMayUseVV;
}
if (isVariadic()) { attrs |= AttrVariadicParam; }
if (!containsCalls) { attrs |= AttrPhpLeafFn; }
assert(!m_pce == !preClass);
Func* f = m_ue.newFunc(this, unit, preClass, line1, line2, base,
past, name, attrs, top, docComment,
params.size(), isClosureBody);
f->shared()->m_info = m_info;
f->shared()->m_returnType = returnType;
std::vector<Func::ParamInfo> fParams;
for (unsigned i = 0; i < params.size(); ++i) {
Func::ParamInfo pi = params[i];
f->appendParam(params[i].byRef, pi, fParams);
}
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = maxStackCells;
f->shared()->m_staticVars = staticVars;
f->shared()->m_ehtab = ehtab;
f->shared()->m_fpitab = fpitab;
f->shared()->m_isClosureBody = isClosureBody;
f->shared()->m_isAsync = isAsync;
f->shared()->m_isGenerator = isGenerator;
f->shared()->m_isPairGenerator = isPairGenerator;
f->shared()->m_userAttributes = userAttributes;
f->shared()->m_builtinFuncPtr = m_builtinFuncPtr;
f->shared()->m_nativeFuncPtr = m_nativeFuncPtr;
f->shared()->m_retTypeConstraint = retTypeConstraint;
f->shared()->m_retUserType = retUserType;
f->shared()->m_originalFilename = originalFilename;
f->shared()->m_isGenerated = isGenerated;
f->finishedEmittingParams(fParams);
if (attrs & AttrNative) {
auto nif = Native::GetBuiltinFunction(name,
m_pce ? m_pce->name() : nullptr,
f->isStatic());
if (nif) {
Attr dummy = AttrNone;
int nativeAttrs = parseNativeAttributes(dummy);
if (nativeAttrs & Native::AttrZendCompat) {
f->shared()->m_nativeFuncPtr = nif;
f->shared()->m_builtinFuncPtr = zend_wrap_func;
} else {
if (parseNativeAttributes(dummy) & Native::AttrActRec) {
f->shared()->m_builtinFuncPtr = nif;
f->shared()->m_nativeFuncPtr = nullptr;
} else {
f->shared()->m_nativeFuncPtr = nif;
f->shared()->m_builtinFuncPtr = m_pce ? Native::methodWrapper
: Native::functionWrapper;
}
}
} else {
f->shared()->m_builtinFuncPtr = Native::unimplementedWrapper;
}
}
return f;
}
PreClass* PreClassEmitter::create(Unit& unit) const {
Attr attrs = m_attrs;
if (attrs & AttrPersistent &&
!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) {
attrs = Attr(attrs & ~AttrPersistent);
}
auto pc = folly::make_unique<PreClass>(
&unit, m_line1, m_line2, m_offset, m_name,
attrs, m_parent, m_docComment, m_id,
m_hoistable);
pc->m_instanceCtor = m_instanceCtor;
pc->m_instanceDtor = m_instanceDtor;
pc->m_builtinObjSize = m_builtinObjSize;
pc->m_builtinODOffset = m_builtinODOffset;
pc->m_interfaces = m_interfaces;
pc->m_usedTraits = m_usedTraits;
pc->m_traitRequirements = m_traitRequirements;
pc->m_traitPrecRules = m_traitPrecRules;
pc->m_traitAliasRules = m_traitAliasRules;
pc->m_userAttributes = m_userAttributes;
PreClass::MethodMap::Builder methodBuild;
for (MethodVec::const_iterator it = m_methods.begin();
it != m_methods.end(); ++it) {
Func* f = (*it)->create(unit, pc.get());
methodBuild.add(f->name(), f);
}
pc->m_methods.create(methodBuild);
PreClass::PropMap::Builder propBuild;
for (unsigned i = 0; i < m_propMap.size(); ++i) {
const Prop& prop = m_propMap[i];
propBuild.add(prop.name(), PreClass::Prop(pc.get(),
prop.name(),
prop.attrs(),
prop.typeConstraint(),
prop.docComment(),
prop.val(),
prop.hphpcType()));
}
pc->m_properties.create(propBuild);
PreClass::ConstMap::Builder constBuild;
for (unsigned i = 0; i < m_constMap.size(); ++i) {
const Const& const_ = m_constMap[i];
constBuild.add(const_.name(), PreClass::Const(pc.get(),
const_.name(),
const_.typeConstraint(),
const_.val(),
const_.phpCode()));
}
if (auto nativeConsts = Native::getClassConstants(m_name)) {
for (auto cnsMap : *nativeConsts) {
auto tv = cnsMap.second;
constBuild.add(cnsMap.first, PreClass::Const(pc.get(),
cnsMap.first,
empty_string.get(),
tv,
empty_string.get()));
}
}
pc->m_constants.create(constBuild);
return pc.release();
}
PreClass* PreClassEmitter::create(Unit& unit) const {
Attr attrs = m_attrs;
if (attrs & AttrPersistent &&
!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) {
attrs = Attr(attrs & ~AttrPersistent);
}
auto pc = folly::make_unique<PreClass>(
&unit, m_line1, m_line2, m_offset, m_name,
attrs, m_parent, m_docComment, m_id,
m_hoistable);
pc->m_instanceCtor = m_instanceCtor;
pc->m_instanceDtor = m_instanceDtor;
pc->m_builtinObjSize = m_builtinObjSize;
pc->m_builtinODOffset = m_builtinODOffset;
pc->m_interfaces = m_interfaces;
pc->m_usedTraits = m_usedTraits;
pc->m_requirements = m_requirements;
pc->m_traitPrecRules = m_traitPrecRules;
pc->m_traitAliasRules = m_traitAliasRules;
pc->m_enumBaseTy = m_enumBaseTy;
// Set user attributes.
[&] {
pc->m_userAttributes = m_userAttributes;
pc->m_nativeDataInfo = nullptr;
if (!m_userAttributes.size()) return;
// Check for <<__NativeData("Type")>>.
auto it = m_userAttributes.find(s_nativedata.get());
if (it == m_userAttributes.end()) return;
TypedValue ndiInfo = it->second;
if (ndiInfo.m_type != KindOfArray) return;
// Use the first string label which references a registered type. In
// practice, there should generally only be one item and it should be a
// string, but maybe that'll be extended...
for (ArrayIter it(ndiInfo.m_data.parr); it; ++it) {
Variant val = it.second();
if (!val.isString()) continue;
pc->m_nativeDataInfo = Native::getNativeDataInfo(val.toString().get());
if (pc->m_nativeDataInfo) break;
}
}();
PreClass::MethodMap::Builder methodBuild;
for (MethodVec::const_iterator it = m_methods.begin();
it != m_methods.end(); ++it) {
Func* f = (*it)->create(unit, pc.get());
methodBuild.add(f->name(), f);
}
pc->m_methods.create(methodBuild);
PreClass::PropMap::Builder propBuild;
for (unsigned i = 0; i < m_propMap.size(); ++i) {
const Prop& prop = m_propMap[i];
propBuild.add(prop.name(), PreClass::Prop(pc.get(),
prop.name(),
prop.attrs(),
prop.typeConstraint(),
prop.docComment(),
prop.val(),
prop.repoAuthType()));
}
pc->m_properties.create(propBuild);
PreClass::ConstMap::Builder constBuild;
for (unsigned i = 0; i < m_constMap.size(); ++i) {
const Const& const_ = m_constMap[i];
constBuild.add(const_.name(), PreClass::Const(pc.get(),
const_.name(),
const_.typeConstraint(),
const_.val(),
const_.phpCode()));
}
if (auto nativeConsts = Native::getClassConstants(m_name)) {
for (auto cnsMap : *nativeConsts) {
auto tv = cnsMap.second;
constBuild.add(cnsMap.first, PreClass::Const(pc.get(),
cnsMap.first,
staticEmptyString(),
tv,
staticEmptyString()));
}
}
pc->m_constants.create(constBuild);
return pc.release();
}
int XmlNode::AttrInt(const char *id, int def) const
{
String x = Attr(id);
CParser p(x);
return p.IsInt() ? p.ReadInt() : def;
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
bool isGenerated = isdigit(name->data()[0]) ||
ParserBase::IsClosureName(name->toCppString());
Attr attrs = this->attrs;
if (preClass && preClass->attrs() & AttrInterface) {
attrs |= AttrAbstract;
}
if (attrs & AttrPersistent &&
((RuntimeOption::EvalJitEnableRenameFunction && !isGenerated) ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) ||
attrs & AttrInterceptable)) {
if (attrs & AttrBuiltin) {
SystemLib::s_anyNonPersistentBuiltins = true;
}
attrs = Attr(attrs & ~AttrPersistent);
}
if (!RuntimeOption::RepoAuthoritative) {
// In non-RepoAuthoritative mode, any function could get a VarEnv because
// of evalPHPDebugger.
attrs |= AttrMayUseVV;
} else if (RuntimeOption::EvalJitEnableRenameFunction &&
!name->empty() &&
!Func::isSpecial(name) &&
!isClosureBody) {
// intercepted functions need to pass all args through
// to the interceptee
attrs |= AttrMayUseVV;
}
if (isVariadic()) { attrs |= AttrVariadicParam; }
if (!containsCalls) { attrs |= AttrPhpLeafFn; }
assert(!m_pce == !preClass);
auto f = m_ue.newFunc(this, unit, name, attrs, params.size());
f->m_isPreFunc = !!preClass;
bool const needsExtendedSharedData =
m_info ||
m_builtinFuncPtr ||
m_nativeFuncPtr ||
(attrs & AttrNative) ||
line2 - line1 >= Func::kSmallDeltaLimit ||
past - base >= Func::kSmallDeltaLimit;
f->m_shared.reset(
needsExtendedSharedData
? new Func::ExtendedSharedData(preClass, base, past, line1, line2,
top, docComment)
: new Func::SharedData(preClass, base, past,
line1, line2, top, docComment)
);
f->init(params.size());
if (auto const ex = f->extShared()) {
ex->m_hasExtendedSharedData = true;
ex->m_builtinFuncPtr = m_builtinFuncPtr;
ex->m_nativeFuncPtr = m_nativeFuncPtr;
ex->m_info = m_info;
ex->m_line2 = line2;
ex->m_past = past;
ex->m_returnByValue = false;
}
std::vector<Func::ParamInfo> fParams;
for (unsigned i = 0; i < params.size(); ++i) {
Func::ParamInfo pi = params[i];
if (pi.isVariadic()) {
pi.builtinType = KindOfArray;
}
f->appendParam(params[i].byRef, pi, fParams);
}
f->shared()->m_returnType = returnType;
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = maxStackCells;
f->shared()->m_staticVars = staticVars;
f->shared()->m_ehtab = toFixed(ehtab);
f->shared()->m_fpitab = fpitab;
f->shared()->m_isClosureBody = isClosureBody;
f->shared()->m_isAsync = isAsync;
f->shared()->m_isGenerator = isGenerator;
f->shared()->m_isPairGenerator = isPairGenerator;
f->shared()->m_userAttributes = userAttributes;
f->shared()->m_retTypeConstraint = retTypeConstraint;
f->shared()->m_retUserType = retUserType;
f->shared()->m_originalFilename = originalFilename;
f->shared()->m_isGenerated = isGenerated;
if (attrs & AttrNative) {
auto const ex = f->extShared();
auto const& info = Native::GetBuiltinFunction(
name,
m_pce ? m_pce->name() : nullptr,
f->isStatic()
);
Attr dummy = AttrNone;
auto nativeAttributes = parseNativeAttributes(dummy);
Native::getFunctionPointers(
info,
nativeAttributes,
ex->m_builtinFuncPtr,
ex->m_nativeFuncPtr
);
if (ex->m_nativeFuncPtr &&
!(nativeAttributes & Native::AttrZendCompat)) {
if (info.sig.ret == Native::NativeSig::Type::MixedTV) {
ex->m_returnByValue = true;
}
int extra =
(attrs & AttrNumArgs ? 1 : 0) +
(isMethod() ? 1 : 0);
assert(info.sig.args.size() == params.size() + extra);
for (auto i = params.size(); i--; ) {
switch (info.sig.args[extra + i]) {
case Native::NativeSig::Type::ObjectArg:
case Native::NativeSig::Type::StringArg:
case Native::NativeSig::Type::ArrayArg:
case Native::NativeSig::Type::ResourceArg:
case Native::NativeSig::Type::OutputArg:
case Native::NativeSig::Type::MixedTV:
fParams[i].nativeArg = true;
break;
default:
break;
}
}
}
}
f->finishedEmittingParams(fParams);
return f;
}
int XmppMessageReciveTask::ProcessStart(void)
{
static buzz::StaticQName QN_DELAY = { "urn:xmpp:delay", "delay" };
// 获取下一个stanza
const auto stanza = NextStanza();
if (stanza == nullptr)
{
return STATE_BLOCKED;
}
// 获取消息体
const auto body = stanza->FirstNamed(buzz::QN_BODY);
if (body == nullptr)
{
return STATE_BLOCKED;
}
XmppMessageInfo message;
// 消息id
message.SetUid(Utf8ToWStr(stanza->Attr(buzz::QN_ID)));
// 消息类型
message.SetType(Utf8ToWStr(stanza->Attr(buzz::QN_TYPE)));
// 获取发送人
std::wstring from(Utf8ToWStr(stanza->Attr(buzz::QN_FROM)));
message.SetFrom(from);
message.SetFromResource(from);
// 获取接收人
message.SetTo(Utf8ToWStr(stanza->Attr(buzz::QN_TO)));
message.SetToResource(Utf8ToWStr(stanza->Attr(buzz::QN_TO)));
// 获取消息
message.SetContent(conv.from_bytes(body->BodyText()));
// 获取时间
const auto delay = stanza->FirstNamed(QN_DELAY);
if (delay != nullptr)
{
message.SetTime(Utf8ToWStr(delay->Attr(buzz::kQnStamp)));
}
// 是否离线消息
message.SetIsOfflineMsg(delay != nullptr);
// 获取主题
const auto subject = stanza->FirstNamed(buzz::QN_SUBJECT);
if (subject != nullptr)
{
message.SetSubject(Utf8ToWStr(subject->BodyText()));
// 主题数据
if (subject->HasAttr(buzz::QN_VALUE))
{
message.SetSubjectValue(Utf8ToWStr(subject->Attr(buzz::QN_VALUE)));
}
}
// 获取扩展数据
auto extention = stanza->FirstNamed(QN_EXTENTION);
if (extention != nullptr)
{
std::map<std::wstring, std::wstring> mapValue;
auto elChild = extention->FirstElement();
while (elChild != nullptr)
{
auto name = elChild->Name().LocalPart();
mapValue.emplace(Utf8ToWStr(name), Utf8ToWStr(elChild->BodyText().c_str()));
elChild = elChild->NextElement();
}
message.SetExtention(mapValue);
}
MessageReceived(message);
return STATE_START;
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
bool isGenerated = isdigit(m_name->data()[0]) ||
ParserBase::IsClosureName(m_name->toCPPString()) || m_isGenerator;
Attr attrs = m_attrs;
if (attrs & AttrPersistent &&
((RuntimeOption::EvalJitEnableRenameFunction && !isGenerated) ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited))) {
attrs = Attr(attrs & ~AttrPersistent);
}
if (RuntimeOption::EvalJitEnableRenameFunction &&
!m_name->empty() &&
!Func::isSpecial(m_name) &&
!m_isClosureBody &&
!m_isGenerator) {
// intercepted functions need to pass all args through
// to the interceptee
attrs = attrs | AttrMayUseVV;
}
if (!m_containsCalls) attrs = Attr(attrs | AttrPhpLeafFn);
Func* f = (m_pce == nullptr)
? m_ue.newFunc(this, unit, m_id, m_line1, m_line2, m_base,
m_past, m_name, attrs, m_top, m_docComment,
m_params.size(), m_isClosureBody | m_isGeneratorFromClosure,
m_isGenerator)
: m_ue.newFunc(this, unit, preClass, m_line1, m_line2, m_base,
m_past, m_name, attrs, m_top, m_docComment,
m_params.size(), m_isClosureBody | m_isGeneratorFromClosure,
m_isGenerator);
f->shared()->m_info = m_info;
f->shared()->m_returnType = m_returnType;
std::vector<Func::ParamInfo> pBuilder;
for (unsigned i = 0; i < m_params.size(); ++i) {
Func::ParamInfo pi;
pi.setFuncletOff(m_params[i].funcletOff());
pi.setDefaultValue(m_params[i].defaultValue());
pi.setPhpCode(m_params[i].phpCode());
pi.setTypeConstraint(m_params[i].typeConstraint());
pi.setUserAttributes(m_params[i].userAttributes());
pi.setBuiltinType(m_params[i].builtinType());
pi.setUserType(m_params[i].userType());
f->appendParam(m_params[i].ref(), pi, pBuilder);
}
if (!m_params.size()) {
assert(!f->m_refBitVal && !f->shared()->m_refBitPtr);
f->m_refBitVal = attrs & AttrVariadicByRef ? -1uLL : 0uLL;
}
f->shared()->m_params = pBuilder;
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = m_maxStackCells;
f->shared()->m_staticVars = m_staticVars;
f->shared()->m_ehtab = m_ehtab;
f->shared()->m_fpitab = m_fpitab;
f->shared()->m_isClosureBody = m_isClosureBody;
f->shared()->m_isGenerator = m_isGenerator;
f->shared()->m_isGeneratorFromClosure = m_isGeneratorFromClosure;
f->shared()->m_isPairGenerator = m_isPairGenerator;
f->shared()->m_hasGeneratorAsBody = m_hasGeneratorAsBody;
f->shared()->m_userAttributes = m_userAttributes;
f->shared()->m_builtinFuncPtr = m_builtinFuncPtr;
f->shared()->m_nativeFuncPtr = m_nativeFuncPtr;
f->shared()->m_retTypeConstraint = m_retTypeConstraint;
f->shared()->m_originalFilename = m_originalFilename;
f->shared()->m_isGenerated = isGenerated;
return f;
}
void Misc::Output_impl_normal::attr(std::string n, std::string val)
{
attrib.push_back(Attr(n, val));
}
void RepoQuery::getAttr(int iCol, Attr& attrs) {
int val;
getInt(iCol, val);
attrs = Attr(val);
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
bool isGenerated = isdigit(name->data()[0]) || needsStripInOut(name);
Attr attrs = this->attrs;
if (preClass && preClass->attrs() & AttrInterface) {
attrs |= AttrAbstract;
}
if (!RuntimeOption::RepoAuthoritative) {
if (RuntimeOption::EvalJitEnableRenameFunction) {
attrs |= AttrInterceptable;
} else {
attrs = Attr(attrs & ~AttrInterceptable);
}
}
if (attrs & AttrPersistent && !preClass) {
if ((RuntimeOption::EvalJitEnableRenameFunction ||
attrs & AttrInterceptable ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited))) {
if (attrs & AttrBuiltin) {
SystemLib::s_anyNonPersistentBuiltins = true;
}
attrs = Attr(attrs & ~AttrPersistent);
}
} else {
assertx(preClass || !(attrs & AttrBuiltin));
}
if (!RuntimeOption::RepoAuthoritative) {
// In non-RepoAuthoritative mode, any function could get a VarEnv because
// of evalPHPDebugger.
attrs |= AttrMayUseVV;
} else if ((attrs & AttrInterceptable) &&
!name->empty() &&
!Func::isSpecial(name) &&
!isClosureBody) {
// intercepted functions need to pass all args through
// to the interceptee
attrs |= AttrMayUseVV;
}
if (isVariadic()) {
attrs |= AttrVariadicParam;
if (isVariadicByRef()) {
attrs |= AttrVariadicByRef;
}
}
assertx(!m_pce == !preClass);
auto f = m_ue.newFunc(this, unit, name, attrs, params.size());
f->m_isPreFunc = !!preClass;
bool const needsExtendedSharedData =
isNative ||
line2 - line1 >= Func::kSmallDeltaLimit ||
past - base >= Func::kSmallDeltaLimit ||
m_numClsRefSlots > 3;
f->m_shared.reset(
needsExtendedSharedData
? new Func::ExtendedSharedData(preClass, base, past, line1, line2,
top, !containsCalls, docComment)
: new Func::SharedData(preClass, base, past,
line1, line2, top, !containsCalls, docComment)
);
f->init(params.size());
if (auto const ex = f->extShared()) {
ex->m_hasExtendedSharedData = true;
ex->m_arFuncPtr = nullptr;
ex->m_nativeFuncPtr = nullptr;
ex->m_line2 = line2;
ex->m_past = past;
ex->m_returnByValue = false;
ex->m_isMemoizeWrapper = false;
ex->m_isMemoizeWrapperLSB = false;
ex->m_actualNumClsRefSlots = m_numClsRefSlots;
}
std::vector<Func::ParamInfo> fParams;
for (unsigned i = 0; i < params.size(); ++i) {
Func::ParamInfo pi = params[i];
if (pi.isVariadic()) {
pi.builtinType = RuntimeOption::EvalHackArrDVArrs
? KindOfVec : KindOfArray;
}
f->appendParam(params[i].byRef, pi, fParams);
}
auto const originalFullName =
(!originalFilename ||
!RuntimeOption::RepoAuthoritative ||
FileUtil::isAbsolutePath(originalFilename->slice())) ?
originalFilename :
makeStaticString(RuntimeOption::SourceRoot +
originalFilename->toCppString());
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = maxStackCells;
f->shared()->m_staticVars = staticVars;
f->shared()->m_ehtab = ehtab;
f->shared()->m_fpitab = fpitab;
f->shared()->m_isClosureBody = isClosureBody;
f->shared()->m_isAsync = isAsync;
f->shared()->m_isGenerator = isGenerator;
f->shared()->m_isPairGenerator = isPairGenerator;
f->shared()->m_userAttributes = userAttributes;
f->shared()->m_retTypeConstraint = retTypeConstraint;
f->shared()->m_retUserType = retUserType;
f->shared()->m_originalFilename = originalFullName;
f->shared()->m_isGenerated = isGenerated;
f->shared()->m_repoReturnType = repoReturnType;
f->shared()->m_repoAwaitedReturnType = repoAwaitedReturnType;
f->shared()->m_isMemoizeWrapper = isMemoizeWrapper;
f->shared()->m_isMemoizeWrapperLSB = isMemoizeWrapperLSB;
f->shared()->m_numClsRefSlots = m_numClsRefSlots;
if (isNative) {
auto const ex = f->extShared();
ex->m_hniReturnType = hniReturnType;
auto const info = getNativeInfo();
Attr dummy = AttrNone;
auto nativeAttributes = parseNativeAttributes(dummy);
Native::getFunctionPointers(
info,
nativeAttributes,
ex->m_arFuncPtr,
ex->m_nativeFuncPtr
);
ex->m_takesNumArgs = !!(nativeAttributes & Native::AttrTakesNumArgs);
if (ex->m_nativeFuncPtr) {
if (info.sig.ret == Native::NativeSig::Type::MixedTV) {
ex->m_returnByValue = true;
}
int extra =
(nativeAttributes & Native::AttrTakesNumArgs ? 1 : 0) +
(isMethod() ? 1 : 0);
assertx(info.sig.args.size() == params.size() + extra);
for (auto i = params.size(); i--; ) {
switch (info.sig.args[extra + i]) {
case Native::NativeSig::Type::ObjectArg:
case Native::NativeSig::Type::StringArg:
case Native::NativeSig::Type::ArrayArg:
case Native::NativeSig::Type::ResourceArg:
case Native::NativeSig::Type::OutputArg:
case Native::NativeSig::Type::MixedTV:
fParams[i].nativeArg = true;
break;
default:
break;
}
}
}
}
f->finishedEmittingParams(fParams);
return f;
}
/**
* @brief declare commonattributes Q and WorkspaceIndex.
* Subclasses containing additional attributes should override this method by
* declaring the additional
* attributes and then calling the parent (this) method to declare Q and
* WorkspaceIndex.
*/
void FunctionQDepends::declareAttributes() {
this->declareAttribute("Q", Attr(EMPTY_DBL()));
this->declareAttribute("WorkspaceIndex", Attr(EMPTY_INT()));
}
Func* FuncEmitter::create(Unit& unit, PreClass* preClass /* = NULL */) const {
bool isGenerated = isdigit(name->data()[0]) ||
ParserBase::IsClosureName(name->toCppString());
Attr attrs = this->attrs;
if (preClass && preClass->attrs() & AttrInterface) {
attrs |= AttrAbstract;
}
if (attrs & AttrPersistent &&
((RuntimeOption::EvalJitEnableRenameFunction && !isGenerated) ||
(!RuntimeOption::RepoAuthoritative && SystemLib::s_inited) ||
attrs & AttrInterceptable)) {
if (attrs & AttrBuiltin) {
SystemLib::s_anyNonPersistentBuiltins = true;
}
attrs = Attr(attrs & ~AttrPersistent);
}
if (!RuntimeOption::RepoAuthoritative) {
// In non-RepoAuthoritative mode, any function could get a VarEnv because
// of evalPHPDebugger.
attrs |= AttrMayUseVV;
} else if (RuntimeOption::EvalJitEnableRenameFunction &&
!name->empty() &&
!Func::isSpecial(name) &&
!isClosureBody) {
// intercepted functions need to pass all args through
// to the interceptee
attrs |= AttrMayUseVV;
}
if (isVariadic()) { attrs |= AttrVariadicParam; }
if (!containsCalls) { attrs |= AttrPhpLeafFn; }
assert(!m_pce == !preClass);
auto f = m_ue.newFunc(this, unit, name, attrs, params.size());
f->m_isPreFunc = !!preClass;
bool const needsExtendedSharedData =
m_info ||
m_builtinFuncPtr ||
m_nativeFuncPtr ||
(attrs & AttrNative) ||
line2 - line1 >= Func::kSmallDeltaLimit ||
past - base >= Func::kSmallDeltaLimit;
f->m_shared.reset(
needsExtendedSharedData
? new Func::ExtendedSharedData(preClass, base, past, line1, line2,
top, docComment)
: new Func::SharedData(preClass, base, past,
line1, line2, top, docComment)
);
f->init(params.size());
if (auto const ex = f->extShared()) {
ex->m_hasExtendedSharedData = true;
ex->m_builtinFuncPtr = m_builtinFuncPtr;
ex->m_nativeFuncPtr = m_nativeFuncPtr;
ex->m_info = m_info;
ex->m_line2 = line2;
ex->m_past = past;
}
std::vector<Func::ParamInfo> fParams;
bool usesDoubles = false, variadic = false;
for (unsigned i = 0; i < params.size(); ++i) {
Func::ParamInfo pi = params[i];
if (pi.builtinType == KindOfDouble) usesDoubles = true;
if (pi.isVariadic()) variadic = true;
f->appendParam(params[i].byRef, pi, fParams);
}
f->shared()->m_returnType = returnType;
f->shared()->m_localNames.create(m_localNames);
f->shared()->m_numLocals = m_numLocals;
f->shared()->m_numIterators = m_numIterators;
f->m_maxStackCells = maxStackCells;
f->shared()->m_staticVars = staticVars;
f->shared()->m_ehtab = toFixed(ehtab);
f->shared()->m_fpitab = fpitab;
f->shared()->m_isClosureBody = isClosureBody;
f->shared()->m_isAsync = isAsync;
f->shared()->m_isGenerator = isGenerator;
f->shared()->m_isPairGenerator = isPairGenerator;
f->shared()->m_userAttributes = userAttributes;
f->shared()->m_retTypeConstraint = retTypeConstraint;
f->shared()->m_retUserType = retUserType;
f->shared()->m_originalFilename = originalFilename;
f->shared()->m_isGenerated = isGenerated;
f->finishedEmittingParams(fParams);
if (attrs & AttrNative) {
auto const ex = f->extShared();
auto const& info = Native::GetBuiltinFunction(
name,
m_pce ? m_pce->name() : nullptr,
f->isStatic()
);
auto const nif = info.ptr;
if (nif) {
Attr dummy = AttrNone;
int nativeAttrs = parseNativeAttributes(dummy);
if (nativeAttrs & Native::AttrZendCompat) {
ex->m_nativeFuncPtr = nif;
ex->m_builtinFuncPtr = zend_wrap_func;
} else {
if (parseNativeAttributes(dummy) & Native::AttrActRec) {
ex->m_builtinFuncPtr = nif;
ex->m_nativeFuncPtr = nullptr;
} else {
ex->m_nativeFuncPtr = nif;
ex->m_builtinFuncPtr =
Native::getWrapper(m_pce, usesDoubles, variadic);
}
}
} else {
ex->m_builtinFuncPtr = Native::unimplementedWrapper;
}
}
return f;
}
