public override void VisitMethodRefSig(MethodRefSig methodRef)
 {
     m_sigWriter.Write(methodRef.CallingConvention);
     Write(methodRef.ParamCount);
     Write(methodRef.RetType);
     Write(methodRef.Parameters, methodRef.Sentinel);
 }
        public MethodRefSig GetMethodRefSig(uint index)
        {
            MethodRefSig m = m_signatures [index] as MethodRefSig;

            if (m == null)
            {
                m = new MethodRefSig(index);
                m.Accept(this);
                m_signatures [index] = m;
            }
            return(m);
        }
        /*
         *
         * public MarshalSig GetMarshalSig (uint index)
         * {
         *      MarshalSig ms = m_signatures [index] as MarshalSig;
         *      if (ms == null) {
         *              byte [] data = m_root.Streams.BlobHeap.Read (index);
         *              ms = ReadMarshalSig (data);
         *              m_signatures [index] = ms;
         *      }
         *      return ms;
         * }
         *
         */

        public MethodSig GetStandAloneMethodSig(uint index)
        {
            int start;

            if ((m_blobData [index] & 0x5) > 0)
            {
                MethodRefSig mrs = new MethodRefSig(index);
                ReadMethodRefSig(mrs, m_blobData, (int)index, out start);
                return(mrs);
            }
            else
            {
                MethodDefSig mds = new MethodDefSig(index);
                ReadMethodDefSig(mds, m_blobData, (int)index, out start);
                return(mds);
            }
        }
        public MethodSig GetStandAloneMethodSig(uint index)
        {
            byte [] data = m_root.Streams.BlobHeap.Read(index);
            int     start;

            if ((data [0] & 0x5) > 0)
            {
                MethodRefSig mrs = new MethodRefSig(index);
                ReadMethodRefSig(mrs, data, 0, out start);
                return(mrs);
            }
            else
            {
                MethodDefSig mds = new MethodDefSig(index);
                ReadMethodDefSig(mds, data, 0, out start);
                return(mds);
            }
        }
        void ReadMethodRefSig(MethodRefSig methodRef, byte [] data, int pos, out int start)
        {
            methodRef.CallingConvention = data [pos];
            start                  = pos + 1;
            methodRef.HasThis      = (methodRef.CallingConvention & 0x20) != 0;
            methodRef.ExplicitThis = (methodRef.CallingConvention & 0x40) != 0;
            if ((methodRef.CallingConvention & 0x1) != 0)
            {
                methodRef.MethCallConv |= MethodCallingConvention.C;
            }
            else if ((methodRef.CallingConvention & 0x2) != 0)
            {
                methodRef.MethCallConv |= MethodCallingConvention.StdCall;
            }
            else if ((methodRef.CallingConvention & 0x3) != 0)
            {
                methodRef.MethCallConv |= MethodCallingConvention.ThisCall;
            }
            else if ((methodRef.CallingConvention & 0x4) != 0)
            {
                methodRef.MethCallConv |= MethodCallingConvention.FastCall;
            }
            else if ((methodRef.CallingConvention & 0x5) != 0)
            {
                methodRef.MethCallConv |= MethodCallingConvention.VarArg;
            }
            else
            {
                methodRef.MethCallConv |= MethodCallingConvention.Default;
            }
            methodRef.ParamCount = Utilities.ReadCompressedInteger(data, start, out start);
            methodRef.RetType    = this.ReadRetType(data, start, out start);
            int sentpos;

            methodRef.Parameters = this.ReadParameters(methodRef.ParamCount, data, start, out sentpos);
            methodRef.Sentinel   = sentpos;
        }
        SigType ReadType(byte [] data, int pos, out int start)
        {
            start = pos;
            ElementType element = (ElementType)Utilities.ReadCompressedInteger(data, start, out start);

            switch (element)
            {
            case ElementType.ValueType:
                VALUETYPE vt = new VALUETYPE();
                vt.Type = Utilities.GetMetadataToken(CodedIndex.TypeDefOrRef,
                                                     (uint)Utilities.ReadCompressedInteger(data, start, out start));
                return(vt);

            case ElementType.Class:
                CLASS c = new CLASS();
                c.Type = Utilities.GetMetadataToken(CodedIndex.TypeDefOrRef,
                                                    (uint)Utilities.ReadCompressedInteger(data, start, out start));
                return(c);

            case ElementType.Ptr:
                PTR p    = new PTR();
                int buf  = start;
                int flag = Utilities.ReadCompressedInteger(data, start, out start);
                p.Void = flag == (int)ElementType.Void;
                if (p.Void)
                {
                    return(p);
                }
                start        = buf;
                p.CustomMods = this.ReadCustomMods(data, start, out start);
                p.PtrType    = this.ReadType(data, start, out start);
                return(p);

            case ElementType.FnPtr:
                FNPTR fp = new FNPTR();
                if ((data [start] & 0x5) != 0)
                {
                    MethodRefSig mr = new MethodRefSig((uint)start);
                    ReadMethodRefSig(mr, data, start, out start);
                    fp.Method = mr;
                }
                else
                {
                    MethodDefSig md = new MethodDefSig((uint)start);
                    ReadMethodDefSig(md, data, start, out start);
                    fp.Method = md;
                }
                return(fp);

            case ElementType.Array:
                ARRAY      ary   = new ARRAY();
                ArrayShape shape = new ArrayShape();
                ary.Type       = this.ReadType(data, start, out start);
                shape.Rank     = Utilities.ReadCompressedInteger(data, start, out start);
                shape.NumSizes = Utilities.ReadCompressedInteger(data, start, out start);
                shape.Sizes    = new int [shape.NumSizes];
                for (int i = 0; i < shape.NumSizes; i++)
                {
                    shape.Sizes [i] = Utilities.ReadCompressedInteger(data, start, out start);
                }
                shape.NumLoBounds = Utilities.ReadCompressedInteger(data, start, out start);
                shape.LoBounds    = new int [shape.NumLoBounds];
                for (int i = 0; i < shape.NumLoBounds; i++)
                {
                    shape.LoBounds [i] = Utilities.ReadCompressedInteger(data, start, out start);
                }
                ary.Shape = shape;
                return(ary);

            case ElementType.SzArray:
                SZARRAY sa = new SZARRAY();
                sa.Type = this.ReadType(data, start, out start);
                return(sa);

            case ElementType.Var:
                return(new VAR(Utilities.ReadCompressedInteger(data, start, out start)));

            case ElementType.MVar:
                return(new MVAR(Utilities.ReadCompressedInteger(data, start, out start)));

            case ElementType.GenericInst:
                GENERICINST ginst = new GENERICINST();

                ginst.ValueType = ((ElementType)Utilities.ReadCompressedInteger(
                                       data, start, out start)) == ElementType.ValueType;

                ginst.Type = Utilities.GetMetadataToken(CodedIndex.TypeDefOrRef,
                                                        (uint)Utilities.ReadCompressedInteger(data, start, out start));

                ginst.Signature = ReadGenericInstSignature(data, start, out start);

                return(ginst);

            default:
                return(new SigType(element));
            }
        }
        public override void VisitMethodRefSig(MethodRefSig methodRef)
        {
            int start;

            ReadMethodRefSig(methodRef, m_root.Streams.BlobHeap.Read(methodRef.BlobIndex), 0, out start);
        }
 public uint AddMethodRefSig(MethodRefSig methSig)
 {
     return(AddSignature(methSig));
 }
