Beispiel #1
0
        /// <summary>
        /// Loads all methods From the given metadata module.
        /// </summary>
        /// <param name="module">The metadata module to load methods From.</param>
        /// <param name="declaringType">The type, which declared the method.</param>
        /// <param name="first">The first method token to load.</param>
        /// <param name="last">The last method token to load (non-inclusive.)</param>
        /// <param name="offset">The offset into the method table to start loading methods From.</param>
        private void LoadMethods(IMetadataModule module, RuntimeType declaringType, TokenTypes first, TokenTypes last, ref int offset)
        {
            IMetadataProvider md = module.Metadata;
            MethodDefRow      methodDef, nextMethodDef = new MethodDefRow();
            TokenTypes        maxParam, maxMethod = md.GetMaxTokenValue(TokenTypes.MethodDef);

            if (first < last)
            {
                md.Read(first, out methodDef);
                for (TokenTypes token = first; token < last; token++)
                {
                    if (token < maxMethod)
                    {
                        md.Read(token + 1, out nextMethodDef);
                        maxParam = nextMethodDef.ParamList;
                    }
                    else
                    {
                        maxParam = md.GetMaxTokenValue(TokenTypes.Param) + 1;
                    }

                    Debug.Assert(offset < _methods.Length, @"Invalid method index.");
                    _methods[offset++] = new CilRuntimeMethod(offset, module, ref methodDef, maxParam, declaringType);
                    methodDef          = nextMethodDef;
                }
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="CilGenericMethod"/> class.
 /// </summary>
 /// <param name="module">The module.</param>
 /// <param name="genericMethod">The generic method.</param>
 /// <param name="signature">The signature.</param>
 /// <param name="declaringType">Type of the declaring.</param>
 public CilGenericMethod(ITypeModule module, CilRuntimeMethod genericMethod, MethodSignature signature, RuntimeType declaringType) :
     base(module, genericMethod.Token, declaringType)
 {
     this.Signature      = signature;
     this.Attributes     = genericMethod.Attributes;
     this.ImplAttributes = genericMethod.ImplAttributes;
     this.Rva            = genericMethod.Rva;
     this.Parameters     = genericMethod.Parameters;
     base.Name           = genericMethod.Name;
 }
Beispiel #3
0
        /// <summary>
        /// Loads all methods from the given metadata module.
        /// </summary>
        /// <param name="declaringType">The type, which declared the method.</param>
        /// <param name="first">The first method token to load.</param>
        /// <param name="last">The last method token to load (non-inclusive.)</param>
        private void LoadMethods(RuntimeType declaringType, Token first, Token last)
        {
            if (first.RID >= last.RID)
            {
                return;
            }

            Token        maxMethod     = GetMaxTokenValue(TableType.MethodDef);
            MethodDefRow methodDef     = metadataProvider.ReadMethodDefRow(first);
            MethodDefRow nextMethodDef = new MethodDefRow();

            foreach (Token token in first.Upto(last.PreviousRow))
            {
                Token maxParam;

                if (token.RID < maxMethod.RID)
                {
                    nextMethodDef = metadataProvider.ReadMethodDefRow(token.NextRow);
                    maxParam      = nextMethodDef.ParamList;
                }
                else
                {
                    maxParam = GetMaxTokenValue(TableType.Param).NextRow;
                }

                CilRuntimeMethod method = new CilRuntimeMethod(
                    this,
                    GetString(methodDef.NameStringIdx),
                    GetMethodSignature(methodDef.SignatureBlobIdx),
                    token,
                    declaringType,
                    methodDef.Flags,
                    methodDef.ImplFlags,
                    methodDef.Rva
                    );

                LoadParameters(method, methodDef.ParamList, maxParam);
                declaringType.Methods.Add(method);

                methods[token.RID - 1] = method;
                methodDef = nextMethodDef;
            }
        }