void Struct::addTypeId(const TypeIdPtr &typeIdPtr)
{
StructPtr sp = StructPtr::dynamicCast(typeIdPtr->getTypePtr());
if(sp)
{
if(sp->getSid() == getSid())
{
g_parse->error("struct can't take self as member data");
}
}
for(size_t i = 0; i < _members.size(); i++)
{
if(_members[i]->getId() == typeIdPtr->getId())
{
g_parse->error("data member '" + typeIdPtr->getId() + "' duplicate definition");
}
if(_members[i]->getTag() == typeIdPtr->getTag())
{
g_parse->error("data member '" + typeIdPtr->getId() + "' has equal tag with '" + _members[i]->getId() + "'");
}
if(_members[i]->getTag() > typeIdPtr->getTag())
{
_members.insert(_members.begin() + i, typeIdPtr);
return;
}
}
_members.push_back(typeIdPtr);
}
bool
FreezeScript::AnalyzeInitVisitor::visitStructStart(const StructPtr& v)
{
if(v->isLocal())
{
return false;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
StructPtr s = StructPtr::dynamicCast(l.front());
if(!s)
{
typeChange(l.front(), scoped, "struct");
}
else
{
return false;
}
}
_out.newline();
_out.newline();
_out << "<!-- struct " << scoped << " -->";
_out << se("init") << attr("type", scoped);
_out << ee;
return false;
}
bool
FreezeScript::AnalyzeTransformVisitor::visitStructStart(const StructPtr& v)
{
if(v->isLocal())
{
return false;
}
string scoped = v->scoped();
if(ignoreType(scoped))
{
return false;
}
TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
if(l.empty())
{
_missingTypes.push_back(scoped);
return false;
}
StructPtr newStruct = StructPtr::dynamicCast(l.front());
if(!newStruct)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return false;
}
_out.newline();
_out.newline();
_out << "<!-- struct " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
DataMemberList oldMembers = v->dataMembers();
DataMemberList newMembers = newStruct->dataMembers();
compareMembers(oldMembers, newMembers);
_out << ee;
return false;
}
bool Slice::ChecksumVisitor::visitStructStart(const StructPtr& p)
{
if (p->isLocal()) {
return false;
}
ostringstream ostr;
ostr << "struct " << p->name() << endl;
DataMemberList members = p->dataMembers();
for (DataMemberList::iterator q = members.begin(); q != members.end(); ++q) {
ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl;
}
updateMap(p->scoped(), ostr.str());
return false;
}
string
Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
{
static const char* outputBuiltinTable[] =
{
"::Ice::Byte&",
"bool&",
"::Ice::Short&",
"::Ice::Int&",
"::Ice::Long&",
"::Ice::Float&",
"::Ice::Double&",
"::std::string&",
"::Ice::ObjectPtr&",
"::Ice::ObjectPrx&",
"::Ice::LocalObjectPtr&"
};
if(optional)
{
return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
return stringTypeToString(type, metaData, typeCtx) + "&";
}
else
{
return outputBuiltinTable[builtin->kind()];
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
return fixKwd(cl->scoped() + "Ptr&");
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(findMetaData(st->getMetaData()) == "%class")
{
return fixKwd(st->scoped() + "Ptr&");
}
return fixKwd(st->scoped()) + "&";
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
return fixKwd(proxy->_class()->scoped() + "Prx&");
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return sequenceTypeToString(seq, metaData, typeCtx) + "&";
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
return dictionaryTypeToString(dict, metaData, typeCtx) + "&";
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return fixKwd(contained->scoped()) + "&";
}
return "???";
}
string
Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
{
static const char* builtinTable[] =
{
"::Ice::Byte",
"bool",
"::Ice::Short",
"::Ice::Int",
"::Ice::Long",
"::Ice::Float",
"::Ice::Double",
"::std::string",
"::Ice::ObjectPtr",
"::Ice::ObjectPrx",
"::Ice::LocalObjectPtr"
};
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
return stringTypeToString(type, metaData, typeCtx);
}
else
{
return builtinTable[builtin->kind()];
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
return fixKwd(cl->scoped() + "Ptr");
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(findMetaData(st->getMetaData()) == "%class")
{
return fixKwd(st->scoped() + "Ptr");
}
return fixKwd(st->scoped());
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
return fixKwd(proxy->_class()->scoped() + "Prx");
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return sequenceTypeToString(seq, metaData, typeCtx);
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
return dictionaryTypeToString(dict, metaData, typeCtx);
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return fixKwd(contained->scoped());
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
return fixKwd(en->scoped());
}
return "???";
}
string
Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
{
static const char* outputBuiltinTable[] =
{
"::Ice::Byte&",
"bool&",
"::Ice::Short&",
"::Ice::Int&",
"::Ice::Long&",
"::Ice::Float&",
"::Ice::Double&",
"::std::string&",
"::Ice::ObjectPtr&",
"::Ice::ObjectPrxPtr&",
"::Ice::LocalObjectPtr&",
"::Ice::ValuePtr&"
};
static const char* cpp11OutputBuiltinTable[] =
{
"::Ice::Byte&",
"bool&",
"short&",
"int&",
"long long int&",
"float&",
"double&",
"::std::string&",
"::std::shared_ptr<::Ice::Object>&",
"::std::shared_ptr<::Ice::ObjectPrx>&",
"::std::shared_ptr<void>&",
"::std::shared_ptr<::Ice::Value>&"
};
if(optional)
{
return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) +">&";
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
return stringTypeToString(type, metaData, typeCtx) + "&";
}
else
{
if(cpp11)
{
if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocalOperation))
{
return "::std::shared_ptr<::Ice::Value>";
}
else
{
return cpp11OutputBuiltinTable[builtin->kind()];
}
}
else
{
return outputBuiltinTable[builtin->kind()];
}
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
if(cpp11)
{
if(cl->isInterface() && !cl->isLocal())
{
return "::std::shared_ptr<::Ice::Value>&";
}
else
{
return "::std::shared_ptr<" + fixKwd(cl->scoped()) + ">&";
}
}
else
{
return fixKwd(cl->scoped() + "Ptr&");
}
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
{
return fixKwd(st->scoped() + "Ptr&");
}
else
{
return fixKwd(st->scoped()) + "&";
}
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
if(cpp11)
{
ClassDefPtr def = proxy->_class()->definition();
//
// Non local classes without operations map to the base
// proxy class shared_ptr<Ice::ObjectPrx>
//
if(def && !def->isInterface() && def->allOperations().empty())
{
return "::std::shared_ptr<::Ice::ObjectPrx>";
}
else
{
return "::std::shared_ptr<" + fixKwd(proxy->_class()->scoped() + "Prx") + ">&";
}
}
else
{
return fixKwd(proxy->_class()->scoped() + "Prx&");
}
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return sequenceTypeToString(seq, metaData, typeCtx) + "&";
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
return dictionaryTypeToString(dict, metaData, typeCtx) + "&";
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return fixKwd(contained->scoped()) + "&";
}
return "???";
}
string
Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
{
static const char* cpp98InputBuiltinTable[] =
{
"::Ice::Byte",
"bool",
"::Ice::Short",
"::Ice::Int",
"::Ice::Long",
"::Ice::Float",
"::Ice::Double",
"const ::std::string&",
"const ::Ice::ObjectPtr&",
"const ::Ice::ObjectPrx&",
"const ::Ice::LocalObjectPtr&",
"const ::Ice::ValuePtr&"
};
static const char* cpp11InputLocalBuiltinTable[] =
{
"::Ice::Byte",
"bool",
"short",
"int",
"long long int",
"float",
"double",
"const ::std::string&",
"const ::std::shared_ptr<::Ice::Object>&",
"const ::std::shared_ptr<::Ice::ObjectPrx>&",
"const ::std::shared_ptr<void>&",
"const ::std::shared_ptr<::Ice::Value>&"
};
static const char* cpp11InputBuiltinTable[] =
{
"::Ice::Byte",
"bool",
"short",
"int",
"long long int",
"float",
"double",
"::std::string&",
"::std::shared_ptr<::Ice::Object>",
"::std::shared_ptr<::Ice::ObjectPrx>",
"::std::shared_ptr<void>",
"::std::shared_ptr<::Ice::Value>"
};
typeCtx |= TypeContextInParam;
if(optional)
{
if(cpp11 && !(typeCtx & TypeContextLocalOperation) &&
!(typeCtx & TypeContextAMD))
{
return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) +">";
}
else
{
return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) +">&";
}
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
if(cpp11 && !(typeCtx & TypeContextLocalOperation) && !(typeCtx & TypeContextAMD))
{
return stringTypeToString(type, metaData, typeCtx);
}
else
{
return string("const ") + stringTypeToString(type, metaData, typeCtx) + "&";
}
}
else
{
if(cpp11)
{
if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocalOperation))
{
if(typeCtx & TypeContextAMD)
{
return "const ::std::shared_ptr<::Ice::Value>&";
}
else
{
return "::std::shared_ptr<::Ice::Value>";
}
}
else
{
if(typeCtx & TypeContextLocalOperation || typeCtx & TypeContextAMD)
{
return cpp11InputLocalBuiltinTable[builtin->kind()];
}
else
{
return cpp11InputBuiltinTable[builtin->kind()];
}
}
}
else
{
return cpp98InputBuiltinTable[builtin->kind()];
}
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
string t;
if(cpp11)
{
if(findMetaData("cpp11:type:", cl, t))
{
return t;
}
else if(cl->isLocal() || (typeCtx & TypeContextLocalOperation))
{
if(cl->definition() && cl->definition()->isDelegate())
{
return classDefToDelegateString(cl->definition(), typeCtx, cpp11);
}
else if(typeCtx & TypeContextDelegate)
{
return "::std::shared_ptr<" + fixKwd(cl->scoped()) + ">";
}
else
{
return "const ::std::shared_ptr<" + fixKwd(cl->scoped()) + ">&";
}
}
else
{
if(typeCtx & TypeContextAMD)
{
if(cl->isInterface())
{
return "const ::std::shared_ptr<::Ice::Value>&";
}
else
{
return "const ::std::shared_ptr<" + fixKwd(cl->scoped()) + ">&";
}
}
else
{
if(cl->isInterface())
{
return "::std::shared_ptr<::Ice::Value>";
}
else
{
return "::std::shared_ptr<" + fixKwd(cl->scoped()) + ">";
}
}
}
}
else
{
return "const " + fixKwd(cl->scoped() + "Ptr&");
}
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(cpp11)
{
if(st->isLocal() || (typeCtx & TypeContextLocalOperation) || (typeCtx & TypeContextAMD))
{
return "const " + fixKwd(st->scoped()) + "&";
}
else
{
return fixKwd(st->scoped());
}
}
else
{
if(findMetaData(st->getMetaData()) == "%class")
{
return "const " + fixKwd(st->scoped() + "Ptr&");
}
else
{
return "const " + fixKwd(st->scoped()) + "&";
}
}
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
if(cpp11)
{
ClassDefPtr def = proxy->_class()->definition();
//
// Non local classes without operations map to the base
// proxy class shared_ptr<Ice::ObjectPrx>
//
if(typeCtx & TypeContextLocalOperation)
{
if(def && !def->isInterface() && def->allOperations().empty())
{
return "const ::std::shared_ptr<::Ice::ObjectPrx>&";
}
else
{
return "const ::std::shared_ptr<" + fixKwd(proxy->_class()->scoped() + "Prx") + ">&";
}
}
else
{
string t;
if(def && !def->isInterface() && def->allOperations().empty())
{
t = "::std::shared_ptr<::Ice::ObjectPrx>";
}
else
{
t = "::std::shared_ptr<" + fixKwd(proxy->_class()->scoped() + "Prx") + ">";
}
return (typeCtx & TypeContextAMD) ? ("const " + t + "&") : t;
}
}
else
{
return "const " + fixKwd(proxy->_class()->scoped() + "Prx&");
}
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
return fixKwd(en->scoped());
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
if(cpp11 && !(typeCtx & TypeContextLocalOperation) && !(typeCtx & TypeContextAMD))
{
return sequenceTypeToString(seq, metaData, typeCtx);
}
else
{
return "const " + sequenceTypeToString(seq, metaData, typeCtx) + "&";
}
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
if(cpp11 && !(typeCtx & TypeContextLocalOperation) && !(typeCtx & TypeContextAMD))
{
return dictionaryTypeToString(dict, metaData, typeCtx);
}
else
{
return "const " + dictionaryTypeToString(dict, metaData, typeCtx) + "&";
}
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
if(cpp11 && !(typeCtx & TypeContextLocalOperation) && !(typeCtx & TypeContextAMD))
{
return fixKwd(contained->scoped());
}
else
{
return "const " + fixKwd(contained->scoped()) + "&";
}
}
return "???";
}
string
Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx, bool cpp11)
{
static const char* builtinTable[] =
{
"::Ice::Byte",
"bool",
"::Ice::Short",
"::Ice::Int",
"::Ice::Long",
"::Ice::Float",
"::Ice::Double",
"::std::string",
"::Ice::ObjectPtr",
"::Ice::ObjectPrx",
"::Ice::LocalObjectPtr",
"::Ice::ValuePtr"
};
static const char* cpp11BuiltinTable[] =
{
"::Ice::Byte",
"bool",
"short",
"int",
"long long int",
"float",
"double",
"::std::string",
"::std::shared_ptr<::Ice::Object>",
"::std::shared_ptr<::Ice::ObjectPrx>",
"::std::shared_ptr<void>",
"::std::shared_ptr<::Ice::Value>"
};
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
return stringTypeToString(type, metaData, typeCtx);
}
else
{
if(cpp11)
{
if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocalOperation))
{
return "::std::shared_ptr<::Ice::Value>";
}
else
{
return cpp11BuiltinTable[builtin->kind()];
}
}
else
{
return builtinTable[builtin->kind()];
}
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
//
// C++11 mapping accepts cpp11:type metadata for classes and proxies
//
if(cpp11)
{
string t;
if(cpp11 && findMetaData("cpp11:type:", cl, t))
{
return t;
}
else if(cl->definition() && cl->definition()->isDelegate())
{
return classDefToDelegateString(cl->definition());
}
else
{
if(cl->isInterface() && !cl->isLocal())
{
return "std::shared_ptr<::Ice::Value>";
}
else
{
return "::std::shared_ptr<" + cl->scoped() + ">";
}
}
}
else
{
return cl->scoped() + "Ptr";
}
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
//
// C++11 mapping doesn't accept cpp:class metdata
//
if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
{
return fixKwd(st->scoped() + "Ptr");
}
return fixKwd(st->scoped());
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
if(cpp11)
{
ClassDefPtr def = proxy->_class()->definition();
//
// Non local classes without operations map to the base
// proxy class shared_ptr<Ice::ObjectPrx>
//
if(def && !def->isInterface() && def->allOperations().empty())
{
return "::std::shared_ptr<::Ice::ObjectPrx>";
}
else
{
return "::std::shared_ptr<" + fixKwd(proxy->_class()->scoped() + "Prx") + ">";
}
}
else
{
return fixKwd(proxy->_class()->scoped() + "Prx");
}
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return sequenceTypeToString(seq, metaData, typeCtx);
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
return dictionaryTypeToString(dict, metaData, typeCtx);
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return fixKwd(contained->scoped());
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
return fixKwd(en->scoped());
}
return "???";
}
int TarsAnalyzer::readStruct(const StructPtr & pPtr, const NamespacePtr & nPtr)
{
vector<TypeIdPtr>& member = pPtr->getAllMemberPtr();
AnalyzerDataHead h;
size_t hLen = h.peekFrom(*this);
if (AnalyzerDataHead::eStructBegin == h.getType()) // 检查结构开始
{
cout << endl;
incTab();
cout << getTab()<< "struct " << pPtr->getId() << " {" << endl;
skip(hLen);
}
//解析struct成员变量
for (size_t i = 0; i < member.size(); i++)
{
cout<< getTab() <<"expect tag ";
cout.setf(ios::right);
cout.width(CHAR_WIDTH_TAG);
cout<< member[i]->getTag();
cout.width(CHAR_WIDTH_ID); // 成员名12字符宽
cout<< member[i]->getId();
//获取tup版本号
if(isTup() && (pPtr->getId() == "RequestPacket"))
{
if(member[i]->getTag() == 1)
{
char iVer = 2;
this->peekBuf(&iVer, sizeof(iVer),1);
_tupVersion = iVer;
}
else if(member[i]->getTag() == 7)///解析sbuffer
{
_tup_sbuffer_pos = _cur;
_cur +=2; //7D 00
int n;
uint8_t tag = 0;
int realType;
read(n, tag, realType, true ); //sbuffer的长度
if(_tupVersion == 2)
{
read(_tup2_helper, 7);
_bIsDumpTup?dumpTup(_tup2_helper):(void(0));
}
else///3
{
read(_tup3_helper, 7);
_bIsDumpTup?dumpTup(_tup3_helper):(void(0));
}
_cur = _tup_sbuffer_pos;
}
}
//读取内置基本类型
BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr());
if (bPtr)
{
cout.width(CHAR_WIDTH_TYPE);
cout<<tostrBuiltin(bPtr);
cout<<getSep();
readBuiltin(bPtr, member[i]->getTag(), member[i]->isRequire(), NULL);
}
VectorPtr vPtr = VectorPtr::dynamicCast(member[i]->getTypePtr());
if (vPtr)
{
cout.width(CHAR_WIDTH_TYPE);
cout<<tostrVector(vPtr);
cout<<getSep();
readVector(vPtr, member[i]->getTag(),member[i]->isRequire(), NULL);
}
MapPtr mPtr = MapPtr::dynamicCast(member[i]->getTypePtr());
if (mPtr)
{
cout.width(CHAR_WIDTH_TYPE);
cout<<tostrMap(mPtr);
cout<<getSep();
readMap(mPtr, member[i]->getTag(), member[i]->isRequire());
}
StructPtr sPtr = StructPtr::dynamicCast(member[i]->getTypePtr());
if (sPtr)
{
cout.width(CHAR_WIDTH_TYPE);
cout<< tostrStruct(sPtr);
cout<<getSep();
readStruct(sPtr, NULL);
}
EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr());
if (ePtr)
{
cout.width(CHAR_WIDTH_TYPE);
cout<< tostrEnum(ePtr);
cout<<getSep();
readEnum(ePtr , member[i]->getTag(), member[i]->isRequire());
}
}
if (!_bTup)
{
hLen = h.peekFrom(*this); //buf中没有结构结束标志，也不会抛异常，因为setBuffer的buf_len有1个保护字节
if (AnalyzerDataHead::eStructEnd == h.getType() || _cur >= _buf_len-chars_buf_reserve) // 检查结构结束
{
cout << getTab() << "} //struct " << pPtr->getId() << endl;
decTab();
skip(hLen);
if (pPtr->getId() == _StructName)
{
cout << "analyze " << _streamFileName << " with struct " << _StructName << " ok!" << endl;
}
}
}
return 0;
}
string
Slice::ObjCGenerator::getOptionalFormat(const TypePtr& type)
{
BuiltinPtr bp = BuiltinPtr::dynamicCast(type);
if(bp)
{
switch(bp->kind())
{
case Builtin::KindByte:
case Builtin::KindBool:
{
return "ICEOptionalFormatF1";
}
case Builtin::KindShort:
{
return "ICEOptionalFormatF2";
}
case Builtin::KindInt:
case Builtin::KindFloat:
{
return "ICEOptionalFormatF4";
}
case Builtin::KindLong:
case Builtin::KindDouble:
{
return "ICEOptionalFormatF8";
}
case Builtin::KindString:
{
return "ICEOptionalFormatVSize";
}
case Builtin::KindObject:
case Builtin::KindValue:
{
return "ICEOptionalFormatClass";
}
case Builtin::KindObjectProxy:
{
return "ICEOptionalFormatFSize";
}
case Builtin::KindLocalObject:
{
assert(false);
break;
}
}
}
if(EnumPtr::dynamicCast(type))
{
return "ICEOptionalFormatSize";
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return seq->type()->isVariableLength() ? "ICEOptionalFormatFSize" : "ICEOptionalFormatVSize";
}
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(d)
{
return (d->keyType()->isVariableLength() || d->valueType()->isVariableLength()) ?
"ICEOptionalFormatFSize" : "ICEOptionalFormatVSize";
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
return st->isVariableLength() ? "ICEOptionalFormatFSize" : "ICEOptionalFormatVSize";
}
if(ProxyPtr::dynamicCast(type))
{
return "ICEOptionalFormatFSize";
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
assert(cl);
return "ICEOptionalFormatClass";
}
bool
FreezeScript::AnalyzeTransformVisitor::visitStructStart(const StructPtr& v)
{
if(v->isLocal())
{
return false;
}
string scoped = v->scoped();
if(ignoreType(scoped))
{
return false;
}
TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
if(l.empty())
{
_missingTypes.push_back(scoped);
return false;
}
//
// Allow transforming from struct to class.
//
StructPtr newStruct = StructPtr::dynamicCast(l.front());
ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
ClassDefPtr newClass;
if(decl)
{
newClass = decl->definition();
if(!newClass)
{
_missingTypes.push_back(scoped);
return false;
}
}
else if(!newStruct)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return false;
}
_out.newline();
_out.newline();
if(newClass)
{
_out << "<!-- class " << scoped << " -->";
}
else
{
_out << "<!-- struct " << scoped << " -->";
}
_out << se("transform") << attr("type", scoped);
DataMemberList oldMembers, newMembers;
if(newClass)
{
oldMembers = v->dataMembers();
newMembers = newClass->allDataMembers();
}
else
{
oldMembers = v->dataMembers();
newMembers = newStruct->dataMembers();
}
compareMembers(oldMembers, newMembers);
_out << ee;
return false;
}
string Jce2Php::generatePHP(const StructPtr &pPtr, const string& namespaceId) const
{
ostringstream s;
vector<TypeIdPtr>& member = pPtr->getAllMemberPtr();
s << TAB << "class " << pPtr->getId() << " extends c_struct" << endl;
s << TAB << "{" << endl;
INC_TAB;
//变量声明
for(size_t k = 0;k < member.size();k++)
{
s<< TAB << "public $" <<member[k]->getId()<<";"<<endl;
}
s<<endl;
s << TAB << "public function __clone()" << endl;
s << TAB << "{" << endl;
INC_TAB;
for(size_t k = 0;k < member.size();k++)
{
s<< TAB << "$this->" <<member[k]->getId()<<" = clone $this->"<<member[k]->getId()<<";"<<endl;
}
DEL_TAB;
s << TAB << "}" << endl;
s <<endl;
s << TAB << "public function __construct()" << endl;
s << TAB << "{" << endl;
INC_TAB;
for(size_t k = 0;k < member.size();k++)
{
s<< TAB << "$this->" <<member[k]->getId()<<" = new "<< tostr(member[k]->getTypePtr())<<";"<<endl;
}
DEL_TAB;
s << TAB << "}" << endl;
s <<endl;
////////////////////////////////////////////////////////////
s << TAB << "public function get_class_name()" << endl;
s << TAB << "{" << endl;
INC_TAB;
s << TAB << "return " << "\"" << namespaceId << "." << pPtr->getId() << "\"" << ";" << endl;
DEL_TAB;
s << TAB << "}" << endl;
s<<endl;
//write begin
if(m_bPDU)
{
s << TAB << "public function writeTo(&$_out,$tag)" << endl;
s << TAB << "{" << endl;
INC_TAB;
//s << TAB << "jce_header::_pack_header($_out,'c_struct_begin',$tag);" << endl;
}
else
{
s << TAB << "public function write(&$_out,$tag)" << endl;
s << TAB << "{" << endl;
INC_TAB;
s << TAB << "jce_header::_pack_header($_out,'c_struct_begin',$tag);" << endl;
}
for(size_t j = 0; j < member.size(); j++)
{
s << writeTo(member[j]);
}
if(m_bPDU)
{
//s << TAB << "jce_header::_pack_header($_out,'c_struct_end',0);" << endl;
}
else
{
s << TAB << "jce_header::_pack_header($_out,'c_struct_end',0);" << endl;
}
DEL_TAB;
s << TAB << "}" << endl;
//write end
///read begin
if(m_bPDU)
{
s << TAB << "public function readFrom(&$_in,$tag,$isRequire = true)" << endl;
s << TAB << "{" << endl;
INC_TAB;
#if 0
s << TAB << "jce_header::_peek_header($_in,$type,$this_tag);"<<endl;
s << TAB << "if($tag != $this_tag)" <<endl;
s << TAB << "{" << endl;
INC_TAB;
s << TAB << "if($isRequire == true){"<<endl;
s << TAB << "throw new JceException(__LINE__ ,TAG_NOT_MATCH);"<<endl;
s << TAB << "}else{" <<endl;
INC_TAB;
s << TAB << "return;"<<endl;
DEL_TAB;
s << TAB << "}" <<endl;
DEL_TAB;
s << TAB << "}" <<endl;
s << TAB << "if($type != 'c_struct_begin')"<<endl;
INC_TAB;
s << TAB << "throw new JceException(__LINE__ ,TYPE_NOT_MATCH);"<<endl;
DEL_TAB;
s<< TAB << "jce_header::_unpack_header($_in,$type,$this_tag);"<<endl;
#endif
}
else
{
s << TAB << "public function read(&$_in,$tag,$isRequire = true)" << endl;
s << TAB << "{" << endl;
INC_TAB;
s << TAB << "jce_header::_check_struct($_in,$type,$tag,$isRequire);"<<endl;
s << TAB << "jce_header::_unpack_header($_in,$type,$this_tag);"<<endl;
}
for(size_t j = 0; j < member.size(); j++)
{
s << readFrom(member[j]);
}
if(!m_bPDU)
{
s<< TAB << "$this->_skip_struct($_in);" << endl;
}
DEL_TAB;
s << TAB << "}" << endl;
//read end
DEL_TAB;
s << TAB << "}" << endl;
return s.str();
}
/*******************************StructPtr********************************/
string Jce2Php::tostrStruct(const StructPtr &pPtr) const
{
return pPtr->getId();
}
bool
Slice::Ruby::CodeVisitor::visitStructStart(const StructPtr& p)
{
string scoped = p->scoped();
string name = fixIdent(p->name(), IdentToUpper);
MemberInfoList memberList;
MemberInfoList::iterator r;
{
DataMemberList members = p->dataMembers();
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
memberList.push_back(MemberInfo());
memberList.back().lowerName = fixIdent((*q)->name(), IdentToLower);
memberList.back().fixedName = fixIdent((*q)->name(), IdentNormal);
memberList.back().inherited = false;
memberList.back().dataMember = *q;
}
}
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper) << ')';
_out.inc();
_out << nl << "class " << name;
_out.inc();
if(!memberList.empty())
{
_out << nl << "def initialize(";
writeConstructorParams(memberList);
_out << ")";
_out.inc();
for(r = memberList.begin(); r != memberList.end(); ++r)
{
_out << nl << '@' << r->fixedName << " = " << r->lowerName;
}
_out.dec();
_out << nl << "end";
}
//
// hash
//
_out << sp << nl << "def hash";
_out.inc();
_out << nl << "_h = 0";
int iter = 0;
for(r = memberList.begin(); r != memberList.end(); ++r)
{
writeHash("@" + r->fixedName, r->dataMember->type(), iter);
}
_out << nl << "_h % 0x7fffffff";
_out.dec();
_out << nl << "end";
//
// ==
//
_out << sp << nl << "def ==(other)";
_out.inc();
_out << nl << "return false if";
_out.inc();
for(r = memberList.begin(); r != memberList.end(); ++r)
{
if(r != memberList.begin())
{
_out << " or";
}
_out << nl << "@" << r->fixedName << " != other." << r->fixedName;
}
_out.dec();
_out << nl << "true";
_out.dec();
_out << nl << "end";
//
// eql?
//
// This method is used to determine the equality of keys in a Hash object.
//
_out << sp << nl << "def eql?(other)";
_out.inc();
_out << nl << "return other.class == self.class && other == self";
_out.dec();
_out << nl << "end";
//
// inspect
//
_out << sp << nl << "def inspect";
_out.inc();
_out << nl << "::Ice::__stringify(self, T_" << name << ")";
_out.dec();
_out << nl << "end";
//
// read/write accessors for data members.
//
if(!memberList.empty())
{
_out << sp << nl << "attr_accessor ";
for(r = memberList.begin(); r != memberList.end(); ++r)
{
if(r != memberList.begin())
{
_out << ", ";
}
_out << ':' << r->fixedName;
}
}
_out.dec();
_out << nl << "end"; // End of class.
//
// Emit the type information.
//
_out << sp << nl << "T_" << name << " = ::Ice::__defineStruct('" << scoped << "', " << name << ", [";
//
// Data members are represented as an array:
//
// ['MemberName', MemberType]
//
// where MemberType is either a primitive type constant (T_INT, etc.) or the id of a constructed type.
//
if(memberList.size() > 1)
{
_out.inc();
_out << nl;
}
for(r = memberList.begin(); r != memberList.end(); ++r)
{
if(r != memberList.begin())
{
_out << ',' << nl;
}
_out << "[\"" << r->fixedName << "\", ";
writeType(r->dataMember->type());
_out << ']';
}
if(memberList.size() > 1)
{
_out.dec();
_out << nl;
}
_out << "])";
_out.dec();
_out << nl << "end"; // if not defined?()
return false;
}
bool
CodeVisitor::visitStructStart(const StructPtr& p)
{
string scoped = p->scoped();
string name = getName(p);
string type = getTypeVar(p);
string abs = getAbsolute(p, _ns);
MemberInfoList memberList;
MemberInfoList::iterator r;
{
DataMemberList members = p->dataMembers();
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
memberList.push_back(MemberInfo());
memberList.back().fixedName = fixIdent((*q)->name());
memberList.back().inherited = false;
memberList.back().dataMember = *q;
}
}
startNamespace(p);
_out << sp << nl << "if(!class_exists('" << escapeName(abs) << "'))";
_out << sb;
_out << nl << "class " << name;
_out << sb;
_out << nl << "public function __construct(";
writeConstructorParams(memberList);
_out << ")";
_out << sb;
for(r = memberList.begin(); r != memberList.end(); ++r)
{
writeAssign(*r);
}
_out << eb;
//
// __toString
//
_out << sp << nl << "public function __toString()";
_out << sb;
_out << nl << "global " << type << ';';
_out << nl << "return IcePHP_stringify($this, " << type << ");";
_out << eb;
if(!memberList.empty())
{
_out << sp;
for(r = memberList.begin(); r != memberList.end(); ++r)
{
_out << nl << "public $" << r->fixedName << ';';
}
}
_out << eb;
//
// Emit the type information.
//
_out << sp << nl << type << " = IcePHP_defineStruct('" << scoped << "', '" << escapeName(abs) << "', array(";
//
// Data members are represented as an array:
//
// ('MemberName', MemberType)
//
// where MemberType is either a primitive type constant (T_INT, etc.) or the id of a constructed type.
//
for(r = memberList.begin(); r != memberList.end(); ++r)
{
if(r != memberList.begin())
{
_out << ", ";
}
_out.inc();
_out << nl << "array('" << r->fixedName << "', ";
writeType(r->dataMember->type());
_out << ')';
_out.dec();
}
_out << "));";
_out << eb;
endNamespace();
return false;
}
void
FreezeScript::AnalyzeTransformVisitor::compareTypes(const string& desc, const TypePtr& oldType, const TypePtr& newType)
{
assert(!oldType->isLocal());
if(newType->isLocal())
{
ostringstream ostr;
ostr << desc << " has changed to a local type";
_errors.push_back(ostr.str());
return;
}
BuiltinPtr b = BuiltinPtr::dynamicCast(oldType);
if(b)
{
BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
switch(b->kind())
{
case Builtin::KindByte:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindString:
{
return;
}
case Builtin::KindBool:
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindBool:
{
if(newb && (newb->kind() == Builtin::KindBool || newb->kind() == Builtin::KindString))
{
return;
}
break;
}
case Builtin::KindShort:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindString:
{
return;
}
case Builtin::KindBool:
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindInt:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindString:
{
return;
}
case Builtin::KindBool:
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindLong:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindString:
{
return;
}
case Builtin::KindBool:
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindFloat:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindString:
{
return;
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindBool:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindDouble:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindString:
{
return;
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindBool:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
break;
}
}
}
break;
}
case Builtin::KindString:
{
if(newb)
{
switch(newb->kind())
{
case Builtin::KindByte:
case Builtin::KindBool:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
case Builtin::KindFloat:
case Builtin::KindDouble:
case Builtin::KindString:
case Builtin::KindObjectProxy:
{
return;
}
case Builtin::KindObject:
case Builtin::KindLocalObject:
{
break;
}
}
break;
}
if(EnumPtr::dynamicCast(newType))
{
return;
}
if(ProxyPtr::dynamicCast(newType))
{
return;
}
break;
}
case Builtin::KindObject:
{
//
// Allow change from Object to class. Validation has to
// be done during transformation, when the actual type of
// an instance can be compared for compatibility with the
// new type.
//
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(newType);
if(cl || (newb && newb->kind() == Builtin::KindObject))
{
return;
}
break;
}
case Builtin::KindObjectProxy:
{
ProxyPtr p = ProxyPtr::dynamicCast(newType);
if(p || (newb && newb->kind() == Builtin::KindObjectProxy) || (newb && newb->kind() == Builtin::KindString))
{
return;
}
break;
}
case Builtin::KindLocalObject:
{
assert(false);
break;
}
}
typeChange(desc, oldType, newType);
return;
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(oldType);
if(cl)
{
if(!cl->definition())
{
_errors.push_back("class " + cl->scoped() + " declared but not defined");
return;
}
//
// Allow target type of Object.
//
BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
if(newb && newb->kind() == Builtin::KindObject)
{
return;
}
//
// Allow target type of struct.
//
if(StructPtr::dynamicCast(newType))
{
return;
}
ClassDeclPtr newcl = ClassDeclPtr::dynamicCast(newType);
if(newcl)
{
if(!newcl->definition())
{
_errors.push_back("class " + newcl->scoped() + " declared but not defined");
return;
}
if(checkClasses(cl, newcl))
{
return;
}
}
typeChange(desc, oldType, newType);
return;
}
StructPtr s = StructPtr::dynamicCast(oldType);
if(s)
{
StructPtr news = StructPtr::dynamicCast(newType);
if(news && s->scoped() == news->scoped())
{
return;
}
//
// Allow target type of class.
//
if(ClassDeclPtr::dynamicCast(newType))
{
return;
}
typeChange(desc, oldType, newType);
return;
}
ProxyPtr proxy = ProxyPtr::dynamicCast(oldType);
if(proxy)
{
//
// Allow target type of Object* and string.
//
BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
if(newb && (newb->kind() == Builtin::KindObjectProxy || newb->kind() == Builtin::KindString))
{
return;
}
ProxyPtr newProxy = ProxyPtr::dynamicCast(newType);
if(newProxy && checkClasses(proxy->_class(), newProxy->_class()))
{
return;
}
typeChange(desc, oldType, newType);
return;
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(oldType);
if(dict)
{
DictionaryPtr newDict = DictionaryPtr::dynamicCast(newType);
if(newDict && dict->scoped() == newDict->scoped())
{
return;
}
typeChange(desc, oldType, newType);
return;
}
SequencePtr seq = SequencePtr::dynamicCast(oldType);
if(seq)
{
SequencePtr newSeq = SequencePtr::dynamicCast(newType);
if(newSeq && seq->scoped() == newSeq->scoped())
{
return;
}
typeChange(desc, oldType, newType);
return;
}
EnumPtr en = EnumPtr::dynamicCast(oldType);
if(en)
{
EnumPtr newen = EnumPtr::dynamicCast(newType);
BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
if((newen && en->scoped() == newen->scoped()) || (newb && newb->kind() == Builtin::KindString))
{
return;
}
typeChange(desc, oldType, newType);
return;
}
assert(false);
}
void
Slice::ObjCGenerator::writeOptMemberMarshalUnmarshalCode(Output &out, const TypePtr& type, const string& param,
bool marshal) const
{
string stream = marshal ? "os_" : "is_";
string optionalHelper;
string helper;
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindObjectProxy)
{
optionalHelper = "ICEVarLengthOptionalHelper";
helper = "[ICEProxyHelper class]";
}
else
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
ProxyPtr prx = ProxyPtr::dynamicCast(type);
if(prx)
{
optionalHelper = "ICEVarLengthOptionalHelper";
helper = "objc_getClass(\"" + moduleName(findModule(prx->_class())) + prx->_class()->name() + "PrxHelper\")";
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(st->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else
{
optionalHelper = "ICEFixedLengthOptionalHelper";
}
helper = "[" + typeToString(st) + "Helper class]";
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
TypePtr element = seq->type();
if(element->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else if(element->minWireSize() == 1)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
else
{
optionalHelper = "ICEFixedSequenceOptionalHelper";
}
helper = "[" + moduleName(findModule(seq)) + seq->name() + "Helper class]";
}
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(d)
{
if(d->keyType()->isVariableLength() || d->valueType()->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else
{
optionalHelper = "ICEFixedDictionaryOptionalHelper";
}
helper = "[" + moduleName(findModule(d)) + d->name() + "Helper class]";
}
out << nl;
if(marshal)
{
out << "[" << optionalHelper << " write:" << param << " stream:" << stream << " helper:" << helper << "];";
}
else
{
out << param << " = [" << optionalHelper << " readRetained:" << stream << " helper:" << helper << "];";
}
}
string TarsAnalyzer::tostrStruct(const StructPtr &pPtr) const
{
return pPtr->getSid();
}