Esempio n. 9
0
		public override void VisitMethodRefSig (MethodRefSig methodRef)
		{
			int start;
			ReadMethodRefSig (methodRef, m_blobData, (int)methodRef.BlobIndex, out start);
		}
Esempio n. 10
0
		public override void VisitMethodRefSig (MethodRefSig methodRef)
		{
			m_sigWriter.Write (methodRef.CallingConvention);
			Write (methodRef.ParamCount);
			Write (methodRef.RetType);
			Write (methodRef.Parameters, methodRef.Sentinel);
		}
Esempio n. 11
0
        SigType ReadType(byte [] data, int pos, out int start)
        {
            start = pos;
            ElementType element = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
            switch (element) {
            case ElementType.ValueType :
                VALUETYPE vt = new VALUETYPE ();
                vt.Type = Utilities.GetMetadataToken(CodedIndex.TypeDefOrRef,
                    (uint) Utilities.ReadCompressedInteger (data, start, out start));
                return vt;
            case ElementType.Class :
                CLASS c = new CLASS ();
                c.Type = Utilities.GetMetadataToken (CodedIndex.TypeDefOrRef,
                    (uint) Utilities.ReadCompressedInteger (data, start, out start));
                return c;
            case ElementType.Ptr :
                PTR p = new PTR ();
                int buf = start;
                int flag = Utilities.ReadCompressedInteger (data, start, out start);
                p.Void = flag == (int) ElementType.Void;
                if (p.Void)
                    return p;
                start = buf;
                p.CustomMods = ReadCustomMods (data, start, out start);
                p.PtrType = ReadType (data, start, out start);
                return p;
            case ElementType.FnPtr :
                FNPTR fp = new FNPTR ();
                if ((data [start] & 0x5) != 0) {
                    MethodRefSig mr = new MethodRefSig ((uint) start);
                    ReadMethodRefSig (mr, data, start, out start);
                    fp.Method = mr;
                } else {
                    MethodDefSig md = new MethodDefSig ((uint) start);
                    ReadMethodDefSig (md, data, start, out start);
                    fp.Method = md;
                }
                return fp;
            case ElementType.Array :
                ARRAY ary = new ARRAY ();
                ary.CustomMods = ReadCustomMods (data, start, out start);
                ArrayShape shape = new ArrayShape ();
                ary.Type = ReadType (data, start, out start);
                shape.Rank = Utilities.ReadCompressedInteger (data, start, out start);
                shape.NumSizes = Utilities.ReadCompressedInteger (data, start, out start);
                shape.Sizes = new int [shape.NumSizes];
                for (int i = 0; i < shape.NumSizes; i++)
                    shape.Sizes [i] = Utilities.ReadCompressedInteger (data, start, out start);
                shape.NumLoBounds = Utilities.ReadCompressedInteger (data, start, out start);
                shape.LoBounds = new int [shape.NumLoBounds];
                for (int i = 0; i < shape.NumLoBounds; i++)
                    shape.LoBounds [i] = Utilities.ReadCompressedInteger (data, start, out start);
                ary.Shape = shape;
                return ary;
            case ElementType.SzArray :
                SZARRAY sa = new SZARRAY ();
                sa.CustomMods = ReadCustomMods (data, start, out start);
                sa.Type = ReadType (data, start, out start);
                return sa;
            case ElementType.Var:
                return new VAR (Utilities.ReadCompressedInteger (data, start, out start));
            case ElementType.MVar:
                return new MVAR (Utilities.ReadCompressedInteger (data, start, out start));
            case ElementType.GenericInst:
                GENERICINST ginst = new GENERICINST ();

                ginst.ValueType = ((ElementType) Utilities.ReadCompressedInteger (
                    data, start, out start)) == ElementType.ValueType;

                ginst.Type = Utilities.GetMetadataToken (CodedIndex.TypeDefOrRef,
                    (uint) Utilities.ReadCompressedInteger (data, start, out start));

                ginst.Signature = ReadGenericInstSignature (data, start, out start);

                return ginst;
            default :
                return new SigType (element);
            }
        }
