void
FreezeScript::AnalyzeInitVisitor::typeChange(const TypePtr& t, const string& scoped, const string& kind)
{
BuiltinPtr b = BuiltinPtr::dynamicCast(t);
ContainedPtr c = ContainedPtr::dynamicCast(t);
ProxyPtr p = ProxyPtr::dynamicCast(t);
_out.newline();
_out.newline();
_out << "<!-- NOTICE: " << scoped << " has changed from ";
if(b)
{
_out << b->kindAsString();
}
else if(p)
{
_out << "proxy";
}
else
{
assert(c);
_out << c->kindOf();
}
_out << " to " << kind << " -->";
}
bool
Slice::ObjCGenerator::isValueType(const TypePtr& type)
{
if(!type)
{
return true;
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindString:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
return false;
break;
}
default:
{
return true;
break;
}
}
}
if(EnumPtr::dynamicCast(type))
{
return true;
}
return false;
}
bool
Slice::ObjCGenerator::mapsToPointerType(const TypePtr& type)
{
if(isValueType(type))
{
return false;
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
return builtin->kind() != Builtin::KindObjectProxy && builtin->kind() != Builtin::KindLocalObject;
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl && cl->isInterface())
{
if(cl->isLocal() || (cl->definition() && cl->definition()->isDelegate()))
{
return false;
}
else
{
return true;
}
}
return !ProxyPtr::dynamicCast(type);
}
bool
Slice::JsGenerator::isClassType(const TypePtr& type)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
return (builtin && (builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindValue)) ||
ClassDeclPtr::dynamicCast(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 "???";
}
bool
Slice::ObjCGenerator::isString(const TypePtr& type)
{
if(!type)
{
return false;
}
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
return builtin && builtin->kind() == Builtin::KindString;
}
bool
Slice::ObjCGenerator::isClass(const TypePtr& type)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
return builtin->kind() == Builtin::KindObject;
}
return ClassDeclPtr::dynamicCast(type);
}
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();
}
string
Slice::Ruby::CodeVisitor::getInitializer(const TypePtr& p)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindBool:
{
return "false";
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
{
return "0";
}
case Builtin::KindFloat:
case Builtin::KindDouble:
{
return "0.0";
}
case Builtin::KindString:
{
return "''";
}
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
return "nil";
}
}
}
EnumPtr en = EnumPtr::dynamicCast(p);
if(en)
{
EnumeratorList enums = en->getEnumerators();
return getAbsolute(en, IdentToUpper) + "::" + fixIdent(enums.front()->name(), IdentToUpper);
}
StructPtr st = StructPtr::dynamicCast(p);
if(st)
{
return getAbsolute(st, IdentToUpper) + ".new";
}
return "nil";
}
/*******************************BuiltinPtr********************************/
string TarsAnalyzer::tostrBuiltin(const BuiltinPtr &pPtr)
{
string s;
switch(pPtr->kind())
{
case Builtin::KindBool:
s = " bool ";
break;
case Builtin::KindByte:
s = " char ";
break;
case Builtin::KindShort:
//为了兼容java无unsigned, 编结码时把tars问件中 unsigned char 对应到short
//c++中需要还原回来
s = (pPtr->isUnsigned()?"uchar":" short ");
break;
case Builtin::KindInt:
s = (pPtr->isUnsigned()?"ushort":" int ");
break;
case Builtin::KindLong:
s = (pPtr->isUnsigned()?"uint":" int64 ");
break;
case Builtin::KindFloat:
s = " float ";
break;
case Builtin::KindDouble:
s = " double ";
break;
case Builtin::KindString:
if(pPtr->isArray())
s = "char[]"; //char a [8];
else
s = " string ";//string a;
break;
case Builtin::KindVector:
s = " vector ";
break;
case Builtin::KindMap:
s = " map ";
break;
default:
cout << getTab() << " _cur:" << _cur << " _last_pos:" << _last_pos << endl;
exit(-1);
break;
}
return s;
}
/*******************************获取定长数组坐标********************************/
int Jce2Php::getSuffix(const TypeIdPtr &pPtr) const
{
BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr->getTypePtr());
if(bPtr && bPtr->kind() == Builtin::KindString && bPtr->isArray())
{
return bPtr->getSize();
}
VectorPtr vPtr = VectorPtr::dynamicCast(pPtr->getTypePtr());
if(vPtr && vPtr->isArray())
{
return vPtr->getSize();
}
return -1;
}
TypeId::TypeId(const TypePtr& ptr, const string&id)
: _ptr(ptr)
, _id(id)
, _bRequire(true)
, _tag(0)
, _bHasDefault(false)
, _size(0)
, _array(false)
{
BuiltinPtr bPtr = BuiltinPtr::dynamicCast(_ptr);
if(bPtr)
{
_bHasDefault = true;
_default = bPtr->def();
}
}
string Jce2Php::tostrBuiltin(const BuiltinPtr &pPtr) const
{
string s;
switch(pPtr->kind())
{
case Builtin::KindBool:
s = "c_char";
break;
case Builtin::KindByte:
s = (pPtr->isUnsigned()?"c_short":"c_char");
break;
case Builtin::KindShort:
s = (pPtr->isUnsigned()?"c_short":"c_short");
break;
case Builtin::KindInt:
s = (pPtr->isUnsigned()?"c_int":"c_int");
break;
case Builtin::KindLong:
s = "c_int64";
break;
case Builtin::KindFloat:
s = "c_float";
break;
case Builtin::KindDouble:
s = "c_double";
break;
case Builtin::KindString:
s = "c_string";
break;
case Builtin::KindVector:
s = "c_vector";
break;
case Builtin::KindMap:
s = "c_map";
break;
default:
assert(false);
break;
}
return s;
}
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::getEndArg(const TypePtr& type, const StringList& metaData, const string& arg)
{
string endArg = arg;
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
string seqType = findMetaData(metaData, TypeContextInParam);
if(seqType.empty())
{
seqType = findMetaData(seq->getMetaData(), TypeContextInParam);
}
if(seqType == "%array")
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
if(builtin &&
builtin->kind() != Builtin::KindByte &&
builtin->kind() != Builtin::KindString &&
builtin->kind() != Builtin::KindObject &&
builtin->kind() != Builtin::KindObjectProxy)
{
endArg = "___" + endArg;
}
else if(!builtin || builtin->kind() != Builtin::KindByte)
{
endArg = "___" + endArg;
}
}
else if(seqType.find("%range") == 0)
{
StringList md;
if(seqType.find("%range:") == 0)
{
md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
}
endArg = "___" + endArg;
}
}
return endArg;
}
string
Slice::ObjCGenerator::getBuiltinName(const BuiltinPtr& builtin)
{
switch(builtin->kind())
{
case Builtin::KindByte:
{
return "Byte";
}
case Builtin::KindBool:
{
return "Bool";
}
case Builtin::KindShort:
{
return "Short";
}
case Builtin::KindInt:
{
return "Int";
}
case Builtin::KindLong:
{
return "Long";
}
case Builtin::KindFloat:
{
return "Float";
}
case Builtin::KindDouble:
{
return "Double";
}
case Builtin::KindString:
{
return "String";
}
case Builtin::KindObject:
{
return "Object";
}
case Builtin::KindObjectProxy:
{
return "Proxy";
}
default:
{
assert(false);
}
}
return "NO__SUCH__TYPE";
}
int TarsAnalyzer::readBuiltin(const BuiltinPtr &pPtr, int expectTag, bool bIsRequire, TypeIdPtr pType)
{
uint8_t tag = expectTag;
int realType = 0 ;
switch (pPtr->kind())
{
case Builtin::KindBool:
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
{
Int64 n;
read(n, tag, realType, bIsRequire);
cout << "read buf tag [" <<(int)tag <<"|"<< AnalyzerDataHead::tostrType(realType)<<"|"<<n<<"]"<<endl;
}
//compareTag(tag, expectTag, bIsRequire);
break;
case Builtin::KindFloat:
case Builtin::KindDouble:
{
double n;
read(n, tag, realType, bIsRequire);
cout << "read buf tag [" <<(int)tag <<"|"<< AnalyzerDataHead::tostrType(realType) << n<<"]"<<endl;
}
//compareTag(tag, expectTag, bIsRequire);
break;
case Builtin::KindString:
{
string s;
read(s, tag, realType, bIsRequire);
cout << "read buf tag [" <<(int)tag <<"|"<< AnalyzerDataHead::tostrType(realType) << s<<"]"<<endl;
//compareTag(tag, expectTag, bIsRequire);
}
break;
default:
cout << getTab() << " _cur:" << _cur << " _last_pos:" << _last_pos ;
exit(-1);
}
return 0;
}
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();
}
string
Slice::JsGenerator::getStaticId(const TypePtr& type)
{
BuiltinPtr b = BuiltinPtr::dynamicCast(type);
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
assert((b && b->kind() == Builtin::KindObject) || cl);
if(b)
{
return "Ice.ObjectImpl.ice_staticId()";
}
else if(cl->isInterface())
{
ContainedPtr cont = ContainedPtr::dynamicCast(cl->container());
assert(cont);
return fixId(cont->scoped()) + "." + cl->name() + "Disp_.ice_staticId()";
}
else
{
return fixId(cl->scoped()) + ".ice_staticId()";
}
}
void HceParse::checkConstValue(TypeIdPtr &tPtr, int c)
{
//只有内建类型才能有缺省值
BuiltinPtr bPtr = BuiltinPtr::dynamicCast(tPtr->getTypePtr());
if(!bPtr)
{
error("only base type can have default value");
}
int b = bPtr->kind();
if(c == ConstTok::VALUE)
{
if(b == Builtin::KindBool)
{
error("default value of bool can only be true or false");
}
if(b == Builtin::KindString)
{
error("default value of string can only be \"string\"");
}
}
else if(c == ConstTok::BOOL)
{
if(b != Builtin::KindBool)
{
error("only bool type can be true or false");
}
}
else if(c == ConstTok::STRING)
{
if(b != Builtin::KindString)
{
error("only string type can be \"string\"");
}
}
}
bool
Slice::isMovable(const TypePtr& type)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindString:
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
case Builtin::KindValue:
{
return true;
}
default:
{
return false;
}
}
}
return !EnumPtr::dynamicCast(type);
}
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
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 << "];";
}
}
}
}
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_");
}
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);
}
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::writeDefaultValue(const TypePtr& p)
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
if(builtin)
{
switch(builtin->kind())
{
case Builtin::KindBool:
{
_out << "false";
break;
}
case Builtin::KindByte:
case Builtin::KindShort:
case Builtin::KindInt:
case Builtin::KindLong:
{
_out << "0";
break;
}
case Builtin::KindFloat:
case Builtin::KindDouble:
{
_out << "0.0";
break;
}
case Builtin::KindString:
{
_out << "''";
break;
}
case Builtin::KindObject:
case Builtin::KindObjectProxy:
case Builtin::KindLocalObject:
{
_out << "null";
break;
}
}
return;
}
EnumPtr en = EnumPtr::dynamicCast(p);
if(en)
{
EnumeratorList enums = en->getEnumerators();
_out << getAbsolute(en, _ns) << "::" << fixIdent(enums.front()->name());
return;
}
//
// PHP does not allow the following construct:
//
// function foo($theStruct=new MyStructType)
//
// Instead we use null as the default value and allocate an instance in
// the constructor.
//
StructPtr st = StructPtr::dynamicCast(p);
if(st)
{
_out << "null";
return;
}
_out << "null";
}
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 << "];";
}
}
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:
{
return "Ice.ObjectHelper";
}
case Builtin::KindObjectProxy:
{
return "Ice.ObjectPrx";
}
case Builtin::KindLocalObject:
{
assert(false);
break;
}
}
}
if(EnumPtr::dynamicCast(type))
{
return typeToString(type) + ".__helper";
}
if(ProxyPtr::dynamicCast(type) || StructPtr::dynamicCast(type))
{
return typeToString(type);
}
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 "???";
}