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