Esempio n. 12
0
 void ReadMethodRefSig(MethodRefSig methodRef, byte [] data, int pos, out int start)
 {
     methodRef.CallingConvention = data [pos];
     start = pos + 1;
     methodRef.HasThis = (methodRef.CallingConvention & 0x20) != 0;
     methodRef.ExplicitThis = (methodRef.CallingConvention & 0x40) != 0;
     if ((methodRef.CallingConvention & 0x1) != 0)
         methodRef.MethCallConv |= MethodCallingConvention.C;
     else if ((methodRef.CallingConvention & 0x2) != 0)
         methodRef.MethCallConv |= MethodCallingConvention.StdCall;
     else if ((methodRef.CallingConvention & 0x3) != 0)
         methodRef.MethCallConv |= MethodCallingConvention.ThisCall;
     else if ((methodRef.CallingConvention & 0x4) != 0)
         methodRef.MethCallConv |= MethodCallingConvention.FastCall;
     else if ((methodRef.CallingConvention & 0x5) != 0)
         methodRef.MethCallConv |= MethodCallingConvention.VarArg;
     else
         methodRef.MethCallConv |= MethodCallingConvention.Default;
     methodRef.ParamCount = Utilities.ReadCompressedInteger (data, start, out start);
     methodRef.RetType = ReadRetType (data, start, out start);
     int sentpos;
     methodRef.Parameters = ReadParameters (methodRef.ParamCount, data, start, out start, out sentpos);
     methodRef.Sentinel = sentpos;
 }
