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); }