string Slice::ObjCGenerator::typeToObjCTypeString(const TypePtr& type) { ProxyPtr proxy = ProxyPtr::dynamicCast(type); if(proxy) { return moduleName(findModule(proxy->_class())) + (proxy->_class()->name()) + "Prx"; } else { return typeToString(type); } }
string Slice::JsGenerator::getModuleMetadata(const TypePtr& type) { static const char* builtinModuleTable[] = { "", // byte "", // bool "", // short "", // int "ice", // long "", // float "", // double "", // string "ice", // Ice.Value "ice", // Ice.ObjectPrx "", // LocalObject "ice" // Ice.Object }; BuiltinPtr builtin = BuiltinPtr::dynamicCast(type); if(builtin) { return builtinModuleTable[builtin->kind()]; } ProxyPtr proxy = ProxyPtr::dynamicCast(type); return getModuleMetadata(proxy ? ContainedPtr::dynamicCast(proxy->_class()->definition()) : ContainedPtr::dynamicCast(type)); }
string Slice::JsGenerator::typeToString(const TypePtr& type) { if(!type) { return "void"; } static const char* builtinTable[] = { "Number", // byte "Boolean", // bool "Number", // short "Number", // int "Number", // long "Number", // float "Number", // double "String", "Ice.Value", "Ice.ObjectPrx", "Object", "Ice.Value" }; BuiltinPtr builtin = BuiltinPtr::dynamicCast(type); if(builtin) { return builtinTable[builtin->kind()]; } ProxyPtr proxy = ProxyPtr::dynamicCast(type); if(proxy) { return fixId(proxy->_class()->scoped() + "Prx"); } SequencePtr seq = SequencePtr::dynamicCast(type); if(seq) { return typeToString(seq->type()) + "[]"; } DictionaryPtr d = DictionaryPtr::dynamicCast(type); if(d) { const TypePtr keyType = d->keyType(); BuiltinPtr b = BuiltinPtr::dynamicCast(keyType); return ((b && b->kind() == Builtin::KindLong) || StructPtr::dynamicCast(keyType)) ? "Ice.HashMap" : "Map"; } ContainedPtr contained = ContainedPtr::dynamicCast(type); if(contained) { return fixId(contained->scoped()); } return "???"; }
void Slice::ObjCGenerator::writeOptParamMarshalUnmarshalCode(Output &out, const TypePtr& type, const string& param, int tag, bool marshal) const { string helper; BuiltinPtr builtin = BuiltinPtr::dynamicCast(type); ProxyPtr proxy = ProxyPtr::dynamicCast(type); if(builtin) { helper = "ICE" + getBuiltinName(builtin) + "Helper"; } else if(proxy) { helper = moduleName(findModule(proxy->_class())) + (proxy->_class()->name()) + "PrxHelper"; } else { helper = typeToString(type) + "Helper"; } ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type); if(cl) { out << nl; if(marshal) { out << "[" << helper << " writeOpt:" << param << " stream:os_ tag:" << tag << "];"; } else { out << "[" << helper << " readOpt:&" << param << " stream:is_ tag:" << tag << "];"; } return; } out << nl; if(marshal) { out << "[" << helper << " writeOpt:" << param << " stream:os_ tag:" << tag << "];"; } else { out << param << " = [" << helper << " readOpt:is_ tag:" << tag << "];"; } }
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 FreezeScript::typeToString(const TypePtr& type) { BuiltinPtr b = BuiltinPtr::dynamicCast(type); ContainedPtr c = ContainedPtr::dynamicCast(type); if(b) { return b->kindAsString(); } else if(c) { return c->scoped(); } else { ProxyPtr p = ProxyPtr::dynamicCast(type); assert(p); return p->_class()->scoped() + "*"; } }
string Slice::ChecksumVisitor::typeToString(const TypePtr& type) { static const char* builtinTable[] = { "byte", "boolean", "short", "int", "long", "float", "double", "string", "Object", "Object*", "LocalObject" }; if (!type) { return "void"; } BuiltinPtr builtin = BuiltinPtr::dynamicCast(type); if (builtin) { return builtinTable[builtin->kind()]; } ProxyPtr proxy = ProxyPtr::dynamicCast(type); if (proxy) { return proxy->_class()->scoped() + "*"; } ContainedPtr cont = ContainedPtr::dynamicCast(type); assert(cont); return cont->scoped(); }
std::string Slice::JsGenerator::getHelper(const TypePtr& type) { BuiltinPtr builtin = BuiltinPtr::dynamicCast(type); if(builtin) { switch(builtin->kind()) { case Builtin::KindByte: { return "Ice.ByteHelper"; } case Builtin::KindBool: { return "Ice.BoolHelper"; } case Builtin::KindShort: { return "Ice.ShortHelper"; } case Builtin::KindInt: { return "Ice.IntHelper"; } case Builtin::KindLong: { return "Ice.LongHelper"; } case Builtin::KindFloat: { return "Ice.FloatHelper"; } case Builtin::KindDouble: { return "Ice.DoubleHelper"; } case Builtin::KindString: { return "Ice.StringHelper"; } case Builtin::KindObject: case Builtin::KindValue: { return "Ice.ObjectHelper"; } case Builtin::KindObjectProxy: { return "Ice.ObjectPrx"; } case Builtin::KindLocalObject: { assert(false); break; } } } if(EnumPtr::dynamicCast(type)) { return typeToString(type) + "._helper"; } if(StructPtr::dynamicCast(type)) { return typeToString(type); } ProxyPtr prx = ProxyPtr::dynamicCast(type); if(prx) { ClassDefPtr def = prx->_class()->definition(); if(def->isInterface() || def->allOperations().size() > 0) { return typeToString(type); } else { return "Ice.ObjectPrx"; } } if(SequencePtr::dynamicCast(type) || DictionaryPtr::dynamicCast(type)) { stringstream s; s << getLocalScope(ContainedPtr::dynamicCast(type)->scoped()) << "Helper"; return s.str(); } if(ClassDeclPtr::dynamicCast(type)) { return "Ice.ObjectHelper"; } assert(false); return "???"; }
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 << "];"; } }
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::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 "???"; }
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 "???"; }
void CodeVisitor::writeType(const TypePtr& p) { BuiltinPtr builtin = BuiltinPtr::dynamicCast(p); if(builtin) { switch(builtin->kind()) { case Builtin::KindBool: { _out << "$IcePHP__t_bool"; break; } case Builtin::KindByte: { _out << "$IcePHP__t_byte"; break; } case Builtin::KindShort: { _out << "$IcePHP__t_short"; break; } case Builtin::KindInt: { _out << "$IcePHP__t_int"; break; } case Builtin::KindLong: { _out << "$IcePHP__t_long"; break; } case Builtin::KindFloat: { _out << "$IcePHP__t_float"; break; } case Builtin::KindDouble: { _out << "$IcePHP__t_double"; break; } case Builtin::KindString: { _out << "$IcePHP__t_string"; break; } case Builtin::KindObject: { _out << "$Ice__t_Object"; break; } case Builtin::KindObjectProxy: { _out << "$Ice__t_ObjectPrx"; break; } case Builtin::KindLocalObject: { _out << "$Ice__t_LocalObject"; break; } } return; } ProxyPtr prx = ProxyPtr::dynamicCast(p); if(prx) { _out << getTypeVar(prx->_class(), "Prx"); return; } ContainedPtr cont = ContainedPtr::dynamicCast(p); assert(cont); _out << getTypeVar(cont); }
void Slice::Ruby::CodeVisitor::writeType(const TypePtr& p) { BuiltinPtr builtin = BuiltinPtr::dynamicCast(p); if(builtin) { switch(builtin->kind()) { case Builtin::KindBool: { _out << "::Ice::T_bool"; break; } case Builtin::KindByte: { _out << "::Ice::T_byte"; break; } case Builtin::KindShort: { _out << "::Ice::T_short"; break; } case Builtin::KindInt: { _out << "::Ice::T_int"; break; } case Builtin::KindLong: { _out << "::Ice::T_long"; break; } case Builtin::KindFloat: { _out << "::Ice::T_float"; break; } case Builtin::KindDouble: { _out << "::Ice::T_double"; break; } case Builtin::KindString: { _out << "::Ice::T_string"; break; } case Builtin::KindObject: { _out << "::Ice::T_Object"; break; } case Builtin::KindObjectProxy: { _out << "::Ice::T_ObjectPrx"; break; } case Builtin::KindLocalObject: { _out << "::Ice::T_LocalObject"; break; } } return; } ProxyPtr prx = ProxyPtr::dynamicCast(p); if(prx) { _out << getAbsolute(prx->_class(), IdentToUpper, "T_") << "Prx"; return; } ContainedPtr cont = ContainedPtr::dynamicCast(p); assert(cont); _out << getAbsolute(cont, IdentToUpper, "T_"); }
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 "???"; }
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, 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 "???"; }