Esempio n. 13
0
 public override void VisitMethodRefSig(MethodRefSig methodRef)
 {
     int start;
     ReadMethodRefSig (methodRef, m_root.Streams.BlobHeap.Read (methodRef.BlobIndex), 0, out start);
 }
Esempio n. 14
0
 public MethodSig GetStandAloneMethodSig(uint index)
 {
     byte [] data = m_root.Streams.BlobHeap.Read (index);
     int start;
     if ((data [0] & 0x5) > 0) {
         MethodRefSig mrs = new MethodRefSig (index);
         ReadMethodRefSig (mrs, data, 0, out start);
         return mrs;
     } else {
         MethodDefSig mds = new MethodDefSig (index);
         ReadMethodDefSig (mds, data, 0, out start);
         return mds;
     }
 }
Esempio n. 15
0
 public MethodRefSig GetMethodRefSig(uint index)
 {
     MethodRefSig m = m_signatures [index] as MethodRefSig;
     if (m == null) {
         m = new MethodRefSig (index);
         m.Accept (this);
         m_signatures [index] = m;
     }
     return m;
 }
        public override void VisitMethodRefSig(MethodRefSig methodRef)
        {
            int start;

            ReadMethodRefSig(methodRef, m_blobData, (int)methodRef.BlobIndex, out start);
        }
Esempio n. 17
0
        public MethodRefSig GetMethodRefSig(MethodReference meth)
        {
            if (meth.GenericParameters.Count > 0)
                return GetMethodDefSig (meth);

            MethodRefSig methSig = new MethodRefSig ();

            CompleteMethodSig (meth, methSig);

            if ((meth.CallingConvention & MethodCallingConvention.C) != 0)
                methSig.CallingConvention |= 0x1;
            else if ((meth.CallingConvention & MethodCallingConvention.StdCall) != 0)
                methSig.CallingConvention |= 0x2;
            else if ((meth.CallingConvention & MethodCallingConvention.ThisCall) != 0)
                methSig.CallingConvention |= 0x3;
            else if ((meth.CallingConvention & MethodCallingConvention.FastCall) != 0)
                methSig.CallingConvention |= 0x4;

            return methSig;
        }
Esempio n. 18
0
        public MethodRefSig GetMethodRefSig(IMethodSignature meth)
        {
            MethodReference methodRef = meth as MethodReference;
            if (methodRef != null && methodRef.GenericParameters.Count > 0)
                return GetMethodDefSig (meth);

            MethodRefSig methSig = new MethodRefSig ();

            CompleteMethodSig (meth, methSig);

            int sentinel = meth.GetSentinel ();
            if (sentinel >= 0)
                methSig.Sentinel = sentinel;

            if ((meth.CallingConvention & MethodCallingConvention.C) != 0)
                methSig.CallingConvention |= 0x1;
            else if ((meth.CallingConvention & MethodCallingConvention.StdCall) != 0)
                methSig.CallingConvention |= 0x2;
            else if ((meth.CallingConvention & MethodCallingConvention.ThisCall) != 0)
                methSig.CallingConvention |= 0x3;
            else if ((meth.CallingConvention & MethodCallingConvention.FastCall) != 0)
                methSig.CallingConvention |= 0x4;

            return methSig;
        }
Esempio n. 19
0
		public uint AddMethodRefSig (MethodRefSig methSig)
		{
			return AddSignature (methSig);
		}
Esempio n. 20
0
		/*

		public MarshalSig GetMarshalSig (uint index)
		{
			MarshalSig ms = m_signatures [index] as MarshalSig;
			if (ms == null) {
				byte [] data = m_root.Streams.BlobHeap.Read (index);
				ms = ReadMarshalSig (data);
				m_signatures [index] = ms;
			}
			return ms;
		}
		
		*/

		public MethodSig GetStandAloneMethodSig (uint index)
		{
			int start;
			if ((m_blobData [index] & 0x5) > 0) {
				MethodRefSig mrs = new MethodRefSig (index);
				ReadMethodRefSig (mrs, m_blobData, (int)index, out start);
				return mrs;
			} else {
				MethodDefSig mds = new MethodDefSig (index);
				ReadMethodDefSig (mds, m_blobData, (int)index, out start);
				return mds;
			}
		}