?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / class / Mono.PEToolkit / metadata / Rows.cs
blob7853f118f7c138e8c8d7ca469ef4d7e5bd75483b
1 // Auto-generated file - DO NOT EDIT!
2 // Please edit md-schema.xml or rows.xsl if you want to make changes.
3
4 using System;
5 using System.IO;
6
7 namespace Mono.PEToolkit.Metadata {
8
9
10
11 /// <summary>
12 /// Represents row in Module table.
13 /// </summary>
14 /// <remarks>
15 /// See Partition II, Metadata; section 21.27
16 /// </remarks>
17 public class ModuleRow : Row {
18
19 private MDTable table;
20
21
22 public ushort Generation;
23 public int Name;
24 public int Mvid;
25 public int EncId;
26 public int EncBaseId;
27
28 public ModuleRow()
29 {
30 }
31
32 public ModuleRow(MDTable parent)
33 {
34 table = parent;
35 }
36
37
38 /// <summary>
39 /// Row in Module table has 5 columns.
40 /// </summary>
41 public virtual int NumberOfColumns {
42 get {
43 return 5;
44 }
45 }
46
47
48 /// <summary>
49 /// Logical size of this instance in bytes.
50 /// </summary>
51 public virtual int Size {
52 get {
53 return LogicalSize;
54 }
55 }
56
57
58 /// <summary>
59 /// </summary>
60 public virtual MDTable Table {
61 get {
62 return table;
63 }
64 }
65
66
67 /// <summary>
68 /// Logical size of this type of row in bytes.
69 /// </summary>
70 unsafe public static int LogicalSize {
71 get {
72 return sizeof (ushort) + 4 + 4 + 4 + 4;
73 }
74 }
75
76
77 /// <summary>
78 /// Fills the row from the array of bytes.
79 /// </summary>
80 unsafe public void FromRawData(byte [] buff, int offs)
81 {
82 if (buff == null) throw new Exception("buff == null");
83 if (offs + Size > buff.Length) throw new Exception("bounds");
84
85
86 this.Generation = LEBitConverter.ToUInt16(buff, offs);
87 offs += sizeof (ushort);
88 this.Name = LEBitConverter.ToInt32(buff, offs);
89 offs += 4;
90 this.Mvid = LEBitConverter.ToInt32(buff, offs);
91 offs += 4;
92 this.EncId = LEBitConverter.ToInt32(buff, offs);
93 offs += 4;
94 this.EncBaseId = LEBitConverter.ToInt32(buff, offs);
95
96 }
97
98
99
100 /// <summary>
101 /// </summary>
102 public void Dump(TextWriter writer) {
103 string dump = String.Format(
104 "Generation : {0}" + Environment.NewLine +
105 "Name : {1}" + Environment.NewLine +
106 "Mvid : {2}" + Environment.NewLine +
107 "EncId : {3}" + Environment.NewLine +
108 "EncBaseId : {4}" + Environment.NewLine,
109 this.Generation,
110 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
111 "#GUID[" + Mvid.ToString() + "]",
112 "#GUID[" + EncId.ToString() + "]",
113 "#GUID[" + EncBaseId.ToString() + "]"
114 );
115 writer.WriteLine(dump);
116 }
117
118
119 /// <summary>
120 /// </summary>
121 public override string ToString()
122 {
123 StringWriter sw = new StringWriter();
124 Dump(sw);
125 return sw.ToString();
126 }
127
128 }
129
130
131
132 /// <summary>
133 /// Represents row in TypeRef table.
134 /// </summary>
135 /// <remarks>
136 /// See Partition II, Metadata; section 21.35
137 /// </remarks>
138 public class TypeRefRow : Row {
139
140 private MDTable table;
141
142
143 public MDToken ResolutionScope;
144 public int Name;
145 public int Namespace;
146
147 public TypeRefRow()
148 {
149 }
150
151 public TypeRefRow(MDTable parent)
152 {
153 table = parent;
154 }
155
156
157 /// <summary>
158 /// Row in TypeRef table has 3 columns.
159 /// </summary>
160 public virtual int NumberOfColumns {
161 get {
162 return 3;
163 }
164 }
165
166
167 /// <summary>
168 /// Logical size of this instance in bytes.
169 /// </summary>
170 public virtual int Size {
171 get {
172 return LogicalSize;
173 }
174 }
175
176
177 /// <summary>
178 /// </summary>
179 public virtual MDTable Table {
180 get {
181 return table;
182 }
183 }
184
185
186 /// <summary>
187 /// Logical size of this type of row in bytes.
188 /// </summary>
189 unsafe public static int LogicalSize {
190 get {
191 return 4 + 4 + 4;
192 }
193 }
194
195
196 /// <summary>
197 /// Fills the row from the array of bytes.
198 /// </summary>
199 unsafe public void FromRawData(byte [] buff, int offs)
200 {
201 if (buff == null) throw new Exception("buff == null");
202 if (offs + Size > buff.Length) throw new Exception("bounds");
203
204
205 this.ResolutionScope = TabsDecoder.DecodeToken(CodedTokenId.ResolutionScope, LEBitConverter.ToInt32(buff, offs));
206 offs += 4;
207 this.Name = LEBitConverter.ToInt32(buff, offs);
208 offs += 4;
209 this.Namespace = LEBitConverter.ToInt32(buff, offs);
210
211 }
212
213
214
215 /// <summary>
216 /// </summary>
217 public void Dump(TextWriter writer) {
218 string dump = String.Format(
219 "ResolutionScope : {0}" + Environment.NewLine +
220 "Name : {1}" + Environment.NewLine +
221 "Namespace : {2}" + Environment.NewLine,
222 this.ResolutionScope,
223 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
224 (Table == null) ? Namespace.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Namespace] + "\" (#Strings[0x" + Namespace.ToString("X") + "])"
225 );
226 writer.WriteLine(dump);
227 }
228
229
230 /// <summary>
231 /// </summary>
232 public override string ToString()
233 {
234 StringWriter sw = new StringWriter();
235 Dump(sw);
236 return sw.ToString();
237 }
238
239 }
240
241
242
243 /// <summary>
244 /// Represents row in TypeDef table.
245 /// </summary>
246 /// <remarks>
247 /// See Partition II, Metadata; section 21.34
248 /// </remarks>
249 public class TypeDefRow : Row {
250
251 private MDTable table;
252
253
254 public System.Reflection.TypeAttributes Flags;
255 public int Name;
256 public int Namespace;
257 public MDToken Extends;
258 public int FieldList;
259 public int MethodList;
260
261 public TypeDefRow()
262 {
263 }
264
265 public TypeDefRow(MDTable parent)
266 {
267 table = parent;
268 }
269
270
271 /// <summary>
272 /// Row in TypeDef table has 6 columns.
273 /// </summary>
274 public virtual int NumberOfColumns {
275 get {
276 return 6;
277 }
278 }
279
280
281 /// <summary>
282 /// Logical size of this instance in bytes.
283 /// </summary>
284 public virtual int Size {
285 get {
286 return LogicalSize;
287 }
288 }
289
290
291 /// <summary>
292 /// </summary>
293 public virtual MDTable Table {
294 get {
295 return table;
296 }
297 }
298
299
300 /// <summary>
301 /// Logical size of this type of row in bytes.
302 /// </summary>
303 unsafe public static int LogicalSize {
304 get {
305 return sizeof (uint) + 4 + 4 + 4 + 4 + 4;
306 }
307 }
308
309
310 /// <summary>
311 /// Fills the row from the array of bytes.
312 /// </summary>
313 unsafe public void FromRawData(byte [] buff, int offs)
314 {
315 if (buff == null) throw new Exception("buff == null");
316 if (offs + Size > buff.Length) throw new Exception("bounds");
317
318
319 this.Flags = (System.Reflection.TypeAttributes) LEBitConverter.ToUInt32(buff, offs);
320 offs += sizeof (uint);
321 this.Name = LEBitConverter.ToInt32(buff, offs);
322 offs += 4;
323 this.Namespace = LEBitConverter.ToInt32(buff, offs);
324 offs += 4;
325 this.Extends = TabsDecoder.DecodeToken(CodedTokenId.TypeDefOrRef, LEBitConverter.ToInt32(buff, offs));
326 offs += 4;
327 this.FieldList = LEBitConverter.ToInt32(buff, offs);
328 offs += 4;
329 this.MethodList = LEBitConverter.ToInt32(buff, offs);
330
331 }
332
333
334
335 /// <summary>
336 /// </summary>
337 public void Dump(TextWriter writer) {
338 string dump = String.Format(
339 "Flags : {0}" + Environment.NewLine +
340 "Name : {1}" + Environment.NewLine +
341 "Namespace : {2}" + Environment.NewLine +
342 "Extends : {3}" + Environment.NewLine +
343 "FieldList : {4}" + Environment.NewLine +
344 "MethodList : {5}" + Environment.NewLine,
345 (int)this.Flags,
346 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
347 (Table == null) ? Namespace.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Namespace] + "\" (#Strings[0x" + Namespace.ToString("X") + "])",
348 this.Extends,
349 "Field[" + FieldList.ToString() + "]",
350 "Method[" + MethodList.ToString() + "]"
351 );
352 writer.WriteLine(dump);
353 }
354
355
356 /// <summary>
357 /// </summary>
358 public override string ToString()
359 {
360 StringWriter sw = new StringWriter();
361 Dump(sw);
362 return sw.ToString();
363 }
364
365 }
366
367
368
369 /// <summary>
370 /// Represents row in FieldPtr table.
371 /// </summary>
372 /// <remarks>
373 ///
374 /// </remarks>
375 public class FieldPtrRow : Row {
376
377 private MDTable table;
378
379
380 public int Field;
381
382 public FieldPtrRow()
383 {
384 }
385
386 public FieldPtrRow(MDTable parent)
387 {
388 table = parent;
389 }
390
391
392 /// <summary>
393 /// Row in FieldPtr table has 1 columns.
394 /// </summary>
395 public virtual int NumberOfColumns {
396 get {
397 return 1;
398 }
399 }
400
401
402 /// <summary>
403 /// Logical size of this instance in bytes.
404 /// </summary>
405 public virtual int Size {
406 get {
407 return LogicalSize;
408 }
409 }
410
411
412 /// <summary>
413 /// </summary>
414 public virtual MDTable Table {
415 get {
416 return table;
417 }
418 }
419
420
421 /// <summary>
422 /// Logical size of this type of row in bytes.
423 /// </summary>
424 unsafe public static int LogicalSize {
425 get {
426 return 4;
427 }
428 }
429
430
431 /// <summary>
432 /// Fills the row from the array of bytes.
433 /// </summary>
434 unsafe public void FromRawData(byte [] buff, int offs)
435 {
436 if (buff == null) throw new Exception("buff == null");
437 if (offs + Size > buff.Length) throw new Exception("bounds");
438
439
440 this.Field = LEBitConverter.ToInt32(buff, offs);
441
442 }
443
444
445
446 /// <summary>
447 /// </summary>
448 public void Dump(TextWriter writer) {
449 string dump = String.Format(
450 "Field : {0}" + Environment.NewLine,
451 "Field[" + Field.ToString() + "]"
452 );
453 writer.WriteLine(dump);
454 }
455
456
457 /// <summary>
458 /// </summary>
459 public override string ToString()
460 {
461 StringWriter sw = new StringWriter();
462 Dump(sw);
463 return sw.ToString();
464 }
465
466 }
467
468
469
470 /// <summary>
471 /// Represents row in Field table.
472 /// </summary>
473 /// <remarks>
474 /// See Partition II, Metadata; section 21.15
475 /// </remarks>
476 public class FieldRow : Row {
477
478 private MDTable table;
479
480
481 public System.Reflection.FieldAttributes Flags;
482 public int Name;
483 public int Signature;
484
485 public FieldRow()
486 {
487 }
488
489 public FieldRow(MDTable parent)
490 {
491 table = parent;
492 }
493
494
495 /// <summary>
496 /// Row in Field table has 3 columns.
497 /// </summary>
498 public virtual int NumberOfColumns {
499 get {
500 return 3;
501 }
502 }
503
504
505 /// <summary>
506 /// Logical size of this instance in bytes.
507 /// </summary>
508 public virtual int Size {
509 get {
510 return LogicalSize;
511 }
512 }
513
514
515 /// <summary>
516 /// </summary>
517 public virtual MDTable Table {
518 get {
519 return table;
520 }
521 }
522
523
524 /// <summary>
525 /// Logical size of this type of row in bytes.
526 /// </summary>
527 unsafe public static int LogicalSize {
528 get {
529 return sizeof (ushort) + 4 + 4;
530 }
531 }
532
533
534 /// <summary>
535 /// Fills the row from the array of bytes.
536 /// </summary>
537 unsafe public void FromRawData(byte [] buff, int offs)
538 {
539 if (buff == null) throw new Exception("buff == null");
540 if (offs + Size > buff.Length) throw new Exception("bounds");
541
542
543 this.Flags = (System.Reflection.FieldAttributes) LEBitConverter.ToUInt16(buff, offs);
544 offs += sizeof (ushort);
545 this.Name = LEBitConverter.ToInt32(buff, offs);
546 offs += 4;
547 this.Signature = LEBitConverter.ToInt32(buff, offs);
548
549 }
550
551
552
553 /// <summary>
554 /// </summary>
555 public void Dump(TextWriter writer) {
556 string dump = String.Format(
557 "Flags : {0}" + Environment.NewLine +
558 "Name : {1}" + Environment.NewLine +
559 "Signature : {2}" + Environment.NewLine,
560 (int)this.Flags,
561 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
562 "#Blob[" + Signature.ToString() + "]"
563 );
564 writer.WriteLine(dump);
565 }
566
567
568 /// <summary>
569 /// </summary>
570 public override string ToString()
571 {
572 StringWriter sw = new StringWriter();
573 Dump(sw);
574 return sw.ToString();
575 }
576
577 }
578
579
580
581 /// <summary>
582 /// Represents row in MethodPtr table.
583 /// </summary>
584 /// <remarks>
585 ///
586 /// </remarks>
587 public class MethodPtrRow : Row {
588
589 private MDTable table;
590
591
592 public int Method;
593
594 public MethodPtrRow()
595 {
596 }
597
598 public MethodPtrRow(MDTable parent)
599 {
600 table = parent;
601 }
602
603
604 /// <summary>
605 /// Row in MethodPtr table has 1 columns.
606 /// </summary>
607 public virtual int NumberOfColumns {
608 get {
609 return 1;
610 }
611 }
612
613
614 /// <summary>
615 /// Logical size of this instance in bytes.
616 /// </summary>
617 public virtual int Size {
618 get {
619 return LogicalSize;
620 }
621 }
622
623
624 /// <summary>
625 /// </summary>
626 public virtual MDTable Table {
627 get {
628 return table;
629 }
630 }
631
632
633 /// <summary>
634 /// Logical size of this type of row in bytes.
635 /// </summary>
636 unsafe public static int LogicalSize {
637 get {
638 return 4;
639 }
640 }
641
642
643 /// <summary>
644 /// Fills the row from the array of bytes.
645 /// </summary>
646 unsafe public void FromRawData(byte [] buff, int offs)
647 {
648 if (buff == null) throw new Exception("buff == null");
649 if (offs + Size > buff.Length) throw new Exception("bounds");
650
651
652 this.Method = LEBitConverter.ToInt32(buff, offs);
653
654 }
655
656
657
658 /// <summary>
659 /// </summary>
660 public void Dump(TextWriter writer) {
661 string dump = String.Format(
662 "Method : {0}" + Environment.NewLine,
663 "Method[" + Method.ToString() + "]"
664 );
665 writer.WriteLine(dump);
666 }
667
668
669 /// <summary>
670 /// </summary>
671 public override string ToString()
672 {
673 StringWriter sw = new StringWriter();
674 Dump(sw);
675 return sw.ToString();
676 }
677
678 }
679
680
681
682 /// <summary>
683 /// Represents row in Method table.
684 /// </summary>
685 /// <remarks>
686 /// See Partition II, Metadata; section 21.24
687 /// </remarks>
688 public class MethodRow : Row {
689
690 private MDTable table;
691
692
693 public RVA RVA;
694 public System.Reflection.MethodImplAttributes ImplFlags;
695 public System.Reflection.MethodAttributes Flags;
696 public int Name;
697 public int Signature;
698 public int ParamList;
699
700 public MethodRow()
701 {
702 }
703
704 public MethodRow(MDTable parent)
705 {
706 table = parent;
707 }
708
709
710 /// <summary>
711 /// Row in Method table has 6 columns.
712 /// </summary>
713 public virtual int NumberOfColumns {
714 get {
715 return 6;
716 }
717 }
718
719
720 /// <summary>
721 /// Logical size of this instance in bytes.
722 /// </summary>
723 public virtual int Size {
724 get {
725 return LogicalSize;
726 }
727 }
728
729
730 /// <summary>
731 /// </summary>
732 public virtual MDTable Table {
733 get {
734 return table;
735 }
736 }
737
738
739 /// <summary>
740 /// Logical size of this type of row in bytes.
741 /// </summary>
742 unsafe public static int LogicalSize {
743 get {
744 return RVA.Size + sizeof (ushort) + sizeof (ushort) + 4 + 4 + 4;
745 }
746 }
747
748
749 /// <summary>
750 /// Fills the row from the array of bytes.
751 /// </summary>
752 unsafe public void FromRawData(byte [] buff, int offs)
753 {
754 if (buff == null) throw new Exception("buff == null");
755 if (offs + Size > buff.Length) throw new Exception("bounds");
756
757
758 this.RVA = LEBitConverter.ToUInt32(buff, offs);
759 offs += RVA.Size;
760 this.ImplFlags = (System.Reflection.MethodImplAttributes) LEBitConverter.ToUInt16(buff, offs);
761 offs += sizeof (ushort);
762 this.Flags = (System.Reflection.MethodAttributes) LEBitConverter.ToUInt16(buff, offs);
763 offs += sizeof (ushort);
764 this.Name = LEBitConverter.ToInt32(buff, offs);
765 offs += 4;
766 this.Signature = LEBitConverter.ToInt32(buff, offs);
767 offs += 4;
768 this.ParamList = LEBitConverter.ToInt32(buff, offs);
769
770 }
771
772
773
774 /// <summary>
775 /// </summary>
776 public void Dump(TextWriter writer) {
777 string dump = String.Format(
778 "RVA : {0}" + Environment.NewLine +
779 "ImplFlags : {1}" + Environment.NewLine +
780 "Flags : {2}" + Environment.NewLine +
781 "Name : {3}" + Environment.NewLine +
782 "Signature : {4}" + Environment.NewLine +
783 "ParamList : {5}" + Environment.NewLine,
784 this.RVA,
785 this.ImplFlags,
786 (int)this.Flags,
787 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
788 "#Blob[" + Signature.ToString() + "]",
789 "Param[" + ParamList.ToString() + "]"
790 );
791 writer.WriteLine(dump);
792 }
793
794
795 /// <summary>
796 /// </summary>
797 public override string ToString()
798 {
799 StringWriter sw = new StringWriter();
800 Dump(sw);
801 return sw.ToString();
802 }
803
804 }
805
806
807
808 /// <summary>
809 /// Represents row in ParamPtr table.
810 /// </summary>
811 /// <remarks>
812 ///
813 /// </remarks>
814 public class ParamPtrRow : Row {
815
816 private MDTable table;
817
818
819 public int Param;
820
821 public ParamPtrRow()
822 {
823 }
824
825 public ParamPtrRow(MDTable parent)
826 {
827 table = parent;
828 }
829
830
831 /// <summary>
832 /// Row in ParamPtr table has 1 columns.
833 /// </summary>
834 public virtual int NumberOfColumns {
835 get {
836 return 1;
837 }
838 }
839
840
841 /// <summary>
842 /// Logical size of this instance in bytes.
843 /// </summary>
844 public virtual int Size {
845 get {
846 return LogicalSize;
847 }
848 }
849
850
851 /// <summary>
852 /// </summary>
853 public virtual MDTable Table {
854 get {
855 return table;
856 }
857 }
858
859
860 /// <summary>
861 /// Logical size of this type of row in bytes.
862 /// </summary>
863 unsafe public static int LogicalSize {
864 get {
865 return 4;
866 }
867 }
868
869
870 /// <summary>
871 /// Fills the row from the array of bytes.
872 /// </summary>
873 unsafe public void FromRawData(byte [] buff, int offs)
874 {
875 if (buff == null) throw new Exception("buff == null");
876 if (offs + Size > buff.Length) throw new Exception("bounds");
877
878
879 this.Param = LEBitConverter.ToInt32(buff, offs);
880
881 }
882
883
884
885 /// <summary>
886 /// </summary>
887 public void Dump(TextWriter writer) {
888 string dump = String.Format(
889 "Param : {0}" + Environment.NewLine,
890 "Param[" + Param.ToString() + "]"
891 );
892 writer.WriteLine(dump);
893 }
894
895
896 /// <summary>
897 /// </summary>
898 public override string ToString()
899 {
900 StringWriter sw = new StringWriter();
901 Dump(sw);
902 return sw.ToString();
903 }
904
905 }
906
907
908
909 /// <summary>
910 /// Represents row in Param table.
911 /// </summary>
912 /// <remarks>
913 /// See Partition II, Metadata; section 21.30
914 /// </remarks>
915 public class ParamRow : Row {
916
917 private MDTable table;
918
919
920 public System.Reflection.ParameterAttributes Flags;
921 public ushort Sequence;
922 public int Name;
923
924 public ParamRow()
925 {
926 }
927
928 public ParamRow(MDTable parent)
929 {
930 table = parent;
931 }
932
933
934 /// <summary>
935 /// Row in Param table has 3 columns.
936 /// </summary>
937 public virtual int NumberOfColumns {
938 get {
939 return 3;
940 }
941 }
942
943
944 /// <summary>
945 /// Logical size of this instance in bytes.
946 /// </summary>
947 public virtual int Size {
948 get {
949 return LogicalSize;
950 }
951 }
952
953
954 /// <summary>
955 /// </summary>
956 public virtual MDTable Table {
957 get {
958 return table;
959 }
960 }
961
962
963 /// <summary>
964 /// Logical size of this type of row in bytes.
965 /// </summary>
966 unsafe public static int LogicalSize {
967 get {
968 return sizeof (ushort) + sizeof (ushort) + 4;
969 }
970 }
971
972
973 /// <summary>
974 /// Fills the row from the array of bytes.
975 /// </summary>
976 unsafe public void FromRawData(byte [] buff, int offs)
977 {
978 if (buff == null) throw new Exception("buff == null");
979 if (offs + Size > buff.Length) throw new Exception("bounds");
980
981
982 this.Flags = (System.Reflection.ParameterAttributes) LEBitConverter.ToUInt16(buff, offs);
983 offs += sizeof (ushort);
984 this.Sequence = LEBitConverter.ToUInt16(buff, offs);
985 offs += sizeof (ushort);
986 this.Name = LEBitConverter.ToInt32(buff, offs);
987
988 }
989
990
991
992 /// <summary>
993 /// </summary>
994 public void Dump(TextWriter writer) {
995 string dump = String.Format(
996 "Flags : {0}" + Environment.NewLine +
997 "Sequence : {1}" + Environment.NewLine +
998 "Name : {2}" + Environment.NewLine,
999 (int)this.Flags,
1000 this.Sequence,
1001 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])"
1002 );
1003 writer.WriteLine(dump);
1004 }
1005
1006
1007 /// <summary>
1008 /// </summary>
1009 public override string ToString()
1010 {
1011 StringWriter sw = new StringWriter();
1012 Dump(sw);
1013 return sw.ToString();
1014 }
1015
1016 }
1017
1018
1019
1020 /// <summary>
1021 /// Represents row in InterfaceImpl table.
1022 /// </summary>
1023 /// <remarks>
1024 /// See Partition II, Metadata; section 21.21
1025 /// </remarks>
1026 public class InterfaceImplRow : Row {
1027
1028 private MDTable table;
1029
1030
1031 public int Class;
1032 public MDToken Interface;
1033
1034 public InterfaceImplRow()
1035 {
1036 }
1037
1038 public InterfaceImplRow(MDTable parent)
1039 {
1040 table = parent;
1041 }
1042
1043
1044 /// <summary>
1045 /// Row in InterfaceImpl table has 2 columns.
1046 /// </summary>
1047 public virtual int NumberOfColumns {
1048 get {
1049 return 2;
1050 }
1051 }
1052
1053
1054 /// <summary>
1055 /// Logical size of this instance in bytes.
1056 /// </summary>
1057 public virtual int Size {
1058 get {
1059 return LogicalSize;
1060 }
1061 }
1062
1063
1064 /// <summary>
1065 /// </summary>
1066 public virtual MDTable Table {
1067 get {
1068 return table;
1069 }
1070 }
1071
1072
1073 /// <summary>
1074 /// Logical size of this type of row in bytes.
1075 /// </summary>
1076 unsafe public static int LogicalSize {
1077 get {
1078 return 4 + 4;
1079 }
1080 }
1081
1082
1083 /// <summary>
1084 /// Fills the row from the array of bytes.
1085 /// </summary>
1086 unsafe public void FromRawData(byte [] buff, int offs)
1087 {
1088 if (buff == null) throw new Exception("buff == null");
1089 if (offs + Size > buff.Length) throw new Exception("bounds");
1090
1091
1092 this.Class = LEBitConverter.ToInt32(buff, offs);
1093 offs += 4;
1094 this.Interface = TabsDecoder.DecodeToken(CodedTokenId.TypeDefOrRef, LEBitConverter.ToInt32(buff, offs));
1095
1096 }
1097
1098
1099
1100 /// <summary>
1101 /// </summary>
1102 public void Dump(TextWriter writer) {
1103 string dump = String.Format(
1104 "Class : {0}" + Environment.NewLine +
1105 "Interface : {1}" + Environment.NewLine,
1106 "TypeDef[" + Class.ToString() + "]",
1107 this.Interface
1108 );
1109 writer.WriteLine(dump);
1110 }
1111
1112
1113 /// <summary>
1114 /// </summary>
1115 public override string ToString()
1116 {
1117 StringWriter sw = new StringWriter();
1118 Dump(sw);
1119 return sw.ToString();
1120 }
1121
1122 }
1123
1124
1125
1126 /// <summary>
1127 /// Represents row in MemberRef table.
1128 /// </summary>
1129 /// <remarks>
1130 /// See Partition II, Metadata; section 21.23
1131 /// </remarks>
1132 public class MemberRefRow : Row {
1133
1134 private MDTable table;
1135
1136
1137 public MDToken Class;
1138 public int Name;
1139 public int Signature;
1140
1141 public MemberRefRow()
1142 {
1143 }
1144
1145 public MemberRefRow(MDTable parent)
1146 {
1147 table = parent;
1148 }
1149
1150
1151 /// <summary>
1152 /// Row in MemberRef table has 3 columns.
1153 /// </summary>
1154 public virtual int NumberOfColumns {
1155 get {
1156 return 3;
1157 }
1158 }
1159
1160
1161 /// <summary>
1162 /// Logical size of this instance in bytes.
1163 /// </summary>
1164 public virtual int Size {
1165 get {
1166 return LogicalSize;
1167 }
1168 }
1169
1170
1171 /// <summary>
1172 /// </summary>
1173 public virtual MDTable Table {
1174 get {
1175 return table;
1176 }
1177 }
1178
1179
1180 /// <summary>
1181 /// Logical size of this type of row in bytes.
1182 /// </summary>
1183 unsafe public static int LogicalSize {
1184 get {
1185 return 4 + 4 + 4;
1186 }
1187 }
1188
1189
1190 /// <summary>
1191 /// Fills the row from the array of bytes.
1192 /// </summary>
1193 unsafe public void FromRawData(byte [] buff, int offs)
1194 {
1195 if (buff == null) throw new Exception("buff == null");
1196 if (offs + Size > buff.Length) throw new Exception("bounds");
1197
1198
1199 this.Class = TabsDecoder.DecodeToken(CodedTokenId.MemberRefParent, LEBitConverter.ToInt32(buff, offs));
1200 offs += 4;
1201 this.Name = LEBitConverter.ToInt32(buff, offs);
1202 offs += 4;
1203 this.Signature = LEBitConverter.ToInt32(buff, offs);
1204
1205 }
1206
1207
1208
1209 /// <summary>
1210 /// </summary>
1211 public void Dump(TextWriter writer) {
1212 string dump = String.Format(
1213 "Class : {0}" + Environment.NewLine +
1214 "Name : {1}" + Environment.NewLine +
1215 "Signature : {2}" + Environment.NewLine,
1216 this.Class,
1217 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
1218 "#Blob[" + Signature.ToString() + "]"
1219 );
1220 writer.WriteLine(dump);
1221 }
1222
1223
1224 /// <summary>
1225 /// </summary>
1226 public override string ToString()
1227 {
1228 StringWriter sw = new StringWriter();
1229 Dump(sw);
1230 return sw.ToString();
1231 }
1232
1233 }
1234
1235
1236
1237 /// <summary>
1238 /// Represents row in Constant table.
1239 /// </summary>
1240 /// <remarks>
1241 /// See Partition II, Metadata; section 21.9
1242 /// </remarks>
1243 public class ConstantRow : Row {
1244
1245 private MDTable table;
1246
1247
1248 public ElementType Type;
1249 public MDToken Parent;
1250 public int Value;
1251
1252 public ConstantRow()
1253 {
1254 }
1255
1256 public ConstantRow(MDTable parent)
1257 {
1258 table = parent;
1259 }
1260
1261
1262 /// <summary>
1263 /// Row in Constant table has 3 columns.
1264 /// </summary>
1265 public virtual int NumberOfColumns {
1266 get {
1267 return 3;
1268 }
1269 }
1270
1271
1272 /// <summary>
1273 /// Logical size of this instance in bytes.
1274 /// </summary>
1275 public virtual int Size {
1276 get {
1277 return LogicalSize;
1278 }
1279 }
1280
1281
1282 /// <summary>
1283 /// </summary>
1284 public virtual MDTable Table {
1285 get {
1286 return table;
1287 }
1288 }
1289
1290
1291 /// <summary>
1292 /// Logical size of this type of row in bytes.
1293 /// </summary>
1294 unsafe public static int LogicalSize {
1295 get {
1296 return sizeof (short) + 4 + 4;
1297 }
1298 }
1299
1300
1301 /// <summary>
1302 /// Fills the row from the array of bytes.
1303 /// </summary>
1304 unsafe public void FromRawData(byte [] buff, int offs)
1305 {
1306 if (buff == null) throw new Exception("buff == null");
1307 if (offs + Size > buff.Length) throw new Exception("bounds");
1308
1309
1310 this.Type = (ElementType) LEBitConverter.ToInt16(buff, offs);
1311 offs += sizeof (short);
1312 this.Parent = TabsDecoder.DecodeToken(CodedTokenId.HasConstant, LEBitConverter.ToInt32(buff, offs));
1313 offs += 4;
1314 this.Value = LEBitConverter.ToInt32(buff, offs);
1315
1316 }
1317
1318
1319
1320 /// <summary>
1321 /// </summary>
1322 public void Dump(TextWriter writer) {
1323 string dump = String.Format(
1324 "Type : {0}" + Environment.NewLine +
1325 "Parent : {1}" + Environment.NewLine +
1326 "Value : {2}" + Environment.NewLine,
1327 this.Type,
1328 this.Parent,
1329 "#Blob[" + Value.ToString() + "]"
1330 );
1331 writer.WriteLine(dump);
1332 }
1333
1334
1335 /// <summary>
1336 /// </summary>
1337 public override string ToString()
1338 {
1339 StringWriter sw = new StringWriter();
1340 Dump(sw);
1341 return sw.ToString();
1342 }
1343
1344 }
1345
1346
1347
1348 /// <summary>
1349 /// Represents row in CustomAttribute table.
1350 /// </summary>
1351 /// <remarks>
1352 /// See Partition II, Metadata; section 21.10
1353 /// </remarks>
1354 public class CustomAttributeRow : Row {
1355
1356 private MDTable table;
1357
1358
1359 public MDToken Parent;
1360 public MDToken Type;
1361 public int Value;
1362
1363 public CustomAttributeRow()
1364 {
1365 }
1366
1367 public CustomAttributeRow(MDTable parent)
1368 {
1369 table = parent;
1370 }
1371
1372
1373 /// <summary>
1374 /// Row in CustomAttribute table has 3 columns.
1375 /// </summary>
1376 public virtual int NumberOfColumns {
1377 get {
1378 return 3;
1379 }
1380 }
1381
1382
1383 /// <summary>
1384 /// Logical size of this instance in bytes.
1385 /// </summary>
1386 public virtual int Size {
1387 get {
1388 return LogicalSize;
1389 }
1390 }
1391
1392
1393 /// <summary>
1394 /// </summary>
1395 public virtual MDTable Table {
1396 get {
1397 return table;
1398 }
1399 }
1400
1401
1402 /// <summary>
1403 /// Logical size of this type of row in bytes.
1404 /// </summary>
1405 unsafe public static int LogicalSize {
1406 get {
1407 return 4 + 4 + 4;
1408 }
1409 }
1410
1411
1412 /// <summary>
1413 /// Fills the row from the array of bytes.
1414 /// </summary>
1415 unsafe public void FromRawData(byte [] buff, int offs)
1416 {
1417 if (buff == null) throw new Exception("buff == null");
1418 if (offs + Size > buff.Length) throw new Exception("bounds");
1419
1420
1421 this.Parent = TabsDecoder.DecodeToken(CodedTokenId.HasCustomAttribute, LEBitConverter.ToInt32(buff, offs));
1422 offs += 4;
1423 this.Type = TabsDecoder.DecodeToken(CodedTokenId.CustomAttributeType, LEBitConverter.ToInt32(buff, offs));
1424 offs += 4;
1425 this.Value = LEBitConverter.ToInt32(buff, offs);
1426
1427 }
1428
1429
1430
1431 /// <summary>
1432 /// </summary>
1433 public void Dump(TextWriter writer) {
1434 string dump = String.Format(
1435 "Parent : {0}" + Environment.NewLine +
1436 "Type : {1}" + Environment.NewLine +
1437 "Value : {2}" + Environment.NewLine,
1438 this.Parent,
1439 this.Type,
1440 "#Blob[" + Value.ToString() + "]"
1441 );
1442 writer.WriteLine(dump);
1443 }
1444
1445
1446 /// <summary>
1447 /// </summary>
1448 public override string ToString()
1449 {
1450 StringWriter sw = new StringWriter();
1451 Dump(sw);
1452 return sw.ToString();
1453 }
1454
1455 }
1456
1457
1458
1459 /// <summary>
1460 /// Represents row in FieldMarshal table.
1461 /// </summary>
1462 /// <remarks>
1463 /// See Partition II, Metadata; section 21.17
1464 /// </remarks>
1465 public class FieldMarshalRow : Row {
1466
1467 private MDTable table;
1468
1469
1470 public MDToken Parent;
1471 public int NativeType;
1472
1473 public FieldMarshalRow()
1474 {
1475 }
1476
1477 public FieldMarshalRow(MDTable parent)
1478 {
1479 table = parent;
1480 }
1481
1482
1483 /// <summary>
1484 /// Row in FieldMarshal table has 2 columns.
1485 /// </summary>
1486 public virtual int NumberOfColumns {
1487 get {
1488 return 2;
1489 }
1490 }
1491
1492
1493 /// <summary>
1494 /// Logical size of this instance in bytes.
1495 /// </summary>
1496 public virtual int Size {
1497 get {
1498 return LogicalSize;
1499 }
1500 }
1501
1502
1503 /// <summary>
1504 /// </summary>
1505 public virtual MDTable Table {
1506 get {
1507 return table;
1508 }
1509 }
1510
1511
1512 /// <summary>
1513 /// Logical size of this type of row in bytes.
1514 /// </summary>
1515 unsafe public static int LogicalSize {
1516 get {
1517 return 4 + 4;
1518 }
1519 }
1520
1521
1522 /// <summary>
1523 /// Fills the row from the array of bytes.
1524 /// </summary>
1525 unsafe public void FromRawData(byte [] buff, int offs)
1526 {
1527 if (buff == null) throw new Exception("buff == null");
1528 if (offs + Size > buff.Length) throw new Exception("bounds");
1529
1530
1531 this.Parent = TabsDecoder.DecodeToken(CodedTokenId.HasFieldMarshal, LEBitConverter.ToInt32(buff, offs));
1532 offs += 4;
1533 this.NativeType = LEBitConverter.ToInt32(buff, offs);
1534
1535 }
1536
1537
1538
1539 /// <summary>
1540 /// </summary>
1541 public void Dump(TextWriter writer) {
1542 string dump = String.Format(
1543 "Parent : {0}" + Environment.NewLine +
1544 "NativeType : {1}" + Environment.NewLine,
1545 this.Parent,
1546 "#Blob[" + NativeType.ToString() + "]"
1547 );
1548 writer.WriteLine(dump);
1549 }
1550
1551
1552 /// <summary>
1553 /// </summary>
1554 public override string ToString()
1555 {
1556 StringWriter sw = new StringWriter();
1557 Dump(sw);
1558 return sw.ToString();
1559 }
1560
1561 }
1562
1563
1564
1565 /// <summary>
1566 /// Represents row in DeclSecurity table.
1567 /// </summary>
1568 /// <remarks>
1569 /// See Partition II, Metadata; section 21.11
1570 /// </remarks>
1571 public class DeclSecurityRow : Row {
1572
1573 private MDTable table;
1574
1575
1576 public short Action;
1577 public MDToken Parent;
1578 public int PermissionSet;
1579
1580 public DeclSecurityRow()
1581 {
1582 }
1583
1584 public DeclSecurityRow(MDTable parent)
1585 {
1586 table = parent;
1587 }
1588
1589
1590 /// <summary>
1591 /// Row in DeclSecurity table has 3 columns.
1592 /// </summary>
1593 public virtual int NumberOfColumns {
1594 get {
1595 return 3;
1596 }
1597 }
1598
1599
1600 /// <summary>
1601 /// Logical size of this instance in bytes.
1602 /// </summary>
1603 public virtual int Size {
1604 get {
1605 return LogicalSize;
1606 }
1607 }
1608
1609
1610 /// <summary>
1611 /// </summary>
1612 public virtual MDTable Table {
1613 get {
1614 return table;
1615 }
1616 }
1617
1618
1619 /// <summary>
1620 /// Logical size of this type of row in bytes.
1621 /// </summary>
1622 unsafe public static int LogicalSize {
1623 get {
1624 return sizeof (short) + 4 + 4;
1625 }
1626 }
1627
1628
1629 /// <summary>
1630 /// Fills the row from the array of bytes.
1631 /// </summary>
1632 unsafe public void FromRawData(byte [] buff, int offs)
1633 {
1634 if (buff == null) throw new Exception("buff == null");
1635 if (offs + Size > buff.Length) throw new Exception("bounds");
1636
1637
1638 this.Action = LEBitConverter.ToInt16(buff, offs);
1639 offs += sizeof (short);
1640 this.Parent = TabsDecoder.DecodeToken(CodedTokenId.HasDeclSecurity, LEBitConverter.ToInt32(buff, offs));
1641 offs += 4;
1642 this.PermissionSet = LEBitConverter.ToInt32(buff, offs);
1643
1644 }
1645
1646
1647
1648 /// <summary>
1649 /// </summary>
1650 public void Dump(TextWriter writer) {
1651 string dump = String.Format(
1652 "Action : {0}" + Environment.NewLine +
1653 "Parent : {1}" + Environment.NewLine +
1654 "PermissionSet : {2}" + Environment.NewLine,
1655 this.Action,
1656 this.Parent,
1657 "#Blob[" + PermissionSet.ToString() + "]"
1658 );
1659 writer.WriteLine(dump);
1660 }
1661
1662
1663 /// <summary>
1664 /// </summary>
1665 public override string ToString()
1666 {
1667 StringWriter sw = new StringWriter();
1668 Dump(sw);
1669 return sw.ToString();
1670 }
1671
1672 }
1673
1674
1675
1676 /// <summary>
1677 /// Represents row in ClassLayout table.
1678 /// </summary>
1679 /// <remarks>
1680 /// See Partition II, Metadata; section 21.8
1681 /// </remarks>
1682 public class ClassLayoutRow : Row {
1683
1684 private MDTable table;
1685
1686
1687 public short PackingSize;
1688 public int ClassSize;
1689 public int Parent;
1690
1691 public ClassLayoutRow()
1692 {
1693 }
1694
1695 public ClassLayoutRow(MDTable parent)
1696 {
1697 table = parent;
1698 }
1699
1700
1701 /// <summary>
1702 /// Row in ClassLayout table has 3 columns.
1703 /// </summary>
1704 public virtual int NumberOfColumns {
1705 get {
1706 return 3;
1707 }
1708 }
1709
1710
1711 /// <summary>
1712 /// Logical size of this instance in bytes.
1713 /// </summary>
1714 public virtual int Size {
1715 get {
1716 return LogicalSize;
1717 }
1718 }
1719
1720
1721 /// <summary>
1722 /// </summary>
1723 public virtual MDTable Table {
1724 get {
1725 return table;
1726 }
1727 }
1728
1729
1730 /// <summary>
1731 /// Logical size of this type of row in bytes.
1732 /// </summary>
1733 unsafe public static int LogicalSize {
1734 get {
1735 return sizeof (short) + sizeof (int) + 4;
1736 }
1737 }
1738
1739
1740 /// <summary>
1741 /// Fills the row from the array of bytes.
1742 /// </summary>
1743 unsafe public void FromRawData(byte [] buff, int offs)
1744 {
1745 if (buff == null) throw new Exception("buff == null");
1746 if (offs + Size > buff.Length) throw new Exception("bounds");
1747
1748
1749 this.PackingSize = LEBitConverter.ToInt16(buff, offs);
1750 offs += sizeof (short);
1751 this.ClassSize = LEBitConverter.ToInt32(buff, offs);
1752 offs += sizeof (int);
1753 this.Parent = LEBitConverter.ToInt32(buff, offs);
1754
1755 }
1756
1757
1758
1759 /// <summary>
1760 /// </summary>
1761 public void Dump(TextWriter writer) {
1762 string dump = String.Format(
1763 "PackingSize : {0}" + Environment.NewLine +
1764 "ClassSize : {1}" + Environment.NewLine +
1765 "Parent : {2}" + Environment.NewLine,
1766 this.PackingSize,
1767 this.ClassSize,
1768 "TypeDef[" + Parent.ToString() + "]"
1769 );
1770 writer.WriteLine(dump);
1771 }
1772
1773
1774 /// <summary>
1775 /// </summary>
1776 public override string ToString()
1777 {
1778 StringWriter sw = new StringWriter();
1779 Dump(sw);
1780 return sw.ToString();
1781 }
1782
1783 }
1784
1785
1786
1787 /// <summary>
1788 /// Represents row in FieldLayout table.
1789 /// </summary>
1790 /// <remarks>
1791 /// See Partition II, Metadata; section 21.16
1792 /// </remarks>
1793 public class FieldLayoutRow : Row {
1794
1795 private MDTable table;
1796
1797
1798 public int Offset;
1799 public int Field;
1800
1801 public FieldLayoutRow()
1802 {
1803 }
1804
1805 public FieldLayoutRow(MDTable parent)
1806 {
1807 table = parent;
1808 }
1809
1810
1811 /// <summary>
1812 /// Row in FieldLayout table has 2 columns.
1813 /// </summary>
1814 public virtual int NumberOfColumns {
1815 get {
1816 return 2;
1817 }
1818 }
1819
1820
1821 /// <summary>
1822 /// Logical size of this instance in bytes.
1823 /// </summary>
1824 public virtual int Size {
1825 get {
1826 return LogicalSize;
1827 }
1828 }
1829
1830
1831 /// <summary>
1832 /// </summary>
1833 public virtual MDTable Table {
1834 get {
1835 return table;
1836 }
1837 }
1838
1839
1840 /// <summary>
1841 /// Logical size of this type of row in bytes.
1842 /// </summary>
1843 unsafe public static int LogicalSize {
1844 get {
1845 return sizeof (int) + 4;
1846 }
1847 }
1848
1849
1850 /// <summary>
1851 /// Fills the row from the array of bytes.
1852 /// </summary>
1853 unsafe public void FromRawData(byte [] buff, int offs)
1854 {
1855 if (buff == null) throw new Exception("buff == null");
1856 if (offs + Size > buff.Length) throw new Exception("bounds");
1857
1858
1859 this.Offset = LEBitConverter.ToInt32(buff, offs);
1860 offs += sizeof (int);
1861 this.Field = LEBitConverter.ToInt32(buff, offs);
1862
1863 }
1864
1865
1866
1867 /// <summary>
1868 /// </summary>
1869 public void Dump(TextWriter writer) {
1870 string dump = String.Format(
1871 "Offset : {0}" + Environment.NewLine +
1872 "Field : {1}" + Environment.NewLine,
1873 this.Offset,
1874 "Field[" + Field.ToString() + "]"
1875 );
1876 writer.WriteLine(dump);
1877 }
1878
1879
1880 /// <summary>
1881 /// </summary>
1882 public override string ToString()
1883 {
1884 StringWriter sw = new StringWriter();
1885 Dump(sw);
1886 return sw.ToString();
1887 }
1888
1889 }
1890
1891
1892
1893 /// <summary>
1894 /// Represents row in StandAloneSig table.
1895 /// </summary>
1896 /// <remarks>
1897 /// See Partition II, Metadata; section 21.33
1898 /// </remarks>
1899 public class StandAloneSigRow : Row {
1900
1901 private MDTable table;
1902
1903
1904 public int Signature;
1905
1906 public StandAloneSigRow()
1907 {
1908 }
1909
1910 public StandAloneSigRow(MDTable parent)
1911 {
1912 table = parent;
1913 }
1914
1915
1916 /// <summary>
1917 /// Row in StandAloneSig table has 1 columns.
1918 /// </summary>
1919 public virtual int NumberOfColumns {
1920 get {
1921 return 1;
1922 }
1923 }
1924
1925
1926 /// <summary>
1927 /// Logical size of this instance in bytes.
1928 /// </summary>
1929 public virtual int Size {
1930 get {
1931 return LogicalSize;
1932 }
1933 }
1934
1935
1936 /// <summary>
1937 /// </summary>
1938 public virtual MDTable Table {
1939 get {
1940 return table;
1941 }
1942 }
1943
1944
1945 /// <summary>
1946 /// Logical size of this type of row in bytes.
1947 /// </summary>
1948 unsafe public static int LogicalSize {
1949 get {
1950 return 4;
1951 }
1952 }
1953
1954
1955 /// <summary>
1956 /// Fills the row from the array of bytes.
1957 /// </summary>
1958 unsafe public void FromRawData(byte [] buff, int offs)
1959 {
1960 if (buff == null) throw new Exception("buff == null");
1961 if (offs + Size > buff.Length) throw new Exception("bounds");
1962
1963
1964 this.Signature = LEBitConverter.ToInt32(buff, offs);
1965
1966 }
1967
1968
1969
1970 /// <summary>
1971 /// </summary>
1972 public void Dump(TextWriter writer) {
1973 string dump = String.Format(
1974 "Signature : {0}" + Environment.NewLine,
1975 "#Blob[" + Signature.ToString() + "]"
1976 );
1977 writer.WriteLine(dump);
1978 }
1979
1980
1981 /// <summary>
1982 /// </summary>
1983 public override string ToString()
1984 {
1985 StringWriter sw = new StringWriter();
1986 Dump(sw);
1987 return sw.ToString();
1988 }
1989
1990 }
1991
1992
1993
1994 /// <summary>
1995 /// Represents row in EventMap table.
1996 /// </summary>
1997 /// <remarks>
1998 /// See Partition II, Metadata; section 21.12
1999 /// </remarks>
2000 public class EventMapRow : Row {
2001
2002 private MDTable table;
2003
2004
2005 public int Parent;
2006 public int EventList;
2007
2008 public EventMapRow()
2009 {
2010 }
2011
2012 public EventMapRow(MDTable parent)
2013 {
2014 table = parent;
2015 }
2016
2017
2018 /// <summary>
2019 /// Row in EventMap table has 2 columns.
2020 /// </summary>
2021 public virtual int NumberOfColumns {
2022 get {
2023 return 2;
2024 }
2025 }
2026
2027
2028 /// <summary>
2029 /// Logical size of this instance in bytes.
2030 /// </summary>
2031 public virtual int Size {
2032 get {
2033 return LogicalSize;
2034 }
2035 }
2036
2037
2038 /// <summary>
2039 /// </summary>
2040 public virtual MDTable Table {
2041 get {
2042 return table;
2043 }
2044 }
2045
2046
2047 /// <summary>
2048 /// Logical size of this type of row in bytes.
2049 /// </summary>
2050 unsafe public static int LogicalSize {
2051 get {
2052 return 4 + 4;
2053 }
2054 }
2055
2056
2057 /// <summary>
2058 /// Fills the row from the array of bytes.
2059 /// </summary>
2060 unsafe public void FromRawData(byte [] buff, int offs)
2061 {
2062 if (buff == null) throw new Exception("buff == null");
2063 if (offs + Size > buff.Length) throw new Exception("bounds");
2064
2065
2066 this.Parent = LEBitConverter.ToInt32(buff, offs);
2067 offs += 4;
2068 this.EventList = LEBitConverter.ToInt32(buff, offs);
2069
2070 }
2071
2072
2073
2074 /// <summary>
2075 /// </summary>
2076 public void Dump(TextWriter writer) {
2077 string dump = String.Format(
2078 "Parent : {0}" + Environment.NewLine +
2079 "EventList : {1}" + Environment.NewLine,
2080 "TypeDef[" + Parent.ToString() + "]",
2081 "Event[" + EventList.ToString() + "]"
2082 );
2083 writer.WriteLine(dump);
2084 }
2085
2086
2087 /// <summary>
2088 /// </summary>
2089 public override string ToString()
2090 {
2091 StringWriter sw = new StringWriter();
2092 Dump(sw);
2093 return sw.ToString();
2094 }
2095
2096 }
2097
2098
2099
2100 /// <summary>
2101 /// Represents row in EventPtr table.
2102 /// </summary>
2103 /// <remarks>
2104 ///
2105 /// </remarks>
2106 public class EventPtrRow : Row {
2107
2108 private MDTable table;
2109
2110
2111 public int Event;
2112
2113 public EventPtrRow()
2114 {
2115 }
2116
2117 public EventPtrRow(MDTable parent)
2118 {
2119 table = parent;
2120 }
2121
2122
2123 /// <summary>
2124 /// Row in EventPtr table has 1 columns.
2125 /// </summary>
2126 public virtual int NumberOfColumns {
2127 get {
2128 return 1;
2129 }
2130 }
2131
2132
2133 /// <summary>
2134 /// Logical size of this instance in bytes.
2135 /// </summary>
2136 public virtual int Size {
2137 get {
2138 return LogicalSize;
2139 }
2140 }
2141
2142
2143 /// <summary>
2144 /// </summary>
2145 public virtual MDTable Table {
2146 get {
2147 return table;
2148 }
2149 }
2150
2151
2152 /// <summary>
2153 /// Logical size of this type of row in bytes.
2154 /// </summary>
2155 unsafe public static int LogicalSize {
2156 get {
2157 return 4;
2158 }
2159 }
2160
2161
2162 /// <summary>
2163 /// Fills the row from the array of bytes.
2164 /// </summary>
2165 unsafe public void FromRawData(byte [] buff, int offs)
2166 {
2167 if (buff == null) throw new Exception("buff == null");
2168 if (offs + Size > buff.Length) throw new Exception("bounds");
2169
2170
2171 this.Event = LEBitConverter.ToInt32(buff, offs);
2172
2173 }
2174
2175
2176
2177 /// <summary>
2178 /// </summary>
2179 public void Dump(TextWriter writer) {
2180 string dump = String.Format(
2181 "Event : {0}" + Environment.NewLine,
2182 "Event[" + Event.ToString() + "]"
2183 );
2184 writer.WriteLine(dump);
2185 }
2186
2187
2188 /// <summary>
2189 /// </summary>
2190 public override string ToString()
2191 {
2192 StringWriter sw = new StringWriter();
2193 Dump(sw);
2194 return sw.ToString();
2195 }
2196
2197 }
2198
2199
2200
2201 /// <summary>
2202 /// Represents row in Event table.
2203 /// </summary>
2204 /// <remarks>
2205 /// See Partition II, Metadata; section 21.13
2206 /// </remarks>
2207 public class EventRow : Row {
2208
2209 private MDTable table;
2210
2211
2212 public System.Reflection.EventAttributes EventFlags;
2213 public int Name;
2214 public MDToken EventType;
2215
2216 public EventRow()
2217 {
2218 }
2219
2220 public EventRow(MDTable parent)
2221 {
2222 table = parent;
2223 }
2224
2225
2226 /// <summary>
2227 /// Row in Event table has 3 columns.
2228 /// </summary>
2229 public virtual int NumberOfColumns {
2230 get {
2231 return 3;
2232 }
2233 }
2234
2235
2236 /// <summary>
2237 /// Logical size of this instance in bytes.
2238 /// </summary>
2239 public virtual int Size {
2240 get {
2241 return LogicalSize;
2242 }
2243 }
2244
2245
2246 /// <summary>
2247 /// </summary>
2248 public virtual MDTable Table {
2249 get {
2250 return table;
2251 }
2252 }
2253
2254
2255 /// <summary>
2256 /// Logical size of this type of row in bytes.
2257 /// </summary>
2258 unsafe public static int LogicalSize {
2259 get {
2260 return sizeof (short) + 4 + 4;
2261 }
2262 }
2263
2264
2265 /// <summary>
2266 /// Fills the row from the array of bytes.
2267 /// </summary>
2268 unsafe public void FromRawData(byte [] buff, int offs)
2269 {
2270 if (buff == null) throw new Exception("buff == null");
2271 if (offs + Size > buff.Length) throw new Exception("bounds");
2272
2273
2274 this.EventFlags = (System.Reflection.EventAttributes) LEBitConverter.ToInt16(buff, offs);
2275 offs += sizeof (short);
2276 this.Name = LEBitConverter.ToInt32(buff, offs);
2277 offs += 4;
2278 this.EventType = TabsDecoder.DecodeToken(CodedTokenId.TypeDefOrRef, LEBitConverter.ToInt32(buff, offs));
2279
2280 }
2281
2282
2283
2284 /// <summary>
2285 /// </summary>
2286 public void Dump(TextWriter writer) {
2287 string dump = String.Format(
2288 "EventFlags : {0}" + Environment.NewLine +
2289 "Name : {1}" + Environment.NewLine +
2290 "EventType : {2}" + Environment.NewLine,
2291 this.EventFlags,
2292 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
2293 this.EventType
2294 );
2295 writer.WriteLine(dump);
2296 }
2297
2298
2299 /// <summary>
2300 /// </summary>
2301 public override string ToString()
2302 {
2303 StringWriter sw = new StringWriter();
2304 Dump(sw);
2305 return sw.ToString();
2306 }
2307
2308 }
2309
2310
2311
2312 /// <summary>
2313 /// Represents row in PropertyMap table.
2314 /// </summary>
2315 /// <remarks>
2316 /// See Partition II, Metadata; section 21.32
2317 /// </remarks>
2318 public class PropertyMapRow : Row {
2319
2320 private MDTable table;
2321
2322
2323 public int Parent;
2324 public int PropertyList;
2325
2326 public PropertyMapRow()
2327 {
2328 }
2329
2330 public PropertyMapRow(MDTable parent)
2331 {
2332 table = parent;
2333 }
2334
2335
2336 /// <summary>
2337 /// Row in PropertyMap table has 2 columns.
2338 /// </summary>
2339 public virtual int NumberOfColumns {
2340 get {
2341 return 2;
2342 }
2343 }
2344
2345
2346 /// <summary>
2347 /// Logical size of this instance in bytes.
2348 /// </summary>
2349 public virtual int Size {
2350 get {
2351 return LogicalSize;
2352 }
2353 }
2354
2355
2356 /// <summary>
2357 /// </summary>
2358 public virtual MDTable Table {
2359 get {
2360 return table;
2361 }
2362 }
2363
2364
2365 /// <summary>
2366 /// Logical size of this type of row in bytes.
2367 /// </summary>
2368 unsafe public static int LogicalSize {
2369 get {
2370 return 4 + 4;
2371 }
2372 }
2373
2374
2375 /// <summary>
2376 /// Fills the row from the array of bytes.
2377 /// </summary>
2378 unsafe public void FromRawData(byte [] buff, int offs)
2379 {
2380 if (buff == null) throw new Exception("buff == null");
2381 if (offs + Size > buff.Length) throw new Exception("bounds");
2382
2383
2384 this.Parent = LEBitConverter.ToInt32(buff, offs);
2385 offs += 4;
2386 this.PropertyList = LEBitConverter.ToInt32(buff, offs);
2387
2388 }
2389
2390
2391
2392 /// <summary>
2393 /// </summary>
2394 public void Dump(TextWriter writer) {
2395 string dump = String.Format(
2396 "Parent : {0}" + Environment.NewLine +
2397 "PropertyList : {1}" + Environment.NewLine,
2398 "TypeDef[" + Parent.ToString() + "]",
2399 "Property[" + PropertyList.ToString() + "]"
2400 );
2401 writer.WriteLine(dump);
2402 }
2403
2404
2405 /// <summary>
2406 /// </summary>
2407 public override string ToString()
2408 {
2409 StringWriter sw = new StringWriter();
2410 Dump(sw);
2411 return sw.ToString();
2412 }
2413
2414 }
2415
2416
2417
2418 /// <summary>
2419 /// Represents row in PropertyPtr table.
2420 /// </summary>
2421 /// <remarks>
2422 ///
2423 /// </remarks>
2424 public class PropertyPtrRow : Row {
2425
2426 private MDTable table;
2427
2428
2429 public int Property;
2430
2431 public PropertyPtrRow()
2432 {
2433 }
2434
2435 public PropertyPtrRow(MDTable parent)
2436 {
2437 table = parent;
2438 }
2439
2440
2441 /// <summary>
2442 /// Row in PropertyPtr table has 1 columns.
2443 /// </summary>
2444 public virtual int NumberOfColumns {
2445 get {
2446 return 1;
2447 }
2448 }
2449
2450
2451 /// <summary>
2452 /// Logical size of this instance in bytes.
2453 /// </summary>
2454 public virtual int Size {
2455 get {
2456 return LogicalSize;
2457 }
2458 }
2459
2460
2461 /// <summary>
2462 /// </summary>
2463 public virtual MDTable Table {
2464 get {
2465 return table;
2466 }
2467 }
2468
2469
2470 /// <summary>
2471 /// Logical size of this type of row in bytes.
2472 /// </summary>
2473 unsafe public static int LogicalSize {
2474 get {
2475 return 4;
2476 }
2477 }
2478
2479
2480 /// <summary>
2481 /// Fills the row from the array of bytes.
2482 /// </summary>
2483 unsafe public void FromRawData(byte [] buff, int offs)
2484 {
2485 if (buff == null) throw new Exception("buff == null");
2486 if (offs + Size > buff.Length) throw new Exception("bounds");
2487
2488
2489 this.Property = LEBitConverter.ToInt32(buff, offs);
2490
2491 }
2492
2493
2494
2495 /// <summary>
2496 /// </summary>
2497 public void Dump(TextWriter writer) {
2498 string dump = String.Format(
2499 "Property : {0}" + Environment.NewLine,
2500 "Property[" + Property.ToString() + "]"
2501 );
2502 writer.WriteLine(dump);
2503 }
2504
2505
2506 /// <summary>
2507 /// </summary>
2508 public override string ToString()
2509 {
2510 StringWriter sw = new StringWriter();
2511 Dump(sw);
2512 return sw.ToString();
2513 }
2514
2515 }
2516
2517
2518
2519 /// <summary>
2520 /// Represents row in Property table.
2521 /// </summary>
2522 /// <remarks>
2523 /// See Partition II, Metadata; section 21.30
2524 /// </remarks>
2525 public class PropertyRow : Row {
2526
2527 private MDTable table;
2528
2529
2530 public System.Reflection.PropertyAttributes Flags;
2531 public int Name;
2532 public int Type;
2533
2534 public PropertyRow()
2535 {
2536 }
2537
2538 public PropertyRow(MDTable parent)
2539 {
2540 table = parent;
2541 }
2542
2543
2544 /// <summary>
2545 /// Row in Property table has 3 columns.
2546 /// </summary>
2547 public virtual int NumberOfColumns {
2548 get {
2549 return 3;
2550 }
2551 }
2552
2553
2554 /// <summary>
2555 /// Logical size of this instance in bytes.
2556 /// </summary>
2557 public virtual int Size {
2558 get {
2559 return LogicalSize;
2560 }
2561 }
2562
2563
2564 /// <summary>
2565 /// </summary>
2566 public virtual MDTable Table {
2567 get {
2568 return table;
2569 }
2570 }
2571
2572
2573 /// <summary>
2574 /// Logical size of this type of row in bytes.
2575 /// </summary>
2576 unsafe public static int LogicalSize {
2577 get {
2578 return sizeof (ushort) + 4 + 4;
2579 }
2580 }
2581
2582
2583 /// <summary>
2584 /// Fills the row from the array of bytes.
2585 /// </summary>
2586 unsafe public void FromRawData(byte [] buff, int offs)
2587 {
2588 if (buff == null) throw new Exception("buff == null");
2589 if (offs + Size > buff.Length) throw new Exception("bounds");
2590
2591
2592 this.Flags = (System.Reflection.PropertyAttributes) LEBitConverter.ToUInt16(buff, offs);
2593 offs += sizeof (ushort);
2594 this.Name = LEBitConverter.ToInt32(buff, offs);
2595 offs += 4;
2596 this.Type = LEBitConverter.ToInt32(buff, offs);
2597
2598 }
2599
2600
2601
2602 /// <summary>
2603 /// </summary>
2604 public void Dump(TextWriter writer) {
2605 string dump = String.Format(
2606 "Flags : {0}" + Environment.NewLine +
2607 "Name : {1}" + Environment.NewLine +
2608 "Type : {2}" + Environment.NewLine,
2609 (int)this.Flags,
2610 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
2611 "#Blob[" + Type.ToString() + "]"
2612 );
2613 writer.WriteLine(dump);
2614 }
2615
2616
2617 /// <summary>
2618 /// </summary>
2619 public override string ToString()
2620 {
2621 StringWriter sw = new StringWriter();
2622 Dump(sw);
2623 return sw.ToString();
2624 }
2625
2626 }
2627
2628
2629
2630 /// <summary>
2631 /// Represents row in MethodSemantics table.
2632 /// </summary>
2633 /// <remarks>
2634 /// See Partition II, Metadata; section 21.26
2635 /// </remarks>
2636 public class MethodSemanticsRow : Row {
2637
2638 private MDTable table;
2639
2640
2641 public MethodSemanticsAttributes Semantics;
2642 public int Method;
2643 public MDToken Association;
2644
2645 public MethodSemanticsRow()
2646 {
2647 }
2648
2649 public MethodSemanticsRow(MDTable parent)
2650 {
2651 table = parent;
2652 }
2653
2654
2655 /// <summary>
2656 /// Row in MethodSemantics table has 3 columns.
2657 /// </summary>
2658 public virtual int NumberOfColumns {
2659 get {
2660 return 3;
2661 }
2662 }
2663
2664
2665 /// <summary>
2666 /// Logical size of this instance in bytes.
2667 /// </summary>
2668 public virtual int Size {
2669 get {
2670 return LogicalSize;
2671 }
2672 }
2673
2674
2675 /// <summary>
2676 /// </summary>
2677 public virtual MDTable Table {
2678 get {
2679 return table;
2680 }
2681 }
2682
2683
2684 /// <summary>
2685 /// Logical size of this type of row in bytes.
2686 /// </summary>
2687 unsafe public static int LogicalSize {
2688 get {
2689 return sizeof (ushort) + 4 + 4;
2690 }
2691 }
2692
2693
2694 /// <summary>
2695 /// Fills the row from the array of bytes.
2696 /// </summary>
2697 unsafe public void FromRawData(byte [] buff, int offs)
2698 {
2699 if (buff == null) throw new Exception("buff == null");
2700 if (offs + Size > buff.Length) throw new Exception("bounds");
2701
2702
2703 this.Semantics = (MethodSemanticsAttributes) LEBitConverter.ToUInt16(buff, offs);
2704 offs += sizeof (ushort);
2705 this.Method = LEBitConverter.ToInt32(buff, offs);
2706 offs += 4;
2707 this.Association = TabsDecoder.DecodeToken(CodedTokenId.HasSemantics, LEBitConverter.ToInt32(buff, offs));
2708
2709 }
2710
2711
2712
2713 /// <summary>
2714 /// </summary>
2715 public void Dump(TextWriter writer) {
2716 string dump = String.Format(
2717 "Semantics : {0}" + Environment.NewLine +
2718 "Method : {1}" + Environment.NewLine +
2719 "Association : {2}" + Environment.NewLine,
2720 (int)this.Semantics,
2721 "Method[" + Method.ToString() + "]",
2722 this.Association
2723 );
2724 writer.WriteLine(dump);
2725 }
2726
2727
2728 /// <summary>
2729 /// </summary>
2730 public override string ToString()
2731 {
2732 StringWriter sw = new StringWriter();
2733 Dump(sw);
2734 return sw.ToString();
2735 }
2736
2737 }
2738
2739
2740
2741 /// <summary>
2742 /// Represents row in MethodImpl table.
2743 /// </summary>
2744 /// <remarks>
2745 /// See Partition II, Metadata; section 21.25
2746 /// </remarks>
2747 public class MethodImplRow : Row {
2748
2749 private MDTable table;
2750
2751
2752 public int Class;
2753 public MDToken MethodBody;
2754 public MDToken MethodDeclaration;
2755
2756 public MethodImplRow()
2757 {
2758 }
2759
2760 public MethodImplRow(MDTable parent)
2761 {
2762 table = parent;
2763 }
2764
2765
2766 /// <summary>
2767 /// Row in MethodImpl table has 3 columns.
2768 /// </summary>
2769 public virtual int NumberOfColumns {
2770 get {
2771 return 3;
2772 }
2773 }
2774
2775
2776 /// <summary>
2777 /// Logical size of this instance in bytes.
2778 /// </summary>
2779 public virtual int Size {
2780 get {
2781 return LogicalSize;
2782 }
2783 }
2784
2785
2786 /// <summary>
2787 /// </summary>
2788 public virtual MDTable Table {
2789 get {
2790 return table;
2791 }
2792 }
2793
2794
2795 /// <summary>
2796 /// Logical size of this type of row in bytes.
2797 /// </summary>
2798 unsafe public static int LogicalSize {
2799 get {
2800 return 4 + 4 + 4;
2801 }
2802 }
2803
2804
2805 /// <summary>
2806 /// Fills the row from the array of bytes.
2807 /// </summary>
2808 unsafe public void FromRawData(byte [] buff, int offs)
2809 {
2810 if (buff == null) throw new Exception("buff == null");
2811 if (offs + Size > buff.Length) throw new Exception("bounds");
2812
2813
2814 this.Class = LEBitConverter.ToInt32(buff, offs);
2815 offs += 4;
2816 this.MethodBody = TabsDecoder.DecodeToken(CodedTokenId.MethodDefOrRef, LEBitConverter.ToInt32(buff, offs));
2817 offs += 4;
2818 this.MethodDeclaration = TabsDecoder.DecodeToken(CodedTokenId.MethodDefOrRef, LEBitConverter.ToInt32(buff, offs));
2819
2820 }
2821
2822
2823
2824 /// <summary>
2825 /// </summary>
2826 public void Dump(TextWriter writer) {
2827 string dump = String.Format(
2828 "Class : {0}" + Environment.NewLine +
2829 "MethodBody : {1}" + Environment.NewLine +
2830 "MethodDeclaration : {2}" + Environment.NewLine,
2831 "TypeDef[" + Class.ToString() + "]",
2832 this.MethodBody,
2833 this.MethodDeclaration
2834 );
2835 writer.WriteLine(dump);
2836 }
2837
2838
2839 /// <summary>
2840 /// </summary>
2841 public override string ToString()
2842 {
2843 StringWriter sw = new StringWriter();
2844 Dump(sw);
2845 return sw.ToString();
2846 }
2847
2848 }
2849
2850
2851
2852 /// <summary>
2853 /// Represents row in ModuleRef table.
2854 /// </summary>
2855 /// <remarks>
2856 /// See Partition II, Metadata; section 21.28
2857 /// </remarks>
2858 public class ModuleRefRow : Row {
2859
2860 private MDTable table;
2861
2862
2863 public int Name;
2864
2865 public ModuleRefRow()
2866 {
2867 }
2868
2869 public ModuleRefRow(MDTable parent)
2870 {
2871 table = parent;
2872 }
2873
2874
2875 /// <summary>
2876 /// Row in ModuleRef table has 1 columns.
2877 /// </summary>
2878 public virtual int NumberOfColumns {
2879 get {
2880 return 1;
2881 }
2882 }
2883
2884
2885 /// <summary>
2886 /// Logical size of this instance in bytes.
2887 /// </summary>
2888 public virtual int Size {
2889 get {
2890 return LogicalSize;
2891 }
2892 }
2893
2894
2895 /// <summary>
2896 /// </summary>
2897 public virtual MDTable Table {
2898 get {
2899 return table;
2900 }
2901 }
2902
2903
2904 /// <summary>
2905 /// Logical size of this type of row in bytes.
2906 /// </summary>
2907 unsafe public static int LogicalSize {
2908 get {
2909 return 4;
2910 }
2911 }
2912
2913
2914 /// <summary>
2915 /// Fills the row from the array of bytes.
2916 /// </summary>
2917 unsafe public void FromRawData(byte [] buff, int offs)
2918 {
2919 if (buff == null) throw new Exception("buff == null");
2920 if (offs + Size > buff.Length) throw new Exception("bounds");
2921
2922
2923 this.Name = LEBitConverter.ToInt32(buff, offs);
2924
2925 }
2926
2927
2928
2929 /// <summary>
2930 /// </summary>
2931 public void Dump(TextWriter writer) {
2932 string dump = String.Format(
2933 "Name : {0}" + Environment.NewLine,
2934 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])"
2935 );
2936 writer.WriteLine(dump);
2937 }
2938
2939
2940 /// <summary>
2941 /// </summary>
2942 public override string ToString()
2943 {
2944 StringWriter sw = new StringWriter();
2945 Dump(sw);
2946 return sw.ToString();
2947 }
2948
2949 }
2950
2951
2952
2953 /// <summary>
2954 /// Represents row in TypeSpec table.
2955 /// </summary>
2956 /// <remarks>
2957 /// See Partition II, Metadata; section 21.36
2958 /// </remarks>
2959 public class TypeSpecRow : Row {
2960
2961 private MDTable table;
2962
2963
2964 public int Signature;
2965
2966 public TypeSpecRow()
2967 {
2968 }
2969
2970 public TypeSpecRow(MDTable parent)
2971 {
2972 table = parent;
2973 }
2974
2975
2976 /// <summary>
2977 /// Row in TypeSpec table has 1 columns.
2978 /// </summary>
2979 public virtual int NumberOfColumns {
2980 get {
2981 return 1;
2982 }
2983 }
2984
2985
2986 /// <summary>
2987 /// Logical size of this instance in bytes.
2988 /// </summary>
2989 public virtual int Size {
2990 get {
2991 return LogicalSize;
2992 }
2993 }
2994
2995
2996 /// <summary>
2997 /// </summary>
2998 public virtual MDTable Table {
2999 get {
3000 return table;
3001 }
3002 }
3003
3004
3005 /// <summary>
3006 /// Logical size of this type of row in bytes.
3007 /// </summary>
3008 unsafe public static int LogicalSize {
3009 get {
3010 return 4;
3011 }
3012 }
3013
3014
3015 /// <summary>
3016 /// Fills the row from the array of bytes.
3017 /// </summary>
3018 unsafe public void FromRawData(byte [] buff, int offs)
3019 {
3020 if (buff == null) throw new Exception("buff == null");
3021 if (offs + Size > buff.Length) throw new Exception("bounds");
3022
3023
3024 this.Signature = LEBitConverter.ToInt32(buff, offs);
3025
3026 }
3027
3028
3029
3030 /// <summary>
3031 /// </summary>
3032 public void Dump(TextWriter writer) {
3033 string dump = String.Format(
3034 "Signature : {0}" + Environment.NewLine,
3035 "#Blob[" + Signature.ToString() + "]"
3036 );
3037 writer.WriteLine(dump);
3038 }
3039
3040
3041 /// <summary>
3042 /// </summary>
3043 public override string ToString()
3044 {
3045 StringWriter sw = new StringWriter();
3046 Dump(sw);
3047 return sw.ToString();
3048 }
3049
3050 }
3051
3052
3053
3054 /// <summary>
3055 /// Represents row in ImplMap table.
3056 /// </summary>
3057 /// <remarks>
3058 /// See Partition II, Metadata; section 21.20
3059 /// </remarks>
3060 public class ImplMapRow : Row {
3061
3062 private MDTable table;
3063
3064
3065 public PInvokeAttributes MappingFlags;
3066 public MDToken MemberForwarded;
3067 public int ImportName;
3068 public int ImportScope;
3069
3070 public ImplMapRow()
3071 {
3072 }
3073
3074 public ImplMapRow(MDTable parent)
3075 {
3076 table = parent;
3077 }
3078
3079
3080 /// <summary>
3081 /// Row in ImplMap table has 4 columns.
3082 /// </summary>
3083 public virtual int NumberOfColumns {
3084 get {
3085 return 4;
3086 }
3087 }
3088
3089
3090 /// <summary>
3091 /// Logical size of this instance in bytes.
3092 /// </summary>
3093 public virtual int Size {
3094 get {
3095 return LogicalSize;
3096 }
3097 }
3098
3099
3100 /// <summary>
3101 /// </summary>
3102 public virtual MDTable Table {
3103 get {
3104 return table;
3105 }
3106 }
3107
3108
3109 /// <summary>
3110 /// Logical size of this type of row in bytes.
3111 /// </summary>
3112 unsafe public static int LogicalSize {
3113 get {
3114 return sizeof (ushort) + 4 + 4 + 4;
3115 }
3116 }
3117
3118
3119 /// <summary>
3120 /// Fills the row from the array of bytes.
3121 /// </summary>
3122 unsafe public void FromRawData(byte [] buff, int offs)
3123 {
3124 if (buff == null) throw new Exception("buff == null");
3125 if (offs + Size > buff.Length) throw new Exception("bounds");
3126
3127
3128 this.MappingFlags = (PInvokeAttributes) LEBitConverter.ToUInt16(buff, offs);
3129 offs += sizeof (ushort);
3130 this.MemberForwarded = TabsDecoder.DecodeToken(CodedTokenId.MemberForwarded, LEBitConverter.ToInt32(buff, offs));
3131 offs += 4;
3132 this.ImportName = LEBitConverter.ToInt32(buff, offs);
3133 offs += 4;
3134 this.ImportScope = LEBitConverter.ToInt32(buff, offs);
3135
3136 }
3137
3138
3139
3140 /// <summary>
3141 /// </summary>
3142 public void Dump(TextWriter writer) {
3143 string dump = String.Format(
3144 "MappingFlags : {0}" + Environment.NewLine +
3145 "MemberForwarded : {1}" + Environment.NewLine +
3146 "ImportName : {2}" + Environment.NewLine +
3147 "ImportScope : {3}" + Environment.NewLine,
3148 this.MappingFlags,
3149 this.MemberForwarded,
3150 (Table == null) ? ImportName.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [ImportName] + "\" (#Strings[0x" + ImportName.ToString("X") + "])",
3151 "ModuleRef[" + ImportScope.ToString() + "]"
3152 );
3153 writer.WriteLine(dump);
3154 }
3155
3156
3157 /// <summary>
3158 /// </summary>
3159 public override string ToString()
3160 {
3161 StringWriter sw = new StringWriter();
3162 Dump(sw);
3163 return sw.ToString();
3164 }
3165
3166 }
3167
3168
3169
3170 /// <summary>
3171 /// Represents row in FieldRVA table.
3172 /// </summary>
3173 /// <remarks>
3174 /// See Partition II, Metadata; section 21.18
3175 /// </remarks>
3176 public class FieldRVARow : Row {
3177
3178 private MDTable table;
3179
3180
3181 public RVA RVA;
3182 public int Field;
3183
3184 public FieldRVARow()
3185 {
3186 }
3187
3188 public FieldRVARow(MDTable parent)
3189 {
3190 table = parent;
3191 }
3192
3193
3194 /// <summary>
3195 /// Row in FieldRVA table has 2 columns.
3196 /// </summary>
3197 public virtual int NumberOfColumns {
3198 get {
3199 return 2;
3200 }
3201 }
3202
3203
3204 /// <summary>
3205 /// Logical size of this instance in bytes.
3206 /// </summary>
3207 public virtual int Size {
3208 get {
3209 return LogicalSize;
3210 }
3211 }
3212
3213
3214 /// <summary>
3215 /// </summary>
3216 public virtual MDTable Table {
3217 get {
3218 return table;
3219 }
3220 }
3221
3222
3223 /// <summary>
3224 /// Logical size of this type of row in bytes.
3225 /// </summary>
3226 unsafe public static int LogicalSize {
3227 get {
3228 return RVA.Size + 4;
3229 }
3230 }
3231
3232
3233 /// <summary>
3234 /// Fills the row from the array of bytes.
3235 /// </summary>
3236 unsafe public void FromRawData(byte [] buff, int offs)
3237 {
3238 if (buff == null) throw new Exception("buff == null");
3239 if (offs + Size > buff.Length) throw new Exception("bounds");
3240
3241
3242 this.RVA = LEBitConverter.ToUInt32(buff, offs);
3243 offs += RVA.Size;
3244 this.Field = LEBitConverter.ToInt32(buff, offs);
3245
3246 }
3247
3248
3249
3250 /// <summary>
3251 /// </summary>
3252 public void Dump(TextWriter writer) {
3253 string dump = String.Format(
3254 "RVA : {0}" + Environment.NewLine +
3255 "Field : {1}" + Environment.NewLine,
3256 this.RVA,
3257 "Field[" + Field.ToString() + "]"
3258 );
3259 writer.WriteLine(dump);
3260 }
3261
3262
3263 /// <summary>
3264 /// </summary>
3265 public override string ToString()
3266 {
3267 StringWriter sw = new StringWriter();
3268 Dump(sw);
3269 return sw.ToString();
3270 }
3271
3272 }
3273
3274
3275
3276 /// <summary>
3277 /// Represents row in ENCLog table.
3278 /// </summary>
3279 /// <remarks>
3280 ///
3281 /// </remarks>
3282 public class ENCLogRow : Row {
3283
3284 private MDTable table;
3285
3286
3287 public uint Token;
3288 public uint FuncCode;
3289
3290 public ENCLogRow()
3291 {
3292 }
3293
3294 public ENCLogRow(MDTable parent)
3295 {
3296 table = parent;
3297 }
3298
3299
3300 /// <summary>
3301 /// Row in ENCLog table has 2 columns.
3302 /// </summary>
3303 public virtual int NumberOfColumns {
3304 get {
3305 return 2;
3306 }
3307 }
3308
3309
3310 /// <summary>
3311 /// Logical size of this instance in bytes.
3312 /// </summary>
3313 public virtual int Size {
3314 get {
3315 return LogicalSize;
3316 }
3317 }
3318
3319
3320 /// <summary>
3321 /// </summary>
3322 public virtual MDTable Table {
3323 get {
3324 return table;
3325 }
3326 }
3327
3328
3329 /// <summary>
3330 /// Logical size of this type of row in bytes.
3331 /// </summary>
3332 unsafe public static int LogicalSize {
3333 get {
3334 return sizeof (uint) + sizeof (uint);
3335 }
3336 }
3337
3338
3339 /// <summary>
3340 /// Fills the row from the array of bytes.
3341 /// </summary>
3342 unsafe public void FromRawData(byte [] buff, int offs)
3343 {
3344 if (buff == null) throw new Exception("buff == null");
3345 if (offs + Size > buff.Length) throw new Exception("bounds");
3346
3347
3348 this.Token = LEBitConverter.ToUInt32(buff, offs);
3349 offs += sizeof (uint);
3350 this.FuncCode = LEBitConverter.ToUInt32(buff, offs);
3351
3352 }
3353
3354
3355
3356 /// <summary>
3357 /// </summary>
3358 public void Dump(TextWriter writer) {
3359 string dump = String.Format(
3360 "Token : {0}" + Environment.NewLine +
3361 "FuncCode : {1}" + Environment.NewLine,
3362 this.Token,
3363 this.FuncCode
3364 );
3365 writer.WriteLine(dump);
3366 }
3367
3368
3369 /// <summary>
3370 /// </summary>
3371 public override string ToString()
3372 {
3373 StringWriter sw = new StringWriter();
3374 Dump(sw);
3375 return sw.ToString();
3376 }
3377
3378 }
3379
3380
3381
3382 /// <summary>
3383 /// Represents row in ENCMap table.
3384 /// </summary>
3385 /// <remarks>
3386 ///
3387 /// </remarks>
3388 public class ENCMapRow : Row {
3389
3390 private MDTable table;
3391
3392
3393 public uint Token;
3394
3395 public ENCMapRow()
3396 {
3397 }
3398
3399 public ENCMapRow(MDTable parent)
3400 {
3401 table = parent;
3402 }
3403
3404
3405 /// <summary>
3406 /// Row in ENCMap table has 1 columns.
3407 /// </summary>
3408 public virtual int NumberOfColumns {
3409 get {
3410 return 1;
3411 }
3412 }
3413
3414
3415 /// <summary>
3416 /// Logical size of this instance in bytes.
3417 /// </summary>
3418 public virtual int Size {
3419 get {
3420 return LogicalSize;
3421 }
3422 }
3423
3424
3425 /// <summary>
3426 /// </summary>
3427 public virtual MDTable Table {
3428 get {
3429 return table;
3430 }
3431 }
3432
3433
3434 /// <summary>
3435 /// Logical size of this type of row in bytes.
3436 /// </summary>
3437 unsafe public static int LogicalSize {
3438 get {
3439 return sizeof (uint);
3440 }
3441 }
3442
3443
3444 /// <summary>
3445 /// Fills the row from the array of bytes.
3446 /// </summary>
3447 unsafe public void FromRawData(byte [] buff, int offs)
3448 {
3449 if (buff == null) throw new Exception("buff == null");
3450 if (offs + Size > buff.Length) throw new Exception("bounds");
3451
3452
3453 this.Token = LEBitConverter.ToUInt32(buff, offs);
3454
3455 }
3456
3457
3458
3459 /// <summary>
3460 /// </summary>
3461 public void Dump(TextWriter writer) {
3462 string dump = String.Format(
3463 "Token : {0}" + Environment.NewLine,
3464 this.Token
3465 );
3466 writer.WriteLine(dump);
3467 }
3468
3469
3470 /// <summary>
3471 /// </summary>
3472 public override string ToString()
3473 {
3474 StringWriter sw = new StringWriter();
3475 Dump(sw);
3476 return sw.ToString();
3477 }
3478
3479 }
3480
3481
3482
3483 /// <summary>
3484 /// Represents row in Assembly table.
3485 /// </summary>
3486 /// <remarks>
3487 /// See Partition II, Metadata; section 21.2
3488 /// </remarks>
3489 public class AssemblyRow : Row {
3490
3491 private MDTable table;
3492
3493
3494 public System.Configuration.Assemblies.AssemblyHashAlgorithm HashAlgId;
3495 public short MajorVersion;
3496 public short MinorVersion;
3497 public short BuildNumber;
3498 public short RevisionNumber;
3499 public AssemblyFlags Flags;
3500 public int PublicKey;
3501 public int Name;
3502 public int Culture;
3503
3504 public AssemblyRow()
3505 {
3506 }
3507
3508 public AssemblyRow(MDTable parent)
3509 {
3510 table = parent;
3511 }
3512
3513
3514 /// <summary>
3515 /// Row in Assembly table has 9 columns.
3516 /// </summary>
3517 public virtual int NumberOfColumns {
3518 get {
3519 return 9;
3520 }
3521 }
3522
3523
3524 /// <summary>
3525 /// Logical size of this instance in bytes.
3526 /// </summary>
3527 public virtual int Size {
3528 get {
3529 return LogicalSize;
3530 }
3531 }
3532
3533
3534 /// <summary>
3535 /// </summary>
3536 public virtual MDTable Table {
3537 get {
3538 return table;
3539 }
3540 }
3541
3542
3543 /// <summary>
3544 /// Logical size of this type of row in bytes.
3545 /// </summary>
3546 unsafe public static int LogicalSize {
3547 get {
3548 return sizeof (int) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (uint) + 4 + 4 + 4;
3549 }
3550 }
3551
3552
3553 /// <summary>
3554 /// Fills the row from the array of bytes.
3555 /// </summary>
3556 unsafe public void FromRawData(byte [] buff, int offs)
3557 {
3558 if (buff == null) throw new Exception("buff == null");
3559 if (offs + Size > buff.Length) throw new Exception("bounds");
3560
3561
3562 this.HashAlgId = (System.Configuration.Assemblies.AssemblyHashAlgorithm) LEBitConverter.ToInt32(buff, offs);
3563 offs += sizeof (int);
3564 this.MajorVersion = LEBitConverter.ToInt16(buff, offs);
3565 offs += sizeof (short);
3566 this.MinorVersion = LEBitConverter.ToInt16(buff, offs);
3567 offs += sizeof (short);
3568 this.BuildNumber = LEBitConverter.ToInt16(buff, offs);
3569 offs += sizeof (short);
3570 this.RevisionNumber = LEBitConverter.ToInt16(buff, offs);
3571 offs += sizeof (short);
3572 this.Flags = (AssemblyFlags) LEBitConverter.ToUInt32(buff, offs);
3573 offs += sizeof (uint);
3574 this.PublicKey = LEBitConverter.ToInt32(buff, offs);
3575 offs += 4;
3576 this.Name = LEBitConverter.ToInt32(buff, offs);
3577 offs += 4;
3578 this.Culture = LEBitConverter.ToInt32(buff, offs);
3579
3580 }
3581
3582
3583
3584 /// <summary>
3585 /// </summary>
3586 public void Dump(TextWriter writer) {
3587 string dump = String.Format(
3588 "HashAlgId : {0}" + Environment.NewLine +
3589 "MajorVersion : {1}" + Environment.NewLine +
3590 "MinorVersion : {2}" + Environment.NewLine +
3591 "BuildNumber : {3}" + Environment.NewLine +
3592 "RevisionNumber : {4}" + Environment.NewLine +
3593 "Flags : {5}" + Environment.NewLine +
3594 "PublicKey : {6}" + Environment.NewLine +
3595 "Name : {7}" + Environment.NewLine +
3596 "Culture : {8}" + Environment.NewLine,
3597 this.HashAlgId,
3598 this.MajorVersion,
3599 this.MinorVersion,
3600 this.BuildNumber,
3601 this.RevisionNumber,
3602 (int)this.Flags,
3603 "#Blob[" + PublicKey.ToString() + "]",
3604 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
3605 (Table == null) ? Culture.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Culture] + "\" (#Strings[0x" + Culture.ToString("X") + "])"
3606 );
3607 writer.WriteLine(dump);
3608 }
3609
3610
3611 /// <summary>
3612 /// </summary>
3613 public override string ToString()
3614 {
3615 StringWriter sw = new StringWriter();
3616 Dump(sw);
3617 return sw.ToString();
3618 }
3619
3620 }
3621
3622
3623
3624 /// <summary>
3625 /// Represents row in AssemblyProcessor table.
3626 /// </summary>
3627 /// <remarks>
3628 /// See Partition II, Metadata; section 21.4
3629 /// </remarks>
3630 public class AssemblyProcessorRow : Row {
3631
3632 private MDTable table;
3633
3634
3635 public int Processor;
3636
3637 public AssemblyProcessorRow()
3638 {
3639 }
3640
3641 public AssemblyProcessorRow(MDTable parent)
3642 {
3643 table = parent;
3644 }
3645
3646
3647 /// <summary>
3648 /// Row in AssemblyProcessor table has 1 columns.
3649 /// </summary>
3650 public virtual int NumberOfColumns {
3651 get {
3652 return 1;
3653 }
3654 }
3655
3656
3657 /// <summary>
3658 /// Logical size of this instance in bytes.
3659 /// </summary>
3660 public virtual int Size {
3661 get {
3662 return LogicalSize;
3663 }
3664 }
3665
3666
3667 /// <summary>
3668 /// </summary>
3669 public virtual MDTable Table {
3670 get {
3671 return table;
3672 }
3673 }
3674
3675
3676 /// <summary>
3677 /// Logical size of this type of row in bytes.
3678 /// </summary>
3679 unsafe public static int LogicalSize {
3680 get {
3681 return sizeof (int);
3682 }
3683 }
3684
3685
3686 /// <summary>
3687 /// Fills the row from the array of bytes.
3688 /// </summary>
3689 unsafe public void FromRawData(byte [] buff, int offs)
3690 {
3691 if (buff == null) throw new Exception("buff == null");
3692 if (offs + Size > buff.Length) throw new Exception("bounds");
3693
3694
3695 this.Processor = LEBitConverter.ToInt32(buff, offs);
3696
3697 }
3698
3699
3700
3701 /// <summary>
3702 /// </summary>
3703 public void Dump(TextWriter writer) {
3704 string dump = String.Format(
3705 "Processor : {0}" + Environment.NewLine,
3706 this.Processor
3707 );
3708 writer.WriteLine(dump);
3709 }
3710
3711
3712 /// <summary>
3713 /// </summary>
3714 public override string ToString()
3715 {
3716 StringWriter sw = new StringWriter();
3717 Dump(sw);
3718 return sw.ToString();
3719 }
3720
3721 }
3722
3723
3724
3725 /// <summary>
3726 /// Represents row in AssemblyOS table.
3727 /// </summary>
3728 /// <remarks>
3729 /// See Partition II, Metadata; section 21.3
3730 /// </remarks>
3731 public class AssemblyOSRow : Row {
3732
3733 private MDTable table;
3734
3735
3736 public int OSPlatformID;
3737 public int OSMajorVersion;
3738 public int OSMinorVersion;
3739
3740 public AssemblyOSRow()
3741 {
3742 }
3743
3744 public AssemblyOSRow(MDTable parent)
3745 {
3746 table = parent;
3747 }
3748
3749
3750 /// <summary>
3751 /// Row in AssemblyOS table has 3 columns.
3752 /// </summary>
3753 public virtual int NumberOfColumns {
3754 get {
3755 return 3;
3756 }
3757 }
3758
3759
3760 /// <summary>
3761 /// Logical size of this instance in bytes.
3762 /// </summary>
3763 public virtual int Size {
3764 get {
3765 return LogicalSize;
3766 }
3767 }
3768
3769
3770 /// <summary>
3771 /// </summary>
3772 public virtual MDTable Table {
3773 get {
3774 return table;
3775 }
3776 }
3777
3778
3779 /// <summary>
3780 /// Logical size of this type of row in bytes.
3781 /// </summary>
3782 unsafe public static int LogicalSize {
3783 get {
3784 return sizeof (int) + sizeof (int) + sizeof (int);
3785 }
3786 }
3787
3788
3789 /// <summary>
3790 /// Fills the row from the array of bytes.
3791 /// </summary>
3792 unsafe public void FromRawData(byte [] buff, int offs)
3793 {
3794 if (buff == null) throw new Exception("buff == null");
3795 if (offs + Size > buff.Length) throw new Exception("bounds");
3796
3797
3798 this.OSPlatformID = LEBitConverter.ToInt32(buff, offs);
3799 offs += sizeof (int);
3800 this.OSMajorVersion = LEBitConverter.ToInt32(buff, offs);
3801 offs += sizeof (int);
3802 this.OSMinorVersion = LEBitConverter.ToInt32(buff, offs);
3803
3804 }
3805
3806
3807
3808 /// <summary>
3809 /// </summary>
3810 public void Dump(TextWriter writer) {
3811 string dump = String.Format(
3812 "OSPlatformID : {0}" + Environment.NewLine +
3813 "OSMajorVersion : {1}" + Environment.NewLine +
3814 "OSMinorVersion : {2}" + Environment.NewLine,
3815 this.OSPlatformID,
3816 this.OSMajorVersion,
3817 this.OSMinorVersion
3818 );
3819 writer.WriteLine(dump);
3820 }
3821
3822
3823 /// <summary>
3824 /// </summary>
3825 public override string ToString()
3826 {
3827 StringWriter sw = new StringWriter();
3828 Dump(sw);
3829 return sw.ToString();
3830 }
3831
3832 }
3833
3834
3835
3836 /// <summary>
3837 /// Represents row in AssemblyRef table.
3838 /// </summary>
3839 /// <remarks>
3840 /// See Partition II, Metadata; section 21.5
3841 /// </remarks>
3842 public class AssemblyRefRow : Row {
3843
3844 private MDTable table;
3845
3846
3847 public short MajorVersion;
3848 public short MinorVersion;
3849 public short BuildNumber;
3850 public short RevisionNumber;
3851 public AssemblyFlags Flags;
3852 public int PublicKeyOrToken;
3853 public int Name;
3854 public int Culture;
3855 public int HashValue;
3856
3857 public AssemblyRefRow()
3858 {
3859 }
3860
3861 public AssemblyRefRow(MDTable parent)
3862 {
3863 table = parent;
3864 }
3865
3866
3867 /// <summary>
3868 /// Row in AssemblyRef table has 9 columns.
3869 /// </summary>
3870 public virtual int NumberOfColumns {
3871 get {
3872 return 9;
3873 }
3874 }
3875
3876
3877 /// <summary>
3878 /// Logical size of this instance in bytes.
3879 /// </summary>
3880 public virtual int Size {
3881 get {
3882 return LogicalSize;
3883 }
3884 }
3885
3886
3887 /// <summary>
3888 /// </summary>
3889 public virtual MDTable Table {
3890 get {
3891 return table;
3892 }
3893 }
3894
3895
3896 /// <summary>
3897 /// Logical size of this type of row in bytes.
3898 /// </summary>
3899 unsafe public static int LogicalSize {
3900 get {
3901 return sizeof (short) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (uint) + 4 + 4 + 4 + 4;
3902 }
3903 }
3904
3905
3906 /// <summary>
3907 /// Fills the row from the array of bytes.
3908 /// </summary>
3909 unsafe public void FromRawData(byte [] buff, int offs)
3910 {
3911 if (buff == null) throw new Exception("buff == null");
3912 if (offs + Size > buff.Length) throw new Exception("bounds");
3913
3914
3915 this.MajorVersion = LEBitConverter.ToInt16(buff, offs);
3916 offs += sizeof (short);
3917 this.MinorVersion = LEBitConverter.ToInt16(buff, offs);
3918 offs += sizeof (short);
3919 this.BuildNumber = LEBitConverter.ToInt16(buff, offs);
3920 offs += sizeof (short);
3921 this.RevisionNumber = LEBitConverter.ToInt16(buff, offs);
3922 offs += sizeof (short);
3923 this.Flags = (AssemblyFlags) LEBitConverter.ToUInt32(buff, offs);
3924 offs += sizeof (uint);
3925 this.PublicKeyOrToken = LEBitConverter.ToInt32(buff, offs);
3926 offs += 4;
3927 this.Name = LEBitConverter.ToInt32(buff, offs);
3928 offs += 4;
3929 this.Culture = LEBitConverter.ToInt32(buff, offs);
3930 offs += 4;
3931 this.HashValue = LEBitConverter.ToInt32(buff, offs);
3932
3933 }
3934
3935
3936
3937 /// <summary>
3938 /// </summary>
3939 public void Dump(TextWriter writer) {
3940 string dump = String.Format(
3941 "MajorVersion : {0}" + Environment.NewLine +
3942 "MinorVersion : {1}" + Environment.NewLine +
3943 "BuildNumber : {2}" + Environment.NewLine +
3944 "RevisionNumber : {3}" + Environment.NewLine +
3945 "Flags : {4}" + Environment.NewLine +
3946 "PublicKeyOrToken : {5}" + Environment.NewLine +
3947 "Name : {6}" + Environment.NewLine +
3948 "Culture : {7}" + Environment.NewLine +
3949 "HashValue : {8}" + Environment.NewLine,
3950 this.MajorVersion,
3951 this.MinorVersion,
3952 this.BuildNumber,
3953 this.RevisionNumber,
3954 (int)this.Flags,
3955 "#Blob[" + PublicKeyOrToken.ToString() + "]",
3956 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
3957 (Table == null) ? Culture.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Culture] + "\" (#Strings[0x" + Culture.ToString("X") + "])",
3958 "#Blob[" + HashValue.ToString() + "]"
3959 );
3960 writer.WriteLine(dump);
3961 }
3962
3963
3964 /// <summary>
3965 /// </summary>
3966 public override string ToString()
3967 {
3968 StringWriter sw = new StringWriter();
3969 Dump(sw);
3970 return sw.ToString();
3971 }
3972
3973 }
3974
3975
3976
3977 /// <summary>
3978 /// Represents row in AssemblyRefProcessor table.
3979 /// </summary>
3980 /// <remarks>
3981 /// See Partition II, Metadata; section 21.7
3982 /// </remarks>
3983 public class AssemblyRefProcessorRow : Row {
3984
3985 private MDTable table;
3986
3987
3988 public int Processor;
3989 public int AssemblyRef;
3990
3991 public AssemblyRefProcessorRow()
3992 {
3993 }
3994
3995 public AssemblyRefProcessorRow(MDTable parent)
3996 {
3997 table = parent;
3998 }
3999
4000
4001 /// <summary>
4002 /// Row in AssemblyRefProcessor table has 2 columns.
4003 /// </summary>
4004 public virtual int NumberOfColumns {
4005 get {
4006 return 2;
4007 }
4008 }
4009
4010
4011 /// <summary>
4012 /// Logical size of this instance in bytes.
4013 /// </summary>
4014 public virtual int Size {
4015 get {
4016 return LogicalSize;
4017 }
4018 }
4019
4020
4021 /// <summary>
4022 /// </summary>
4023 public virtual MDTable Table {
4024 get {
4025 return table;
4026 }
4027 }
4028
4029
4030 /// <summary>
4031 /// Logical size of this type of row in bytes.
4032 /// </summary>
4033 unsafe public static int LogicalSize {
4034 get {
4035 return sizeof (int) + 4;
4036 }
4037 }
4038
4039
4040 /// <summary>
4041 /// Fills the row from the array of bytes.
4042 /// </summary>
4043 unsafe public void FromRawData(byte [] buff, int offs)
4044 {
4045 if (buff == null) throw new Exception("buff == null");
4046 if (offs + Size > buff.Length) throw new Exception("bounds");
4047
4048
4049 this.Processor = LEBitConverter.ToInt32(buff, offs);
4050 offs += sizeof (int);
4051 this.AssemblyRef = LEBitConverter.ToInt32(buff, offs);
4052
4053 }
4054
4055
4056
4057 /// <summary>
4058 /// </summary>
4059 public void Dump(TextWriter writer) {
4060 string dump = String.Format(
4061 "Processor : {0}" + Environment.NewLine +
4062 "AssemblyRef : {1}" + Environment.NewLine,
4063 this.Processor,
4064 "AssemblyRef[" + AssemblyRef.ToString() + "]"
4065 );
4066 writer.WriteLine(dump);
4067 }
4068
4069
4070 /// <summary>
4071 /// </summary>
4072 public override string ToString()
4073 {
4074 StringWriter sw = new StringWriter();
4075 Dump(sw);
4076 return sw.ToString();
4077 }
4078
4079 }
4080
4081
4082
4083 /// <summary>
4084 /// Represents row in AssemblyRefOS table.
4085 /// </summary>
4086 /// <remarks>
4087 /// See Partition II, Metadata; section 21.6
4088 /// </remarks>
4089 public class AssemblyRefOSRow : Row {
4090
4091 private MDTable table;
4092
4093
4094 public int OSPlatformID;
4095 public int OSMajorVersion;
4096 public int OSMinorVersion;
4097 public int AssemblyRef;
4098
4099 public AssemblyRefOSRow()
4100 {
4101 }
4102
4103 public AssemblyRefOSRow(MDTable parent)
4104 {
4105 table = parent;
4106 }
4107
4108
4109 /// <summary>
4110 /// Row in AssemblyRefOS table has 4 columns.
4111 /// </summary>
4112 public virtual int NumberOfColumns {
4113 get {
4114 return 4;
4115 }
4116 }
4117
4118
4119 /// <summary>
4120 /// Logical size of this instance in bytes.
4121 /// </summary>
4122 public virtual int Size {
4123 get {
4124 return LogicalSize;
4125 }
4126 }
4127
4128
4129 /// <summary>
4130 /// </summary>
4131 public virtual MDTable Table {
4132 get {
4133 return table;
4134 }
4135 }
4136
4137
4138 /// <summary>
4139 /// Logical size of this type of row in bytes.
4140 /// </summary>
4141 unsafe public static int LogicalSize {
4142 get {
4143 return sizeof (int) + sizeof (int) + sizeof (int) + 4;
4144 }
4145 }
4146
4147
4148 /// <summary>
4149 /// Fills the row from the array of bytes.
4150 /// </summary>
4151 unsafe public void FromRawData(byte [] buff, int offs)
4152 {
4153 if (buff == null) throw new Exception("buff == null");
4154 if (offs + Size > buff.Length) throw new Exception("bounds");
4155
4156
4157 this.OSPlatformID = LEBitConverter.ToInt32(buff, offs);
4158 offs += sizeof (int);
4159 this.OSMajorVersion = LEBitConverter.ToInt32(buff, offs);
4160 offs += sizeof (int);
4161 this.OSMinorVersion = LEBitConverter.ToInt32(buff, offs);
4162 offs += sizeof (int);
4163 this.AssemblyRef = LEBitConverter.ToInt32(buff, offs);
4164
4165 }
4166
4167
4168
4169 /// <summary>
4170 /// </summary>
4171 public void Dump(TextWriter writer) {
4172 string dump = String.Format(
4173 "OSPlatformID : {0}" + Environment.NewLine +
4174 "OSMajorVersion : {1}" + Environment.NewLine +
4175 "OSMinorVersion : {2}" + Environment.NewLine +
4176 "AssemblyRef : {3}" + Environment.NewLine,
4177 this.OSPlatformID,
4178 this.OSMajorVersion,
4179 this.OSMinorVersion,
4180 "AssemblyRef[" + AssemblyRef.ToString() + "]"
4181 );
4182 writer.WriteLine(dump);
4183 }
4184
4185
4186 /// <summary>
4187 /// </summary>
4188 public override string ToString()
4189 {
4190 StringWriter sw = new StringWriter();
4191 Dump(sw);
4192 return sw.ToString();
4193 }
4194
4195 }
4196
4197
4198
4199 /// <summary>
4200 /// Represents row in File table.
4201 /// </summary>
4202 /// <remarks>
4203 /// See Partition II, Metadata; section 21.19
4204 /// </remarks>
4205 public class FileRow : Row {
4206
4207 private MDTable table;
4208
4209
4210 public System.IO.FileAttributes Flags;
4211 public int Name;
4212 public int HashValue;
4213
4214 public FileRow()
4215 {
4216 }
4217
4218 public FileRow(MDTable parent)
4219 {
4220 table = parent;
4221 }
4222
4223
4224 /// <summary>
4225 /// Row in File table has 3 columns.
4226 /// </summary>
4227 public virtual int NumberOfColumns {
4228 get {
4229 return 3;
4230 }
4231 }
4232
4233
4234 /// <summary>
4235 /// Logical size of this instance in bytes.
4236 /// </summary>
4237 public virtual int Size {
4238 get {
4239 return LogicalSize;
4240 }
4241 }
4242
4243
4244 /// <summary>
4245 /// </summary>
4246 public virtual MDTable Table {
4247 get {
4248 return table;
4249 }
4250 }
4251
4252
4253 /// <summary>
4254 /// Logical size of this type of row in bytes.
4255 /// </summary>
4256 unsafe public static int LogicalSize {
4257 get {
4258 return sizeof (uint) + 4 + 4;
4259 }
4260 }
4261
4262
4263 /// <summary>
4264 /// Fills the row from the array of bytes.
4265 /// </summary>
4266 unsafe public void FromRawData(byte [] buff, int offs)
4267 {
4268 if (buff == null) throw new Exception("buff == null");
4269 if (offs + Size > buff.Length) throw new Exception("bounds");
4270
4271
4272 this.Flags = (System.IO.FileAttributes) LEBitConverter.ToUInt32(buff, offs);
4273 offs += sizeof (uint);
4274 this.Name = LEBitConverter.ToInt32(buff, offs);
4275 offs += 4;
4276 this.HashValue = LEBitConverter.ToInt32(buff, offs);
4277
4278 }
4279
4280
4281
4282 /// <summary>
4283 /// </summary>
4284 public void Dump(TextWriter writer) {
4285 string dump = String.Format(
4286 "Flags : {0}" + Environment.NewLine +
4287 "Name : {1}" + Environment.NewLine +
4288 "HashValue : {2}" + Environment.NewLine,
4289 (int)this.Flags,
4290 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
4291 "#Blob[" + HashValue.ToString() + "]"
4292 );
4293 writer.WriteLine(dump);
4294 }
4295
4296
4297 /// <summary>
4298 /// </summary>
4299 public override string ToString()
4300 {
4301 StringWriter sw = new StringWriter();
4302 Dump(sw);
4303 return sw.ToString();
4304 }
4305
4306 }
4307
4308
4309
4310 /// <summary>
4311 /// Represents row in ExportedType table.
4312 /// </summary>
4313 /// <remarks>
4314 /// See Partition II, Metadata; section 21.14
4315 /// </remarks>
4316 public class ExportedTypeRow : Row {
4317
4318 private MDTable table;
4319
4320
4321 public System.Reflection.TypeAttributes Flags;
4322 public int TypeDefId;
4323 public int TypeName;
4324 public int TypeNamespace;
4325 public MDToken Implementation;
4326
4327 public ExportedTypeRow()
4328 {
4329 }
4330
4331 public ExportedTypeRow(MDTable parent)
4332 {
4333 table = parent;
4334 }
4335
4336
4337 /// <summary>
4338 /// Row in ExportedType table has 5 columns.
4339 /// </summary>
4340 public virtual int NumberOfColumns {
4341 get {
4342 return 5;
4343 }
4344 }
4345
4346
4347 /// <summary>
4348 /// Logical size of this instance in bytes.
4349 /// </summary>
4350 public virtual int Size {
4351 get {
4352 return LogicalSize;
4353 }
4354 }
4355
4356
4357 /// <summary>
4358 /// </summary>
4359 public virtual MDTable Table {
4360 get {
4361 return table;
4362 }
4363 }
4364
4365
4366 /// <summary>
4367 /// Logical size of this type of row in bytes.
4368 /// </summary>
4369 unsafe public static int LogicalSize {
4370 get {
4371 return sizeof (uint) + 4 + 4 + 4 + 4;
4372 }
4373 }
4374
4375
4376 /// <summary>
4377 /// Fills the row from the array of bytes.
4378 /// </summary>
4379 unsafe public void FromRawData(byte [] buff, int offs)
4380 {
4381 if (buff == null) throw new Exception("buff == null");
4382 if (offs + Size > buff.Length) throw new Exception("bounds");
4383
4384
4385 this.Flags = (System.Reflection.TypeAttributes) LEBitConverter.ToUInt32(buff, offs);
4386 offs += sizeof (uint);
4387 this.TypeDefId = LEBitConverter.ToInt32(buff, offs);
4388 offs += 4;
4389 this.TypeName = LEBitConverter.ToInt32(buff, offs);
4390 offs += 4;
4391 this.TypeNamespace = LEBitConverter.ToInt32(buff, offs);
4392 offs += 4;
4393 this.Implementation = TabsDecoder.DecodeToken(CodedTokenId.Implementation, LEBitConverter.ToInt32(buff, offs));
4394
4395 }
4396
4397
4398
4399 /// <summary>
4400 /// </summary>
4401 public void Dump(TextWriter writer) {
4402 string dump = String.Format(
4403 "Flags : {0}" + Environment.NewLine +
4404 "TypeDefId : {1}" + Environment.NewLine +
4405 "TypeName : {2}" + Environment.NewLine +
4406 "TypeNamespace : {3}" + Environment.NewLine +
4407 "Implementation : {4}" + Environment.NewLine,
4408 (int)this.Flags,
4409 "TypeDef[" + TypeDefId.ToString() + "]",
4410 (Table == null) ? TypeName.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [TypeName] + "\" (#Strings[0x" + TypeName.ToString("X") + "])",
4411 (Table == null) ? TypeNamespace.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [TypeNamespace] + "\" (#Strings[0x" + TypeNamespace.ToString("X") + "])",
4412 this.Implementation
4413 );
4414 writer.WriteLine(dump);
4415 }
4416
4417
4418 /// <summary>
4419 /// </summary>
4420 public override string ToString()
4421 {
4422 StringWriter sw = new StringWriter();
4423 Dump(sw);
4424 return sw.ToString();
4425 }
4426
4427 }
4428
4429
4430
4431 /// <summary>
4432 /// Represents row in ManifestResource table.
4433 /// </summary>
4434 /// <remarks>
4435 /// See Partition II, Metadata; section 21.22
4436 /// </remarks>
4437 public class ManifestResourceRow : Row {
4438
4439 private MDTable table;
4440
4441
4442 public int Offset;
4443 public ManifestResourceAttributes Flags;
4444 public int Name;
4445 public MDToken Implementation;
4446
4447 public ManifestResourceRow()
4448 {
4449 }
4450
4451 public ManifestResourceRow(MDTable parent)
4452 {
4453 table = parent;
4454 }
4455
4456
4457 /// <summary>
4458 /// Row in ManifestResource table has 4 columns.
4459 /// </summary>
4460 public virtual int NumberOfColumns {
4461 get {
4462 return 4;
4463 }
4464 }
4465
4466
4467 /// <summary>
4468 /// Logical size of this instance in bytes.
4469 /// </summary>
4470 public virtual int Size {
4471 get {
4472 return LogicalSize;
4473 }
4474 }
4475
4476
4477 /// <summary>
4478 /// </summary>
4479 public virtual MDTable Table {
4480 get {
4481 return table;
4482 }
4483 }
4484
4485
4486 /// <summary>
4487 /// Logical size of this type of row in bytes.
4488 /// </summary>
4489 unsafe public static int LogicalSize {
4490 get {
4491 return sizeof (int) + sizeof (uint) + 4 + 4;
4492 }
4493 }
4494
4495
4496 /// <summary>
4497 /// Fills the row from the array of bytes.
4498 /// </summary>
4499 unsafe public void FromRawData(byte [] buff, int offs)
4500 {
4501 if (buff == null) throw new Exception("buff == null");
4502 if (offs + Size > buff.Length) throw new Exception("bounds");
4503
4504
4505 this.Offset = LEBitConverter.ToInt32(buff, offs);
4506 offs += sizeof (int);
4507 this.Flags = (ManifestResourceAttributes) LEBitConverter.ToUInt32(buff, offs);
4508 offs += sizeof (uint);
4509 this.Name = LEBitConverter.ToInt32(buff, offs);
4510 offs += 4;
4511 this.Implementation = TabsDecoder.DecodeToken(CodedTokenId.Implementation, LEBitConverter.ToInt32(buff, offs));
4512
4513 }
4514
4515
4516
4517 /// <summary>
4518 /// </summary>
4519 public void Dump(TextWriter writer) {
4520 string dump = String.Format(
4521 "Offset : {0}" + Environment.NewLine +
4522 "Flags : {1}" + Environment.NewLine +
4523 "Name : {2}" + Environment.NewLine +
4524 "Implementation : {3}" + Environment.NewLine,
4525 this.Offset,
4526 (int)this.Flags,
4527 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])",
4528 this.Implementation
4529 );
4530 writer.WriteLine(dump);
4531 }
4532
4533
4534 /// <summary>
4535 /// </summary>
4536 public override string ToString()
4537 {
4538 StringWriter sw = new StringWriter();
4539 Dump(sw);
4540 return sw.ToString();
4541 }
4542
4543 }
4544
4545
4546
4547 /// <summary>
4548 /// Represents row in NestedClass table.
4549 /// </summary>
4550 /// <remarks>
4551 /// See Partition II, Metadata; section 21.29
4552 /// </remarks>
4553 public class NestedClassRow : Row {
4554
4555 private MDTable table;
4556
4557
4558 public int NestedClass;
4559 public int EnclosingClass;
4560
4561 public NestedClassRow()
4562 {
4563 }
4564
4565 public NestedClassRow(MDTable parent)
4566 {
4567 table = parent;
4568 }
4569
4570
4571 /// <summary>
4572 /// Row in NestedClass table has 2 columns.
4573 /// </summary>
4574 public virtual int NumberOfColumns {
4575 get {
4576 return 2;
4577 }
4578 }
4579
4580
4581 /// <summary>
4582 /// Logical size of this instance in bytes.
4583 /// </summary>
4584 public virtual int Size {
4585 get {
4586 return LogicalSize;
4587 }
4588 }
4589
4590
4591 /// <summary>
4592 /// </summary>
4593 public virtual MDTable Table {
4594 get {
4595 return table;
4596 }
4597 }
4598
4599
4600 /// <summary>
4601 /// Logical size of this type of row in bytes.
4602 /// </summary>
4603 unsafe public static int LogicalSize {
4604 get {
4605 return 4 + 4;
4606 }
4607 }
4608
4609
4610 /// <summary>
4611 /// Fills the row from the array of bytes.
4612 /// </summary>
4613 unsafe public void FromRawData(byte [] buff, int offs)
4614 {
4615 if (buff == null) throw new Exception("buff == null");
4616 if (offs + Size > buff.Length) throw new Exception("bounds");
4617
4618
4619 this.NestedClass = LEBitConverter.ToInt32(buff, offs);
4620 offs += 4;
4621 this.EnclosingClass = LEBitConverter.ToInt32(buff, offs);
4622
4623 }
4624
4625
4626
4627 /// <summary>
4628 /// </summary>
4629 public void Dump(TextWriter writer) {
4630 string dump = String.Format(
4631 "NestedClass : {0}" + Environment.NewLine +
4632 "EnclosingClass : {1}" + Environment.NewLine,
4633 "TypeDef[" + NestedClass.ToString() + "]",
4634 "TypeDef[" + EnclosingClass.ToString() + "]"
4635 );
4636 writer.WriteLine(dump);
4637 }
4638
4639
4640 /// <summary>
4641 /// </summary>
4642 public override string ToString()
4643 {
4644 StringWriter sw = new StringWriter();
4645 Dump(sw);
4646 return sw.ToString();
4647 }
4648
4649 }
4650
4651
4652
4653 /// <summary>
4654 /// Represents row in TypeTyPar table.
4655 /// </summary>
4656 /// <remarks>
4657 ///
4658 /// </remarks>
4659 public class TypeTyParRow : Row {
4660
4661 private MDTable table;
4662
4663
4664 public ushort Number;
4665 public int Class;
4666 public MDToken Bound;
4667 public int Name;
4668
4669 public TypeTyParRow()
4670 {
4671 }
4672
4673 public TypeTyParRow(MDTable parent)
4674 {
4675 table = parent;
4676 }
4677
4678
4679 /// <summary>
4680 /// Row in TypeTyPar table has 4 columns.
4681 /// </summary>
4682 public virtual int NumberOfColumns {
4683 get {
4684 return 4;
4685 }
4686 }
4687
4688
4689 /// <summary>
4690 /// Logical size of this instance in bytes.
4691 /// </summary>
4692 public virtual int Size {
4693 get {
4694 return LogicalSize;
4695 }
4696 }
4697
4698
4699 /// <summary>
4700 /// </summary>
4701 public virtual MDTable Table {
4702 get {
4703 return table;
4704 }
4705 }
4706
4707
4708 /// <summary>
4709 /// Logical size of this type of row in bytes.
4710 /// </summary>
4711 unsafe public static int LogicalSize {
4712 get {
4713 return sizeof (ushort) + 4 + 4 + 4;
4714 }
4715 }
4716
4717
4718 /// <summary>
4719 /// Fills the row from the array of bytes.
4720 /// </summary>
4721 unsafe public void FromRawData(byte [] buff, int offs)
4722 {
4723 if (buff == null) throw new Exception("buff == null");
4724 if (offs + Size > buff.Length) throw new Exception("bounds");
4725
4726
4727 this.Number = LEBitConverter.ToUInt16(buff, offs);
4728 offs += sizeof (ushort);
4729 this.Class = LEBitConverter.ToInt32(buff, offs);
4730 offs += 4;
4731 this.Bound = TabsDecoder.DecodeToken(CodedTokenId.TypeDefOrRef, LEBitConverter.ToInt32(buff, offs));
4732 offs += 4;
4733 this.Name = LEBitConverter.ToInt32(buff, offs);
4734
4735 }
4736
4737
4738
4739 /// <summary>
4740 /// </summary>
4741 public void Dump(TextWriter writer) {
4742 string dump = String.Format(
4743 "Number : {0}" + Environment.NewLine +
4744 "Class : {1}" + Environment.NewLine +
4745 "Bound : {2}" + Environment.NewLine +
4746 "Name : {3}" + Environment.NewLine,
4747 this.Number,
4748 "TypeDef[" + Class.ToString() + "]",
4749 this.Bound,
4750 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])"
4751 );
4752 writer.WriteLine(dump);
4753 }
4754
4755
4756 /// <summary>
4757 /// </summary>
4758 public override string ToString()
4759 {
4760 StringWriter sw = new StringWriter();
4761 Dump(sw);
4762 return sw.ToString();
4763 }
4764
4765 }
4766
4767
4768
4769 /// <summary>
4770 /// Represents row in MethodTyPar table.
4771 /// </summary>
4772 /// <remarks>
4773 ///
4774 /// </remarks>
4775 public class MethodTyParRow : Row {
4776
4777 private MDTable table;
4778
4779
4780 public ushort Number;
4781 public int Method;
4782 public MDToken Bound;
4783 public int Name;
4784
4785 public MethodTyParRow()
4786 {
4787 }
4788
4789 public MethodTyParRow(MDTable parent)
4790 {
4791 table = parent;
4792 }
4793
4794
4795 /// <summary>
4796 /// Row in MethodTyPar table has 4 columns.
4797 /// </summary>
4798 public virtual int NumberOfColumns {
4799 get {
4800 return 4;
4801 }
4802 }
4803
4804
4805 /// <summary>
4806 /// Logical size of this instance in bytes.
4807 /// </summary>
4808 public virtual int Size {
4809 get {
4810 return LogicalSize;
4811 }
4812 }
4813
4814
4815 /// <summary>
4816 /// </summary>
4817 public virtual MDTable Table {
4818 get {
4819 return table;
4820 }
4821 }
4822
4823
4824 /// <summary>
4825 /// Logical size of this type of row in bytes.
4826 /// </summary>
4827 unsafe public static int LogicalSize {
4828 get {
4829 return sizeof (ushort) + 4 + 4 + 4;
4830 }
4831 }
4832
4833
4834 /// <summary>
4835 /// Fills the row from the array of bytes.
4836 /// </summary>
4837 unsafe public void FromRawData(byte [] buff, int offs)
4838 {
4839 if (buff == null) throw new Exception("buff == null");
4840 if (offs + Size > buff.Length) throw new Exception("bounds");
4841
4842
4843 this.Number = LEBitConverter.ToUInt16(buff, offs);
4844 offs += sizeof (ushort);
4845 this.Method = LEBitConverter.ToInt32(buff, offs);
4846 offs += 4;
4847 this.Bound = TabsDecoder.DecodeToken(CodedTokenId.TypeDefOrRef, LEBitConverter.ToInt32(buff, offs));
4848 offs += 4;
4849 this.Name = LEBitConverter.ToInt32(buff, offs);
4850
4851 }
4852
4853
4854
4855 /// <summary>
4856 /// </summary>
4857 public void Dump(TextWriter writer) {
4858 string dump = String.Format(
4859 "Number : {0}" + Environment.NewLine +
4860 "Method : {1}" + Environment.NewLine +
4861 "Bound : {2}" + Environment.NewLine +
4862 "Name : {3}" + Environment.NewLine,
4863 this.Number,
4864 "Method[" + Method.ToString() + "]",
4865 this.Bound,
4866 (Table == null) ? Name.ToString() : "\"" + ((Table.Heap.Stream.Root.Streams["#Strings"] as MDStream).Heap as StringsHeap) [Name] + "\" (#Strings[0x" + Name.ToString("X") + "])"
4867 );
4868 writer.WriteLine(dump);
4869 }
4870
4871
4872 /// <summary>
4873 /// </summary>
4874 public override string ToString()
4875 {
4876 StringWriter sw = new StringWriter();
4877 Dump(sw);
4878 return sw.ToString();
4879 }
4880
4881 }
4882
4883
4884
4885
4886 }
4887
Mirror of the official Mono project git repository