void FreezeScript::AnalyzeInitVisitor::visitDictionary(const DictionaryPtr& v) { if(v->isLocal()) { return; } string scoped = v->scoped(); TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false); if(!l.empty()) { DictionaryPtr d = DictionaryPtr::dynamicCast(l.front()); if(!d) { typeChange(l.front(), scoped, "dictionary"); } else { return; } } _out.newline(); _out.newline(); _out << "<!-- dictionary " << scoped << " -->"; _out << se("init") << attr("type", scoped); _out << ee; }
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::ChecksumVisitor::visitDictionary(const DictionaryPtr& p) { if (p->isLocal()) { return; } ostringstream ostr; ostr << "dictionary<" << typeToString(p->keyType()) << ", " << typeToString(p->valueType()) << "> " << p->name() << endl; updateMap(p->scoped(), ostr.str()); }
string Slice::ObjCGenerator::outTypeToString(const TypePtr& type, bool optional, bool autoreleasing, bool reference) { if(!type) { return "void"; } string s; if(optional) { s = "id"; } else { SequencePtr seq = SequencePtr::dynamicCast(type); DictionaryPtr d = DictionaryPtr::dynamicCast(type); if(isString(type)) { s = "NSMutableString"; } else if(seq) { string prefix = moduleName(findModule(seq)); s = prefix + "Mutable" + seq->name(); } else if(d) { string prefix = moduleName(findModule(d)); s = prefix + "Mutable" + d->name(); } else { s = typeToString(type); } if(mapsToPointerType(type)) { s += "*"; } } if(autoreleasing && !isValueType(type)) { s += " ICE_AUTORELEASING_QUALIFIER"; } if(reference) { s += "*"; } return s; }
void CodeVisitor::visitDictionary(const DictionaryPtr& p) { TypePtr keyType = p->keyType(); BuiltinPtr b = BuiltinPtr::dynamicCast(keyType); if(b) { switch(b->kind()) { case Slice::Builtin::KindBool: case Slice::Builtin::KindByte: case Slice::Builtin::KindShort: case Slice::Builtin::KindInt: case Slice::Builtin::KindLong: case Slice::Builtin::KindString: // // These types are acceptable as dictionary keys. // break; case Slice::Builtin::KindFloat: case Slice::Builtin::KindDouble: emitWarning(p->file(), p->line(), "dictionary key type not supported in PHP"); break; case Slice::Builtin::KindObject: case Slice::Builtin::KindObjectProxy: case Slice::Builtin::KindLocalObject: assert(false); } } else if(!EnumPtr::dynamicCast(keyType)) { emitWarning(p->file(), p->line(), "dictionary key type not supported in PHP"); } string type = getTypeVar(p); startNamespace(p); // // Emit the type information. // string scoped = p->scoped(); _out << sp << nl << "if(!isset(" << type << "))"; _out << sb; _out << nl << type << " = IcePHP_defineDictionary('" << scoped << "', "; writeType(p->keyType()); _out << ", "; writeType(p->valueType()); _out << ");"; _out << eb; endNamespace(); }
void Slice::Ruby::CodeVisitor::visitDictionary(const DictionaryPtr& p) { // // Emit the type information. // string name = fixIdent(p->name(), IdentToUpper); string scoped = p->scoped(); _out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper, "T_") << ')'; _out.inc(); _out << nl << "T_" << name << " = ::Ice::__defineDictionary('" << scoped << "', "; writeType(p->keyType()); _out << ", "; writeType(p->valueType()); _out << ")"; _out.dec(); _out << nl << "end"; // if not defined?() }
void FreezeScript::AnalyzeTransformVisitor::visitDictionary(const DictionaryPtr& v) { if(v->isLocal()) { return; } string scoped = v->scoped(); if(ignoreType(scoped)) { return; } TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false); if(l.empty()) { _missingTypes.push_back(scoped); return; } DictionaryPtr newDict = DictionaryPtr::dynamicCast(l.front()); if(!newDict) { if(!_ignoreTypeChanges) { typeChange(scoped, v, l.front()); } return; } _out.newline(); _out.newline(); _out << "<!-- dictionary " << scoped << " -->"; _out << se("transform") << attr("type", scoped); compareTypes(scoped + " key type", v->keyType(), newDict->keyType()); compareTypes(scoped + " value type", v->valueType(), newDict->valueType()); _out << ee; }
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 << "];"; } }
string Slice::ObjCGenerator::getOptionalFormat(const TypePtr& type) { BuiltinPtr bp = BuiltinPtr::dynamicCast(type); if(bp) { switch(bp->kind()) { case Builtin::KindByte: case Builtin::KindBool: { return "ICEOptionalFormatF1"; } case Builtin::KindShort: { return "ICEOptionalFormatF2"; } case Builtin::KindInt: case Builtin::KindFloat: { return "ICEOptionalFormatF4"; } case Builtin::KindLong: case Builtin::KindDouble: { return "ICEOptionalFormatF8"; } case Builtin::KindString: { return "ICEOptionalFormatVSize"; } case Builtin::KindObject: case Builtin::KindValue: { return "ICEOptionalFormatClass"; } case Builtin::KindObjectProxy: { return "ICEOptionalFormatFSize"; } case Builtin::KindLocalObject: { assert(false); break; } } } if(EnumPtr::dynamicCast(type)) { return "ICEOptionalFormatSize"; } SequencePtr seq = SequencePtr::dynamicCast(type); if(seq) { return seq->type()->isVariableLength() ? "ICEOptionalFormatFSize" : "ICEOptionalFormatVSize"; } DictionaryPtr d = DictionaryPtr::dynamicCast(type); if(d) { return (d->keyType()->isVariableLength() || d->valueType()->isVariableLength()) ? "ICEOptionalFormatFSize" : "ICEOptionalFormatVSize"; } StructPtr st = StructPtr::dynamicCast(type); if(st) { return st->isVariableLength() ? "ICEOptionalFormatFSize" : "ICEOptionalFormatVSize"; } if(ProxyPtr::dynamicCast(type)) { return "ICEOptionalFormatFSize"; } ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type); assert(cl); return "ICEOptionalFormatClass"; }
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::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 "???"; }