void
FreezeScript::AnalyzeInitVisitor::visitEnum(const EnumPtr& v)
{
if(v->isLocal())
{
return;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
EnumPtr e = EnumPtr::dynamicCast(l.front());
if(!e)
{
typeChange(l.front(), scoped, "enum");
}
else
{
return;
}
}
_out.newline();
_out.newline();
_out << "<!-- enum " << scoped << " -->";
_out << se("init") << attr("type", scoped);
_out << ee;
}
string
Slice::Ruby::CodeVisitor::getInitializer(const TypePtr& p)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindBool:
{
return "false";
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
{
return "0";
}
case Builtin::KindFloat:
case Builtin::KindDouble:
{
return "0.0";
}
case Builtin::KindString:
{
return "''";
}
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
return "nil";
}
}
}
EnumPtr en = EnumPtr::dynamicCast(p);
if(en)
{
EnumeratorList enums = en->getEnumerators();
return getAbsolute(en, IdentToUpper) + "::" + fixIdent(enums.front()->name(), IdentToUpper);
}
StructPtr st = StructPtr::dynamicCast(p);
if(st)
{
return getAbsolute(st, IdentToUpper) + ".new";
}
return "nil";
}
void
CodeVisitor::visitEnum(const EnumPtr& p)
{
string scoped = p->scoped();
string name = getName(p);
string type = getTypeVar(p);
string abs = getAbsolute(p, _ns);
EnumeratorList enums = p->getEnumerators();
EnumeratorList::iterator q;
long i;
startNamespace(p);
_out << sp << nl << "if(!class_exists('" << escapeName(abs) << "'))";
_out << sb;
_out << nl << "class " << name;
_out << sb;
for(q = enums.begin(), i = 0; q != enums.end(); ++q, ++i)
{
string fixedEnum = fixIdent((*q)->name());
ostringstream idx;
idx << i;
_out << nl << "const " << fixedEnum << " = " << idx.str() << ';';
}
_out << eb;
//
// Emit the type information.
//
_out << sp << nl << type << " = IcePHP_defineEnum('" << scoped << "', array(";
for(q = enums.begin(); q != enums.end(); ++q)
{
if(q != enums.begin())
{
_out << ", ";
}
_out << "'" << (*q)->name() << "'";
}
_out << "));";
_out << eb;
endNamespace();
}
void Slice::ChecksumVisitor::visitEnum(const EnumPtr& p)
{
if (p->isLocal()) {
return;
}
ostringstream ostr;
ostr << "enum " << p->name() << endl;
EnumeratorList enums = p->getEnumerators();
for (EnumeratorList::iterator q = enums.begin(); q != enums.end(); ++q) {
ostr << (*q)->name() << endl;
}
updateMap(p->scoped(), ostr.str());
}
void
Slice::ObjCGenerator::writeMarshalUnmarshalCode(Output &out, const TypePtr& type, const string& param,
bool marshal, bool autoreleased) const
{
string stream = marshal ? "os_" : "is_";
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
string name;
if(builtin->kind() == Builtin::KindObject)
{
if(marshal)
{
out << nl << "[" << stream << " writeObject:" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << "[" << stream << " readObject:&" << param << "];";
}
else
{
out << nl << "[" << stream << " newObject:&" << param << "];";
}
}
}
else if(builtin->kind() == Builtin::KindObjectProxy)
{
if(marshal)
{
out << nl << "[" << stream << " writeProxy:" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << param << " = [" << stream << " readProxy:[ICEObjectPrx class]];";
}
else
{
out << nl << param << " = [" << stream << " newProxy:[ICEObjectPrx class]];";
}
}
}
else
{
if(marshal)
{
out << nl << "[" << stream << " write" << getBuiltinName(builtin) << ":" << param << "];";
}
else
{
if(autoreleased || isValueType(builtin))
{
out << nl << param << " = [" << stream << " read" << getBuiltinName(builtin) << "];";
}
else
{
out << nl << param << " = [" << stream << " new" << getBuiltinName(builtin) << "];";
}
}
}
return;
}
ProxyPtr prx = ProxyPtr::dynamicCast(type);
if(prx)
{
if(marshal)
{
out << nl << "[" << stream << " writeProxy:(id<ICEObjectPrx>)" << param << "];";
}
else
{
string name = moduleName(findModule(prx->_class())) + prx->_class()->name() + "Prx";
out << nl << param << " = (id<" << name << ">)[" << stream;
if(autoreleased)
{
out << " readProxy:";
}
else
{
out << " newProxy:";
}
//
// We use objc_getClass to get the proxy class instead of [name class]. This is to avoid
// a warning if the proxy is forward declared.
//
if(prx->_class()->definition())
{
out << "[" << name << " class]];";
}
else
{
out << "objc_getClass(\"" << name << "\")];";
}
}
return;
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
if(marshal)
{
// Cast avoids warning for forward-declared classes.
out << nl << "[" << stream << " writeObject:(ICEObject*)" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << "[" << stream << " " << "readObject:(ICEObject**)&" << param;
}
else
{
out << nl << "[" << stream << " " << "newObject:(ICEObject**)&" << param;
}
if(cl->isInterface())
{
out << "];";
}
else
{
string name = moduleName(findModule(cl)) + cl->name();
if(cl->definition())
{
out << " expectedType:[" << name << " class]];";
}
else
{
out << " expectedType:objc_getClass(\"" << name << "\")];";
}
}
}
return;
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
if(marshal)
{
out << nl << "[" << stream << " writeEnumerator:" << param << " min:" << en->minValue()
<< " max:" << en->maxValue() << "];";
}
else
{
out << nl << param << " = " << "[" << stream << " readEnumerator:" << en->minValue()
<< " max:" << en->maxValue() << "];";
}
return;
}
ContainedPtr c = ContainedPtr::dynamicCast(type);
assert(c);
string name = moduleName(findModule(c)) + c->name() + "Helper";
if(marshal)
{
out << nl << "[" + name << " write:" << param << " stream:" << stream << "];";
}
else
{
if(StructPtr::dynamicCast(type))
{
if(autoreleased)
{
out << nl << param << " = [" << name << " read:" << stream << " value:" << param << "];";
}
else
{
out << nl << param << " = [" << name << " readRetained:" << stream << " value:" << param << "];";
}
}
else
{
if(autoreleased)
{
out << nl << param << " = [" << name << " read:" << stream << "];";
}
else
{
out << nl << param << " = [" << name << " readRetained:" << stream << "];";
}
}
}
}
void
CodeVisitor::writeDefaultValue(const TypePtr& p)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindBool:
{
_out << "false";
break;
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
{
_out << "0";
break;
}
case Builtin::KindFloat:
case Builtin::KindDouble:
{
_out << "0.0";
break;
}
case Builtin::KindString:
{
_out << "''";
break;
}
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
_out << "null";
break;
}
}
return;
}
EnumPtr en = EnumPtr::dynamicCast(p);
if(en)
{
EnumeratorList enums = en->getEnumerators();
_out << getAbsolute(en, _ns) << "::" << fixIdent(enums.front()->name());
return;
}
//
// PHP does not allow the following construct:
//
// function foo($theStruct=new MyStructType)
//
// Instead we use null as the default value and allocate an instance in
// the constructor.
//
StructPtr st = StructPtr::dynamicCast(p);
if(st)
{
_out << "null";
return;
}
_out << "null";
}
void
Slice::Ruby::CodeVisitor::visitEnum(const EnumPtr& p)
{
string scoped = p->scoped();
string name = fixIdent(p->name(), IdentToUpper);
EnumeratorList enums = p->getEnumerators();
EnumeratorList::iterator q;
int i;
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper) << ')';
_out.inc();
_out << nl << "class " << name;
_out.inc();
_out << nl << "include Comparable";
_out << sp << nl << "def initialize(val)";
_out.inc();
{
ostringstream assertion;
assertion << "fail(\"invalid value #{val} for " << name << "\") unless(val >= 0 and val < "
<< enums.size() << ')';
_out << nl << assertion.str();
}
_out << nl << "@val = val";
_out.dec();
_out << nl << "end";
//
// from_int
//
{
_out << sp << nl << "def " << name << ".from_int(val)";
ostringstream sz;
sz << enums.size() - 1;
_out.inc();
_out << nl << "raise IndexError, \"#{val} is out of range 0.." << sz.str() << "\" if(val < 0 || val > "
<< sz.str() << ')';
_out << nl << "@@_values[val]";
_out.dec();
_out << nl << "end";
}
//
// to_s
//
_out << sp << nl << "def to_s";
_out.inc();
_out << nl << "@@_names[@val]";
_out.dec();
_out << nl << "end";
//
// to_i
//
_out << sp << nl << "def to_i";
_out.inc();
_out << nl << "@val";
_out.dec();
_out << nl << "end";
//
// <=>
//
_out << sp << nl << "def <=>(other)";
_out.inc();
_out << nl << "other.is_a?(" << name << ") or raise ArgumentError, \"value must be a " << name << "\"";
_out << nl << "@val <=> other.to_i";
_out.dec();
_out << nl << "end";
//
// hash
//
_out << sp << nl << "def hash";
_out.inc();
_out << nl << "@val.hash";
_out.dec();
_out << nl << "end";
//
// inspect
//
_out << sp << nl << "def inspect";
_out.inc();
_out << nl << "@@_names[@val] + \"(#{@val})\"";
_out.dec();
_out << nl << "end";
//
// each
//
_out << sp << nl << "def " << name << ".each(&block)";
_out.inc();
_out << nl << "@@_values.each(&block)";
_out.dec();
_out << nl << "end";
_out << sp << nl << "@@_names = [";
for(q = enums.begin(); q != enums.end(); ++q)
{
if(q != enums.begin())
{
_out << ", ";
}
_out << "'" << (*q)->name() << "'";
}
_out << ']';
_out << nl << "@@_values = [";
for(EnumeratorList::size_type j = 0; j < enums.size(); ++j)
{
if(j > 0)
{
_out << ", ";
}
ostringstream idx;
idx << j;
_out << name << ".new(" << idx.str() << ')';
}
_out << ']';
//
// Constant for each enumerator.
//
_out << sp;
for(q = enums.begin(), i = 0; q != enums.end(); ++q, ++i)
{
ostringstream idx;
idx << i;
_out << nl << fixIdent((*q)->name(), IdentToUpper) << " = @@_values[" << idx.str() << "]";
}
_out << sp << nl << "private_class_method :new";
_out.dec();
_out << nl << "end"; // End of class.
//
// Emit the type information.
//
_out << sp << nl << "T_" << name << " = ::Ice::__defineEnum('" << scoped << "', " << name << ", [";
for(q = enums.begin(); q != enums.end(); ++q)
{
if(q != enums.begin())
{
_out << ", ";
}
_out << name << "::" << fixIdent((*q)->name(), IdentToUpper);
}
_out << "])";
_out.dec();
_out << nl << "end"; // if not defined?()
}
string
Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
{
static const char* inputBuiltinTable[] =
{
"::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&"
};
typeCtx |= TypeContextInParam;
if(optional)
{
return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindString)
{
return string("const ") + stringTypeToString(type, metaData, typeCtx) + "&";
}
else
{
return inputBuiltinTable[builtin->kind()];
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
return "const " + fixKwd(cl->scoped() + "Ptr&");
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(findMetaData(st->getMetaData()) == "%class")
{
return "const " + fixKwd(st->scoped() + "Ptr&");
}
return "const " + fixKwd(st->scoped()) + "&";
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
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)
{
return "const " + sequenceTypeToString(seq, metaData, typeCtx) + "&";
}
DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
if(dict)
{
return "const " + dictionaryTypeToString(dict, metaData, typeCtx) + "&";
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return "const " + 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::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 "???";
}
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
FreezeScript::AnalyzeTransformVisitor::visitEnum(const EnumPtr& v)
{
if(v->isLocal())
{
return;
}
string scoped = v->scoped();
if(ignoreType(scoped))
{
return;
}
TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
if(l.empty())
{
_missingTypes.push_back(scoped);
return;
}
EnumPtr newEnum = EnumPtr::dynamicCast(l.front());
if(!newEnum)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return;
}
map<string, int> m;
{
Slice::EnumeratorList enumerators = newEnum->getEnumerators();
int i = 0;
for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
{
m.insert(map<string, int>::value_type((*p)->name(), i));
}
}
_out.newline();
_out.newline();
_out << "<!-- enum " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
Slice::EnumeratorList enumerators = v->getEnumerators();
int i = 0;
for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
{
map<string, int>::const_iterator q = m.find((*p)->name());
if(q == m.end())
{
_out.newline();
_out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has been removed -->";
}
else if(q->second != i)
{
_out.newline();
_out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has changed position -->";
}
}
_out << ee;
}
string TarsAnalyzer::tostrEnum(const EnumPtr &pPtr)
{
return pPtr->getSid();
}
void
Slice::ObjCGenerator::MetaDataVisitor::validate(const ContainedPtr& cont)
{
ModulePtr m = ModulePtr::dynamicCast(cont);
if(m)
{
bool error = false;
bool foundPrefix = false;
StringList meta = getMetaData(m);
for(StringList::iterator p = meta.begin(); p != meta.end();)
{
string s = *p++;
const string prefix = "objc:prefix:";
string name;
if(s.find(prefix) == 0)
{
foundPrefix = true;
name = trim(s.substr(prefix.size()));
if(name.empty())
{
m->definitionContext()->warning(InvalidMetaData, m->definitionContext()->filename(),
m->line(), _msg + " `" + s + "'");
meta.remove(s);
error = true;
}
else
{
if(!addModule(m, name))
{
modulePrefixError(m, s);
}
}
}
else
{
m->definitionContext()->warning(InvalidMetaData, m->definitionContext()->filename(),
m->line(), _msg + " `" + s + "'");
meta.remove(s);
error = true;
}
}
setMetaData(m, meta);
if(!error && !foundPrefix)
{
StringList names = splitScopedName(m->scoped());
string name;
for(StringList::const_iterator i = names.begin(); i != names.end(); ++i)
{
name += *i;
}
if(!addModule(m, name))
{
modulePrefixError(m, "");
}
}
}
EnumPtr en = EnumPtr::dynamicCast(cont);
if(en)
{
StringList meta = getMetaData(en);
for(StringList::iterator p = meta.begin(); p != meta.end();)
{
string s = *p;
if(s != "objc:scoped")
{
en->definitionContext()->warning(InvalidMetaData, en->definitionContext()->filename(),
en->line(), _msg + " `" + s + "'");
meta.erase(p++);
}
else
{
++p;
}
}
setMetaData(en, meta);
}
}
