|
public MethodParameter ( string method, int position ) : |
||
| method | string | |
| position | int | |
| return | ||
TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
switch (type.etype) {
case ElementType.SzArray:
var vector = (ArrayType) type;
return new ArrayType (ImportType (vector.ElementType, context));
case ElementType.Ptr:
var pointer = (PointerType) type;
return new PointerType (ImportType (pointer.ElementType, context));
case ElementType.ByRef:
var byref = (ByReferenceType) type;
return new ByReferenceType (ImportType (byref.ElementType, context));
case ElementType.Pinned:
var pinned = (PinnedType) type;
return new PinnedType (ImportType (pinned.ElementType, context));
case ElementType.Sentinel:
var sentinel = (SentinelType) type;
return new SentinelType (ImportType (sentinel.ElementType, context));
case ElementType.CModOpt:
var modopt = (OptionalModifierType) type;
return new OptionalModifierType (
ImportType (modopt.ModifierType, context),
ImportType (modopt.ElementType, context));
case ElementType.CModReqD:
var modreq = (RequiredModifierType) type;
return new RequiredModifierType (
ImportType (modreq.ModifierType, context),
ImportType (modreq.ElementType, context));
case ElementType.Array:
var array = (ArrayType) type;
var imported_array = new ArrayType (ImportType (array.ElementType, context));
if (array.IsVector)
return imported_array;
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear ();
for (int i = 0; i < dimensions.Count; i++) {
var dimension = dimensions [i];
imported_dimensions.Add (new ArrayDimension (dimension.LowerBound, dimension.UpperBound));
}
return imported_array;
case ElementType.GenericInst:
var instance = (GenericInstanceType) type;
var element_type = ImportType (instance.ElementType, context);
var imported_instance = new GenericInstanceType (element_type);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add (ImportType (arguments [i], context));
return imported_instance;
case ElementType.Var:
var var_parameter = (GenericParameter) type;
return context.TypeParameter (type.DeclaringType.FullName, var_parameter.Position);
case ElementType.MVar:
var mvar_parameter = (GenericParameter) type;
return context.MethodParameter (mvar_parameter.DeclaringMethod.Name, mvar_parameter.Position);
case ElementType.FnPtr:
var funcPtr = (FunctionPointerType)type;
var imported = new FunctionPointerType() {
HasThis = funcPtr.HasThis,
ExplicitThis = funcPtr.ExplicitThis,
CallingConvention = funcPtr.CallingConvention,
ReturnType = ImportType (funcPtr.ReturnType, context)
};
var parameters = funcPtr.Parameters;
for (int i = 0; i < parameters.Count; i++)
imported.Parameters.Add(
new ParameterDefinition (ImportType (parameters [i].ParameterType, context)));
return imported;
}
throw new NotSupportedException (type.etype.ToString ());
}
static TypeReference ImportGenericParameter(Type type, ImportGenericContext context)
{
if (context.IsEmpty)
throw new InvalidOperationException ();
if (type.DeclaringMethod != null)
{
return context.MethodParameter (type.DeclaringMethod.Name, type.GenericParameterPosition);
}
if (type.DeclaringType != null)
{
return context.TypeParameter (NormalizedFullName (type.DeclaringType), type.GenericParameterPosition);
}
throw new InvalidOperationException();
}
TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
switch (type.etype)
{
case ElementType.SzArray:
var vector = (ArrayType)type;
return(new ArrayType(ImportType(vector.ElementType, context)));
case ElementType.Ptr:
var pointer = (PointerType)type;
return(new PointerType(ImportType(pointer.ElementType, context)));
case ElementType.ByRef:
var byref = (ByReferenceType)type;
return(new ByReferenceType(ImportType(byref.ElementType, context)));
case ElementType.Pinned:
var pinned = (PinnedType)type;
return(new PinnedType(ImportType(pinned.ElementType, context)));
case ElementType.Sentinel:
var sentinel = (SentinelType)type;
return(new SentinelType(ImportType(sentinel.ElementType, context)));
case ElementType.FnPtr:
var fnptr = (FunctionPointerType)type;
var imported_fnptr = new FunctionPointerType()
{
HasThis = fnptr.HasThis,
ExplicitThis = fnptr.ExplicitThis,
CallingConvention = fnptr.CallingConvention,
ReturnType = ImportType(fnptr.ReturnType, context),
};
if (!fnptr.HasParameters)
{
return(imported_fnptr);
}
for (int i = 0; i < fnptr.Parameters.Count; i++)
{
imported_fnptr.Parameters.Add(new ParameterDefinition(
ImportType(fnptr.Parameters [i].ParameterType, context)));
}
return(imported_fnptr);
case ElementType.CModOpt:
var modopt = (OptionalModifierType)type;
return(new OptionalModifierType(
ImportType(modopt.ModifierType, context),
ImportType(modopt.ElementType, context)));
case ElementType.CModReqD:
var modreq = (RequiredModifierType)type;
return(new RequiredModifierType(
ImportType(modreq.ModifierType, context),
ImportType(modreq.ElementType, context)));
case ElementType.Array:
var array = (ArrayType)type;
var imported_array = new ArrayType(ImportType(array.ElementType, context));
if (array.IsVector)
{
return(imported_array);
}
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions [i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return(imported_array);
case ElementType.GenericInst:
var instance = (GenericInstanceType)type;
var element_type = ImportType(instance.ElementType, context);
var imported_instance = new GenericInstanceType(element_type);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
imported_arguments.Add(ImportType(arguments [i], context));
}
return(imported_instance);
case ElementType.Var:
var var_parameter = (GenericParameter)type;
if (var_parameter.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(var_parameter.DeclaringType.FullName, var_parameter.Position));
case ElementType.MVar:
var mvar_parameter = (GenericParameter)type;
if (mvar_parameter.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(((MethodReference)mvar_parameter.Owner).DeclaringType.FullName, mvar_parameter.DeclaringMethod.Name, mvar_parameter.Position));
}
throw new NotSupportedException(type.etype.ToString());
}
private TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
switch (type.etype)
{
case ElementType.SzArray:
{
ArrayType arrayType = (ArrayType)type;
return(new ArrayType(ImportType(arrayType.ElementType, context)));
}
case ElementType.Ptr:
{
PointerType pointerType = (PointerType)type;
return(new PointerType(ImportType(pointerType.ElementType, context)));
}
case ElementType.ByRef:
{
ByReferenceType byReferenceType = (ByReferenceType)type;
return(new ByReferenceType(ImportType(byReferenceType.ElementType, context)));
}
case ElementType.Pinned:
{
PinnedType pinnedType = (PinnedType)type;
return(new PinnedType(ImportType(pinnedType.ElementType, context)));
}
case ElementType.Sentinel:
{
SentinelType sentinelType = (SentinelType)type;
return(new SentinelType(ImportType(sentinelType.ElementType, context)));
}
case ElementType.FnPtr:
{
FunctionPointerType functionPointerType = (FunctionPointerType)type;
FunctionPointerType functionPointerType2 = new FunctionPointerType
{
HasThis = functionPointerType.HasThis,
ExplicitThis = functionPointerType.ExplicitThis,
CallingConvention = functionPointerType.CallingConvention,
ReturnType = ImportType(functionPointerType.ReturnType, context)
};
if (!functionPointerType.HasParameters)
{
return(functionPointerType2);
}
for (int j = 0; j < functionPointerType.Parameters.Count; j++)
{
functionPointerType2.Parameters.Add(new ParameterDefinition(ImportType(functionPointerType.Parameters[j].ParameterType, context)));
}
return(functionPointerType2);
}
case ElementType.CModOpt:
{
OptionalModifierType optionalModifierType = (OptionalModifierType)type;
return(new OptionalModifierType(ImportType(optionalModifierType.ModifierType, context), ImportType(optionalModifierType.ElementType, context)));
}
case ElementType.CModReqD:
{
RequiredModifierType requiredModifierType = (RequiredModifierType)type;
return(new RequiredModifierType(ImportType(requiredModifierType.ModifierType, context), ImportType(requiredModifierType.ElementType, context)));
}
case ElementType.Array:
{
ArrayType arrayType2 = (ArrayType)type;
ArrayType arrayType3 = new ArrayType(ImportType(arrayType2.ElementType, context));
if (arrayType2.IsVector)
{
return(arrayType3);
}
Collection <ArrayDimension> dimensions = arrayType2.Dimensions;
Collection <ArrayDimension> dimensions2 = arrayType3.Dimensions;
dimensions2.Clear();
for (int k = 0; k < dimensions.Count; k++)
{
ArrayDimension arrayDimension = dimensions[k];
dimensions2.Add(new ArrayDimension(arrayDimension.LowerBound, arrayDimension.UpperBound));
}
return(arrayType3);
}
case ElementType.GenericInst:
{
GenericInstanceType genericInstanceType = (GenericInstanceType)type;
GenericInstanceType genericInstanceType2 = new GenericInstanceType(ImportType(genericInstanceType.ElementType, context));
Collection <TypeReference> genericArguments = genericInstanceType.GenericArguments;
Collection <TypeReference> genericArguments2 = genericInstanceType2.GenericArguments;
for (int i = 0; i < genericArguments.Count; i++)
{
genericArguments2.Add(ImportType(genericArguments[i], context));
}
return(genericInstanceType2);
}
case ElementType.Var:
{
GenericParameter genericParameter2 = (GenericParameter)type;
if (genericParameter2.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(genericParameter2.DeclaringType.FullName, genericParameter2.Position));
}
case ElementType.MVar:
{
GenericParameter genericParameter = (GenericParameter)type;
if (genericParameter.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(context.NormalizeMethodName(genericParameter.DeclaringMethod), genericParameter.Position));
}
default:
throw new NotSupportedException(type.etype.ToString());
}
}
TypeReference ImportGenericParameter(Type type, ImportGenericContext context, ISRImportMapper mapper)
{
if (context.IsEmpty)
throw new InvalidOperationException ();
if (type.DeclaringMethod != null)
return context.MethodParameter(type.DeclaringMethod, type.GenericParameterPosition, mapper);
if (type.DeclaringType != null)
return context.TypeParameter(type.DeclaringType, type.GenericParameterPosition, mapper);
throw new InvalidOperationException();
}
static TypeReference ImportGenericParameter(Type type, ImportGenericContext context)
{
if (context.IsEmpty)
throw new InvalidOperationException ();
#if !NETFX_CORE
if (type.DeclaringMethod != null)
return context.MethodParameter (type.DeclaringMethod.Name, type.GenericParameterPosition);
#else
var typeInfo = type.GetTypeInfo();
if (typeInfo.DeclaringMethod != null)
return context.MethodParameter(typeInfo.DeclaringMethod.Name, type.GenericParameterPosition);
#endif
if (type.DeclaringType != null)
return context.TypeParameter (NormalizedFullName (type.DeclaringType), type.GenericParameterPosition);
throw new InvalidOperationException();
}
