void
FreezeScript::AnalyzeInitVisitor::visitSequence(const SequencePtr& v)
{
if(v->isLocal())
{
return;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
SequencePtr s = SequencePtr::dynamicCast(l.front());
if(!s)
{
typeChange(l.front(), scoped, "sequence");
}
else
{
return;
}
}
_out.newline();
_out.newline();
_out << "<!-- sequence " << 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::visitSequence(const SequencePtr& p)
{
if (p->isLocal()) {
return;
}
ostringstream ostr;
ostr << "sequence<" << typeToString(p->type()) << "> " << 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
Slice::Ruby::CodeVisitor::visitSequence(const SequencePtr& 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::__defineSequence('" << scoped << "', ";
writeType(p->type());
_out << ")";
_out.dec();
_out << nl << "end"; // if not defined?()
}
void Translator::AddStep(IEnginePtr engine, MSXML2::IXMLDOMNodePtr currentStep, std::map<std::string, std::string> stepProperties, std::string stepName, SequenceFilePtr seqFile, std::string parentSeqName)
{
SequencePtr seq = seqFile->GetSequenceByName(parentSeqName.c_str());
std::string stepTypeString = GetParser()->GetStepType(currentStep);
StepPtr newStep = engine->NewStep(GetAdapter(stepTypeString).c_str() ,GetStepType(stepTypeString).c_str());
newStep->Name = stepName.c_str();
PropertyObjectPtr stepPropObject = newStep->AsPropertyObject();
SetStepProperties(currentStep, stepPropObject, stepProperties);
if ( GetParser()->StepHasResult( currentStep))
{
std::map<std::string, std::string> resultData = GetParser()->GetResultData(currentStep);
AddReportVariable(newStep->AsPropertyObject(), seq, resultData);
}
seq->InsertStep(newStep, m_totalSteps, StepGroup_Main);
m_totalSteps++;
//Add the step to the TypeUsagelist of the sequence file
seqFile->AsPropertyObjectFile()->GetTypeUsageList()->AddUsedTypes(newStep->AsPropertyObject());
}
foreach (const ResourcePtr &i, sorted)
{
seq->append(i);
// add rdf:about (type)
model.addStatement(i, RDFVocab::self()->type(), RSSVocab::self()->item());
//add to items sequence
model.addStatement(seq, RDFVocab::self()->li(), i);
}
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;
}
void
CodeVisitor::visitSequence(const SequencePtr& p)
{
string type = getTypeVar(p);
TypePtr content = p->type();
startNamespace(p);
//
// Emit the type information.
//
string scoped = p->scoped();
_out << sp << nl << "if(!isset(" << type << "))";
_out << sb;
_out << nl << type << " = IcePHP_defineSequence('" << scoped << "', ";
writeType(content);
_out << ");";
_out << eb;
endNamespace();
}
void
FreezeScript::AnalyzeTransformVisitor::visitSequence(const SequencePtr& 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;
}
SequencePtr newSeq = SequencePtr::dynamicCast(l.front());
if(!newSeq)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return;
}
_out.newline();
_out.newline();
_out << "<!-- sequence " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
compareTypes(scoped + " sequence type", v->type(), newSeq->type());
_out << ee;
}
bool
Slice::inWstringModule(const SequencePtr& seq)
{
ContainerPtr cont = seq->container();
while(cont)
{
ModulePtr mod = ModulePtr::dynamicCast(cont);
if(!mod)
{
break;
}
StringList metaData = mod->getMetaData();
if(find(metaData.begin(), metaData.end(), "cpp:type:wstring") != metaData.end())
{
return true;
}
else if(find(metaData.begin(), metaData.end(), "cpp:type:string") != metaData.end())
{
return false;
}
cont = mod->container();
}
return false;
}
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";
}
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 "???";
}
void
Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional, int tag, const string& param,
bool marshal, const StringList& metaData, int typeCtx, const string& str, bool pointer)
{
ostringstream os;
if(str.empty())
{
os << (marshal ? "__os" : "__is");
}
else
{
os << str;
}
string deref;
if(pointer)
{
os << "->";
}
else
{
os << '.';
}
if(marshal)
{
os << "write(";
}
else
{
os << "read(";
}
if(optional)
{
os << tag << ", ";
}
string func = os.str();
if(!marshal)
{
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq && !(typeCtx & TypeContextAMIPrivateEnd))
{
string seqType = findMetaData(metaData, typeCtx);
if(seqType == "%array")
{
BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
if(builtin && builtin->kind() == Builtin::KindByte)
{
out << nl << func << param << ");";
return;
}
out << nl << func << "___" << param << ");";
writeParamEndCode(out, seq, optional, param, metaData);
return;
}
else if(seqType.find("%range") == 0)
{
out << nl << func << "___" << param << ");";
writeParamEndCode(out, seq, optional, param, metaData);
return;
}
}
}
out << nl << func << param << ");";
}
ResourcePtr ModelMaker::readResource(Model& model, const QDomElement& el)
{
QString rdfns = RDFVocab::self()->namespaceURI();
QString about = QLatin1String("about");
QString resource = QLatin1String("resource");
QString descriptionStr = QLatin1String("Description");
ResourcePtr res;
ResourcePtr type = model.createResource(el.namespaceURI() + el.localName());
if (*type == *(RDFVocab::self()->seq()))
{
SequencePtr seq = model.createSequence(el.attribute(about));
res = seq;
}
else
{
res = model.createResource(el.attribute(about));
}
model.addStatement(res, RDFVocab::self()->type(), type);
QDomNodeList children = el.childNodes();
bool isSeq = res->isSequence();
for (uint i = 0; i < children.length(); ++i)
{
if (children.item(i).isElement())
{
QDomElement ce = children.item(i).toElement();
PropertyPtr pred = model.createProperty(ce.namespaceURI() + ce.localName());
if (ce.hasAttribute(resource)) // referenced Resource via (rdf:)resource
{
NodePtr obj = model.createResource(ce.attribute(resource));
if (isSeq && *pred == *(RDFVocab::self()->li()))
{
SequencePtr tseq = boost::static_pointer_cast<Sequence>(res);
tseq->append(obj);
}
else
model.addStatement(res, pred, obj);
}
else if (!ce.text().isEmpty() && ce.lastChildElement().isNull()) // Literal
{
NodePtr obj = model.createLiteral(ce.text());
if (isSeq && *pred == *(RDFVocab::self()->li()))
{
SequencePtr tseq = boost::static_pointer_cast<Sequence>(res);
tseq->append(obj);
}
else
model.addStatement(res, pred, obj);
}
else // embedded description
{
QDomElement re = ce.lastChildElement();
QString uri = re.attribute(about);
// read recursively
NodePtr obj = readResource(model, re);
if (isSeq && *pred == *(RDFVocab::self()->li()))
{
SequencePtr tseq = boost::static_pointer_cast<Sequence>(res);
tseq->append(obj);
}
else
model.addStatement(res, pred, obj);
}
//TODO: bag, reification (nice to have, but not important for basic RSS 1.0)
}
}
return res;
}
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);
}
