Ejemplo n.º 1
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));
            }
        }
Ejemplo n.º 2
0
        void Write(SigType t)
        {
            Write((int)t.ElementType);

            switch (t.ElementType)
            {
            case ElementType.ValueType:
                Write((int)Utilities.CompressMetadataToken(
                          CodedIndex.TypeDefOrRef, ((VALUETYPE)t).Type));
                break;

            case ElementType.Class:
                Write((int)Utilities.CompressMetadataToken(
                          CodedIndex.TypeDefOrRef, ((CLASS)t).Type));
                break;

            case ElementType.Ptr:
                PTR p = (PTR)t;
                if (p.Void)
                {
                    Write(ElementType.Void);
                }
                else
                {
                    Write(p.CustomMods);
                    Write(p.PtrType);
                }
                break;

            case ElementType.FnPtr:
                FNPTR fp = (FNPTR)t;
                if (fp.Method is MethodRefSig)
                {
                    (fp.Method as MethodRefSig).Accept(this);
                }
                else
                {
                    (fp.Method as MethodDefSig).Accept(this);
                }
                break;

            case ElementType.Array:
                ARRAY ary = (ARRAY)t;
                Write(ary.CustomMods);
                ArrayShape shape = ary.Shape;
                Write(ary.Type);
                Write(shape.Rank);
                Write(shape.NumSizes);
                foreach (int size in shape.Sizes)
                {
                    Write(size);
                }
                Write(shape.NumLoBounds);
                foreach (int loBound in shape.LoBounds)
                {
                    Write(loBound);
                }
                break;

            case ElementType.SzArray:
                SZARRAY sa = (SZARRAY)t;
                Write(sa.CustomMods);
                Write(sa.Type);
                break;

            case ElementType.Var:
                Write(((VAR)t).Index);
                break;

            case ElementType.MVar:
                Write(((MVAR)t).Index);
                break;

            case ElementType.GenericInst:
                GENERICINST gi = t as GENERICINST;
                Write(gi.ValueType ? ElementType.ValueType : ElementType.Class);
                Write((int)Utilities.CompressMetadataToken(
                          CodedIndex.TypeDefOrRef, gi.Type));
                Write(gi.Signature);
                break;
            }
        }