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 {
35 using Mono.Cecil.Binary;
37 using Mono.Cecil.Metadata;
38 using Mono.Cecil.Signatures;
40 internal abstract class ReflectionReader : BaseReflectionReader {
42 ModuleDefinition m_module;
44 SecurityDeclarationReader m_secReader;
45 protected MetadataTableReader m_tableReader;
46 protected MetadataRoot m_root;
47 protected TablesHeap m_tHeap;
48 protected bool m_checkDeleted;
50 protected TypeDefinition [] m_typeDefs;
51 protected TypeReference [] m_typeRefs;
52 protected TypeReference [] m_typeSpecs;
53 protected MethodDefinition [] m_meths;
54 protected FieldDefinition [] m_fields;
55 protected EventDefinition [] m_events;
56 protected PropertyDefinition [] m_properties;
57 protected MemberReference [] m_memberRefs;
58 protected ParameterDefinition [] m_parameters;
59 protected GenericParameter [] m_genericParameters;
60 protected GenericInstanceMethod [] m_methodSpecs;
63 AssemblyNameReference m_corlib;
65 protected SignatureReader m_sigReader;
66 protected CodeReader m_codeReader;
67 protected ISymbolReader m_symbolReader;
69 internal AssemblyNameReference Corlib {
74 foreach (AssemblyNameReference ar in m_module.AssemblyReferences) {
75 if (ar.Name == Constants.Corlib) {
85 public ModuleDefinition Module {
86 get { return m_module; }
89 public SignatureReader SigReader {
90 get { return m_sigReader; }
93 public MetadataTableReader TableReader {
94 get { return m_tableReader; }
97 public CodeReader Code {
98 get { return m_codeReader; }
101 public ISymbolReader SymbolReader {
102 get { return m_symbolReader; }
103 set { m_symbolReader = value; }
106 public MetadataRoot MetadataRoot {
107 get { return m_root; }
110 public ReflectionReader (ModuleDefinition module)
113 m_reader = m_module.ImageReader;
114 m_root = m_module.Image.MetadataRoot;
115 m_tHeap = m_root.Streams.TablesHeap;
116 m_checkDeleted = (m_tHeap.HeapSizes & 0x80) != 0;
117 if (m_reader != null)
118 m_tableReader = m_reader.MetadataReader.TableReader;
119 m_codeReader = new CodeReader (this);
120 m_sigReader = new SignatureReader (m_root, this);
121 m_isCorlib = module.Assembly.Name.Name == Constants.Corlib;
124 public TypeDefinition GetTypeDefAt (uint rid)
126 if (rid > m_typeDefs.Length)
129 return m_typeDefs [rid - 1];
132 public TypeReference GetTypeRefAt (uint rid)
134 if (rid > m_typeRefs.Length)
137 return m_typeRefs [rid - 1];
140 public TypeReference GetTypeSpecAt (uint rid, GenericContext context)
142 if (rid > m_typeSpecs.Length)
145 int index = (int) rid - 1;
147 TypeSpecTable tsTable = m_tableReader.GetTypeSpecTable ();
148 TypeSpecRow tsRow = tsTable [index];
149 TypeSpec ts = m_sigReader.GetTypeSpec (tsRow.Signature);
151 // don't cache generic instances
152 if (ts.Type.ElementType == ElementType.GenericInst)
153 return CreateTypeSpecFromSig (ts, index, context);
155 TypeReference tspec = m_typeSpecs [index];
159 tspec = CreateTypeSpecFromSig (ts, index, context);
160 m_typeSpecs [index] = tspec;
165 TypeReference CreateTypeSpecFromSig (TypeSpec ts, int index, GenericContext context)
167 TypeReference tspec = GetTypeRefFromSig (ts.Type, context);
168 tspec = GetModifierType (ts.CustomMods, tspec);
169 tspec.MetadataToken = MetadataToken.FromMetadataRow (TokenType.TypeSpec, index);
173 public FieldDefinition GetFieldDefAt (uint rid)
175 if (rid > m_fields.Length)
178 return m_fields [rid - 1];
181 public MethodDefinition GetMethodDefAt (uint rid)
183 if (rid > m_meths.Length)
186 return m_meths [rid - 1];
189 protected bool IsDeleted (IMemberDefinition member)
194 if (!member.IsSpecialName || !member.IsRuntimeSpecialName)
197 return member.Name.StartsWith (Constants.Deleted);
200 public MemberReference GetMemberRefAt (uint rid, GenericContext context)
202 if (rid > m_memberRefs.Length)
205 int index = (int) rid - 1;
206 MemberReference member = m_memberRefs [index];
210 MemberRefTable mrTable = m_tableReader.GetMemberRefTable ();
211 MemberRefRow mrefRow = mrTable [index];
213 Signature sig = m_sigReader.GetMemberRefSig (mrefRow.Class.TokenType, mrefRow.Signature);
214 switch (mrefRow.Class.TokenType) {
215 case TokenType.TypeDef :
216 case TokenType.TypeRef :
217 case TokenType.TypeSpec :
218 TypeReference declaringType = GetTypeDefOrRef (mrefRow.Class, context);
219 GenericContext nc = context.Clone ();
221 if (declaringType is GenericInstanceType) {
222 TypeReference ct = declaringType;
223 while (ct is GenericInstanceType)
224 ct = (ct as GenericInstanceType).ElementType;
229 if (sig is FieldSig) {
230 FieldSig fs = sig as FieldSig;
231 TypeReference fieldType = GetTypeRefFromSig (fs.Type, nc);
232 fieldType = GetModifierType (fs.CustomMods, fieldType);
234 member = new FieldReference (
235 m_root.Streams.StringsHeap [mrefRow.Name],
239 string name = m_root.Streams.StringsHeap [mrefRow.Name];
240 MethodSig ms = (MethodSig) sig;
242 member = CreateMethodReferenceFromSig (ms, name, declaringType, nc);
245 case TokenType.Method :
246 // really not sure about this
247 MethodDefinition methdef = GetMethodDefAt (mrefRow.Class.RID);
249 member = CreateMethodReferenceFromSig ((MethodSig) sig, methdef.Name, methdef.DeclaringType, new GenericContext ());
251 case TokenType.ModuleRef :
252 break; // TODO, implement that, or not
255 member.MetadataToken = MetadataToken.FromMetadataRow (TokenType.MemberRef, index);
256 m_module.MemberReferences.Add (member);
257 m_memberRefs [index] = member;
262 MethodReference CreateMethodReferenceFromSig (MethodSig ms, string name, TypeReference declaringType, GenericContext context)
264 MethodReference methref = new MethodReference (
265 name, ms.HasThis, ms.ExplicitThis, ms.MethCallConv);
266 methref.DeclaringType = declaringType;
268 if (ms is MethodDefSig) {
269 int arity = (ms as MethodDefSig).GenericParameterCount;
270 for (int i = 0; i < arity; i++)
271 methref.GenericParameters.Add (new GenericParameter (i, methref));
274 if (methref.GenericParameters.Count > 0)
275 context.Method = methref;
277 methref.ReturnType = GetMethodReturnType (ms, context);
279 methref.ReturnType.Method = methref;
280 for (int j = 0; j < ms.ParamCount; j++) {
281 Param p = ms.Parameters [j];
282 ParameterDefinition pdef = BuildParameterDefinition (j, p, context);
283 pdef.Method = methref;
284 methref.Parameters.Add (pdef);
287 CreateSentinelIfNeeded (methref, ms);
292 public static void CreateSentinelIfNeeded (IMethodSignature meth, MethodSig signature)
294 MethodDefSig sig = signature as MethodDefSig;
298 int sentinel = sig.Sentinel;
300 if (sig.Sentinel < 0 || sig.Sentinel >= meth.Parameters.Count)
303 ParameterDefinition param = meth.Parameters [sentinel];
304 param.ParameterType = new SentinelType (param.ParameterType);
307 public PropertyDefinition GetPropertyDefAt (uint rid)
309 if (rid > m_properties.Length)
312 return m_properties [rid - 1];
315 public EventDefinition GetEventDefAt (uint rid)
317 if (rid > m_events.Length)
320 return m_events [rid - 1];
323 public ParameterDefinition GetParamDefAt (uint rid)
325 if (rid > m_parameters.Length)
328 return m_parameters [rid - 1];
331 public GenericParameter GetGenericParameterAt (uint rid)
333 if (rid > m_genericParameters.Length)
336 return m_genericParameters [rid - 1];
339 public GenericInstanceMethod GetMethodSpecAt (uint rid, GenericContext context)
341 if (rid > m_methodSpecs.Length)
344 int index = (int) rid - 1;
345 GenericInstanceMethod gim = m_methodSpecs [index];
349 MethodSpecTable msTable = m_tableReader.GetMethodSpecTable ();
350 MethodSpecRow msRow = msTable [index];
352 MethodSpec sig = m_sigReader.GetMethodSpec (msRow.Instantiation);
354 MethodReference meth;
355 if (msRow.Method.TokenType == TokenType.Method)
356 meth = GetMethodDefAt (msRow.Method.RID);
357 else if (msRow.Method.TokenType == TokenType.MemberRef)
358 meth = (MethodReference) GetMemberRefAt (msRow.Method.RID, context);
360 throw new ReflectionException ("Unknown method type for method spec");
362 gim = new GenericInstanceMethod (meth);
363 context.CheckProvider (meth, sig.Signature.Arity);
364 foreach (GenericArg arg in sig.Signature.Types)
365 gim.GenericArguments.Add (GetGenericArg (arg, context));
367 m_methodSpecs [index] = gim;
372 public TypeReference GetTypeDefOrRef (MetadataToken token, GenericContext context)
377 switch (token.TokenType) {
378 case TokenType.TypeDef :
379 return GetTypeDefAt (token.RID);
380 case TokenType.TypeRef :
381 return GetTypeRefAt (token.RID);
382 case TokenType.TypeSpec :
383 return GetTypeSpecAt (token.RID, context);
389 public TypeReference SearchCoreType (string fullName)
392 return m_module.Types [fullName];
394 TypeReference coreType = m_module.TypeReferences [fullName];
395 if (coreType == null) {
396 string [] parts = fullName.Split ('.');
397 if (parts.Length != 2)
398 throw new ReflectionException ("Unvalid core type name");
399 coreType = new TypeReference (parts [1], parts [0], Corlib);
400 m_module.TypeReferences.Add (coreType);
402 if (!coreType.IsValueType) {
403 switch (coreType.FullName) {
404 case Constants.Boolean :
405 case Constants.Char :
406 case Constants.Single :
407 case Constants.Double :
408 case Constants.SByte :
409 case Constants.Byte :
410 case Constants.Int16 :
411 case Constants.UInt16 :
412 case Constants.Int32 :
413 case Constants.UInt32 :
414 case Constants.Int64 :
415 case Constants.UInt64 :
416 case Constants.IntPtr :
417 case Constants.UIntPtr :
418 coreType.IsValueType = true;
425 public IMetadataTokenProvider LookupByToken (MetadataToken token)
427 switch (token.TokenType) {
428 case TokenType.TypeDef :
429 return GetTypeDefAt (token.RID);
430 case TokenType.TypeRef :
431 return GetTypeRefAt (token.RID);
432 case TokenType.Method :
433 return GetMethodDefAt (token.RID);
434 case TokenType.Field :
435 return GetFieldDefAt (token.RID);
436 case TokenType.Event :
437 return GetEventDefAt (token.RID);
438 case TokenType.Property :
439 return GetPropertyDefAt (token.RID);
440 case TokenType.Param :
441 return GetParamDefAt (token.RID);
443 throw new NotSupportedException ("Lookup is not allowed on this kind of token");
447 public CustomAttribute GetCustomAttribute (MethodReference ctor, byte [] data, bool resolve)
449 CustomAttrib sig = m_sigReader.GetCustomAttrib (data, ctor, resolve);
450 return BuildCustomAttribute (ctor, data, sig);
453 public CustomAttribute GetCustomAttribute (MethodReference ctor, byte [] data)
455 return GetCustomAttribute (ctor, data, false);
458 public override void VisitModuleDefinition (ModuleDefinition mod)
460 VisitTypeDefinitionCollection (mod.Types);
463 public override void VisitTypeDefinitionCollection (TypeDefinitionCollection types)
466 TypeDefTable typesTable = m_tableReader.GetTypeDefTable ();
467 m_typeDefs = new TypeDefinition [typesTable.Rows.Count];
468 for (int i = 0; i < typesTable.Rows.Count; i++) {
469 TypeDefRow type = typesTable [i];
470 TypeDefinition t = new TypeDefinition (
471 m_root.Streams.StringsHeap [type.Name],
472 m_root.Streams.StringsHeap [type.Namespace],
474 t.MetadataToken = MetadataToken.FromMetadataRow (TokenType.TypeDef, i);
480 if (m_tHeap.HasTable (NestedClassTable.RId)) {
481 NestedClassTable nested = m_tableReader.GetNestedClassTable ();
482 for (int i = 0; i < nested.Rows.Count; i++) {
483 NestedClassRow row = nested [i];
485 TypeDefinition parent = GetTypeDefAt (row.EnclosingClass);
486 TypeDefinition child = GetTypeDefAt (row.NestedClass);
488 if (!IsDeleted (child))
489 parent.NestedTypes.Add (child);
493 foreach (TypeDefinition type in m_typeDefs)
494 if (!IsDeleted (type))
498 if (m_tHeap.HasTable (TypeRefTable.RId)) {
499 TypeRefTable typesRef = m_tableReader.GetTypeRefTable ();
501 m_typeRefs = new TypeReference [typesRef.Rows.Count];
503 for (int i = 0; i < typesRef.Rows.Count; i++)
504 AddTypeRef (typesRef, i);
506 m_typeRefs = new TypeReference [0];
512 ReadGenericParameters ();
515 for (int i = 0; i < typesTable.Rows.Count; i++) {
516 TypeDefRow type = typesTable [i];
517 TypeDefinition child = m_typeDefs [i];
518 child.BaseType = GetTypeDefOrRef (type.Extends, new GenericContext (child));
523 ReadMemberReferences ();
526 void AddTypeRef (TypeRefTable typesRef, int i)
528 if (i >= typesRef.Rows.Count)
531 // Check if index has been already added.
532 if (m_typeRefs [i] != null)
535 TypeRefRow type = typesRef [i];
536 IMetadataScope scope = null;
537 TypeReference parent = null;
539 if (type.ResolutionScope.RID != 0) {
540 int rid = (int) type.ResolutionScope.RID - 1;
541 switch (type.ResolutionScope.TokenType) {
542 case TokenType.AssemblyRef:
543 scope = m_module.AssemblyReferences [rid];
545 case TokenType.ModuleRef:
546 scope = m_module.ModuleReferences [rid];
548 case TokenType.Module:
549 scope = m_module.Assembly.Modules [rid];
551 case TokenType.TypeRef:
552 AddTypeRef (typesRef, rid);
553 parent = GetTypeRefAt (type.ResolutionScope.RID);
555 scope = parent.Scope;
560 TypeReference t = new TypeReference (
561 m_root.Streams.StringsHeap [type.Name],
562 m_root.Streams.StringsHeap [type.Namespace],
564 t.MetadataToken = MetadataToken.FromMetadataRow (TokenType.TypeRef, i);
567 t.DeclaringType = parent;
570 m_module.TypeReferences.Add (t);
573 void ReadTypeSpecs ()
575 if (!m_tHeap.HasTable (TypeSpecTable.RId))
578 TypeSpecTable tsTable = m_tableReader.GetTypeSpecTable ();
579 m_typeSpecs = new TypeReference [tsTable.Rows.Count];
582 void ReadMethodSpecs ()
584 if (!m_tHeap.HasTable (MethodSpecTable.RId))
587 MethodSpecTable msTable = m_tableReader.GetMethodSpecTable ();
588 m_methodSpecs = new GenericInstanceMethod [msTable.Rows.Count];
591 void ReadGenericParameters ()
593 if (!m_tHeap.HasTable (GenericParamTable.RId))
596 GenericParamTable gpTable = m_tableReader.GetGenericParamTable ();
597 m_genericParameters = new GenericParameter [gpTable.Rows.Count];
598 for (int i = 0; i < gpTable.Rows.Count; i++) {
599 GenericParamRow gpRow = gpTable [i];
600 IGenericParameterProvider owner;
601 if (gpRow.Owner.TokenType == TokenType.Method)
602 owner = GetMethodDefAt (gpRow.Owner.RID);
603 else if (gpRow.Owner.TokenType == TokenType.TypeDef)
604 owner = GetTypeDefAt (gpRow.Owner.RID);
606 throw new ReflectionException ("Unknown owner type for generic parameter");
608 GenericParameter gp = new GenericParameter (gpRow.Number, owner);
609 gp.Attributes = gpRow.Flags;
610 gp.Name = MetadataRoot.Streams.StringsHeap [gpRow.Name];
611 gp.MetadataToken = MetadataToken.FromMetadataRow (TokenType.GenericParam, i);
613 owner.GenericParameters.Add (gp);
614 m_genericParameters [i] = gp;
618 void ReadAllFields ()
620 TypeDefTable tdefTable = m_tableReader.GetTypeDefTable ();
622 if (!m_tHeap.HasTable (FieldTable.RId)) {
623 m_fields = new FieldDefinition [0];
627 FieldTable fldTable = m_tableReader.GetFieldTable ();
628 m_fields = new FieldDefinition [fldTable.Rows.Count];
630 for (int i = 0; i < m_typeDefs.Length; i++) {
631 TypeDefinition dec = m_typeDefs [i];
632 GenericContext context = new GenericContext (dec);
636 if (index == tdefTable.Rows.Count - 1)
637 next = fldTable.Rows.Count + 1;
639 next = (int) (tdefTable [index + 1]).FieldList;
641 for (int j = (int) tdefTable [index].FieldList; j < next; j++) {
642 FieldRow frow = fldTable [j - 1];
643 FieldSig fsig = m_sigReader.GetFieldSig (frow.Signature);
645 FieldDefinition fdef = new FieldDefinition (
646 m_root.Streams.StringsHeap [frow.Name],
647 GetTypeRefFromSig (fsig.Type, context), frow.Flags);
648 fdef.MetadataToken = MetadataToken.FromMetadataRow (TokenType.Field, j - 1);
650 if (fsig.CustomMods.Length > 0)
651 fdef.FieldType = GetModifierType (fsig.CustomMods, fdef.FieldType);
653 if (!IsDeleted (fdef))
654 dec.Fields.Add (fdef);
656 m_fields [j - 1] = fdef;
663 if (!m_tHeap.HasTable (MethodTable.RId)) {
664 m_meths = new MethodDefinition [0];
668 MethodTable mTable = m_tableReader.GetMethodTable ();
669 m_meths = new MethodDefinition [mTable.Rows.Count];
670 for (int i = 0; i < mTable.Rows.Count; i++) {
671 MethodRow mRow = mTable [i];
672 MethodDefinition meth = new MethodDefinition (
673 m_root.Streams.StringsHeap [mRow.Name],
676 meth.ImplAttributes = mRow.ImplFlags;
678 meth.MetadataToken = MetadataToken.FromMetadataRow (TokenType.Method, i);
684 void CompleteMethods ()
686 TypeDefTable tdefTable = m_tableReader.GetTypeDefTable ();
688 if (!m_tHeap.HasTable (MethodTable.RId)) {
689 m_meths = new MethodDefinition [0];
693 MethodTable methTable = m_tableReader.GetMethodTable ();
694 ParamTable paramTable = m_tableReader.GetParamTable ();
695 if (!m_tHeap.HasTable (ParamTable.RId))
696 m_parameters = new ParameterDefinition [0];
698 m_parameters = new ParameterDefinition [paramTable.Rows.Count];
700 for (int i = 0; i < m_typeDefs.Length; i++) {
701 TypeDefinition dec = m_typeDefs [i];
705 if (index == tdefTable.Rows.Count - 1)
706 next = methTable.Rows.Count + 1;
708 next = (int) (tdefTable [index + 1]).MethodList;
710 for (int j = (int) tdefTable [index].MethodList; j < next; j++) {
711 MethodRow methRow = methTable [j - 1];
712 MethodDefinition mdef = m_meths [j - 1];
714 if (!IsDeleted (mdef)) {
715 if (mdef.IsConstructor)
716 dec.Constructors.Add (mdef);
718 dec.Methods.Add (mdef);
721 GenericContext context = new GenericContext (mdef);
723 MethodDefSig msig = m_sigReader.GetMethodDefSig (methRow.Signature);
724 mdef.HasThis = msig.HasThis;
725 mdef.ExplicitThis = msig.ExplicitThis;
726 mdef.CallingConvention = msig.MethCallConv;
729 if (j == methTable.Rows.Count)
730 prms = m_parameters.Length + 1;
732 prms = (int) (methTable [j]).ParamList;
734 ParameterDefinition retparam = null;
736 //TODO: optimize this
737 int start = (int) methRow.ParamList - 1;
739 if (paramTable != null && start < prms - 1) {
741 ParamRow pRetRow = paramTable [start];
743 if (pRetRow != null && pRetRow.Sequence == 0) { // ret type
745 retparam = new ParameterDefinition (
746 m_root.Streams.StringsHeap [pRetRow.Name],
751 retparam.Method = mdef;
752 m_parameters [start] = retparam;
757 for (int k = 0; k < msig.ParamCount; k++) {
759 int pointer = start + k;
761 ParamRow pRow = null;
763 if (paramTable != null && pointer < prms - 1)
764 pRow = paramTable [pointer];
766 Param psig = msig.Parameters [k];
768 ParameterDefinition pdef;
770 pdef = BuildParameterDefinition (
771 m_root.Streams.StringsHeap [pRow.Name],
772 pRow.Sequence, pRow.Flags, psig, context);
773 pdef.MetadataToken = MetadataToken.FromMetadataRow (TokenType.Param, pointer);
774 m_parameters [pointer] = pdef;
776 pdef = BuildParameterDefinition (k + 1, psig, context);
779 mdef.Parameters.Add (pdef);
782 mdef.ReturnType = GetMethodReturnType (msig, context);
783 MethodReturnType mrt = mdef.ReturnType;
785 if (retparam != null) {
786 mrt.Parameter = retparam;
787 mrt.Parameter.ParameterType = mrt.ReturnType;
792 uint eprid = CodeReader.GetRid ((int) m_reader.Image.CLIHeader.EntryPointToken);
793 if (eprid > 0 && eprid <= m_meths.Length)
794 m_module.Assembly.EntryPoint = GetMethodDefAt (eprid);
797 void ReadMemberReferences ()
799 if (!m_tHeap.HasTable (MemberRefTable.RId))
802 MemberRefTable mrefTable = m_tableReader.GetMemberRefTable ();
803 m_memberRefs = new MemberReference [mrefTable.Rows.Count];
806 public override void VisitExternTypeCollection (ExternTypeCollection externs)
808 ExternTypeCollection ext = externs;
810 if (!m_tHeap.HasTable (ExportedTypeTable.RId))
813 ExportedTypeTable etTable = m_tableReader.GetExportedTypeTable ();
814 TypeReference [] buffer = new TypeReference [etTable.Rows.Count];
816 for (int i = 0; i < etTable.Rows.Count; i++) {
817 ExportedTypeRow etRow = etTable [i];
819 buffer [i] = new TypeDefinition (
820 m_root.Streams.StringsHeap [etRow.TypeName],
821 m_root.Streams.StringsHeap [etRow.TypeNamespace],
823 buffer [i].AttachToScope (GetExportedTypeScope (etRow.Implementation));
826 for (int i = 0; i < etTable.Rows.Count; i++) {
827 ExportedTypeRow etRow = etTable [i];
828 if (etRow.Implementation.TokenType != TokenType.ExportedType)
831 TypeReference exported = buffer [i];
832 TypeReference owner = buffer [etRow.Implementation.RID - 1];
833 exported.DeclaringType = owner;
834 exported.AttachToScope (owner.Scope);
837 for (int i = 0; i < buffer.Length; i++) {
838 TypeReference curs = buffer [i];
844 IMetadataScope GetExportedTypeScope (MetadataToken scope)
846 int index = (int) scope.RID - 1;
847 switch (scope.TokenType) {
848 case TokenType.AssemblyRef:
849 return Module.AssemblyReferences [index];
851 return Module.ModuleReferences [index];
852 case TokenType.ExportedType:
853 return null; // resolved later
855 throw new NotSupportedException ();
859 static object GetFixedArgValue (CustomAttrib.FixedArg fa)
862 object [] vals = new object [fa.NumElem];
863 for (int j = 0; j < vals.Length; j++)
864 vals [j] = fa.Elems [j].Value;
867 return fa.Elems [0].Value;
870 TypeReference GetFixedArgType (CustomAttrib.FixedArg fa)
874 return new ArrayType (SearchCoreType (Constants.Object));
876 return new ArrayType (fa.Elems [0].ElemType);
878 return fa.Elems [0].ElemType;
881 TypeReference GetNamedArgType (CustomAttrib.NamedArg na)
883 if (na.FieldOrPropType == ElementType.Boxed)
884 return SearchCoreType (Constants.Object);
886 return GetFixedArgType (na.FixedArg);
889 protected CustomAttribute BuildCustomAttribute (MethodReference ctor, byte [] data, CustomAttrib sig)
891 CustomAttribute cattr = new CustomAttribute (ctor);
893 cattr.Resolved = false;
898 foreach (CustomAttrib.FixedArg fa in sig.FixedArgs)
899 cattr.ConstructorParameters.Add (GetFixedArgValue (fa));
901 foreach (CustomAttrib.NamedArg na in sig.NamedArgs) {
902 object value = GetFixedArgValue (na.FixedArg);
904 cattr.Fields [na.FieldOrPropName] = value;
905 cattr.SetFieldType (na.FieldOrPropName, GetNamedArgType (na));
906 } else if (na.Property) {
907 cattr.Properties [na.FieldOrPropName] = value;
908 cattr.SetPropertyType (na.FieldOrPropName, GetNamedArgType (na));
910 throw new ReflectionException ("Non valid named arg");
916 void CompleteParameter (ParameterDefinition parameter, Param signature, GenericContext context)
918 TypeReference paramType;
920 if (signature.TypedByRef)
921 paramType = SearchCoreType (Constants.TypedReference);
923 paramType = GetTypeRefFromSig (signature.Type, context);
925 paramType = GetModifierType (signature.CustomMods, paramType);
928 paramType = new ReferenceType (paramType);
930 parameter.ParameterType = paramType;
933 public ParameterDefinition BuildParameterDefinition (int sequence, Param psig, GenericContext context)
935 ParameterDefinition parameter = new ParameterDefinition (null);
936 parameter.Sequence = sequence;
938 CompleteParameter (parameter, psig, context);
943 public ParameterDefinition BuildParameterDefinition (string name, int sequence, ParameterAttributes attrs, Param psig, GenericContext context)
945 ParameterDefinition parameter = new ParameterDefinition (name, sequence, attrs, null);
947 CompleteParameter (parameter, psig, context);
952 protected SecurityDeclaration BuildSecurityDeclaration (DeclSecurityRow dsRow)
954 return BuildSecurityDeclaration (dsRow.Action, m_root.Streams.BlobHeap.Read (dsRow.PermissionSet));
957 public SecurityDeclaration BuildSecurityDeclaration (SecurityAction action, byte [] permset)
959 if (m_secReader == null)
960 m_secReader = new SecurityDeclarationReader (m_root, this);
962 return m_secReader.FromByteArray (action, permset);
965 protected MarshalSpec BuildMarshalDesc (MarshalSig ms, IHasMarshalSpec container)
967 if (ms.Spec is MarshalSig.Array) {
968 ArrayMarshalSpec amd = new ArrayMarshalSpec (container);
969 MarshalSig.Array ar = (MarshalSig.Array) ms.Spec;
970 amd.ElemType = ar.ArrayElemType;
971 amd.NumElem = ar.NumElem;
972 amd.ParamNum = ar.ParamNum;
973 amd.ElemMult = ar.ElemMult;
975 } else if (ms.Spec is MarshalSig.CustomMarshaler) {
976 CustomMarshalerSpec cmd = new CustomMarshalerSpec (container);
977 MarshalSig.CustomMarshaler cmsig = (MarshalSig.CustomMarshaler) ms.Spec;
978 cmd.Guid = cmsig.Guid.Length > 0 ? new Guid (cmsig.Guid) : new Guid ();
979 cmd.UnmanagedType = cmsig.UnmanagedType;
980 cmd.ManagedType = cmsig.ManagedType;
981 cmd.Cookie = cmsig.Cookie;
983 } else if (ms.Spec is MarshalSig.FixedArray) {
984 FixedArraySpec fad = new FixedArraySpec (container);
985 MarshalSig.FixedArray fasig = (MarshalSig.FixedArray) ms.Spec;
986 fad.ElemType = fasig.ArrayElemType;
987 fad.NumElem = fasig.NumElem;
989 } else if (ms.Spec is MarshalSig.FixedSysString) {
990 FixedSysStringSpec fssc = new FixedSysStringSpec (container);
991 fssc.Size = ((MarshalSig.FixedSysString) ms.Spec).Size;
993 } else if (ms.Spec is MarshalSig.SafeArray) {
994 SafeArraySpec sad = new SafeArraySpec (container);
995 sad.ElemType = ((MarshalSig.SafeArray) ms.Spec).ArrayElemType;
998 return new MarshalSpec (ms.NativeInstrinsic, container);
1002 public TypeReference GetModifierType (CustomMod [] cmods, TypeReference type)
1004 if (cmods == null || cmods.Length == 0)
1007 TypeReference ret = type;
1008 for (int i = cmods.Length - 1; i >= 0; i--) {
1009 CustomMod cmod = cmods [i];
1010 TypeReference modType;
1012 if (cmod.TypeDefOrRef.RID == 0)
1015 if (cmod.TypeDefOrRef.TokenType == TokenType.TypeDef)
1016 modType = GetTypeDefAt (cmod.TypeDefOrRef.RID);
1018 modType = GetTypeRefAt (cmod.TypeDefOrRef.RID);
1020 if (cmod.CMOD == CustomMod.CMODType.OPT)
1021 ret = new ModifierOptional (ret, modType);
1022 else if (cmod.CMOD == CustomMod.CMODType.REQD)
1023 ret = new ModifierRequired (ret, modType);
1028 public MethodReturnType GetMethodReturnType (MethodSig msig, GenericContext context)
1030 TypeReference retType;
1031 if (msig.RetType.Void)
1032 retType = SearchCoreType (Constants.Void);
1033 else if (msig.RetType.TypedByRef)
1034 retType = SearchCoreType (Constants.TypedReference);
1036 retType = GetTypeRefFromSig (msig.RetType.Type, context);
1038 retType = GetModifierType (msig.RetType.CustomMods, retType);
1040 if (msig.RetType.ByRef)
1041 retType = new ReferenceType (retType);
1043 return new MethodReturnType (retType);
1046 public TypeReference GetTypeRefFromSig (SigType t, GenericContext context)
1048 switch (t.ElementType) {
1049 case ElementType.Class :
1050 CLASS c = t as CLASS;
1051 return GetTypeDefOrRef (c.Type, context);
1052 case ElementType.ValueType :
1053 VALUETYPE vt = t as VALUETYPE;
1054 TypeReference vtr = GetTypeDefOrRef (vt.Type, context);
1055 vtr.IsValueType = true;
1057 case ElementType.String :
1058 return SearchCoreType (Constants.String);
1059 case ElementType.Object :
1060 return SearchCoreType (Constants.Object);
1061 case ElementType.Void :
1062 return SearchCoreType (Constants.Void);
1063 case ElementType.Boolean :
1064 return SearchCoreType (Constants.Boolean);
1065 case ElementType.Char :
1066 return SearchCoreType (Constants.Char);
1067 case ElementType.I1 :
1068 return SearchCoreType (Constants.SByte);
1069 case ElementType.U1 :
1070 return SearchCoreType (Constants.Byte);
1071 case ElementType.I2 :
1072 return SearchCoreType (Constants.Int16);
1073 case ElementType.U2 :
1074 return SearchCoreType (Constants.UInt16);
1075 case ElementType.I4 :
1076 return SearchCoreType (Constants.Int32);
1077 case ElementType.U4 :
1078 return SearchCoreType (Constants.UInt32);
1079 case ElementType.I8 :
1080 return SearchCoreType (Constants.Int64);
1081 case ElementType.U8 :
1082 return SearchCoreType (Constants.UInt64);
1083 case ElementType.R4 :
1084 return SearchCoreType (Constants.Single);
1085 case ElementType.R8 :
1086 return SearchCoreType (Constants.Double);
1087 case ElementType.I :
1088 return SearchCoreType (Constants.IntPtr);
1089 case ElementType.U :
1090 return SearchCoreType (Constants.UIntPtr);
1091 case ElementType.TypedByRef :
1092 return SearchCoreType (Constants.TypedReference);
1093 case ElementType.Array :
1094 ARRAY ary = t as ARRAY;
1095 return new ArrayType (GetTypeRefFromSig (ary.Type, context), ary.Shape);
1096 case ElementType.SzArray :
1097 SZARRAY szary = t as SZARRAY;
1098 ArrayType at = new ArrayType (GetTypeRefFromSig (szary.Type, context));
1100 case ElementType.Ptr :
1101 PTR pointer = t as PTR;
1103 return new PointerType (SearchCoreType (Constants.Void));
1104 return new PointerType (GetTypeRefFromSig (pointer.PtrType, context));
1105 case ElementType.FnPtr :
1106 FNPTR funcptr = t as FNPTR;
1107 FunctionPointerType fnptr = new FunctionPointerType (funcptr.Method.HasThis, funcptr.Method.ExplicitThis,
1108 funcptr.Method.MethCallConv, GetMethodReturnType (funcptr.Method, context));
1110 for (int i = 0; i < funcptr.Method.ParamCount; i++) {
1111 Param p = funcptr.Method.Parameters [i];
1112 fnptr.Parameters.Add (BuildParameterDefinition (i, p, context));
1115 CreateSentinelIfNeeded (fnptr, funcptr.Method);
1118 case ElementType.Var:
1120 context.CheckProvider (context.Type, var.Index + 1);
1122 if (context.Type is GenericInstanceType)
1123 return (context.Type as GenericInstanceType).GenericArguments [var.Index];
1125 return context.Type.GenericParameters [var.Index];
1126 case ElementType.MVar:
1127 MVAR mvar = t as MVAR;
1128 context.CheckProvider (context.Method, mvar.Index + 1);
1130 if (context.Method is GenericInstanceMethod)
1131 return (context.Method as GenericInstanceMethod).GenericArguments [mvar.Index];
1133 return context.Method.GenericParameters [mvar.Index];
1134 case ElementType.GenericInst:
1135 GENERICINST ginst = t as GENERICINST;
1136 GenericInstanceType instance = new GenericInstanceType (GetTypeDefOrRef (ginst.Type, context));
1137 instance.IsValueType = ginst.ValueType;
1138 context.CheckProvider (instance.GetOriginalType (), ginst.Signature.Arity);
1140 for (int i = 0; i < ginst.Signature.Arity; i++)
1141 instance.GenericArguments.Add (GetGenericArg (
1142 ginst.Signature.Types [i], context));
1151 TypeReference GetGenericArg (GenericArg arg, GenericContext context)
1153 TypeReference type = GetTypeRefFromSig (arg.Type, context);
1154 type = GetModifierType (arg.CustomMods, type);
1158 static bool IsOdd (int i)
1160 return (i & 1) == 1;
1163 protected object GetConstant (uint pos, ElementType elemType)
1165 if (elemType == ElementType.Class)
1168 byte [] constant = m_root.Streams.BlobHeap.Read (pos);
1170 if (elemType == ElementType.String) {
1171 int length = constant.Length;
1175 return Encoding.Unicode.GetString (constant, 0, length);
1178 // One byte types can always be read using BitConverter. However it can't be used
1179 // elsewhere since it behaves differently in Mono compared to CF on BE architectures
1181 case ElementType.Boolean :
1182 return BitConverter.ToBoolean (constant, 0);
1183 case ElementType.I1 :
1184 return (sbyte) constant [0];
1185 case ElementType.U1 :
1186 return (byte) constant [0];
1187 case ElementType.Object: // illegal, but foundable
1190 if (BitConverter.IsLittleEndian)
1191 return GetConstantLittleEndian (elemType, constant);
1193 return GetConstantBigEndian (elemType, constant);
1197 static object GetConstantLittleEndian (ElementType elemType, byte [] constant)
1200 case ElementType.Char :
1201 return BitConverter.ToChar (constant, 0);
1202 case ElementType.I2 :
1203 return BitConverter.ToInt16 (constant, 0);
1204 case ElementType.I4 :
1205 return BitConverter.ToInt32 (constant, 0);
1206 case ElementType.I8 :
1207 return BitConverter.ToInt64 (constant, 0);
1208 case ElementType.U2 :
1209 return BitConverter.ToUInt16 (constant, 0);
1210 case ElementType.U4 :
1211 return BitConverter.ToUInt32 (constant, 0);
1212 case ElementType.U8 :
1213 return BitConverter.ToUInt64 (constant, 0);
1214 case ElementType.R4 :
1215 return BitConverter.ToSingle (constant, 0);
1216 case ElementType.R8 :
1217 return BitConverter.ToDouble (constant, 0);
1219 throw new ReflectionException ("Non valid element in constant table");
1223 static object GetConstantBigEndian (ElementType elemType, byte [] constant)
1225 // BinaryReader always read it's data in LE format
1226 // note: this could be further optimized (even without unsafe code)
1227 BinaryReader br = new BinaryReader (new MemoryStream (constant));
1229 case ElementType.Char :
1230 return (char) br.ReadUInt16 ();
1231 case ElementType.I2 :
1232 return br.ReadInt16 ();
1233 case ElementType.I4 :
1234 return br.ReadInt32 ();
1235 case ElementType.I8 :
1236 return br.ReadInt64 ();
1237 case ElementType.U2 :
1238 return br.ReadUInt16 ();
1239 case ElementType.U4 :
1240 return br.ReadUInt32 ();
1241 case ElementType.U8 :
1242 return br.ReadUInt64 ();
1243 case ElementType.R4 :
1244 return br.ReadSingle ();
1245 case ElementType.R8 :
1246 return br.ReadDouble ();
1248 throw new ReflectionException ("Non valid element in constant table");
1252 protected void SetInitialValue (FieldDefinition field)
1255 TypeReference fieldType = field.FieldType;
1256 switch (fieldType.FullName) {
1257 case Constants.Boolean:
1258 case Constants.Byte:
1259 case Constants.SByte:
1262 case Constants.Int16:
1263 case Constants.UInt16:
1264 case Constants.Char:
1267 case Constants.Int32:
1268 case Constants.UInt32:
1269 case Constants.Single:
1272 case Constants.Int64:
1273 case Constants.UInt64:
1274 case Constants.Double:
1278 fieldType = fieldType.GetOriginalType ();
1280 TypeDefinition fieldTypeDef = fieldType as TypeDefinition;
1282 if (fieldTypeDef != null)
1283 size = (int) fieldTypeDef.ClassSize;
1287 if (size > 0 && field.RVA != RVA.Zero) {
1288 byte [] data = new byte [size];
1289 Section sect = m_reader.Image.GetSectionAtVirtualAddress (field.RVA);
1291 Buffer.BlockCopy (sect.Data, (int) (long) (field.RVA - sect.VirtualAddress), data, 0, size);
1292 field.InitialValue = data;
1294 field.InitialValue = new byte [0];