private FunctionPointer/*!*/ ParseFunctionPointer(MemoryCursor/*!*/ sigReader)
{
CallingConventionFlags convention = (CallingConventionFlags)sigReader.ReadByte();
int n = sigReader.ReadCompressedInt();
TypeNode returnType = this.ParseTypeSignature(sigReader);
if(returnType == null)
returnType = CoreSystemTypes.Object;
TypeNodeList parameterTypes = new TypeNodeList();
int m = n;
for(int i = 0; i < n; i++)
{
TypeNode t = this.ParseTypeSignature(sigReader);
if (t == null)
m = i--;
else
parameterTypes.Add(t);
}
FunctionPointer fp = FunctionPointer.For(parameterTypes, returnType);
fp.CallingConvention = convention;
fp.VarArgStart = m;
return fp;
}
private static string ReadSerString(MemoryCursor/*!*/ sigReader)
{
int n = sigReader.ReadCompressedInt();
if (n < 0) return null;
return sigReader.ReadUTF8(n);
}
private TypeNode ParseTypeSignature(MemoryCursor/*!*/ sigReader, ref bool pinned, ref bool isTypeArgument)
{
TypeNode elementType;
ElementType tok = (ElementType)sigReader.ReadCompressedInt();
if (tok == ElementType.Pinned)
{
pinned = true;
tok = (ElementType)sigReader.ReadCompressedInt();
}
switch (tok)
{
case ElementType.Boolean: return CoreSystemTypes.Boolean;
case ElementType.Char: return CoreSystemTypes.Char;
case ElementType.Double: return CoreSystemTypes.Double;
case ElementType.Int16: return CoreSystemTypes.Int16;
case ElementType.Int32: return CoreSystemTypes.Int32;
case ElementType.Int64: return CoreSystemTypes.Int64;
case ElementType.Int8: return CoreSystemTypes.Int8;
case ElementType.IntPtr: return CoreSystemTypes.IntPtr;
case ElementType.BoxedEnum:
case ElementType.Object: return CoreSystemTypes.Object;
case ElementType.Single: return CoreSystemTypes.Single;
case ElementType.String: return CoreSystemTypes.String;
case ElementType.DynamicallyTypedReference: return CoreSystemTypes.DynamicallyTypedReference;
case ElementType.UInt16: return CoreSystemTypes.UInt16;
case ElementType.UInt32: return CoreSystemTypes.UInt32;
case ElementType.UInt64: return CoreSystemTypes.UInt64;
case ElementType.UInt8: return CoreSystemTypes.UInt8;
case ElementType.UIntPtr: return CoreSystemTypes.UIntPtr;
case ElementType.Void: return CoreSystemTypes.Void;
case ElementType.Pointer:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
return elementType.GetPointerType();
case ElementType.Reference:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
return elementType.GetReferenceType();
case ElementType.FunctionPointer:
return this.ParseFunctionPointer(sigReader);
case ElementType.OptionalModifier:
case ElementType.RequiredModifier:
TypeNode modifier = this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt());
if (modifier == null) modifier = CoreSystemTypes.Object;
TypeNode modified = this.ParseTypeSignature(sigReader, ref pinned);
if (modified == null) modified = CoreSystemTypes.Object;
if (modified == null || modified == null) return null;
if (tok == ElementType.RequiredModifier)
return RequiredModifier.For(modifier, modified);
else
return OptionalModifier.For(modifier, modified);
case ElementType.Class:
return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt());
case ElementType.ValueType:
return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt(), true);
case ElementType.TypeParameter:
TypeNode tPar = null;
int pnum = sigReader.ReadCompressedInt();
if (this.currentTypeParameters != null && this.currentTypeParameters.Count > pnum)
tPar = this.currentTypeParameters[pnum];
if (tPar == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture,
ExceptionStrings.BadTypeParameterInPositionForType, pnum, this.currentType == null ? "" : this.currentType.FullName));
tPar = new TypeParameter();
tPar.Name = Identifier.For("Bad type parameter in position " + pnum);
tPar.DeclaringModule = this.module;
}
isTypeArgument = true;
return tPar;
case ElementType.MethodParameter:
TypeNode mTPar = null;
pnum = sigReader.ReadCompressedInt();
if (this.currentMethodTypeParameters != null && this.currentMethodTypeParameters.Count > pnum)
mTPar = this.currentMethodTypeParameters[pnum];
if (mTPar == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture,
ExceptionStrings.BadMethodTypeParameterInPosition, pnum));
mTPar = new MethodTypeParameter();
mTPar.Name = Identifier.For("Bad method type parameter in position " + pnum);
}
isTypeArgument = true;
return mTPar;
case ElementType.GenericTypeInstance:
TypeNodeList savedCurrentTypeParameters = this.currentTypeParameters;
TypeNode template = this.ParseTypeSignature(sigReader, ref pinned);
this.currentTypeParameters = savedCurrentTypeParameters;
if (template == null || template.ConsolidatedTemplateParameters == null) return template; //Likely a dummy type
if (CoreSystemTypes.Initialized)
{
if (this.currentTypeParameters == null || this.currentTypeParameters.Count == 0)
this.currentTypeParameters = template.ConsolidatedTemplateParameters;
TypeNodeList genArgs = this.ParseTypeList(sigReader);
if (this.module == null) return null;
TypeNode genInst = template.GetGenericTemplateInstance(this.module, genArgs);
this.currentTypeParameters = savedCurrentTypeParameters;
return genInst;
}
InterfaceExpression ifaceExpr = new InterfaceExpression(null);
ifaceExpr.Template = template;
ifaceExpr.Namespace = template.Namespace;
ifaceExpr.Name = template.Name;
ifaceExpr.TemplateArguments = this.ParseTypeList(sigReader);
this.currentTypeParameters = savedCurrentTypeParameters;
return ifaceExpr;
case ElementType.SzArray:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
return elementType.GetArrayType(1);
case ElementType.Array:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
int rank = sigReader.ReadCompressedInt();
int numSizes = sigReader.ReadCompressedInt();
int[] sizes = new int[numSizes];
for (int i = 0; i < numSizes; i++) sizes[i] = sigReader.ReadCompressedInt();
int numLoBounds = sigReader.ReadCompressedInt();
int[] loBounds = new int[numLoBounds];
for (int i = 0; i < numLoBounds; i++) loBounds[i] = sigReader.ReadCompressedInt();
return elementType.GetArrayType(rank, numSizes, numLoBounds, sizes, loBounds);
case ElementType.Sentinel: return null;
case ElementType.Type: return CoreSystemTypes.Type;
case ElementType.Enum: return this.GetTypeFromSerializedName(ReadSerString(sigReader));
}
throw new InvalidMetadataException(ExceptionStrings.MalformedSignature);
}
private bool TypeSignatureIsClass(MemoryCursor/*!*/ sigReader)
{
ElementType tok = (ElementType)sigReader.ReadCompressedInt();
switch (tok)
{
case ElementType.Pinned:
case ElementType.Pointer:
case ElementType.Reference:
return this.TypeSignatureIsClass(sigReader);
case ElementType.OptionalModifier:
case ElementType.RequiredModifier:
sigReader.ReadCompressedInt();
return this.TypeSignatureIsClass(sigReader);
case ElementType.Class:
return true;
case ElementType.GenericTypeInstance:
return this.TypeSignatureIsClass(sigReader);
case ElementType.TypeParameter:
{
int pnum = sigReader.ReadCompressedInt();
if (this.currentTypeParameters != null && this.currentTypeParameters.Count > pnum)
{
TypeNode tPar = this.currentTypeParameters[pnum];
return tPar != null && tPar is Class;
}
return false;
}
case ElementType.MethodParameter:
{
int pnum = sigReader.ReadCompressedInt();
if (this.currentMethodTypeParameters != null && this.currentMethodTypeParameters.Count > pnum)
{
TypeNode tPar = this.currentMethodTypeParameters[pnum];
return tPar != null && tPar is Class;
}
return false;
}
default:
return false;
}
}
private TypeNodeList/*!*/ ParseTypeList(MemoryCursor/*!*/ sigReader)
{
int n = sigReader.ReadCompressedInt();
TypeNodeList result = new TypeNodeList();
for(int i = 0; i < n; i++)
{
TypeNode t = this.ParseTypeSignature(sigReader);
if(t == null || t == Struct.Dummy)
{
// Can happen when dealing with a primitive type that implements an interface that references the primitive type.
// For example, System.String implements IComparable<System.String>.
if(this.currentType != null && !CoreSystemTypes.Initialized)
t = this.currentType;
else
{
Debug.Assert(false);
t = new TypeParameter();
t.Name = Identifier.For("Bad type parameter in position " + i);
t.DeclaringModule = this.module;
}
}
result.Add(t);
}
return result;
}
private AttributeNode GetPermissionAttribute2(MemoryCursor/*!*/ sigReader, System.Security.Permissions.SecurityAction action)
{
int typeNameLength = sigReader.ReadCompressedInt();
string serializedTypeName = sigReader.ReadUTF8(typeNameLength);
TypeNode attrType = null;
try
{
attrType = this.GetTypeFromSerializedName(serializedTypeName);
}
catch (InvalidMetadataException) { }
if (attrType == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture, ExceptionStrings.CouldNotResolveType, serializedTypeName));
return null;
}
InstanceInitializer cons = attrType.GetConstructor(CoreSystemTypes.SecurityAction);
if (cons == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture,
ExceptionStrings.SecurityAttributeTypeDoesNotHaveADefaultConstructor, serializedTypeName));
return null;
}
sigReader.ReadCompressedInt(); //caBlobLength
int numProps = sigReader.ReadCompressedInt(); //Skip over the number of properties in the CA blob
ExpressionList arguments = new ExpressionList();
arguments.Add(new Literal(action, CoreSystemTypes.SecurityAction));
this.GetCustomAttributeNamedArguments(arguments, (ushort)numProps, sigReader);
return new AttributeNode(new MemberBinding(null, cons), arguments);
}
private static void GetAndCheckSignatureToken(int expectedToken, MemoryCursor/*!*/ sigReader)
{
int tok = sigReader.ReadCompressedInt();
if (tok != expectedToken) throw new InvalidMetadataException(ExceptionStrings.MalformedSignature);
}
