void AddExtra(ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode();
parent.AddChild(node);
node.Status = ComparisonStatus.Extra;
if (item is ICompTypeContainer)
{
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces())
{
AddExtra(node, ifc);
}
foreach (CompNamed cls in c.GetNestedClasses())
{
AddExtra(node, cls);
}
foreach (CompNamed cls in c.GetNestedStructs())
{
AddExtra(node, cls);
}
foreach (CompNamed en in c.GetNestedEnums())
{
AddExtra(node, en);
}
}
}
void AddExtra(ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode();
parent.AddChild(node);
node.Status = ComparisonStatus.Extra;
profile_documentation.AddError(String.Format("Extra contents \"{0}\" in \"{1}\"", item.DisplayName, parent.Name));
if (item is ICompTypeContainer)
{
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces())
{
AddExtra(node, ifc);
}
foreach (CompNamed cls in c.GetNestedClasses())
{
AddExtra(node, cls);
}
foreach (CompNamed cls in c.GetNestedStructs())
{
AddExtra(node, cls);
}
foreach (CompNamed en in c.GetNestedEnums())
{
AddExtra(node, en);
}
}
}
void CompareAttributes(ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List <CompNamed> reference_attrs = reference_container.GetAttributes();
List <CompNamed> target_attrs = target_container.GetAttributes();
reference_attrs.Sort(CompNamed.Compare);
target_attrs.Sort(CompNamed.Compare);
while (m < reference_attrs.Count || a < target_attrs.Count)
{
if (m == reference_attrs.Count)
{
AddExtra(parent, target_attrs[a]);
a++;
continue;
}
else if (a == target_attrs.Count)
{
AddMissing(parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare(reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed++;
if (c == 0)
{
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild(comparison);
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_attrs[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_attrs[a]);
a++;
}
}
}
void CompareTypeLists (ComparisonNode parent,
List<CompNamed> reference_list,
List<CompNamed> target_list)
{
int m = 0, a = 0;
reference_list.Sort (CompNamed.Compare);
target_list.Sort (CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count) {
if (m == reference_list.Count) {
AddExtra (parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count) {
AddMissing (parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare (reference_list[m].Name, target_list[a].Name);
comparisons_performed ++;
if (c == 0) {
ProgressChange ((double)comparisons_performed / total_comparisons * 100.0, String.Format ("Comparing {0} {1}", reference_list[m].Type, reference_list[m].Name));
/* the names match, further investigation is required */
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild (comparison);
// compare base types
if (reference_list[m] is ICompHasBaseType && target_list[a] is ICompHasBaseType) {
CompareBaseTypes (comparison,
(ICompHasBaseType)reference_list[m],
(ICompHasBaseType)target_list[a]);
}
// compares generic type parameters
if (reference_list[m] is ICompGenericParameter && target_list[a] is ICompGenericParameter) {
CompareTypeParameters (comparison,
(ICompGenericParameter)reference_list[m],
(ICompGenericParameter)target_list[a]);
}
// compare nested types
if (reference_list[m] is ICompTypeContainer && target_list[a] is ICompTypeContainer) {
CompareNestedTypes (comparison,
(ICompTypeContainer)reference_list[m],
(ICompTypeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer && target_list[a] is ICompMemberContainer) {
CompareMembers (comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
if (reference_list[m] is ICompAttributeContainer && target_list[a] is ICompAttributeContainer) {
CompareAttributes (comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_list[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_list[a]);
a++;
}
}
}
void CompareTypeLists(ComparisonNode parent,
List<CompNamed> reference_list,
List<CompNamed> target_list)
{
int m = 0, a = 0;
UnityProfilesDocumentation.State state = profile_documentation.CurrentState;
reference_list.Sort (CompNamed.Compare);
target_list.Sort (CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count) {
if (m == reference_list.Count) {
AddExtra (parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count) {
AddMissing (parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare (reference_list[m].Name, target_list[a].Name);
comparisons_performed ++;
//Console.WriteLine ("\t\t\t\tWorking on item {0} [type {1}] in profile {2}", reference_list[m].Name, reference_list[m].Type, target_profile);
if (c == 0) {
ProgressChange ((double)comparisons_performed / total_comparisons * 100.0, String.Format ("Comparing {0} {1}", reference_list[m].Type, reference_list[m].Name));
switch (reference_list[m].Type) {
case CompType.Namespace:
profile_documentation.AddReferenceNamespace (reference_list[m].Name);
profile_documentation.CurrentClass = null;
//Console.WriteLine ("\t\t\t\tAdding namespace {0} in profile {1}", reference_list[m].Name, target_profile);
break;
case CompType.Class:
profile_documentation.AddReferenceClass (reference_list[m].Name);
profile_documentation.CurrentClass.AddSupportedProfile (target_profile);
//Console.WriteLine ("\t\t\t\tAdding class {0} in profile {1}", reference_list[m].Name, target_profile);
break;
default:
break;
}
/* the names match, further investigation is required */
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild (comparison);
// compare base types
if (reference_list[m] is ICompHasBaseType && target_list[a] is ICompHasBaseType) {
CompareBaseTypes (comparison,
(ICompHasBaseType)reference_list[m],
(ICompHasBaseType)target_list[a]);
}
// compares generic type parameters
if (reference_list[m] is ICompGenericParameter && target_list[a] is ICompGenericParameter) {
CompareTypeParameters (comparison,
(ICompGenericParameter)reference_list[m],
(ICompGenericParameter)target_list[a]);
}
// compare nested types
if (reference_list[m] is ICompTypeContainer && target_list[a] is ICompTypeContainer) {
CompareNestedTypes (comparison,
(ICompTypeContainer)reference_list[m],
(ICompTypeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer && target_list[a] is ICompMemberContainer) {
CompareMembers (comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
if (reference_list[m] is ICompAttributeContainer && target_list[a] is ICompAttributeContainer) {
CompareAttributes (comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_list[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_list[a]);
a++;
}
}
profile_documentation.CurrentState = state;
}
void CompareMemberLists(ComparisonNode parent,
List<CompNamed> reference_list,
List<CompNamed> target_list)
{
int m = 0, a = 0;
UnityProfilesDocumentation.State state = profile_documentation.CurrentState;
reference_list.Sort (CompNamed.Compare);
target_list.Sort (CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count) {
if (m == reference_list.Count) {
AddExtra (parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count) {
AddMissing (parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare (reference_list[m].Name, target_list[a].Name);
comparisons_performed ++;
if (c == 0) {
DocumentedMember currentMember;
switch (reference_list[m].Type) {
case CompType.Field:
currentMember = profile_documentation.AddReferenceField (reference_list[m].Name);
break;
case CompType.Method:
currentMember = profile_documentation.AddReferenceMethod (reference_list[m].Name);
break;
case CompType.Property:
currentMember = profile_documentation.AddReferenceProperty (reference_list[m].Name);
break;
default:
profile_documentation.CurrentMember = null;
currentMember = null;
break;
}
if (currentMember != null) {
currentMember.AddSupportedProfile (target_profile);
//Console.WriteLine ("\t\t\t\tAdded member {0} in profile {1}", reference_list[m].Name, target_profile);
}
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild (comparison);
if (reference_list[m] is CompMember && target_list[a] is CompMember) {
string reference_type = ((CompMember)reference_list[m]).GetMemberType();
string target_type = ((CompMember)target_list[a]).GetMemberType();
if (reference_type != target_type) {
HandleError (comparison, String.Format ("reference type is <i>{0}</i>, target type is <i>{1}</i>",
reference_type, target_type));
}
string reference_access = ((CompMember)reference_list[m]).GetMemberAccess();
string target_access = ((CompMember)target_list[a]).GetMemberAccess();
if (reference_access != target_access) {
// Try to give some hints to the developer, best we can do with
// strings.
string extra_msg = "";
if (reference_access.IndexOf ("Public, Final, Virtual, HideBySig") != -1 &&
target_access.IndexOf ("Public, HideBySig") != -1){
extra_msg = "\n\t\t<b>Hint:</b> reference uses an implicit interface implementation, target doesn't";
}
HandleError (comparison, String.Format ("reference access is '<i>{0}</i>', target access is '<i>{1}</i>'{2}",
reference_access, target_access, extra_msg));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is CompMethod) {
if (((CompMethod)target_list[a]).ThrowsNotImplementedException ()
&& !((CompMethod)reference_list[m]).ThrowsNotImplementedException ()) {
comparison.ThrowsNIE = true;
}
}
if (reference_list[m] is CompField) {
if (((CompField)reference_list[m]).GetLiteralValue() !=
((CompField)target_list[a]).GetLiteralValue()) {
HandleError (comparison, String.Format ("reference field has value {0}, target field has value {1}",
((CompField)reference_list[m]).GetLiteralValue(),
((CompField)target_list[a]).GetLiteralValue()));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is ICompAttributeContainer) {
//Console.WriteLine ("Comparing attributes for {0}", reference_list[m].Name);
CompareAttributes (comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer) {
CompareMembers (comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_list[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_list[a]);
a++;
}
}
profile_documentation.CurrentState = state;
}
void AddExtra(ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode ();
parent.AddChild (node);
node.Status = ComparisonStatus.Extra;
profile_documentation.AddError (String.Format ("Extra contents \"{0}\" in \"{1}\"", item.DisplayName, parent.Name));
if (item is ICompTypeContainer) {
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces ())
AddExtra (node, ifc);
foreach (CompNamed cls in c.GetNestedClasses())
AddExtra (node, cls);
foreach (CompNamed cls in c.GetNestedStructs())
AddExtra (node, cls);
foreach (CompNamed en in c.GetNestedEnums())
AddExtra (node, en);
}
}
void CompareAttributes (ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List<CompNamed> reference_attrs = reference_container.GetAttributes ();
List<CompNamed> target_attrs = target_container.GetAttributes ();
Comparison<CompNamed> comp = (x, y) => {
var r = CompNamed.Compare (x, y);
if (r != 0)
return r;
var xa = ((CompAttribute)x).Properties.Values.ToList ();
var ya = ((CompAttribute)y).Properties.Values.ToList ();
for (int i = 0; i < Math.Min (xa.Count, ya.Count); ++i) {
r = xa[i].CompareTo (ya[i]);
if (r != 0)
return r;
}
return 0;
};
reference_attrs.Sort (comp);
target_attrs.Sort (comp);
while (m < reference_attrs.Count || a < target_attrs.Count) {
if (m == reference_attrs.Count) {
switch (target_attrs[a].Name) {
case "System.Diagnostics.DebuggerDisplayAttribute":
case "System.Runtime.CompilerServices.AsyncStateMachineAttribute":
case "System.Runtime.CompilerServices.IteratorStateMachineAttribute":
case "System.Diagnostics.DebuggerBrowsableAttribute":
// Ignore extra attributes in Mono source code
break;
default:
AddExtra (parent, target_attrs[a]);
break;
}
a++;
continue;
}
else if (a == target_attrs.Count) {
AddMissing (parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare (reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed ++;
if (c == 0) {
/* the names match, further investigation is required */
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild (comparison);
CompareAttributeArguments (comparison, (CompAttribute)reference_attrs[m], (CompAttribute)target_attrs[a]);
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_attrs[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_attrs[a]);
a++;
}
}
}
void CompareTypeLists(ComparisonNode parent,
List <CompNamed> reference_list,
List <CompNamed> target_list)
{
int m = 0, a = 0;
reference_list.Sort(CompNamed.Compare);
target_list.Sort(CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count)
{
if (m == reference_list.Count)
{
AddExtra(parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count)
{
AddMissing(parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare(reference_list[m].Name, target_list[a].Name);
comparisons_performed++;
if (c == 0)
{
ProgressChange((double)comparisons_performed / total_comparisons * 100.0, String.Format("Comparing {0} {1}", reference_list[m].Type, reference_list[m].Name));
/* the names match, further investigation is required */
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild(comparison);
// compare base types
if (reference_list[m] is ICompHasBaseType && target_list[a] is ICompHasBaseType)
{
CompareBaseTypes(comparison,
(ICompHasBaseType)reference_list[m],
(ICompHasBaseType)target_list[a]);
}
// compares generic type parameters
if (reference_list[m] is ICompGenericParameter && target_list[a] is ICompGenericParameter)
{
CompareTypeParameters(comparison,
(ICompGenericParameter)reference_list[m],
(ICompGenericParameter)target_list[a]);
}
// compare nested types
if (reference_list[m] is ICompTypeContainer && target_list[a] is ICompTypeContainer)
{
CompareNestedTypes(comparison,
(ICompTypeContainer)reference_list[m],
(ICompTypeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer && target_list[a] is ICompMemberContainer)
{
CompareMembers(comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
if (reference_list[m] is ICompAttributeContainer && target_list[a] is ICompAttributeContainer)
{
CompareAttributes(comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_list[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_list[a]);
a++;
}
}
}
void AddExtra (ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode ();
parent.AddChild (node);
node.Status = ComparisonStatus.Extra;
if (item is ICompTypeContainer) {
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces ())
AddExtra (node, ifc);
foreach (CompNamed cls in c.GetNestedClasses())
AddExtra (node, cls);
foreach (CompNamed cls in c.GetNestedStructs())
AddExtra (node, cls);
foreach (CompNamed en in c.GetNestedEnums())
AddExtra (node, en);
}
}
void CompareMemberLists(ComparisonNode parent,
List <CompNamed> reference_list,
List <CompNamed> target_list)
{
int m = 0, a = 0;
UnityProfilesDocumentation.State state = profile_documentation.CurrentState;
reference_list.Sort(CompNamed.Compare);
target_list.Sort(CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count)
{
if (m == reference_list.Count)
{
AddExtra(parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count)
{
AddMissing(parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare(reference_list[m].Name, target_list[a].Name);
comparisons_performed++;
if (c == 0)
{
DocumentedMember currentMember;
switch (reference_list[m].Type)
{
case CompType.Field:
currentMember = profile_documentation.AddReferenceField(reference_list[m].Name);
break;
case CompType.Method:
currentMember = profile_documentation.AddReferenceMethod(reference_list[m].Name);
break;
case CompType.Property:
currentMember = profile_documentation.AddReferenceProperty(reference_list[m].Name);
break;
default:
profile_documentation.CurrentMember = null;
currentMember = null;
break;
}
if (currentMember != null)
{
currentMember.AddSupportedProfile(target_profile);
//Console.WriteLine ("\t\t\t\tAdded member {0} in profile {1}", reference_list[m].Name, target_profile);
}
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild(comparison);
if (reference_list[m] is CompMember && target_list[a] is CompMember)
{
string reference_type = ((CompMember)reference_list[m]).GetMemberType();
string target_type = ((CompMember)target_list[a]).GetMemberType();
if (reference_type != target_type)
{
HandleError(comparison, String.Format("reference type is <i>{0}</i>, target type is <i>{1}</i>",
reference_type, target_type));
}
string reference_access = ((CompMember)reference_list[m]).GetMemberAccess();
string target_access = ((CompMember)target_list[a]).GetMemberAccess();
if (reference_access != target_access)
{
// Try to give some hints to the developer, best we can do with
// strings.
string extra_msg = "";
if (reference_access.IndexOf("Public, Final, Virtual, HideBySig") != -1 &&
target_access.IndexOf("Public, HideBySig") != -1)
{
extra_msg = "\n\t\t<b>Hint:</b> reference uses an implicit interface implementation, target doesn't";
}
HandleError(comparison, String.Format("reference access is '<i>{0}</i>', target access is '<i>{1}</i>'{2}",
reference_access, target_access, extra_msg));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is CompMethod)
{
if (((CompMethod)target_list[a]).ThrowsNotImplementedException() &&
!((CompMethod)reference_list[m]).ThrowsNotImplementedException())
{
comparison.ThrowsNIE = true;
}
}
if (reference_list[m] is CompField)
{
if (((CompField)reference_list[m]).GetLiteralValue() !=
((CompField)target_list[a]).GetLiteralValue())
{
HandleError(comparison, String.Format("reference field has value {0}, target field has value {1}",
((CompField)reference_list[m]).GetLiteralValue(),
((CompField)target_list[a]).GetLiteralValue()));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is ICompAttributeContainer)
{
//Console.WriteLine ("Comparing attributes for {0}", reference_list[m].Name);
CompareAttributes(comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer)
{
CompareMembers(comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_list[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_list[a]);
a++;
}
}
profile_documentation.CurrentState = state;
}
void CompareTypeLists(ComparisonNode parent,
List <CompNamed> reference_list,
List <CompNamed> target_list)
{
int m = 0, a = 0;
UnityProfilesDocumentation.State state = profile_documentation.CurrentState;
reference_list.Sort(CompNamed.Compare);
target_list.Sort(CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count)
{
if (m == reference_list.Count)
{
AddExtra(parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count)
{
AddMissing(parent, reference_list[m]);
m++;
continue;
}
int c = String.Compare(reference_list[m].Name, target_list[a].Name);
comparisons_performed++;
//Console.WriteLine ("\t\t\t\tWorking on item {0} [type {1}] in profile {2}", reference_list[m].Name, reference_list[m].Type, target_profile);
if (c == 0)
{
ProgressChange((double)comparisons_performed / total_comparisons * 100.0, String.Format("Comparing {0} {1}", reference_list[m].Type, reference_list[m].Name));
switch (reference_list[m].Type)
{
case CompType.Namespace:
profile_documentation.AddReferenceNamespace(reference_list[m].Name);
profile_documentation.CurrentClass = null;
//Console.WriteLine ("\t\t\t\tAdding namespace {0} in profile {1}", reference_list[m].Name, target_profile);
break;
case CompType.Class:
profile_documentation.AddReferenceClass(reference_list[m].Name);
profile_documentation.CurrentClass.AddSupportedProfile(target_profile);
//Console.WriteLine ("\t\t\t\tAdding class {0} in profile {1}", reference_list[m].Name, target_profile);
break;
default:
break;
}
/* the names match, further investigation is required */
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild(comparison);
// compare base types
if (reference_list[m] is ICompHasBaseType && target_list[a] is ICompHasBaseType)
{
CompareBaseTypes(comparison,
(ICompHasBaseType)reference_list[m],
(ICompHasBaseType)target_list[a]);
}
// compares generic type parameters
if (reference_list[m] is ICompGenericParameter && target_list[a] is ICompGenericParameter)
{
CompareTypeParameters(comparison,
(ICompGenericParameter)reference_list[m],
(ICompGenericParameter)target_list[a]);
}
// compare nested types
if (reference_list[m] is ICompTypeContainer && target_list[a] is ICompTypeContainer)
{
CompareNestedTypes(comparison,
(ICompTypeContainer)reference_list[m],
(ICompTypeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer && target_list[a] is ICompMemberContainer)
{
CompareMembers(comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
if (reference_list[m] is ICompAttributeContainer && target_list[a] is ICompAttributeContainer)
{
CompareAttributes(comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_list[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_list[a]);
a++;
}
}
profile_documentation.CurrentState = state;
}
void CompareMemberLists(ComparisonNode parent,
List <CompNamed> reference_list,
List <CompNamed> target_list,
bool isSealed)
{
int m = 0, a = 0;
reference_list.Sort(CompNamed.Compare);
target_list.Sort(CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count)
{
if (m == reference_list.Count)
{
AddExtra(parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count)
{
AddMissing(parent, reference_list[m]);
m++;
continue;
}
int c = CompNamed.Compare(reference_list[m], target_list[a]);
comparisons_performed++;
if (c == 0)
{
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild(comparison);
if (reference_list[m] is CompMember && target_list[a] is CompMember)
{
string reference_type = ((CompMember)reference_list[m]).GetMemberType();
string target_type = ((CompMember)target_list[a]).GetMemberType();
if (reference_type != target_type)
{
comparison.AddError(String.Format("reference type is <i>{0}</i>, target type is <i>{1}</i>",
reference_type, target_type));
}
string reference_access = ((CompMember)reference_list[m]).GetMemberAccess();
string target_access = ((CompMember)target_list[a]).GetMemberAccess();
if (reference_access != target_access)
{
// Try to give some hints to the developer, best we can do with
// strings.
string extra_msg = "";
if (reference_access.IndexOf("Private, Final, Virtual, HideBySig") != -1 &&
target_access.IndexOf("Public, HideBySig") != -1)
{
extra_msg = "\n\t\t<b>Hint:</b> reference uses an explicit interface implementation, target doesn't";
}
comparison.AddError(String.Format("reference access is '<i>{0}</i>', target access is '<i>{1}</i>'{2}",
reference_access, target_access, extra_msg));
comparison.Status = ComparisonStatus.Error;
}
}
var r_method = reference_list[m] as CompMethod;
if (r_method != null)
{
var t_method = (CompMethod)target_list[a];
if (t_method.ThrowsNotImplementedException() && !r_method.ThrowsNotImplementedException())
{
comparison.ThrowsNIE = true;
}
CompareTypeParameters(comparison, r_method, t_method);
CompareParameters(comparison, r_method, t_method);
}
else if (reference_list[m] is CompProperty)
{
var m1 = ((CompProperty)reference_list[m]).GetMethods();
var m2 = ((CompProperty)target_list[a]).GetMethods();
if (m1.Count != m2.Count)
{
comparison.AddError(String.Format("Expected {0} accessors but found {1}", m1.Count, m2.Count));
comparison.Status = ComparisonStatus.Error;
}
else
{
for (int i = 0; i < m1.Count; ++i)
{
string reference_access = ((CompMember)m1[i]).GetMemberAccess();
string target_access = ((CompMember)m2[i]).GetMemberAccess();
if (reference_access != target_access)
{
// Try to give some hints to the developer, best we can do with
// strings.
string extra_msg = "";
if (reference_access.IndexOf("Private, Final, Virtual, HideBySig") != -1 &&
target_access.IndexOf("Public, HideBySig") != -1)
{
extra_msg = "\n\t\t<b>Hint:</b> reference uses an explicit interface implementation, target doesn't";
}
comparison.AddError(String.Format("reference access is '<i>{0}</i>', target access is '<i>{1}</i>'{2}",
reference_access, target_access, extra_msg));
comparison.Status = ComparisonStatus.Error;
break;
}
}
if (m1[0].Name[0] == m2[0].Name[0])
{
CompareAttributes(comparison, (ICompAttributeContainer)m1[0], (ICompAttributeContainer)m2[0]);
if (m1.Count > 1)
{
CompareAttributes(comparison, (ICompAttributeContainer)m1[1], (ICompAttributeContainer)m2[1]);
}
}
else
{
CompareAttributes(comparison, (ICompAttributeContainer)m1[0], (ICompAttributeContainer)m2[1]);
if (m1.Count > 1)
{
CompareAttributes(comparison, (ICompAttributeContainer)m1[1], (ICompAttributeContainer)m2[0]);
}
}
}
// Compare indexer parameters
if (m1.Count == m2.Count)
{
CompareParameters(comparison, (ICompParameters)m1[0], (ICompParameters)m2[0]);
}
}
if (reference_list[m] is CompField)
{
var v_ref = ((CompField)reference_list[m]).GetLiteralValue();
var v_tar = ((CompField)target_list[a]).GetLiteralValue();
if (v_ref != v_tar)
{
comparison.AddError(String.Format("Expected field value {0} but found value {1}", v_ref, v_tar));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is ICompAttributeContainer)
{
//Console.WriteLine ("Comparing attributes for {0}", reference_list[m].Name);
CompareAttributes(comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer)
{
CompareMembers(comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0)
{
if (isSealed && reference_list[m].Name.Contains("~"))
{
// Ignore finalizer differences in sealed classes
}
else
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_list[m]);
}
m++;
}
else
{
if (isSealed && target_list[a].Name.Contains("~"))
{
// Ignore finalizer differences in sealed classes
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_list[a]);
}
a++;
}
}
}
void CompareAttributes(ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List <CompNamed> reference_attrs = reference_container.GetAttributes();
List <CompNamed> target_attrs = target_container.GetAttributes();
Comparison <CompNamed> comp = (x, y) => {
var r = CompNamed.Compare(x, y);
if (r != 0)
{
return(r);
}
var xa = ((CompAttribute)x).Properties.Values.ToList();
var ya = ((CompAttribute)y).Properties.Values.ToList();
for (int i = 0; i < Math.Min(xa.Count, ya.Count); ++i)
{
r = xa[i].CompareTo(ya[i]);
if (r != 0)
{
return(r);
}
}
return(0);
};
reference_attrs.Sort(comp);
target_attrs.Sort(comp);
while (m < reference_attrs.Count || a < target_attrs.Count)
{
if (m == reference_attrs.Count)
{
switch (target_attrs[a].Name)
{
case "System.Diagnostics.DebuggerDisplayAttribute":
case "System.Runtime.CompilerServices.AsyncStateMachineAttribute":
case "System.Runtime.CompilerServices.IteratorStateMachineAttribute":
case "System.Diagnostics.DebuggerBrowsableAttribute":
// Ignore extra attributes in Mono source code
break;
default:
AddExtra(parent, target_attrs[a]);
break;
}
a++;
continue;
}
else if (a == target_attrs.Count)
{
AddMissing(parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare(reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed++;
if (c == 0)
{
/* the names match, further investigation is required */
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild(comparison);
CompareAttributeArguments(comparison, (CompAttribute)reference_attrs[m], (CompAttribute)target_attrs[a]);
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_attrs[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_attrs[a]);
a++;
}
}
}
void CompareAttributes (ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List<CompNamed> reference_attrs = reference_container.GetAttributes ();
List<CompNamed> target_attrs = target_container.GetAttributes ();
reference_attrs.Sort (CompNamed.Compare);
target_attrs.Sort (CompNamed.Compare);
while (m < reference_attrs.Count || a < target_attrs.Count) {
if (m == reference_attrs.Count) {
AddExtra (parent, target_attrs[a]);
a++;
continue;
}
else if (a == target_attrs.Count) {
AddMissing (parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare (reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed ++;
if (c == 0) {
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild (comparison);
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_attrs[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_attrs[a]);
a++;
}
}
}
void AddMissing(ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode();
parent.AddChild(node);
node.Status = ComparisonStatus.Missing;
comparisons_performed++;
if (item is ICompHasBaseType)
{
string baseTypeName = ((ICompHasBaseType)item).GetBaseType();
if (!string.IsNullOrEmpty(baseTypeName))
{
ComparisonNode baseTypeNode = new ComparisonNode(CompType.Class,
string.Format("BaseType: {0}",
baseTypeName),
baseTypeName);
baseTypeNode.Status = ComparisonStatus.Missing;
node.AddChild(baseTypeNode);
}
}
if (item is ICompTypeContainer)
{
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces())
{
AddMissing(node, ifc);
}
foreach (CompNamed cls in c.GetNestedClasses())
{
AddMissing(node, cls);
}
foreach (CompNamed cls in c.GetNestedStructs())
{
AddMissing(node, cls);
}
foreach (CompNamed en in c.GetNestedEnums())
{
AddMissing(node, en);
}
}
if (item is ICompMemberContainer)
{
ICompMemberContainer c = (ICompMemberContainer)item;
foreach (CompNamed ifc in c.GetInterfaces())
{
AddMissing(node, ifc);
}
foreach (CompNamed m in c.GetConstructors())
{
AddMissing(node, m);
}
foreach (CompNamed m in c.GetMethods())
{
AddMissing(node, m);
}
foreach (CompNamed p in c.GetProperties())
{
AddMissing(node, p);
}
foreach (CompNamed f in c.GetFields())
{
AddMissing(node, f);
}
foreach (CompNamed e in c.GetEvents())
{
AddMissing(node, e);
}
}
if (item is ICompAttributeContainer)
{
ICompAttributeContainer c = (ICompAttributeContainer)item;
foreach (CompNamed attr in c.GetAttributes())
{
AddMissing(node, attr);
}
}
}
void CompareMemberLists (ComparisonNode parent,
List<CompNamed> reference_list,
List<CompNamed> target_list)
{
int m = 0, a = 0;
reference_list.Sort (CompNamed.Compare);
target_list.Sort (CompNamed.Compare);
while (m < reference_list.Count || a < target_list.Count) {
if (m == reference_list.Count) {
AddExtra (parent, target_list[a]);
a++;
continue;
}
else if (a == target_list.Count) {
AddMissing (parent, reference_list[m]);
m++;
continue;
}
int c = CompNamed.Compare (reference_list[m], target_list[a]);
comparisons_performed ++;
if (c == 0) {
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_list[a].GetComparisonNode();
parent.AddChild (comparison);
if (reference_list[m] is CompMember && target_list[a] is CompMember) {
string reference_type = ((CompMember)reference_list[m]).GetMemberType();
string target_type = ((CompMember)target_list[a]).GetMemberType();
if (reference_type != target_type) {
comparison.AddError (String.Format ("reference type is <i>{0}</i>, target type is <i>{1}</i>",
reference_type, target_type));
}
string reference_access = ((CompMember)reference_list[m]).GetMemberAccess();
string target_access = ((CompMember)target_list[a]).GetMemberAccess();
if (reference_access != target_access) {
// Try to give some hints to the developer, best we can do with
// strings.
string extra_msg = "";
if (reference_access.IndexOf ("Private, Final, Virtual, HideBySig") != -1 &&
target_access.IndexOf ("Public, HideBySig") != -1){
extra_msg = "\n\t\t<b>Hint:</b> reference uses an explicit interface implementation, target doesn't";
}
comparison.AddError (String.Format ("reference access is '<i>{0}</i>', target access is '<i>{1}</i>'{2}",
reference_access, target_access, extra_msg));
comparison.Status = ComparisonStatus.Error;
}
}
var r_method = reference_list[m] as CompMethod;
if (r_method != null) {
var t_method = (CompMethod)target_list[a];
if (t_method.ThrowsNotImplementedException () && !r_method.ThrowsNotImplementedException ()) {
comparison.ThrowsNIE = true;
}
CompareTypeParameters (comparison, r_method, t_method);
CompareParameters (comparison, r_method, t_method);
}
if (reference_list[m] is CompField) {
var v_ref = ((CompField)reference_list[m]).GetLiteralValue();
var v_tar = ((CompField)target_list[a]).GetLiteralValue();
if (v_ref != v_tar) {
comparison.AddError (String.Format ("reference field has value {0}, target field has value {1}", v_ref, v_tar));
comparison.Status = ComparisonStatus.Error;
}
}
if (reference_list[m] is ICompAttributeContainer) {
//Console.WriteLine ("Comparing attributes for {0}", reference_list[m].Name);
CompareAttributes (comparison,
(ICompAttributeContainer)reference_list[m],
(ICompAttributeContainer)target_list[a]);
}
if (reference_list[m] is ICompMemberContainer) {
CompareMembers (comparison,
(ICompMemberContainer)reference_list[m],
(ICompMemberContainer)target_list[a]);
}
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_list[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_list[a]);
a++;
}
}
}
void CompareAttributes (ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List<CompNamed> reference_attrs = reference_container.GetAttributes ();
List<CompNamed> target_attrs = target_container.GetAttributes ();
reference_attrs.Sort (CompNamed.Compare);
target_attrs.Sort (CompNamed.Compare);
while (m < reference_attrs.Count || a < target_attrs.Count) {
if (m == reference_attrs.Count) {
switch (target_attrs[a].Name) {
case "System.Diagnostics.DebuggerDisplayAttribute":
case "System.Runtime.CompilerServices.AsyncStateMachineAttribute":
case "System.Runtime.CompilerServices.IteratorStateMachineAttribute":
// Ignore extra attributes in Mono source code
break;
default:
AddExtra (parent, target_attrs[a]);
break;
}
a++;
continue;
}
else if (a == target_attrs.Count) {
AddMissing (parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare (reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed ++;
if (c == 0) {
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild (comparison);
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0) {
/* reference name is before target name, reference name is missing from target */
AddMissing (parent, reference_attrs[m]);
m++;
}
else {
/* reference name is after target name, target name is extra */
AddExtra (parent, target_attrs[a]);
a++;
}
}
}
void AddMissing (ComparisonNode parent, CompNamed item)
{
ComparisonNode node = item.GetComparisonNode ();
parent.AddChild (node);
node.Status = ComparisonStatus.Missing;
comparisons_performed ++;
if (item is ICompHasBaseType) {
string baseTypeName = ((ICompHasBaseType)item).GetBaseType();
if (!string.IsNullOrEmpty (baseTypeName)) {
ComparisonNode baseTypeNode = new ComparisonNode (CompType.Class,
string.Format ("BaseType: {0}",
baseTypeName),
baseTypeName);
baseTypeNode.Status = ComparisonStatus.Missing;
node.AddChild (baseTypeNode);
}
}
if (item is ICompTypeContainer) {
ICompTypeContainer c = (ICompTypeContainer)item;
foreach (CompNamed ifc in c.GetNestedInterfaces ())
AddMissing (node, ifc);
foreach (CompNamed cls in c.GetNestedClasses())
AddMissing (node, cls);
foreach (CompNamed cls in c.GetNestedStructs())
AddMissing (node, cls);
foreach (CompNamed en in c.GetNestedEnums())
AddMissing (node, en);
}
if (item is ICompMemberContainer) {
ICompMemberContainer c = (ICompMemberContainer)item;
foreach (CompNamed ifc in c.GetInterfaces())
AddMissing (node, ifc);
foreach (CompNamed m in c.GetConstructors())
AddMissing (node, m);
foreach (CompNamed m in c.GetMethods())
AddMissing (node, m);
foreach (CompNamed p in c.GetProperties())
AddMissing (node, p);
foreach (CompNamed f in c.GetFields())
AddMissing (node, f);
foreach (CompNamed e in c.GetEvents())
AddMissing (node, e);
}
if (item is ICompAttributeContainer) {
ICompAttributeContainer c = (ICompAttributeContainer)item;
foreach (CompNamed attr in c.GetAttributes())
AddMissing (node, attr);
}
}
void CompareAttributes(ComparisonNode parent,
ICompAttributeContainer reference_container, ICompAttributeContainer target_container)
{
int m = 0, a = 0;
List <CompNamed> reference_attrs = reference_container.GetAttributes();
List <CompNamed> target_attrs = target_container.GetAttributes();
reference_attrs.Sort(CompNamed.Compare);
target_attrs.Sort(CompNamed.Compare);
while (m < reference_attrs.Count || a < target_attrs.Count)
{
if (m == reference_attrs.Count)
{
switch (target_attrs[a].Name)
{
case "System.Diagnostics.DebuggerDisplayAttribute":
case "System.Runtime.CompilerServices.AsyncStateMachineAttribute":
case "System.Runtime.CompilerServices.IteratorStateMachineAttribute":
// Ignore extra attributes in Mono source code
break;
default:
AddExtra(parent, target_attrs[a]);
break;
}
a++;
continue;
}
else if (a == target_attrs.Count)
{
AddMissing(parent, reference_attrs[m]);
m++;
continue;
}
int c = String.Compare(reference_attrs[m].Name, target_attrs[a].Name);
comparisons_performed++;
if (c == 0)
{
/* the names match, further investigation is required */
// Console.WriteLine ("method {0} is in both, doing more comparisons", reference_list[m].Name);
ComparisonNode comparison = target_attrs[a].GetComparisonNode();
parent.AddChild(comparison);
//CompareParameters (comparison, reference_list[m], target_namespace [target_list[a]]);
m++;
a++;
}
else if (c < 0)
{
/* reference name is before target name, reference name is missing from target */
AddMissing(parent, reference_attrs[m]);
m++;
}
else
{
/* reference name is after target name, target name is extra */
AddExtra(parent, target_attrs[a]);
a++;
}
}
}
