?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-03-27 Sebastien Pouliot <sebastien@ximian.com>
[mono-project.git] / mcs / class / PEAPI / Metadata.cs
blob49ed4dc52331de7a14edb01a82f4c05dc2464089
1 using System;
2 using System.IO;
3 using System.Collections;
4 using System.Text;
5 using System.Reflection;
6
7 namespace PEAPI {
8
9 #region Enums
10
11 /// <summary>
12 /// flags for the assembly (.corflags)
13 /// </summary>
14 public enum CorFlags {CF_IL_ONLY = 1, CF_32_BITREQUIRED = 2,
15 CF_STRONGNAMESIGNED = 8, CF_TRACKDEBUGDATA = 0x10000 }
16
17 /// <summary>
18 /// subsystem for the assembly (.subsystem)
19 /// </summary>
20 public enum SubSystem { Native = 1, Windows_GUI = 2,
21 Windows_CUI = 3, OS2_CUI = 5, POSIX_CUI = 7, Native_Windows = 8,
22 Windows_CE_GUI = 9}
23
24 /// <summary>
25 /// Hash algorithms for the assembly
26 /// </summary>
27 public enum HashAlgorithm { None, SHA1 }
28
29 /// <summary>
30 /// Attributes for this assembly
31 /// </summary>
32 public enum AssemAttr { Retargetable = 0x100, EnableJITCompileTracking = 0x8000,
33 DisableJITCompileOptimizer = 0x4000}
34
35 /// <summary>
36 /// Method call conventions
37 /// </summary>
38 [Flags]
39 public enum CallConv { Default, Cdecl, Stdcall, Thiscall,
40 Fastcall, Vararg, Instance = 0x20, Generic = 0x10, InstanceExplicit = 0x60 }
41
42 /// <summary>
43 /// Type custom modifier
44 /// </summary>
45 public enum CustomModifier { modreq = 0x1F, modopt };
46
47 /// <summary>
48 /// Attibutes for a class
49 /// </summary>
50 [Flags]
51 public enum TypeAttr {Private, Public, NestedPublic, NestedPrivate,
52 NestedFamily, NestedAssembly, NestedFamAndAssem, NestedFamOrAssem,
53 SequentialLayout, ExplicitLayout = 0x10, Interface = 0x20,
54 Abstract = 0x80, PublicAbstract = 0x81, Sealed = 0x100,
55 PublicSealed = 0x101, SpecialName = 0x400, RTSpecialName = 0x800,
56 Import = 0x1000, Serializable = 0x2000, UnicodeClass = 0x10000,
57 AutoClass = 0x20000, HasSecurity = 0x40000, BeforeFieldInit = 0x100000,
58 VisibilityMask = 0x07 }
59
60 /// <summary>
61 /// Attributes for a field
62 /// </summary>
63 public enum FieldAttr {Default, Private, FamAndAssem, Assembly,
64 Family, FamOrAssem, Public, Static = 0x10, PublicStatic = 0x16,
65 Initonly = 0x20, Literal = 0x40, Notserialized = 0x80,
66 SpecialName = 0x200, RTSpecialName = 0x400, HasFieldMarshal = 0x1000 }
67
68 /// <summary>
69 /// Attributes for a method
70 /// </summary>
71 public enum MethAttr { Default, Private, FamAndAssem, Assembly,
72 Family, FamOrAssem, Public, Static = 0x0010, PublicStatic = 0x16,
73 Final = 0x0020, PublicStaticFinal = 0x36, Virtual = 0x0040,
74 PrivateVirtual, PublicVirtual = 0x0046, HideBySig = 0x0080,
75 NewSlot = 0x0100, Strict = 0x200, Abstract = 0x0400, SpecialName = 0x0800,
76 RTSpecialName = 0x1000, SpecialRTSpecialName = 0x1800,
77 HasSecurity = 0x4000, RequireSecObject = 0x8000}
78
79 /// <summary>
80 /// Attributes for .pinvokeimpl method declarations
81 /// </summary>
82 public enum PInvokeAttr { nomangle = 1, ansi = 2, unicode = 4, autochar = 6,
83 bestfit_on = 0x0010, bestfit_off = 0x0020, bestfit_mask = 0x0030,
84 lasterr = 0x0040, winapi = 0x0100, cdecl = 0x0200,
85 stdcall = 0x0300, thiscall = 0x0400, fastcall = 0x0500,
86 charmaperror_on = 0x1000, charmaperror_off = 0x2000
87 }
88
89 /// <summary>
90 /// Implementation attributes for a method
91 /// </summary>
92 public enum ImplAttr { IL, Native, Runtime = 0x03, Unmanaged = 0x04,
93 ForwardRef = 0x10, PreserveSig = 0x0080, InternalCall = 0x1000,
94 Synchronised = 0x0020, Synchronized = 0x0020, NoInLining = 0x0008, Optil = 0x0002}
95
96 /// <summary>
97 /// Modes for a parameter
98 /// </summary>
99 public enum ParamAttr { Default, In, Out, Opt = 16, HasDefault = 0x1000, HasFieldMarshal = 0x2000 }
100
101 /// <summary>
102 /// CIL instructions
103 /// </summary>
104 public enum Op { nop, breakOp, ldarg_0, ldarg_1, ldarg_2, ldarg_3,
105 ldloc_0, ldloc_1, ldloc_2, ldloc_3, stloc_0, stloc_1, stloc_2, stloc_3,
106 ldnull = 0x14, ldc_i4_m1, ldc_i4_0, ldc_i4_1, ldc_i4_2, ldc_i4_3,
107 ldc_i4_4, ldc_i4_5, ldc_i4_6, ldc_i4_7, ldc_i4_8, dup = 0x25, pop,
108 ret = 0x2A, ldind_i1 = 0x46, ldind_u1, ldind_i2, ldind_u2, ldind_i4,
109 ldind_u4, ldind_i8, ldind_i, ldind_r4, ldind_r8, ldind_ref, stind_ref,
110 stind_i1, stind_i2, stind_i4, stind_i8, stind_r4, stind_r8, add, sub, mul,
111 div, div_un, rem, rem_un, and, or, xor, shl, shr, shr_un, neg, not,
112 conv_i1, conv_i2, conv_i4, conv_i8, conv_r4, conv_r8, conv_u4, conv_u8,
113 conv_r_un = 0x76, throwOp = 0x7A, conv_ovf_i1_un = 0x82, conv_ovf_i2_un,
114 conv_ovf_i4_un, conv_ovf_i8_un, conf_ovf_u1_un, conv_ovf_u2_un,
115 conv_ovf_u4_un, conv_ovf_u8_un, conv_ovf_i_un, conv_ovf_u_un,
116 ldlen = 0x8E, ldelem_i1 = 0x90, ldelem_u1, ldelem_i2, ldelem_u2,
117 ldelem_i4, ldelem_u4, ldelem_i8, ldelem_i, ldelem_r4, ldelem_r8,
118 ldelem_ref, stelem_i, stelem_i1, stelem_i2, stelem_i4, stelem_i8, stelem_r4 = 0xA0, stelem_r8,
119 stelem_ref, conv_ovf_i1 = 0xb3, conv_ovf_u1, conv_ovf_i2, conv_ovf_u2,
120 conv_ovf_i4, conv_ovf_u4, conv_ovf_i8, conv_ovf_u8, ckfinite = 0xC3,
121 conv_u2 = 0xD1, conv_u1, conv_i, conv_ovf_i, conv_ovf_u, add_ovf,
122 add_ovf_un, mul_ovf, mul_ovf_un, sub_ovf, sub_ovf_un, endfinally,
123 stind_i = 0xDF, conv_u, arglist = 0xFE00, ceq, cgt, cgt_un, clt, clt_un,
124 localloc = 0xFE0F, endfilter = 0xFE11, volatile_ = 0xFE13, tail_,
125 cpblk = 0xFE17, initblk, rethrow = 0xFE1A, refanytype = 0xFE1D, readonly_ = 0xFE1E }
126
127 /// <summary>
128 /// CIL instructions requiring an integer parameter
129 /// </summary>
130 public enum IntOp {ldarg_s = 0x0E, ldarga_s, starg_s, ldloc_s, ldloca_s,
131 stloc_s, ldc_i4_s = 0x1F, ldc_i4, ldarg = 0xFE09,
132 ldarga, starg, ldloc, ldloca, stloc, unaligned = 0xFE12 }
133
134 /// <summary>
135 /// CIL instructions requiring a field parameter
136 /// </summary>
137 public enum FieldOp {ldfld = 0x7B, ldflda, stfld, ldsfld, ldsflda,
138 stsfld, ldtoken = 0xD0 }
139
140 /// <summary>
141 /// CIL instructions requiring a method parameter
142 /// </summary>
143 public enum MethodOp {jmp = 0x27, call, callvirt = 0x6F, newobj = 0x73,
144 ldtoken = 0xD0, ldftn = 0xFE06, ldvirtfn }
145
146 /// <summary>
147 /// CIL instructions requiring a type parameter
148 /// </summary>
149 public enum TypeOp {cpobj = 0x70, ldobj, castclass = 0x74, isinst,
150 unbox = 0x79, stobj = 0x81, box = 0x8C, newarr,
151 ldelema = 0x8F, refanyval = 0xC2, mkrefany = 0xC6,
152 ldtoken = 0xD0, initobj = 0xFE15, constrained = 0xFE16,
153 sizeOf = 0xFE1C, ldelem = 0xA3, stelem = 0xA4, unbox_any }
154
155 /// <summary>
156 /// CIL branch instructions
157 /// </summary>
158 public enum BranchOp {
159 // short branches
160 br_s = 0x2B, brfalse_s, brtrue_s, beq_s, bge_s, bgt_s,
161 ble_s, blt_s, bne_un_s, bge_un_s, bgt_un_s, ble_un_s, blt_un_s,
162 // long branches
163 br = 0x38, brfalse, brtrue, beq, bge, bgt, ble, blt,
164 bne_un, bge_un, bgt_un, ble_un, blt_un,
165
166 leave = 0xDD, leave_s }
167
168 /// <summary>
169 /// Index for all the tables in the meta data
170 /// </summary>
171 public enum MDTable { Module, TypeRef, TypeDef, Field = 0x04, Method = 0x06,
172 Param = 0x08, InterfaceImpl, MemberRef, Constant, CustomAttribute,
173 FieldMarshal, DeclSecurity, ClassLayout, FieldLayout, StandAloneSig,
174 EventMap, Event = 0x14, PropertyMap, Property = 0x17, MethodSemantics,
175 MethodImpl, ModuleRef, TypeSpec, ImplMap, FieldRVA, Assembly = 0x20,
176 AssemblyProcessor, AssemblyOS, AssemblyRef, AssemblyRefProcessor,
177 AssemblyRefOS, File, ExportedType, ManifestResource, NestedClass,
178 GenericParam, MethodSpec, GenericParamConstraint }
179
180 public enum SafeArrayType { int16 = 2, int32, float32, float64,
181 currency, date, bstr, dispatch, error, boolean, variant, unknown,
182 Decimal, int8 = 16, uint8, uint16, uint32, Int = 22, UInt }
183
184 internal enum CIx { TypeDefOrRef, HasConst, HasCustomAttr, HasFieldMarshal,
185 HasDeclSecurity, MemberRefParent, HasSemantics, MethodDefOrRef,
186 MemberForwarded, Implementation, CustomAttributeType, ResolutionScope,
187 TypeOrMethodDef, MaxCIx }
188
189 internal enum MapType { eventMap, propertyMap, nestedClass }
190
191 public enum ValueClass { ValueType, Enum }
192
193 public enum GenParamType : byte {
194 Var = 0x13, MVar = 0x1E
195 }
196
197 [Flags]
198 public enum GenericParamAttributes : ushort {
199 VarianceMask = 0x0003,
200 NonVariant = 0x0000,
201 Covariant = 0x0001,
202 Contravariant = 0x0002,
203
204 SpecialConstraintMask = 0x001c,
205 ReferenceTypeConstraint = 0x0004,
206 NotNullableValueTypeConstraint = 0x0008,
207 DefaultConstructorConstrait = 0x0010
208 }
209
210 /* Taken from Mono.Cecil */
211 public enum SecurityAction : short {
212 Request = 1,
213 Demand = 2,
214 Assert = 3,
215 Deny = 4,
216 PermitOnly = 5,
217 LinkDemand = 6,
218 InheritDemand = 7,
219 RequestMinimum = 8,
220 RequestOptional = 9,
221 RequestRefuse = 10,
222 PreJitGrant = 11,
223 PreJitDeny = 12,
224 NonCasDemand = 13,
225 NonCasLinkDemand = 14,
226 NonCasInheritance = 15,
227 LinkDemandChoice = 16,
228 InheritDemandChoice = 17,
229 DemandChoice = 18
230 }
231
232 #endregion
233
234 /**************************************************************************/
235 /// <summary>
236 /// Base class for all Meta Data table elements
237 /// </summary>
238
239 public abstract class MetaDataElement: IComparable {
240 protected ArrayList customAttributes;
241 private uint row = 0;
242 protected bool done = false;
243 protected MDTable tabIx;
244 protected bool sortTable = false;
245 //Temporary hack..
246 private bool has_custom_attrs = false;
247
248 internal MetaDataElement() { }
249
250 public uint Row {
251 get {
252 return row;
253 }
254 set {
255 row = value;
256 }
257 }
258
259 public bool HasCustomAttr {
260 get { return has_custom_attrs; }
261 set { has_custom_attrs = value; }
262 }
263
264 internal virtual uint GetCodedIx(CIx code) { return 0; }
265
266 /// <summary>
267 /// Add a custom attribute to this item
268 /// </summary>
269 /// <param name="ctorMeth">the constructor method for this attribute</param>
270 /// <param name="val">the byte value of the parameters</param>
271 public void AddCustomAttribute(Method ctorMeth, byte[] val)
272 {
273 if (customAttributes == null) {
274 customAttributes = new ArrayList();
275 }
276 customAttributes.Add(new CustomAttribute(this,ctorMeth,val));
277 }
278
279 /// <summary>
280 /// Add a custom attribute to this item
281 /// </summary>
282 /// <param name="ctorMeth">the constructor method for this attribute</param>
283 /// <param name="val">the constant values of the parameters</param>
284 public void AddCustomAttribute(Method ctorMeth, Constant[] cVals)
285 {
286 if (customAttributes == null) {
287 customAttributes = new ArrayList();
288 }
289 // customAttributes.Add(new CustomAttribute(this,ctorMeth,cVals));
290 }
291
292 internal uint Token()
293 {
294 return (((uint)tabIx << 24) | row);
295 }
296
297 internal virtual void BuildTables(MetaData md)
298 {
299 done = true;
300 }
301
302 internal virtual uint Size(MetaData md)
303 {
304 return 0;
305 }
306
307 internal virtual void Write(FileImage output) { }
308
309 internal virtual uint SortKey()
310 {
311 throw new PEFileException("Trying to sort table of " + this);
312 //return 0;
313 }
314
315 internal virtual uint SortKey2()
316 {
317 return 0;
318 }
319
320 public int CompareTo(object obj)
321 {
322 uint otherKey = ((MetaDataElement)obj).SortKey();
323 uint thisKey = SortKey();
324
325 if (thisKey == otherKey) {
326
327 otherKey = ((MetaDataElement)obj).SortKey2();
328 thisKey = SortKey2();
329 if (thisKey == otherKey)
330 return 0;
331 if (thisKey < otherKey)
332 return -1;
333 return 1;
334 }
335 if (thisKey < otherKey) return -1;
336
337 return 1;
338 }
339
340 }
341
342 /**************************************************************************/
343 /// <summary>
344 /// Layout information for a class (.class [sequential | explicit])
345 /// </summary>
346 internal class ClassLayout : MetaDataElement {
347
348 ClassDef parent;
349 ushort packSize = 0;
350 uint classSize = 0;
351
352 internal ClassLayout(int pack, int cSize, ClassDef par)
353 {
354 packSize = (ushort)pack;
355 classSize = (uint)cSize;
356 parent = par;
357 tabIx = MDTable.ClassLayout;
358 }
359
360 internal sealed override uint Size(MetaData md)
361 {
362 return 6 + md.TableIndexSize(MDTable.TypeDef);
363 }
364
365 internal sealed override void Write(FileImage output)
366 {
367 output.Write(packSize);
368 output.Write(classSize);
369 output.WriteIndex(MDTable.TypeDef,parent.Row);
370 }
371
372 }
373
374 /**************************************************************************/
375 /// <summary>
376 /// Summary description for ConstantElem.
377 /// </summary>
378 internal class ConstantElem : MetaDataElement {
379
380 MetaDataElement parent;
381 Constant cValue;
382 uint valIx = 0;
383
384 internal ConstantElem(MetaDataElement parent, Constant val)
385 {
386 this.parent = parent;
387 cValue = val;
388 tabIx = MDTable.Constant;
389 sortTable = true;
390 }
391
392 internal override uint SortKey()
393 {
394 return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasConst])
395 | parent.GetCodedIx(CIx.HasConst);
396 }
397
398 internal sealed override void BuildTables(MetaData md)
399 {
400 if (done) return;
401 valIx = cValue.GetBlobIndex(md);
402 done = true;
403 }
404
405 internal void AddToBlob(BinaryWriter bw)
406 {
407 cValue.Write(bw);
408 }
409
410 internal sealed override uint Size(MetaData md)
411 {
412 return 2 + md.CodedIndexSize(CIx.HasConst) + md.BlobIndexSize();
413 }
414
415 internal sealed override void Write(FileImage output)
416 {
417 output.Write(cValue.GetTypeIndex());
418 output.Write((byte)0);
419 output.WriteCodedIndex(CIx.HasConst,parent);
420 output.BlobIndex(valIx);
421 }
422
423 }
424 /**************************************************************************/
425 /// <summary>
426 /// Descriptor for a Custom Attribute (.custom)
427 /// </summary>
428
429 public class CustomAttribute : MetaDataElement {
430
431 private static readonly ushort prolog = 0x0001;
432 MetaDataElement parent;
433 Method type;
434 uint valIx;
435 Constant cVal;
436 byte[] byteVal;
437 ushort numNamed = 0;
438 ArrayList names, vals;
439
440 internal CustomAttribute(MetaDataElement paren, Method constrType,
441 Constant val) {
442 parent = paren;
443 type = constrType;
444 cVal = val;
445 tabIx = MDTable.CustomAttribute;
446 }
447
448 internal CustomAttribute(MetaDataElement paren, Method constrType,
449 byte[] val) {
450 parent = paren;
451 type = constrType;
452 tabIx = MDTable.CustomAttribute;
453 byteVal = val;
454 }
455
456 internal override uint SortKey()
457 {
458 return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasCustomAttr])
459 | parent.GetCodedIx(CIx.HasCustomAttr);
460 }
461
462 public void AddFieldOrProp(string name, Constant val)
463 {
464 if (numNamed == 0) {
465 names = new ArrayList();
466 vals = new ArrayList();
467 }
468 names.Add(name);
469 vals.Add(val);
470 }
471
472 internal sealed override void BuildTables(MetaData md)
473 {
474 md.AddToTable(MDTable.CustomAttribute, this);
475 if (byteVal == null) {
476 valIx = 0;
477 return;
478 }
479
480 BinaryWriter bw = new BinaryWriter(new MemoryStream());
481 bw.Write(byteVal);
482 MemoryStream str = (MemoryStream)bw.BaseStream;
483 valIx = md.AddToBlobHeap(str.ToArray());
484 }
485
486 internal sealed override uint Size(MetaData md)
487 {
488 return md.CodedIndexSize(CIx.HasCustomAttr) + md.CodedIndexSize(CIx.CustomAttributeType) + md.BlobIndexSize();
489 }
490
491 internal sealed override void Write(FileImage output)
492 {
493 output.WriteCodedIndex(CIx.HasCustomAttr,parent);
494 output.WriteCodedIndex(CIx.CustomAttributeType,type);
495 output.BlobIndex(valIx);
496 }
497
498 }
499
500 /**************************************************************************/
501 /// <summary>
502 /// Descriptor for security permissions for a class or a method
503 /// </summary>
504
505 public abstract class BaseDeclSecurity : MetaDataElement {
506
507 ushort action;
508 MetaDataElement parent;
509 uint permissionIx;
510
511 internal BaseDeclSecurity(MetaDataElement paren, ushort act)
512 {
513 parent = paren;
514 action = act;
515 tabIx = MDTable.DeclSecurity;
516 }
517
518 internal override uint SortKey()
519 {
520 return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasDeclSecurity])
521 | parent.GetCodedIx(CIx.HasDeclSecurity);
522 }
523
524 internal sealed override uint Size(MetaData md)
525 {
526 return 2 + md.CodedIndexSize(CIx.HasDeclSecurity) + md.BlobIndexSize();
527 }
528
529 internal sealed override void BuildTables(MetaData md)
530 {
531 if (done) return;
532
533 BinaryWriter bw = new BinaryWriter (new MemoryStream ());
534 md.AddToTable (MDTable.DeclSecurity, this);
535 MemoryStream str = (MemoryStream)bw.BaseStream;
536 WriteSig (bw);
537 permissionIx = md.AddToBlobHeap(str.ToArray());
538
539 done = true;
540 }
541
542 internal abstract void WriteSig (BinaryWriter bw);
543
544 internal sealed override void Write(FileImage output)
545 {
546 output.Write(action);
547 output.WriteCodedIndex(CIx.HasDeclSecurity,parent);
548 output.BlobIndex(permissionIx);
549 }
550
551 }
552
553 public class DeclSecurity : BaseDeclSecurity {
554
555 byte [] byteVal;
556
557 internal DeclSecurity(MetaDataElement paren, ushort act, byte [] val)
558 : base (paren, act)
559 {
560 byteVal = val;
561 }
562
563 internal override void WriteSig (BinaryWriter bw)
564 {
565 bw.Write (byteVal);
566 }
567
568 }
569
570 public class DeclSecurity_20 : BaseDeclSecurity {
571
572 PermissionSet ps;
573
574 internal DeclSecurity_20 (MetaDataElement paren, ushort act, PermissionSet ps)
575 : base (paren, act)
576 {
577 this.ps = ps;
578 }
579
580 internal override void WriteSig (BinaryWriter bw)
581 {
582 ps.Write (bw);
583 }
584 }
585
586 public class PermissionMember {
587
588 MemberTypes member_type;
589 PEAPI.Type type;
590 string name;
591 object value;
592
593 public PermissionMember (MemberTypes member_type, PEAPI.Type type, string name, object value)
594 {
595 this.member_type = member_type;
596 this.type = type;
597 this.name = name;
598 this.value = value;
599 }
600
601 public void Write (BinaryWriter bw)
602 {
603 byte [] b;
604
605 if (member_type == MemberTypes.Field)
606 bw.Write ((byte) 0x53);
607 else
608 //Property
609 bw.Write ((byte) 0x54);
610
611 if (type is PrimitiveType) {
612 bw.Write (type.GetTypeIndex ());
613 } else {
614 //must be enum
615 bw.Write ((byte) 0x55); //ENUM
616
617 b = Encoding.UTF8.GetBytes (((ClassRef) type).TypeName ());
618 MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
619 bw.Write (b);
620 }
621
622 b = Encoding.UTF8.GetBytes (name);
623 MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
624 bw.Write (b);
625
626 ((Constant) value).Write (bw);
627 }
628
629 }
630
631 public class Permission
632 {
633 PEAPI.Type type;
634
635 //PermissionMembers
636 ArrayList members;
637 string name;
638
639 public Permission (PEAPI.Type type, string name)
640 {
641 this.type = type;
642 this.name = name;
643 }
644
645 public void AddMember (PEAPI.PermissionMember member)
646 {
647 if (members == null)
648 members = new ArrayList ();
649
650 members.Add (member);
651 }
652
653 public void Write (BinaryWriter bw)
654 {
655 byte [] b = Encoding.UTF8.GetBytes (name);
656 MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
657 bw.Write (b);
658
659 BinaryWriter perm_writer = new BinaryWriter (new MemoryStream (), Encoding.Unicode);
660 MemoryStream str = (MemoryStream) perm_writer.BaseStream;
661
662 MetaData.CompressNum ((uint) members.Count, str);//number of params
663 foreach (PermissionMember member in members)
664 member.Write (perm_writer);
665
666 bw.Write ((byte) str.Length); //(optional) parameters length
667 bw.Write (str.ToArray ());
668 }
669 }
670
671 public class PermissionSet
672 {
673 PEAPI.SecurityAction sec_action;
674 ArrayList permissions;
675 PEAPI.PermissionSet ps;
676
677 public PermissionSet (PEAPI.SecurityAction sec_action)
678 {
679 this.sec_action = sec_action;
680 }
681
682 public void AddPermission (PEAPI.Permission perm)
683 {
684 if (permissions == null)
685 permissions = new ArrayList ();
686
687 permissions.Add (perm);
688 }
689
690 public void Write (BinaryWriter bw)
691 {
692 bw.Write ((byte) 0x2e);
693 MetaData.CompressNum ((uint) permissions.Count, (MemoryStream) bw.BaseStream);
694
695 foreach (Permission perm in permissions)
696 perm.Write (bw);
697 }
698
699 }
700
701 /**************************************************************************/
702 /// <summary>
703 /// Descriptor for layout information for a field
704 /// </summary>
705
706 public class FieldLayout : MetaDataElement {
707
708 Field field;
709 uint offset;
710
711 internal FieldLayout(Field field, uint offset)
712 {
713 this.field = field;
714 this.offset = offset;
715 tabIx = MDTable.FieldLayout;
716 }
717
718 internal sealed override uint Size(MetaData md)
719 {
720 return 4 + md.TableIndexSize(MDTable.Field);
721 }
722
723 internal sealed override void Write(FileImage output)
724 {
725 output.Write(offset);
726 output.WriteIndex(MDTable.Field,field.Row);
727 }
728
729 }
730
731 /*****************************************************************************/
732 /// <summary>
733 /// Marshalling information for a field or param
734 /// </summary>
735 public class FieldMarshal : MetaDataElement {
736
737 MetaDataElement field;
738 NativeType nt;
739 uint ntIx;
740
741 internal FieldMarshal(MetaDataElement field, NativeType nType)
742 {
743 this.field = field;
744 this.nt = nType;
745 tabIx = MDTable.FieldMarshal;
746 }
747
748 internal override uint SortKey()
749 {
750 return (field.Row << MetaData.CIxShiftMap[(uint)CIx.HasFieldMarshal])
751 | field.GetCodedIx(CIx.HasFieldMarshal);
752 }
753
754 internal sealed override void BuildTables(MetaData md)
755 {
756 if (done) return;
757 ntIx = md.AddToBlobHeap(nt.ToBlob());
758 done = true;
759 }
760
761 internal sealed override uint Size(MetaData md)
762 {
763 return md.CodedIndexSize(CIx.HasFieldMarshal) + md.BlobIndexSize();
764 }
765
766 internal sealed override void Write(FileImage output)
767 {
768 output.WriteCodedIndex(CIx.HasFieldMarshal,field);
769 output.BlobIndex(ntIx);
770 }
771
772 }
773
774 /**************************************************************************/
775 /// <summary>
776 /// Descriptor for the address of a field's value in the PE file
777 /// </summary>
778 public class FieldRVA : MetaDataElement {
779
780 Field field;
781 DataConstant data;
782
783 internal FieldRVA(Field field, DataConstant data)
784 {
785 this.field = field;
786 this.data = data;
787 tabIx = MDTable.FieldRVA;
788 }
789
790 internal sealed override void BuildTables(MetaData md)
791 {
792 if (done) return;
793 md.AddData(data);
794 done = true;
795 }
796
797 internal sealed override uint Size(MetaData md)
798 {
799 return 4 + md.TableIndexSize(MDTable.Field);
800 }
801
802 internal sealed override void Write(FileImage output)
803 {
804 output.WriteDataRVA(data.DataOffset);
805 output.WriteIndex(MDTable.Field,field.Row);
806 }
807
808 }
809
810 /**************************************************************************/
811 /// <summary>
812 /// Descriptor for a file referenced in THIS assembly/module (.file)
813 /// </summary>
814 public class FileRef : MetaDataElement {
815
816 private static readonly uint NoMetaData = 0x1;
817 uint nameIx = 0, hashIx = 0;
818 uint flags = 0;
819 protected string name;
820
821 internal FileRef(string name, byte[] hashBytes, bool metaData,
822 bool entryPoint, MetaData md) {
823 if (!metaData) flags = NoMetaData;
824 if (entryPoint) md.SetEntryPoint(this);
825 this.name = name;
826 nameIx = md.AddToStringsHeap(name);
827 hashIx = md.AddToBlobHeap(hashBytes);
828 tabIx = MDTable.File;
829 }
830
831 internal FileRef(uint nameIx, byte[] hashBytes, bool metaData,
832 bool entryPoint, MetaData md) {
833 if (!metaData) flags = NoMetaData;
834 if (entryPoint) md.SetEntryPoint(this);
835 this.nameIx = nameIx;
836 hashIx = md.AddToBlobHeap(hashBytes);
837 tabIx = MDTable.File;
838 }
839
840 internal sealed override uint Size(MetaData md)
841 {
842 return 4 + md.StringsIndexSize() + md.BlobIndexSize();
843 }
844
845 internal sealed override void BuildTables(MetaData md)
846 {
847 md.AddToTable(MDTable.File,this);
848 }
849
850 internal sealed override void Write(FileImage output)
851 {
852 output.Write(flags);
853 output.StringsIndex(nameIx);
854 output.BlobIndex(hashIx);
855 }
856
857 internal sealed override uint GetCodedIx(CIx code)
858 {
859 switch (code) {
860 case (CIx.HasCustomAttr) : return 16;
861 case (CIx.Implementation) : return 0;
862 }
863 return 0;
864 }
865
866 }
867 /**************************************************************************/
868 /// <summary>
869 /// Descriptor for pinvoke information for a method NOT YET IMPLEMENTED
870 /// </summary>
871 public class ImplMap : MetaDataElement {
872
873 private static readonly ushort NoMangle = 0x01;
874 ushort flags;
875 Method meth;
876 string importName;
877 uint iNameIx;
878 ModuleRef importScope;
879
880 internal ImplMap(ushort flag, Method implMeth, string iName, ModuleRef mScope)
881 {
882 flags = flag;
883 meth = implMeth;
884 importName = iName;
885 importScope = mScope;
886 tabIx = MDTable.ImplMap;
887 if (iName == null) flags |= NoMangle;
888 //throw(new NotYetImplementedException("PInvoke "));
889 }
890
891 internal override uint SortKey()
892 {
893 return (meth.Row << MetaData.CIxShiftMap[(uint)CIx.MemberForwarded])
894 | meth.GetCodedIx(CIx.MemberForwarded);
895 }
896
897 internal sealed override void BuildTables(MetaData md)
898 {
899 if (done) return;
900 iNameIx = md.AddToStringsHeap(importName);
901 done = true;
902 }
903
904 internal sealed override uint Size(MetaData md)
905 {
906 return 2+ md.CodedIndexSize(CIx.MemberForwarded) +
907 md.StringsIndexSize() + md.TableIndexSize(MDTable.ModuleRef);
908 }
909
910 internal sealed override void Write(FileImage output)
911 {
912 output.Write(flags);
913 output.WriteCodedIndex(CIx.MemberForwarded,meth);
914 output.StringsIndex(iNameIx);
915 output.WriteIndex(MDTable.ModuleRef,importScope.Row);
916 }
917
918 }
919
920 /**************************************************************************/
921
922 public class GenericParameter : MetaDataElement {
923
924 MetaDataElement owner;
925 MetaData metadata;
926 public string name;
927 uint nameIx;
928 short index;
929 GenericParamAttributes attr;
930
931 internal GenericParameter (ClassDef owner, MetaData metadata,
932 short index, string name, GenericParamAttributes attr) : this (owner, metadata, index, name, attr, true)
933 {
934 }
935
936 internal GenericParameter (MethodDef owner, MetaData metadata,
937 short index, string name, GenericParamAttributes attr) : this (owner, metadata, index, name, attr, true)
938 {
939 }
940
941 private GenericParameter (MetaDataElement owner, MetaData metadata,
942 short index, string name, GenericParamAttributes attr, bool nadda) {
943 this.owner = owner;
944 this.metadata = metadata;
945 this.index = index;
946 tabIx = MDTable.GenericParam;
947 this.name = name;
948 this.attr = attr;
949 }
950
951 internal override uint SortKey()
952 {
953 return (owner.Row << MetaData.CIxShiftMap[(uint)CIx.TypeOrMethodDef])
954 | owner.GetCodedIx(CIx.TypeOrMethodDef);
955 }
956
957 internal override uint SortKey2 ()
958 {
959 return (uint) index;
960 }
961
962 public void AddConstraint (Type constraint)
963 {
964 metadata.AddToTable (MDTable.GenericParamConstraint,
965 new GenericParamConstraint (this, constraint));
966 }
967
968 internal sealed override uint Size(MetaData md)
969 {
970 return (uint) (4 +
971 md.CodedIndexSize(CIx.TypeOrMethodDef) +
972 md.StringsIndexSize ());
973 }
974
975 internal sealed override void BuildTables(MetaData md)
976 {
977 if (done) return;
978 nameIx = md.AddToStringsHeap(name);
979 done = true;
980 }
981
982 internal sealed override void Write(FileImage output)
983 {
984 output.Write ((short) index);
985 output.Write ((short) attr);
986 output.WriteCodedIndex(CIx.TypeOrMethodDef, owner);
987 output.StringsIndex (nameIx);
988 }
989
990 internal sealed override uint GetCodedIx(CIx code)
991 {
992 switch (code) {
993 case (CIx.HasCustomAttr) : return 19;
994 }
995 return 0;
996 }
997
998 }
999
1000 internal class GenericParamConstraint : MetaDataElement {
1001
1002 GenericParameter param;
1003 Type type;
1004
1005 public GenericParamConstraint (GenericParameter param, Type type)
1006 {
1007 this.param = param;
1008 this.type = type;
1009 tabIx = MDTable.GenericParamConstraint;
1010 }
1011
1012 internal override uint SortKey()
1013 {
1014 return param.Row;
1015 }
1016
1017 internal sealed override uint Size(MetaData md)
1018 {
1019 return (uint) (md.TableIndexSize(MDTable.GenericParam) +
1020 md.CodedIndexSize(CIx.TypeDefOrRef));
1021 }
1022
1023 internal sealed override void Write(FileImage output)
1024 {
1025 output.WriteIndex(MDTable.GenericParam, param.Row);
1026 output.WriteCodedIndex(CIx.TypeDefOrRef, type);
1027 }
1028
1029 }
1030
1031 internal class MethodSpec : Method {
1032
1033 Method meth;
1034 GenericMethodSig g_sig;
1035 uint sidx;
1036
1037 internal MethodSpec (Method meth, GenericMethodSig g_sig) : base ("")
1038 {
1039 this.meth = meth;
1040 this.g_sig = g_sig;
1041 tabIx = MDTable.MethodSpec;
1042 }
1043
1044 internal override uint GetSigIx (MetaData md)
1045 {
1046 throw new Exception ("Should not be used.");
1047 }
1048
1049 public override void AddCallConv (CallConv cconv)
1050 {
1051 throw new Exception ("Should not be used.");
1052 }
1053
1054 internal sealed override void BuildTables (MetaData md)
1055 {
1056 if (done) return;
1057 sidx = g_sig.GetSigIx (md);
1058 done = true;
1059 }
1060
1061 internal sealed override uint Size (MetaData md)
1062 {
1063 return (uint) (md.CodedIndexSize(CIx.MethodDefOrRef) +
1064 md.BlobIndexSize ());
1065 }
1066
1067 internal sealed override void Write (FileImage output)
1068 {
1069 output.WriteCodedIndex (CIx.MethodDefOrRef, meth);
1070 output.BlobIndex (sidx);
1071 }
1072
1073 internal sealed override void TypeSig (MemoryStream sig)
1074 {
1075 throw new Exception ("Should not be used.");
1076 }
1077 }
1078
1079 /**************************************************************************/
1080 /// <summary>
1081 /// Descriptor for interface implemented by a class
1082 /// </summary>
1083 public class InterfaceImpl: MetaDataElement {
1084
1085 ClassDef theClass;
1086 Class theInterface;
1087
1088 internal InterfaceImpl(ClassDef theClass, Class theInterface)
1089 {
1090 this.theClass = theClass;
1091 this.theInterface = theInterface;
1092 tabIx = MDTable.InterfaceImpl;
1093 }
1094
1095 internal sealed override uint Size(MetaData md)
1096 {
1097 return md.TableIndexSize(MDTable.TypeDef) +
1098 md.CodedIndexSize(CIx.TypeDefOrRef);
1099 }
1100
1101 internal sealed override void Write(FileImage output)
1102 {
1103 output.WriteIndex(MDTable.TypeDef,theClass.Row);
1104 output.WriteCodedIndex(CIx.TypeDefOrRef,theInterface);
1105 }
1106
1107 internal sealed override uint GetCodedIx(CIx code) { return 5; }
1108
1109 internal override uint SortKey ()
1110 {
1111 return (theClass.Row << MetaData.CIxShiftMap[(uint)CIx.TypeDefOrRef])
1112 | theClass.GetCodedIx (CIx.TypeDefOrRef);
1113 }
1114
1115 }
1116
1117 /**************************************************************************/
1118 /// <summary>
1119 /// Descriptor for resources used in this PE file
1120 /// </summary>
1121
1122 public class ManifestResource : MetaDataElement {
1123
1124 public static readonly uint PublicResource = 0x1;
1125 public static readonly uint PrivateResource = 0x2;
1126
1127 string mrName;
1128 MetaDataElement rRef;
1129 uint fileOffset;
1130 uint nameIx = 0;
1131 uint flags = 0;
1132 byte [] resourceBytes;
1133
1134 public ManifestResource (string name, byte[] resBytes, uint flags)
1135 {
1136 InitResource (name, flags);
1137 this.resourceBytes = resBytes;
1138 }
1139
1140 public ManifestResource(string name, uint flags, FileRef fileRef)
1141 {
1142 InitResource (name, flags);
1143 rRef = fileRef;
1144 }
1145
1146 public ManifestResource(string name, uint flags, FileRef fileRef,
1147 uint fileIx) {
1148 InitResource (name, flags);
1149 rRef = fileRef;
1150 fileOffset = fileIx;
1151 }
1152
1153 public ManifestResource(string name, uint flags, AssemblyRef assemRef)
1154 {
1155 InitResource (name, flags);
1156 rRef = assemRef;
1157 }
1158
1159 internal ManifestResource (ManifestResource mres)
1160 {
1161 mrName = mres.mrName;
1162 flags = mres.flags;
1163 rRef = mres.rRef;
1164 fileOffset = mres.fileOffset;
1165 resourceBytes = mres.resourceBytes;
1166 }
1167
1168 private void InitResource (string name, uint flags)
1169 {
1170 mrName = name;
1171 this.flags = flags;
1172 tabIx = MDTable.ManifestResource;
1173 }
1174
1175 internal sealed override void BuildTables(MetaData md)
1176 {
1177 if (done) return;
1178 md.AddToTable (MDTable.ManifestResource, this);
1179 nameIx = md.AddToStringsHeap(mrName);
1180 if (resourceBytes != null) {
1181 if (rRef != null)
1182 throw new PEFileException ("Manifest Resource has byte value and file reference");
1183 fileOffset = md.AddResource(resourceBytes);
1184 } else {
1185 if (rRef == null)
1186 throw new PEFileException ("Manifest Resource has no implementation or value");
1187 rRef.BuildTables (md);
1188 }
1189
1190 done = true;
1191 }
1192
1193 internal sealed override uint Size(MetaData md)
1194 {
1195 return 8 + md.StringsIndexSize() +
1196 md.CodedIndexSize(CIx.Implementation);
1197 }
1198
1199 internal sealed override void Write(FileImage output)
1200 {
1201 output.Write(fileOffset);
1202 output.Write(flags);
1203 output.StringsIndex(nameIx);
1204 output.WriteCodedIndex(CIx.Implementation,rRef);
1205 }
1206
1207 internal sealed override uint GetCodedIx(CIx code) { return 18; }
1208
1209 public string Name {
1210 get { return mrName; }
1211 set { mrName = value; }
1212 }
1213
1214 }
1215 /**************************************************************************/
1216 /// <summary>
1217 /// Base class for elements in the PropertyMap, EventMap and
1218 /// NestedClass MetaData tables
1219 /// </summary>
1220 public class MapElem : MetaDataElement {
1221
1222 ClassDef parent;
1223 uint elemIx;
1224 MDTable elemTable;
1225
1226 internal MapElem(ClassDef par, uint elIx, MDTable elemTab)
1227 {
1228 parent = par;
1229 elemIx = elIx;
1230 elemTable = elemTab;
1231 }
1232
1233 internal sealed override uint Size(MetaData md)
1234 {
1235 return md.TableIndexSize(MDTable.TypeDef) + md.TableIndexSize(elemTable);
1236 }
1237
1238 internal sealed override void Write(FileImage output)
1239 {
1240 output.WriteIndex(MDTable.TypeDef,parent.Row);
1241 output.WriteIndex(elemTable,elemIx);
1242 }
1243 }
1244
1245 /**************************************************************************/
1246 /// <summary>
1247 /// Descriptor for an overriding method (.override)
1248 /// </summary>
1249 public class MethodImpl : MetaDataElement {
1250
1251 ClassDef parent;
1252 Method header, body;
1253
1254 internal MethodImpl(ClassDef par, Method decl, Method bod)
1255 {
1256 parent = par;
1257 header = decl;
1258 body = bod;
1259 tabIx = MDTable.MethodImpl;
1260 }
1261
1262 internal sealed override uint Size(MetaData md)
1263 {
1264 return md.TableIndexSize(MDTable.TypeDef) + 2 * md.CodedIndexSize(CIx.MethodDefOrRef);
1265 }
1266
1267 internal sealed override void Write(FileImage output)
1268 {
1269 output.WriteIndex(MDTable.TypeDef,parent.Row);
1270 output.WriteCodedIndex(CIx.MethodDefOrRef,body);
1271 output.WriteCodedIndex(CIx.MethodDefOrRef,header);
1272 }
1273
1274 }
1275
1276 /**************************************************************************/
1277 /// <summary>
1278 /// Descriptor for Property and Event methods
1279 /// </summary>
1280 public class MethodSemantics : MetaDataElement {
1281
1282 Feature.MethodType type;
1283 MethodDef meth;
1284 Feature eventOrProp;
1285
1286 internal MethodSemantics(Feature.MethodType mType, MethodDef method, Feature feature)
1287 {
1288 type = mType;
1289 meth = method;
1290 eventOrProp = feature;
1291 tabIx = MDTable.MethodSemantics;
1292 }
1293
1294 internal override uint SortKey()
1295 {
1296 return (eventOrProp.Row << MetaData.CIxShiftMap [(uint)CIx.HasSemantics])
1297 | eventOrProp.GetCodedIx (CIx.HasSemantics);
1298 }
1299
1300 internal sealed override uint Size(MetaData md)
1301 {
1302 return 2 + md.TableIndexSize(MDTable.Method) + md.CodedIndexSize(CIx.HasSemantics);
1303 }
1304
1305 internal sealed override void Write(FileImage output)
1306 {
1307 output.Write((ushort)type);
1308 output.WriteIndex(MDTable.Method,meth.Row);
1309 output.WriteCodedIndex(CIx.HasSemantics,eventOrProp);
1310 }
1311
1312 }
1313
1314 /**************************************************************************/
1315 /// <summary>
1316 /// Descriptor for a parameter of a method defined in this assembly/module
1317 /// </summary>
1318 public class Param : MetaDataElement {
1319
1320
1321 Type pType;
1322 string pName;
1323 internal ushort seqNo = 0;
1324 ushort parMode;
1325 ConstantElem defaultVal;
1326 uint nameIx = 0;
1327 FieldMarshal marshalInfo;
1328
1329 /// <summary>
1330 /// Create a new parameter for a method
1331 /// </summary>
1332 /// <param name="mode">param mode (in, out, opt)</param>
1333 /// <param name="parName">parameter name</param>
1334 /// <param name="parType">parameter type</param>
1335 public Param(ParamAttr mode, string parName, Type parType)
1336 {
1337 pName = parName;
1338 pType = parType;
1339 parMode = (ushort)mode;
1340 tabIx = MDTable.Param;
1341 }
1342
1343 public bool HasMarshalInfo {
1344 get { return marshalInfo != null; }
1345 }
1346
1347 /// <summary>
1348 /// Add a default value to this parameter
1349 /// </summary>
1350 /// <param name="c">the default value for the parameter</param>
1351 public void AddDefaultValue(Constant cVal)
1352 {
1353 defaultVal = new ConstantElem(this,cVal);
1354 parMode |= (ushort) ParamAttr.HasDefault;
1355 }
1356
1357 /// <summary>
1358 /// Add marshalling information about this parameter
1359 /// </summary>
1360 public void AddMarshallInfo(NativeType marshallType)
1361 {
1362 parMode |= (ushort) ParamAttr.HasFieldMarshal;
1363 marshalInfo = new FieldMarshal(this,marshallType);
1364 }
1365
1366 internal Type GetParType() { return pType; }
1367
1368 internal sealed override void BuildTables(MetaData md)
1369 {
1370 if (done) return;
1371 nameIx = md.AddToStringsHeap(pName);
1372 if (defaultVal != null) {
1373 md.AddToTable(MDTable.Constant,defaultVal);
1374 defaultVal.BuildTables(md);
1375 }
1376 if (marshalInfo != null) {
1377 md.AddToTable(MDTable.FieldMarshal,marshalInfo);
1378 marshalInfo.BuildTables(md);
1379 }
1380 done = true;
1381 }
1382
1383 internal void TypeSig(MemoryStream str)
1384 {
1385 pType.TypeSig(str);
1386 }
1387
1388 internal sealed override uint Size(MetaData md)
1389 {
1390 return 4 + md.StringsIndexSize();
1391 }
1392
1393 internal sealed override void Write(FileImage output)
1394 {
1395 output.Write(parMode);
1396 output.Write(seqNo);
1397 output.StringsIndex(nameIx);
1398 }
1399
1400 internal sealed override uint GetCodedIx(CIx code)
1401 {
1402 switch (code) {
1403 case (CIx.HasCustomAttr) : return 4;
1404 case (CIx.HasConst) : return 1;
1405 case (CIx.HasFieldMarshal) : return 1;
1406 }
1407 return 0;
1408 }
1409
1410 }
1411
1412 /**************************************************************************/
1413 public abstract class Signature : MetaDataElement {
1414
1415 protected uint sigIx;
1416
1417 internal Signature()
1418 {
1419 tabIx = MDTable.StandAloneSig;
1420 }
1421
1422 internal sealed override uint Size(MetaData md)
1423 {
1424 return md.BlobIndexSize();
1425 }
1426
1427 internal sealed override void Write(FileImage output)
1428 {
1429 output.BlobIndex(sigIx);
1430 }
1431
1432 internal sealed override uint GetCodedIx(CIx code) { return (uint)tabIx; }
1433
1434 }
1435
1436 /**************************************************************************/
1437 public class TypeSpec : MetaDataElement {
1438 uint sigIx = 0;
1439
1440 internal TypeSpec(Type aType, MetaData md)
1441 {
1442 MemoryStream sig = new MemoryStream();
1443 aType.TypeSig(sig);
1444 sigIx = md.AddToBlobHeap(sig.ToArray());
1445 tabIx = MDTable.TypeSpec;
1446 }
1447
1448 internal sealed override uint GetCodedIx(CIx code)
1449 {
1450 switch (code) {
1451 case (CIx.TypeDefOrRef) : return 2;
1452 case (CIx.HasCustomAttr) : return 13;
1453 case (CIx.MemberRefParent) : return 4;
1454 }
1455 return 0;
1456 }
1457
1458 internal override uint Size(MetaData md)
1459 {
1460 return md.BlobIndexSize();
1461 }
1462
1463 internal sealed override void Write(FileImage output)
1464 {
1465 //Console.WriteLine("Writing the blob index for a TypeSpec");
1466 output.BlobIndex(sigIx);
1467 }
1468 }
1469
1470
1471 /**************************************************************************/
1472 /// <summary>
1473 /// Base class for all IL types
1474 /// </summary>
1475 public abstract class Type : MetaDataElement {
1476 protected byte typeIndex;
1477 protected TypeSpec typeSpec;
1478
1479 internal Type(byte tyIx) { typeIndex = tyIx; }
1480
1481 internal byte GetTypeIndex() { return typeIndex; }
1482 internal void SetTypeIndex (byte b) { typeIndex = b; }
1483
1484 internal virtual MetaDataElement GetTypeSpec(MetaData md)
1485 {
1486 if (typeSpec == null) {
1487 typeSpec = new TypeSpec(this,md);
1488 md.AddToTable(MDTable.TypeSpec,typeSpec);
1489 }
1490 return typeSpec;
1491 }
1492
1493 internal virtual void TypeSig(MemoryStream str)
1494 {
1495 throw(new TypeSignatureException(this.GetType().AssemblyQualifiedName +
1496 " doesn't have a type signature!!"));
1497 }
1498 }
1499
1500 public class ClassRefInst : Type {
1501
1502 private Type type;
1503 private bool is_value;
1504
1505 public ClassRefInst (Type type, bool is_value) : base (PrimitiveType.Class.GetTypeIndex ())
1506 {
1507 this.type = type;
1508 this.is_value = is_value;
1509 if (is_value)
1510 typeIndex = PrimitiveType.ValueType.GetTypeIndex ();
1511 tabIx = MDTable.TypeSpec;
1512 }
1513
1514 internal sealed override void TypeSig(MemoryStream str)
1515 {
1516 type.TypeSig (str);
1517 }
1518 }
1519
1520 /**************************************************************************/
1521 /// <summary>
1522 /// The base descriptor for a class
1523 /// </summary>
1524 public abstract class Class : Type {
1525
1526 protected int row = 0;
1527 public string name, nameSpace;
1528 protected uint nameIx, nameSpaceIx;
1529 protected MetaData _metaData;
1530 internal Class(string nameSpaceName, string className, MetaData md)
1531 : base(PrimitiveType.Class.GetTypeIndex ())
1532 {
1533 nameSpace = nameSpaceName;
1534 name = className;
1535 nameIx = md.AddToStringsHeap(name);
1536 nameSpaceIx = md.AddToStringsHeap(nameSpace);
1537 _metaData = md;
1538 }
1539
1540 internal Class(uint nsIx, uint nIx) : base(PrimitiveType.Class.GetTypeIndex ())
1541 {
1542 nameSpaceIx = nsIx;
1543 nameIx = nIx;
1544 }
1545
1546 internal Class (byte typeIndex) : base (typeIndex)
1547 {
1548 nameSpace = "Should not be used";
1549 name = "Should not be used";
1550 }
1551
1552 internal virtual uint TypeDefOrRefToken() { return 0; }
1553
1554 internal virtual void MakeValueClass(ValueClass vClass)
1555 {
1556 typeIndex = PrimitiveType.ValueType.GetTypeIndex ();
1557 }
1558
1559 internal virtual string TypeName()
1560 {
1561 return (nameSpace + "." + name);
1562 }
1563
1564 internal override MetaDataElement GetTypeSpec(MetaData md)
1565 {
1566 return this;
1567 }
1568 }
1569
1570 /**************************************************************************/
1571 // This Class produces entries in the TypeDef table of the MetaData
1572 // in the PE meta data.
1573
1574 // NOTE: Entry 0 in TypeDef table is always the pseudo class <module>
1575 // which is the parent for functions and variables declared a module level
1576
1577 /// <summary>
1578 /// The descriptor for a class defined in the IL (.class) in the current assembly/module
1579 /// </summary>
1580 ///
1581 public class ClassDef : Class {
1582
1583 private static readonly byte ElementType_Class = 0x12;
1584
1585 Class superType;
1586 ArrayList fields = new ArrayList();
1587 ArrayList methods = new ArrayList();
1588 ArrayList events;
1589 ArrayList properties;
1590 bool typeIndexChecked = true;
1591 uint fieldIx = 0, methodIx = 0;
1592 byte[] securityActions;
1593 uint flags;
1594 ClassLayout layout;
1595 ClassDef parentClass;
1596 MetaData metaData;
1597
1598 internal ClassDef(TypeAttr attrSet, string nsName, string name,
1599 MetaData md) : base(nsName, name, md)
1600 {
1601 metaData = md;
1602 if (! ((nsName == "" && name == "<Module>") || (nsName == "System" && name == "Object")) ) {
1603 superType = metaData.mscorlib.GetSpecialSystemClass(PrimitiveType.Object);
1604 }
1605 flags = (uint)attrSet;
1606 tabIx = MDTable.TypeDef;
1607 }
1608
1609 internal void SetSuper(Class sClass)
1610 {
1611 superType = sClass;
1612 if (! (sClass is GenericTypeInst))
1613 typeIndexChecked = false;
1614 }
1615
1616 internal override void MakeValueClass(ValueClass vClass)
1617 {
1618 if (vClass == ValueClass.Enum)
1619 superType = metaData.mscorlib.EnumType();
1620 else
1621 superType = metaData.mscorlib.ValueType();
1622
1623 typeIndex = PrimitiveType.ValueType.GetTypeIndex ();
1624 }
1625
1626 public void SpecialNoSuper()
1627 {
1628 superType = null;
1629 }
1630
1631 /// <summary>
1632 /// Add an attribute to this class
1633 /// </summary>
1634 /// <param name="ta">the attribute to be added</param>
1635 public void AddAttribute(TypeAttr ta)
1636 {
1637 flags |= (uint)ta;
1638 }
1639
1640 /// <summary>
1641 /// Add an interface that is implemented by this class
1642 /// </summary>
1643 /// <param name="iFace">the interface that is implemented</param>
1644 public void AddImplementedInterface(Class iFace)
1645 {
1646 metaData.AddToTable(MDTable.InterfaceImpl,new InterfaceImpl(this,iFace));
1647 }
1648
1649 /// <summary>
1650 /// Add a named generic type parameter
1651 /// </summary>
1652 public GenericParameter AddGenericParameter (short index, string name)
1653 {
1654 return AddGenericParameter (index, name, 0);
1655 }
1656
1657 /// <summary>
1658 /// Add a named generic type parameter with attributes
1659 /// </summary>
1660 public GenericParameter AddGenericParameter (short index, string name, GenericParamAttributes attr)
1661 {
1662 GenericParameter gp = new GenericParameter (this, metaData, index, name, attr);
1663 metaData.AddToTable (MDTable.GenericParam, gp);
1664 return gp;
1665 }
1666
1667 /// <summary>
1668 /// Add a field to this class
1669 /// </summary>
1670 /// <param name="name">field name</param>
1671 /// <param name="fType">field type</param>
1672 /// <returns>a descriptor for this new field</returns>
1673 public FieldDef AddField(string name, Type fType)
1674 {
1675 FieldDef field = new FieldDef(name,fType);
1676 fields.Add(field);
1677 return field;
1678 }
1679
1680 /// <summary>
1681 /// Add a field to this class
1682 /// </summary>
1683 /// <param name="fAtts">attributes for this field</param>
1684 /// <param name="name">field name</param>
1685 /// <param name="fType">field type</param>
1686 /// <returns>a descriptor for this new field</returns>
1687 public FieldDef AddField(FieldAttr fAtts, string name, Type fType)
1688 {
1689 FieldDef field = new FieldDef(fAtts,name,fType);
1690 fields.Add(field);
1691 return field;
1692 }
1693
1694 public void SetFieldOrder (ArrayList fields)
1695 {
1696 this.fields = fields;
1697 }
1698
1699 /// <summary>
1700 /// Add a method to this class
1701 /// </summary>
1702 /// <param name="name">method name</param>
1703 /// <param name="retType">return type</param>
1704 /// <param name="pars">parameters</param>
1705 /// <returns>a descriptor for this new method</returns>
1706 public MethodDef AddMethod(string name, Type retType, Param[] pars)
1707 {
1708 return AddMethod (name, new Param (ParamAttr.Default, "", retType), pars);
1709 }
1710
1711 public MethodDef AddMethod (string name, Param ret_param, Param [] pars)
1712 {
1713 // Console.WriteLine("Adding method " + name + " to class " + this.name);
1714 MethodDef meth = new MethodDef(metaData,name, ret_param, pars);
1715 methods.Add(meth);
1716 return meth;
1717 }
1718
1719 /// <summary>
1720 /// Add a method to this class
1721 /// </summary>
1722 /// <param name="mAtts">attributes for this method</param>
1723 /// <param name="iAtts">implementation attributes for this method</param>
1724 /// <param name="name">method name</param>
1725 /// <param name="retType">return type</param>
1726 /// <param name="pars">parameters</param>
1727 /// <returns>a descriptor for this new method</returns>
1728 public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name,
1729 Param ret_param, Param [] pars) {
1730 // Console.WriteLine("Adding method " + name + " to class " + this.name);
1731 MethodDef meth = new MethodDef (metaData, mAtts, iAtts, name, ret_param, pars);
1732 methods.Add(meth);
1733 return meth;
1734 }
1735
1736 /// <summary>
1737 /// Add an event to this class
1738 /// </summary>
1739 /// <param name="name">event name</param>
1740 /// <param name="eType">event type</param>
1741 /// <returns>a descriptor for this new event</returns>
1742 public Event AddEvent(string name, Type eType)
1743 {
1744 Event e = new Event(name,eType,this);
1745 if (events == null) events = new ArrayList();
1746 events.Add(e);
1747 return e;
1748 }
1749
1750 /// <summary>
1751 /// Add a property to this class
1752 /// </summary>
1753 /// <param name="name">property name</param>
1754 /// <param name="propType">property type</param>
1755 /// <returns>a descriptor for this new property</returns>
1756 public Property AddProperty(string name, Type retType, Type[] pars)
1757 {
1758 Property p = new Property(name, retType, pars, this);
1759 if (properties == null) properties = new ArrayList();
1760 properties.Add(p);
1761 return p;
1762 }
1763
1764 /// <summary>
1765 /// Add a nested class to this class
1766 /// </summary>
1767 /// <param name="attrSet">attributes for this nested class</param>
1768 /// <param name="nsName">nested name space name</param>
1769 /// <param name="name">nested class name</param>
1770 /// <returns>a descriptor for this new nested class</returns>
1771 public ClassDef AddNestedClass(TypeAttr attrSet, string nsName,
1772 string name) {
1773 ClassDef nClass = new ClassDef(attrSet,"",name,metaData);
1774 metaData.AddToTable(MDTable.TypeDef,nClass);
1775 metaData.AddToTable(MDTable.NestedClass,new MapElem(nClass,Row,MDTable.TypeDef));
1776 nClass.parentClass = this;
1777 return (nClass);
1778 }
1779
1780 public static bool IsValueType (Class type)
1781 {
1782 return IsValueType (type.nameSpace, type.name);
1783 }
1784
1785 public static bool IsEnum (Class type)
1786 {
1787 return IsEnum (type.nameSpace, type.name);
1788 }
1789
1790 public static bool IsValueType (string nsName, string name)
1791 {
1792 return (nsName == "System" && name == "ValueType");
1793 }
1794
1795 public static bool IsEnum (string nsName, string name)
1796 {
1797 return (nsName == "System" && name == "Enum");
1798 }
1799
1800 /// <summary>
1801 /// Add a nested class to this class
1802 /// </summary>
1803 /// <param name="attrSet">attributes for this nested class</param>
1804 /// <param name="nsName">nested name space name</param>
1805 /// <param name="name">nested class name</param>
1806 /// <param name="sType">super type of this nested class</param>
1807 /// <returns>a descriptor for this new nested class</returns>
1808 public ClassDef AddNestedClass(TypeAttr attrSet, string nsName,
1809 string name, Class sType) {
1810 ClassDef nClass = AddNestedClass (attrSet, nsName, name);
1811 nClass.SetSuper(sType);
1812 if (ClassDef.IsValueType (sType))
1813 nClass.MakeValueClass (ValueClass.ValueType);
1814 else
1815 if (ClassDef.IsEnum (sType))
1816 nClass.MakeValueClass (ValueClass.Enum);
1817
1818 if (ClassDef.IsValueType (sType) || ClassDef.IsEnum (sType))
1819 nClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ());
1820
1821 nClass.typeIndexChecked = true;
1822 return (nClass);
1823 }
1824
1825 /// <summary>
1826 /// Add layout information for this class. This class must have the
1827 /// sequential or explicit attribute.
1828 /// </summary>
1829 /// <param name="packSize">packing size (.pack)</param>
1830 /// <param name="classSize">class size (.size)</param>
1831 public void AddLayoutInfo (int packSize, int classSize)
1832 {
1833 layout = new ClassLayout(packSize,classSize,this);
1834 }
1835
1836 /// <summary>
1837 /// Use a method as the implementation for another method (.override)
1838 /// </summary>
1839 /// <param name="decl">the method to be overridden</param>
1840 /// <param name="body">the implementation to be used</param>
1841 public void AddMethodOverride(Method decl, Method body)
1842 {
1843 metaData.AddToTable(MDTable.MethodImpl,new MethodImpl(this,decl,body));
1844 }
1845
1846 /// <summary>
1847 /// Add security to this class NOT YET IMPLEMENTED
1848 /// </summary>
1849 /// <param name="permissionSet"></param>
1850 public void AddSecurity(byte[] permissionSet)
1851 {
1852 throw(new NotYetImplementedException("Class security "));
1853 //flags |= HasSecurity;
1854 // securityActions = permissionSet;
1855 }
1856
1857 //public void AddLineInfo(int row, int col) { }
1858
1859 internal void CheckTypeIndex()
1860 {
1861 if (typeIndexChecked) return;
1862 if (superType is ClassDef)
1863 ((ClassDef)superType).CheckTypeIndex();
1864 typeIndex = superType.GetTypeIndex();
1865 typeIndexChecked = true;
1866 }
1867
1868 internal sealed override void BuildTables(MetaData md)
1869 {
1870 if (done) return;
1871 if ((flags & (uint)TypeAttr.Interface) != 0) { superType = null; }
1872 // Console.WriteLine("Building tables for " + name);
1873 if (layout != null) md.AddToTable(MDTable.ClassLayout,layout);
1874 // Console.WriteLine("adding methods " + methods.Count);
1875 methodIx = md.TableIndex(MDTable.Method);
1876 for (int i=0; i < methods.Count; i++) {
1877 md.AddToTable(MDTable.Method,(MetaDataElement)methods[i]);
1878 ((MethodDef)methods[i]).BuildTables(md);
1879 }
1880 // Console.WriteLine("adding fields");
1881 fieldIx = md.TableIndex(MDTable.Field);
1882 for (int i=0; i < fields.Count; i++) {
1883 md.AddToTable(MDTable.Field,(MetaDataElement)fields[i]);
1884 ((FieldDef)fields[i]).BuildTables(md);
1885 }
1886 // Console.WriteLine("adding events and properties");
1887 if (events != null) {
1888 for (int i=0; i < events.Count; i++) {
1889 md.AddToTable(MDTable.Event,(Event)events[i]);
1890 ((Event)events[i]).BuildTables(md);
1891 }
1892 md.AddToTable(MDTable.EventMap,
1893 new MapElem(this,((Event)events[0]).Row,MDTable.Event));
1894 }
1895 if (properties != null) {
1896 for (int i=0; i < properties.Count; i++) {
1897 md.AddToTable(MDTable.Property,(Property)properties[i]);
1898 ((Property)properties[i]).BuildTables(md);
1899 }
1900 md.AddToTable(MDTable.PropertyMap,new MapElem(this,
1901 ((Property)properties[0]).Row,MDTable.Property));
1902 }
1903 // Console.WriteLine("End of building tables");
1904 done = true;
1905 }
1906
1907 internal sealed override uint Size(MetaData md)
1908 {
1909 return 4 + 2 * md.StringsIndexSize() +
1910 md.CodedIndexSize(CIx.TypeDefOrRef) +
1911 md.TableIndexSize(MDTable.Field) +
1912 md.TableIndexSize(MDTable.Method);
1913 }
1914
1915 internal sealed override void Write(FileImage output)
1916 {
1917 output.Write(flags);
1918 output.StringsIndex(nameIx);
1919 output.StringsIndex(nameSpaceIx);
1920 //if (superType != null)
1921 // Console.WriteLine("getting coded index for superType of " + name + " = " + superType.GetCodedIx(CIx.TypeDefOrRef));
1922 output.WriteCodedIndex(CIx.TypeDefOrRef,superType);
1923 output.WriteIndex(MDTable.Field,fieldIx);
1924 output.WriteIndex(MDTable.Method,methodIx);
1925 }
1926
1927 internal sealed override uint TypeDefOrRefToken()
1928 {
1929 uint cIx = Row;
1930 cIx = cIx << 2;
1931 return cIx;
1932 }
1933
1934 internal sealed override void TypeSig(MemoryStream sig)
1935 {
1936 if (!typeIndexChecked) CheckTypeIndex();
1937 sig.WriteByte(GetTypeIndex());
1938 MetaData.CompressNum(TypeDefOrRefToken(),sig);
1939 }
1940
1941 internal sealed override uint GetCodedIx(CIx code)
1942 {
1943 switch (code) {
1944 case (CIx.TypeDefOrRef) : return 0;
1945 case (CIx.HasCustomAttr) : return 3;
1946 case (CIx.HasDeclSecurity) : return 0;
1947 case (CIx.TypeOrMethodDef) : return 0;
1948 }
1949 return 0;
1950 }
1951
1952 }
1953
1954 /**************************************************************************/
1955 /// <summary>
1956 /// Descriptor for a class/interface declared in another module of THIS
1957 /// assembly, or in another assembly.
1958 /// </summary>
1959 public class ClassRef : Class, IExternRef, IResolutionScope {
1960
1961 protected IResolutionScope parent;
1962 ExternClass externClass;
1963 protected MetaData metaData;
1964
1965 internal ClassRef(string nsName, string name, MetaData md) : base(nsName, name, md)
1966 {
1967 metaData = md;
1968 tabIx = MDTable.TypeRef;
1969 }
1970
1971 /// <summary>
1972 /// Add a method to this class
1973 /// </summary>
1974 /// <param name="name">method name</param>
1975 /// <param name="retType">return type</param>
1976 /// <param name="pars">parameter types</param>
1977 /// <returns>a descriptor for this method</returns>
1978 public MethodRef AddMethod(string name, Type retType, Type[] pars)
1979 {
1980 return AddMethod (name, retType, pars, 0);
1981 }
1982
1983 /// <summary>
1984 /// Add a method to this class
1985 /// </summary>
1986 /// <param name="name">method name</param>
1987 /// <param name="retType">return type</param>
1988 /// <param name="pars">parameter types</param>
1989 /// <param name="gen_param_count">num of generic parameters</param>
1990 /// <returns>a descriptor for this method</returns>
1991 public MethodRef AddMethod (string name, Type retType, Type[] pars, int gen_param_count)
1992 {
1993 MethodRef meth = new MethodRef (this, name, retType, pars, false, null, gen_param_count);
1994 metaData.AddToTable(MDTable.MemberRef,meth);
1995 return meth;
1996 }
1997
1998 /// <summary>
1999 /// Add a method to this class
2000 /// </summary>
2001 /// <param name="name">method name</param>
2002 /// <param name="retType">return type</param>
2003 /// <param name="pars">parameter types</param>
2004 /// <returns>a descriptor for this method</returns>
2005 public MethodRef AddVarArgMethod(string name, Type retType,
2006 Type[] pars, Type[] optPars)
2007 {
2008 MethodRef meth = new MethodRef(this,name,retType,pars,true,optPars, 0);
2009 metaData.AddToTable(MDTable.MemberRef,meth);
2010 return meth;
2011 }
2012
2013 /// <summary>
2014 /// Add a field to this class
2015 /// </summary>
2016 /// <param name="name">field name</param>
2017 /// <param name="fType">field type</param>
2018 /// <returns>a descriptor for this field</returns>
2019 public FieldRef AddField(string name, Type fType)
2020 {
2021 FieldRef field = new FieldRef(this,name,fType);
2022 metaData.AddToTable(MDTable.MemberRef,field);
2023 return field;
2024 }
2025
2026 public ClassRef AddClass (string nsName, string name)
2027 {
2028 ClassRef aClass = new ClassRef(nsName,name,metaData);
2029 metaData.AddToTable(MDTable.TypeRef,aClass);
2030 aClass.SetParent(this);
2031 return aClass;
2032 }
2033
2034 public ClassRef AddValueClass (string nsName, string name)
2035 {
2036 ClassRef aClass = AddClass (nsName, name);
2037 aClass.MakeValueClass (ValueClass.ValueType);
2038 return aClass;
2039 }
2040
2041 internal void SetParent(IResolutionScope par)
2042 {
2043 parent = par;
2044 }
2045
2046 internal override string TypeName()
2047 {
2048 if ((parent != null) && (parent is AssemblyRef))
2049 return (nameSpace + "." + name + ", " + ((AssemblyRef)parent).TypeName());
2050 else
2051 return (nameSpace + name);
2052 }
2053
2054 internal sealed override uint Size(MetaData md)
2055 {
2056 return md.CodedIndexSize(CIx.ResolutionScope) + 2 *
2057 md.StringsIndexSize();
2058 }
2059
2060 internal sealed override void Write(FileImage output)
2061 {
2062 output.WriteCodedIndex(CIx.ResolutionScope,(MetaDataElement) parent);
2063 output.StringsIndex(nameIx);
2064 output.StringsIndex(nameSpaceIx);
2065 }
2066
2067 internal override sealed uint TypeDefOrRefToken()
2068 {
2069 uint cIx = Row;
2070 cIx = (cIx << 2) | 0x1;
2071 return cIx;
2072 }
2073
2074 internal override void TypeSig(MemoryStream sig)
2075 {
2076 sig.WriteByte(GetTypeIndex());
2077 MetaData.CompressNum(TypeDefOrRefToken(),sig);
2078 }
2079
2080 internal sealed override uint GetCodedIx(CIx code)
2081 {
2082 switch (code) {
2083 case (CIx.TypeDefOrRef) : return 1;
2084 case (CIx.HasCustomAttr) : return 2;
2085 case (CIx.MemberRefParent) : return 1;
2086 case (CIx.ResolutionScope) : return 3;
2087 }
2088 return 0;
2089 }
2090
2091 }
2092
2093 /**************************************************************************/
2094 public class ExternClassRef : ClassRef {
2095
2096 ExternClass externClass;
2097
2098 internal ExternClassRef(TypeAttr attrs, string nsName, string name,
2099 FileRef declFile, MetaData md) : base(nsName,name,md)
2100 {
2101 externClass = new ExternClass(attrs,nameSpaceIx,nameIx,declFile);
2102 metaData.AddToTable(MDTable.ExportedType,externClass);
2103 }
2104
2105 internal ExternClassRef(string name, MetaData md) : base(null,name,md)
2106 {
2107 }
2108
2109 public ClassRef AddNestedClass(TypeAttr attrs, string name)
2110 {
2111 ExternClassRef nestedClass = new ExternClassRef(name,metaData);
2112 externClass = new ExternClass(attrs,0,nameIx,this.externClass);
2113 metaData.AddToTable(MDTable.ExportedType,externClass);
2114 return nestedClass;
2115 }
2116
2117 }
2118
2119 /**************************************************************************/
2120 /// <summary>
2121 /// Descriptor for a class defined in another module of THIS assembly
2122 /// and exported (.class extern)
2123 /// </summary>
2124
2125 internal class ExternClass : Class {
2126
2127 MetaDataElement parent;
2128 uint flags;
2129
2130 internal ExternClass(TypeAttr attr, uint nsIx, uint nIx,
2131 MetaDataElement paren) : base(nsIx,nIx)
2132 {
2133 flags = (uint)attr;
2134 parent = paren;
2135 tabIx = MDTable.ExportedType;
2136 }
2137
2138 internal sealed override uint Size(MetaData md)
2139 {
2140 return 8 + 2* md.StringsIndexSize() + md.CodedIndexSize(CIx.Implementation);
2141 }
2142
2143 internal sealed override void Write(FileImage output)
2144 {
2145 output.Write(flags);
2146 output.Write(0);
2147 output.StringsIndex(nameIx);
2148 output.StringsIndex(nameSpaceIx);
2149 output.WriteCodedIndex(CIx.Implementation,parent);
2150 }
2151
2152 internal sealed override uint GetCodedIx(CIx code)
2153 {
2154 switch (code) {
2155 case (CIx.HasCustomAttr) : return 17;
2156 case (CIx.Implementation) : return 2;
2157 }
2158 return 0;
2159 }
2160
2161 }
2162
2163 public class GenParam : Class {
2164
2165 private int index;
2166 private string param_name;
2167 private uint sigIx = 0;
2168
2169 public GenParam (int index, string name, GenParamType ptype) : base ((byte) ptype)
2170 {
2171 this.index = index;
2172 this.param_name = name;
2173 tabIx = MDTable.TypeSpec;
2174 }
2175
2176 public int Index {
2177 get { return index; }
2178 set { index = value; }
2179 }
2180
2181 public string Name {
2182 get { return param_name; }
2183 set { param_name = value; }
2184 }
2185
2186 public GenParamType Type {
2187 get { return (GenParamType) GetTypeIndex (); }
2188 }
2189
2190 internal sealed override void BuildTables (MetaData md)
2191 {
2192 if (done)
2193 return;
2194 MemoryStream str = new MemoryStream ();
2195 TypeSig (str);
2196 sigIx = md.AddToBlobHeap (str.ToArray ());
2197
2198 done = true;
2199 }
2200
2201 internal sealed override void TypeSig(MemoryStream str)
2202 {
2203 if (index < 0)
2204 throw new PEFileException (String.Format ("Unresolved {0} - {1}", (GenParamType) GetTypeIndex (), param_name));
2205 str.WriteByte(typeIndex);
2206 MetaData.CompressNum ((uint) index, str);
2207 }
2208
2209 internal override uint Size(MetaData md)
2210 {
2211 return md.BlobIndexSize();
2212 }
2213
2214 internal sealed override void Write (FileImage output)
2215 {
2216 output.BlobIndex (sigIx);
2217 }
2218
2219 internal sealed override uint GetCodedIx(CIx code)
2220 {
2221 switch (code) {
2222 case (CIx.TypeDefOrRef) : return 2;
2223 case (CIx.HasCustomAttr) : return 13;
2224 case (CIx.MemberRefParent) : return 4;
2225 }
2226 return 0;
2227 }
2228 }
2229
2230 public class GenericTypeInst : Class {
2231
2232 private Type gen_type;
2233 private Type[] gen_param;
2234 bool inTable = false;
2235 uint sigIx = 0;
2236
2237 public GenericTypeInst (Type gen_type, Type[] gen_param)
2238 : base ((byte) PrimitiveType.GenericInst.GetTypeIndex ())
2239 {
2240 this.gen_type = gen_type;
2241 this.gen_param = gen_param;
2242 tabIx = MDTable.TypeSpec;
2243 }
2244
2245 internal override MetaDataElement GetTypeSpec (MetaData md)
2246 {
2247 if (!inTable) {
2248 md.AddToTable (MDTable.TypeSpec, this);
2249 inTable = true;
2250 }
2251
2252 return this;
2253 }
2254
2255 internal sealed override void TypeSig(MemoryStream str)
2256 {
2257 str.WriteByte(typeIndex);
2258 gen_type.TypeSig (str);
2259 MetaData.CompressNum ((uint) gen_param.Length, str);
2260 foreach (Type param in gen_param)
2261 param.TypeSig (str);
2262 }
2263
2264 internal sealed override void BuildTables (MetaData md)
2265 {
2266 if (done)
2267 return;
2268 MemoryStream str = new MemoryStream ();
2269 TypeSig (str);
2270 sigIx = md.AddToBlobHeap (str.ToArray ());
2271
2272 done = true;
2273 }
2274
2275 internal sealed override uint Size (MetaData md)
2276 {
2277 return md.BlobIndexSize ();
2278 }
2279
2280 internal sealed override void Write (FileImage output)
2281 {
2282 output.BlobIndex (sigIx);
2283 }
2284
2285 internal sealed override uint GetCodedIx (CIx code)
2286 {
2287 switch (code) {
2288 case (CIx.TypeDefOrRef): return 2;
2289 case (CIx.MemberRefParent): return 4;
2290 case (CIx.HasCustomAttr): return 13;
2291 }
2292 return 0;
2293 }
2294 }
2295
2296 public class GenericMethodSig {
2297
2298 private Type[] gen_param;
2299 private bool done;
2300 private uint sigIx = 0;
2301
2302 public GenericMethodSig (Type[] gen_param)
2303 {
2304 this.gen_param = gen_param;
2305 done = false;
2306 }
2307
2308 internal void TypeSig (MemoryStream str)
2309 {
2310 str.WriteByte (0x0A); /* GENERIC_INST */
2311 MetaData.CompressNum ((uint) gen_param.Length, str);
2312 foreach (Type param in gen_param)
2313 param.TypeSig (str);
2314 }
2315
2316 internal uint GetSigIx (MetaData md)
2317 {
2318 if (done)
2319 return sigIx;
2320
2321 MemoryStream sig = new MemoryStream();
2322 TypeSig (sig);
2323 sigIx = md.AddToBlobHeap (sig.ToArray());
2324 done = true;
2325 return sigIx;
2326 }
2327 }
2328
2329 public class Sentinel : Type {
2330
2331 public Sentinel () : base (0x41) { }
2332
2333 internal sealed override void TypeSig(MemoryStream str)
2334 {
2335 str.WriteByte(typeIndex);
2336 }
2337 }
2338
2339 /**************************************************************************/
2340 /// <summary>
2341 /// Descriptor for a FunctionPointer type
2342 /// </summary>
2343 ///
2344 public class MethPtrType : Type {
2345
2346 bool varArgMeth;
2347 Type retType;
2348 Type [] parList;
2349 Type [] optParList;
2350 CallConv callConv;
2351 uint numPars;
2352 uint numOptPars;
2353 uint sigIx = 0;
2354
2355 /// <summary>
2356 /// Create a new function pointer type
2357 /// </summary>
2358 /// <param name="meth">the function to be referenced</param>
2359 public MethPtrType (CallConv callconv, Type retType, Type[] pars,
2360 bool varArgMeth, Type[] optPars) : base(0x1B)
2361 {
2362 this.retType = retType;
2363 callConv = callconv;
2364 parList = pars;
2365 this.varArgMeth = varArgMeth;
2366 if (parList != null) numPars = (uint)parList.Length;
2367 if (varArgMeth) {
2368 optParList = optPars;
2369 if (optParList != null) numOptPars = (uint)optParList.Length;
2370 callConv |= CallConv.Vararg;
2371 }
2372 tabIx = MDTable.TypeSpec;
2373 }
2374
2375 internal sealed override void TypeSig(MemoryStream sig)
2376 {
2377 sig.WriteByte(typeIndex);
2378 // Bootlegged from method ref
2379 sig.WriteByte((byte)callConv);
2380 MetaData.CompressNum (numPars + numOptPars, sig);
2381 retType.TypeSig (sig);
2382 for (int i=0; i < numPars; i++) {
2383 parList[i].TypeSig (sig);
2384 }
2385 if (varArgMeth) {
2386 sig.WriteByte (0x41); // Write the sentinel
2387 for (int i=0; i < numOptPars; i++) {
2388 optParList[i].TypeSig (sig);
2389 }
2390 }
2391 }
2392
2393 internal sealed override void BuildTables(MetaData md)
2394 {
2395 if (done) return;
2396 MemoryStream sig = new MemoryStream();
2397 TypeSig(sig);
2398 sigIx = md.AddToBlobHeap(sig.ToArray());
2399 done = true;
2400 }
2401
2402 internal sealed override uint Size(MetaData md)
2403 {
2404 return md.BlobIndexSize();
2405 }
2406
2407 internal sealed override void Write(FileImage output)
2408 {
2409 output.BlobIndex(sigIx);
2410 }
2411
2412 internal sealed override uint GetCodedIx(CIx code) { return 0x1B; }
2413
2414 }
2415
2416 #region Array Types
2417 /* Classes for Arrays */
2418
2419 /// <summary>
2420 /// The IL Array type
2421 /// </summary>
2422 public abstract class Array : Type {
2423
2424 protected Type elemType;
2425 protected MetaData metaData;
2426 protected string cnameSpace, cname;
2427
2428 internal Array(Type eType, byte TypeId) : base(TypeId)
2429 {
2430 elemType = eType;
2431 tabIx = MDTable.TypeSpec;
2432 }
2433 }
2434
2435 /// <summary>
2436 /// Single dimensional array with zero lower bound
2437 /// </summary>
2438 public class ZeroBasedArray : Array {
2439
2440 /// <summary>
2441 /// Create a new array - elementType[]
2442 /// </summary>
2443 /// <param name="elementType">the type of the array elements</param>
2444 public ZeroBasedArray(Type elementType) : base (elementType, PrimitiveType.SZArray.GetTypeIndex ()) { }
2445
2446 internal sealed override void TypeSig(MemoryStream str)
2447 {
2448 str.WriteByte(typeIndex);
2449 elemType.TypeSig(str);
2450 }
2451
2452 }
2453
2454 /// <summary>
2455 /// Multi dimensional array with explicit bounds
2456 /// </summary>
2457 public class BoundArray : Array {
2458 int[] lowerBounds;
2459 int[] sizes;
2460 uint numDims;
2461
2462 /// <summary>
2463 /// Create a new multi dimensional array type
2464 /// eg. elemType[1..5,3..10,5,,] would be
2465 /// new BoundArray(elemType,5,[1,3,0],[5,10,4])
2466 /// </summary>
2467 /// <param name="elementType">the type of the elements</param>
2468 /// <param name="dimensions">the number of dimensions</param>
2469 /// <param name="loBounds">lower bounds of dimensions</param>
2470 /// <param name="sizes">sizes for the dimensions</param>
2471 public BoundArray(Type elementType, uint dimensions, int[] loBounds,
2472 int[] sizes) : base (elementType,0x14)
2473 {
2474 numDims = dimensions;
2475 lowerBounds = loBounds;
2476 this.sizes = sizes;
2477 }
2478
2479 /// <summary>
2480 /// Create a new multi dimensional array type
2481 /// eg. elemType[5,10,20] would be new BoundArray(elemType,3,[5,10,20])
2482 /// </summary>
2483 /// <param name="elementType">the type of the elements</param>
2484 /// <param name="dimensions">the number of dimensions</param>
2485 /// <param name="size">the sizes of the dimensions</param>
2486 public BoundArray(Type elementType, uint dimensions, int[] size)
2487 : base (elementType,0x14)
2488 {
2489 numDims = dimensions;
2490 sizes = size;
2491 }
2492
2493 /// <summary>
2494 /// Create a new multi dimensional array type
2495 /// eg. elemType[,,] would be new BoundArray(elemType,3)
2496 /// </summary>
2497 /// <param name="elementType">the type of the elements</param>
2498 /// <param name="dimensions">the number of dimensions</param>
2499 public BoundArray(Type elementType, uint dimensions)
2500 : base (elementType,0x14)
2501 {
2502 numDims = dimensions;
2503 }
2504
2505 internal sealed override void TypeSig(MemoryStream str)
2506 {
2507 str.WriteByte(typeIndex);
2508 elemType.TypeSig(str);
2509 MetaData.CompressNum(numDims,str);
2510 if ((sizes != null) && (sizes.Length > 0)) {
2511
2512 MetaData.CompressNum((uint)sizes.Length,str);
2513 for (int i=0; i < sizes.Length; i++) {
2514 MetaData.CompressNum((uint)sizes[i],str);
2515 }
2516 } else str.WriteByte(0);
2517 if ((lowerBounds != null) && (lowerBounds.Length > 0)) {
2518 MetaData.CompressNum((uint)lowerBounds.Length,str);
2519 for (int i=0; i < lowerBounds.Length; i++) {
2520 CompressSignedNum (lowerBounds[i],str);
2521 }
2522 } else str.WriteByte(0);
2523 }
2524 private void CompressSignedNum (int val, MemoryStream str)
2525 {
2526 uint uval = (uint) val;
2527 byte sign = 0;
2528 if (val < 0) {
2529 val = -val;
2530 sign = 1;
2531 }
2532
2533 /* Map the signed number to an unsigned number in two ways.
2534
2535 fval: left-rotated 2's complement representation
2536 sval: map the signed number to unsigned as follows: 0 -> 0, -1 -> 1, 1 -> 2, -2 -> 3, 2 -> 4, ....
2537 the mapping is: x -> 2*|x| - signbit(x)
2538 */
2539 uint fval = (uval << 1) | sign;
2540 int sval = (val << 1) - sign;
2541
2542 /* An overly clever transformation:
2543
2544 a. sval is used to determine the number of bytes in the compressed representation.
2545 b. fval is truncated to the appropriate number of bits and output using the
2546 normal unsigned-int compressor.
2547
2548 However, or certain values, the truncated fval doesn't carry enough information to round trip.
2549
2550 (fval & 0x3FFF) <= 0x7F => compressor emits 1 byte, not 2 => there is aliasing of values
2551
2552 So, we use full 4 bytes to encode such values.
2553
2554 LAMESPEC: The Microsoft implementation doesn't appear to handle this subtle case.
2555 e.g., it ends up encoding -8192 as the byte 0x01, which decodes to -64
2556 */
2557 if (sval <= 0x7F)
2558 MetaData.CompressNum (fval & 0x7F, str);
2559 else if (sval <= 0x3FFF && (fval & 0x3FFF) > 0x7F)
2560 MetaData.CompressNum (fval & 0x3FFF, str);
2561 else if (sval <= 0x1FFFFFFF && (fval & 0x1FFFFFFF) > 0x3FFF)
2562 MetaData.CompressNum (fval & 0x1FFFFFFF, str);
2563 else
2564 /* FIXME: number cannot be represented. Report a warning. */
2565 // throw new Exception ("cannot represent signed value" + -val);
2566 MetaData.CompressNum (fval, str);
2567 }
2568 }
2569
2570 #endregion
2571
2572
2573 /* Empty interface for grouping TypeRef's possible ResolutionScope
2574 namely : Module, ModuleRef, AssemblyRef and TypeRef */
2575 public interface IResolutionScope {
2576 }
2577
2578 /**************************************************************************/
2579 /// <summary>
2580 /// Base class for scopes (extended by Module, ModuleRef, Assembly, AssemblyRef)
2581 /// </summary>
2582 public abstract class ResolutionScope : MetaDataElement, IResolutionScope {
2583
2584 protected uint nameIx = 0;
2585 protected MetaData metaData;
2586 protected string name;
2587
2588 internal ResolutionScope(string name, MetaData md)
2589 {
2590 metaData = md;
2591 this.name = name;
2592 nameIx = md.AddToStringsHeap(name);
2593 }
2594
2595 internal string GetName() { return name; }
2596
2597 }
2598
2599 /**************************************************************************/
2600 /// <summary>
2601 /// Descriptor for THIS assembly (.assembly)
2602 /// </summary>
2603 public class Assembly : ResolutionScope {
2604
2605 ushort majorVer, minorVer, buildNo, revisionNo;
2606 uint flags;
2607 uint hashAlgId;
2608 uint keyIx = 0, cultIx = 0;
2609 bool hasPublicKey = false;
2610
2611 internal Assembly(string name, MetaData md) : base(name,md)
2612 {
2613 tabIx = MDTable.Assembly;
2614 }
2615
2616 /// <summary>
2617 /// Add details about THIS assembly
2618 /// </summary>
2619 /// <param name="majVer">Major Version</param>
2620 /// <param name="minVer">Minor Version</param>
2621 /// <param name="bldNo">Build Number</param>
2622 /// <param name="revNo">Revision Number</param>
2623 /// <param name="key">Hash Key</param>
2624 /// <param name="hash">Hash Algorithm</param>
2625 /// <param name="cult">Culture</param>
2626 public void AddAssemblyInfo(int majVer, int minVer, int bldNo, int revNo,
2627 byte[] key, uint hash, string cult)
2628 {
2629 majorVer = (ushort)majVer;
2630 minorVer = (ushort)minVer;
2631 buildNo = (ushort)bldNo;
2632 revisionNo = (ushort)revNo;
2633 hashAlgId = hash;
2634 hasPublicKey = (key != null);
2635 keyIx = metaData.AddToBlobHeap(key);
2636 cultIx = metaData.AddToStringsHeap(cult);
2637 }
2638
2639 /// <summary>
2640 /// Add an attribute to THIS assembly
2641 /// </summary>
2642 /// <param name="aa">assembly attribute</param>
2643 public void AddAssemblyAttr(AssemAttr aa)
2644 {
2645 flags |= (uint)aa;
2646 }
2647
2648 internal sealed override uint Size(MetaData md)
2649 {
2650 return 16 + md.BlobIndexSize() + 2 * md.StringsIndexSize();
2651 }
2652
2653 internal sealed override void Write(FileImage output)
2654 {
2655 // Console.WriteLine("Writing assembly element with nameIx of " + nameIx + " at file offset " + output.Seek(0,SeekOrigin.Current));
2656 output.Write((uint)hashAlgId);
2657 output.Write(majorVer);
2658 output.Write(minorVer);
2659 output.Write(buildNo);
2660 output.Write(revisionNo);
2661 output.Write(flags);
2662 output.BlobIndex(keyIx);
2663 output.StringsIndex(nameIx);
2664 output.StringsIndex(cultIx);
2665 }
2666
2667 internal sealed override uint GetCodedIx(CIx code)
2668 {
2669 switch (code) {
2670 case (CIx.HasCustomAttr) : return 14;
2671 case (CIx.HasDeclSecurity) : return 2;
2672 }
2673 return 0;
2674 }
2675
2676 internal bool HasPublicKey {
2677 get { return hasPublicKey; }
2678 }
2679 }
2680
2681 /**************************************************************************/
2682 /// <summary>
2683 /// Descriptor for THIS module
2684 /// </summary>
2685 public class Module : ResolutionScope, IExternRef {
2686
2687 Guid mvid;
2688 uint mvidIx = 0;
2689
2690 internal Module(string name, MetaData md) : base(name,md)
2691 {
2692 mvid = Guid.NewGuid();
2693 mvidIx = md.AddToGUIDHeap(mvid);
2694 tabIx = MDTable.Module;
2695 }
2696
2697 public Guid Guid {
2698 get { return mvid; }
2699 }
2700
2701 public ClassRef AddClass(string nsName, string name)
2702 {
2703 ClassRef aClass = new ClassRef (nsName, name, metaData);
2704 metaData.AddToTable (MDTable.TypeRef, aClass);
2705 aClass.SetParent (this);
2706 return aClass;
2707 }
2708
2709 public ClassRef AddValueClass(string nsName, string name)
2710 {
2711 ClassRef aClass = AddClass (nsName, name);
2712 aClass.MakeValueClass (ValueClass.ValueType);
2713 return aClass;
2714 }
2715
2716 internal sealed override uint Size(MetaData md)
2717 {
2718 return 2 + md.StringsIndexSize() + 3 * md.GUIDIndexSize();
2719 }
2720
2721 internal sealed override void Write(FileImage output)
2722 {
2723 output.Write((short)0);
2724 output.StringsIndex(nameIx);
2725 output.GUIDIndex(mvidIx);
2726 output.GUIDIndex(0);
2727 output.GUIDIndex(0);
2728 }
2729
2730 internal sealed override uint GetCodedIx(CIx code)
2731 {
2732 switch (code) {
2733 case (CIx.HasCustomAttr) : return 7;
2734 case (CIx.ResolutionScope) : return 0;
2735 }
2736 return 0;
2737 }
2738 }
2739 /**************************************************************************/
2740 /// <summary>
2741 /// Descriptor for another module in THIS assembly
2742 /// </summary>
2743 public class ModuleRef : ResolutionScope, IExternRef {
2744
2745 internal ModuleRef(MetaData md, string name) : base(name,md)
2746 {
2747 tabIx = MDTable.ModuleRef;
2748 }
2749
2750 /// <summary>
2751 /// Add a class to this external module. This is a class declared in
2752 /// another module of THIS assembly.
2753 /// </summary>
2754 /// <param name="nsName">name space name</param>
2755 /// <param name="name">class name</param>
2756 /// <returns>a descriptor for this class in another module</returns>
2757 public ClassRef AddClass(string nsName, string name)
2758 {
2759 ClassRef aClass = new ClassRef(nsName,name,metaData);
2760 metaData.AddToTable(MDTable.TypeRef,aClass);
2761 aClass.SetParent(this);
2762 return aClass;
2763 }
2764
2765 /// <summary>
2766 /// Make a file descriptor to correspond to this module. The file
2767 /// descriptor will have the same name as the module descriptor
2768 /// </summary>
2769 /// <param name="hashBytes">the hash of the file</param>
2770 /// <param name="hasMetaData">the file contains metadata</param>
2771 /// <param name="entryPoint">the program entry point is in this file</param>
2772 /// <returns>a descriptor for the file which contains this module</returns>
2773 public FileRef MakeFile(byte[] hashBytes, bool hasMetaData, bool entryPoint)
2774 {
2775 FileRef file = new FileRef(nameIx,hashBytes,hasMetaData,entryPoint,metaData);
2776 metaData.AddToTable(MDTable.File,file);
2777 return file;
2778 }
2779
2780 /// <summary>
2781 /// Add a value class to this module. This is a class declared in
2782 /// another module of THIS assembly.
2783 /// </summary>
2784 /// <param name="nsName">name space name</param>
2785 /// <param name="name">class name</param>
2786 /// <returns></returns>
2787 public ClassRef AddValueClass(string nsName, string name)
2788 {
2789 ClassRef aClass = new ClassRef(nsName,name,metaData);
2790 metaData.AddToTable(MDTable.TypeRef,aClass);
2791 aClass.SetParent(this);
2792 aClass.MakeValueClass(ValueClass.ValueType);
2793 return aClass;
2794 }
2795
2796 /// <summary>
2797 /// Add a class which is declared public in this external module of
2798 /// THIS assembly. This class will be exported from this assembly.
2799 /// The ilasm syntax for this is .extern class
2800 /// </summary>
2801 /// <param name="attrSet">attributes of the class to be exported</param>
2802 /// <param name="nsName">name space name</param>
2803 /// <param name="name">external class name</param>
2804 /// <param name="declFile">the file where the class is declared</param>
2805 /// <param name="isValueClass">is this class a value type?</param>
2806 /// <returns>a descriptor for this external class</returns>
2807 public ExternClassRef AddExternClass(TypeAttr attrSet, string nsName,
2808 string name, FileRef declFile,
2809 bool isValueClass) {
2810 ExternClassRef cRef = new ExternClassRef(attrSet,nsName,name,declFile,metaData);
2811 metaData.AddToTable(MDTable.TypeRef,cRef);
2812 cRef.SetParent(this);
2813 if (isValueClass) cRef.MakeValueClass(ValueClass.ValueType);
2814 return cRef;
2815 }
2816
2817 /// <summary>
2818 /// Add a "global" method in another module
2819 /// </summary>
2820 /// <param name="name">method name</param>
2821 /// <param name="retType">return type</param>
2822 /// <param name="pars">method parameter types</param>
2823 /// <returns>a descriptor for this method in anther module</returns>
2824 public MethodRef AddMethod(string name, Type retType, Type[] pars)
2825 {
2826 MethodRef meth = new MethodRef(this,name,retType,pars,false,null, 0);
2827 metaData.AddToTable(MDTable.MemberRef,meth);
2828 return meth;
2829 }
2830
2831 /// <summary>
2832 /// Add a vararg method to this class
2833 /// </summary>
2834 /// <param name="name">method name</param>
2835 /// <param name="retType">return type</param>
2836 /// <param name="pars">parameter types</param>
2837 /// <param name="optPars">optional param types for this vararg method</param>
2838 /// <returns>a descriptor for this method</returns>
2839 public MethodRef AddVarArgMethod(string name, Type retType,
2840 Type[] pars, Type[] optPars) {
2841 MethodRef meth = new MethodRef(this,name,retType,pars,true,optPars, 0);
2842 metaData.AddToTable(MDTable.MemberRef,meth);
2843 return meth;
2844 }
2845
2846 /// <summary>
2847 /// Add a field in another module
2848 /// </summary>
2849 /// <param name="name">field name</param>
2850 /// <param name="fType">field type</param>
2851 /// <returns>a descriptor for this field in another module</returns>
2852 public FieldRef AddField(string name, Type fType)
2853 {
2854 FieldRef field = new FieldRef(this,name,fType);
2855 metaData.AddToTable(MDTable.MemberRef,field);
2856 return field;
2857 }
2858
2859 internal sealed override uint Size(MetaData md)
2860 {
2861 return md.StringsIndexSize();
2862 }
2863
2864 internal sealed override void Write(FileImage output)
2865 {
2866 output.StringsIndex(nameIx);
2867 }
2868
2869 internal sealed override uint GetCodedIx(CIx code)
2870 {
2871 switch (code) {
2872 case (CIx.HasCustomAttr) : return 12;
2873 case (CIx.MemberRefParent) : return 2;
2874 case (CIx.ResolutionScope) : return 1;
2875 }
2876 return 0;
2877 }
2878
2879 }
2880
2881 #region Classes for Constants
2882 /// <summary>
2883 /// Descriptor for a constant value
2884 /// </summary>
2885 public abstract class Constant {
2886 protected uint size = 0;
2887 protected Type type;
2888 protected uint blobIndex;
2889 protected bool addedToBlobHeap = false;
2890
2891 internal Constant() { }
2892
2893 internal virtual uint GetBlobIndex(MetaData md) { return 0; }
2894
2895 internal uint GetSize() { return size; }
2896
2897 internal byte GetTypeIndex() { return type.GetTypeIndex(); }
2898
2899 internal virtual void Write(BinaryWriter bw) { }
2900
2901 }
2902 /// <summary>
2903 /// Descriptor for a constant value
2904 /// </summary>
2905 public abstract class DataConstant : Constant {
2906 private uint dataOffset = 0;
2907
2908 internal DataConstant() { }
2909
2910 public uint DataOffset {
2911 get { return dataOffset; }
2912 set { dataOffset = value; }
2913 }
2914
2915 }
2916
2917 /// <summary>
2918 /// Boolean constant
2919 /// </summary>
2920 public class BoolConst : Constant {
2921 bool val;
2922
2923 /// <summary>
2924 /// Create a new boolean constant with the value "val"
2925 /// </summary>
2926 /// <param name="val">value of this boolean constant</param>
2927 public BoolConst(bool val)
2928 {
2929 this.val = val;
2930 size = 1;
2931 type = PrimitiveType.Boolean;
2932 }
2933
2934 internal sealed override uint GetBlobIndex(MetaData md)
2935 {
2936 if (!addedToBlobHeap) {
2937 if (val) blobIndex = md.AddToBlobHeap((sbyte)1);
2938 else blobIndex = md.AddToBlobHeap((sbyte)0);
2939 addedToBlobHeap = true;
2940 }
2941 return blobIndex;
2942 }
2943
2944 internal sealed override void Write(BinaryWriter bw)
2945 {
2946 if (val) bw.Write((sbyte)1);
2947 else bw.Write((sbyte)0);
2948 }
2949
2950 }
2951
2952 public class ByteArrConst : DataConstant {
2953 byte[] val;
2954
2955 public ByteArrConst(byte[] val)
2956 {
2957 type = PrimitiveType.String;
2958 this.val = val;
2959 size = (uint)val.Length;
2960 }
2961
2962 public Type Type {
2963 get { return type; }
2964 set { type = value; }
2965 }
2966
2967 internal sealed override uint GetBlobIndex(MetaData md)
2968 {
2969 if (!addedToBlobHeap) {
2970 blobIndex = md.AddToBlobHeap(val);
2971 addedToBlobHeap = true;
2972 }
2973 return blobIndex;
2974 }
2975
2976 internal sealed override void Write(BinaryWriter bw)
2977 {
2978 bw.Write(val);
2979 }
2980
2981 }
2982
2983 public class CharConst : Constant {
2984 char val;
2985
2986 public CharConst(char val)
2987 {
2988 this.val = val;
2989 size = 2;
2990 type = PrimitiveType.Char;
2991 }
2992
2993 internal sealed override uint GetBlobIndex(MetaData md)
2994 {
2995 if (!addedToBlobHeap) {
2996 blobIndex = md.AddToBlobHeap(val);
2997 addedToBlobHeap = true;
2998 }
2999 return blobIndex;
3000 }
3001
3002 internal sealed override void Write(BinaryWriter bw)
3003 {
3004 bw.Write(val);
3005 }
3006
3007 }
3008
3009 public class FloatConst : DataConstant {
3010 float val;
3011
3012 public FloatConst(float val)
3013 {
3014 this.val = val;
3015 size = 4;
3016 type = PrimitiveType.Float32;
3017 }
3018
3019 internal sealed override uint GetBlobIndex(MetaData md)
3020 {
3021 if (!addedToBlobHeap) {
3022 blobIndex = md.AddToBlobHeap(val);
3023 addedToBlobHeap = true;
3024 }
3025 return blobIndex;
3026 }
3027
3028 internal sealed override void Write(BinaryWriter bw)
3029 {
3030 bw.Write(val);
3031 }
3032
3033 }
3034
3035 public class DoubleConst : DataConstant {
3036 double val;
3037
3038 public DoubleConst(double val)
3039 {
3040 this.val = val;
3041 size = 8;
3042 type = PrimitiveType.Float64;
3043 }
3044
3045 internal sealed override uint GetBlobIndex(MetaData md)
3046 {
3047 if (!addedToBlobHeap) {
3048 blobIndex = md.AddToBlobHeap(val);
3049 addedToBlobHeap = true;
3050 }
3051 return blobIndex;
3052 }
3053
3054 internal sealed override void Write(BinaryWriter bw)
3055 {
3056 bw.Write(val);
3057 }
3058
3059 }
3060
3061 public class IntConst : DataConstant {
3062 long val;
3063
3064 public IntConst(sbyte val)
3065 {
3066 this.val = val;
3067 size = 1;
3068 type = PrimitiveType.Int8;
3069 }
3070
3071 public IntConst(short val)
3072 {
3073 this.val = val;
3074 size = 2;
3075 type = PrimitiveType.Int16;
3076 }
3077
3078 public IntConst(int val)
3079 {
3080 this.val = val;
3081 size = 4;
3082 type = PrimitiveType.Int32;
3083 }
3084
3085 public IntConst(long val)
3086 {
3087 this.val = val;
3088 size = 8;
3089 type = PrimitiveType.Int64;
3090 }
3091
3092 internal sealed override uint GetBlobIndex(MetaData md)
3093 {
3094 if (!addedToBlobHeap) {
3095 switch (size) {
3096 case (1) : blobIndex = md.AddToBlobHeap((sbyte)val); break;
3097 case (2) : blobIndex = md.AddToBlobHeap((short)val); break;
3098 case (4) : blobIndex = md.AddToBlobHeap((int)val); break;
3099 default : blobIndex = md.AddToBlobHeap(val); break;
3100 }
3101 addedToBlobHeap = true;
3102 }
3103 return blobIndex;
3104 }
3105
3106 internal sealed override void Write(BinaryWriter bw)
3107 {
3108 switch (size) {
3109 case (1) : bw.Write((sbyte)val); break;
3110 case (2) : bw.Write((short)val); break;
3111 case (4) : bw.Write((int)val); break;
3112 default : bw.Write(val); break;
3113 }
3114 }
3115
3116 }
3117
3118 public class UIntConst : Constant {
3119 ulong val;
3120
3121 public UIntConst(byte val)
3122 {
3123 this.val = val;
3124 size = 1;
3125 type = PrimitiveType.UInt8;
3126 }
3127 public UIntConst(ushort val)
3128 {
3129 this.val = val;
3130 size = 2;
3131 type = PrimitiveType.UInt16;
3132 }
3133 public UIntConst(uint val)
3134 {
3135 this.val = val;
3136 size = 4;
3137 type = PrimitiveType.UInt32;
3138 }
3139 public UIntConst(ulong val)
3140 {
3141 this.val = val;
3142 size = 8;
3143 type = PrimitiveType.UInt64;
3144 }
3145
3146 internal sealed override uint GetBlobIndex(MetaData md)
3147 {
3148 if (!addedToBlobHeap) {
3149 switch (size) {
3150 case (1) : blobIndex = md.AddToBlobHeap((byte)val); break;
3151 case (2) : blobIndex = md.AddToBlobHeap((ushort)val); break;
3152 case (4) : blobIndex = md.AddToBlobHeap((uint)val); break;
3153 default : blobIndex = md.AddToBlobHeap(val); break;
3154 }
3155 addedToBlobHeap = true;
3156 }
3157 return blobIndex;
3158 }
3159
3160 internal sealed override void Write(BinaryWriter bw)
3161 {
3162 switch (size) {
3163 case (1) : bw.Write((byte)val); break;
3164 case (2) : bw.Write((ushort)val); break;
3165 case (4) : bw.Write((uint)val); break;
3166 default : bw.Write(val); break;
3167 }
3168 }
3169
3170 }
3171
3172 public class StringConst : DataConstant {
3173 string val;
3174
3175 public StringConst(string val)
3176 {
3177 this.val = val;
3178 size = (uint)val.Length; // need to add null ??
3179 type = PrimitiveType.String;
3180 }
3181
3182 internal sealed override uint GetBlobIndex(MetaData md)
3183 {
3184 if (!addedToBlobHeap) {
3185 byte [] b = Encoding.Unicode.GetBytes (val);
3186 blobIndex = md.AddToBlobHeap(b);
3187 addedToBlobHeap = true;
3188 }
3189 return blobIndex;
3190 }
3191
3192 internal sealed override void Write(BinaryWriter bw)
3193 {
3194 bw.Write(val);
3195 }
3196
3197 }
3198
3199 public class NullConst : Constant {
3200
3201 public NullConst()
3202 {
3203 size = 4;
3204 type = PrimitiveType.Class;
3205 }
3206
3207 internal sealed override uint GetBlobIndex(MetaData md)
3208 {
3209 if (!addedToBlobHeap) {
3210 blobIndex = md.AddToBlobHeap((int)0);
3211 addedToBlobHeap = true;
3212 }
3213 return blobIndex;
3214 }
3215
3216 internal sealed override void Write(BinaryWriter bw)
3217 {
3218 bw.Write((int)0);
3219 }
3220
3221 }
3222
3223 public class AddressConstant : DataConstant {
3224 DataConstant data;
3225
3226 public AddressConstant(DataConstant dConst)
3227 {
3228 data = dConst;
3229 size = 4;
3230 type = PrimitiveType.TypedRef;
3231 }
3232
3233 internal sealed override void Write(BinaryWriter bw)
3234 {
3235 ((FileImage)bw).WriteDataRVA(data.DataOffset);
3236 }
3237
3238 }
3239
3240 public class RepeatedConstant : DataConstant {
3241 DataConstant data;
3242 uint repCount;
3243
3244 public RepeatedConstant(DataConstant dConst, int repeatCount)
3245 {
3246 data = dConst;
3247 repCount = (uint)repeatCount;
3248 int[] sizes = new int[1];
3249 sizes[0] = repeatCount;
3250 type = new BoundArray(type,1,sizes);
3251 size = data.GetSize() * repCount;
3252 }
3253
3254 internal sealed override void Write(BinaryWriter bw)
3255 {
3256 for (int i=0; i < repCount; i++) {
3257 data.Write(bw);
3258 }
3259 }
3260
3261 }
3262
3263 public class ArrayConstant : DataConstant {
3264 DataConstant[] dataVals;
3265
3266 public ArrayConstant(DataConstant[] dVals)
3267 {
3268 dataVals = dVals;
3269 for (int i=0; i < dataVals.Length; i++) {
3270 size += dataVals[i].GetSize();
3271 }
3272 }
3273
3274 internal sealed override void Write(BinaryWriter bw)
3275 {
3276 for (int i=0; i < dataVals.Length; i++) {
3277 dataVals[i].Write(bw);
3278 }
3279 }
3280
3281 }
3282
3283 public class ClassType : Constant {
3284 string name;
3285 Class desc;
3286
3287 public ClassType(string className)
3288 {
3289 name = className;
3290 type = PrimitiveType.ClassType;
3291 }
3292
3293 public ClassType(Class classDesc)
3294 {
3295 desc = classDesc;
3296 type = PrimitiveType.ClassType;
3297 }
3298
3299 internal override void Write(BinaryWriter bw)
3300 {
3301 if (name == null) name = desc.TypeName();
3302 bw.Write(name);
3303 }
3304
3305 }
3306
3307 #endregion
3308
3309 /**************************************************************************/
3310 /// <summary>
3311 /// Descriptor for a custom modifier of a type (modopt or modreq)
3312 /// </summary>
3313
3314 public class CustomModifiedType : Type {
3315
3316 Type type;
3317 Class cmodType;
3318
3319 /// <summary>
3320 /// Create a new custom modifier for a type
3321 /// </summary>
3322 /// <param name="type">the type to be modified</param>
3323 /// <param name="cmod">the modifier</param>
3324 /// <param name="cmodType">the type reference to be associated with the type</param>
3325 public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)
3326 : base((byte)cmod)
3327 {
3328 this.type = type;
3329 this.cmodType = cmodType;
3330 }
3331
3332 internal sealed override void TypeSig(MemoryStream str)
3333 {
3334 str.WriteByte(typeIndex);
3335 MetaData.CompressNum(cmodType.TypeDefOrRefToken(),str);
3336 type.TypeSig(str);
3337 }
3338
3339 }
3340
3341 /**************************************************************************/
3342 /// <summary>
3343 /// Base class for Event and Property descriptors
3344 /// </summary>
3345
3346 public class Feature : MetaDataElement {
3347
3348 internal enum MethodType : ushort { Setter = 0x01, Getter, Other = 0x04, AddOn = 0x08,
3349 RemoveOn = 0x10, Fire = 0x20 }
3350
3351 private static readonly int INITSIZE = 5;
3352 private static readonly ushort specialName = 0x200;
3353 private static readonly ushort rtSpecialName = 0x400;
3354
3355 protected ClassDef parent;
3356 protected ushort flags = 0;
3357 protected string name;
3358 protected int tide = 0;
3359 protected uint nameIx;
3360 protected MethodSemantics[] methods = new MethodSemantics[INITSIZE];
3361
3362 internal Feature(string name, ClassDef par)
3363 {
3364 parent = par;
3365 this.name = name;
3366 }
3367
3368 internal void AddMethod(MethodDef meth, MethodType mType)
3369 {
3370 if (tide >= methods.Length) {
3371 int len = methods.Length;
3372 MethodSemantics[] mTmp = methods;
3373 methods = new MethodSemantics[len * 2];
3374 for (int i=0; i < len; i++) {
3375 methods[i] = mTmp[i];
3376 }
3377 }
3378 methods[tide++] = new MethodSemantics(mType,meth,this);
3379 }
3380
3381 /// <summary>
3382 /// Set the specialName attribute for this Event or Property
3383 /// </summary>
3384 public void SetSpecialName()
3385 {
3386 flags |= specialName;
3387 }
3388
3389 /// <summary>
3390 /// Set the RTSpecialName attribute for this Event or Property
3391 /// </summary>
3392 public void SetRTSpecialName()
3393 {
3394 flags |= rtSpecialName;
3395 }
3396
3397 }
3398
3399 /**************************************************************************/
3400 /// <summary>
3401 /// Descriptor for an event
3402 /// </summary>
3403 public class Event : Feature {
3404
3405 Type eventType;
3406
3407 internal Event(string name, Type eType, ClassDef parent)
3408 : base(name, parent)
3409 {
3410 eventType = eType;
3411 tabIx = MDTable.Event;
3412 }
3413
3414 /// <summary>
3415 /// Add the addon method to this event
3416 /// </summary>
3417 /// <param name="addon">the addon method</param>
3418 public void AddAddon(MethodDef addon)
3419 {
3420 AddMethod(addon,MethodType.AddOn);
3421 }
3422
3423 /// <summary>
3424 /// Add the removeon method to this event
3425 /// </summary>
3426 /// <param name="removeOn">the removeon method</param>
3427 public void AddRemoveOn(MethodDef removeOn)
3428 {
3429 AddMethod(removeOn,MethodType.RemoveOn);
3430 }
3431
3432 /// <summary>
3433 /// Add the fire method to this event
3434 /// </summary>
3435 /// <param name="fire">the fire method</param>
3436 public void AddFire(MethodDef fire)
3437 {
3438 AddMethod(fire,MethodType.Fire);
3439 }
3440
3441 /// <summary>
3442 /// Add another method to this event
3443 /// </summary>
3444 /// <param name="other">the method to be added</param>
3445 public void AddOther(MethodDef other)
3446 {
3447 AddMethod(other,MethodType.Other);
3448 }
3449
3450 internal sealed override void BuildTables(MetaData md)
3451 {
3452 if (done) return;
3453 nameIx = md.AddToStringsHeap(name);
3454 for (int i=0; i < tide; i++) {
3455 md.AddToTable(MDTable.MethodSemantics,methods[i]);
3456 }
3457 done = true;
3458 }
3459
3460 internal sealed override uint Size(MetaData md)
3461 {
3462 return 2 + md.StringsIndexSize() + md.CodedIndexSize(CIx.TypeDefOrRef);
3463 }
3464
3465 internal sealed override void Write(FileImage output)
3466 {
3467 output.Write(flags);
3468 output.StringsIndex(nameIx);
3469 output.WriteCodedIndex(CIx.TypeDefOrRef,eventType);
3470 }
3471
3472 internal sealed override uint GetCodedIx(CIx code)
3473 {
3474 switch (code) {
3475 case (CIx.HasCustomAttr) : return 10;
3476 case (CIx.HasSemantics) : return 0;
3477 }
3478 return 0;
3479 }
3480
3481 }
3482
3483 /**************************************************************************/
3484 /// <summary>
3485 /// Descriptor for the Property of a class
3486 /// </summary>
3487 public class Property : Feature {
3488
3489 private static readonly byte PropertyTag = 0x8;
3490 private bool instance;
3491 MethodDef getterMeth;
3492 ConstantElem constVal;
3493 uint typeBlobIx = 0;
3494 Type[] parList;
3495 Type returnType;
3496 uint numPars = 0;
3497
3498 internal Property(string name, Type retType, Type[] pars, ClassDef parent) : base(name, parent)
3499 {
3500 returnType = retType;
3501 parList = pars;
3502 if (pars != null) numPars = (uint)pars.Length;
3503 tabIx = MDTable.Property;
3504 }
3505
3506 /// <summary>
3507 /// Add a set method to this property
3508 /// </summary>
3509 /// <param name="setter">the set method</param>
3510 public void AddSetter(MethodDef setter)
3511 {
3512 AddMethod(setter,MethodType.Setter);
3513 }
3514
3515 /// <summary>
3516 /// Add a get method to this property
3517 /// </summary>
3518 /// <param name="getter">the get method</param>
3519 public void AddGetter(MethodDef getter)
3520 {
3521 AddMethod(getter,MethodType.Getter);
3522 getterMeth = getter;
3523 }
3524
3525 /// <summary>
3526 /// Add another method to this property
3527 /// </summary>
3528 /// <param name="other">the method</param>
3529 public void AddOther(MethodDef other)
3530 {
3531 AddMethod(other,MethodType.Other);
3532 }
3533
3534 /// <summary>
3535 /// Add an initial value for this property
3536 /// </summary>
3537 /// <param name="constVal">the initial value for this property</param>
3538 public void AddInitValue(Constant constVal)
3539 {
3540 this.constVal = new ConstantElem(this,constVal);
3541 }
3542
3543 public void SetInstance (bool isInstance)
3544 {
3545 this.instance = isInstance;
3546 }
3547
3548 internal sealed override void BuildTables(MetaData md)
3549 {
3550 if (done) return;
3551 nameIx = md.AddToStringsHeap(name);
3552 MemoryStream sig = new MemoryStream();
3553 byte tag = PropertyTag;
3554 if (instance)
3555 tag |= 0x20;
3556 sig.WriteByte(tag);
3557 MetaData.CompressNum(numPars,sig);
3558 returnType.TypeSig(sig);
3559 for (int i=0; i < numPars; i++) {
3560 parList[i].TypeSig(sig);
3561 }
3562 typeBlobIx = md.AddToBlobHeap(sig.ToArray());
3563 for (int i=0; i < tide; i++) {
3564 md.AddToTable(MDTable.MethodSemantics,methods[i]);
3565 }
3566 if (constVal != null) {
3567 md.AddToTable(MDTable.Constant,constVal);
3568 constVal.BuildTables(md);
3569 }
3570 done = true;
3571 }
3572
3573 internal sealed override uint Size(MetaData md)
3574 {
3575 return 2 + md.StringsIndexSize() + md.BlobIndexSize();
3576 }
3577
3578 internal sealed override void Write(FileImage output)
3579 {
3580 output.Write(flags);
3581 output.StringsIndex(nameIx);
3582 output.BlobIndex(typeBlobIx);
3583 }
3584
3585 internal sealed override uint GetCodedIx(CIx code)
3586 {
3587 switch (code) {
3588 case (CIx.HasCustomAttr) : return 9;
3589 case (CIx.HasConst) : return 2;
3590 case (CIx.HasSemantics) : return 1;
3591 }
3592 return 0;
3593 }
3594
3595 }
3596
3597 /**************************************************************************/
3598 /// <summary>
3599 /// Base class for field/methods (member of a class)
3600 /// </summary>
3601 public abstract class Member : MetaDataElement {
3602
3603 protected string name;
3604 protected uint nameIx = 0, sigIx = 0;
3605
3606 internal Member(string memName)
3607 {
3608 name = memName;
3609 tabIx = MDTable.MemberRef;
3610 }
3611
3612 }
3613
3614 /*****************************************************************************/
3615 /// <summary>
3616 /// Descriptor for a field of a class
3617 /// </summary>
3618
3619 public abstract class Field : Member {
3620
3621 protected static readonly byte FieldSig = 0x6;
3622
3623 protected Type type;
3624
3625 internal Field(string pfName, Type pfType) : base(pfName)
3626 {
3627 type = pfType;
3628 }
3629
3630 }
3631 /**************************************************************************/
3632 /// <summary>
3633 /// Descriptor for a field defined in a class of THIS assembly/module
3634 /// </summary>
3635 public class FieldDef : Field {
3636
3637 //private static readonly uint PInvokeImpl = 0x2000;
3638 private static readonly ushort HasFieldRVA = 0x100;
3639 private static readonly ushort HasDefault = 0x8000;
3640
3641 FieldRVA rva;
3642 ConstantElem constVal;
3643 FieldLayout layout;
3644 FieldMarshal marshalInfo;
3645 ushort flags;
3646
3647 internal FieldDef(string name, Type fType) : base(name,fType)
3648 {
3649 tabIx = MDTable.Field;
3650 }
3651
3652 internal FieldDef(FieldAttr attrSet, string name, Type fType) : base(name, fType)
3653 {
3654 flags = (ushort)attrSet;
3655 tabIx = MDTable.Field;
3656 }
3657
3658 /// <summary>
3659 /// Add an attribute(s) to this field
3660 /// </summary>
3661 /// <param name="fa">the attribute(s) to be added</param>
3662 public void AddFieldAttr(FieldAttr fa)
3663 {
3664 flags |= (ushort)fa;
3665 }
3666
3667 /// <summary>
3668 /// Add a value for this field
3669 /// </summary>
3670 /// <param name="val">the value for the field</param>
3671 public void AddValue(Constant val)
3672 {
3673 constVal = new ConstantElem(this,val);
3674 flags |= HasDefault;
3675 }
3676
3677 /// <summary>
3678 /// Add an initial value for this field (at dataLabel) (.data)
3679 /// </summary>
3680 /// <param name="val">the value for the field</param>
3681 /// <param name="repeatVal">the number of repetitions of this value</param>
3682 public void AddDataValue(DataConstant val)
3683 {
3684 flags |= HasFieldRVA;
3685 rva = new FieldRVA(this,val);
3686 }
3687
3688 /// <summary>
3689 /// Set the offset of the field. Used for sequential or explicit classes.
3690 /// (.field [offs])
3691 /// </summary>
3692 /// <param name="offs">field offset</param>
3693 public void SetOffset(uint offs)
3694 {
3695 layout = new FieldLayout(this,offs);
3696 }
3697
3698 /// <summary>
3699 /// Set the marshalling info for a field
3700 /// </summary>
3701 /// <param name="mInf"></param>
3702 public void SetMarshalInfo(NativeType marshallType)
3703 {
3704 flags |= (ushort) FieldAttr.HasFieldMarshal;
3705 marshalInfo = new FieldMarshal(this,marshallType);
3706 }
3707
3708 internal sealed override void BuildTables(MetaData md)
3709 {
3710 if (done) return;
3711 nameIx = md.AddToStringsHeap(name);
3712 MemoryStream sig = new MemoryStream();
3713 sig.WriteByte(FieldSig);
3714 type.TypeSig(sig);
3715 sigIx = md.AddToBlobHeap(sig.ToArray());
3716 if (rva != null) {
3717 md.AddToTable(MDTable.FieldRVA,rva);
3718 rva.BuildTables(md);
3719 } else if (constVal != null) {
3720 md.AddToTable(MDTable.Constant,constVal);
3721 constVal.BuildTables(md);
3722 }
3723 if (layout != null) md.AddToTable(MDTable.FieldLayout,layout);
3724 if (marshalInfo != null) {
3725 md.AddToTable(MDTable.FieldMarshal,marshalInfo);
3726 marshalInfo.BuildTables(md);
3727 }
3728 done = true;
3729 }
3730
3731 internal sealed override uint Size(MetaData md)
3732 {
3733 return 2 + md.StringsIndexSize() + md.BlobIndexSize();
3734 }
3735
3736 internal sealed override void Write(FileImage output)
3737 {
3738 output.Write(flags);
3739 output.StringsIndex(nameIx);
3740 output.BlobIndex(sigIx);
3741 }
3742
3743 internal sealed override uint GetCodedIx(CIx code)
3744 {
3745 switch (code) {
3746 case (CIx.HasConst) : return 0;
3747 case (CIx.HasCustomAttr) : return 1;
3748 case (CIx.HasFieldMarshal) : return 0;
3749 case (CIx.MemberForwarded) : return 0;
3750 }
3751 return 0;
3752 }
3753
3754 }
3755
3756 /**************************************************************************/
3757 /// <summary>
3758 /// Descriptor for a field of a class defined in another assembly/module
3759 /// </summary>
3760 public class FieldRef : Field {
3761
3762 MetaDataElement parent;
3763
3764 internal FieldRef(MetaDataElement paren, string name, Type fType) : base(name, fType)
3765 {
3766 parent = paren;
3767 }
3768
3769 internal sealed override void BuildTables(MetaData md)
3770 {
3771 if (done) return;
3772 nameIx = md.AddToStringsHeap(name);
3773 MemoryStream sig = new MemoryStream();
3774 sig.WriteByte(FieldSig);
3775 type.TypeSig(sig);
3776 sigIx = md.AddToBlobHeap(sig.ToArray());
3777 done = true;
3778 }
3779
3780 internal sealed override uint Size(MetaData md)
3781 {
3782 return md.CodedIndexSize(CIx.MemberRefParent) + md.StringsIndexSize() + md.BlobIndexSize();
3783 }
3784
3785 internal sealed override void Write(FileImage output)
3786 {
3787 output.WriteCodedIndex(CIx.MemberRefParent,parent);
3788 output.StringsIndex(nameIx);
3789 output.BlobIndex(sigIx);
3790 }
3791
3792 internal sealed override uint GetCodedIx(CIx code) { return 6; }
3793
3794 }
3795
3796 /**************************************************************************/
3797 /// <summary>
3798 /// Base class for Method Descriptors
3799 /// </summary>
3800
3801 public abstract class Method : Member {
3802
3803 internal Method (string methName) : base (methName)
3804 {}
3805
3806 public abstract void AddCallConv(CallConv cconv);
3807 internal abstract void TypeSig(MemoryStream sig);
3808 internal abstract uint GetSigIx(MetaData md);
3809 }
3810
3811 /**************************************************************************/
3812 /// <summary>
3813 /// Descriptor for a method defined in THIS assembly/module
3814 /// IL .method
3815 /// </summary>
3816
3817 public class MethodDef : Method {
3818
3819 private static readonly ushort PInvokeImpl = 0x2000;
3820 //private static readonly uint UnmanagedExport = 0x0008;
3821 // private static readonly byte LocalSigByte = 0x7;
3822 uint parIx = 0, textOffset = 0;
3823 private CallConv callConv = CallConv.Default;
3824 private int gen_param_count;
3825
3826 MetaData metaData;
3827 CILInstructions code;
3828 ArrayList securityActions = new ArrayList();
3829 Param[] parList;
3830 Local[] locals;
3831 bool initLocals;
3832 ushort methFlags = 0, implFlags = 0;
3833 int maxStack = 0, numPars = 0;
3834 bool entryPoint = false;
3835 LocalSig localSig;
3836 ArrayList varArgSigList;
3837 ImplMap pinvokeImpl;
3838 Param ret_param;
3839
3840 internal MethodDef (MetaData md, string name, Param ret_param, Param [] pars)
3841 : this (md, 0, 0, name, ret_param, pars)
3842 {
3843 }
3844
3845 internal MethodDef (MetaData md, MethAttr mAttrSet, ImplAttr iAttrSet, string name,
3846 Param ret_param, Param [] pars)
3847 : base (name)
3848 {
3849 methFlags = (ushort)mAttrSet;
3850 implFlags = (ushort)iAttrSet;
3851 this.ret_param = ret_param;
3852 metaData = md;
3853 parList = pars;
3854 if (parList != null)
3855 numPars = parList.Length;
3856 tabIx = MDTable.Method;
3857 }
3858
3859 internal Param[] GetPars()
3860 {
3861 return parList;
3862 }
3863
3864 internal override uint GetSigIx(MetaData md)
3865 {
3866 MemoryStream sig = new MemoryStream();
3867 TypeSig(sig);
3868 return md.AddToBlobHeap(sig.ToArray());
3869 }
3870
3871 public override void AddCallConv(CallConv cconv)
3872 {
3873 callConv |= cconv;
3874 }
3875
3876 /// <summary>
3877 /// Add some attributes to this method descriptor
3878 /// </summary>
3879 /// <param name="ma">the attributes to be added</param>
3880 public void AddMethAttribute(MethAttr ma)
3881 {
3882 methFlags |= (ushort)ma;
3883 }
3884
3885 /// <summary>
3886 /// Add some implementation attributes to this method descriptor
3887 /// </summary>
3888 /// <param name="ia">the attributes to be added</param>
3889 public void AddImplAttribute(ImplAttr ia)
3890 {
3891 implFlags |= (ushort)ia;
3892 }
3893
3894 public void AddPInvokeInfo(ModuleRef scope, string methName,
3895 PInvokeAttr callAttr) {
3896 pinvokeImpl = new ImplMap((ushort)callAttr,this,methName,scope);
3897 methFlags |= PInvokeImpl;
3898 }
3899
3900 /// <summary>
3901 /// Add a named generic type parameter
3902 /// </summary>
3903 public GenericParameter AddGenericParameter (short index, string name)
3904 {
3905 return AddGenericParameter (index, name, 0);
3906 }
3907
3908 /// <summary>
3909 /// Add a named generic type parameter with attributes
3910 /// </summary>
3911 public GenericParameter AddGenericParameter (short index, string name, GenericParamAttributes attr)
3912 {
3913 GenericParameter gp = new GenericParameter (this, metaData, index, name, attr);
3914 metaData.AddToTable (MDTable.GenericParam, gp);
3915 gen_param_count ++;
3916 return gp;
3917 }
3918
3919 /// <summary>
3920 /// Set the maximum stack height for this method
3921 /// </summary>
3922 /// <param name="maxStack">the maximum height of the stack</param>
3923 public void SetMaxStack(int maxStack)
3924 {
3925 this.maxStack = maxStack;
3926 }
3927
3928 /// <summary>
3929 /// Add local variables to this method
3930 /// </summary>
3931 /// <param name="locals">the locals to be added</param>
3932 /// <param name="initLocals">are locals initialised to default values</param>
3933 public void AddLocals(Local[] locals, bool initLocals)
3934 {
3935 this.locals = locals;
3936 this.initLocals = initLocals;
3937 }
3938
3939 /* Add Marshal info for return type */
3940 public void AddRetTypeMarshallInfo (NativeType marshallType)
3941 {
3942 ret_param.AddMarshallInfo (marshallType);
3943 }
3944
3945 /// <summary>
3946 /// Mark this method as having an entry point
3947 /// </summary>
3948 public void DeclareEntryPoint()
3949 {
3950 entryPoint = true;
3951 }
3952
3953 /// <summary>
3954 /// Create a code buffer for this method to add the IL instructions to
3955 /// </summary>
3956 /// <returns>a buffer for this method's IL instructions</returns>
3957 public CILInstructions CreateCodeBuffer()
3958 {
3959 code = new CILInstructions(metaData);
3960 return code;
3961 }
3962
3963 /// <summary>
3964 /// Make a method reference descriptor for this method to be used
3965 /// as a callsite signature for this vararg method
3966 /// </summary>
3967 /// <param name="optPars">the optional pars for the vararg method call</param>
3968 /// <returns></returns>
3969 public MethodRef MakeVarArgSignature(Type[] optPars)
3970 {
3971 Type[] pars = new Type[numPars];
3972 MethodRef varArgSig;
3973 for (int i=0; i < numPars; i++) {
3974 pars[i] = parList[i].GetParType();
3975 }
3976 varArgSig = new MethodRef (this, name, ret_param.GetParType (), pars, true, optPars, 0);
3977
3978 if (varArgSigList == null)
3979 varArgSigList = new ArrayList ();
3980 varArgSigList.Add (varArgSig);
3981 return varArgSig;
3982 }
3983
3984 internal sealed override void TypeSig(MemoryStream sig)
3985 {
3986 sig.WriteByte((byte)callConv);
3987 if ((callConv & CallConv.Generic) == CallConv.Generic)
3988 MetaData.CompressNum ((uint) gen_param_count, sig);
3989 MetaData.CompressNum((uint)numPars,sig);
3990
3991 ret_param.seqNo = 0;
3992 ret_param.TypeSig (sig);
3993 for (ushort i=0; i < numPars; i++) {
3994 parList[i].seqNo = (ushort)(i+1);
3995 parList[i].TypeSig(sig);
3996 }
3997 }
3998
3999 internal sealed override void BuildTables(MetaData md)
4000 {
4001 if (done) return;
4002 if (pinvokeImpl != null) {
4003 md.AddToTable(MDTable.ImplMap,pinvokeImpl);
4004 pinvokeImpl.BuildTables(md);
4005 }
4006 if (entryPoint) md.SetEntryPoint(this);
4007 uint locToken = 0;
4008 if (locals != null) {
4009 localSig = new LocalSig(locals);
4010 md.AddToTable(MDTable.StandAloneSig,localSig);
4011 localSig.BuildTables(md);
4012 locToken = localSig.Token();
4013 }
4014 if (code != null) {
4015 code.CheckCode(locToken,initLocals,maxStack);
4016 textOffset = md.AddCode(code);
4017 }
4018 nameIx = md.AddToStringsHeap(name);
4019 sigIx = GetSigIx(md);
4020 parIx = md.TableIndex(MDTable.Param);
4021 if (ret_param.HasMarshalInfo || ret_param.HasCustomAttr) {
4022 md.AddToTable(MDTable.Param, ret_param);
4023 ret_param.BuildTables(md);
4024 }
4025 for (int i=0; i < numPars; i++) {
4026 md.AddToTable(MDTable.Param,parList[i]);
4027 parList[i].BuildTables(md);
4028 }
4029 if (varArgSigList != null) {
4030 foreach (MethodRef varArgSig in varArgSigList) {
4031 md.AddToTable(MDTable.MemberRef,varArgSig);
4032 varArgSig.BuildTables(md);
4033 }
4034 }
4035 // Console.WriteLine("method has " + numPars + " parameters");
4036 done = true;
4037 }
4038
4039 internal sealed override uint Size(MetaData md)
4040 {
4041 return 8 + md.StringsIndexSize() + md.BlobIndexSize() + md.TableIndexSize(MDTable.Param);
4042 }
4043
4044 internal sealed override void Write(FileImage output)
4045 {
4046 if (ZeroRva ()) output.Write(0);
4047 else output.WriteCodeRVA(textOffset);
4048 output.Write(implFlags);
4049 output.Write(methFlags);
4050 output.StringsIndex(nameIx);
4051 output.BlobIndex(sigIx);
4052 output.WriteIndex(MDTable.Param,parIx);
4053 }
4054
4055 internal bool ZeroRva ()
4056 {
4057 return (((methFlags & (ushort)MethAttr.Abstract) != 0) ||
4058 ((implFlags & (ushort)ImplAttr.Runtime) != 0) ||
4059 ((implFlags & (ushort)ImplAttr.InternalCall) != 0) ||
4060 (pinvokeImpl != null)); // TODO: Not entirely true but works for now
4061 }
4062
4063 internal sealed override uint GetCodedIx(CIx code)
4064 {
4065 switch (code) {
4066 case (CIx.HasCustomAttr) : return 0;
4067 case (CIx.HasDeclSecurity) : return 1;
4068 case (CIx.MemberRefParent) : return 3;
4069 case (CIx.MethodDefOrRef) : return 0;
4070 case (CIx.MemberForwarded) : return 1;
4071 case (CIx.CustomAttributeType) : return 2;
4072 case (CIx.TypeOrMethodDef) : return 1;
4073 }
4074 return 0;
4075 }
4076
4077 }
4078 /**************************************************************************/
4079 /// <summary>
4080 /// Descriptor for a method defined in another assembly/module
4081 /// </summary>
4082 public class MethodRef : Method {
4083
4084 private static readonly byte Sentinel = 0x41;
4085 Type[] parList, optParList;
4086 MetaDataElement parent;
4087 uint numPars = 0, numOptPars = 0;
4088 CallConv callConv = CallConv.Default;
4089 Type retType;
4090 int gen_param_count;
4091
4092 internal MethodRef(MetaDataElement paren, string name, Type retType,
4093 Type[] pars, bool varArgMeth, Type[] optPars, int gen_param_count) : base(name)
4094 {
4095 parent = paren;
4096 parList = pars;
4097 this.retType = retType;
4098 if (parList != null) numPars = (uint)parList.Length;
4099 if (varArgMeth) {
4100 optParList = optPars;
4101 if (optParList != null) numOptPars = (uint)optParList.Length;
4102 callConv = CallConv.Vararg;
4103 }
4104 this.gen_param_count = gen_param_count;
4105 }
4106
4107 internal override uint GetSigIx(MetaData md)
4108 {
4109 MemoryStream sig = new MemoryStream();
4110 TypeSig(sig);
4111 return md.AddToBlobHeap(sig.ToArray());
4112 }
4113
4114 public override void AddCallConv(CallConv cconv)
4115 {
4116 callConv |= cconv;
4117 }
4118
4119 internal sealed override void TypeSig(MemoryStream sig)
4120 {
4121 sig.WriteByte((byte)callConv);
4122 if ((callConv & CallConv.Generic) == CallConv.Generic)
4123 MetaData.CompressNum ((uint) gen_param_count, sig);
4124 MetaData.CompressNum(numPars+numOptPars,sig);
4125 retType.TypeSig(sig);
4126 for (int i=0; i < numPars; i++) {
4127 parList[i].TypeSig(sig);
4128 }
4129 if (numOptPars > 0) {
4130 sig.WriteByte(Sentinel);
4131 for (int i=0; i < numOptPars; i++) {
4132 optParList[i].TypeSig(sig);
4133 }
4134 }
4135 }
4136
4137 internal sealed override void BuildTables(MetaData md)
4138 {
4139 if (done) return;
4140 nameIx = md.AddToStringsHeap(name);
4141 sigIx = GetSigIx(md);
4142 done = true;
4143 }
4144
4145 internal sealed override uint Size(MetaData md)
4146 {
4147 return md.CodedIndexSize(CIx.MemberRefParent) + md.StringsIndexSize() + md.BlobIndexSize();
4148 }
4149
4150 internal sealed override void Write(FileImage output)
4151 {
4152 output.WriteCodedIndex(CIx.MemberRefParent,parent);
4153 output.StringsIndex(nameIx);
4154 output.BlobIndex(sigIx);
4155 }
4156
4157 internal sealed override uint GetCodedIx(CIx code)
4158 {
4159 switch (code) {
4160 case (CIx.HasCustomAttr) : return 6;
4161 case (CIx.MethodDefOrRef) : return 1;
4162 case (CIx.CustomAttributeType) : return 3;
4163 }
4164 return 0;
4165 }
4166
4167 }
4168
4169
4170 /**************************************************************************/
4171 /// <summary>
4172 /// Descriptors for native types used for marshalling
4173 /// </summary>
4174 public class NativeType {
4175 public static readonly NativeType Void = new NativeType(0x01);
4176 public static readonly NativeType Boolean = new NativeType(0x02);
4177 public static readonly NativeType Int8 = new NativeType(0x03);
4178 public static readonly NativeType UInt8 = new NativeType(0x04);
4179 public static readonly NativeType Int16 = new NativeType(0x05);
4180 public static readonly NativeType UInt16 = new NativeType(0x06);
4181 public static readonly NativeType Int32 = new NativeType(0x07);
4182 public static readonly NativeType UInt32 = new NativeType(0x08);
4183 public static readonly NativeType Int64 = new NativeType(0x09);
4184 public static readonly NativeType UInt64 = new NativeType(0x0A);
4185 public static readonly NativeType Float32 = new NativeType(0x0B);
4186 public static readonly NativeType Float64 = new NativeType(0x0C);
4187 public static readonly NativeType Currency = new NativeType(0x0F);
4188 public static readonly NativeType BStr = new NativeType(0x13);
4189 public static readonly NativeType LPStr = new NativeType(0x14);
4190 public static readonly NativeType LPWStr = new NativeType(0x15);
4191 public static readonly NativeType LPTStr = new NativeType(0x16);
4192 public static readonly NativeType FixedSysString = new NativeType(0x17);
4193 public static readonly NativeType IUnknown = new NativeType(0x19);
4194 public static readonly NativeType IDispatch = new NativeType(0x1A);
4195 public static readonly NativeType Struct = new NativeType(0x1B);
4196 public static readonly NativeType Interface = new NativeType(0x1C);
4197 public static readonly NativeType Int = new NativeType(0x1F);
4198 public static readonly NativeType UInt = new NativeType(0x20);
4199 public static readonly NativeType ByValStr = new NativeType(0x22);
4200 public static readonly NativeType AnsiBStr = new NativeType(0x23);
4201 public static readonly NativeType TBstr = new NativeType(0x24);
4202 public static readonly NativeType VariantBool = new NativeType(0x25);
4203 public static readonly NativeType FuncPtr = new NativeType(0x26);
4204 public static readonly NativeType AsAny = new NativeType(0x28);
4205 public static readonly NativeType LPStruct = new NativeType(0x2b);
4206 public static readonly NativeType Error = new NativeType(0x2d);
4207
4208 protected byte typeIndex;
4209
4210 internal NativeType(byte tyIx) { typeIndex = tyIx; }
4211 internal byte GetTypeIndex() { return typeIndex; }
4212
4213 internal virtual byte[] ToBlob()
4214 {
4215 byte[] bytes = new byte[1];
4216 bytes[0] = GetTypeIndex();
4217 return bytes;
4218 }
4219
4220 }
4221
4222 public class FixedSysString : NativeType {
4223
4224 uint size;
4225
4226 public FixedSysString (uint size) : base (NativeType.FixedSysString.GetTypeIndex ())
4227 {
4228 this.size = size;
4229 }
4230
4231 internal override byte [] ToBlob ()
4232 {
4233 MemoryStream str = new MemoryStream ();
4234 str.WriteByte (GetTypeIndex ());
4235 MetaData.CompressNum (size, str);
4236 return str.ToArray ();
4237 }
4238
4239 }
4240
4241 public class NativeArray : NativeType {
4242
4243 NativeType elemType;
4244 int numElem = -1, parNum = -1, elemMult = -1;
4245
4246 public NativeArray(NativeType elemType) : this (elemType, -1, -1, -1)
4247 {
4248 this.elemType = elemType;
4249 }
4250
4251 /* public NativeArray(NativeType elemType, int len) : base(0x2A) {
4252 this.elemType = elemType;
4253 this.len = len;
4254 }
4255 */
4256
4257 public NativeArray(NativeType elemType, int numElem, int parNumForLen, int elemMult) : base(0x2A)
4258 {
4259 this.elemType = elemType;
4260 this.numElem = numElem;
4261 parNum = parNumForLen;
4262 this.elemMult = elemMult;
4263 }
4264
4265 public NativeArray(NativeType elemType, int numElem, int parNumForLen)
4266 : this (elemType, numElem, parNumForLen, -1)
4267 {
4268 }
4269
4270 internal override byte[] ToBlob()
4271 {
4272 MemoryStream str = new MemoryStream();
4273 str.WriteByte(GetTypeIndex());
4274 if (elemType == null) str.WriteByte(0x50); // no info (MAX)
4275 else str.WriteByte(elemType.GetTypeIndex());
4276
4277 /* see : mono/metadata/metadata.c:mono_metadata_parse_marshal_spec
4278 * LAMESPEC: Older spec versions say elemMult comes before
4279 * len. Newer spec versions don't talk about elemMult at
4280 * all, but csc still emits it, and it is used to distinguish
4281 * between parNum being 0, and parNum being omitted.
4282 */
4283
4284 if (parNum == -1)
4285 // <native_type> []
4286 return str.ToArray ();
4287
4288 MetaData.CompressNum((uint) parNum,str);
4289 if (numElem != -1) {
4290 MetaData.CompressNum ((uint) numElem, str);
4291 if (elemMult != -1)
4292 // <native_type> [ int32 ]
4293 MetaData.CompressNum((uint) elemMult,str);
4294 //else <native_type> [ int32 + int32 ]
4295 } else if (elemMult != -1) {
4296 // When can this occur ?
4297 MetaData.CompressNum (0, str);
4298 MetaData.CompressNum((uint) elemMult,str);
4299 }
4300 //else <native_type> [ + int32 ]
4301
4302 return str.ToArray();
4303 }
4304
4305 }
4306
4307 public class SafeArray : NativeType {
4308
4309 SafeArrayType elemType;
4310 bool hasElemType;
4311
4312 public SafeArray() : base(0x1D)
4313 {
4314 }
4315
4316 public SafeArray(SafeArrayType elemType) : base(0x1D)
4317 {
4318 this.elemType = elemType;
4319 hasElemType = true;
4320 }
4321
4322 internal override byte[] ToBlob()
4323 {
4324 byte[] bytes = new byte[hasElemType ? 2 : 1];
4325 bytes[0] = GetTypeIndex();
4326 if (hasElemType)
4327 bytes[1] = (byte)elemType;
4328 return bytes;
4329 }
4330
4331 }
4332
4333 public class FixedArray : NativeType {
4334
4335 NativeType elemType;
4336 uint numElem;
4337
4338 //public FixedArray(NativeType elemType, int numElems) : base(0x1E) {
4339 public FixedArray(int numElems) : base(0x1E)
4340 {
4341 //this.elemType = elemType;
4342 numElem = (uint)numElems;
4343 }
4344
4345 internal override byte[] ToBlob()
4346 {
4347 MemoryStream str = new MemoryStream();
4348 str.WriteByte(GetTypeIndex());
4349 MetaData.CompressNum(numElem,str);
4350 /* FIXME:
4351 fixed array [5] lpstr [2]
4352 This format is not supported by ilasm 1.1.4322.2032,
4353 but is supported by 2.0.5125..
4354 ilasm 1.1 only supports "fixed array [5]"
4355 if (elemType == null) str.WriteByte(0x50); // no info (MAX)
4356 else str.WriteByte(elemType.GetTypeIndex());*/
4357
4358 return str.ToArray();
4359 }
4360
4361 }
4362
4363 public class CustomMarshaller : NativeType {
4364
4365 string typeName;
4366 string marshallerName;
4367 string cookie;
4368
4369 public CustomMarshaller(string typeNameOrGUID, string marshallerName,
4370 string optCookie) : base(0x2C)
4371 {
4372 typeName = typeNameOrGUID;
4373 this.marshallerName = marshallerName;
4374 cookie = optCookie;
4375 }
4376
4377 public CustomMarshaller(string marshallerName, string optCookie)
4378 :this (null, marshallerName, optCookie)
4379 {
4380 }
4381
4382 internal override byte[] ToBlob()
4383 {
4384 MemoryStream str = new MemoryStream();
4385 BinaryWriter bw = new BinaryWriter(str,new UTF8Encoding());
4386 bw.Write(GetTypeIndex());
4387 //Native type name & unmanaged type - unused
4388 //See mono/metadata/metadata.c : mono_metadata_parse_marshal_spec
4389 bw.Write ((byte) 0); // Native Type name, unused
4390 bw.Write ((byte) 0); // Unmanaged type, unused
4391 if (marshallerName != null) {
4392 MetaData.CompressNum ((uint)marshallerName.Length, str);
4393 bw.Write(marshallerName.ToCharArray());
4394 } else {
4395 bw.Write ((byte) 0);
4396 }
4397 if (cookie != null) {
4398 MetaData.CompressNum ((uint)cookie.Length, str);
4399 bw.Write(cookie.ToCharArray());
4400 } else {
4401 bw.Write ((byte) 0);
4402 }
4403 bw.Flush();
4404 return str.ToArray();
4405 }
4406 }
4407
4408 /**************************************************************************/
4409 /// <summary>
4410 /// Descriptor for the Primitive types defined in IL
4411 /// </summary>
4412 public class PrimitiveType : Type {
4413
4414 private string name;
4415 private int systemTypeIndex;
4416 public static int NumSystemTypes = 18;
4417
4418 public static readonly PrimitiveType Void = new PrimitiveType(0x01,"Void",0);
4419 public static readonly PrimitiveType Boolean = new PrimitiveType(0x02,"Boolean",1);
4420 public static readonly PrimitiveType Char = new PrimitiveType(0x03,"Char",2);
4421 public static readonly PrimitiveType Int8 = new PrimitiveType(0x04,"SByte",3);
4422 public static readonly PrimitiveType UInt8 = new PrimitiveType(0x05,"Byte",4);
4423 public static readonly PrimitiveType Int16 = new PrimitiveType(0x06,"Int16",5);
4424 public static readonly PrimitiveType UInt16 = new PrimitiveType(0x07,"UInt16",6);
4425 public static readonly PrimitiveType Int32 = new PrimitiveType(0x08,"Int32",7);
4426 public static readonly PrimitiveType UInt32 = new PrimitiveType(0x09,"UInt32",8);
4427 public static readonly PrimitiveType Int64 = new PrimitiveType(0x0A,"Int64",9);
4428 public static readonly PrimitiveType UInt64 = new PrimitiveType(0x0B,"UInt64",10);
4429 public static readonly PrimitiveType Float32 = new PrimitiveType(0x0C,"Single",11);
4430 public static readonly PrimitiveType Float64 = new PrimitiveType(0x0D,"Double",12);
4431 public static readonly PrimitiveType String = new PrimitiveType(0x0E,"String",13);
4432 internal static readonly PrimitiveType Class = new PrimitiveType(0x12);
4433 internal static readonly PrimitiveType Var = new PrimitiveType(0x13);
4434 internal static readonly PrimitiveType GenericInst = new PrimitiveType(0x15);
4435 public static readonly PrimitiveType TypedRef = new PrimitiveType(0x16,"TypedReference",14);
4436 public static readonly PrimitiveType IntPtr = new PrimitiveType(0x18,"IntPtr",15);
4437 public static readonly PrimitiveType UIntPtr = new PrimitiveType(0x19,"UIntPtr",16);
4438 public static readonly PrimitiveType Object = new PrimitiveType(0x1C,"Object",17);
4439 internal static readonly PrimitiveType ClassType = new PrimitiveType(0x50);
4440 internal static readonly PrimitiveType SZArray = new PrimitiveType(0x1D);
4441 internal static readonly PrimitiveType MVar = new PrimitiveType(0x1E);
4442 internal static readonly PrimitiveType ValueType = new PrimitiveType(0x11, "ValueType", 18);
4443 public static readonly PrimitiveType NativeInt = IntPtr;
4444 public static readonly PrimitiveType NativeUInt = UIntPtr;
4445
4446 internal PrimitiveType(byte typeIx) : base(typeIx) { }
4447
4448 internal PrimitiveType(byte typeIx, string name, int STIx) : base(typeIx)
4449 {
4450 this.name = name;
4451 this.systemTypeIndex = STIx;
4452 }
4453
4454 internal string GetName() { return name; }
4455
4456 internal int GetSystemTypeIx() { return systemTypeIndex; }
4457
4458 internal sealed override void TypeSig(MemoryStream str)
4459 {
4460 str.WriteByte(typeIndex);
4461 }
4462
4463 internal override MetaDataElement GetTypeSpec(MetaData md)
4464 {
4465 TypeSpec tS = md.GetPrimitiveTypeSpec(systemTypeIndex);
4466 if (tS == null) {
4467 tS = new TypeSpec(this,md);
4468 md.SetPrimitiveTypeSpec(systemTypeIndex,tS);
4469 md.AddToTable(MDTable.TypeSpec,tS);
4470 }
4471 return tS;
4472 }
4473
4474 }
4475
4476 /**************************************************************************/
4477 /// <summary>
4478 /// Descriptor for an pointer (type * or type &)
4479 /// </summary>
4480 public abstract class PtrType : Type {
4481
4482 Type baseType;
4483
4484 internal PtrType(Type bType, byte typeIx) : base(typeIx)
4485 {
4486 baseType = bType;
4487 tabIx = MDTable.TypeSpec;
4488 }
4489
4490 internal sealed override void TypeSig(MemoryStream str)
4491 {
4492 str.WriteByte(typeIndex);
4493 baseType.TypeSig(str);
4494 }
4495
4496 }
4497 /**************************************************************************/
4498 /// <summary>
4499 /// Descriptor for a managed pointer (type & or byref)
4500 /// </summary>
4501
4502 public class ManagedPointer : PtrType {
4503
4504 /// <summary>
4505 /// Create new managed pointer to baseType
4506 /// </summary>
4507 /// <param name="bType">the base type of the pointer</param>
4508 public ManagedPointer(Type baseType) : base(baseType,0x10) { }
4509
4510 }
4511 /**************************************************************************/
4512 /// <summary>
4513 /// Descriptor for an unmanaged pointer (type *)
4514 /// </summary>
4515 public class UnmanagedPointer : PtrType {
4516
4517 /// <summary>
4518 /// Create a new unmanaged pointer to baseType
4519 /// </summary>
4520 /// <param name="baseType">the base type of the pointer</param>
4521 public UnmanagedPointer(Type baseType) : base(baseType, 0x0F) { }
4522
4523 }
4524
4525 /**************************************************************************/
4526
4527 public interface IExternRef {
4528 ClassRef AddClass(string nsName, string name);
4529 ClassRef AddValueClass(string nsName, string name);
4530 }
4531
4532 /// <summary>
4533 /// A reference to an external assembly (.assembly extern)
4534 /// </summary>
4535 public class AssemblyRef : ResolutionScope, IExternRef {
4536
4537 private ushort major, minor, build, revision;
4538 uint flags, keyIx, hashIx, cultIx;
4539 bool hasVersion = false, isKeyToken = false;
4540 byte[] keyBytes;
4541 string culture;
4542
4543 internal AssemblyRef(MetaData md, string name) : base(name,md)
4544 {
4545 tabIx = MDTable.AssemblyRef;
4546 }
4547
4548 public void AddAssemblyAttr (AssemAttr aa)
4549 {
4550 flags |= (uint)aa;
4551 }
4552
4553 /// <summary>
4554 /// Add version information about this external assembly
4555 /// </summary>
4556 /// <param name="majVer">Major Version</param>
4557 /// <param name="minVer">Minor Version</param>
4558 /// <param name="bldNo">Build Number</param>
4559 /// <param name="revNo">Revision Number</param>
4560 public void AddVersionInfo(int majVer, int minVer, int bldNo, int revNo)
4561 {
4562 major = (ushort)majVer;
4563 minor = (ushort)minVer;
4564 build = (ushort)bldNo;
4565 revision = (ushort)revNo;
4566 hasVersion = true;
4567 }
4568
4569 /// <summary>
4570 /// Add the hash value for this external assembly
4571 /// </summary>
4572 /// <param name="hash">bytes of the hash value</param>
4573 public void AddHash(byte[] hash)
4574 {
4575 hashIx = metaData.AddToBlobHeap(hash);
4576 }
4577
4578 /// <summary>
4579 /// Set the culture for this external assembly
4580 /// </summary>
4581 /// <param name="cult">the culture string</param>
4582 public void AddCulture(string cult)
4583 {
4584 cultIx = metaData.AddToStringsHeap(cult);
4585 culture = cult;
4586 }
4587
4588 /// <summary>
4589 /// Add the full public key for this external assembly
4590 /// </summary>
4591 /// <param name="key">bytes of the public key</param>
4592 public void AddKey(byte[] key)
4593 {
4594 flags |= 0x0001; // full public key
4595 keyBytes = key;
4596 keyIx = metaData.AddToBlobHeap(key);
4597 }
4598
4599 /// <summary>
4600 /// Add the public key token (low 8 bytes of the public key)
4601 /// </summary>
4602 /// <param name="key">low 8 bytes of public key</param>
4603 public void AddKeyToken(byte[] key)
4604 {
4605 keyIx = metaData.AddToBlobHeap(key);
4606 keyBytes = key;
4607 isKeyToken = true;
4608 }
4609
4610 /// <summary>
4611 /// Add a class to this external assembly
4612 /// </summary>
4613 /// <param name="nsName">name space name</param>
4614 /// <param name="name">class name</param>
4615 /// <returns></returns>
4616 public virtual ClassRef AddClass(string nsName, string name)
4617 {
4618 ClassRef aClass = new ClassRef(nsName,name,metaData);
4619 metaData.AddToTable(MDTable.TypeRef,aClass);
4620 aClass.SetParent(this);
4621 return aClass;
4622 }
4623
4624 /// <summary>
4625 /// Add a value class to this external assembly
4626 /// </summary>
4627 /// <param name="nsName">name space name</param>
4628 /// <param name="name">class name</param>
4629 /// <returns></returns>
4630 public virtual ClassRef AddValueClass(string nsName, string name)
4631 {
4632 ClassRef aClass = new ClassRef(nsName,name,metaData);
4633 metaData.AddToTable(MDTable.TypeRef,aClass);
4634 aClass.SetParent(this);
4635 aClass.MakeValueClass(ValueClass.ValueType);
4636 return aClass;
4637 }
4638
4639 internal string TypeName()
4640 {
4641 string result = name;
4642 if (hasVersion)
4643 result = result + ", Version=" + major + "." + minor + "." +
4644 build + "." + revision;
4645 if (keyBytes != null) {
4646 string tokenStr = "=";
4647 if (isKeyToken) tokenStr = "Token=";
4648 result = result + ", PublicKey" + tokenStr;
4649 for (int i=0; i < keyBytes.Length; i++) {
4650 result = result + Hex.Byte(keyBytes[i]);
4651 }
4652 }
4653 if (culture != null)
4654 result = result + ", Culture=" + culture;
4655 return result;
4656 }
4657
4658 internal sealed override uint Size(MetaData md)
4659 {
4660 return 12 + 2 * md.StringsIndexSize() + 2 * md.BlobIndexSize();
4661 }
4662
4663 internal sealed override void Write(FileImage output)
4664 {
4665 output.Write(major);
4666 output.Write(minor);
4667 output.Write(build);
4668 output.Write(revision);
4669 output.Write(flags);
4670 output.BlobIndex(keyIx);
4671 output.StringsIndex(nameIx);
4672 output.StringsIndex(cultIx);
4673 output.BlobIndex(hashIx);
4674 }
4675
4676 internal sealed override uint GetCodedIx(CIx code)
4677 {
4678 switch (code) {
4679 case (CIx.ResolutionScope) : return 2;
4680 case (CIx.HasCustomAttr) : return 15;
4681 case (CIx.Implementation) : return 1;
4682 }
4683 return 0;
4684 }
4685
4686 }
4687
4688 /**************************************************************************/
4689 /// <summary>
4690 /// Descriptor for a class defined in System (mscorlib)
4691 /// </summary>
4692 internal class SystemClass : ClassRef {
4693
4694 PrimitiveType elemType;
4695
4696 internal SystemClass(PrimitiveType eType, AssemblyRef paren, MetaData md)
4697 : base("System",eType.GetName(),md) {
4698 elemType = eType;
4699 parent = paren;
4700 }
4701
4702 internal override sealed MetaDataElement GetTypeSpec(MetaData md)
4703 {
4704 if (typeSpec == null) typeSpec = (TypeSpec)elemType.GetTypeSpec(md);
4705 return typeSpec;
4706 }
4707
4708
4709 internal sealed override void TypeSig(MemoryStream str)
4710 {
4711 str.WriteByte(elemType.GetTypeIndex());
4712 }
4713
4714 }
4715
4716 /**************************************************************************/
4717 /// <summary>
4718 /// The assembly for mscorlib.
4719 /// </summary>
4720 public sealed class MSCorLib : AssemblyRef {
4721
4722 private static readonly int valueTypeIx = 18;
4723 private readonly string systemName = "System";
4724 private Class[] systemClasses = new Class[valueTypeIx+2];
4725 private PrimitiveType[] systemTypes = new PrimitiveType[valueTypeIx];
4726 private TypeSpec[] specialTypeSpecs = new TypeSpec[valueTypeIx];
4727 private static int[] specialNames = {
4728 PrimitiveType.Void.GetName().GetHashCode(),
4729 PrimitiveType.Boolean.GetName().GetHashCode(),
4730 PrimitiveType.Char.GetName().GetHashCode(),
4731 PrimitiveType.Int8.GetName().GetHashCode(),
4732 PrimitiveType.UInt8.GetName().GetHashCode(),
4733 PrimitiveType.Int16.GetName().GetHashCode(),
4734 PrimitiveType.UInt16.GetName().GetHashCode(),
4735 PrimitiveType.Int32.GetName().GetHashCode(),
4736 PrimitiveType.UInt32.GetName().GetHashCode(),
4737 PrimitiveType.Int64.GetName().GetHashCode(),
4738 PrimitiveType.UInt64.GetName().GetHashCode(),
4739 PrimitiveType.Float32.GetName().GetHashCode(),
4740 PrimitiveType.Float64.GetName().GetHashCode(),
4741 PrimitiveType.String.GetName().GetHashCode(),
4742 PrimitiveType.TypedRef.GetName().GetHashCode(),
4743 PrimitiveType.IntPtr.GetName().GetHashCode(),
4744 PrimitiveType.UIntPtr.GetName().GetHashCode(),
4745 PrimitiveType.Object.GetName().GetHashCode(),
4746 PrimitiveType.ValueType.GetName ().GetHashCode(),
4747 "Enum".GetHashCode()
4748 };
4749
4750 internal MSCorLib(MetaData md) : base(md,"mscorlib")
4751 {
4752 if (!PEFile.IsMSCorlib)
4753 md.AddToTable(MDTable.AssemblyRef,this);
4754 systemTypes[PrimitiveType.Void.GetSystemTypeIx()] = PrimitiveType.Void;
4755 systemTypes[PrimitiveType.Boolean.GetSystemTypeIx()] = PrimitiveType.Boolean;
4756 systemTypes[PrimitiveType.Char.GetSystemTypeIx()] = PrimitiveType.Char;
4757 systemTypes[PrimitiveType.Int8.GetSystemTypeIx()] = PrimitiveType.Int8;
4758 systemTypes[PrimitiveType.UInt8.GetSystemTypeIx()] = PrimitiveType.UInt8;
4759 systemTypes[PrimitiveType.Int16.GetSystemTypeIx()] = PrimitiveType.Int16;
4760 systemTypes[PrimitiveType.UInt16.GetSystemTypeIx()] = PrimitiveType.UInt16;
4761 systemTypes[PrimitiveType.Int32.GetSystemTypeIx()] = PrimitiveType.Int32;
4762 systemTypes[PrimitiveType.UInt32.GetSystemTypeIx()] = PrimitiveType.UInt32;
4763 systemTypes[PrimitiveType.Int64.GetSystemTypeIx()] = PrimitiveType.Int64;
4764 systemTypes[PrimitiveType.UInt64.GetSystemTypeIx()] = PrimitiveType.UInt64;
4765 systemTypes[PrimitiveType.Float32.GetSystemTypeIx()] = PrimitiveType.Float32;
4766 systemTypes[PrimitiveType.Float64.GetSystemTypeIx()] = PrimitiveType.Float64;
4767 systemTypes[PrimitiveType.IntPtr.GetSystemTypeIx()] = PrimitiveType.IntPtr;
4768 systemTypes[PrimitiveType.UIntPtr.GetSystemTypeIx()] = PrimitiveType.UIntPtr;
4769 systemTypes[PrimitiveType.String.GetSystemTypeIx()] = PrimitiveType.String;
4770 systemTypes[PrimitiveType.Object.GetSystemTypeIx()] = PrimitiveType.Object;
4771 systemTypes[PrimitiveType.TypedRef.GetSystemTypeIx()] = PrimitiveType.TypedRef;
4772 }
4773
4774 /// <summary>
4775 /// Add a class to the mscorlib assembly
4776 /// </summary>
4777 /// <param name="nsName">name space name</param>
4778 /// <param name="name">class name</param>
4779 /// <returns></returns>
4780 public override ClassRef AddClass(string nsName, string name)
4781 {
4782 /* This gets called by !mscorlib, for adding references INTO mscorlib, so
4783 it should be returning ClassRef ..*/
4784 Class aClass = GetSpecialClass(nsName,name);
4785 if (aClass == null) {
4786 aClass = new ClassRef(nsName,name,metaData);
4787 metaData.AddToTable(MDTable.TypeRef,aClass);
4788 if (aClass is ClassRef)
4789 ((ClassRef) aClass).SetParent(this);
4790 }
4791 //FIXME: Check for !ClassRef here?
4792 return (ClassRef) aClass;
4793 }
4794
4795 private Class GetSpecialClass(string nsName,string name)
4796 {
4797 if (nsName.CompareTo(systemName) != 0) return null;
4798 int hash = name.GetHashCode();
4799 for (int i=0; i < specialNames.Length; i++) {
4800 if (hash != specialNames[i])
4801 continue;
4802 if (systemClasses[i] == null) {
4803 if (i < valueTypeIx) {
4804 systemClasses[i] = new SystemClass(systemTypes[i],this,metaData);
4805 if ((systemTypes[i] != PrimitiveType.Object) &&
4806 (systemTypes[i] != PrimitiveType.String)) {
4807 systemClasses[i].MakeValueClass(ValueClass.ValueType);
4808 }
4809 } else {
4810 systemClasses[i] = new ClassRef(nsName,name,metaData);
4811 ((ClassRef) systemClasses[i]).SetParent(this);
4812 if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name))
4813 systemClasses[i].MakeValueClass(ValueClass.ValueType);
4814 }
4815 metaData.AddToTable(MDTable.TypeRef,systemClasses[i]);
4816 }
4817 return systemClasses[i];
4818 }
4819 return null;
4820 }
4821
4822 internal void SetSpecialSystemClass (string nsName, string name, Class aClass)
4823 {
4824 if (nsName != systemName) return;
4825 int hash = name.GetHashCode ();
4826 for (int i = 0; i < specialNames.Length; i++) {
4827 if (hash != specialNames [i])
4828 continue;
4829 if (systemClasses [i] == null) {
4830 systemClasses [i] = aClass;
4831 }
4832 }
4833 }
4834
4835 internal Class GetSpecialSystemClass(PrimitiveType pType)
4836 {
4837 int ix = pType.GetSystemTypeIx();
4838 if (systemClasses[ix] == null && !PEFile.IsMSCorlib) {
4839 systemClasses[ix] = new SystemClass(pType,this,metaData);
4840 metaData.AddToTable(MDTable.TypeRef,systemClasses[ix]);
4841 }
4842 return systemClasses[ix];
4843 }
4844
4845 private ClassRef GetValueClass(string name, int hash)
4846 {
4847 /* Called by MSCorLib.AddValueClass, which is called by
4848 !mscorlib, for adding ref to value class INTO mscorlib,
4849 so this should be classref */
4850 int ix = valueTypeIx;
4851 if (hash != specialNames[valueTypeIx]) ix++;
4852 if (systemClasses[ix] == null) {
4853 systemClasses[ix] = new ClassRef(systemName,name,metaData);
4854 ((ClassRef) systemClasses[ix]).SetParent(this);
4855 ((ClassRef) systemClasses[ix]).MakeValueClass(ValueClass.ValueType);
4856 metaData.AddToTable(MDTable.TypeRef,systemClasses[ix]);
4857 }
4858 return (ClassRef) systemClasses[ix];
4859 }
4860
4861 internal Class ValueType()
4862 {
4863 if (systemClasses[valueTypeIx] == null && !PEFile.IsMSCorlib) {
4864 ClassRef valType = new ClassRef("System","ValueType",metaData);
4865 valType.SetParent(this);
4866 valType.MakeValueClass(ValueClass.ValueType);
4867 metaData.AddToTable(MDTable.TypeRef,valType);
4868 systemClasses[valueTypeIx] = valType;
4869 }
4870 return systemClasses[valueTypeIx];
4871 }
4872
4873 internal Class EnumType()
4874 {
4875 /* Called by both mscorlib & !mscorlib, so can be
4876 either ClassRef or ClassDef */
4877 //systemClasses [ valueTypeIx + 1] -> System.Enum
4878 if (systemClasses[valueTypeIx + 1] == null && !PEFile.IsMSCorlib) {
4879 ClassRef valType = new ClassRef("System","Enum",metaData);
4880 valType.SetParent(this);
4881 valType.MakeValueClass(ValueClass.Enum);
4882 metaData.AddToTable(MDTable.TypeRef,valType);
4883 systemClasses[valueTypeIx + 1] = valType;
4884 }
4885 return systemClasses[valueTypeIx + 1];
4886 }
4887
4888 /// <summary>
4889 /// Add a value class to this external assembly
4890 /// </summary>
4891 /// <param name="nsName">name space name</param>
4892 /// <param name="name">class name</param>
4893 /// <returns></returns>
4894 public override ClassRef AddValueClass(string nsName, string name)
4895 {
4896 if (nsName.CompareTo(systemName) == 0) {
4897 int hash = name.GetHashCode();
4898 if ((hash == specialNames[valueTypeIx]) ||
4899 (hash == specialNames[valueTypeIx+1])) {
4900 return GetValueClass(name,hash);
4901 }
4902 }
4903 ClassRef aClass = new ClassRef(nsName,name,metaData);
4904 metaData.AddToTable(MDTable.TypeRef,aClass);
4905 aClass.SetParent(this);
4906 aClass.MakeValueClass(ValueClass.ValueType);
4907 return aClass;
4908 }
4909
4910 }
4911
4912 /**************************************************************************/
4913 /// <summary>
4914 /// MetaData
4915 /// Root (20 bytes + UTF-8 Version String + quad align padding)
4916 /// StreamHeaders (8 bytes + null terminated name string + quad align padding)
4917 /// Streams
4918 /// #~ (always present - holds metadata tables)
4919 /// #Strings (always present - holds identifier strings)
4920 /// #US (Userstring heap)
4921 /// #Blob (signature blobs)
4922 /// #GUID (guids for assemblies or Modules)
4923 /// </summary>
4924 public class MetaData {
4925
4926 internal static readonly int[] CIxShiftMap = {2,2,5,1,2,3,1,1,1,2,3,2,1};
4927 private static readonly byte StringsHeapMask = 0x1;
4928 private static readonly byte GUIDHeapMask = 0x2;
4929 private static readonly byte BlobHeapMask = 0x4;
4930 private static readonly uint MetaDataSignature = 0x424A5342;
4931 private static readonly uint maxSmlIxSize = 0xFFFF;
4932 private static readonly uint max1BitSmlIx = 0x7FFF;
4933 private static readonly uint max2BitSmlIx = 0x3FFF;
4934 private static readonly uint max3BitSmlIx = 0x1FFF;
4935 private static readonly uint max5BitSmlIx = 0x7FF;
4936 // NOTE: version and stream name strings MUST always be quad padded
4937 #if NET_2_0 || BOOTSTRAP_NET_2_0
4938 private static readonly string version = "v2.0.50727\0\0";
4939 #else
4940 private static readonly string version = "v1.1.4322\0\0\0";
4941 #endif
4942 private static readonly char[] tildeName = {'#','~','\0','\0'};
4943 private static readonly char[] stringsName = {'#','S','t','r','i','n','g','s','\0','\0','\0','\0'};
4944 private static readonly char[] usName = {'#','U','S','\0'};
4945 private static readonly char[] guidName = {'#','G','U','I','D','\0','\0','\0'};
4946 private static readonly char[] blobName = {'#','B','l','o','b','\0','\0','\0'};
4947 private static readonly uint MetaDataHeaderSize = 20 + (uint)version.Length;
4948 private static readonly uint TildeHeaderSize = 24;
4949 private static readonly uint StreamHeaderSize = 8;
4950 private static readonly uint numMetaDataTables = (int)MDTable.GenericParamConstraint + 1;
4951 private static readonly uint tildeHeaderSize = 8 + (uint)tildeName.Length;
4952
4953 MetaDataStream strings, us, guid, blob;
4954
4955 MetaDataStream[] streams = new MetaDataStream[5];
4956 uint numStreams = 5;
4957 uint tildeTide = 0, tildePadding = 0, tildeStart = 0;
4958 uint numTables = 0, resourcesSize = 0;
4959 ArrayList[] metaDataTables = new ArrayList[numMetaDataTables];
4960 ArrayList byteCodes = new ArrayList();
4961 uint codeSize = 0, codeStart, byteCodePadding = 0, metaDataSize = 0;
4962 ulong valid = 0, /*sorted = 0x000002003301FA00;*/ sorted = 0;
4963 bool[] largeIx = new bool[numMetaDataTables];
4964 bool[] lgeCIx = new bool[(int)CIx.MaxCIx];
4965 bool largeStrings = false, largeUS = false, largeGUID = false, largeBlob = false;
4966 private FileImage file;
4967 private byte heapSizes = 0;
4968 MetaDataElement entryPoint;
4969 BinaryWriter output;
4970 public MSCorLib mscorlib;
4971 private TypeSpec[] systemTypeSpecs = new TypeSpec[PrimitiveType.NumSystemTypes];
4972 long mdStart;
4973 private ArrayList cattr_list;
4974 private ArrayList declsec_list;
4975 ArrayList resources;
4976
4977 internal MetaData(FileImage file)
4978 {
4979 // tilde = new MetaDataStream(tildeName,false,0);
4980 this.file = file;
4981 strings = new MetaDataStream(stringsName,new UTF8Encoding(),true);
4982 us = new MetaDataStream(usName,new UnicodeEncoding(),true);
4983 guid = new MetaDataStream(guidName,false);
4984 blob = new MetaDataStream(blobName,true);
4985 streams[1] = strings;
4986 streams[2] = us;
4987 streams[3] = guid;
4988 streams[4] = blob;
4989 for (int i=0; i < numMetaDataTables; i++) {
4990 largeIx[i] = false;
4991 }
4992 for (int i=0; i < lgeCIx.Length; i++) {
4993 lgeCIx[i] = false;
4994 }
4995 mscorlib = new MSCorLib(this);
4996 }
4997
4998 internal TypeSpec GetPrimitiveTypeSpec(int ix)
4999 {
5000 return systemTypeSpecs[ix];
5001 }
5002
5003 internal void SetPrimitiveTypeSpec(int ix, TypeSpec typeSpec)
5004 {
5005 systemTypeSpecs[ix] = typeSpec;
5006 }
5007
5008 internal uint Size()
5009 {
5010 return metaDataSize;
5011 }
5012
5013 private void CalcHeapSizes ()
5014 {
5015 if (strings.LargeIx()) {
5016 largeStrings = true;
5017 heapSizes |= StringsHeapMask;
5018 }
5019 if (guid.LargeIx()) {
5020 largeGUID = true;
5021 heapSizes |= GUIDHeapMask;
5022 }
5023 if (blob.LargeIx()) {
5024 largeBlob = true;
5025 heapSizes |= BlobHeapMask;
5026 }
5027
5028 largeUS = us.LargeIx();
5029 }
5030
5031 internal void StreamSize(byte mask)
5032 {
5033 heapSizes |= mask;
5034 }
5035
5036 internal uint AddToUSHeap(string str)
5037 {
5038 if (str == null) return 0;
5039 return us.Add(str,true);
5040 }
5041
5042 internal uint AddToUSHeap(byte[] str)
5043 {
5044 if (str == null) return 0;
5045 return us.Add (str, true);
5046 }
5047
5048 internal uint AddToStringsHeap(string str)
5049 {
5050 if ((str == null) || (str.CompareTo("") == 0)) return 0;
5051 return strings.Add(str,false);
5052 }
5053
5054 internal uint AddToGUIDHeap(Guid guidNum)
5055 {
5056 return guid.Add(guidNum, false);
5057 }
5058
5059 internal uint AddToBlobHeap(byte[] blobBytes)
5060 {
5061 if (blobBytes == null) return 0;
5062 return blob.Add(blobBytes, true);
5063 }
5064
5065 internal uint AddToBlobHeap(byte val)
5066 {
5067 return blob.Add(val, true);
5068 }
5069
5070 internal uint AddToBlobHeap(sbyte val)
5071 {
5072 return blob.Add(val, true);
5073 }
5074
5075 internal uint AddToBlobHeap(ushort val)
5076 {
5077 return blob.Add(val, true);
5078 }
5079
5080 internal uint AddToBlobHeap(short val)
5081 {
5082 return blob.Add(val, true);
5083 }
5084
5085 internal uint AddToBlobHeap(uint val)
5086 {
5087 return blob.Add(val, true);
5088 }
5089
5090 internal uint AddToBlobHeap(int val)
5091 {
5092 return blob.Add(val, true);
5093 }
5094
5095 internal uint AddToBlobHeap(ulong val)
5096 {
5097 return blob.Add(val, true);
5098 }
5099
5100 internal uint AddToBlobHeap(long val)
5101 {
5102 return blob.Add(val, true);
5103 }
5104
5105 internal uint AddToBlobHeap(float val)
5106 {
5107 return blob.Add(val, true);
5108 }
5109
5110 internal uint AddToBlobHeap(double val)
5111 {
5112 return blob.Add(val, true);
5113 }
5114
5115 internal uint AddToBlobHeap(string val)
5116 {
5117 return blob.Add(val,true);
5118 }
5119
5120 internal void AddCustomAttribute (CustomAttribute cattr)
5121 {
5122 if (cattr_list == null)
5123 cattr_list = new ArrayList ();
5124 cattr_list.Add (cattr);
5125 }
5126
5127 internal void AddDeclSecurity (BaseDeclSecurity decl_sec)
5128 {
5129 if (declsec_list == null)
5130 declsec_list = new ArrayList ();
5131 declsec_list.Add (decl_sec);
5132 }
5133
5134 private ArrayList GetTable(MDTable tableIx)
5135 {
5136 int tabIx = (int)tableIx;
5137 if (metaDataTables[tabIx] == null) {
5138 metaDataTables[tabIx] = new ArrayList();
5139 valid |= ((ulong)0x1 << tabIx);
5140 // Console.WriteLine("after creating table " + tableIx + "(" + tabIx + ") valid = " + valid);
5141 numTables++;
5142 }
5143 return metaDataTables[tabIx];
5144 }
5145
5146 internal void AddToTable(MDTable tableIx, MetaDataElement elem)
5147 {
5148 if (elem.Row > 0) {
5149 // Console.Out.WriteLine("ERROR - element already in table " + tableIx);
5150 return;
5151 }
5152 // updates Row field of the element
5153 // Console.WriteLine("Adding element to table " + (uint)tableIx);
5154 ArrayList table = GetTable(tableIx);
5155 elem.Row = (uint)table.Count + 1;
5156 table.Add(elem);
5157 }
5158
5159 internal uint TableIndex(MDTable tableIx)
5160 {
5161 if (metaDataTables[(int)tableIx] == null) return 1;
5162 return (uint)metaDataTables[(int)tableIx].Count+1;
5163 }
5164
5165 internal uint AddCode(CILInstructions byteCode)
5166 {
5167 byteCodes.Add(byteCode);
5168 uint offset = codeSize + codeStart;
5169 codeSize += byteCode.GetCodeSize();
5170 return offset;
5171 }
5172
5173 internal void SetEntryPoint(MetaDataElement ep)
5174 {
5175 entryPoint = ep;
5176 }
5177
5178 internal uint AddResource(byte[] resBytes)
5179 {
5180 if (resources == null) resources = new ArrayList ();
5181 resources.Add (resBytes);
5182 uint offset = resourcesSize;
5183 resourcesSize += (uint)resBytes.Length + 4;
5184 return offset;
5185 }
5186
5187 internal void AddData(DataConstant cVal)
5188 {
5189 file.AddInitData(cVal);
5190 }
5191
5192 internal static void CompressNum(uint val, MemoryStream sig)
5193 {
5194 if (val <= 0x7F) {
5195 sig.WriteByte((byte)val);
5196 } else if (val <= 0x3FFF) {
5197 byte b1 = (byte)((val >> 8) | 0x80);
5198 byte b2 = (byte)(val & FileImage.iByteMask[0]);
5199 sig.WriteByte(b1);
5200 sig.WriteByte(b2);
5201 } else {
5202 byte b1 = (byte)((val >> 24) | 0xC0);
5203 byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);
5204 byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
5205 byte b4 = (byte)(val & FileImage.iByteMask[0]);
5206 sig.WriteByte(b1);
5207 sig.WriteByte(b2);
5208 sig.WriteByte(b3);
5209 sig.WriteByte(b4);
5210 }
5211 }
5212
5213 internal uint CodeSize()
5214 {
5215 return codeSize + byteCodePadding;
5216 }
5217
5218 internal uint GetResourcesSize()
5219 {
5220 return resourcesSize;
5221 }
5222
5223 internal uint StringsIndexSize()
5224 {
5225 if (largeStrings) return 4;
5226 return 2;
5227 }
5228
5229 internal uint GUIDIndexSize()
5230 {
5231 if (largeGUID) return 4;
5232 return 2;
5233 }
5234
5235 internal uint USIndexSize()
5236 {
5237 if (largeUS) return 4;
5238 return 2;
5239 }
5240
5241 internal uint BlobIndexSize()
5242 {
5243 if (largeBlob) return 4;
5244 return 2;
5245 }
5246
5247 internal uint CodedIndexSize(CIx code)
5248 {
5249 if (lgeCIx[(uint)code]) return 4;
5250 return 2;
5251 }
5252
5253 internal uint TableIndexSize(MDTable tabIx)
5254 {
5255 if (largeIx[(uint)tabIx]) return 4;
5256 return 2;
5257 }
5258
5259 private void SetIndexSizes()
5260 {
5261 for (int i=0; i < numMetaDataTables; i++) {
5262 if (metaDataTables[i] == null)
5263 continue;
5264
5265 uint count = (uint)metaDataTables[i].Count;
5266 if (count > maxSmlIxSize)
5267 largeIx[i] = true;
5268
5269 MDTable tabIx = (MDTable)i;
5270 if (count > max5BitSmlIx) {
5271 lgeCIx[(int)CIx.HasCustomAttr] = true;
5272 }
5273 if (count > max3BitSmlIx) {
5274 if ((tabIx == MDTable.TypeRef) || (tabIx == MDTable.ModuleRef) || (tabIx == MDTable.Method) || (tabIx == MDTable.TypeSpec) || (tabIx == MDTable.Field))
5275 lgeCIx[(int)CIx.CustomAttributeType] = true;
5276 if ((tabIx == MDTable.Method) || (tabIx == MDTable.MemberRef))
5277 lgeCIx[(int)CIx.MemberRefParent] = true;
5278 }
5279 if (count > max2BitSmlIx) {
5280 if ((tabIx == MDTable.Field) || (tabIx == MDTable.Param) || (tabIx == MDTable.Property))
5281 lgeCIx[(int)CIx.HasConst] = true;
5282 if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.TypeRef) || (tabIx == MDTable.TypeSpec))
5283 lgeCIx[(int)CIx.TypeDefOrRef] = true;
5284 if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.Method) || (tabIx == MDTable.Assembly))
5285 lgeCIx[(int)CIx.HasDeclSecurity] = true;
5286 if ((tabIx == MDTable.File) || (tabIx == MDTable.AssemblyRef) || (tabIx == MDTable.ExportedType))
5287 lgeCIx[(int)CIx.Implementation] = true;
5288 if ((tabIx == MDTable.Module) || (tabIx == MDTable.ModuleRef) || (tabIx == MDTable.AssemblyRef) || (tabIx == MDTable.TypeRef))
5289 lgeCIx[(int)CIx.ResolutionScope] = true;
5290 }
5291 if (count > max1BitSmlIx) {
5292 if ((tabIx == MDTable.Field) || (tabIx == MDTable.Param))
5293 lgeCIx[(int)CIx.HasFieldMarshal] = true;
5294 if ((tabIx == MDTable.Event) || (tabIx == MDTable.Property))
5295 lgeCIx[(int)CIx.HasSemantics] = true;
5296 if ((tabIx == MDTable.Method) || (tabIx == MDTable.MemberRef))
5297 lgeCIx[(int)CIx.MethodDefOrRef] = true;
5298 if ((tabIx == MDTable.Field) || (tabIx == MDTable.Method))
5299 lgeCIx[(int)CIx.MemberForwarded] = true;
5300 if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.Method))
5301 lgeCIx[(int)CIx.TypeOrMethodDef] = true;
5302 }
5303 }
5304 }
5305
5306 private void SetStreamOffsets()
5307 {
5308 uint sizeOfHeaders = StreamHeaderSize + (uint)tildeName.Length;
5309 for (int i=1; i < numStreams; i++) {
5310 sizeOfHeaders += streams[i].headerSize();
5311 }
5312 metaDataSize = MetaDataHeaderSize + sizeOfHeaders;
5313 tildeStart = metaDataSize;
5314 metaDataSize += tildeTide + tildePadding;
5315 for (int i=1; i < numStreams; i++) {
5316 streams[i].Start = metaDataSize;
5317 metaDataSize += streams[i].Size();
5318 streams[i].WriteDetails();
5319 }
5320 }
5321
5322 internal void CalcTildeStreamSize()
5323 {
5324 CalcHeapSizes ();
5325 //tilde.SetIndexSizes(strings.LargeIx(),us.LargeIx(),guid.LargeIx(),blob.LargeIx());
5326 tildeTide = TildeHeaderSize;
5327 tildeTide += 4 * numTables;
5328 //Console.WriteLine("Tilde header + sizes = " + tildeTide);
5329 for (int i=0; i < numMetaDataTables; i++) {
5330 if (metaDataTables[i] != null) {
5331 ArrayList table = metaDataTables[i];
5332 // Console.WriteLine("Meta data table " + i + " at offset " + tildeTide);
5333 tildeTide += (uint)table.Count * ((MetaDataElement)table[0]).Size(this);
5334 // Console.WriteLine("Metadata table " + i + " has size " + table.Count);
5335 // Console.WriteLine("tildeTide = " + tildeTide);
5336 }
5337 }
5338 if ((tildeTide % 4) != 0) tildePadding = 4 - (tildeTide % 4);
5339 //Console.WriteLine("tildePadding = " + tildePadding);
5340 }
5341
5342 internal void WriteTildeStream(FileImage output)
5343 {
5344 long startTilde = output.Seek(0,SeekOrigin.Current);
5345 output.Write((uint)0); // Reserved
5346 #if NET_2_0 || BOOTSTRAP_NET_2_0
5347 output.Write((byte)2); // MajorVersion
5348 output.Write((byte)0); // MinorVersion
5349 #else
5350 output.Write((byte)1); // MajorVersion
5351 output.Write((byte)0); // MinorVersion
5352 #endif
5353 output.Write(heapSizes);
5354 output.Write((byte)1); // Reserved
5355 output.Write(valid);
5356 output.Write(sorted);
5357 for (int i=0; i < numMetaDataTables; i++) {
5358 if (metaDataTables[i] != null) {
5359 uint count = (uint)metaDataTables[i].Count;
5360 output.Write(count);
5361 }
5362 }
5363 long tabStart = output.Seek(0,SeekOrigin.Current);
5364 // Console.WriteLine("Starting metaData tables at " + tabStart);
5365 for (int i=0; i < numMetaDataTables; i++) {
5366 if (metaDataTables[i] != null) {
5367 // Console.WriteLine("Starting metaData table " + i + " at " + (output.Seek(0,SeekOrigin.Current) - startTilde));
5368 ArrayList table = metaDataTables[i];
5369 for (int j=0; j < table.Count; j++) {
5370 ((MetaDataElement)table[j]).Write(output);
5371 }
5372 }
5373 }
5374 // Console.WriteLine("Writing padding at " + output.Seek(0,SeekOrigin.Current));
5375 for (int i=0; i < tildePadding; i++) output.Write((byte)0);
5376 }
5377
5378 private void BuildTable(ArrayList table)
5379 {
5380 if (table == null) return;
5381 for (int j=0; j < table.Count; j++) {
5382 ((MetaDataElement)table[j]).BuildTables(this);
5383 }
5384 }
5385
5386 private void SortTable (ArrayList mTable)
5387 {
5388 if (mTable == null) return;
5389 mTable.Sort();
5390 for (int i=0; i < mTable.Count; i++) {
5391 ((MetaDataElement)mTable[i]).Row = (uint)i+1;
5392 }
5393 }
5394
5395 internal void BuildMetaData(uint codeStartOffset)
5396 {
5397 codeStart = codeStartOffset;
5398 BuildTable(metaDataTables[(int)MDTable.TypeDef]);
5399 BuildTable(metaDataTables[(int)MDTable.TypeSpec]);
5400 BuildTable(metaDataTables[(int)MDTable.MemberRef]);
5401 #if NET_2_0 || BOOTSTRAP_NET_2_0
5402 BuildTable(metaDataTables[(int)MDTable.GenericParam]);
5403 BuildTable(metaDataTables[(int)MDTable.MethodSpec]);
5404 BuildTable(metaDataTables[(int)MDTable.GenericParamConstraint]);
5405 #endif
5406 BuildTable(metaDataTables[(int)MDTable.ManifestResource]);
5407
5408 if (cattr_list != null) {
5409 foreach (CustomAttribute cattr in cattr_list)
5410 cattr.BuildTables (this);
5411 }
5412
5413 if (declsec_list != null) {
5414 foreach (BaseDeclSecurity decl_sec in declsec_list)
5415 decl_sec.BuildTables (this);
5416 }
5417
5418 /* for (int i=0; i < metaDataTables.Length; i++) {
5419 ArrayList table = metaDataTables[i];
5420 if (table != null) {
5421 for (int j=0; j < table.Count; j++) {
5422 ((MetaDataElement)table[j]).BuildTables(this);
5423 }
5424 }
5425 }
5426 */
5427
5428 SetIndexSizes();
5429 for (int i=1; i < numStreams; i++) {
5430 streams[i].EndStream();
5431 }
5432 CalcTildeStreamSize();
5433 SetStreamOffsets();
5434 byteCodePadding = NumToAlign(codeSize,4);
5435 if (entryPoint != null) file.SetEntryPoint(entryPoint.Token());
5436
5437 // Check ordering of specific tables
5438 // Constant, CustomAttribute, FieldMarshal, DeclSecurity, MethodSemantics
5439 // ImplMap, GenericParam
5440 // Need to load GenericParamConstraint AFTER GenericParam table in correct order
5441 // The tables:
5442 // InterfaceImpl, ClassLayout, FieldLayout, MethodImpl, FieldRVA, NestedClass
5443 // will _ALWAYS_ be in the correct order as embedded in BuildMDTables
5444
5445 SortTable(metaDataTables[(int)MDTable.Constant]);
5446 SortTable(metaDataTables[(int)MDTable.FieldMarshal]);
5447 SortTable(metaDataTables[(int)MDTable.DeclSecurity]);
5448 SortTable(metaDataTables[(int)MDTable.MethodSemantics]);
5449 SortTable(metaDataTables[(int)MDTable.ImplMap]);
5450 #if NET_2_0 || BOOTSTRAP_NET_2_0
5451 if (metaDataTables[(int)MDTable.GenericParam] != null) {
5452 SortTable(metaDataTables[(int)MDTable.GenericParam]);
5453 // Now add GenericParamConstraints
5454 /*for (int i=0; i < metaDataTables[(int)MDTable.GenericParam].Count; i++) {
5455 ((GenericParameter)metaDataTables[(int)MDTable.GenericParam][i]).AddConstraints(this);
5456 }*/
5457 }
5458 SortTable(metaDataTables[(int)MDTable.GenericParamConstraint]);
5459 #endif
5460 SortTable(metaDataTables[(int)MDTable.InterfaceImpl]);
5461 SortTable(metaDataTables[(int)MDTable.CustomAttribute]);
5462
5463 }
5464
5465 internal void WriteByteCodes(FileImage output)
5466 {
5467 for (int i=0; i < byteCodes.Count; i++) {
5468 ((CILInstructions)byteCodes[i]).Write(output);
5469 }
5470 for (int i=0; i < byteCodePadding; i++) {
5471 output.Write((byte)0);
5472 }
5473 }
5474
5475 internal void WriteResources (FileImage output)
5476 {
5477 if (resources == null) return;
5478 for (int i = 0; i < resources.Count; i ++) {
5479 byte [] resBytes = (byte []) resources [i];
5480 output.Write ((uint) resBytes.Length);
5481 output.Write (resBytes);
5482 }
5483 }
5484
5485 internal void WriteMetaData(FileImage output)
5486 {
5487 this.output = output;
5488 mdStart = output.Seek(0,SeekOrigin.Current);
5489 // Console.WriteLine("Writing metaData at " + Hex.Long(mdStart));
5490 output.Write(MetaDataSignature);
5491 output.Write((short)1); // Major Version
5492 output.Write((short)1); // Minor Version ECMA = 0, PEFiles = 1
5493 output.Write(0); // Reserved
5494 output.Write(version.Length);
5495 output.Write(version.ToCharArray()); // version string is already zero padded
5496 output.Write((short)0);
5497 output.Write((ushort)numStreams);
5498 // write tilde header
5499 output.Write(tildeStart);
5500 output.Write(tildeTide + tildePadding);
5501 output.Write(tildeName);
5502 for (int i=1; i < numStreams; i++) streams[i].WriteHeader(output);
5503 // Console.WriteLine("Writing tilde stream at " + output.Seek(0,SeekOrigin.Current) + " = " + tildeStart);
5504 WriteTildeStream(output);
5505 for (int i=1; i < numStreams; i++) streams[i].Write(output);
5506 // Console.WriteLine("Finished Writing metaData at " + output.Seek(0,SeekOrigin.Current));
5507 }
5508
5509 internal bool LargeStringsIndex() { return strings.LargeIx(); }
5510 internal bool LargeGUIDIndex() { return guid.LargeIx(); }
5511 internal bool LargeUSIndex() { return us.LargeIx(); }
5512 internal bool LargeBlobIndex() { return blob.LargeIx(); }
5513
5514 internal bool LargeIx(MDTable tabIx) { return largeIx[(uint)tabIx]; }
5515
5516
5517 private uint NumToAlign(uint val, uint alignVal)
5518 {
5519 if ((val % alignVal) == 0) return 0;
5520 return alignVal - (val % alignVal);
5521 }
5522
5523 internal void WriteCodedIndex(CIx code, MetaDataElement elem, FileImage output)
5524 {
5525 uint ix = 0;
5526 if (elem != null) {
5527 ix = (elem.Row << CIxShiftMap[(uint)code]) | elem.GetCodedIx(code);
5528 // Console.WriteLine("coded index = " + ix + " row = " + elem.Row);
5529 //} else {
5530 // Console.WriteLine("elem for coded index is null");
5531 }
5532 if (lgeCIx[(uint)code])
5533 output.Write(ix);
5534 else
5535 output.Write((ushort)ix);
5536 }
5537
5538 }
5539
5540 /**************************************************************************/
5541 /// <summary>
5542 /// Stream in the Meta Data (#Strings, #US, #Blob and #GUID)
5543 /// </summary>
5544
5545 internal class MetaDataStream : BinaryWriter {
5546
5547 private static readonly uint StreamHeaderSize = 8;
5548 private static uint maxSmlIxSize = 0xFFFF;
5549
5550 private uint start = 0;
5551 uint size = 0, tide = 1;
5552 bool largeIx = false;
5553 uint sizeOfHeader;
5554 char[] name;
5555 Hashtable htable = new Hashtable();
5556 Hashtable btable = new Hashtable (new ByteArrayHashCodeProvider (), new ByteArrayComparer ());
5557
5558 internal MetaDataStream(char[] name, bool addInitByte) : base(new MemoryStream())
5559 {
5560 if (addInitByte) { Write((byte)0); size = 1; }
5561 this.name = name;
5562 sizeOfHeader = StreamHeaderSize + (uint)name.Length;
5563 }
5564
5565 internal MetaDataStream(char[] name, System.Text.Encoding enc, bool addInitByte) : base(new MemoryStream(),enc)
5566 {
5567 if (addInitByte) { Write((byte)0); size = 1; }
5568 this.name = name;
5569 sizeOfHeader = StreamHeaderSize + (uint)name.Length;
5570 }
5571
5572 public uint Start {
5573 get { return start; }
5574 set { start = value; }
5575 }
5576
5577 internal uint headerSize()
5578 {
5579 // Console.WriteLine(name + " stream has headersize of " + sizeOfHeader);
5580 return sizeOfHeader;
5581 }
5582
5583 internal void SetSize(uint siz)
5584 {
5585 size = siz;
5586 }
5587
5588 internal uint Size()
5589 {
5590 return size;
5591 }
5592
5593 internal bool LargeIx()
5594 {
5595 return largeIx;
5596 }
5597
5598 internal void WriteDetails()
5599 {
5600 // Console.WriteLine(name + " - size = " + size);
5601 }
5602
5603 internal uint Add(string str, bool prependSize)
5604 {
5605 Object val = htable[str];
5606 uint index = 0;
5607 if (val == null) {
5608 index = size;
5609 htable[str] = index;
5610 char[] arr = str.ToCharArray();
5611 if (prependSize) CompressNum((uint)arr.Length*2+1);
5612 Write(arr);
5613 Write((byte)0);
5614 size = (uint)Seek(0,SeekOrigin.Current);
5615 } else {
5616 index = (uint)val;
5617 }
5618 return index;
5619 }
5620 internal uint Add (byte[] str, bool prependSize)
5621 {
5622 Object val = btable [str];
5623 uint index = 0;
5624 if (val == null) {
5625 index = size;
5626 btable [str] = index;
5627 if (prependSize) CompressNum ((uint) str.Length);
5628 Write (str);
5629 size = (uint) Seek (0, SeekOrigin.Current);
5630 } else {
5631 index = (uint) val;
5632 }
5633 return index;
5634 }
5635
5636
5637 internal uint Add(Guid guid, bool prependSize)
5638 {
5639 byte [] b = guid.ToByteArray ();
5640 if (prependSize) CompressNum ((uint) b.Length);
5641 Write(guid.ToByteArray());
5642 size =(uint)Seek(0,SeekOrigin.Current);
5643 return tide++;
5644 }
5645
5646 internal uint Add(byte[] blob)
5647 {
5648 uint ix = size;
5649 CompressNum((uint)blob.Length);
5650 Write(blob);
5651 size = (uint)Seek(0,SeekOrigin.Current);
5652 return ix;
5653 }
5654
5655 internal uint Add(byte val, bool prependSize)
5656 {
5657 uint ix = size;
5658 if (prependSize) CompressNum (1);
5659 Write(val);
5660 size = (uint)Seek(0,SeekOrigin.Current);
5661 return ix;
5662 }
5663
5664 internal uint Add(sbyte val, bool prependSize)
5665 {
5666 uint ix = size;
5667 if (prependSize) CompressNum (1);
5668 Write(val);
5669 size = (uint)Seek(0,SeekOrigin.Current);
5670 return ix;
5671 }
5672
5673 internal uint Add(ushort val, bool prependSize)
5674 {
5675 uint ix = size;
5676 if (prependSize) CompressNum (2);
5677 Write(val);
5678 size = (uint)Seek(0,SeekOrigin.Current);
5679 return ix;
5680 }
5681
5682 internal uint Add(short val, bool prependSize)
5683 {
5684 uint ix = size;
5685 if (prependSize) CompressNum (2);
5686 Write(val);
5687 size = (uint)Seek(0,SeekOrigin.Current);
5688 return ix;
5689 }
5690
5691 internal uint Add(uint val, bool prependSize)
5692 {
5693 uint ix = size;
5694 if (prependSize) CompressNum (4);
5695 Write(val);
5696 size = (uint)Seek(0,SeekOrigin.Current);
5697 return ix;
5698 }
5699
5700 internal uint Add(int val, bool prependSize)
5701 {
5702 uint ix = size;
5703 if (prependSize) CompressNum (4);
5704 Write (val);
5705 size = (uint)Seek(0,SeekOrigin.Current);
5706 return ix;
5707 }
5708
5709 internal uint Add(ulong val, bool prependSize)
5710 {
5711 uint ix = size;
5712 if (prependSize) CompressNum (8);
5713 Write(val);
5714 size = (uint)Seek(0,SeekOrigin.Current);
5715 return ix;
5716 }
5717
5718 internal uint Add(long val, bool prependSize)
5719 {
5720 uint ix = size;
5721 if (prependSize) CompressNum (8);
5722 Write(val);
5723 size = (uint)Seek(0,SeekOrigin.Current);
5724 return ix;
5725 }
5726
5727 internal uint Add(float val, bool prependSize)
5728 {
5729 uint ix = size;
5730 if (prependSize) CompressNum (4);
5731 Write(val);
5732 size = (uint)Seek(0,SeekOrigin.Current);
5733 return ix;
5734 }
5735
5736 internal uint Add(double val, bool prependSize)
5737 {
5738 uint ix = size;
5739 if (prependSize) CompressNum (8);
5740 Write(val);
5741 size = (uint)Seek(0,SeekOrigin.Current);
5742 return ix;
5743 }
5744
5745 private void CompressNum(uint val)
5746 {
5747 if (val < 0x7F) {
5748 Write((byte)val);
5749 } else if (val < 0x3FFF) {
5750 byte b1 = (byte)((val >> 8) | 0x80);
5751 byte b2 = (byte)(val & FileImage.iByteMask[0]);
5752 Write(b1);
5753 Write(b2);
5754 } else {
5755 byte b1 = (byte)((val >> 24) | 0xC0);
5756 byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);
5757 byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
5758 byte b4 = (byte)(val & FileImage.iByteMask[0]);
5759 Write(b1);
5760 Write(b2);
5761 Write(b3);
5762 Write(b4);
5763 }
5764 }
5765
5766 private void QuadAlign()
5767 {
5768 if ((size % 4) != 0) {
5769 uint pad = 4 - (size % 4);
5770 size += pad;
5771 for (int i=0; i < pad; i++) {
5772 Write((byte)0);
5773 }
5774 }
5775 }
5776
5777 internal void EndStream()
5778 {
5779 QuadAlign();
5780 if (size > maxSmlIxSize) {
5781 largeIx = true;
5782 }
5783 }
5784
5785 internal void WriteHeader(BinaryWriter output)
5786 {
5787 output.Write(start);
5788 output.Write(size);
5789 output.Write(name);
5790 }
5791
5792 internal virtual void Write(BinaryWriter output)
5793 {
5794 // Console.WriteLine("Writing " + name + " stream at " + output.Seek(0,SeekOrigin.Current) + " = " + start);
5795 MemoryStream str = (MemoryStream)BaseStream;
5796 output.Write(str.ToArray());
5797 }
5798
5799 }
5800
5801 /**************************************************************************/
5802 class ByteArrayComparer : IComparer {
5803
5804 public int Compare (object x, object y)
5805 {
5806 byte [] a = (byte []) x;
5807 byte [] b = (byte []) y;
5808 int len = a.Length;
5809
5810 if (b.Length != len)
5811 return 1;
5812
5813 for (int i = 0; i < len; ++i)
5814 if (a [i] != b [i])
5815 return 1;
5816 return 0;
5817 }
5818 }
5819
5820 class ByteArrayHashCodeProvider : IHashCodeProvider {
5821
5822 public int GetHashCode (Object key)
5823 {
5824 byte [] arr = (byte []) key;
5825 int len = arr.Length;
5826 int h = 0;
5827
5828 for (int i = 0; i < len; ++i)
5829 h = (h << 5) - h + arr [i];
5830
5831 return h;
5832 }
5833
5834 }
5835
5836
5837 }
Mirror of the official Mono project git repository