← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mono-addins/trusty-proposed

« back to all changes in this revision

Viewing changes to Mono.Addins.CecilReflector/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2011-04-25 11:11:33 UTC
  • mfrom: (4.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110425111133-t05u5p7o5fxx70fu
Tags: 0.6-2
Upload to Unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mono.Addins.CecilReflector/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs
1
 
//
2
 
// SignatureReader.cs
3
 
//
4
 
// Author:
5
 
//   Jb Evain (jbevain@gmail.com)
6
 
//
7
 
// (C) 2005 - 2007 Jb Evain
8
 
//
9
 
// Permission is hereby granted, free of charge, to any person obtaining
10
 
// a copy of this software and associated documentation files (the
11
 
// "Software"), to deal in the Software without restriction, including
12
 
// without limitation the rights to use, copy, modify, merge, publish,
13
 
// distribute, sublicense, and/or sell copies of the Software, and to
14
 
// permit persons to whom the Software is furnished to do so, subject to
15
 
// the following conditions:
16
 
//
17
 
// The above copyright notice and this permission notice shall be
18
 
// included in all copies or substantial portions of the Software.
19
 
//
20
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21
 
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22
 
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23
 
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24
 
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25
 
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26
 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27
 
//
28
 
 
29
 
namespace Mono.Cecil.Signatures {
30
 
 
31
 
        using System;
32
 
        using System.Collections;
33
 
        using System.IO;
34
 
        using System.Text;
35
 
 
36
 
        using Mono.Cecil;
37
 
        using Mono.Cecil.Metadata;
38
 
 
39
 
        internal sealed class SignatureReader : BaseSignatureVisitor {
40
 
 
41
 
                MetadataRoot m_root;
42
 
                ReflectionReader m_reflectReader;
43
 
                byte [] m_blobData;
44
 
 
45
 
                IDictionary m_signatures;
46
 
 
47
 
                IAssemblyResolver AssemblyResolver {
48
 
                        get { return m_reflectReader.Module.Assembly.Resolver; }
49
 
                }
50
 
 
51
 
                public SignatureReader (MetadataRoot root, ReflectionReader reflectReader)
52
 
                {
53
 
                        m_root = root;
54
 
                        m_reflectReader = reflectReader;
55
 
 
56
 
                        m_blobData = m_root.Streams.BlobHeap != null ? m_root.Streams.BlobHeap.Data : new byte [0];
57
 
 
58
 
                        m_signatures = new Hashtable ();
59
 
                }
60
 
 
61
 
                public FieldSig GetFieldSig (uint index)
62
 
                {
63
 
                        FieldSig f = m_signatures [index] as FieldSig;
64
 
                        if (f == null) {
65
 
                                f = new FieldSig (index);
66
 
                                f.Accept (this);
67
 
                                m_signatures [index] = f;
68
 
                        }
69
 
                        return f;
70
 
                }
71
 
 
72
 
                public PropertySig GetPropSig (uint index)
73
 
                {
74
 
                        PropertySig p = m_signatures [index] as PropertySig;
75
 
                        if (p == null) {
76
 
                                p = new PropertySig (index);
77
 
                                p.Accept (this);
78
 
                                m_signatures [index] = p;
79
 
                        }
80
 
                        return p;
81
 
                }
82
 
 
83
 
                public MethodDefSig GetMethodDefSig (uint index)
84
 
                {
85
 
                        MethodDefSig m = m_signatures [index] as MethodDefSig;
86
 
                        if (m == null) {
87
 
                                m = new MethodDefSig (index);
88
 
                                m.Accept (this);
89
 
                                m_signatures [index] = m;
90
 
                        }
91
 
                        return m;
92
 
                }
93
 
 
94
 
                public MethodRefSig GetMethodRefSig (uint index)
95
 
                {
96
 
                        MethodRefSig m = m_signatures [index] as MethodRefSig;
97
 
                        if (m == null) {
98
 
                                m = new MethodRefSig (index);
99
 
                                m.Accept (this);
100
 
                                m_signatures [index] = m;
101
 
                        }
102
 
                        return m;
103
 
                }
104
 
 
105
 
                public TypeSpec GetTypeSpec (uint index)
106
 
                {
107
 
                        TypeSpec ts = m_signatures [index] as TypeSpec;
108
 
 
109
 
                        if (ts == null) {
110
 
                                ts = ReadTypeSpec (m_blobData, (int) index);
111
 
                                m_signatures [index] = ts;
112
 
                        }
113
 
 
114
 
                        return ts;
115
 
                }
116
 
 
117
 
                public MethodSpec GetMethodSpec (uint index)
118
 
                {
119
 
                        MethodSpec ms = m_signatures [index] as MethodSpec;
120
 
 
121
 
                        if (ms == null) {
122
 
                                ms = ReadMethodSpec (m_blobData, (int) index);
123
 
                                m_signatures [index] = ms;
124
 
                        }
125
 
 
126
 
                        return ms;
127
 
                }
128
 
 
129
 
                public LocalVarSig GetLocalVarSig (uint index)
130
 
                {
131
 
                        LocalVarSig lv = m_signatures [index] as LocalVarSig;
132
 
                        if (lv == null) {
133
 
                                lv = new LocalVarSig (index);
134
 
                                lv.Accept (this);
135
 
                                m_signatures [index] = lv;
136
 
                        }
137
 
                        return lv;
138
 
                }
139
 
 
140
 
                public CustomAttrib GetCustomAttrib (uint index, MethodReference ctor)
141
 
                {
142
 
                        return GetCustomAttrib (index, ctor, false);
143
 
                }
144
 
 
145
 
                public CustomAttrib GetCustomAttrib (uint index, MethodReference ctor, bool resolve)
146
 
                {
147
 
                        return ReadCustomAttrib ((int) index, ctor, resolve);
148
 
                }
149
 
 
150
 
                public CustomAttrib GetCustomAttrib (byte [] data, MethodReference ctor)
151
 
                {
152
 
                        return GetCustomAttrib (data, ctor, false);
153
 
                }
154
 
 
155
 
                public CustomAttrib GetCustomAttrib (byte [] data, MethodReference ctor, bool resolve)
156
 
                {
157
 
                        BinaryReader br = new BinaryReader (new MemoryStream (data));
158
 
                        return ReadCustomAttrib (br, data, ctor, resolve);
159
 
                }
160
 
 
161
 
                public Signature GetMemberRefSig (TokenType tt, uint index)
162
 
                {
163
 
                        int start, callconv;
164
 
                        Utilities.ReadCompressedInteger (m_blobData, (int) index, out start);
165
 
                        callconv = m_blobData [start];
166
 
                        if ((callconv & 0x5) == 0x5 || (callconv & 0x10) == 0x10) // vararg || generic?
167
 
                                return GetMethodDefSig (index);
168
 
                        if ((callconv & 0x6) != 0) // field ?
169
 
                                return GetFieldSig (index);
170
 
 
171
 
                        switch (tt) {
172
 
                        case TokenType.TypeDef :
173
 
                        case TokenType.TypeRef :
174
 
                        case TokenType.TypeSpec :
175
 
                                return GetMethodRefSig (index);
176
 
                        case TokenType.ModuleRef :
177
 
                        case TokenType.Method :
178
 
                                return GetMethodDefSig (index);
179
 
                        }
180
 
                        return null;
181
 
                }
182
 
 
183
 
                public MarshalSig GetMarshalSig (uint index)
184
 
                {
185
 
                        MarshalSig ms = m_signatures [index] as MarshalSig;
186
 
                        if (ms == null) {
187
 
                                byte [] data = m_root.Streams.BlobHeap.Read (index);
188
 
                                ms = ReadMarshalSig (data);
189
 
                                m_signatures [index] = ms;
190
 
                        }
191
 
                        return ms;
192
 
                }
193
 
 
194
 
                public MethodSig GetStandAloneMethodSig (uint index)
195
 
                {
196
 
                        byte [] data = m_root.Streams.BlobHeap.Read (index);
197
 
                        int start;
198
 
                        if ((data [0] & 0x5) > 0) {
199
 
                                MethodRefSig mrs = new MethodRefSig (index);
200
 
                                ReadMethodRefSig (mrs, data, 0, out start);
201
 
                                return mrs;
202
 
                        } else {
203
 
                                MethodDefSig mds = new MethodDefSig (index);
204
 
                                ReadMethodDefSig (mds, data, 0, out start);
205
 
                                return mds;
206
 
                        }
207
 
                }
208
 
 
209
 
                public override void VisitMethodDefSig (MethodDefSig methodDef)
210
 
                {
211
 
                        int start;
212
 
                        ReadMethodDefSig (methodDef, m_root.Streams.BlobHeap.Read (methodDef.BlobIndex), 0, out start);
213
 
                }
214
 
 
215
 
                public override void VisitMethodRefSig (MethodRefSig methodRef)
216
 
                {
217
 
                        int start;
218
 
                        ReadMethodRefSig (methodRef, m_root.Streams.BlobHeap.Read (methodRef.BlobIndex), 0, out start);
219
 
                }
220
 
 
221
 
                public override void VisitFieldSig (FieldSig field)
222
 
                {
223
 
                        int start;
224
 
                        Utilities.ReadCompressedInteger (m_blobData, (int) field.BlobIndex, out start);
225
 
                        field.CallingConvention = m_blobData [start];
226
 
                        field.Field = (field.CallingConvention & 0x6) != 0;
227
 
                        field.CustomMods = ReadCustomMods (m_blobData, start + 1, out start);
228
 
                        field.Type = ReadType (m_blobData, start, out start);
229
 
                }
230
 
 
231
 
                public override void VisitPropertySig (PropertySig property)
232
 
                {
233
 
                        int start;
234
 
                        Utilities.ReadCompressedInteger (m_blobData, (int) property.BlobIndex, out start);
235
 
                        property.CallingConvention = m_blobData [start];
236
 
                        property.Property = (property.CallingConvention & 0x8) != 0;
237
 
                        property.ParamCount = Utilities.ReadCompressedInteger (m_blobData, start + 1, out start);
238
 
                        property.CustomMods = ReadCustomMods (m_blobData, start, out start);
239
 
                        property.Type = ReadType (m_blobData, start, out start);
240
 
                        property.Parameters = ReadParameters (property.ParamCount, m_blobData, start);
241
 
                }
242
 
 
243
 
                public override void VisitLocalVarSig (LocalVarSig localvar)
244
 
                {
245
 
                        int start;
246
 
                        Utilities.ReadCompressedInteger (m_blobData, (int) localvar.BlobIndex, out start);
247
 
                        localvar.CallingConvention = m_blobData [start];
248
 
                        localvar.Local = (localvar.CallingConvention & 0x7) != 0;
249
 
                        localvar.Count = Utilities.ReadCompressedInteger (m_blobData, start + 1, out start);
250
 
                        localvar.LocalVariables = ReadLocalVariables (localvar.Count, m_blobData, start);
251
 
                }
252
 
 
253
 
                void ReadMethodDefSig (MethodDefSig methodDef, byte [] data, int pos, out int start)
254
 
                {
255
 
                        methodDef.CallingConvention = data [pos];
256
 
                        start = pos + 1;
257
 
                        methodDef.HasThis = (methodDef.CallingConvention & 0x20) != 0;
258
 
                        methodDef.ExplicitThis = (methodDef.CallingConvention & 0x40) != 0;
259
 
                        if ((methodDef.CallingConvention & 0x5) != 0)
260
 
                                methodDef.MethCallConv |= MethodCallingConvention.VarArg;
261
 
                        else if ((methodDef.CallingConvention & 0x10) != 0) {
262
 
                                methodDef.MethCallConv |= MethodCallingConvention.Generic;
263
 
                                methodDef.GenericParameterCount = Utilities.ReadCompressedInteger (data, start, out start);
264
 
                        } else
265
 
                                methodDef.MethCallConv |= MethodCallingConvention.Default;
266
 
 
267
 
                        methodDef.ParamCount = Utilities.ReadCompressedInteger (data, start, out start);
268
 
                        methodDef.RetType = ReadRetType (data, start, out start);
269
 
                        int sentpos;
270
 
                        methodDef.Parameters = ReadParameters (methodDef.ParamCount, data, start, out sentpos);
271
 
                        methodDef.Sentinel = sentpos;
272
 
                }
273
 
 
274
 
                void ReadMethodRefSig (MethodRefSig methodRef, byte [] data, int pos, out int start)
275
 
                {
276
 
                        methodRef.CallingConvention = data [pos];
277
 
                        start = pos + 1;
278
 
                        methodRef.HasThis = (methodRef.CallingConvention & 0x20) != 0;
279
 
                        methodRef.ExplicitThis = (methodRef.CallingConvention & 0x40) != 0;
280
 
                        if ((methodRef.CallingConvention & 0x1) != 0)
281
 
                                methodRef.MethCallConv |= MethodCallingConvention.C;
282
 
                        else if ((methodRef.CallingConvention & 0x2) != 0)
283
 
                                methodRef.MethCallConv |= MethodCallingConvention.StdCall;
284
 
                        else if ((methodRef.CallingConvention & 0x3) != 0)
285
 
                                methodRef.MethCallConv |= MethodCallingConvention.ThisCall;
286
 
                        else if ((methodRef.CallingConvention & 0x4) != 0)
287
 
                                methodRef.MethCallConv |= MethodCallingConvention.FastCall;
288
 
                        else if ((methodRef.CallingConvention & 0x5) != 0)
289
 
                                methodRef.MethCallConv |= MethodCallingConvention.VarArg;
290
 
                        else
291
 
                                methodRef.MethCallConv |= MethodCallingConvention.Default;
292
 
                        methodRef.ParamCount = Utilities.ReadCompressedInteger (data, start, out start);
293
 
                        methodRef.RetType = ReadRetType (data, start, out start);
294
 
                        int sentpos;
295
 
                        methodRef.Parameters = ReadParameters (methodRef.ParamCount, data, start, out sentpos);
296
 
                        methodRef.Sentinel = sentpos;
297
 
                }
298
 
 
299
 
                LocalVarSig.LocalVariable [] ReadLocalVariables (int length, byte [] data, int pos)
300
 
                {
301
 
                        int start = pos;
302
 
                        LocalVarSig.LocalVariable [] types = new LocalVarSig.LocalVariable [length];
303
 
                        for (int i = 0; i < length; i++)
304
 
                                types [i] = ReadLocalVariable (data, start, out start);
305
 
                        return types;
306
 
                }
307
 
 
308
 
                LocalVarSig.LocalVariable ReadLocalVariable (byte [] data, int pos, out int start)
309
 
                {
310
 
                        start = pos;
311
 
                        LocalVarSig.LocalVariable lv = new LocalVarSig.LocalVariable ();
312
 
                        lv.ByRef = false;
313
 
                        int cursor;
314
 
                        while (true) {
315
 
                                lv.CustomMods = ReadCustomMods (data, start, out start);
316
 
                                cursor = start;
317
 
                                int current = Utilities.ReadCompressedInteger (data, start, out start);
318
 
                                if (current == (int) ElementType.Pinned) // the only possible constraint
319
 
                                        lv.Constraint |= Constraint.Pinned;
320
 
                                else if (current == (int) ElementType.ByRef) {
321
 
                                        lv.ByRef = true;
322
 
 
323
 
                                        if (lv.CustomMods == null || lv.CustomMods.Length == 0)
324
 
                                                lv.CustomMods = ReadCustomMods (data, start, out start);
325
 
                                } else {
326
 
                                        lv.Type = ReadType (data, cursor, out start);
327
 
                                        break;
328
 
                                }
329
 
                        }
330
 
                        return lv;
331
 
                }
332
 
 
333
 
                TypeSpec ReadTypeSpec (byte [] data, int pos)
334
 
                {
335
 
                        int start = pos;
336
 
                        Utilities.ReadCompressedInteger (data, start, out start);
337
 
                        TypeSpec ts = new TypeSpec ();
338
 
                        ts.CustomMods = ReadCustomMods (data, start, out start);
339
 
                        ts.Type = ReadType (data, start, out start);
340
 
                        return ts;
341
 
                }
342
 
 
343
 
                MethodSpec ReadMethodSpec (byte [] data, int pos)
344
 
                {
345
 
                        int start = pos;
346
 
 
347
 
                        Utilities.ReadCompressedInteger (data, start, out start);
348
 
                        if (Utilities.ReadCompressedInteger (data, start, out start) != 0x0a)
349
 
                                throw new ReflectionException ("Invalid MethodSpec signature");
350
 
 
351
 
                        return new MethodSpec (ReadGenericInstSignature (data, start, out start));
352
 
                }
353
 
 
354
 
                RetType ReadRetType (byte [] data, int pos, out int start)
355
 
                {
356
 
                        RetType rt = new RetType ();
357
 
                        start = pos;
358
 
                        rt.CustomMods = ReadCustomMods (data, start, out start);
359
 
                        int curs = start;
360
 
                        ElementType flag = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
361
 
                        switch (flag) {
362
 
                        case ElementType.Void :
363
 
                                rt.ByRef = rt.TypedByRef = false;
364
 
                                rt.Void = true;
365
 
                                break;
366
 
                        case ElementType.TypedByRef :
367
 
                                rt.ByRef = rt.Void = false;
368
 
                                rt.TypedByRef = true;
369
 
                                break;
370
 
                        case ElementType.ByRef :
371
 
                                rt.TypedByRef = rt.Void = false;
372
 
                                rt.ByRef = true;
373
 
 
374
 
                                if (rt.CustomMods == null || rt.CustomMods.Length == 0)
375
 
                                        rt.CustomMods = ReadCustomMods (data, start, out start);
376
 
 
377
 
                                rt.Type = ReadType (data, start, out start);
378
 
                                break;
379
 
                        default :
380
 
                                rt.TypedByRef = rt.Void = rt.ByRef = false;
381
 
                                rt.Type = ReadType (data, curs, out start);
382
 
                                break;
383
 
                        }
384
 
                        return rt;
385
 
                }
386
 
 
387
 
                Param [] ReadParameters (int length, byte [] data, int pos)
388
 
                {
389
 
                        Param [] ret = new Param [length];
390
 
                        int start = pos;
391
 
                        for (int i = 0; i < length; i++)
392
 
                                ret [i] = ReadParameter (data, start, out start);
393
 
                        return ret;
394
 
                }
395
 
 
396
 
                Param [] ReadParameters (int length, byte [] data, int pos, out int sentinelpos)
397
 
                {
398
 
                        Param [] ret = new Param [length];
399
 
                        int start = pos;
400
 
                        sentinelpos = -1;
401
 
 
402
 
                        for (int i = 0; i < length; i++) {
403
 
                                int curs = start;
404
 
                                int flag = Utilities.ReadCompressedInteger (data, start, out start);
405
 
 
406
 
                                if (flag == (int) ElementType.Sentinel) {
407
 
                                        sentinelpos = i;
408
 
                                        curs = start;
409
 
                                }
410
 
 
411
 
                                ret [i] = ReadParameter (data, curs, out start);
412
 
                        }
413
 
 
414
 
                        return ret;
415
 
                }
416
 
 
417
 
                Param ReadParameter (byte [] data, int pos, out int start)
418
 
                {
419
 
                        Param p = new Param ();
420
 
                        start = pos;
421
 
 
422
 
                        p.CustomMods = ReadCustomMods (data, start, out start);
423
 
                        int curs = start;
424
 
                        ElementType flag = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
425
 
                        switch (flag) {
426
 
                        case ElementType.TypedByRef :
427
 
                                p.TypedByRef = true;
428
 
                                p.ByRef = false;
429
 
                                break;
430
 
                        case ElementType.ByRef :
431
 
                                p.TypedByRef = false;
432
 
                                p.ByRef = true;
433
 
 
434
 
                                if (p.CustomMods == null || p.CustomMods.Length == 0)
435
 
                                        p.CustomMods = ReadCustomMods (data, start, out start);
436
 
 
437
 
                                p.Type = ReadType (data, start, out start);
438
 
                                break;
439
 
                        default :
440
 
                                p.TypedByRef = false;
441
 
                                p.ByRef = false;
442
 
                                p.Type = ReadType (data, curs, out start);
443
 
                                break;
444
 
                        }
445
 
                        return p;
446
 
                }
447
 
 
448
 
                SigType ReadType (byte [] data, int pos, out int start)
449
 
                {
450
 
                        start = pos;
451
 
                        ElementType element = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
452
 
                        switch (element) {
453
 
                        case ElementType.ValueType :
454
 
                                VALUETYPE vt = new VALUETYPE ();
455
 
                                vt.Type = Utilities.GetMetadataToken(CodedIndex.TypeDefOrRef,
456
 
                                        (uint) Utilities.ReadCompressedInteger (data, start, out start));
457
 
                                return vt;
458
 
                        case ElementType.Class :
459
 
                                CLASS c = new CLASS ();
460
 
                                c.Type = Utilities.GetMetadataToken (CodedIndex.TypeDefOrRef,
461
 
                                        (uint) Utilities.ReadCompressedInteger (data, start, out start));
462
 
                                return c;
463
 
                        case ElementType.Ptr :
464
 
                                PTR p = new PTR ();
465
 
                                int buf = start;
466
 
                                int flag = Utilities.ReadCompressedInteger (data, start, out start);
467
 
                                p.Void = flag == (int) ElementType.Void;
468
 
                                if (p.Void)
469
 
                                        return p;
470
 
                                start = buf;
471
 
                                p.CustomMods = ReadCustomMods (data, start, out start);
472
 
                                p.PtrType = ReadType (data, start, out start);
473
 
                                return p;
474
 
                        case ElementType.FnPtr :
475
 
                                FNPTR fp = new FNPTR ();
476
 
                                if ((data [start] & 0x5) != 0) {
477
 
                                        MethodRefSig mr = new MethodRefSig ((uint) start);
478
 
                                        ReadMethodRefSig (mr, data, start, out start);
479
 
                                        fp.Method = mr;
480
 
                                } else {
481
 
                                        MethodDefSig md = new MethodDefSig ((uint) start);
482
 
                                        ReadMethodDefSig (md, data, start, out start);
483
 
                                        fp.Method = md;
484
 
                                }
485
 
                                return fp;
486
 
                        case ElementType.Array :
487
 
                                ARRAY ary = new ARRAY ();
488
 
                                ary.CustomMods = ReadCustomMods (data, start, out start);
489
 
                                ArrayShape shape = new ArrayShape ();
490
 
                                ary.Type = ReadType (data, start, out start);
491
 
                                shape.Rank = Utilities.ReadCompressedInteger (data, start, out start);
492
 
                                shape.NumSizes = Utilities.ReadCompressedInteger (data, start, out start);
493
 
                                shape.Sizes = new int [shape.NumSizes];
494
 
                                for (int i = 0; i < shape.NumSizes; i++)
495
 
                                        shape.Sizes [i] = Utilities.ReadCompressedInteger (data, start, out start);
496
 
                                shape.NumLoBounds = Utilities.ReadCompressedInteger (data, start, out start);
497
 
                                shape.LoBounds = new int [shape.NumLoBounds];
498
 
                                for (int i = 0; i < shape.NumLoBounds; i++)
499
 
                                        shape.LoBounds [i] = Utilities.ReadCompressedInteger (data, start, out start);
500
 
                                ary.Shape = shape;
501
 
                                return ary;
502
 
                        case ElementType.SzArray :
503
 
                                SZARRAY sa = new SZARRAY ();
504
 
                                sa.CustomMods = ReadCustomMods (data, start, out start);
505
 
                                sa.Type = ReadType (data, start, out start);
506
 
                                return sa;
507
 
                        case ElementType.Var:
508
 
                                return new VAR (Utilities.ReadCompressedInteger (data, start, out start));
509
 
                        case ElementType.MVar:
510
 
                                return new MVAR (Utilities.ReadCompressedInteger (data, start, out start));
511
 
                        case ElementType.GenericInst:
512
 
                                GENERICINST ginst = new GENERICINST ();
513
 
 
514
 
                                ginst.ValueType = ((ElementType) Utilities.ReadCompressedInteger (
515
 
                                        data, start, out start)) == ElementType.ValueType;
516
 
 
517
 
                                ginst.Type = Utilities.GetMetadataToken (CodedIndex.TypeDefOrRef,
518
 
                                        (uint) Utilities.ReadCompressedInteger (data, start, out start));
519
 
 
520
 
                                ginst.Signature = ReadGenericInstSignature (data, start, out start);
521
 
 
522
 
                                return ginst;
523
 
                        default :
524
 
                                return new SigType (element);
525
 
                        }
526
 
                }
527
 
 
528
 
                GenericInstSignature ReadGenericInstSignature (byte [] data, int pos, out int start)
529
 
                {
530
 
                        start = pos;
531
 
                        GenericInstSignature gis = new GenericInstSignature ();
532
 
                        gis.Arity = Utilities.ReadCompressedInteger (data, start, out start);
533
 
                        gis.Types = new GenericArg [gis.Arity];
534
 
                        for (int i = 0; i < gis.Arity; i++)
535
 
                                gis.Types [i] = ReadGenericArg (data, start, out start);
536
 
 
537
 
                        return gis;
538
 
                }
539
 
 
540
 
                GenericArg ReadGenericArg (byte[] data, int pos, out int start)
541
 
                {
542
 
                        start = pos;
543
 
                        CustomMod [] mods = ReadCustomMods (data, start, out start);
544
 
                        GenericArg arg = new GenericArg (ReadType (data, start, out start));
545
 
                        arg.CustomMods = mods;
546
 
                        return arg;
547
 
                }
548
 
 
549
 
                CustomMod [] ReadCustomMods (byte [] data, int pos, out int start)
550
 
                {
551
 
                        ArrayList cmods = new ArrayList ();
552
 
                        start = pos;
553
 
                        while (true) {
554
 
                                int buf = start;
555
 
                                ElementType flag = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
556
 
                                start = buf;
557
 
                                if (!((flag == ElementType.CModOpt) || (flag == ElementType.CModReqD)))
558
 
                                        break;
559
 
                                cmods.Add (ReadCustomMod (data, start, out start));
560
 
                        }
561
 
                        return cmods.ToArray (typeof (CustomMod)) as CustomMod [];
562
 
                }
563
 
 
564
 
                CustomMod ReadCustomMod (byte [] data, int pos, out int start)
565
 
                {
566
 
                        CustomMod cm = new CustomMod ();
567
 
                        start = pos;
568
 
                        ElementType cmod = (ElementType) Utilities.ReadCompressedInteger (data, start, out start);
569
 
                        if (cmod == ElementType.CModOpt)
570
 
                                cm.CMOD = CustomMod.CMODType.OPT;
571
 
                        else if (cmod == ElementType.CModReqD)
572
 
                                cm.CMOD = CustomMod.CMODType.REQD;
573
 
                        else
574
 
                                cm.CMOD = CustomMod.CMODType.None;
575
 
                        cm.TypeDefOrRef = Utilities.GetMetadataToken (CodedIndex.TypeDefOrRef,
576
 
                                (uint) Utilities.ReadCompressedInteger (data, start, out start));
577
 
                        return cm;
578
 
                }
579
 
 
580
 
                CustomAttrib ReadCustomAttrib (int pos, MethodReference ctor, bool resolve)
581
 
                {
582
 
                        int start, length = Utilities.ReadCompressedInteger (m_blobData, pos, out start);
583
 
                        byte [] data = new byte [length];
584
 
                        Buffer.BlockCopy (m_blobData, start, data, 0, length);
585
 
                        try {
586
 
                                return ReadCustomAttrib (new BinaryReader (
587
 
                                        new MemoryStream (data)), data, ctor, resolve);
588
 
                        } catch {
589
 
                                CustomAttrib ca = new CustomAttrib (ctor);
590
 
                                ca.Read = false;
591
 
                                return ca;
592
 
                        }
593
 
                }
594
 
 
595
 
                CustomAttrib ReadCustomAttrib (BinaryReader br, byte [] data, MethodReference ctor, bool resolve)
596
 
                {
597
 
                        CustomAttrib ca = new CustomAttrib (ctor);
598
 
                        if (data.Length == 0) {
599
 
                                ca.FixedArgs = new CustomAttrib.FixedArg [0];
600
 
                                ca.NamedArgs = new CustomAttrib.NamedArg [0];
601
 
                                return ca;
602
 
                        }
603
 
 
604
 
                        bool read = true;
605
 
 
606
 
                        ca.Prolog = br.ReadUInt16 ();
607
 
                        if (ca.Prolog != CustomAttrib.StdProlog)
608
 
                                throw new MetadataFormatException ("Non standard prolog for custom attribute");
609
 
 
610
 
                        ca.FixedArgs = new CustomAttrib.FixedArg [ctor.Parameters.Count];
611
 
                        for (int i = 0; i < ca.FixedArgs.Length && read; i++)
612
 
                                ca.FixedArgs [i] = ReadFixedArg (data, br,
613
 
                                        ctor.Parameters [i].ParameterType, ref read, resolve);
614
 
 
615
 
                        if (br.BaseStream.Position == br.BaseStream.Length)
616
 
                                read = false;
617
 
 
618
 
                        if (!read) {
619
 
                                ca.Read = read;
620
 
                                return ca;
621
 
                        }
622
 
 
623
 
                        ca.NumNamed = br.ReadUInt16 ();
624
 
                        ca.NamedArgs = new CustomAttrib.NamedArg [ca.NumNamed];
625
 
                        for (int i = 0; i < ca.NumNamed && read; i++)
626
 
                                ca.NamedArgs [i] = ReadNamedArg (data, br, ref read, resolve);
627
 
 
628
 
                        ca.Read = read;
629
 
                        return ca;
630
 
                }
631
 
 
632
 
                CustomAttrib.FixedArg ReadFixedArg (byte [] data, BinaryReader br,
633
 
                        TypeReference param, ref bool read, bool resolve)
634
 
                {
635
 
                        CustomAttrib.FixedArg fa = new CustomAttrib.FixedArg ();
636
 
                        if (param is ArrayType) {
637
 
                                param = ((ArrayType) param).ElementType;
638
 
                                fa.SzArray = true;
639
 
                                fa.NumElem = br.ReadUInt32 ();
640
 
 
641
 
                                if (fa.NumElem == 0 || fa.NumElem == 0xffffffff) {
642
 
                                        fa.Elems = new CustomAttrib.Elem [0];
643
 
                                        fa.NumElem = 0;
644
 
                                        return fa;
645
 
                                }
646
 
 
647
 
                                fa.Elems = new CustomAttrib.Elem [fa.NumElem];
648
 
                                for (int i = 0; i < fa.NumElem; i++)
649
 
                                        fa.Elems [i] = ReadElem (data, br, param, ref read, resolve);
650
 
                        } else
651
 
                                fa.Elems = new CustomAttrib.Elem [] { ReadElem (data, br, param, ref read, resolve) };
652
 
 
653
 
                        return fa;
654
 
                }
655
 
 
656
 
                TypeReference CreateEnumTypeReference (string enumName)
657
 
                {
658
 
                        string asmName = null;
659
 
                        int asmStart = enumName.IndexOf (',');
660
 
                        if (asmStart != -1) {
661
 
                                asmName = enumName.Substring (asmStart + 1);
662
 
                                enumName = enumName.Substring (0, asmStart);
663
 
                        }
664
 
                        // Inner class style is reflection style.
665
 
                        enumName = enumName.Replace ('+', '/');
666
 
                        AssemblyNameReference asm;
667
 
                        if (asmName == null) {
668
 
                                // If no assembly is given then the ECMA standard says the
669
 
                                // assembly is either the current one or mscorlib.
670
 
                                if (m_reflectReader.Module.Types.Contains (enumName))
671
 
                                        return m_reflectReader.Module.Types [enumName];
672
 
 
673
 
                                asm = m_reflectReader.Corlib;
674
 
                        } else
675
 
                                asm = AssemblyNameReference.Parse (asmName);
676
 
 
677
 
                        string [] outers = enumName.Split ('/');
678
 
                        string outerfullname = outers [0];
679
 
                        string ns = null;
680
 
                        int nsIndex = outerfullname.LastIndexOf ('.');
681
 
                        if (nsIndex != -1)
682
 
                                ns = outerfullname.Substring (0, nsIndex);
683
 
                        string name = outerfullname.Substring (nsIndex + 1);
684
 
                        TypeReference decType = new TypeReference (name, ns, asm);
685
 
                        for (int i = 1; i < outers.Length; i++) {
686
 
                                TypeReference t = new TypeReference (outers [i], null, asm);
687
 
                                t.DeclaringType = decType;
688
 
                                decType = t;
689
 
                        }
690
 
                        decType.IsValueType = true;
691
 
 
692
 
                        return decType;
693
 
                }
694
 
 
695
 
                TypeReference ReadTypeReference (byte [] data, BinaryReader br, out ElementType elemType)
696
 
                {
697
 
                        bool array = false;
698
 
                        elemType = (ElementType) br.ReadByte ();
699
 
                        if (elemType == ElementType.SzArray) {
700
 
                                elemType = (ElementType) br.ReadByte ();
701
 
                                array = true;
702
 
                        }
703
 
 
704
 
                        TypeReference res;
705
 
                        if (elemType == ElementType.Enum)
706
 
                                res = CreateEnumTypeReference (ReadUTF8String (data, br));
707
 
                        else
708
 
                                res = TypeReferenceFromElemType (elemType);
709
 
 
710
 
                        if (array)
711
 
                                res = new ArrayType (res);
712
 
 
713
 
                        return res;
714
 
                }
715
 
 
716
 
                TypeReference TypeReferenceFromElemType (ElementType elemType)
717
 
                {
718
 
                        switch (elemType) {
719
 
                        case ElementType.Boxed :
720
 
                                return m_reflectReader.SearchCoreType (Constants.Object);
721
 
                        case ElementType.String :
722
 
                                return m_reflectReader.SearchCoreType (Constants.String);
723
 
                        case ElementType.Type :
724
 
                                return m_reflectReader.SearchCoreType (Constants.Type);
725
 
                        case ElementType.Boolean :
726
 
                                return m_reflectReader.SearchCoreType (Constants.Boolean);
727
 
                        case ElementType.Char :
728
 
                                return m_reflectReader.SearchCoreType (Constants.Char);
729
 
                        case ElementType.R4 :
730
 
                                return m_reflectReader.SearchCoreType (Constants.Single);
731
 
                        case ElementType.R8 :
732
 
                                return m_reflectReader.SearchCoreType (Constants.Double);
733
 
                        case ElementType.I1 :
734
 
                                return m_reflectReader.SearchCoreType (Constants.SByte);
735
 
                        case ElementType.I2 :
736
 
                                return m_reflectReader.SearchCoreType (Constants.Int16);
737
 
                        case ElementType.I4 :
738
 
                                return m_reflectReader.SearchCoreType (Constants.Int32);
739
 
                        case ElementType.I8 :
740
 
                                return m_reflectReader.SearchCoreType (Constants.Int64);
741
 
                        case ElementType.U1 :
742
 
                                return m_reflectReader.SearchCoreType (Constants.Byte);
743
 
                        case ElementType.U2 :
744
 
                                return m_reflectReader.SearchCoreType (Constants.UInt16);
745
 
                        case ElementType.U4 :
746
 
                                return m_reflectReader.SearchCoreType (Constants.UInt32);
747
 
                        case ElementType.U8 :
748
 
                                return m_reflectReader.SearchCoreType (Constants.UInt64);
749
 
                        default :
750
 
                                throw new MetadataFormatException ("Non valid type in CustomAttrib.Elem: 0x{0}",
751
 
                                        ((byte) elemType).ToString("x2"));
752
 
                        }
753
 
                }
754
 
 
755
 
                internal CustomAttrib.NamedArg ReadNamedArg (byte [] data, BinaryReader br, ref bool read, bool resolve)
756
 
                {
757
 
                        CustomAttrib.NamedArg na = new CustomAttrib.NamedArg ();
758
 
                        byte kind = br.ReadByte ();
759
 
                        if (kind == 0x53) { // field
760
 
                                na.Field = true;
761
 
                                na.Property = false;
762
 
                        } else if (kind == 0x54) { // property
763
 
                                na.Field = false;
764
 
                                na.Property = true;
765
 
                        } else
766
 
                                throw new MetadataFormatException ("Wrong kind of namedarg found: 0x" + kind.ToString("x2"));
767
 
 
768
 
                        TypeReference elemType = ReadTypeReference (data, br, out na.FieldOrPropType);
769
 
                        na.FieldOrPropName = ReadUTF8String (data, br);
770
 
                        na.FixedArg = ReadFixedArg (data, br, elemType, ref read, resolve);
771
 
 
772
 
                        return na;
773
 
                }
774
 
 
775
 
                CustomAttrib.Elem ReadElem (byte [] data, BinaryReader br, TypeReference elemType, ref bool read, bool resolve)
776
 
                {
777
 
                        CustomAttrib.Elem elem = new CustomAttrib.Elem ();
778
 
 
779
 
                        string elemName = elemType.FullName;
780
 
 
781
 
                        if (elemName == Constants.Object) {
782
 
                                elemType = ReadTypeReference (data, br, out elem.FieldOrPropType);
783
 
                                if (elemType is ArrayType) {
784
 
                                        read = false; // Don't know how to represent arrays as an object value.
785
 
                                        return elem;
786
 
                                } else if (elemType.FullName == Constants.Object)
787
 
                                        throw new MetadataFormatException ("Non valid type in CustomAttrib.Elem after boxed prefix: 0x{0}",
788
 
                                                ((byte) elem.FieldOrPropType).ToString("x2"));
789
 
 
790
 
                                elem = ReadElem (data, br, elemType, ref read, resolve);
791
 
                                elem.String = elem.Simple = elem.Type = false;
792
 
                                elem.BoxedValueType = true;
793
 
                                return elem;
794
 
                        }
795
 
 
796
 
                        elem.ElemType = elemType;
797
 
 
798
 
                        if (elemName == Constants.Type || elemName == Constants.String) {
799
 
                                switch (elemType.FullName) {
800
 
                                case Constants.String:
801
 
                                        elem.String = true;
802
 
                                        elem.BoxedValueType = elem.Simple = elem.Type = false;
803
 
                                        break;
804
 
                                case Constants.Type:
805
 
                                        elem.Type = true;
806
 
                                        elem.BoxedValueType = elem.Simple = elem.String = false;
807
 
                                        break;
808
 
                                }
809
 
 
810
 
                                if (data [br.BaseStream.Position] == 0xff) { // null
811
 
                                        elem.Value = null;
812
 
                                        br.BaseStream.Position++;
813
 
                                } else {
814
 
                                        elem.Value = ReadUTF8String (data, br);
815
 
                                }
816
 
                                return elem;
817
 
                        }
818
 
 
819
 
                        elem.String = elem.Type = elem.BoxedValueType = false;
820
 
                        if (!ReadSimpleValue (br, ref elem, elem.ElemType)) {
821
 
                                if (!resolve) { // until enums writing is implemented
822
 
                                        read = false;
823
 
                                        return elem;
824
 
                                }
825
 
                                TypeReference typeRef = GetEnumUnderlyingType (elem.ElemType, resolve);
826
 
                                if (typeRef == null || !ReadSimpleValue (br, ref elem, typeRef))
827
 
                                        read = false;
828
 
                        }
829
 
 
830
 
                        return elem;
831
 
                }
832
 
 
833
 
                TypeReference GetEnumUnderlyingType (TypeReference enumType, bool resolve)
834
 
                {
835
 
                        TypeDefinition type = enumType as TypeDefinition;
836
 
                        if (type == null && resolve && AssemblyResolver != null) {
837
 
                                if (enumType.Scope is ModuleDefinition)
838
 
                                        throw new NotSupportedException ();
839
 
 
840
 
                                AssemblyDefinition asm = AssemblyResolver.Resolve (
841
 
                                        ((AssemblyNameReference) enumType.Scope).FullName);
842
 
                                type = asm.MainModule.Types [enumType.FullName];
843
 
                        }
844
 
 
845
 
                        if (type != null && type.IsEnum)
846
 
                                return type.Fields.GetField ("value__").FieldType;
847
 
 
848
 
                        return null;
849
 
                }
850
 
 
851
 
                bool ReadSimpleValue (BinaryReader br, ref CustomAttrib.Elem elem, TypeReference type)
852
 
                {
853
 
                        switch (type.FullName) {
854
 
                        case Constants.Boolean :
855
 
                                elem.Value = br.ReadByte () == 1;
856
 
                                break;
857
 
                        case Constants.Char :
858
 
                                elem.Value = (char) br.ReadUInt16 ();
859
 
                                break;
860
 
                        case Constants.Single :
861
 
                                elem.Value = br.ReadSingle ();
862
 
                                break;
863
 
                        case Constants.Double :
864
 
                                elem.Value = br.ReadDouble ();
865
 
                                break;
866
 
                        case Constants.Byte :
867
 
                                elem.Value = br.ReadByte ();
868
 
                                break;
869
 
                        case Constants.Int16 :
870
 
                                elem.Value = br.ReadInt16 ();
871
 
                                break;
872
 
                        case Constants.Int32 :
873
 
                                elem.Value = br.ReadInt32 ();
874
 
                                break;
875
 
                        case Constants.Int64 :
876
 
                                elem.Value = br.ReadInt64 ();
877
 
                                break;
878
 
                        case Constants.SByte :
879
 
                                elem.Value = br.ReadSByte ();
880
 
                                break;
881
 
                        case Constants.UInt16 :
882
 
                                elem.Value = br.ReadUInt16 ();
883
 
                                break;
884
 
                        case Constants.UInt32 :
885
 
                                elem.Value = br.ReadUInt32 ();
886
 
                                break;
887
 
                        case Constants.UInt64 :
888
 
                                elem.Value = br.ReadUInt64 ();
889
 
                                break;
890
 
                        default : // enum
891
 
                                return false;
892
 
                        }
893
 
                        elem.Simple = true;
894
 
                        return true;
895
 
                }
896
 
 
897
 
                MarshalSig ReadMarshalSig (byte [] data)
898
 
                {
899
 
                        int start;
900
 
                        MarshalSig ms = new MarshalSig ((NativeType) Utilities.ReadCompressedInteger (data, 0, out start));
901
 
                        switch (ms.NativeInstrinsic) {
902
 
                        case NativeType.ARRAY:
903
 
                                MarshalSig.Array ar = new MarshalSig.Array ();
904
 
                                ar.ArrayElemType = (NativeType) Utilities.ReadCompressedInteger (data, start, out start);
905
 
                                if (start < data.Length)
906
 
                                        ar.ParamNum = Utilities.ReadCompressedInteger (data, start, out start);
907
 
                                if (start < data.Length)
908
 
                                        ar.NumElem = Utilities.ReadCompressedInteger (data, start, out start);
909
 
                                if (start < data.Length)
910
 
                                        ar.ElemMult = Utilities.ReadCompressedInteger (data, start, out start);
911
 
                                ms.Spec = ar;
912
 
                                break;
913
 
                        case NativeType.CUSTOMMARSHALER:
914
 
                                MarshalSig.CustomMarshaler cm = new MarshalSig.CustomMarshaler ();
915
 
                                cm.Guid = ReadUTF8String (data, start, out start);
916
 
                                cm.UnmanagedType = ReadUTF8String (data, start, out start);
917
 
                                cm.ManagedType = ReadUTF8String (data, start, out start);
918
 
                                cm.Cookie = ReadUTF8String (data, start, out start);
919
 
                                ms.Spec = cm;
920
 
                                break;
921
 
                        case NativeType.FIXEDARRAY:
922
 
                                MarshalSig.FixedArray fa = new MarshalSig.FixedArray ();
923
 
                                fa.NumElem = Utilities.ReadCompressedInteger (data, start, out start);
924
 
                                if (start < data.Length)
925
 
                                        fa.ArrayElemType = (NativeType) Utilities.ReadCompressedInteger (data, start, out start);
926
 
                                ms.Spec = fa;
927
 
                                break;
928
 
                        case NativeType.SAFEARRAY:
929
 
                                MarshalSig.SafeArray sa = new MarshalSig.SafeArray ();
930
 
                                if (start < data.Length)
931
 
                                        sa.ArrayElemType = (VariantType) Utilities.ReadCompressedInteger (data, start, out start);
932
 
                                ms.Spec = sa;
933
 
                                break;
934
 
                        case NativeType.FIXEDSYSSTRING:
935
 
                                MarshalSig.FixedSysString fss = new MarshalSig.FixedSysString ();
936
 
                                if (start < data.Length)
937
 
                                        fss.Size = Utilities.ReadCompressedInteger (data, start, out start);
938
 
                                ms.Spec = fss;
939
 
                                break;
940
 
                        }
941
 
                        return ms;
942
 
                }
943
 
 
944
 
                static internal string ReadUTF8String (byte [] data, BinaryReader br)
945
 
                {
946
 
                        int start = (int)br.BaseStream.Position;
947
 
                        string val = ReadUTF8String (data, start, out start);
948
 
                        br.BaseStream.Position = start;
949
 
                        return val;
950
 
                }
951
 
 
952
 
                static internal string ReadUTF8String (byte [] data, int pos, out int start)
953
 
                {
954
 
                        int length = Utilities.ReadCompressedInteger (data, pos, out start);
955
 
                        pos = start;
956
 
                        start += length;
957
 
                        // COMPACT FRAMEWORK NOTE: Encoding.GetString (byte[]) is not supported.
958
 
                        return Encoding.UTF8.GetString (data, pos, length);
959
 
                }
960
 
        }
961
 
}