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