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;
}
string
Slice::ObjCGenerator::getFactoryMethod(const ContainedPtr& p, bool deprecated)
{
ClassDefPtr def = ClassDefPtr::dynamicCast(p);
if(def && def->declaration()->isLocal())
{
deprecated = false; // Local classes don't have this issue since they were added after this fix.
}
//
// If deprecated is true, we return uDPConnectionInfo for a class
// named UDPConnectionInfo, return udpConnectionInfo otherwise.
//
string name = fixId(p->name());
if(name.empty())
{
return name;
}
else if(deprecated || name.size() < 2 || !isupper(*(name.begin() + 1)))
{
*name.begin() = tolower(*name.begin());
}
else
{
for(string::iterator p = name.begin(); p != name.end() && isalpha(*p); ++p)
{
if(p != name.end() - 1 && isalpha(*(p + 1)) && !isupper(*(p + 1)))
{
break;
}
*p = tolower(*p);
}
}
return name;
}
void ClassCheck::doCheck(
const StaticContextPtr& pRootCtx,
const ASTNodePtr& pNode,
const LogPtr& pLog) const
{
if (pNode->getASTNodeType() != ASTN_CLASS)
{
return;
}
ClassDefPtr pClassDef = boost::static_pointer_cast<ClassDef>(pNode);
const list<const wstring>& ifaces = pClassDef->getImplementedInterfaces();
list<const wstring>::const_iterator it;
for (it = ifaces.begin(); it != ifaces.end(); it++)
{
const wstring& ifaceName = *it;
CStaticContextEntryPtr pEntry;
InterfaceDefPtr pInterfaceDef;
if (!pRootCtx->lookup(ifaceName, pEntry))
{
boost::wformat f(L"Interface %1% not found.");
f % ifaceName;
pLog->log(*pClassDef, msg::ErrAnaClassDef_IfaceNotFound, f.str());
continue;
}
else if (!pEntry->getInterface(pInterfaceDef))
{
boost::wformat f(L"%1% is not an interface.");
f % ifaceName;
pLog->log(*pClassDef, msg::ErrAnaClassDef_NotAnIface, f.str());
continue;
}
checkInterfaceParams(pClassDef, pInterfaceDef, pRootCtx, pLog);
checkInterfaceVars(pClassDef, pInterfaceDef, pRootCtx, pLog);
}
const list<VariableDeclDefPtr>& vars = pClassDef->getVariableDecls();
list<VariableDeclDefPtr>::const_iterator vit;
for (vit = vars.begin(); vit != vars.end(); vit++)
{
const VariableDeclDefPtr& pVar = *vit;
if (pVar->getValue().get() == NULL)
{
boost::wformat f(L"Unassigned class variable %1%.");
f % pVar->getName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_UnassignedClassVar, f.str());
continue;
}
}
}
virtual bool visitClassDefStart(const ClassDefPtr& p)
{
if(p->compactId() != -1)
{
_r->add(p->compactId(), p->scoped());
}
return true;
}
TEST(TestProtocol, testClass)
{
PARSE_STATEMENT(L"class SomeClass: SomeSuperclass, FirstProtocol, AnotherProtocol {\n"
L"// class definition goes here\n"
L"}");
ClassDefPtr c;
ASSERT_NOT_NULL(c = std::dynamic_pointer_cast<ClassDef>(root));
ASSERT_EQ(3, c->numParents());
}
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;
}
void ClassCheck::checkInterfaceVars(
const ClassDefPtr& pClassDef,
const InterfaceDefPtr& pInterfaceDef,
const StaticContextPtr& pRootCtx,
const LogPtr& pLog) const
{
const list<VariableDeclDefPtr>& classVars = pClassDef->getVariableDecls();
const list<VariableDeclDefPtr>& ifaceVars = pInterfaceDef->getVariableDecls();
map<const wstring, VariableDeclDefPtr> classVarsMap;
map<const wstring, VariableDeclDefPtr>::const_iterator mit;
list<VariableDeclDefPtr>::const_iterator cit;
for (cit = classVars.begin(); cit != classVars.end(); cit++)
{
const VariableDeclDefPtr& pVariableDecl = *cit;
classVarsMap[pVariableDecl->getName()] = pVariableDecl;
}
list<VariableDeclDefPtr>::const_iterator iit;
for (iit = ifaceVars.begin(); iit != ifaceVars.end(); iit++)
{
const VariableDeclDefPtr& pIfaceVariableDecl = *iit;
const wstring& variableName = pIfaceVariableDecl->getName();
if ((mit = classVarsMap.find(variableName)) == classVarsMap.end())
{
boost::wformat f(L"Variable %1% defined on interface %2% not found in class.");
f % variableName % pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_MissingIfaceVar, f.str());
continue;
}
const VariableDeclDefPtr& pClassVariableDecl = (*mit).second;
if (pIfaceVariableDecl->isStatic() != pClassVariableDecl->isStatic())
{
boost::wformat f(L"Variable %1% has invalid scope. See interface %2%");
f % variableName % pInterfaceDef->getClassName();
pLog->log(*pClassVariableDecl, msg::ErrAnaClassDef_IfaceVarWrongScope, f.str());
continue;
}
if (!SemanticAnalysis::isTypeAssignableFrom(
pClassVariableDecl->getDeclaredType(),
pIfaceVariableDecl->getDeclaredType(),
pRootCtx))
{
boost::wformat f(L"Can't convert from %1% to %2% at class variable %3% defined on interface %4%");
f % pIfaceVariableDecl->getDeclaredType()->toString()%
pClassVariableDecl->getDeclaredType()->toString() %
variableName %
pInterfaceDef->getClassName();
pLog->log(*pClassVariableDecl, msg::ErrAnaClassDef_IfaceVarIncompTypes, f.str());
continue;
}
}
}
void FunctionAnalyzer::visitClass(const ClassDefPtr& node)
{
SymbolScope* scope = symbolRegistry->getCurrentScope();
SymbolPtr sym = scope->getForwardDeclaration(node->getIdentifier()->getName());
TypePtr type = static_pointer_cast<Type>(sym);
ScopeGuard guard(symbolRegistry, type->getScope());
SCOPED_SET(ctx->currentType, type);
semanticAnalyzer->visitImplementation(node, this, true);
}
void
Slice::ObjCGenerator::MetaDataVisitor::visitOperation(const OperationPtr& p)
{
if(p->hasMetaData("UserException"))
{
ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container());
if(!cl->isLocal())
{
ostringstream os;
os << "ignoring invalid metadata `UserException': directive applies only to local operations "
<< ": warning: metadata directive `UserException' applies only to local operations "
<< "but enclosing " << (cl->isInterface() ? "interface" : "class") << "`" << cl->name()
<< "' is not local";
emitWarning(p->file(), p->line(), os.str());
}
}
validate(p);
}
void PairPosLookup2::apply (OpenTypeText::iterator begin, OpenTypeText::iterator ¤t,
OpenTypeText::iterator scopeEnd, OpenTypeText::iterator end) const
{
if (coverage->isCovered ((*current)->getGlyphId(), NULL)) {
UShort index1 = class1->getClass ((*current)->getGlyphId());
OpenTypeText::iterator second = current;
second ++;
if (second != scopeEnd) {
UShort index2 = class2->getClass ((*second)->getGlyphId());
const Values &v = (pairSets [index1]) [index2];
v.v1->apply (current);
v.v2->apply (second);
if (!secondEmpty)
// Skip next character for this lookup
current ++;
}
}
current ++;
}
void
CodeVisitor::collectClassMembers(const ClassDefPtr& p, MemberInfoList& allMembers, bool inherited)
{
ClassList bases = p->bases();
if(!bases.empty() && !bases.front()->isInterface())
{
collectClassMembers(bases.front(), allMembers, true);
}
DataMemberList members = p->dataMembers();
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
MemberInfo m;
m.fixedName = fixIdent((*q)->name());
m.inherited = inherited;
m.dataMember = *q;
allMembers.push_back(m);
}
}
string
Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx, bool cpp11)
{
assert(cl->isDelegate());
// A delegate only has one operation
OperationPtr op = cl->allOperations().front();
TypePtr ret = op->returnType();
string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), typeCtx, cpp11);
string t = "::std::function<" + retS + " (";
if(cpp11)
{
// inputTypeToString usually passes local operation values by
// reference. This is not the desired behavior for delegates
typeCtx &= ~TypeContextLocalOperation;
typeCtx |= TypeContextDelegate;
}
ParamDeclList paramList = cl->allOperations().front()->parameters();
for(ParamDeclList::iterator q = paramList.begin(); q != paramList.end(); ++q)
{
if((*q)->isOutParam())
{
t += outputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx, cpp11);
}
else
{
t += inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx, cpp11);
}
t += distance(q, paramList.end()) == 1 ? "" : ", ";
}
t += ")>";
return t;
}
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;
}
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;
}
/*
“GRAMMAR OF A CLASS DECLARATION
class-declaration → attributes opt class class-name generic-parameter-clause opt type-inheritance-clause opt class-body
class-name → identifier
class-body → {declarations opt}”
*/
DeclarationPtr Parser::parseClass(const std::vector<AttributePtr>& attrs)
{
Token token;
expect(Keyword::Class, token);
ClassDefPtr ret = nodeFactory->createClass(token.state);
ret->setAttributes(attrs);
expect_identifier(token);
TypeIdentifierPtr typeId = nodeFactory->createTypeIdentifier(token.state);
typeId->setName(token.token);
ret->setIdentifier(typeId);
if(predicate(L"<"))
{
GenericParametersDefPtr params = parseGenericParametersDef();
ret->setGenericParametersDef(params);
}
if(match(L":"))
{
do
{
TypeIdentifierPtr protocol = parseTypeIdentifier();
ret->addParent(protocol);
}while(match(L","));
}
Flags f(this);
f += UNDER_CLASS;
expect(L"{");
while(!predicate(L"}"))
{
DeclarationPtr decl = parseDeclaration();
ret->addDeclaration(decl);
}
expect(L"}");
return ret;
}
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 "???";
}
bool
CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
{
string scoped = p->scoped();
string name = getName(p);
string type = getTypeVar(p);
string abs = getAbsolute(p, _ns);
string prxName = getName(p, "Prx");
string prxType = getTypeVar(p, "Prx");
string prxAbs = getAbsolute(p, _ns, "", "Prx");
ClassList bases = p->bases();
ClassDefPtr base;
OperationList ops = p->operations();
OperationList::iterator oli;
DataMemberList members = p->dataMembers();
bool isInterface = p->isInterface();
bool isAbstract = isInterface || p->allOperations().size() > 0; // Don't use isAbstract() - see bug 3739
startNamespace(p);
//
// Define the class.
//
if(isInterface)
{
_out << sp << nl << "if(!interface_exists('" << escapeName(abs) << "'))";
_out << sb;
_out << nl << "interface " << name;
if(!bases.empty())
{
_out << " extends ";
for(ClassList::const_iterator q = bases.begin(); q != bases.end(); ++q)
{
if(q != bases.begin())
{
_out << ", ";
}
_out << getAbsolute(*q, _ns);
}
}
_out << sb;
for(oli = ops.begin(); oli != ops.end(); ++oli)
{
_out << nl << "public function " << fixIdent((*oli)->name()) << '(';
ParamDeclList params = (*oli)->parameters();
for(ParamDeclList::iterator q = params.begin(); q != params.end(); ++q)
{
if(q != params.begin())
{
_out << ", ";
}
_out << '$' << fixIdent((*q)->name());
}
_out << ");";
}
_out << eb;
}
else
{
_out << sp << nl << "if(!class_exists('" << escapeName(abs) << "'))";
_out << sb;
_out << nl;
if(isAbstract)
{
_out << "abstract ";
}
_out << "class " << name;
if(!bases.empty() && !bases.front()->isInterface())
{
base = bases.front();
bases.pop_front();
}
if(base)
{
_out << " extends " << getAbsolute(base, _ns);
}
else
{
if(!p->isLocal())
{
_out << " extends " << scopedToName("::Ice::ObjectImpl", _ns);
}
}
if(!bases.empty())
{
_out << " implements ";
for(ClassList::const_iterator q = bases.begin(); q != bases.end(); ++q)
{
if(q != bases.begin())
{
_out << ", ";
}
_out << getAbsolute(*q, _ns);
}
}
_out << sb;
//
// __construct
//
_out << nl << "public function __construct(";
MemberInfoList allMembers;
collectClassMembers(p, allMembers, false);
writeConstructorParams(allMembers);
_out << ")";
_out << sb;
if(base)
{
_out << nl << "parent::__construct(";
int count = 0;
for(MemberInfoList::iterator q = allMembers.begin(); q != allMembers.end(); ++q)
{
if(q->inherited)
{
if(count)
{
_out << ", ";
}
_out << '$' << q->fixedName;
++count;
}
}
_out << ");";
}
{
for(MemberInfoList::iterator q = allMembers.begin(); q != allMembers.end(); ++q)
{
if(!q->inherited)
{
writeAssign(*q);
}
}
}
_out << eb;
if(!ops.empty())
{
_out << sp;
for(oli = ops.begin(); oli != ops.end(); ++oli)
{
_out << nl << "abstract public function " << fixIdent((*oli)->name()) << '(';
ParamDeclList params = (*oli)->parameters();
for(ParamDeclList::iterator q = params.begin(); q != params.end(); ++q)
{
if(q != params.begin())
{
_out << ", ";
}
_out << '$' << fixIdent((*q)->name());
}
_out << ");";
}
}
if(!p->isLocal())
{
//
// ice_staticId
//
_out << sp << nl << "public static function ice_staticId()";
_out << sb;
_out << nl << "return '" << scoped << "';";
_out << eb;
}
//
// __toString
//
_out << sp << nl << "public function __toString()";
_out << sb;
_out << nl << "global " << type << ';';
_out << nl << "return IcePHP_stringify($this, " << type << ");";
_out << eb;
if(!members.empty())
{
_out << sp;
bool isProtected = p->hasMetaData("protected");
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
_out << nl;
if(isProtected || (*q)->hasMetaData("protected"))
{
_out << "protected ";
}
else
{
_out << "public ";
}
_out << "$" << fixIdent((*q)->name()) << ";";
}
}
_out << eb; // End of class.
}
//
// Define the proxy class.
//
if(!p->isLocal())
{
_out << sp << nl << "class " << prxName << "Helper";
_out << sb;
_out << sp << nl << "public static function checkedCast($proxy, $facetOrCtx=null, $ctx=null)";
_out << sb;
_out << nl << "return $proxy->ice_checkedCast('" << scoped << "', $facetOrCtx, $ctx);";
_out << eb;
_out << sp << nl << "public static function uncheckedCast($proxy, $facet=null)";
_out << sb;
_out << nl << "return $proxy->ice_uncheckedCast('" << scoped << "', $facet);";
_out << eb;
_out << eb;
}
if(_classHistory.count(scoped) == 0 && p->canBeCyclic())
{
//
// Emit a forward declaration for the class in case a data member refers to this type.
//
_out << sp << nl << type << " = IcePHP_declareClass('" << scoped << "');";
}
//
// Emit the type information.
//
_out << sp << nl << type << " = IcePHP_defineClass('" << scoped << "', '" << escapeName(abs) << "', "
<< (isAbstract ? "true" : "false") << ", ";
if(!base)
{
_out << "$Ice__t_Object";
}
else
{
_out << getTypeVar(base);
}
_out << ", ";
//
// Interfaces
//
if(!bases.empty())
{
_out << "array(";
for(ClassList::const_iterator q = bases.begin(); q != bases.end(); ++q)
{
if(q != bases.begin())
{
_out << ", ";
}
_out << getTypeVar(*q);
}
_out << ')';
}
else
{
_out << "null";
}
_out << ", ";
//
// Members
//
// Data members are represented as an array:
//
// ('MemberName', MemberType)
//
// where MemberType is either a primitive type constant (T_INT, etc.) or the id of a constructed type.
//
if(!members.empty())
{
_out << "array(";
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
if(q != members.begin())
{
_out << ',' << nl;
}
_out.inc();
_out << nl << "array('" << fixIdent((*q)->name()) << "', ";
writeType((*q)->type());
_out << ')';
_out.dec();
}
_out << ')';
}
else
{
_out << "null";
}
_out << ");";
if(!p->isLocal())
{
_out << sp << nl << prxType << " = IcePHP_defineProxy(" << type << ");";
//
// Define each operation. The arguments to IcePHP_defineOperation are:
//
// $ClassType, 'opName', Mode, SendMode, (InParams), (OutParams), ReturnType, (Exceptions)
//
// where InParams and OutParams are arrays of type descriptions, and Exceptions
// is an array of exception type ids.
//
if(!ops.empty())
{
_out << sp;
for(oli = ops.begin(); oli != ops.end(); ++oli)
{
ParamDeclList params = (*oli)->parameters();
ParamDeclList::iterator t;
int count;
_out << nl << "IcePHP_defineOperation(" << type << ", '" << (*oli)->name() << "', "
<< getOperationMode((*oli)->mode(), _ns) << ", " << getOperationMode((*oli)->sendMode(), _ns)
<< ", ";
for(t = params.begin(), count = 0; t != params.end(); ++t)
{
if(!(*t)->isOutParam())
{
if(count == 0)
{
_out << "array(";
}
else if(count > 0)
{
_out << ", ";
}
writeType((*t)->type());
++count;
}
}
if(count > 0)
{
_out << ')';
}
else
{
_out << "null";
}
_out << ", ";
for(t = params.begin(), count = 0; t != params.end(); ++t)
{
if((*t)->isOutParam())
{
if(count == 0)
{
_out << "array(";
}
else if(count > 0)
{
_out << ", ";
}
writeType((*t)->type());
++count;
}
}
if(count > 0)
{
_out << ')';
}
else
{
_out << "null";
}
_out << ", ";
TypePtr returnType = (*oli)->returnType();
if(returnType)
{
writeType(returnType);
}
else
{
_out << "null";
}
_out << ", ";
ExceptionList exceptions = (*oli)->throws();
if(!exceptions.empty())
{
_out << "array(";
for(ExceptionList::iterator u = exceptions.begin(); u != exceptions.end(); ++u)
{
if(u != exceptions.begin())
{
_out << ", ";
}
_out << getTypeVar(*u);
}
_out << ')';
}
else
{
_out << "null";
}
_out << ");";
}
}
}
_out << eb;
endNamespace();
if(_classHistory.count(scoped) == 0)
{
_classHistory.insert(scoped); // Avoid redundant declarations.
}
return false;
}
void ClassCheck::checkInterfaceParams(
const ClassDefPtr& pClassDef,
const InterfaceDefPtr& pInterfaceDef,
const StaticContextPtr& pRootCtx,
const LogPtr& pLog) const
{
const map<const wstring, FormalParamDefPtr>& ifaceFormalParams =
pInterfaceDef->getFormalParametersMap();
const map<const wstring, FormalParamDefPtr>& classFormalParams =
pClassDef->getFormalParametersMap();
if (ifaceFormalParams.empty())
{
return;
}
map<const wstring, FormalParamDefPtr>::const_iterator iit;
map<const wstring, FormalParamDefPtr>::const_iterator cit;
for (iit = ifaceFormalParams.begin(); iit != ifaceFormalParams.end(); iit++)
{
const FormalParamDefPtr& pIfaceParam = (*iit).second;
cit = classFormalParams.find(pIfaceParam->getParamName());
if (cit == classFormalParams.end())
{
boost::wformat f(L"Interface parameter %1% not found.");
f % pIfaceParam->getParamName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_MissingIfaceParam, f.str());
continue;
}
const FormalParamDefPtr& pClassParam = (*cit).second;
if (!SemanticAnalysis::isTypeAssignableFrom(
pClassParam->getType(),
pIfaceParam->getType(),
pRootCtx))
{
boost::wformat f(
L"Can't convert from %1% to %2% at class parameter %3% defined on interface %4%.");
f % pIfaceParam->getType()->toString() %
pClassParam->getType()->toString() %
pIfaceParam->getParamName() %
pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_IfaceParamIncompTypes, f.str());
continue;
}
}
for (cit = classFormalParams.begin(); cit != classFormalParams.end(); cit++)
{
const wstring& classParamName = (*cit).first;
iit = ifaceFormalParams.find(classParamName);
if (iit == ifaceFormalParams.end())
{
boost::wformat f(L"Class parameter %1% not defined on interface %2%.");
f % classParamName % pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_ClassParamNotFoundIface, f.str());
continue;
}
}
}
bool
Slice::Ruby::CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
{
string scoped = p->scoped();
string name = fixIdent(p->name(), IdentToUpper);
ClassList bases = p->bases();
ClassDefPtr base;
OperationList ops = p->operations();
OperationList::iterator oli;
//
// Define a mix-in module for the class.
//
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper) << "_mixin)";
_out.inc();
_out << nl << "module " << name << "_mixin";
_out.inc();
if(!p->isLocal())
{
if(!bases.empty() && !bases.front()->isInterface())
{
base = bases.front();
_out << nl << "include " << getAbsolute(bases.front(), IdentToUpper) << "_mixin";
}
else
{
_out << nl << "include ::Ice::Object_mixin";
}
//
// ice_ids
//
ClassList allBases = p->allBases();
StringList ids;
#if defined(__IBMCPP__) && defined(NDEBUG)
//
// VisualAge C++ 6.0 does not see that ClassDef is a Contained,
// when inlining is on. The code below issues a warning: better
// than an error!
//
transform(allBases.begin(), allBases.end(), back_inserter(ids),
IceUtil::constMemFun<string,ClassDef>(&Contained::scoped));
#else
transform(allBases.begin(), allBases.end(), back_inserter(ids), IceUtil::constMemFun(&Contained::scoped));
#endif
StringList other;
other.push_back(scoped);
other.push_back("::Ice::Object");
other.sort();
ids.merge(other);
ids.unique();
_out << sp << nl << "def ice_ids(current=nil)";
_out.inc();
_out << nl << "[";
for(StringList::iterator q = ids.begin(); q != ids.end(); ++q)
{
if(q != ids.begin())
{
_out << ", ";
}
_out << "'" << *q << "'";
}
_out << ']';
_out.dec();
_out << nl << "end";
//
// ice_id
//
_out << sp << nl << "def ice_id(current=nil)";
_out.inc();
_out << nl << "'" << scoped << "'";
_out.dec();
_out << nl << "end";
}
if(!ops.empty())
{
//
// Emit a comment for each operation.
//
_out << sp
<< nl << "#"
<< nl << "# Operation signatures."
<< nl << "#";
for(oli = ops.begin(); oli != ops.end(); ++oli)
{
string fixedOpName = fixIdent((*oli)->name(), IdentNormal);
/* If AMI/AMD is ever implemented...
if(!p->isLocal() && (p->hasMetaData("amd") || (*oli)->hasMetaData("amd")))
{
_out << nl << "# def " << fixedOpName << "_async(_cb";
ParamDeclList params = (*oli)->parameters();
for(ParamDeclList::iterator pli = params.begin(); pli != params.end(); ++pli)
{
if(!(*pli)->isOutParam())
{
_out << ", " << fixIdent((*pli)->name(), IdentToLower);
}
}
if(!p->isLocal())
{
_out << ", current=nil";
}
_out << ")";
}
else
*/
{
_out << nl << "# def " << fixedOpName << "(";
ParamDeclList params = (*oli)->parameters();
bool first = true;
for(ParamDeclList::iterator pli = params.begin(); pli != params.end(); ++pli)
{
if(!(*pli)->isOutParam())
{
if(first)
{
first = false;
}
else
{
_out << ", ";
}
_out << fixIdent((*pli)->name(), IdentToLower);
}
}
if(!p->isLocal())
{
if(!first)
{
_out << ", ";
}
_out << "current=nil";
}
_out << ")";
}
}
}
//
// inspect
//
_out << sp << nl << "def inspect";
_out.inc();
_out << nl << "::Ice::__stringify(self, T_" << name << ")";
_out.dec();
_out << nl << "end";
//
// read/write accessors for data members.
//
DataMemberList members = p->dataMembers();
if(!members.empty())
{
bool prot = p->hasMetaData("protected");
DataMemberList protectedMembers;
DataMemberList::iterator q;
_out << sp << nl << "attr_accessor ";
for(q = members.begin(); q != members.end(); ++q)
{
if(q != members.begin())
{
_out << ", ";
}
_out << ":" << fixIdent((*q)->name(), IdentNormal);
if(prot || (*q)->hasMetaData("protected"))
{
protectedMembers.push_back(*q);
}
}
if(!protectedMembers.empty())
{
_out << nl << "protected ";
for(q = protectedMembers.begin(); q != protectedMembers.end(); ++q)
{
if(q != protectedMembers.begin())
{
_out << ", ";
}
//
// We need to list the symbols of the reader and the writer (e.g., ":member" and ":member=").
//
_out << ":" << fixIdent((*q)->name(), IdentNormal) << ", :"
<< fixIdent((*q)->name(), IdentNormal) << '=';
}
}
}
_out.dec();
_out << nl << "end"; // End of mix-in module for class.
if(p->isInterface())
{
//
// Class.
//
_out << nl << "class " << name;
_out.inc();
_out << nl << "include " << name << "_mixin";
_out << nl;
_out << nl << "def " << name << ".ice_staticId()";
_out.inc();
_out << nl << "'" << scoped << "'";
_out.dec();
_out << nl << "end";
_out.dec();
_out << nl << "end";
}
else
{
//
// Class.
//
_out << nl << "class " << name;
if(base)
{
_out << " < " << getAbsolute(base, IdentToUpper);
}
_out.inc();
_out << nl << "include " << name << "_mixin";
_out << nl;
_out << nl << "def " << name << ".ice_staticId()";
_out.inc();
_out << nl << "'" << scoped << "'";
_out.dec();
_out << nl << "end";
//
// initialize
//
MemberInfoList allMembers;
collectClassMembers(p, allMembers, false);
if(!allMembers.empty())
{
_out << sp << nl << "def initialize(";
writeConstructorParams(allMembers);
_out << ')';
_out.inc();
MemberInfoList::iterator q;
bool inheritsMembers = false;
for(q = allMembers.begin(); q != allMembers.end(); ++q)
{
if(q->inherited)
{
inheritsMembers = true;
break;
}
}
if(inheritsMembers)
{
_out << nl << "super" << spar;
for(q = allMembers.begin(); q != allMembers.end(); ++q)
{
if(q->inherited)
{
_out << q->lowerName;
}
}
_out << epar;
}
for(q = allMembers.begin(); q != allMembers.end(); ++q)
{
if(!q->inherited)
{
_out << nl << '@' << q->fixedName << " = " << q->lowerName;
}
}
_out.dec();
_out << nl << "end";
}
_out.dec();
_out << nl << "end"; // End of class.
}
//
// Generate proxy support. This includes a mix-in module for the proxy's
// operations and a class for the proxy itself.
//
if(!p->isLocal())
{
_out << nl << "module " << name << "Prx_mixin";
_out.inc();
for(ClassList::iterator cli = bases.begin(); cli != bases.end(); ++cli)
{
_out << nl << "include " << getAbsolute(*cli, IdentToUpper) << "Prx_mixin";
}
for(oli = ops.begin(); oli != ops.end(); ++oli)
{
string fixedOpName = fixIdent((*oli)->name(), IdentNormal);
if(fixedOpName == "checkedCast" || fixedOpName == "uncheckedCast")
{
fixedOpName.insert(0, "_");
}
TypePtr ret = (*oli)->returnType();
ParamDeclList paramList = (*oli)->parameters();
string inParams;
for(ParamDeclList::const_iterator q = paramList.begin(); q != paramList.end(); ++q)
{
if(!(*q)->isOutParam())
{
if(!inParams.empty())
{
inParams.append(", ");
}
inParams.append(fixIdent((*q)->name(), IdentToLower));
}
}
_out << sp << nl << "def " << fixedOpName << "(";
if(!inParams.empty())
{
_out << inParams << ", ";
}
_out << "_ctx=nil)";
_out.inc();
_out << nl << name << "_mixin::OP_" << (*oli)->name() << ".invoke(self, [" << inParams;
_out << "], _ctx)";
_out.dec();
_out << nl << "end";
/* If AMI/AMD is ever implemented...
if(p->hasMetaData("ami") || (*oli)->hasMetaData("ami"))
{
_out << sp << nl << "def " << fixedOpName << "_async(_cb";
if(!inParams.empty())
{
_out << ", " << inParams;
}
_out << ", _ctx=nil)";
_out.inc();
_out << nl << name << "_mixin::OP_" << (*oli)->name() << ".invokeAsync(self, _cb, [" << inParams;
if(!inParams.empty() && inParams.find(',') == string::npos)
{
_out << ", ";
}
_out << "], _ctx)";
_out.dec();
_out << nl << "end";
}
*/
}
_out.dec();
_out << nl << "end"; // End of mix-in module for proxy.
_out << nl << "class " << name << "Prx < ::Ice::ObjectPrx";
_out.inc();
_out << nl << "include " << name << "Prx_mixin";
_out << sp << nl << "def " << name << "Prx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)";
_out.inc();
_out << nl << "ice_checkedCast(proxy, '" << scoped << "', facetOrCtx, _ctx)";
_out.dec();
_out << nl << "end";
_out << sp << nl << "def " << name << "Prx.uncheckedCast(proxy, facet=nil)";
_out.inc();
_out << nl << "ice_uncheckedCast(proxy, facet)";
_out.dec();
_out << nl << "end";
_out.dec();
_out << nl << "end"; // End of proxy class.
}
//
// Emit type descriptions.
//
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper, "T_") << ')';
_out.inc();
if(p->isLocal())
{
_out << nl << "T_" << name << " = ::Ice::__declareLocalClass('" << scoped << "')";
}
else
{
_out << nl << "T_" << name << " = ::Ice::__declareClass('" << scoped << "')";
_out << nl << "T_" << name << "Prx = ::Ice::__declareProxy('" << scoped << "')";
}
_out.dec();
_out << nl << "end";
_classHistory.insert(scoped); // Avoid redundant declarations.
bool isAbstract = p->isInterface() || p->allOperations().size() > 0; // Don't use isAbstract() here - see bug 3739
_out << sp << nl << "T_" << name << ".defineClass(" << name << ", " << (isAbstract ? "true" : "false") << ", ";
if(!base)
{
_out << "nil";
}
else
{
_out << getAbsolute(base, IdentToUpper, "T_");
}
_out << ", [";
//
// Interfaces
//
// TODO: Necessary?
//
{
int interfaceCount = 0;
for(ClassList::const_iterator q = bases.begin(); q != bases.end(); ++q)
{
if((*q)->isInterface())
{
if(interfaceCount > 0)
{
_out << ", ";
}
_out << getAbsolute(*q, IdentToUpper, "T_");
++interfaceCount;
}
}
}
//
// Members
//
// Data members are represented as an array:
//
// ['MemberName', MemberType]
//
// where MemberType is either a primitive type constant (T_INT, etc.) or the id of a constructed type.
//
_out << "], [";
if(members.size() > 1)
{
_out.inc();
_out << nl;
}
{
for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
{
if(q != members.begin())
{
_out << ',' << nl;
}
_out << "['" << fixIdent((*q)->name(), IdentNormal) << "', ";
writeType((*q)->type());
_out << ']';
}
}
if(members.size() > 1)
{
_out.dec();
_out << nl;
}
_out << "])";
_out << nl << name << "_mixin::ICE_TYPE = T_" << name;
//
// Define each operation. The arguments to __defineOperation are:
//
// 'opName', Mode, [InParams], [OutParams], ReturnType, [Exceptions]
//
// where InParams and OutParams are arrays of type descriptions, and Exceptions
// is an array of exception types.
//
if(!p->isLocal())
{
_out << sp << nl << "T_" << name << "Prx.defineProxy(" << name << "Prx, T_" << name << ')';
_out << nl << name << "Prx::ICE_TYPE = T_" << name << "Prx";
if(!ops.empty())
{
_out << sp;
}
for(OperationList::iterator s = ops.begin(); s != ops.end(); ++s)
{
ParamDeclList params = (*s)->parameters();
ParamDeclList::iterator t;
int count;
_out << nl << name << "_mixin::OP_" << (*s)->name() << " = ::Ice::__defineOperation('"
<< (*s)->name() << "', ";
switch((*s)->mode())
{
case Operation::Normal:
_out << "::Ice::OperationMode::Normal";
break;
case Operation::Nonmutating:
_out << "::Ice::OperationMode::Nonmutating";
break;
case Operation::Idempotent:
_out << "::Ice::OperationMode::Idempotent";
break;
}
_out << ", ";
switch((*s)->sendMode())
{
case Operation::Normal:
_out << "::Ice::OperationMode::Normal";
break;
case Operation::Nonmutating:
_out << "::Ice::OperationMode::Nonmutating";
break;
case Operation::Idempotent:
_out << "::Ice::OperationMode::Idempotent";
break;
}
_out << ", " << ((p->hasMetaData("amd") || (*s)->hasMetaData("amd")) ? "true" : "false") << ", [";
for(t = params.begin(), count = 0; t != params.end(); ++t)
{
if(!(*t)->isOutParam())
{
if(count > 0)
{
_out << ", ";
}
writeType((*t)->type());
++count;
}
}
_out << "], [";
for(t = params.begin(), count = 0; t != params.end(); ++t)
{
if((*t)->isOutParam())
{
if(count > 0)
{
_out << ", ";
}
writeType((*t)->type());
++count;
}
}
_out << "], ";
TypePtr returnType = (*s)->returnType();
if(returnType)
{
writeType(returnType);
}
else
{
_out << "nil";
}
_out << ", [";
ExceptionList exceptions = (*s)->throws();
for(ExceptionList::iterator u = exceptions.begin(); u != exceptions.end(); ++u)
{
if(u != exceptions.begin())
{
_out << ", ";
}
_out << getAbsolute(*u, IdentToUpper, "T_");
}
_out << "])";
string deprecateMetadata;
if((*s)->findMetaData("deprecate", deprecateMetadata) || p->findMetaData("deprecate", deprecateMetadata))
{
string msg;
string::size_type pos = deprecateMetadata.find(':');
if(pos != string::npos && pos < deprecateMetadata.size() - 1)
{
msg = deprecateMetadata.substr(pos + 1);
}
_out << nl << name << "_mixin::OP_" << (*s)->name() << ".deprecate(\"" << msg << "\")";
}
}
}
_out.dec();
_out << nl << "end"; // if not defined?()
return false;
}
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 "???";
}
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 "???";
}
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;
}
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 "???";
}
bool TypeInference::followPathElement(
const Type& currentType,
const StaticContext& rootCtx,
const wstring& pathElement,
TypePtr& pNextType)
{
boolean isObject = false;
switch (currentType.getBasicType())
{
case FLOAT_B_TYPE:
case INTEGER_B_TYPE:
case STRING_B_TYPE:
case ARRAY_B_TYPE:
{
return false;
}
case OBJECT_B_TYPE:
case CLASS_B_TYPE:
{
const ReferenceType& refType = static_cast<const ReferenceType&>(currentType);
const wstring& className = refType.getReferenceTypeName();
CStaticContextEntryPtr pEntry;
if (!rootCtx.lookup(className, pEntry))
{
return false;
}
list<VariableDeclDefPtr> varsDecls;
if (pEntry->getStaticEntryType() == CLASS_DEF_CTX_ENTRY)
{
ClassDefPtr pClassDefEntry;
pEntry->getClass(pClassDefEntry);
varsDecls = pClassDefEntry->getVariableDecls();
}
else if (pEntry->getStaticEntryType() == INTERFACE_DEF_CTX_ENTRY)
{
InterfaceDefPtr pInterfaceDefEntry;
pEntry->getInterface(pInterfaceDefEntry);
varsDecls = pInterfaceDefEntry->getVariableDecls();
}
else
{
return false;
}
bool isObject = (refType.getBasicType() == OBJECT_REF_TYPE);
list<VariableDeclDefPtr>::const_iterator it;
for (it = varsDecls.begin(); it != varsDecls.end(); it++)
{
VariableDeclDefPtr varDecl = *it;
if (varDecl->getName() == pathElement)
{
if (isObject && varDecl->isStatic())
{
return false;
}
else if (!isObject && !varDecl->isStatic())
{
return false;
}
pNextType = varDecl->getDeclaredType();
return true;
}
}
}
break;
default:
assert(false);
}
return false;
}
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 "???";
}
bool Slice::ChecksumVisitor::visitClassDefStart(const ClassDefPtr& p)
{
if (p->isLocal()) {
return false;
}
ClassList bases = p->bases();
ostringstream ostr;
if (p->isInterface()) {
ostr << "interface ";
} else {
ostr << "class ";
}
ostr << p->name();
if (!bases.empty()) {
if (!bases.front()->isInterface()) {
ostr << " extends " << bases.front()->scoped();
bases.erase(bases.begin());
}
if (!bases.empty()) {
if (p->isInterface()) {
ostr << " extends ";
} else {
ostr << " implements ";
}
for (ClassList::iterator q = bases.begin(); q != bases.end(); ++q) {
if (q != bases.begin()) {
ostr << ", ";
}
ostr << (*q)->scoped();
}
}
}
ostr << endl;
if (p->hasDataMembers()) {
DataMemberList members = p->dataMembers();
for (DataMemberList::iterator q = members.begin(); q != members.end(); ++q) {
ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl;
}
}
if (p->hasOperations()) {
OperationList ops = p->operations();
for (OperationList::iterator q = ops.begin(); q != ops.end(); ++q) {
ostr << typeToString((*q)->returnType()) << ' ' << (*q)->name() << '(';
ParamDeclList params = (*q)->parameters();
for (ParamDeclList::iterator r = params.begin(); r != params.end(); ++r) {
if (r != params.begin()) {
ostr << ", ";
}
if ((*r)->isOutParam()) {
ostr << "out ";
}
ostr << typeToString((*r)->type()) << ' ' << (*r)->name();
}
ostr << ')';
ExceptionList ex = (*q)->throws();
if (!ex.empty()) {
ostr << " throws ";
for (ExceptionList::iterator s = ex.begin(); s != ex.end(); ++s) {
if (s != ex.begin()) {
ostr << ", ";
}
ostr << (*s)->scoped();
}
}
ostr << endl;
}
}
updateMap(p->scoped(), ostr.str());
return false;
}