private static void ReadMethods(TypeDefinition type) { Collection <MethodDefinition> methods = type.Methods; for (int i = 0; i < methods.Count; i++) { MethodDefinition item = methods[i]; ImmediateModuleReader.ReadGenericParameters(item); if (item.HasParameters) { ImmediateModuleReader.ReadParameters(item); } if (item.HasOverrides) { ImmediateModuleReader.Read(item.Overrides); } if (item.IsPInvokeImpl) { ImmediateModuleReader.Read(item.PInvokeInfo); } ImmediateModuleReader.ReadSecurityDeclarations(item); ImmediateModuleReader.ReadCustomAttributes(item); MethodReturnType methodReturnType = item.MethodReturnType; if (methodReturnType.HasConstant) { ImmediateModuleReader.Read(methodReturnType.Constant); } if (methodReturnType.HasMarshalInfo) { ImmediateModuleReader.Read(methodReturnType.MarshalInfo); } ImmediateModuleReader.ReadCustomAttributes(methodReturnType); } }
private void ReadMethods(TypeDefinition type) { Collection <MethodDefinition> methods = type.Methods; for (int i = 0; i < methods.Count; i++) { MethodDefinition methodDefinition = methods[i]; ReadGenericParameters(methodDefinition); if (methodDefinition.HasParameters) { ReadParameters(methodDefinition); } if (methodDefinition.HasOverrides) { Mixin.Read(methodDefinition.Overrides); } if (methodDefinition.IsPInvokeImpl) { Mixin.Read(methodDefinition.PInvokeInfo); } ReadSecurityDeclarations(methodDefinition); ReadCustomAttributes(methodDefinition); MethodReturnType methodReturnType = methodDefinition.MethodReturnType; if (methodReturnType.HasConstant) { Mixin.Read(methodReturnType.Constant); } if (methodReturnType.HasMarshalInfo) { Mixin.Read(methodReturnType.MarshalInfo); } ReadCustomAttributes(methodReturnType); } }
internal MethodReference(string name) : base(name) { m_returnType = new MethodReturnType (null); AllReferences.Add(this); }
public MethodReference(string name, TypeReference returnType) : base(name) { Mixin.CheckType(returnType, Mixin.Argument.returnType); return_type = new MethodReturnType(this); return_type.ReturnType = returnType; base.token = new MetadataToken(TokenType.MemberRef); }
public MethodReference(string name, TypeReference declaringType, TypeReference returnType, bool hasThis, bool explicitThis, MethodCallingConvention callConv) : this(name, hasThis, explicitThis, callConv) { this.DeclaringType = declaringType; this.ReturnType.ReturnType = returnType; }
/*Telerik Authorship*/ /// <summary> /// Performs shallow clone of the MethodReturnType of <paramref name="method"/> /// </summary> private MethodReturnType DeepCloneMethodReturnType(MethodReference method) { MethodReturnType result = new MethodReturnType(this); // not sure how will this behave result.parameter = method.MethodReturnType.parameter; result.ReturnType = DeepCloneType(method.ReturnType); return(result); }
public MethodReference(string name, TypeReference returnType) : base(name) { if (returnType == null) throw new ArgumentNullException ("returnType"); this.return_type = new MethodReturnType (this); this.return_type.ReturnType = returnType; this.token = new MetadataToken (TokenType.MemberRef); }
public static void CopyReturnTypeTo(MethodReturnType dst, MethodReturnType src) { dst.Attributes = src.Attributes; dst.Constant = src.Constant; dst.CustomAttributes.Clear(); foreach (var attr in src.CustomAttributes) dst.CustomAttributes.Add(attr); dst.HasConstant = src.HasConstant; dst.HasDefault = src.HasDefault; dst.HasFieldMarshal = src.HasFieldMarshal; dst.MarshalInfo = src.MarshalInfo; dst.ReturnType = src.ReturnType; }
internal MethodReturnType ResolveGenericTypes(Collection <GenericParameter> parameters, Collection <TypeReference> arguments) { TypeReference resolved = MemberReference.ResolveType(return_type, parameters, arguments); MethodReturnType result; if (resolved == return_type) { return(this); } result = new MethodReturnType(method); result.ReturnType = resolved; if (parameter != null) { result.MetadataToken = MetadataToken; result.MarshalInfo = MarshalInfo; result.Constant = Constant; //TODO: result.m_param.CustomAttributes = CustomAttributes; } return(result); }
void ConvertAttributes(AttributedNode attributedNode, MethodReturnType methodReturnType, ModuleDefinition module) { ConvertCustomAttributes(attributedNode, methodReturnType, "return"); if (methodReturnType.HasMarshalInfo) { var marshalInfo = ConvertMarshalInfo(methodReturnType, module); attributedNode.Attributes.Add(new AttributeSection(marshalInfo) { AttributeTarget = "return" }); } }
void CompleteMethods() { TypeDefTable tdefTable = m_tableReader.GetTypeDefTable(); if (!m_tHeap.HasTable(MethodTable.RId)) { m_meths = new MethodDefinition [0]; return; } MethodTable methTable = m_tableReader.GetMethodTable(); ParamTable paramTable = m_tableReader.GetParamTable(); if (!m_tHeap.HasTable(ParamTable.RId)) { m_parameters = new ParameterDefinition [0]; } else { m_parameters = new ParameterDefinition [paramTable.Rows.Count]; } for (int i = 0; i < m_typeDefs.Length; i++) { TypeDefinition dec = m_typeDefs [i]; int index = i, next; if (index == tdefTable.Rows.Count - 1) { next = methTable.Rows.Count + 1; } else { next = (int)(tdefTable [index + 1]).MethodList; } for (int j = (int)tdefTable [index].MethodList; j < next; j++) { MethodRow methRow = methTable [j - 1]; MethodDefinition mdef = m_meths [j - 1]; if (mdef.IsConstructor) { dec.Constructors.Add(mdef); } else { dec.Methods.Add(mdef); } GenericContext context = new GenericContext(mdef); MethodDefSig msig = m_sigReader.GetMethodDefSig(methRow.Signature); mdef.HasThis = msig.HasThis; mdef.ExplicitThis = msig.ExplicitThis; mdef.CallingConvention = msig.MethCallConv; int prms; if (j == methTable.Rows.Count) { prms = m_parameters.Length + 1; } else { prms = (int)(methTable [j]).ParamList; } ParameterDefinition retparam = null; //TODO: optimize this ParamRow pRow = null; int start = (int)methRow.ParamList - 1; if (paramTable != null && start < prms - 1) { pRow = paramTable [start]; } if (pRow != null && pRow.Sequence == 0) // ret type { retparam = new ParameterDefinition( m_root.Streams.StringsHeap [pRow.Name], 0, pRow.Flags, null); retparam.Method = mdef; m_parameters [start] = retparam; start++; } for (int k = 0; k < msig.ParamCount; k++) { int pointer = start + k; if (paramTable != null && pointer < prms - 1) { pRow = paramTable [pointer]; } Param psig = msig.Parameters [k]; ParameterDefinition pdef; if (pRow != null) { pdef = BuildParameterDefinition( m_root.Streams.StringsHeap [pRow.Name], pRow.Sequence, pRow.Flags, psig, context); pdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Param, pointer); m_parameters [pointer] = pdef; } else { pdef = BuildParameterDefinition( string.Concat("A_", mdef.IsStatic ? k : k + 1), k + 1, (ParamAttributes)0, psig, context); } pdef.Method = mdef; mdef.Parameters.Add(pdef); } mdef.ReturnType = GetMethodReturnType(msig, context); MethodReturnType mrt = mdef.ReturnType as MethodReturnType; mrt.Method = mdef; if (retparam != null) { mrt.Parameter = retparam; mrt.Parameter.ParameterType = mrt.ReturnType; } } } uint eprid = CodeReader.GetRid((int)m_reader.Image.CLIHeader.EntryPointToken); if (eprid > 0 && eprid <= m_meths.Length) { m_module.Assembly.EntryPoint = GetMethodDefAt(eprid); } }
static bool IsIgnored (ICollection<IMetadataTokenProvider> list, MethodReturnType returnType) { return (list.Contains (returnType) || IsIgnored (list, returnType.Method)); }
internal MethodReference(string name) : base(name) { m_returnType = new MethodReturnType(null); }
void addMethodReturnType(MethodReturnType methodReturnType) { if (methodReturnType == null) return; pushMember(methodReturnType.Method as MemberReference); pushMember(methodReturnType.ReturnType); addParameterDefinition(methodReturnType.Parameter); }
public static TypeDefinition CreateDelegate(ModuleDefinition module, string @namespace, string name, TypeAttributes delegateVisibility = TypeAttributes.NotPublic, MethodReturnType returnType = null, IEnumerable<ParameterDefinition> parameters = null) { if ((delegateVisibility & TypeAttributes.VisibilityMask) != delegateVisibility) throw new ArgumentException("Parameter may only contain visibility attributes.", "delegateVisibility"); var objectRef = module.TypeSystem.Object; var voidRef = module.TypeSystem.Void; var intPtrRef = module.TypeSystem.IntPtr; var multicastDelegateRef = module.Import(typeof(MulticastDelegate)); var asyncCallbackRef = module.Import(typeof(AsyncCallback)); var iAsyncResultRef = module.Import(typeof(IAsyncResult)); if (returnType == null) returnType = new MethodReturnType(null) { ReturnType = voidRef }; if (parameters == null) parameters = Enumerable.Empty<ParameterDefinition>(); TypeAttributes typeAttributes = delegateVisibility | TypeAttributes.AnsiClass | TypeAttributes.Sealed; TypeDefinition td = new TypeDefinition(@namespace, name, typeAttributes, multicastDelegateRef); MethodAttributes ctorAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName; //.ctor MethodDefinition ctor = new MethodDefinition(".ctor", ctorAttributes, voidRef) { IsRuntime = true, IsManaged = true }; ctor.Parameters.Add(new ParameterDefinition("object", ParameterAttributes.None, objectRef)); ctor.Parameters.Add(new ParameterDefinition("method", ParameterAttributes.None, intPtrRef)); td.Methods.Add(ctor); //Invoke MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual; MethodDefinition InvokeMethod = new MethodDefinition("Invoke", methodAttributes, returnType.ReturnType) { IsRuntime = true, IsManaged = true }; CopyReturnTypeTo(InvokeMethod.MethodReturnType, returnType); foreach (var p in parameters) InvokeMethod.Parameters.Add(p); td.Methods.Add(InvokeMethod); //BeginInvoke MethodDefinition BeginInvokeMethod = new MethodDefinition("BeginInvoke", methodAttributes, iAsyncResultRef) { IsRuntime = true, IsManaged = true }; foreach (var p in parameters) BeginInvokeMethod.Parameters.Add(p); BeginInvokeMethod.Parameters.Add(new ParameterDefinition("callback", ParameterAttributes.None, asyncCallbackRef)); BeginInvokeMethod.Parameters.Add(new ParameterDefinition("object", ParameterAttributes.None, objectRef)); td.Methods.Add(BeginInvokeMethod); //EndInvoke MethodDefinition EndInvokeMethod = new MethodDefinition("EndInvoke", methodAttributes, returnType.ReturnType) { IsRuntime = true, IsManaged = true }; CopyReturnTypeTo(EndInvokeMethod.MethodReturnType, returnType); EndInvokeMethod.Parameters.Add(new ParameterDefinition("result", ParameterAttributes.None, iAsyncResultRef)); td.Methods.Add(EndInvokeMethod); return td; }
public CallSite(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType) { m_function = new MethodReference(string.Empty, hasThis, explicitThis, callConv); m_function.ReturnType = retType; }
private void Merge(DeepCopier copier, MethodReturnType def1, MethodReturnType def2) { copier.MergeAll(def1,def2,def2,"Method","ReturnType"); }
public MethodReference (string name, TypeReference declaringType, TypeReference returnType, bool hasThis, bool explicitThis, MethodCallingConvention callConv) : this (name, hasThis, explicitThis, callConv) { this.DeclaringType = declaringType; this.ReturnType.ReturnType = returnType; }
internal MethodReference () { this.return_type = new MethodReturnType (this); this.token = new MetadataToken (TokenType.MemberRef); }
public static bool MethodReturnTypeEquals(MethodReturnType a, MethodReturnType b) { return a.HasConstant == b.HasConstant && TypeReferenceEquals(a.ReturnType, b.ReturnType); }
private Type MapReturnType(MethodReturnType returnType) { return outer.ResolveReturnType(returnType); }
/*Telerik Authorship*/ /// <summary> /// Performs shallow clone of the MethodReturnType of <paramref name="method"/> /// </summary> private MethodReturnType DeepCloneMethodReturnType(MethodReference method) { MethodReturnType result = new MethodReturnType(this); // not sure how will this behave result.parameter = method.MethodReturnType.parameter; result.ReturnType = DeepCloneType(method.ReturnType); return result; }
private IEnumerable<ProjectReference> GetMethodReturnAttributesReferences( MethodReturnType methodReturnType, AuditEntryParameters parameters) { if (methodReturnType.HasCustomAttributes) { var references = methodReturnType.CustomAttributes. SelectMany(ca => GetCustomAttributeReferences(ca, parameters)); foreach(var projectReference in references) yield return projectReference; } if (methodReturnType.HasMarshalInfo) { var projectReference = GetMarshalInfoReference(methodReturnType.MarshalInfo, parameters); if (projectReference != null) yield return projectReference; } yield break; }
protected DefaultMarshalInfoWriter MarshalInfoWriterFor(MethodReturnType methodReturnType) { return this._marshaler.MarshalInfoWriterFor(methodReturnType); }
private MethodReturnType Copy(DeepCopier copier, MethodReturnType def, IMethodSignature parent) { var ret= new MethodReturnType(parent); ret.ReturnType = CopyReference(copier,def.ReturnType); copier.Log("< MethodReturnType "); copier.CopyAll(def,ret,ret,"Method","ReturnType"); return ret; }
internal Type ResolveReturnType(MethodReturnType returnType) { return ResolveType(returnType.ReturnType); }
bool RequiresParameterRow(MethodReturnType mrt) { return mrt.HasConstant || mrt.MarshalSpec != null || mrt.CustomAttributes.Count > 0 || mrt.Parameter.Attributes != (ParamAttributes) 0; }
public FunctionPointerType(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType) : base(retType.ReturnType) { m_function = new MethodReference ("method", hasThis, explicitThis, callConv); m_function.ReturnType = retType; }
public static string ForReturnType(MethodReturnType methodReturnType) { var name = methodReturnType.GetNamedAttributeName(); return ForType(methodReturnType.ReturnType, name); }
internal MethodReturnType ResolveGenericTypes(Collection<GenericParameter> parameters, Collection<TypeReference> arguments) { TypeReference resolved = MemberReference.ResolveType (return_type, parameters, arguments); MethodReturnType result; if (resolved == return_type) return this; result = new MethodReturnType (method); result.ReturnType = resolved; if (parameter != null) { result.MetadataToken = MetadataToken; result.MarshalInfo = MarshalInfo; result.Constant = Constant; //TODO: result.m_param.CustomAttributes = CustomAttributes; } return result; }
public FunctionPointerType(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType) : base(retType.ReturnType) { m_function = new MethodReference("method", hasThis, explicitThis, callConv); m_function.ReturnType = retType; }
private void InitializeReturnType(MethodBuilder methodBuilder, MethodReturnType returnType) { methodBuilder.SetReturnType(ResolveReturnType(returnType)); ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(0, System.Reflection.ParameterAttributes.Retval, null); if (returnType.HasConstant) parameterBuilder.SetConstant(returnType.Constant); metadataPass.Add(delegate { InitializeCustomAttributes(parameterBuilder.SetCustomAttribute, returnType.CustomAttributes); }); }
public CallSite (bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType) { m_function = new MethodReference (string.Empty, hasThis, explicitThis, callConv); m_function.ReturnType = retType; }
internal MethodReference() { return_type = new MethodReturnType(this); base.token = new MetadataToken(TokenType.MemberRef); }