void
Slice::Ruby::CodeVisitor::visitClassDecl(const ClassDeclPtr& p)
{
//
// Emit forward declarations.
//
string scoped = p->scoped();
if(_classHistory.count(scoped) == 0)
{
string name = "T_" + fixIdent(p->name(), IdentToUpper);
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper, "T_") << ')';
_out.inc();
if(p->isLocal())
{
_out << nl << name << " = ::Ice::__declareLocalClass('" << scoped << "')";
}
else
{
_out << nl << name << " = ::Ice::__declareClass('" << scoped << "')";
_out << nl << name << "Prx = ::Ice::__declareProxy('" << scoped << "')";
}
_out.dec();
_out << nl << "end";
_classHistory.insert(scoped); // Avoid redundant declarations.
}
}
void
CodeVisitor::visitClassDecl(const ClassDeclPtr& p)
{
//
// Handle forward declarations.
//
string scoped = p->scoped();
string abs = getAbsolute(p, _ns);
if(_classHistory.count(scoped) == 0)
{
startNamespace(p);
string type = getTypeVar(p);
_out << sp << nl << "if(!isset(" << type << "))";
_out << sb;
_out << nl << type << " = IcePHP_declareClass('" << scoped << "');";
if(!p->isLocal())
{
_out << nl << type << "Prx = IcePHP_defineProxy(" << type << ");";
}
_out << eb;
endNamespace();
_classHistory.insert(scoped); // Avoid redundant declarations.
}
}
bool
FreezeScript::AnalyzeInitVisitor::visitClassDefStart(const ClassDefPtr& v)
{
if(v->isInterface() || v->isLocal())
{
return false;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
if(!decl || decl->isInterface())
{
typeChange(l.front(), scoped, "class");
}
else
{
return false;
}
}
_out.newline();
_out.newline();
_out << "<!-- class " << scoped << " -->";
_out << se("init") << attr("type", scoped);
_out << ee;
return false;
}
bool
Slice::ObjCGenerator::mapsToPointerType(const TypePtr& type)
{
if(isValueType(type))
{
return false;
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
return builtin->kind() != Builtin::KindObjectProxy && builtin->kind() != Builtin::KindLocalObject;
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl && cl->isInterface())
{
if(cl->isLocal() || (cl->definition() && cl->definition()->isDelegate()))
{
return false;
}
else
{
return true;
}
}
return !ProxyPtr::dynamicCast(type);
}
bool
Slice::findMetaData(const string& prefix, const ClassDeclPtr& cl, string& value)
{
if(findMetaData(prefix, cl->getMetaData(), value))
{
return true;
}
ClassDefPtr def = cl->definition();
return def ? findMetaData(prefix, def->getMetaData(), value) : false;
}
bool
FreezeScript::AnalyzeTransformVisitor::visitClassDefStart(const ClassDefPtr& v)
{
if(v->isInterface() || 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;
}
ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
if(!decl || decl->isInterface())
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v->declaration(), l.front());
}
return false;
}
ClassDefPtr newClass = decl->definition();
if(!newClass)
{
_missingTypes.push_back(scoped);
return false;
}
_out.newline();
_out.newline();
_out << "<!-- class " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
DataMemberList oldMembers = v->dataMembers();
DataMemberList newMembers = newClass->dataMembers();
compareMembers(oldMembers, newMembers);
_out << ee;
return false;
}
string
Slice::JsGenerator::importPrefix(const TypePtr& type,
const ContainedPtr& toplevel,
const vector<pair<string, string> >& imports)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
return typeToString(type, toplevel, imports, true);
}
else if(ProxyPtr::dynamicCast(type))
{
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
return importPrefix(ContainedPtr::dynamicCast(proxy->_class()->definition()), toplevel, imports);
}
else if(ContainedPtr::dynamicCast(type))
{
bool local = false;
if(toplevel)
{
if(ConstructedPtr::dynamicCast(toplevel))
{
local = ConstructedPtr::dynamicCast(toplevel)->isLocal();
}
else if(ClassDefPtr::dynamicCast(toplevel))
{
local = ClassDefPtr::dynamicCast(toplevel)->isLocal();
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl && cl->isInterface() && !local)
{
return "iceNS0.";
}
else
{
return importPrefix(ContainedPtr::dynamicCast(type), toplevel, imports);
}
}
return "";
}
string
Slice::JsGenerator::getStaticId(const TypePtr& type)
{
BuiltinPtr b = BuiltinPtr::dynamicCast(type);
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
assert((b && b->kind() == Builtin::KindObject) || cl);
if(b)
{
return "Ice.ObjectImpl.ice_staticId()";
}
else if(cl->isInterface())
{
ContainedPtr cont = ContainedPtr::dynamicCast(cl->container());
assert(cont);
return fixId(cont->scoped()) + "." + cl->name() + "Disp_.ice_staticId()";
}
else
{
return fixId(cl->scoped()) + ".ice_staticId()";
}
}
util::String PrintClassDecl::declToString (ClassDeclPtr const & class_decl) const
{
String str;
if (is_inst)
{
// extern only if dll_api is set
if (is_inst_extern && conf::isOptionSet (conf::opt_dll_api))
{
str = "extern ";
}
str += "template";
}
else if (is_frnd)
{
str = "friend";
}
appendWithSpace (str, classKeyToString (class_decl->getKey ()));
if (class_decl->isDllApi ())
{
appendWithSpace (str, conf::getOptionValue (conf::opt_dll_api));
}
appendWithSpace (str, nameToString (class_decl->getName ()));
return str;
}
void PrintClassDecl::print (FilePtr const & file, ClassDeclPtr const & class_decl) const
{
// instantiation extern only if dll_api macro is set
bool has_exports = is_inst && is_inst_extern && conf::isOptionSet (conf::opt_dll_api);
if (has_exports)
{
// we know dll_exports macro is set if dll_api macro is set
file->getStream (skind) << "#ifndef " << conf::getOptionValue (conf::opt_dll_exports) << '\n';
}
String str = declToString (class_decl);
str += ';';
printLine (file, skind, getNameLoc (class_decl->getName ()), str);
if (has_exports)
{
file->getStream (skind) << "#endif" << '\n';
}
}
bool
FreezeScript::AnalyzeTransformVisitor::checkClasses(const ClassDeclPtr& from, const ClassDeclPtr& to)
{
string fromScoped = from->scoped();
string toScoped = to->scoped();
if(fromScoped == toScoped)
{
return true;
}
//
// The types don't match, so check them for compatibility. Specifically,
// look up the old type id in the new Slice and see if it has the target
// type as a base class.
//
TypeList l = to->unit()->lookupTypeNoBuiltin(from->scoped(), false);
if(!l.empty())
{
ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
if(decl)
{
ClassDefPtr def = decl->definition();
if(def)
{
ClassList bases = def->allBases();
for(ClassList::iterator p = bases.begin(); p != bases.end(); ++p)
{
if((*p)->scoped() == toScoped)
{
return true;
}
}
}
}
}
return false;
}
string
Slice::ObjCGenerator::typeToString(const TypePtr& type)
{
if(!type)
{
return "void";
}
static const char* builtinTable[] =
{
"ICEByte",
"BOOL",
"ICEShort",
"ICEInt",
"ICELong",
"ICEFloat",
"ICEDouble",
"NSString",
"ICEObject",
"id<ICEObjectPrx>",
"id", // Dummy--we don't support Slice local Object
"ICEObject"
};
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
return builtinTable[builtin->kind()];
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
string mName = moduleName(findModule(proxy->_class()));
return "id<" + mName + (proxy->_class()->name()) + "Prx>";
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
return fixName(seq);
}
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(d)
{
return fixName(d);
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
if(cl->isInterface())
{
if(cl->definition() && cl->definition()->isDelegate())
{
return fixName(cl);
}
else if(cl->isLocal())
{
return "id<" + fixName(cl) + ">";
}
else
{
return "ICEObject";
}
}
else if(cl->isLocal())
{
string name = fixName(cl);
return name + "<" + name + ">";
}
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
return fixName(contained);
}
return "???";
}
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;
}
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);
}
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::JsGenerator::typeToString(const TypePtr& type,
const ContainedPtr& toplevel,
const vector<pair<string, string> >& imports,
bool typescript,
bool definition)
{
if(!type)
{
return "void";
}
bool local = false;
if(toplevel)
{
if(ConstructedPtr::dynamicCast(toplevel))
{
local = ConstructedPtr::dynamicCast(toplevel)->isLocal();
}
else if(ClassDefPtr::dynamicCast(toplevel))
{
local = ClassDefPtr::dynamicCast(toplevel)->isLocal();
}
}
static const char* typeScriptBuiltinTable[] =
{
"number", // byte
"boolean", // bool
"number", // short
"number", // int
"Ice.Long", // long
"number", // float
"number", // double
"string",
"Ice.Object",
"Ice.ObjectPrx",
"Object",
"Ice.Value"
};
static const char* javaScriptBuiltinTable[] =
{
"Number", // byte
"Boolean", // bool
"Number", // short
"Number", // int
"Ice.Long", // long
"Number", // float
"Number", // double
"String",
"Ice.Value",
"Ice.ObjectPrx",
"Object",
"Ice.Value"
};
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(typescript)
{
int kind = (!local && builtin->kind() == Builtin::KindObject) ? Builtin::KindValue : builtin->kind();
ostringstream os;
if(getModuleMetadata(type) == "ice" && getModuleMetadata(toplevel) != "ice")
{
os << "iceNS0.";
}
os << getUnqualified(typeScriptBuiltinTable[kind], toplevel->scope(), "iceNS0.");
return os.str();
}
else
{
return javaScriptBuiltinTable[builtin->kind()];
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
string prefix;
ostringstream os;
if(typescript)
{
if(cl->isInterface() && !local)
{
prefix = importPrefix("Ice.Value", toplevel);
}
else
{
prefix = importPrefix(ContainedPtr::dynamicCast(cl), toplevel, imports);
}
}
os << prefix;
if(!prefix.empty() && typescript)
{
if(cl->isInterface() && !local)
{
os << getUnqualified("Ice.Value", toplevel->scope(), prefix);
}
else
{
os << getUnqualified(fixId(cl->scoped()), toplevel->scope(), prefix);
}
}
else
{
os << fixId(cl->scoped());
}
return os.str();
}
ProxyPtr proxy = ProxyPtr::dynamicCast(type);
if(proxy)
{
ostringstream os;
ClassDefPtr def = proxy->_class()->definition();
if(!def->isInterface() && def->allOperations().empty())
{
if(getModuleMetadata(toplevel) != "ice")
{
os << "iceNS0.";
}
os << getUnqualified(typeScriptBuiltinTable[Builtin::KindObjectProxy],
toplevel->scope(),
getModuleMetadata(toplevel));
}
else
{
string prefix;
if(typescript)
{
prefix = importPrefix(ContainedPtr::dynamicCast(def), toplevel, imports);
os << prefix;
}
if(prefix.empty() && typescript)
{
os << getUnqualified(fixId(proxy->_class()->scoped() + "Prx"), toplevel->scope(), prefix);
}
else
{
os << fixId(proxy->_class()->scoped() + "Prx");
}
}
return os.str();
}
if(!typescript || definition)
{
SequencePtr seq = SequencePtr::dynamicCast(type);
if (seq)
{
BuiltinPtr b = BuiltinPtr::dynamicCast(seq->type());
if (b && b->kind() == Builtin::KindByte)
{
return "Uint8Array";
}
else
{
return typeToString(seq->type(), toplevel, imports, typescript) + "[]";
}
}
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(d)
{
const TypePtr keyType = d->keyType();
BuiltinPtr builtin = BuiltinPtr::dynamicCast(keyType);
ostringstream os;
if ((builtin && builtin->kind() == Builtin::KindLong) || StructPtr::dynamicCast(keyType))
{
const string prefix = importPrefix("Ice.HashMap", toplevel);
os << prefix << getUnqualified("Ice.HashMap", toplevel->scope(), prefix);
}
else
{
os << "Map";
}
if (typescript)
{
os << "<"
<< typeToString(keyType, toplevel, imports, true) << ", "
<< typeToString(d->valueType(), toplevel, imports, true) << ">";
}
return os.str();
}
}
ContainedPtr contained = ContainedPtr::dynamicCast(type);
if(contained)
{
ostringstream os;
string prefix;
if(typescript)
{
prefix = importPrefix(contained, toplevel, imports);
os << prefix;
}
if(prefix.empty() && typescript)
{
os << getUnqualified(fixId(contained->scoped()), toplevel->scope(), prefix);
}
else
{
os << fixId(contained->scoped());
}
return os.str();
}
return "???";
}
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 << "];";
}
}
}
}
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 "???";
}
