void
FreezeScript::AnalyzeInitVisitor::visitEnum(const EnumPtr& v)
{
if(v->isLocal())
{
return;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
EnumPtr e = EnumPtr::dynamicCast(l.front());
if(!e)
{
typeChange(l.front(), scoped, "enum");
}
else
{
return;
}
}
_out.newline();
_out.newline();
_out << "<!-- enum " << scoped << " -->";
_out << se("init") << attr("type", scoped);
_out << ee;
}
bool
FreezeScript::AnalyzeInitVisitor::visitStructStart(const StructPtr& v)
{
if(v->isLocal())
{
return false;
}
string scoped = v->scoped();
TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
if(!l.empty())
{
StructPtr s = StructPtr::dynamicCast(l.front());
if(!s)
{
typeChange(l.front(), scoped, "struct");
}
else
{
return false;
}
}
_out.newline();
_out.newline();
_out << "<!-- struct " << scoped << " -->";
_out << se("init") << attr("type", scoped);
_out << ee;
return false;
}
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;
}
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;
}
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;
}
StructPtr newStruct = StructPtr::dynamicCast(l.front());
if(!newStruct)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return false;
}
_out.newline();
_out.newline();
_out << "<!-- struct " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
DataMemberList oldMembers = v->dataMembers();
DataMemberList newMembers = newStruct->dataMembers();
compareMembers(oldMembers, newMembers);
_out << ee;
return false;
}
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
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
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;
}
void
FreezeScript::AnalyzeTransformVisitor::visitEnum(const EnumPtr& 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;
}
EnumPtr newEnum = EnumPtr::dynamicCast(l.front());
if(!newEnum)
{
if(!_ignoreTypeChanges)
{
typeChange(scoped, v, l.front());
}
return;
}
map<string, int> m;
{
Slice::EnumeratorList enumerators = newEnum->getEnumerators();
int i = 0;
for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
{
m.insert(map<string, int>::value_type((*p)->name(), i));
}
}
_out.newline();
_out.newline();
_out << "<!-- enum " << scoped << " -->";
_out << se("transform") << attr("type", scoped);
Slice::EnumeratorList enumerators = v->getEnumerators();
int i = 0;
for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
{
map<string, int>::const_iterator q = m.find((*p)->name());
if(q == m.end())
{
_out.newline();
_out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has been removed -->";
}
else if(q->second != i)
{
_out.newline();
_out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has changed position -->";
}
}
_out << ee;
}
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;
}
