private bool AreParametersEqual(ParameterSymbol parameter, ParameterSymbol other)
{
Debug.Assert(parameter.Ordinal == other.Ordinal);
return(StringOrdinalComparer.Equals(parameter.Name, other.Name) &&
(parameter.RefKind == other.RefKind) &&
_comparer.Equals(parameter.Type, other.Type));
}
private bool ArePropertiesEqual(PropertySymbol property, PropertySymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(property.MetadataName, other.MetadataName));
return(_comparer.Equals(property.Type, other.Type) &&
property.RefKind.Equals(other.RefKind) &&
property.Parameters.SequenceEqual(other.Parameters, AreParametersEqual));
}
/************
** strsift **
*************
** Pass this function:
** 1) A pointer to an array of offset pointers
** 2) A pointer to a string array
** 3) The number of elements in the string array
** 4) Offset within which to sort.
** Sift the array within the bounds of those offsets (thus
** building a heap).
*/
private static void strsift(string[] array,
int i,
int j)
{
int k;
string temp;
while ((i + i) <= j)
{
k = i + i;
if (k < j)
{
//array[k].CompareTo(array[k+1]);
if (StringOrdinalComparer.Compare(array[k], array[k + 1]) < 0)
{
++k;
}
}
//if(array[i]<array[k])
if (StringOrdinalComparer.Compare(array[i], array[k]) < 0)
{
temp = array[k];
array[k] = array[i];
array[i] = temp;
i = k;
}
else
{
i = j + 1;
}
}
return;
}
private bool AreNamedTypesEqual(NamedTypeSymbol type, NamedTypeSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
// TODO: Test with overloads (from PE base class?) that have modifiers.
Debug.Assert(!type.HasTypeArgumentsCustomModifiers);
Debug.Assert(!other.HasTypeArgumentsCustomModifiers);
return(type.TypeArgumentsNoUseSiteDiagnostics.SequenceEqual(other.TypeArgumentsNoUseSiteDiagnostics, AreTypesEqual));
}
private bool AreFieldsEqual(FieldSymbol field, FieldSymbol other)
{
#if XSHARP
Debug.Assert(s_nameComparer.Equals(field.Name, other.Name));
#else
Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name));
#endif
return(_comparer.Equals(field.Type, other.Type));
}
private bool AreEventsEqual(EventSymbol @event, EventSymbol other)
{
#if XSHARP
Debug.Assert(s_nameComparer.Equals(@event.Name, other.Name));
#else
Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name));
#endif
return(_comparer.Equals(@event.Type, other.Type));
}
private bool AreNamedTypesEqual(NamedTypeSymbol type, NamedTypeSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(type.MetadataName, other.MetadataName));
// TODO: Test with overloads (from PE base class?) that have modifiers.
Debug.Assert(type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.All(t => t.CustomModifiers.IsEmpty));
Debug.Assert(other.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.All(t => t.CustomModifiers.IsEmpty));
return(type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.SequenceEqual(other.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics, AreTypesEqual));
}
private bool AreParametersEqual(ParameterSymbol parameter, ParameterSymbol other)
{
Debug.Assert(parameter.Ordinal == other.Ordinal);
#if XSHARP
return(s_nameComparer.Equals(parameter.MetadataName, other.MetadataName) &&
#else
return StringOrdinalComparer.Equals(parameter.MetadataName, other.MetadataName) &&
#endif
(parameter.RefKind == other.RefKind) &&
_comparer.Equals(parameter.Type, other.Type));
}
private static bool AreTypeParametersEqual(TypeParameterSymbol type, TypeParameterSymbol other)
{
Debug.Assert(type.Ordinal == other.Ordinal);
Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
// Comparing constraints is unnecessary: two methods cannot differ by
// constraints alone and changing the signature of a method is a rude
// edit. Furthermore, comparing constraint types might lead to a cycle.
Debug.Assert(type.HasConstructorConstraint == other.HasConstructorConstraint);
Debug.Assert(type.HasValueTypeConstraint == other.HasValueTypeConstraint);
Debug.Assert(type.HasReferenceTypeConstraint == other.HasReferenceTypeConstraint);
Debug.Assert(type.ConstraintTypesNoUseSiteDiagnostics.Length == other.ConstraintTypesNoUseSiteDiagnostics.Length);
return(true);
}
private bool AreNamedTypesEqual(NamedTypeSymbol type, NamedTypeSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
// TODO: Test with overloads (from PE base class?) that have modifiers.
Debug.Assert(!type.HasTypeArgumentsCustomModifiers);
Debug.Assert(!other.HasTypeArgumentsCustomModifiers);
// Tuple types should be unwrapped to their underlying type before getting here (see MatchSymbols.VisitNamedType)
Debug.Assert(!type.IsTupleType);
Debug.Assert(!other.IsTupleType);
return(type.TypeArgumentsNoUseSiteDiagnostics.SequenceEqual(other.TypeArgumentsNoUseSiteDiagnostics, AreTypesEqual));
}
private bool AreMethodsEqual(MethodSymbol method, MethodSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(method.Name, other.Name));
Debug.Assert(method.IsDefinition);
Debug.Assert(other.IsDefinition);
method = SubstituteTypeParameters(method);
other = SubstituteTypeParameters(other);
return(_comparer.Equals(method.ReturnType, other.ReturnType) &&
method.Parameters.SequenceEqual(other.Parameters, AreParametersEqual) &&
method.TypeParameters.SequenceEqual(other.TypeParameters, AreTypesEqual));
}
/**************************
** DoStringSortIteration **
***************************
** This routine executes one iteration of the string
** sort benchmark. It returns the number of ticks
** Note that this routine also builds the offset pointer
** array.
*/
private static int DoStringSortIteration(string[][] arraybase, int numarrays, int arraysize)
{
long elapsed; /* Elapsed ticks */
int i;
/*
** Load up the array(s) with random numbers
*/
LoadStringArray(arraybase, arraysize, numarrays);
/*
** Start the stopwatch
*/
elapsed = ByteMark.StartStopwatch();
/*
** Execute heapsorts
*/
for (i = 0; i < numarrays; i++)
{
// StrHeapSort(tempobase,tempsbase,nstrings,0L,nstrings-1);
StrHeapSort(arraybase[i], 0, arraysize - 1);
}
/*
** Record elapsed time
*/
elapsed = ByteMark.StopStopwatch(elapsed);
#if DEBUG
for (i = 0; i < arraysize - 1; i++)
{
/*
** Compare strings to check for proper
** sort.
*/
if (StringOrdinalComparer.Compare(arraybase[0][i + 1], arraybase[0][i]) < 0)
{
Console.Write("Error in StringSort! arraybase[0][{0}]='{1}', arraybase[0][{2}]='{3}\n", i, arraybase[0][i], i + 1, arraybase[0][i + 1]);
break;
}
}
#endif
return((int)elapsed);
}
private Cci.IDefinition VisitDefInternal(Cci.IDefinition def)
{
var type = def as Cci.ITypeDefinition;
if (type != null)
{
var namespaceType = type.AsNamespaceTypeDefinition(_sourceContext);
if (namespaceType != null)
{
return(VisitNamespaceType(namespaceType));
}
var nestedType = type.AsNestedTypeDefinition(_sourceContext);
Debug.Assert(nestedType != null);
var otherContainer = (Cci.ITypeDefinition) this.VisitDef(nestedType.ContainingTypeDefinition);
if (otherContainer == null)
{
return(null);
}
return(VisitTypeMembers(otherContainer, nestedType, GetNestedTypes, (a, b) => StringOrdinalComparer.Equals(a.Name, b.Name)));
}
var member = def as Cci.ITypeDefinitionMember;
if (member != null)
{
var otherContainer = (Cci.ITypeDefinition) this.VisitDef(member.ContainingTypeDefinition);
if (otherContainer == null)
{
return(null);
}
var field = def as Cci.IFieldDefinition;
if (field != null)
{
return(VisitTypeMembers(otherContainer, field, GetFields, (a, b) => StringOrdinalComparer.Equals(a.Name, b.Name)));
}
}
// We are only expecting types and fields currently.
throw ExceptionUtilities.UnexpectedValue(def);
}
private bool AreFieldsEqual(FieldSymbol field, FieldSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name));
return(_comparer.Equals(field.Type, other.Type));
}
private bool AreEventsEqual(EventSymbol @event, EventSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name));
return(_comparer.Equals(@event.Type, other.Type));
}
private bool AreNamespacesEqual(NamespaceSymbol @namespace, NamespaceSymbol other)
{
Debug.Assert(StringOrdinalComparer.Equals(@namespace.MetadataName, other.MetadataName));
return(true);
}
