5 // Jb Evain (jbevain@gmail.com)
7 // (C) 2005 - 2007 Jb Evain
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 namespace Mono.Cecil {
32 using System.Collections;
33 using System.Globalization;
36 using Mono.Cecil.Binary;
38 using Mono.Cecil.Metadata;
39 using Mono.Cecil.Signatures;
41 internal sealed class ReflectionWriter : BaseReflectionVisitor {
43 StructureWriter m_structureWriter;
44 ModuleDefinition m_mod;
45 SignatureWriter m_sigWriter;
46 CodeWriter m_codeWriter;
47 MetadataWriter m_mdWriter;
48 MetadataTableWriter m_tableWriter;
49 MetadataRowWriter m_rowWriter;
53 ISymbolWriter m_symbolWriter;
55 ArrayList m_typeDefStack;
56 ArrayList m_methodStack;
57 ArrayList m_fieldStack;
58 ArrayList m_genericParamStack;
59 IDictionary m_typeSpecTokenCache;
60 IDictionary m_memberRefTokenCache;
68 MemoryBinaryWriter m_constWriter;
70 public StructureWriter StructureWriter {
71 get { return m_structureWriter; }
73 m_structureWriter = value;
79 public CodeWriter CodeWriter {
80 get { return m_codeWriter; }
83 public bool SaveSymbols {
84 get { return m_saveSymbols; }
85 set { m_saveSymbols = value; }
88 public string OutputFile
90 get { return m_asmOutput; }
91 set { m_asmOutput = value; }
94 public ISymbolWriter SymbolWriter {
95 get { return m_symbolWriter; }
96 set { m_symbolWriter = value; }
99 public SignatureWriter SignatureWriter {
100 get { return m_sigWriter; }
103 public MetadataWriter MetadataWriter {
104 get { return m_mdWriter; }
107 public MetadataTableWriter MetadataTableWriter {
108 get { return m_tableWriter; }
111 public MetadataRowWriter MetadataRowWriter {
112 get { return m_rowWriter; }
115 public ReflectionWriter (ModuleDefinition mod)
122 m_mdWriter = new MetadataWriter (
124 m_mod.Image.MetadataRoot,
125 m_structureWriter.Assembly.Kind,
126 m_mod.Assembly.Runtime,
127 m_structureWriter.GetWriter ());
128 m_tableWriter = m_mdWriter.GetTableVisitor ();
129 m_rowWriter = m_tableWriter.GetRowVisitor () as MetadataRowWriter;
130 m_sigWriter = new SignatureWriter (m_mdWriter);
131 m_codeWriter = new CodeWriter (this, m_mdWriter.CilWriter);
133 m_typeDefStack = new ArrayList ();
134 m_methodStack = new ArrayList ();
135 m_fieldStack = new ArrayList ();
136 m_genericParamStack = new ArrayList ();
137 m_typeSpecTokenCache = new Hashtable ();
138 m_memberRefTokenCache = new Hashtable ();
146 m_constWriter = new MemoryBinaryWriter ();
149 public TypeReference GetCoreType (string name)
151 return m_mod.Controller.Reader.SearchCoreType (name);
154 public static uint GetRidFor (IMetadataTokenProvider tp)
156 return tp.MetadataToken.RID;
159 public uint GetRidFor (AssemblyNameReference asmName)
161 return (uint) m_mod.AssemblyReferences.IndexOf (asmName) + 1;
164 public uint GetRidFor (ModuleDefinition mod)
166 return (uint) m_mod.Assembly.Modules.IndexOf (mod) + 1;
169 public uint GetRidFor (ModuleReference modRef)
171 return (uint) m_mod.ModuleReferences.IndexOf (modRef) + 1;
174 static bool IsTypeSpec (TypeReference type)
176 return type is TypeSpecification || type is GenericParameter;
179 public MetadataToken GetTypeDefOrRefToken (TypeReference type)
181 if (IsTypeSpec (type)) {
182 uint sig = m_sigWriter.AddTypeSpec (GetTypeSpecSig (type));
183 if (m_typeSpecTokenCache.Contains (sig))
184 return (MetadataToken) m_typeSpecTokenCache [sig];
186 TypeSpecTable tsTable = m_tableWriter.GetTypeSpecTable ();
187 TypeSpecRow tsRow = m_rowWriter.CreateTypeSpecRow (sig);
188 tsTable.Rows.Add (tsRow);
190 MetadataToken token = new MetadataToken (TokenType.TypeSpec, (uint) tsTable.Rows.Count);
191 if (! (type is GenericParameter))
192 type.MetadataToken = token;
194 m_typeSpecTokenCache [sig] = token;
196 } else if (type != null)
197 return type.MetadataToken;
198 else // <Module> and interfaces
199 return new MetadataToken (TokenType.TypeRef, 0);
202 public MetadataToken GetMemberRefToken (MemberReference member)
204 if (member is MethodSpecification)
205 return GetMemberRefToken (((MethodSpecification) member).ElementMethod);
206 if (member is IMemberDefinition)
207 return member.MetadataToken;
208 if (m_memberRefTokenCache.Contains (member))
209 return (MetadataToken) m_memberRefTokenCache [member];
211 MemberRefTable mrTable = m_tableWriter.GetMemberRefTable ();
214 if (member is FieldReference)
215 sig = m_sigWriter.AddFieldSig (GetFieldSig ((FieldReference) member));
216 else if (member is MethodReference)
217 sig = m_sigWriter.AddMethodRefSig (GetMethodRefSig ((MethodReference) member));
219 MetadataToken declaringType = GetTypeDefOrRefToken (member.DeclaringType);
220 uint name = m_mdWriter.AddString (member.Name);
222 for (int i = 0; i < mrTable.Rows.Count; i++) {
223 MemberRefRow row = mrTable [i];
224 if (row.Class == declaringType && row.Name == name && row.Signature == sig)
225 return MetadataToken.FromMetadataRow (TokenType.MemberRef, i);
228 MemberRefRow mrRow = m_rowWriter.CreateMemberRefRow (
233 mrTable.Rows.Add (mrRow);
234 member.MetadataToken = new MetadataToken (
235 TokenType.MemberRef, (uint) mrTable.Rows.Count);
236 m_memberRefTokenCache [member] = member.MetadataToken;
237 return member.MetadataToken;
240 public MetadataToken GetMethodSpecToken (GenericInstanceMethod gim)
242 uint sig = m_sigWriter.AddMethodSpec (GetMethodSpecSig (gim));
243 MethodSpecTable msTable = m_tableWriter.GetMethodSpecTable ();
245 MetadataToken meth = GetMemberRefToken (gim.ElementMethod);
247 for (int i = 0; i < msTable.Rows.Count; i++) {
248 MethodSpecRow row = msTable [i];
249 if (row.Method == meth && row.Instantiation == sig)
250 return MetadataToken.FromMetadataRow (TokenType.MethodSpec, i);
253 MethodSpecRow msRow = m_rowWriter.CreateMethodSpecRow (
256 msTable.Rows.Add (msRow);
257 gim.MetadataToken = new MetadataToken (TokenType.MethodSpec, (uint) msTable.Rows.Count);
258 return gim.MetadataToken;
261 public override void VisitModuleDefinition (ModuleDefinition mod)
266 public override void VisitTypeDefinitionCollection (TypeDefinitionCollection types)
268 TypeDefTable tdTable = m_tableWriter.GetTypeDefTable ();
270 if (types [Constants.ModuleType] == null)
271 types.Add (new TypeDefinition (
272 Constants.ModuleType, string.Empty, TypeAttributes.NotPublic));
274 foreach (TypeDefinition t in types)
275 m_typeDefStack.Add (t);
277 m_typeDefStack.Sort (TableComparers.TypeDef.Instance);
279 for (int i = 0; i < m_typeDefStack.Count; i++) {
280 TypeDefinition t = (TypeDefinition) m_typeDefStack [i];
281 if (t.Module.Assembly != m_mod.Assembly)
282 throw new ReflectionException ("A type as not been correctly imported");
284 t.MetadataToken = new MetadataToken (TokenType.TypeDef, (uint) (i + 1));
287 foreach (TypeDefinition t in m_typeDefStack) {
288 TypeDefRow tdRow = m_rowWriter.CreateTypeDefRow (
290 m_mdWriter.AddString (t.Name),
291 m_mdWriter.AddString (t.Namespace),
292 GetTypeDefOrRefToken (t.BaseType),
296 tdTable.Rows.Add (tdRow);
300 public void CompleteTypeDefinitions ()
302 TypeDefTable tdTable = m_tableWriter.GetTypeDefTable ();
304 for (int i = 0; i < m_typeDefStack.Count; i++) {
305 TypeDefRow tdRow = tdTable [i];
306 TypeDefinition t = (TypeDefinition) m_typeDefStack [i];
307 tdRow.FieldList = m_fieldIndex;
308 tdRow.MethodList = m_methodIndex;
310 foreach (FieldDefinition field in t.Fields)
311 VisitFieldDefinition (field);
313 if (t.HasConstructors) {
314 foreach (MethodDefinition ctor in t.Constructors)
315 VisitMethodDefinition (ctor);
318 foreach (MethodDefinition meth in t.Methods)
319 VisitMethodDefinition (meth);
326 foreach (FieldDefinition field in m_fieldStack) {
327 if (field.HasCustomAttributes)
328 VisitCustomAttributeCollection (field.CustomAttributes);
329 if (field.MarshalSpec != null)
330 VisitMarshalSpec (field.MarshalSpec);
333 foreach (MethodDefinition meth in m_methodStack) {
334 if (meth.ReturnType.HasCustomAttributes)
335 VisitCustomAttributeCollection (meth.ReturnType.CustomAttributes);
336 if (meth.HasParameters) {
337 foreach (ParameterDefinition param in meth.Parameters) {
338 if (param.HasCustomAttributes)
339 VisitCustomAttributeCollection (param.CustomAttributes);
342 if (meth.HasGenericParameters)
343 VisitGenericParameterCollection (meth.GenericParameters);
344 if (meth.HasOverrides)
345 VisitOverrideCollection (meth.Overrides);
346 if (meth.HasCustomAttributes)
347 VisitCustomAttributeCollection (meth.CustomAttributes);
348 if (meth.HasSecurityDeclarations)
349 VisitSecurityDeclarationCollection (meth.SecurityDeclarations);
350 if (meth.PInvokeInfo != null) {
351 meth.Attributes |= MethodAttributes.PInvokeImpl;
352 VisitPInvokeInfo (meth.PInvokeInfo);
356 foreach (TypeDefinition t in m_typeDefStack)
360 public override void VisitTypeReferenceCollection (TypeReferenceCollection refs)
362 ArrayList orderedTypeRefs = new ArrayList (refs.Count);
363 foreach (TypeReference tr in refs)
364 orderedTypeRefs.Add (tr);
366 orderedTypeRefs.Sort (TableComparers.TypeRef.Instance);
368 TypeRefTable trTable = m_tableWriter.GetTypeRefTable ();
369 foreach (TypeReference t in orderedTypeRefs) {
372 if (t.Module.Assembly != m_mod.Assembly)
373 throw new ReflectionException ("A type as not been correctly imported");
378 if (t.DeclaringType != null)
379 scope = new MetadataToken (TokenType.TypeRef, GetRidFor (t.DeclaringType));
380 else if (t.Scope is AssemblyNameReference)
381 scope = new MetadataToken (TokenType.AssemblyRef,
382 GetRidFor ((AssemblyNameReference) t.Scope));
383 else if (t.Scope is ModuleDefinition)
384 scope = new MetadataToken (TokenType.Module,
385 GetRidFor ((ModuleDefinition) t.Scope));
386 else if (t.Scope is ModuleReference)
387 scope = new MetadataToken (TokenType.ModuleRef,
388 GetRidFor ((ModuleReference) t.Scope));
390 scope = new MetadataToken (TokenType.ExportedType, 0);
392 TypeRefRow trRow = m_rowWriter.CreateTypeRefRow (
394 m_mdWriter.AddString (t.Name),
395 m_mdWriter.AddString (t.Namespace));
397 trTable.Rows.Add (trRow);
398 t.MetadataToken = new MetadataToken (TokenType.TypeRef, (uint) trTable.Rows.Count);
402 public override void VisitGenericParameterCollection (GenericParameterCollection parameters)
404 if (parameters.Count == 0)
407 foreach (GenericParameter gp in parameters)
408 m_genericParamStack.Add (gp);
411 public override void VisitInterfaceCollection (InterfaceCollection interfaces)
413 if (interfaces.Count == 0)
416 InterfaceImplTable iiTable = m_tableWriter.GetInterfaceImplTable ();
417 foreach (TypeReference interf in interfaces) {
418 InterfaceImplRow iiRow = m_rowWriter.CreateInterfaceImplRow (
419 GetRidFor (interfaces.Container),
420 GetTypeDefOrRefToken (interf));
422 iiTable.Rows.Add (iiRow);
426 public override void VisitExternTypeCollection (ExternTypeCollection externs)
428 VisitCollection (externs);
431 public override void VisitExternType (TypeReference externType)
436 public override void VisitOverrideCollection (OverrideCollection meths)
438 if (meths.Count == 0)
441 MethodImplTable miTable = m_tableWriter.GetMethodImplTable ();
442 foreach (MethodReference ov in meths) {
443 MethodImplRow miRow = m_rowWriter.CreateMethodImplRow (
444 GetRidFor (meths.Container.DeclaringType as TypeDefinition),
445 new MetadataToken (TokenType.Method, GetRidFor (meths.Container)),
446 GetMemberRefToken (ov));
448 miTable.Rows.Add (miRow);
452 public override void VisitNestedTypeCollection (NestedTypeCollection nestedTypes)
454 if (nestedTypes.Count == 0)
457 NestedClassTable ncTable = m_tableWriter.GetNestedClassTable ();
458 foreach (TypeDefinition nested in nestedTypes) {
459 NestedClassRow ncRow = m_rowWriter.CreateNestedClassRow (
460 nested.MetadataToken.RID,
461 GetRidFor (nestedTypes.Container));
463 ncTable.Rows.Add (ncRow);
467 public override void VisitParameterDefinitionCollection (ParameterDefinitionCollection parameters)
469 if (parameters.Count == 0)
473 ParamTable pTable = m_tableWriter.GetParamTable ();
474 foreach (ParameterDefinition param in parameters)
475 InsertParameter (pTable, param, seq++);
478 void InsertParameter (ParamTable pTable, ParameterDefinition param, ushort seq)
480 ParamRow pRow = m_rowWriter.CreateParamRow (
483 m_mdWriter.AddString (param.Name));
485 pTable.Rows.Add (pRow);
486 param.MetadataToken = new MetadataToken (TokenType.Param, (uint) pTable.Rows.Count);
488 if (param.MarshalSpec != null)
489 param.MarshalSpec.Accept (this);
491 if (param.HasConstant)
492 WriteConstant (param, param.ParameterType);
497 static bool RequiresParameterRow (MethodReturnType mrt)
499 return mrt.HasConstant || mrt.MarshalSpec != null ||
500 mrt.CustomAttributes.Count > 0 || mrt.Parameter.Attributes != (ParameterAttributes) 0;
503 public override void VisitMethodDefinition (MethodDefinition method)
505 MethodTable mTable = m_tableWriter.GetMethodTable ();
506 MethodRow mRow = m_rowWriter.CreateMethodRow (
508 method.ImplAttributes,
510 m_mdWriter.AddString (method.Name),
511 m_sigWriter.AddMethodDefSig (GetMethodDefSig (method)),
514 mTable.Rows.Add (mRow);
515 m_methodStack.Add (method);
516 method.MetadataToken = new MetadataToken (TokenType.Method, (uint) mTable.Rows.Count);
519 if (RequiresParameterRow (method.ReturnType))
520 InsertParameter (m_tableWriter.GetParamTable (), method.ReturnType.Parameter, 0);
522 VisitParameterDefinitionCollection (method.Parameters);
525 public override void VisitPInvokeInfo (PInvokeInfo pinvk)
527 ImplMapTable imTable = m_tableWriter.GetImplMapTable ();
528 ImplMapRow imRow = m_rowWriter.CreateImplMapRow (
530 new MetadataToken (TokenType.Method, GetRidFor (pinvk.Method)),
531 m_mdWriter.AddString (pinvk.EntryPoint),
532 GetRidFor (pinvk.Module));
534 imTable.Rows.Add (imRow);
537 public override void VisitEventDefinitionCollection (EventDefinitionCollection events)
539 if (events.Count == 0)
542 EventMapTable emTable = m_tableWriter.GetEventMapTable ();
543 EventMapRow emRow = m_rowWriter.CreateEventMapRow (
544 GetRidFor (events.Container),
547 emTable.Rows.Add (emRow);
548 VisitCollection (events);
551 public override void VisitEventDefinition (EventDefinition evt)
553 EventTable eTable = m_tableWriter.GetEventTable ();
554 EventRow eRow = m_rowWriter.CreateEventRow (
556 m_mdWriter.AddString (evt.Name),
557 GetTypeDefOrRefToken (evt.EventType));
559 eTable.Rows.Add (eRow);
560 evt.MetadataToken = new MetadataToken (TokenType.Event, (uint) eTable.Rows.Count);
562 if (evt.AddMethod != null)
563 WriteSemantic (MethodSemanticsAttributes.AddOn, evt, evt.AddMethod);
565 if (evt.InvokeMethod != null)
566 WriteSemantic (MethodSemanticsAttributes.Fire, evt, evt.InvokeMethod);
568 if (evt.RemoveMethod != null)
569 WriteSemantic (MethodSemanticsAttributes.RemoveOn, evt, evt.RemoveMethod);
574 public override void VisitFieldDefinition (FieldDefinition field)
576 FieldTable fTable = m_tableWriter.GetFieldTable ();
577 FieldRow fRow = m_rowWriter.CreateFieldRow (
579 m_mdWriter.AddString (field.Name),
580 m_sigWriter.AddFieldSig (GetFieldSig (field)));
582 fTable.Rows.Add (fRow);
583 field.MetadataToken = new MetadataToken (TokenType.Field, (uint) fTable.Rows.Count);
586 if (field.HasConstant)
587 WriteConstant (field, field.FieldType);
589 if (field.HasLayoutInfo)
592 m_fieldStack.Add (field);
595 public override void VisitPropertyDefinitionCollection (PropertyDefinitionCollection properties)
597 if (properties.Count == 0)
600 PropertyMapTable pmTable = m_tableWriter.GetPropertyMapTable ();
601 PropertyMapRow pmRow = m_rowWriter.CreatePropertyMapRow (
602 GetRidFor (properties.Container),
605 pmTable.Rows.Add (pmRow);
606 VisitCollection (properties);
609 public override void VisitPropertyDefinition (PropertyDefinition property)
611 PropertyTable pTable = m_tableWriter.GetPropertyTable ();
612 PropertyRow pRow = m_rowWriter.CreatePropertyRow (
614 m_mdWriter.AddString (property.Name),
615 m_sigWriter.AddPropertySig (GetPropertySig (property)));
617 pTable.Rows.Add (pRow);
618 property.MetadataToken = new MetadataToken (TokenType.Property, (uint) pTable.Rows.Count);
620 if (property.GetMethod != null)
621 WriteSemantic (MethodSemanticsAttributes.Getter, property, property.GetMethod);
623 if (property.SetMethod != null)
624 WriteSemantic (MethodSemanticsAttributes.Setter, property, property.SetMethod);
626 if (property.HasConstant)
627 WriteConstant (property, property.PropertyType);
632 public override void VisitSecurityDeclarationCollection (SecurityDeclarationCollection secDecls)
634 if (secDecls.Count == 0)
637 DeclSecurityTable dsTable = m_tableWriter.GetDeclSecurityTable ();
638 foreach (SecurityDeclaration secDec in secDecls) {
639 DeclSecurityRow dsRow = m_rowWriter.CreateDeclSecurityRow (
641 secDecls.Container.MetadataToken,
642 m_mdWriter.AddBlob (secDec.Resolved ?
643 m_mod.GetAsByteArray (secDec) : secDec.Blob));
645 dsTable.Rows.Add (dsRow);
649 public override void VisitCustomAttributeCollection (CustomAttributeCollection customAttrs)
651 if (customAttrs.Count == 0)
654 CustomAttributeTable caTable = m_tableWriter.GetCustomAttributeTable ();
655 foreach (CustomAttribute ca in customAttrs) {
656 MetadataToken parent;
657 if (customAttrs.Container is AssemblyDefinition)
658 parent = new MetadataToken (TokenType.Assembly, 1);
659 else if (customAttrs.Container is ModuleDefinition)
660 parent = new MetadataToken (TokenType.Module, 1);
661 else if (customAttrs.Container is IMetadataTokenProvider)
662 parent = ((IMetadataTokenProvider) customAttrs.Container).MetadataToken;
664 throw new ReflectionException ("Unknown Custom Attribute parent");
666 uint value = ca.Resolved ?
667 m_sigWriter.AddCustomAttribute (GetCustomAttributeSig (ca), ca.Constructor) :
668 m_mdWriter.AddBlob (m_mod.GetAsByteArray (ca));
669 CustomAttributeRow caRow = m_rowWriter.CreateCustomAttributeRow (
671 GetMemberRefToken (ca.Constructor),
674 caTable.Rows.Add (caRow);
678 public override void VisitMarshalSpec (MarshalSpec marshalSpec)
680 FieldMarshalTable fmTable = m_tableWriter.GetFieldMarshalTable ();
681 FieldMarshalRow fmRow = m_rowWriter.CreateFieldMarshalRow (
682 marshalSpec.Container.MetadataToken,
683 m_sigWriter.AddMarshalSig (GetMarshalSig (marshalSpec)));
685 fmTable.Rows.Add (fmRow);
688 void WriteConstant (IHasConstant hc, TypeReference type)
690 ConstantTable cTable = m_tableWriter.GetConstantTable ();
692 if (type is TypeDefinition && (type as TypeDefinition).IsEnum) {
693 Type t = hc.Constant.GetType ();
695 t = Enum.GetUnderlyingType (t);
697 et = GetCorrespondingType (string.Concat (t.Namespace, '.', t.Name));
699 et = GetCorrespondingType (type.FullName);
701 if (et == ElementType.Object || et == ElementType.Type || et == ElementType.String)
702 et = hc.Constant == null ?
704 GetCorrespondingType (hc.Constant.GetType ().FullName);
706 ConstantRow cRow = m_rowWriter.CreateConstantRow (
709 m_mdWriter.AddBlob (EncodeConstant (et, hc.Constant)));
711 cTable.Rows.Add (cRow);
714 void WriteLayout (FieldDefinition field)
716 FieldLayoutTable flTable = m_tableWriter.GetFieldLayoutTable ();
717 FieldLayoutRow flRow = m_rowWriter.CreateFieldLayoutRow (
721 flTable.Rows.Add (flRow);
724 void WriteLayout (TypeDefinition type)
726 ClassLayoutTable clTable = m_tableWriter.GetClassLayoutTable ();
727 ClassLayoutRow clRow = m_rowWriter.CreateClassLayoutRow (
732 clTable.Rows.Add (clRow);
735 void WriteSemantic (MethodSemanticsAttributes attrs,
736 IMetadataTokenProvider member, MethodDefinition meth)
738 MethodSemanticsTable msTable = m_tableWriter.GetMethodSemanticsTable ();
739 MethodSemanticsRow msRow = m_rowWriter.CreateMethodSemanticsRow (
742 member.MetadataToken);
744 msTable.Rows.Add (msRow);
749 TablesHeap th = m_mdWriter.GetMetadataRoot ().Streams.TablesHeap;
752 if (th.HasTable (NestedClassTable.RId))
753 m_tableWriter.GetNestedClassTable ().Rows.Sort (
754 TableComparers.NestedClass.Instance);
755 th.Sorted |= ((long) 1 << NestedClassTable.RId);
757 if (th.HasTable (InterfaceImplTable.RId))
758 m_tableWriter.GetInterfaceImplTable ().Rows.Sort (
759 TableComparers.InterfaceImpl.Instance);
760 th.Sorted |= ((long) 1 << InterfaceImplTable.RId);
762 if (th.HasTable (ConstantTable.RId))
763 m_tableWriter.GetConstantTable ().Rows.Sort (
764 TableComparers.Constant.Instance);
765 th.Sorted |= ((long) 1 << ConstantTable.RId);
767 if (th.HasTable (MethodSemanticsTable.RId))
768 m_tableWriter.GetMethodSemanticsTable ().Rows.Sort (
769 TableComparers.MethodSem.Instance);
770 th.Sorted |= ((long) 1 << MethodSemanticsTable.RId);
772 if (th.HasTable (FieldMarshalTable.RId))
773 m_tableWriter.GetFieldMarshalTable ().Rows.Sort (
774 TableComparers.FieldMarshal.Instance);
775 th.Sorted |= ((long) 1 << FieldMarshalTable.RId);
777 if (th.HasTable (ClassLayoutTable.RId))
778 m_tableWriter.GetClassLayoutTable ().Rows.Sort (
779 TableComparers.TypeLayout.Instance);
780 th.Sorted |= ((long) 1 << ClassLayoutTable.RId);
782 if (th.HasTable (FieldLayoutTable.RId))
783 m_tableWriter.GetFieldLayoutTable ().Rows.Sort (
784 TableComparers.FieldLayout.Instance);
785 th.Sorted |= ((long) 1 << FieldLayoutTable.RId);
787 if (th.HasTable (ImplMapTable.RId))
788 m_tableWriter.GetImplMapTable ().Rows.Sort (
789 TableComparers.PInvoke.Instance);
790 th.Sorted |= ((long) 1 << ImplMapTable.RId);
792 if (th.HasTable (FieldRVATable.RId))
793 m_tableWriter.GetFieldRVATable ().Rows.Sort (
794 TableComparers.FieldRVA.Instance);
795 th.Sorted |= ((long) 1 << FieldRVATable.RId);
797 if (th.HasTable (MethodImplTable.RId))
798 m_tableWriter.GetMethodImplTable ().Rows.Sort (
799 TableComparers.Override.Instance);
800 th.Sorted |= ((long) 1 << MethodImplTable.RId);
802 if (th.HasTable (CustomAttributeTable.RId))
803 m_tableWriter.GetCustomAttributeTable ().Rows.Sort (
804 TableComparers.CustomAttribute.Instance);
805 th.Sorted |= ((long) 1 << CustomAttributeTable.RId);
807 if (th.HasTable (DeclSecurityTable.RId))
808 m_tableWriter.GetDeclSecurityTable ().Rows.Sort (
809 TableComparers.SecurityDeclaration.Instance);
810 th.Sorted |= ((long) 1 << DeclSecurityTable.RId);
813 void CompleteGenericTables ()
815 if (m_genericParamStack.Count == 0)
818 TablesHeap th = m_mdWriter.GetMetadataRoot ().Streams.TablesHeap;
819 GenericParamTable gpTable = m_tableWriter.GetGenericParamTable ();
821 m_genericParamStack.Sort (TableComparers.GenericParam.Instance);
823 foreach (GenericParameter gp in m_genericParamStack) {
824 GenericParamRow gpRow = m_rowWriter.CreateGenericParamRow (
825 (ushort) gp.Owner.GenericParameters.IndexOf (gp),
827 gp.Owner.MetadataToken,
828 m_mdWriter.AddString (gp.Name));
830 gpTable.Rows.Add (gpRow);
831 gp.MetadataToken = new MetadataToken (TokenType.GenericParam, (uint) gpTable.Rows.Count);
833 if (gp.HasCustomAttributes)
834 VisitCustomAttributeCollection (gp.CustomAttributes);
836 if (!gp.HasConstraints)
839 GenericParamConstraintTable gpcTable = m_tableWriter.GetGenericParamConstraintTable ();
841 foreach (TypeReference constraint in gp.Constraints) {
842 GenericParamConstraintRow gpcRow = m_rowWriter.CreateGenericParamConstraintRow (
843 (uint) gpTable.Rows.Count,
844 GetTypeDefOrRefToken (constraint));
846 gpcTable.Rows.Add (gpcRow);
850 th.Sorted |= ((long) 1 << GenericParamTable.RId);
851 th.Sorted |= ((long) 1 << GenericParamConstraintTable.RId);
854 public override void TerminateModuleDefinition (ModuleDefinition module)
856 if (module.Assembly.HasCustomAttributes)
857 VisitCustomAttributeCollection (module.Assembly.CustomAttributes);
858 if (module.Assembly.HasSecurityDeclarations)
859 VisitSecurityDeclarationCollection (module.Assembly.SecurityDeclarations);
860 if (module.HasCustomAttributes)
861 VisitCustomAttributeCollection (module.CustomAttributes);
863 CompleteGenericTables ();
866 MethodTable mTable = m_tableWriter.GetMethodTable ();
867 for (int i = 0; i < m_methodStack.Count; i++) {
868 MethodDefinition meth = (MethodDefinition) m_methodStack [i];
870 mTable [i].RVA = m_codeWriter.WriteMethodBody (meth);
873 if (m_fieldStack.Count > 0) {
874 FieldRVATable frTable = null;
875 foreach (FieldDefinition field in m_fieldStack) {
876 if (field.InitialValue != null && field.InitialValue.Length > 0) {
878 frTable = m_tableWriter.GetFieldRVATable ();
880 FieldRVARow frRow = m_rowWriter.CreateFieldRVARow (
881 m_mdWriter.GetDataCursor (),
882 field.MetadataToken.RID);
884 m_mdWriter.AddData (field.InitialValue.Length + 3 & (~3));
885 m_mdWriter.AddFieldInitData (field.InitialValue);
887 frTable.Rows.Add (frRow);
892 if (m_symbolWriter != null)
893 m_symbolWriter.Dispose ();
895 if (m_mod.Assembly.EntryPoint != null)
896 m_mdWriter.EntryPointToken =
897 ((uint) TokenType.Method) | GetRidFor (m_mod.Assembly.EntryPoint);
899 m_mod.Image.MetadataRoot.Accept (m_mdWriter);
902 public static ElementType GetCorrespondingType (string fullName)
905 case Constants.Boolean :
906 return ElementType.Boolean;
907 case Constants.Char :
908 return ElementType.Char;
909 case Constants.SByte :
910 return ElementType.I1;
911 case Constants.Int16 :
912 return ElementType.I2;
913 case Constants.Int32 :
914 return ElementType.I4;
915 case Constants.Int64 :
916 return ElementType.I8;
917 case Constants.Byte :
918 return ElementType.U1;
919 case Constants.UInt16 :
920 return ElementType.U2;
921 case Constants.UInt32 :
922 return ElementType.U4;
923 case Constants.UInt64 :
924 return ElementType.U8;
925 case Constants.Single :
926 return ElementType.R4;
927 case Constants.Double :
928 return ElementType.R8;
929 case Constants.String :
930 return ElementType.String;
931 case Constants.Type :
932 return ElementType.Type;
933 case Constants.Object :
934 return ElementType.Object;
936 return ElementType.Class;
940 byte [] EncodeConstant (ElementType et, object value)
942 m_constWriter.Empty ();
945 et = ElementType.Class;
947 IConvertible ic = value as IConvertible;
948 IFormatProvider fp = CultureInfo.CurrentCulture.NumberFormat;
951 case ElementType.Boolean :
952 m_constWriter.Write ((byte) (ic.ToBoolean (fp) ? 1 : 0));
954 case ElementType.Char :
955 m_constWriter.Write ((ushort) ic.ToChar (fp));
957 case ElementType.I1 :
958 m_constWriter.Write (ic.ToSByte (fp));
960 case ElementType.I2 :
961 m_constWriter.Write (ic.ToInt16 (fp));
963 case ElementType.I4 :
964 m_constWriter.Write (ic.ToInt32 (fp));
966 case ElementType.I8 :
967 m_constWriter.Write (ic.ToInt64 (fp));
969 case ElementType.U1 :
970 m_constWriter.Write (ic.ToByte (fp));
972 case ElementType.U2 :
973 m_constWriter.Write (ic.ToUInt16 (fp));
975 case ElementType.U4 :
976 m_constWriter.Write (ic.ToUInt32 (fp));
978 case ElementType.U8 :
979 m_constWriter.Write (ic.ToUInt64 (fp));
981 case ElementType.R4 :
982 m_constWriter.Write (ic.ToSingle (fp));
984 case ElementType.R8 :
985 m_constWriter.Write (ic.ToDouble (fp));
987 case ElementType.String :
988 m_constWriter.Write (Encoding.Unicode.GetBytes ((string) value));
990 case ElementType.Class :
991 m_constWriter.Write (new byte [4]);
994 throw new ArgumentException ("Non valid element for a constant");
997 return m_constWriter.ToArray ();
1000 public SigType GetSigType (TypeReference type)
1002 string name = type.FullName;
1005 case Constants.Void :
1006 return new SigType (ElementType.Void);
1007 case Constants.Object :
1008 return new SigType (ElementType.Object);
1009 case Constants.Boolean :
1010 return new SigType (ElementType.Boolean);
1011 case Constants.String :
1012 return new SigType (ElementType.String);
1013 case Constants.Char :
1014 return new SigType (ElementType.Char);
1015 case Constants.SByte :
1016 return new SigType (ElementType.I1);
1017 case Constants.Byte :
1018 return new SigType (ElementType.U1);
1019 case Constants.Int16 :
1020 return new SigType (ElementType.I2);
1021 case Constants.UInt16 :
1022 return new SigType (ElementType.U2);
1023 case Constants.Int32 :
1024 return new SigType (ElementType.I4);
1025 case Constants.UInt32 :
1026 return new SigType (ElementType.U4);
1027 case Constants.Int64 :
1028 return new SigType (ElementType.I8);
1029 case Constants.UInt64 :
1030 return new SigType (ElementType.U8);
1031 case Constants.Single :
1032 return new SigType (ElementType.R4);
1033 case Constants.Double :
1034 return new SigType (ElementType.R8);
1035 case Constants.IntPtr :
1036 return new SigType (ElementType.I);
1037 case Constants.UIntPtr :
1038 return new SigType (ElementType.U);
1039 case Constants.TypedReference :
1040 return new SigType (ElementType.TypedByRef);
1043 if (type is GenericParameter) {
1044 GenericParameter gp = type as GenericParameter;
1045 int pos = gp.Owner.GenericParameters.IndexOf (gp);
1046 if (gp.Owner is TypeReference)
1047 return new VAR (pos);
1048 else if (gp.Owner is MethodReference)
1049 return new MVAR (pos);
1051 throw new ReflectionException ("Unkown generic parameter type");
1052 } else if (type is GenericInstanceType) {
1053 GenericInstanceType git = type as GenericInstanceType;
1054 GENERICINST gi = new GENERICINST ();
1055 gi.ValueType = git.IsValueType;
1056 gi.Type = GetTypeDefOrRefToken (git.ElementType);
1057 gi.Signature = new GenericInstSignature ();
1058 gi.Signature.Arity = git.GenericArguments.Count;
1059 gi.Signature.Types = new GenericArg [gi.Signature.Arity];
1060 for (int i = 0; i < git.GenericArguments.Count; i++)
1061 gi.Signature.Types [i] = GetGenericArgSig (git.GenericArguments [i]);
1064 } else if (type is ArrayType) {
1065 ArrayType aryType = type as ArrayType;
1066 if (aryType.IsSizedArray) {
1067 SZARRAY szary = new SZARRAY ();
1068 szary.CustomMods = GetCustomMods (aryType.ElementType);
1069 szary.Type = GetSigType (aryType.ElementType);
1074 ArrayShape shape = new ArrayShape ();
1075 shape.Rank = aryType.Dimensions.Count;
1078 for (int i = 0; i < shape.Rank; i++) {
1079 ArrayDimension dim = aryType.Dimensions [i];
1080 if (dim.UpperBound > 0)
1084 shape.Sizes = new int [shape.NumSizes];
1085 shape.NumLoBounds = shape.Rank;
1086 shape.LoBounds = new int [shape.NumLoBounds];
1088 for (int i = 0; i < shape.Rank; i++) {
1089 ArrayDimension dim = aryType.Dimensions [i];
1090 shape.LoBounds [i] = dim.LowerBound;
1091 if (dim.UpperBound > 0)
1092 shape.Sizes [i] = dim.UpperBound - dim.LowerBound + 1;
1095 ARRAY ary = new ARRAY ();
1097 ary.CustomMods = GetCustomMods (aryType.ElementType);
1098 ary.Type = GetSigType (aryType.ElementType);
1100 } else if (type is PointerType) {
1102 TypeReference elementType = (type as PointerType).ElementType;
1103 p.Void = elementType.FullName == Constants.Void;
1105 p.CustomMods = GetCustomMods (elementType);
1106 p.PtrType = GetSigType (elementType);
1109 } else if (type is FunctionPointerType) {
1110 FNPTR fp = new FNPTR ();
1111 FunctionPointerType fptr = type as FunctionPointerType;
1113 int sentinel = fptr.GetSentinel ();
1115 fp.Method = GetMethodDefSig (fptr);
1117 fp.Method = GetMethodRefSig (fptr);
1120 } else if (type is TypeSpecification) {
1121 return GetSigType ((type as TypeSpecification).ElementType);
1122 } else if (type.IsValueType) {
1123 VALUETYPE vt = new VALUETYPE ();
1124 vt.Type = GetTypeDefOrRefToken (type);
1127 CLASS c = new CLASS ();
1128 c.Type = GetTypeDefOrRefToken (type);
1133 public GenericArg GetGenericArgSig (TypeReference type)
1135 GenericArg arg = new GenericArg (GetSigType (type));
1136 arg.CustomMods = GetCustomMods (type);
1140 public CustomMod [] GetCustomMods (TypeReference type)
1142 ModType modifier = type as ModType;
1143 if (modifier == null)
1144 return CustomMod.EmptyCustomMod;
1146 ArrayList cmods = new ArrayList ();
1148 CustomMod cmod = new CustomMod ();
1149 cmod.TypeDefOrRef = GetTypeDefOrRefToken (modifier.ModifierType);
1151 if (modifier is ModifierOptional)
1152 cmod.CMOD = CustomMod.CMODType.OPT;
1153 else if (modifier is ModifierRequired)
1154 cmod.CMOD = CustomMod.CMODType.REQD;
1157 modifier = modifier.ElementType as ModType;
1158 } while (modifier != null);
1160 return cmods.ToArray (typeof (CustomMod)) as CustomMod [];
1163 public Signature GetMemberRefSig (MemberReference member)
1165 if (member is FieldReference)
1166 return GetFieldSig (member as FieldReference);
1168 return GetMemberRefSig (member as MethodReference);
1171 public FieldSig GetFieldSig (FieldReference field)
1173 FieldSig sig = new FieldSig ();
1174 sig.CallingConvention |= 0x6;
1176 sig.CustomMods = GetCustomMods (field.FieldType);
1177 sig.Type = GetSigType (field.FieldType);
1181 Param [] GetParametersSig (ParameterDefinitionCollection parameters)
1183 Param [] ret = new Param [parameters.Count];
1184 for (int i = 0; i < ret.Length; i++) {
1185 ParameterDefinition pDef = parameters [i];
1186 Param p = new Param ();
1187 p.CustomMods = GetCustomMods (pDef.ParameterType);
1188 if (pDef.ParameterType.FullName == Constants.TypedReference)
1189 p.TypedByRef = true;
1190 else if (IsByReferenceType (pDef.ParameterType)) {
1192 p.Type = GetSigType (pDef.ParameterType);
1194 p.Type = GetSigType (pDef.ParameterType);
1200 void CompleteMethodSig (IMethodSignature meth, MethodSig sig)
1202 sig.HasThis = meth.HasThis;
1203 sig.ExplicitThis = meth.ExplicitThis;
1205 sig.CallingConvention |= 0x20;
1206 if (sig.ExplicitThis)
1207 sig.CallingConvention |= 0x40;
1209 if ((meth.CallingConvention & MethodCallingConvention.VarArg) != 0)
1210 sig.CallingConvention |= 0x5;
1212 sig.ParamCount = meth.Parameters.Count;
1213 sig.Parameters = GetParametersSig (meth.Parameters);
1215 RetType rtSig = new RetType ();
1216 rtSig.CustomMods = GetCustomMods (meth.ReturnType.ReturnType);
1218 if (meth.ReturnType.ReturnType.FullName == Constants.Void)
1220 else if (meth.ReturnType.ReturnType.FullName == Constants.TypedReference)
1221 rtSig.TypedByRef = true;
1222 else if (IsByReferenceType (meth.ReturnType.ReturnType)) {
1224 rtSig.Type = GetSigType (meth.ReturnType.ReturnType);
1226 rtSig.Type = GetSigType (meth.ReturnType.ReturnType);
1228 sig.RetType = rtSig;
1231 static bool IsByReferenceType (TypeReference type)
1233 TypeSpecification ts = type as TypeSpecification;
1234 while (ts != null) {
1235 if (ts is ReferenceType)
1237 ts = ts.ElementType as TypeSpecification;
1242 public MethodRefSig GetMethodRefSig (IMethodSignature meth)
1244 MethodReference methodRef = meth as MethodReference;
1245 if (methodRef != null && methodRef.GenericParameters.Count > 0)
1246 return GetMethodDefSig (meth);
1248 MethodRefSig methSig = new MethodRefSig ();
1250 CompleteMethodSig (meth, methSig);
1252 int sentinel = meth.GetSentinel ();
1254 methSig.Sentinel = sentinel;
1256 if ((meth.CallingConvention & MethodCallingConvention.C) != 0)
1257 methSig.CallingConvention |= 0x1;
1258 else if ((meth.CallingConvention & MethodCallingConvention.StdCall) != 0)
1259 methSig.CallingConvention |= 0x2;
1260 else if ((meth.CallingConvention & MethodCallingConvention.ThisCall) != 0)
1261 methSig.CallingConvention |= 0x3;
1262 else if ((meth.CallingConvention & MethodCallingConvention.FastCall) != 0)
1263 methSig.CallingConvention |= 0x4;
1268 public MethodDefSig GetMethodDefSig (IMethodSignature meth)
1270 MethodDefSig sig = new MethodDefSig ();
1272 CompleteMethodSig (meth, sig);
1274 MethodReference methodRef = meth as MethodReference;
1275 if (methodRef != null && methodRef.GenericParameters.Count > 0) {
1276 sig.CallingConvention |= 0x10;
1277 sig.GenericParameterCount = methodRef.GenericParameters.Count;
1283 public PropertySig GetPropertySig (PropertyDefinition prop)
1285 PropertySig ps = new PropertySig ();
1286 ps.CallingConvention |= 0x8;
1290 MethodCallingConvention mcc;
1291 ParameterDefinitionCollection parameters = prop.Parameters;
1293 MethodDefinition meth;
1294 if (prop.GetMethod != null)
1295 meth = prop.GetMethod;
1296 else if (prop.SetMethod != null)
1297 meth = prop.SetMethod;
1302 hasThis = meth.HasThis;
1303 explicitThis = meth.ExplicitThis;
1304 mcc = meth.CallingConvention;
1306 hasThis = explicitThis = false;
1307 mcc = MethodCallingConvention.Default;
1311 ps.CallingConvention |= 0x20;
1313 ps.CallingConvention |= 0x40;
1315 if ((mcc & MethodCallingConvention.VarArg) != 0)
1316 ps.CallingConvention |= 0x5;
1318 int paramCount = parameters != null ? parameters.Count : 0;
1320 ps.ParamCount = paramCount;
1321 ps.Parameters = GetParametersSig (parameters);
1322 ps.CustomMods = GetCustomMods (prop.PropertyType);
1323 ps.Type = GetSigType (prop.PropertyType);
1328 public TypeSpec GetTypeSpecSig (TypeReference type)
1330 TypeSpec ts = new TypeSpec ();
1331 ts.CustomMods = GetCustomMods (type);
1332 ts.Type = GetSigType (type);
1336 public MethodSpec GetMethodSpecSig (GenericInstanceMethod gim)
1338 GenericInstSignature gis = new GenericInstSignature ();
1339 gis.Arity = gim.GenericArguments.Count;
1340 gis.Types = new GenericArg [gis.Arity];
1341 for (int i = 0; i < gis.Arity; i++)
1342 gis.Types [i] = GetGenericArgSig (gim.GenericArguments [i]);
1344 return new MethodSpec (gis);
1347 static string GetObjectTypeName (object o)
1349 Type t = o.GetType ();
1350 return string.Concat (t.Namespace, ".", t.Name);
1353 static CustomAttrib.Elem CreateElem (TypeReference type, object value)
1355 CustomAttrib.Elem elem = new CustomAttrib.Elem ();
1357 elem.ElemType = type;
1358 elem.FieldOrPropType = GetCorrespondingType (type.FullName);
1360 switch (elem.FieldOrPropType) {
1361 case ElementType.Boolean :
1362 case ElementType.Char :
1363 case ElementType.R4 :
1364 case ElementType.R8 :
1365 case ElementType.I1 :
1366 case ElementType.I2 :
1367 case ElementType.I4 :
1368 case ElementType.I8 :
1369 case ElementType.U1 :
1370 case ElementType.U2 :
1371 case ElementType.U4 :
1372 case ElementType.U8 :
1375 case ElementType.String:
1378 case ElementType.Type:
1381 case ElementType.Object:
1382 elem.BoxedValueType = true;
1384 elem.FieldOrPropType = ElementType.String;
1386 elem.FieldOrPropType = GetCorrespondingType (
1387 GetObjectTypeName (value));
1394 static CustomAttrib.FixedArg CreateFixedArg (TypeReference type, object value)
1396 CustomAttrib.FixedArg fa = new CustomAttrib.FixedArg ();
1397 if (value is object []) {
1399 object [] values = value as object [];
1400 TypeReference obj = ((ArrayType) type).ElementType;
1401 fa.NumElem = (uint) values.Length;
1402 fa.Elems = new CustomAttrib.Elem [values.Length];
1403 for (int i = 0; i < values.Length; i++)
1404 fa.Elems [i] = CreateElem (obj, values [i]);
1406 fa.Elems = new CustomAttrib.Elem [1];
1407 fa.Elems [0] = CreateElem (type, value);
1413 static CustomAttrib.NamedArg CreateNamedArg (TypeReference type, string name,
1414 object value, bool field)
1416 CustomAttrib.NamedArg na = new CustomAttrib.NamedArg ();
1418 na.Property = !field;
1420 na.FieldOrPropName = name;
1421 na.FieldOrPropType = GetCorrespondingType (type.FullName);
1422 na.FixedArg = CreateFixedArg (type, value);
1427 public static CustomAttrib GetCustomAttributeSig (CustomAttribute ca)
1429 CustomAttrib cas = new CustomAttrib (ca.Constructor);
1430 cas.Prolog = CustomAttrib.StdProlog;
1432 cas.FixedArgs = new CustomAttrib.FixedArg [ca.Constructor.Parameters.Count];
1434 for (int i = 0; i < cas.FixedArgs.Length; i++)
1435 cas.FixedArgs [i] = CreateFixedArg (
1436 ca.Constructor.Parameters [i].ParameterType, ca.ConstructorParameters [i]);
1438 int nn = ca.Fields.Count + ca.Properties.Count;
1439 cas.NumNamed = (ushort) nn;
1440 cas.NamedArgs = new CustomAttrib.NamedArg [nn];
1442 if (cas.NamedArgs.Length > 0) {
1444 foreach (DictionaryEntry entry in ca.Fields) {
1445 string field = (string) entry.Key;
1446 cas.NamedArgs [curs++] = CreateNamedArg (
1447 ca.GetFieldType (field), field, entry.Value, true);
1450 foreach (DictionaryEntry entry in ca.Properties) {
1451 string property = (string) entry.Key;
1452 cas.NamedArgs [curs++] = CreateNamedArg (
1453 ca.GetPropertyType (property), property, entry.Value, false);
1460 static MarshalSig GetMarshalSig (MarshalSpec mSpec)
1462 MarshalSig ms = new MarshalSig (mSpec.NativeIntrinsic);
1464 if (mSpec is ArrayMarshalSpec) {
1465 ArrayMarshalSpec amd = mSpec as ArrayMarshalSpec;
1466 MarshalSig.Array ar = new MarshalSig.Array ();
1467 ar.ArrayElemType = amd.ElemType;
1468 ar.NumElem = amd.NumElem;
1469 ar.ParamNum = amd.ParamNum;
1470 ar.ElemMult = amd.ElemMult;
1472 } else if (mSpec is CustomMarshalerSpec) {
1473 CustomMarshalerSpec cmd = mSpec as CustomMarshalerSpec;
1474 MarshalSig.CustomMarshaler cm = new MarshalSig.CustomMarshaler ();
1475 cm.Guid = cmd.Guid.ToString ();
1476 cm.UnmanagedType = cmd.UnmanagedType;
1477 cm.ManagedType = cmd.ManagedType;
1478 cm.Cookie = cmd.Cookie;
1480 } else if (mSpec is FixedArraySpec) {
1481 FixedArraySpec fad = mSpec as FixedArraySpec;
1482 MarshalSig.FixedArray fa = new MarshalSig.FixedArray ();
1483 fa.ArrayElemType = fad.ElemType;
1484 fa.NumElem = fad.NumElem;
1486 } else if (mSpec is FixedSysStringSpec) {
1487 MarshalSig.FixedSysString fss = new MarshalSig.FixedSysString ();
1488 fss.Size = (mSpec as FixedSysStringSpec).Size;
1490 } else if (mSpec is SafeArraySpec) {
1491 MarshalSig.SafeArray sa = new MarshalSig.SafeArray ();
1492 sa.ArrayElemType = (mSpec as SafeArraySpec).ElemType;
1499 public void WriteSymbols (ModuleDefinition module)
1504 if (m_asmOutput == null)
1505 m_asmOutput = module.Assembly.Name.Name + "." + (module.Assembly.Kind == AssemblyKind.Dll ? "dll" : "exe");
1507 if (m_symbolWriter == null)
1508 m_symbolWriter = SymbolStoreHelper.GetWriter (module, m_asmOutput);
1510 foreach (TypeDefinition type in module.Types) {
1511 if (type.HasMethods) {
1512 foreach (MethodDefinition method in type.Methods)
1513 WriteSymbols (method);
1515 if (type.HasConstructors) {
1516 foreach (MethodDefinition ctor in type.Constructors)
1517 WriteSymbols (ctor);
1521 m_symbolWriter.Dispose ();
1524 void WriteSymbols (MethodDefinition meth)
1529 m_symbolWriter.Write (meth.Body);