public override void VisitArrayTypeReference <TTypeReference>(IArrayTypeReference <TTypeReference> arrayTypeReference)
{
Value = new TypeReference()
{
ArrayTypeReference = new ArrayTypeReferenceFactory(arrayTypeReference).Value
};
}
internal ArrayExpression(
IArrayTypeReference vectorType,
EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> elements
) {
this.VectorType = vectorType;
this.Elements = elements;
}
/// <summary>
/// Strip off *, &, and [].
/// </summary>
private static ITypeReference UnwrapTypeReference(ITypeReference typeReference, EmitContext context)
{
while (true)
{
IArrayTypeReference arrType = typeReference as IArrayTypeReference;
if (arrType != null)
{
typeReference = arrType.GetElementType(context);
continue;
}
IPointerTypeReference pointer = typeReference as IPointerTypeReference;
if (pointer != null)
{
typeReference = pointer.GetTargetType(context);
continue;
}
IManagedPointerTypeReference reference = typeReference as IManagedPointerTypeReference;
if (reference != null)
{
typeReference = reference.GetTargetType(context);
continue;
}
return(typeReference);
}
}
private static void InitializeArrayCreateInstruction(Instruction instruction, Stack <Instruction> stack, IOperation currentOperation)
{
Contract.Requires(instruction != null);
Contract.Requires(stack != null);
Contract.Requires(currentOperation != null);
IArrayTypeReference arrayType = (IArrayTypeReference)currentOperation.Value;
Contract.Assume(arrayType != null); //This is an informally specified property of the Metadata model.
var rank = arrayType.Rank;
if (rank > 0)
{
if (currentOperation.OperationCode == OperationCode.Array_Create_WithLowerBound)
{
rank *= 2;
}
rank--;
if (rank > 0)
{
var indices = new Instruction[rank];
instruction.Operand2 = indices;
for (var i = rank; i > 0; i--)
{
indices[i - 1] = stack.Pop();
}
}
instruction.Operand1 = stack.Pop();
}
stack.Push(instruction);
}
// Array and pointer types might cause deep recursions; visit them iteratively
// rather than recursively.
public override void Visit(IArrayTypeReference arrayTypeReference)
{
// We don't visit the current array type; it has already been visited.
// We go straight to the element type and visit it.
ITypeReference current = arrayTypeReference.GetElementType(Context);
while (true)
{
bool mustVisitChildren = VisitTypeReference(current);
if (!mustVisitChildren)
{
return;
}
else if (current is IArrayTypeReference)
{
// The element type is itself an array type, and we must visit *its* element type.
// Iterate rather than recursing.
current = ((IArrayTypeReference)current).GetElementType(Context);
continue;
}
else
{
// The element type is not an array type and we must visit its children.
// Dispatch the type in order to visit its children.
DispatchAsReference(current);
return;
}
}
}
private void InitializeArrayCreateInstruction(Instruction instruction, LocalsAndOperands <V> state, IOperation currentOperation)
{
/* Contract.Requires(instruction != null);
* Contract.Requires(stack != null);
* Contract.Requires(currentOperation != null);
* IArrayTypeReference arrayType = (IArrayTypeReference)currentOperation.Value;
* Contract.Assume(arrayType != null); //This is an informally specified property of the Metadata model.
* var rank = arrayType.Rank;
* if (currentOperation.OperationCode == OperationCode.Array_Create_WithLowerBound) rank *= 2;
* var indices = new Instruction[rank];
* instruction.Operand2 = indices;
* for (var i = rank; i > 0; i--)
* indices[i - 1] = stack.Pop();
* stack.Push(instruction);
*/
IArrayTypeReference arrayType = (IArrayTypeReference)currentOperation.Value;
Contract.Assume(arrayType != null); //This is an informally specified property of the Metadata model.
var rank = arrayType.Rank;
if (currentOperation.OperationCode == OperationCode.Array_Create_WithLowerBound)
{
rank *= 2;
}
for (var i = rank; i > 0; i--)
{
state.Pop();
}
state.Push(ValueAbstraction.Top); // can be smarter than Top
}
public override void Visit(IArrayTypeReference arrayTypeReference)
{
if (Process(arrayTypeReference))
{
visitor.Visit(arrayTypeReference);
}
base.Visit(arrayTypeReference);
}
private static void VisitTypeReference(ITypeReference typeReference, EmitContext context)
{
Debug.Assert(typeReference != null);
IArrayTypeReference arrayType = typeReference as IArrayTypeReference;
if (arrayType != null)
{
VisitTypeReference(arrayType.GetElementType(context), context);
return;
}
IPointerTypeReference pointerType = typeReference as IPointerTypeReference;
if (pointerType != null)
{
VisitTypeReference(pointerType.GetTargetType(context), context);
return;
}
//IManagedPointerTypeReference managedPointerType = typeReference as IManagedPointerTypeReference;
//if (managedPointerType != null)
//{
// VisitTypeReference(managedPointerType.GetTargetType(this.context));
// return;
//}
IModifiedTypeReference modifiedType = typeReference as IModifiedTypeReference;
if (modifiedType != null)
{
foreach (var custModifier in modifiedType.CustomModifiers)
{
VisitTypeReference(custModifier.GetModifier(context), context);
}
VisitTypeReference(modifiedType.UnmodifiedType, context);
return;
}
// Visit containing type
INestedTypeReference nestedType = typeReference.AsNestedTypeReference;
if (nestedType != null)
{
VisitTypeReference(nestedType.GetContainingType(context), context);
}
// Visit generic arguments
IGenericTypeInstanceReference genericInstance = typeReference.AsGenericTypeInstanceReference;
if (genericInstance != null)
{
foreach (var arg in genericInstance.GetGenericArguments(context))
{
VisitTypeReference(arg, context);
}
}
}
/// <summary>
/// Appends a C#-like specific string of the dimensions of the given array type reference to the given StringBuilder.
/// <example>For example, this appends the "[][,]" part of an array like "int[][,]".</example>
/// </summary>
protected override void AppendArrayDimensions(IArrayTypeReference arrayType, StringBuilder sb, NameFormattingOptions formattingOptions)
{
Contract.Requires(arrayType != null);
Contract.Requires(sb != null);
IArrayTypeReference /*?*/ elementArrayType = arrayType.ElementType as IArrayTypeReference;
bool formattingForDocumentationId = (formattingOptions & NameFormattingOptions.FormattingForDocumentationId) != 0;
if (formattingForDocumentationId && elementArrayType != null) //Append the outer dimensions of the array first
{
this.AppendArrayDimensions(elementArrayType, sb, formattingOptions);
}
sb.Append("(");
if (!arrayType.IsVector)
{
if (formattingForDocumentationId)
{
bool first = true;
IEnumerator <int> lowerBounds = arrayType.LowerBounds.GetEnumerator();
IEnumerator <ulong> sizes = arrayType.Sizes.GetEnumerator();
for (int i = 0; i < arrayType.Rank; i++)
{
if (!first)
{
sb.Append(",");
}
first = false;
if (lowerBounds.MoveNext())
{
sb.Append(lowerBounds.Current);
sb.Append(":");
if (sizes.MoveNext())
{
sb.Append(sizes.Current);
}
}
else
{
if (sizes.MoveNext())
{
sb.Append("0:" + sizes.Current);
}
}
}
}
else
{
sb.Append(',', (int)arrayType.Rank - 1);
}
}
sb.Append(")");
if (!formattingForDocumentationId && elementArrayType != null) //Append the inner dimensions of the array first
{
this.AppendArrayDimensions(elementArrayType, sb, formattingOptions);
}
}
private bool IsStringArray(ITypeReference typeReference)
{
IArrayTypeReference atr = typeReference as IArrayTypeReference;
if (atr == null)
{
return(false);
}
return(TypeHelper.TypesAreEquivalent(atr.ElementType, this.host.PlatformType.SystemString));
}
/// <summary>
/// Performs some computation with the given array type reference.
/// </summary>
/// <param name="arrayTypeReference"></param>
public virtual void Visit(IArrayTypeReference arrayTypeReference)
//^ ensures this.path.Count == old(this.path.Count);
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(arrayTypeReference);
this.Visit(arrayTypeReference.ElementType);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public override void TraverseChildren(IArrayTypeReference arrayTypeReference)
{
var typ = arrayTypeReference.ResolvedType;
if (typ == Dummy.Type)
{
this.EmitError(arrayTypeReference, ErrorCode.NamespaceTypeResolution);
}
base.TraverseChildren(arrayTypeReference);
}
private static void AppendAssemblyQualifierIfNecessary(StringBuilder sb, ITypeReference typeReference, out bool isAssemQualified, EmitContext context)
{
INestedTypeReference nestedType = typeReference.AsNestedTypeReference;
if (nestedType != null)
{
AppendAssemblyQualifierIfNecessary(sb, nestedType.GetContainingType(context), out isAssemQualified, context);
return;
}
IGenericTypeInstanceReference genInst = typeReference.AsGenericTypeInstanceReference;
if (genInst != null)
{
AppendAssemblyQualifierIfNecessary(sb, genInst.GetGenericType(context), out isAssemQualified, context);
return;
}
IArrayTypeReference arrType = typeReference as IArrayTypeReference;
if (arrType != null)
{
AppendAssemblyQualifierIfNecessary(sb, arrType.GetElementType(context), out isAssemQualified, context);
return;
}
IPointerTypeReference pointer = typeReference as IPointerTypeReference;
if (pointer != null)
{
AppendAssemblyQualifierIfNecessary(sb, pointer.GetTargetType(context), out isAssemQualified, context);
return;
}
isAssemQualified = false;
IAssemblyReference referencedAssembly = null;
INamespaceTypeReference namespaceType = typeReference.AsNamespaceTypeReference;
if (namespaceType != null)
{
referencedAssembly = namespaceType.GetUnit(context) as IAssemblyReference;
}
if (referencedAssembly != null)
{
var containingAssembly = context.Module.GetContainingAssembly(context);
if (containingAssembly == null || !ReferenceEquals(referencedAssembly, containingAssembly))
{
sb.Append(", ");
sb.Append(MetadataWriter.StrongName(referencedAssembly));
isAssemQualified = true;
}
}
}
internal MethodInfo GetArrayCreateWithLowerBoundsMethod(IArrayTypeReference arrayTypeReference, ModuleBuilder moduleBuilder)
{
var type = this.GetType(arrayTypeReference);
var parameterTypes = new Type[arrayTypeReference.Rank * 2];
for (int i = 0; i < arrayTypeReference.Rank * 2; i++)
{
parameterTypes[i] = typeof(int);
}
return(moduleBuilder.GetArrayMethod(type, ".ctor", CallingConventions.HasThis, typeof(void), parameterTypes));
}
public override void Visit(IArrayTypeReference arrayTypeReference)
{
if (arrayTypeReference.IsVector)
{
this.result = this.mapper.GetType(arrayTypeReference.ElementType).MakeArrayType();
}
else
{
this.result = this.mapper.GetType(arrayTypeReference.ElementType).MakeArrayType((int)arrayTypeReference.Rank);
}
}
internal MethodInfo GetArrayGetMethod(IArrayTypeReference arrayTypeReference, ModuleBuilder moduleBuilder)
{
var type = this.GetType(arrayTypeReference);
var parameterTypes = new Type[arrayTypeReference.Rank];
for (int i = 0; i < arrayTypeReference.Rank; i++)
{
parameterTypes[i] = typeof(int);
}
return(moduleBuilder.GetArrayMethod(type, "Get", CallingConventions.HasThis, type.GetElementType(), parameterTypes));
}
public override void TraverseChildren(IArrayIndexer arrayIndexer)
{
base.TraverseChildren(arrayIndexer);
IArrayTypeReference /*?*/ arrayType = arrayIndexer.IndexedObject.Type as IArrayTypeReference;
if (arrayType == null)
{
return;
}
((ArrayIndexer)arrayIndexer).Type = arrayType.ElementType;
}
public static INamedTypeReference CanonicalizeTypeReference(ITypeReference type)
{
while (type != null)
{
IModifiedTypeReference modifiedType = type as IModifiedTypeReference;
IPointerTypeReference ptrType = type as IPointerTypeReference;
IManagedPointerType refType = type as IManagedPointerType;
IArrayTypeReference arrType = type as IArrayTypeReference;
IGenericTypeInstanceReference genType = type as IGenericTypeInstanceReference;
ISpecializedNestedTypeReference nestedType = type as ISpecializedNestedTypeReference;
// TODO: Why doesn't ISpecializedNestedTypeDefinition derive from ISpecializedNestedTypeReference?
ISpecializedNestedTypeDefinition nestedTypeDef = type as ISpecializedNestedTypeDefinition;
if (modifiedType != null)
{
type = modifiedType.UnmodifiedType;
}
else if (ptrType != null)
{
type = ptrType.TargetType;
}
else if (refType != null)
{
type = refType.TargetType;
}
else if (arrType != null)
{
type = arrType.ElementType;
}
else if (genType != null)
{
type = genType.GenericType;
}
else if (nestedType != null)
{
type = nestedType.UnspecializedVersion;
}
else if (nestedTypeDef != null)
{
type = nestedTypeDef.UnspecializedVersion;
}
else /* ITypeDefinition */
{
break;
}
}
return(type as INamedTypeReference);
}
public static ITypeReference UnWrap(this ITypeReference reference)
{
IPointerTypeReference pointer = reference as IPointerTypeReference;
if (pointer != null)
{
return(pointer.TargetType.UnWrap());
}
IArrayTypeReference array = reference as IArrayTypeReference;
if (array != null)
{
return(array.ElementType.UnWrap());
}
IModifiedTypeReference modified = reference as IModifiedTypeReference;
if (modified != null)
{
return(modified.UnmodifiedType.UnWrap());
}
ISpecializedNestedTypeReference specialized = reference as ISpecializedNestedTypeReference;
if (specialized != null)
{
return(specialized.UnspecializedVersion.UnWrap());
}
IGenericTypeInstanceReference instantiation = reference as IGenericTypeInstanceReference;
if (instantiation != null)
{
return(instantiation.GenericType.UnWrap());
}
Contract.Assert(reference is INamedTypeReference ||
reference is INestedTypeReference ||
reference is INamespaceTypeReference ||
reference is IGenericTypeParameterReference ||
reference is IGenericMethodParameterReference ||
reference is IFunctionPointerTypeReference ||
reference is IManagedPointerType,
string.Format("Unexpected type reference that we may need to unwrap {0}", (reference != null ? reference.GetType().FullName : "null")));
return(reference);
}
public static ITypeReference UnWrap(this ITypeReference reference)
{
IPointerTypeReference pointer = reference as IPointerTypeReference;
if (pointer != null)
{
return(pointer.TargetType.UnWrap());
}
IArrayTypeReference array = reference as IArrayTypeReference;
if (array != null)
{
return(array.ElementType.UnWrap());
}
IModifiedTypeReference modified = reference as IModifiedTypeReference;
if (modified != null)
{
return(modified.UnmodifiedType.UnWrap());
}
ISpecializedNestedTypeReference specialized = reference as ISpecializedNestedTypeReference;
if (specialized != null)
{
return(specialized.UnspecializedVersion.UnWrap());
}
IGenericTypeInstanceReference instantiation = reference as IGenericTypeInstanceReference;
if (instantiation != null)
{
return(instantiation.GenericType.UnWrap());
}
Contract.Assert(reference is INamedTypeReference ||
reference is INestedTypeReference ||
reference is INamespaceTypeReference ||
reference is IGenericTypeParameterReference ||
reference is IGenericMethodParameterReference ||
reference is IFunctionPointerTypeReference,
string.Format(CultureInfo.CurrentCulture, LocalizedStrings.UnexpectedTypeReference, (reference?.GetType()?.FullName ?? "null")));
return(reference);
}
private static ArrayMethod MakeArrayMethod(IArrayTypeReference arrayType, ArrayMethodKind id)
{
switch (id)
{
case ArrayMethodKind.CTOR:
return(new ArrayConstructor(arrayType));
case ArrayMethodKind.GET:
return(new ArrayGet(arrayType));
case ArrayMethodKind.SET:
return(new ArraySet(arrayType));
case ArrayMethodKind.ADDRESS:
return(new ArrayAddress(arrayType));
}
throw ExceptionUtilities.UnexpectedValue(id);
}
/// <summary>
/// lazily fetches or creates a new array method.
/// </summary>
private ArrayMethod GetArrayMethod(IArrayTypeReference arrayType, ArrayMethodKind id)
{
var key = new KeyValuePair <byte, IArrayTypeReference>((byte)id, arrayType);
ArrayMethod result;
var dict = _dict;
if (!dict.TryGetValue(key, out result))
{
result = MakeArrayMethod(arrayType, id);
if (dict.ContainsKey(key))
{
result = dict[key];
}
else
{
dict.Add(key, result);
}
}
return(result);
}
internal static string GetSerializedTypeName(this ITypeReference typeReference, EmitContext context, ref bool isAssemblyQualified)
{
var pooled = PooledStringBuilder.GetInstance();
StringBuilder sb = pooled.Builder;
IArrayTypeReference arrType = typeReference as IArrayTypeReference;
if (arrType != null)
{
typeReference = arrType.GetElementType(context);
bool isAssemQual = false;
AppendSerializedTypeName(sb, typeReference, ref isAssemQual, context);
if (arrType.IsSZArray)
{
sb.Append("[]");
}
else
{
sb.Append('[');
if (arrType.Rank == 1)
{
sb.Append('*');
}
sb.Append(',', (int)arrType.Rank - 1);
sb.Append(']');
}
goto done;
}
IPointerTypeReference pointer = typeReference as IPointerTypeReference;
if (pointer != null)
{
typeReference = pointer.GetTargetType(context);
bool isAssemQual = false;
AppendSerializedTypeName(sb, typeReference, ref isAssemQual, context);
sb.Append('*');
goto done;
}
INamespaceTypeReference namespaceType = typeReference.AsNamespaceTypeReference;
if (namespaceType != null)
{
var name = namespaceType.NamespaceName;
if (name.Length != 0)
{
sb.Append(name);
sb.Append('.');
}
sb.Append(GetMangledAndEscapedName(namespaceType));
goto done;
}
if (typeReference.IsTypeSpecification())
{
ITypeReference uninstantiatedTypeReference = typeReference.GetUninstantiatedGenericType(context);
ArrayBuilder <ITypeReference> consolidatedTypeArguments = ArrayBuilder <ITypeReference> .GetInstance();
typeReference.GetConsolidatedTypeArguments(consolidatedTypeArguments, context);
bool uninstantiatedTypeIsAssemblyQualified = false;
sb.Append(GetSerializedTypeName(uninstantiatedTypeReference, context, ref uninstantiatedTypeIsAssemblyQualified));
sb.Append('[');
bool first = true;
foreach (ITypeReference argument in consolidatedTypeArguments)
{
if (first)
{
first = false;
}
else
{
sb.Append(',');
}
bool isAssemQual = true;
AppendSerializedTypeName(sb, argument, ref isAssemQual, context);
}
consolidatedTypeArguments.Free();
sb.Append(']');
goto done;
}
INestedTypeReference nestedType = typeReference.AsNestedTypeReference;
if (nestedType != null)
{
bool nestedTypeIsAssemblyQualified = false;
sb.Append(GetSerializedTypeName(nestedType.GetContainingType(context), context, ref nestedTypeIsAssemblyQualified));
sb.Append('+');
sb.Append(GetMangledAndEscapedName(nestedType));
goto done;
}
// TODO: error
done:
if (isAssemblyQualified)
{
AppendAssemblyQualifierIfNecessary(sb, UnwrapTypeReference(typeReference, context), out isAssemblyQualified, context);
}
return(pooled.ToStringAndFree());
}
internal MethodInfo GetArrayCreateWithLowerBoundsMethod(IArrayTypeReference arrayTypeReference, ModuleBuilder moduleBuilder) {
var type = this.GetType(arrayTypeReference);
var parameterTypes = new Type[arrayTypeReference.Rank*2];
for (int i = 0; i < arrayTypeReference.Rank*2; i++) parameterTypes[i] = typeof(int);
return moduleBuilder.GetArrayMethod(type, ".ctor", CallingConventions.HasThis, typeof(void), parameterTypes);
}
private void EmitTypeLoadingCallsFor(IArrayTypeReference arrayType, string typeObjectName, SetOfUints alreadyLoadedTypes) {
Contract.Requires(arrayType != null);
Contract.Requires(typeObjectName != null);
Contract.Requires(alreadyLoadedTypes != null);
var elementTypeObjectName = this.GetMangledTypeName(arrayType.ElementType)+"_typeObject";
this.EmitTypeLoadingCallsFor(arrayType.ElementType, elementTypeObjectName, alreadyLoadedTypes);
if (arrayType.IsVector) {
this.sourceEmitter.EmitString("GetVectorType(");
this.sourceEmitter.EmitString(elementTypeObjectName);
} else {
this.sourceEmitter.EmitString("GetMatrixType(");
this.sourceEmitter.EmitString(elementTypeObjectName);
this.sourceEmitter.EmitString(", "+arrayType.Rank);
}
this.sourceEmitter.EmitString(", (uintptr_t)&");
this.sourceEmitter.EmitString(typeObjectName);
this.sourceEmitter.EmitString(");");
this.sourceEmitter.EmitNewLine();
}
public override void Visit(IArrayTypeReference arrayTypeReference) {
arrayTypeReference.ElementType.Dispatch(this);
int h = this.hash;
h = (h << 5 + h) ^ ((int)arrayTypeReference.Rank+4);
this.hash = h;
}
public virtual void Visit(IArrayTypeReference arrayTypeReference)
{
this.Visit(arrayTypeReference.GetElementType(Context));
}
/// <summary>
/// Traverses the array type reference.
/// </summary>
public void Traverse(IArrayTypeReference arrayTypeReference)
{
Contract.Requires(arrayTypeReference != null);
if (!this.objectsThatHaveAlreadyBeenTraversed.Add(arrayTypeReference)) return;
if (this.preorderVisitor != null) this.preorderVisitor.Visit(arrayTypeReference); //No need to dispatch. This call is already type specific.
if (this.stopTraversal) return;
this.TraverseChildren(arrayTypeReference);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(arrayTypeReference);
}
private static void InitializeArraySetInstruction(Instruction instruction, Stack <Instruction> stack, IArrayTypeReference arrayType)
{
Contract.Requires(instruction != null);
Contract.Requires(stack != null);
Contract.Requires(arrayType != null);
var rank = arrayType.Rank;
var indices = new Instruction[rank + 1];
instruction.Operand2 = indices;
for (var i = rank + 1; i > 0; i--)
{
indices[i - 1] = stack.Pop();
}
instruction.Operand1 = stack.Pop();
}
private void StoreInitializers(ICreateArray createArray, IArrayTypeReference arrayType)
{
var initializers = new List<IExpression>(createArray.Initializers);
if (initializers.Count > 0) {
var sizes = new List<IExpression>(createArray.Sizes);
// Used to do the "reverse" mapping from offset (linear index into
// initializer list) to the d-dimensional coordinates, where d is
// the rank of the array.
ulong[] dimensionStride = new ulong[sizes.Count];
dimensionStride[sizes.Count - 1] = 1;
for (int i = sizes.Count - 2; 0 <= i; i--) {
var size = ((IConvertible)((ICompileTimeConstant)sizes[i + 1]).Value).ToUInt64(null);
dimensionStride[i] = size * dimensionStride[i + 1];
}
for (int i = 0; i < initializers.Count; i++) {
this.generator.Emit(OperationCode.Dup);
this.StackSize++;
ulong n = (ulong)i; // compute the indices that map to the offset n
for (uint d = 0; d < createArray.Rank; d++) {
var divisor = dimensionStride[d];
var indexInThisDimension = n / divisor;
n = n % divisor;
this.EmitConstant((int)indexInThisDimension);
}
this.Traverse(initializers[i]);
this.generator.Emit(OperationCode.Array_Set, arrayType);
this.StackSize -= (ushort)(createArray.Rank + 2);
}
}
}
public void Visit(IArrayTypeReference arrayTypeReference)
{
this.traverser.Traverse(arrayTypeReference);
}
internal MethodInfo GetArraySetMethod(IArrayTypeReference arrayTypeReference, ModuleBuilder moduleBuilder) {
var type = this.GetType(arrayTypeReference);
var parameterTypes = new Type[arrayTypeReference.Rank+1];
for (int i = 0; i < arrayTypeReference.Rank; i++) parameterTypes[i] = typeof(int);
parameterTypes[arrayTypeReference.Rank] = type.GetElementType();
return moduleBuilder.GetArrayMethod(type, "Set", CallingConventions.HasThis, typeof(void), parameterTypes);
}
/// <summary>
/// Performs some computation with the given array type reference.
/// </summary>
public void Visit(IArrayTypeReference arrayTypeReference)
{
this.Visit((ITypeReference)arrayTypeReference);
if (arrayTypeReference.ElementType is Dummy)
this.ReportError(MetadataError.IncompleteNode, arrayTypeReference, "ElementType");
}
public override void TraverseChildren(IArrayTypeReference arrayTypeReference)
{
MethodEnter(arrayTypeReference);
base.TraverseChildren(arrayTypeReference);
MethodExit();
}
public override void Visit(IArrayTypeReference arrayTypeReference) {
if (arrayTypeReference.IsVector)
this.result = this.mapper.GetType(arrayTypeReference.ElementType).MakeArrayType();
else
this.result = this.mapper.GetType(arrayTypeReference.ElementType).MakeArrayType((int)arrayTypeReference.Rank);
}
/// <summary>
/// Use this routine, rather than ITypeReference.Dispatch, to call the appropriate derived overload of an ITypeReference.
/// The former routine will call Visit(INamespaceTypeDefinition) rather than Visit(INamespaceTypeReference), etc.,
/// in the case where a definition is used as a reference to itself.
/// </summary>
/// <param name="typeReference">A reference to a type definition. Note that a type definition can serve as a reference to itself.</param>
protected void DispatchAsReference(ITypeReference typeReference)
{
INamespaceTypeReference namespaceTypeReference = typeReference.AsNamespaceTypeReference;
if (namespaceTypeReference != null)
{
this.Visit(namespaceTypeReference);
return;
}
IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference;
if (genericTypeInstanceReference != null)
{
this.Visit(genericTypeInstanceReference);
return;
}
INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference;
if (nestedTypeReference != null)
{
this.Visit(nestedTypeReference);
return;
}
IArrayTypeReference arrayTypeReference = typeReference as IArrayTypeReference;
if (arrayTypeReference != null)
{
this.Visit(arrayTypeReference);
return;
}
IGenericTypeParameterReference genericTypeParameterReference = typeReference.AsGenericTypeParameterReference;
if (genericTypeParameterReference != null)
{
this.Visit(genericTypeParameterReference);
return;
}
IGenericMethodParameterReference genericMethodParameterReference = typeReference.AsGenericMethodParameterReference;
if (genericMethodParameterReference != null)
{
this.Visit(genericMethodParameterReference);
return;
}
IPointerTypeReference pointerTypeReference = typeReference as IPointerTypeReference;
if (pointerTypeReference != null)
{
this.Visit(pointerTypeReference);
return;
}
IModifiedTypeReference modifiedTypeReference = typeReference as IModifiedTypeReference;
if (modifiedTypeReference != null)
{
this.Visit(modifiedTypeReference);
return;
}
}
// Array and pointer types might cause deep recursions; visit them iteratively
// rather than recursively.
public override void Visit(IArrayTypeReference arrayTypeReference)
{
// We don't visit the current array type; it has already been visited.
// We go straight to the element type and visit it.
ITypeReference current = arrayTypeReference.GetElementType(Context);
while (true)
{
bool mustVisitChildren = VisitTypeReference(current);
if (!mustVisitChildren)
{
return;
}
else if (current is IArrayTypeReference)
{
// The element type is itself an array type, and we must visit *its* element type.
// Iterate rather than recursing.
current = ((IArrayTypeReference)current).GetElementType(Context);
continue;
}
else
{
// The element type is not an array type and we must visit its children.
// Dispatch the type in order to visit its children.
DispatchAsReference(current);
return;
}
}
}
/// <summary>
/// Performs some computation with the given array type reference.
/// </summary>
public virtual void Visit(IArrayTypeReference arrayTypeReference)
{
}
/// <summary>
/// Performs some computation with the given array type reference.
/// </summary>
public virtual void Visit(IArrayTypeReference arrayTypeReference)
{
}
/// <summary>
/// Rewrites the array type reference.
/// </summary>
public virtual IArrayTypeReference Rewrite(IArrayTypeReference arrayTypeReference)
{
return arrayTypeReference;
}
/// <summary>
/// Traverses the children of the array type reference.
/// </summary>
public virtual void TraverseChildren(IArrayTypeReference arrayTypeReference)
{
Contract.Requires(arrayTypeReference != null);
this.TraverseChildren((ITypeReference)arrayTypeReference);
if (this.stopTraversal) return;
this.Traverse(arrayTypeReference.ElementType);
}
public override void Visit(IArrayTypeReference arrayTypeReference)
{
if(Process(arrayTypeReference)){visitor.Visit(arrayTypeReference);}
base.Visit(arrayTypeReference);
}
/// <summary>
/// Performs some computation with the given array type reference.
/// </summary>
public virtual void Visit(IArrayTypeReference arrayTypeReference)
{
this.Visit((ITypeReference)arrayTypeReference);
}
/// <summary>
/// Generates IL code for the given for each statement for the special case where the collection is known
/// to be vector type.
/// </summary>
/// <param name="forEachStatement">The foreach statement to visit.</param>
/// <param name="arrayType">The vector type of the collection.</param>
public virtual void VisitForeachArrayElement(IForEachStatement forEachStatement, IArrayTypeReference arrayType)
{
Contract.Requires(arrayType.IsVector);
ILGeneratorLabel savedCurrentBreakTarget = this.currentBreakTarget;
ILGeneratorLabel savedCurrentContinueTarget = this.currentContinueTarget;
this.currentBreakTarget = new ILGeneratorLabel();
this.currentContinueTarget = new ILGeneratorLabel();
if (this.currentTryCatch != null) {
this.mostNestedTryCatchFor.Add(this.currentBreakTarget, this.currentTryCatch);
this.mostNestedTryCatchFor.Add(this.currentContinueTarget, this.currentTryCatch);
}
ILGeneratorLabel conditionCheck = new ILGeneratorLabel();
ILGeneratorLabel loopStart = new ILGeneratorLabel();
this.EmitSequencePoint(forEachStatement.Variable.Locations);
this.Traverse(forEachStatement.Collection);
this.generator.Emit(OperationCode.Dup);
var array = new TemporaryVariable(arrayType, this.method);
this.VisitAssignmentTo(array);
var length = new TemporaryVariable(this.host.PlatformType.SystemInt32, this.method);
this.generator.Emit(OperationCode.Ldlen);
this.generator.Emit(OperationCode.Conv_I4);
this.VisitAssignmentTo(length);
var counter = new TemporaryVariable(this.host.PlatformType.SystemInt32, this.method);
this.generator.Emit(OperationCode.Ldc_I4_0);
this.StackSize++;
this.VisitAssignmentTo(counter);
this.generator.Emit(OperationCode.Br, conditionCheck);
this.generator.MarkLabel(loopStart);
this.LoadLocal(array);
this.LoadLocal(counter);
this.LoadVectorElement(arrayType.ElementType);
this.VisitAssignmentTo(forEachStatement.Variable);
this.Traverse(forEachStatement.Body);
this.generator.MarkLabel(this.currentContinueTarget);
this.LoadLocal(counter);
this.generator.Emit(OperationCode.Ldc_I4_1);
this.StackSize++;
this.generator.Emit(OperationCode.Add);
this.StackSize--;
this.VisitAssignmentTo(counter);
this.generator.MarkLabel(conditionCheck);
this.EmitSequencePoint(forEachStatement.Collection.Locations);
this.LoadLocal(counter);
this.LoadLocal(length);
this.generator.Emit(OperationCode.Blt, loopStart);
this.generator.MarkLabel(this.currentBreakTarget);
this.currentBreakTarget = savedCurrentBreakTarget;
this.currentContinueTarget = savedCurrentContinueTarget;
}
private void InitializeArrayIndexerInstruction(Instruction instruction, LocalsAndOperands <V> state, IArrayTypeReference arrayType)
{
// Copied from Cci's DataFlowInferencer.cs
/* Contract.Requires(instruction != null);
* Contract.Requires(stack != null);
* Contract.Requires(arrayType != null);
* var rank = arrayType.Rank;
* var indices = new Instruction[rank];
* instruction.Operand2 = indices;
* for (var i = rank; i > 0; i--)
* indices[i - 1] = stack.Pop();
* instruction.Operand1 = stack.Pop();
* stack.Push(instruction);
*/
var rank = arrayType.Rank;
for (var i = rank; i > 0; i--)
{
state.Pop();
}
state.Pop();
state.Push(ValueAbstraction.Top); // need to be smarter about top
}
public override void VisitArrayTypeReference <TTypeReference>(IArrayTypeReference <TTypeReference> arrayTypeReference)
{
TypeReference = new ArrayTypeReferenceWrapper(arrayTypeReference);
}
public virtual void Visit(IArrayTypeReference arrayTypeReference)
{
this.Visit(arrayTypeReference.GetElementType(Context));
}
public void Visit(IArrayTypeReference arrayTypeReference)
{
throw new NotImplementedException();
}
public override void TraverseChildren(IArrayTypeReference arrayTypeReference) {
base.TraverseChildren(arrayTypeReference);
}
// Each plugged translator may choose to implement some action on each metadata / AST element
public virtual void onMetadataElement(IArrayTypeReference arrayTypeReference)
{
}
// Each plugged translator may choose to implement some action on each metadata / AST element
public virtual void onMetadataElement(IArrayTypeReference arrayTypeReference) { }
public override void TraverseChildren(IArrayTypeReference arrayTypeReference)
{ MethodEnter(arrayTypeReference);
base.TraverseChildren(arrayTypeReference);
MethodExit(); }
public override void VisitArrayTypeReference <TTypeReference>(IArrayTypeReference <TTypeReference> arrayTypeReference)
{
visitor.VisitArrayTypeReferenceWithReflection((ArrayTypeReferenceWithReflection)(object)arrayTypeReference);
}
/// <summary>
/// Traverses the children of the array type reference.
/// </summary>
public virtual void TraverseChildren(IArrayTypeReference arrayTypeReference)
{
this.TraverseChildren((ITypeReference)arrayTypeReference);
if (this.stopTraversal) return;
this.Traverse(arrayTypeReference.ElementType);
}
