mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs

   1 //
   2 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 //
  23
  24 //
  25 // System.Reflection.Emit/ModuleBuilder.cs
  26 //
  27 // Author:
  28 //   Paolo Molaro (lupus@ximian.com)
  29 //
  30 // (C) 2001 Ximian, Inc.  http://www.ximian.com
  31 //
  32
  33 #if !FULL_AOT_RUNTIME
  34 using System;
  35 using System.Reflection;
  36 using System.Collections;
  37 using System.Collections.Generic;
  38 using System.Runtime.CompilerServices;
  39 using System.Runtime.InteropServices;
  40 using System.Diagnostics.SymbolStore;
  41 using System.IO;
  42 using System.Resources;
  43 using System.Globalization;
  44
  45 namespace System.Reflection.Emit {
  46         [ComVisible (true)]
  47         [ComDefaultInterface (typeof (_ModuleBuilder))]
  48         [ClassInterface (ClassInterfaceType.None)]
  49         [StructLayout (LayoutKind.Sequential)]
  50         public class ModuleBuilder : Module, _ModuleBuilder {
  51
  52 #pragma warning disable 169, 414
  53                 #region Sync with object-internals.h
  54                 private UIntPtr dynamic_image; /* GC-tracked */
  55                 private int num_types;
  56                 private TypeBuilder[] types;
  57                 private CustomAttributeBuilder[] cattrs;
  58                 private byte[] guid;
  59                 private int table_idx;
  60                 internal AssemblyBuilder assemblyb;
  61                 private MethodBuilder[] global_methods;
  62                 private FieldBuilder[] global_fields;
  63                 bool is_main;
  64                 private MonoResource[] resources;
  65                 private IntPtr unparented_classes;
  66                 #endregion
  67 #pragma warning restore 169, 414
  68
  69                 private TypeBuilder global_type;
  70                 private Type global_type_created;
  71                 // name_cache keys are display names
  72                 Dictionary<TypeName, TypeBuilder> name_cache;
  73                 Dictionary<string, int> us_string_cache;
  74                 private int[] table_indexes;
  75                 bool transient;
  76                 ModuleBuilderTokenGenerator token_gen;
  77                 Hashtable resource_writers;
  78                 ISymbolWriter symbolWriter;
  79
  80                 static bool has_warned_about_symbolWriter;
  81
  82                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  83                 private static extern void basic_init (ModuleBuilder ab);
  84
  85                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  86                 private static extern void set_wrappers_type (ModuleBuilder mb, Type ab);
  87
  88                 internal ModuleBuilder (AssemblyBuilder assb, string name, string fullyqname, bool emitSymbolInfo, bool transient) {
  89                         this.name = this.scopename = name;
  90                         this.fqname = fullyqname;
  91                         this.assembly = this.assemblyb = assb;
  92                         this.transient = transient;
  93                         // to keep mcs fast we do not want CryptoConfig wo be involved to create the RNG
  94                         guid = Guid.FastNewGuidArray ();
  95                         // guid = Guid.NewGuid().ToByteArray ();
  96                         table_idx = get_next_table_index (this, 0x00, true);
  97                         name_cache = new Dictionary<TypeName, TypeBuilder> ();
  98                         us_string_cache = new Dictionary<string, int> (512);
  99
 100                         basic_init (this);
 101
 102                         CreateGlobalType ();
 103
 104                         if (assb.IsRun) {
 105                                 TypeBuilder tb = new TypeBuilder (this, TypeAttributes.Abstract, 0xFFFFFF); /*last valid token*/
 106                                 Type type = tb.CreateType ();
 107                                 set_wrappers_type (this, type);
 108                         }
 109
 110                         if (emitSymbolInfo) {
 111                                 Assembly asm = Assembly.LoadWithPartialName ("Mono.CompilerServices.SymbolWriter");
 112
 113                                 Type t = null;
 114                                 if (asm != null)
 115                                         t = asm.GetType ("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl");
 116
 117                                 if (t == null) {
 118                                         WarnAboutSymbolWriter ("Failed to load the default Mono.CompilerServices.SymbolWriter assembly");
 119                                 } else {
 120                                         try {
 121                                                 symbolWriter = (ISymbolWriter) Activator.CreateInstance (t, new object[] { this });
 122                                         } catch (System.MissingMethodException) {
 123                                                 WarnAboutSymbolWriter ("The default Mono.CompilerServices.SymbolWriter is not available on this platform");
 124                                                 return;
 125                                         }
 126                                 }
 127
 128                                 string fileName = fqname;
 129                                 if (assemblyb.AssemblyDir != null)
 130                                         fileName = Path.Combine (assemblyb.AssemblyDir, fileName);
 131                                 symbolWriter.Initialize (IntPtr.Zero, fileName, true);
 132                         }
 133                 }
 134
 135                 static void WarnAboutSymbolWriter (string message)
 136                 {
 137                         if (has_warned_about_symbolWriter)
 138                                 return;
 139
 140                         has_warned_about_symbolWriter = true;
 141                         Console.Error.WriteLine ("WARNING: {0}", message);
 142                 }
 143
 144                 public override string FullyQualifiedName {get { return fqname;}}
 145
 146                 public bool IsTransient () {
 147                         return transient;
 148                 }
 149
 150                 public void CreateGlobalFunctions ()
 151                 {
 152                         if (global_type_created != null)
 153                                 throw new InvalidOperationException ("global methods already created");
 154                         if (global_type != null)
 155                                 global_type_created = global_type.CreateType ();
 156                 }
 157
 158                 public FieldBuilder DefineInitializedData( string name, byte[] data, FieldAttributes attributes) {
 159                         if (data == null)
 160                                 throw new ArgumentNullException ("data");
 161
 162                         var maskedAttributes = attributes & ~FieldAttributes.ReservedMask;
 163                         FieldBuilder fb = DefineDataImpl (name, data.Length, maskedAttributes | FieldAttributes.HasFieldRVA);
 164                         fb.SetRVAData (data);
 165
 166                         return fb;
 167                 }
 168
 169                 public FieldBuilder DefineUninitializedData (string name, int size, FieldAttributes attributes)
 170                 {
 171                         return DefineDataImpl (name, size, attributes & ~FieldAttributes.ReservedMask);
 172                 }
 173
 174                 private FieldBuilder DefineDataImpl (string name, int size, FieldAttributes attributes)
 175                 {
 176                         if (name == null)
 177                                 throw new ArgumentNullException ("name");
 178                         if (name == String.Empty)
 179                                 throw new ArgumentException ("name cannot be empty", "name");
 180                         if (global_type_created != null)
 181                                 throw new InvalidOperationException ("global fields already created");
 182                         if ((size <= 0) || (size >= 0x3f0000))
 183                                 throw new ArgumentException ("Data size must be > 0 and < 0x3f0000", null as string);
 184
 185                         CreateGlobalType ();
 186
 187                         string typeName = "$ArrayType$" + size;
 188                         Type datablobtype = GetType (typeName, false, false);
 189                         if (datablobtype == null) {
 190                                 TypeBuilder tb = DefineType (typeName,
 191                                     TypeAttributes.Public|TypeAttributes.ExplicitLayout|TypeAttributes.Sealed,
 192                                         assemblyb.corlib_value_type, null, PackingSize.Size1, size);
 193                                 tb.CreateType ();
 194                                 datablobtype = tb;
 195                         }
 196                         FieldBuilder fb = global_type.DefineField (name, datablobtype, attributes|FieldAttributes.Static);
 197
 198                         if (global_fields != null) {
 199                                 FieldBuilder[] new_fields = new FieldBuilder [global_fields.Length+1];
 200                                 System.Array.Copy (global_fields, new_fields, global_fields.Length);
 201                                 new_fields [global_fields.Length] = fb;
 202                                 global_fields = new_fields;
 203                         } else {
 204                                 global_fields = new FieldBuilder [1];
 205                                 global_fields [0] = fb;
 206                         }
 207                         return fb;
 208                 }
 209
 210                 private void addGlobalMethod (MethodBuilder mb) {
 211                         if (global_methods != null) {
 212                                 MethodBuilder[] new_methods = new MethodBuilder [global_methods.Length+1];
 213                                 System.Array.Copy (global_methods, new_methods, global_methods.Length);
 214                                 new_methods [global_methods.Length] = mb;
 215                                 global_methods = new_methods;
 216                         } else {
 217                                 global_methods = new MethodBuilder [1];
 218                                 global_methods [0] = mb;
 219                         }
 220                 }
 221
 222                 public MethodBuilder DefineGlobalMethod (string name, MethodAttributes attributes, Type returnType, Type[] parameterTypes)
 223                 {
 224                         return DefineGlobalMethod (name, attributes, CallingConventions.Standard, returnType, parameterTypes);
 225                 }
 226
 227                 public MethodBuilder DefineGlobalMethod (string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) {
 228                         return DefineGlobalMethod (name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
 229                 }
 230
 231                 public MethodBuilder DefineGlobalMethod (string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
 232                 {
 233                         if (name == null)
 234                                 throw new ArgumentNullException ("name");
 235                         if ((attributes & MethodAttributes.Static) == 0)
 236                                 throw new ArgumentException ("global methods must be static");
 237                         if (global_type_created != null)
 238                                 throw new InvalidOperationException ("global methods already created");
 239                         CreateGlobalType ();
 240                         MethodBuilder mb = global_type.DefineMethod (name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
 241
 242                         addGlobalMethod (mb);
 243                         return mb;
 244                 }
 245
 246                 public MethodBuilder DefinePInvokeMethod (string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) {
 247                         return DefinePInvokeMethod (name, dllName, name, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
 248                 }
 249
 250                 public MethodBuilder DefinePInvokeMethod (string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) {
 251                         if (name == null)
 252                                 throw new ArgumentNullException ("name");
 253                         if ((attributes & MethodAttributes.Static) == 0)
 254                                 throw new ArgumentException ("global methods must be static");
 255                         if (global_type_created != null)
 256                                 throw new InvalidOperationException ("global methods already created");
 257                         CreateGlobalType ();
 258                         MethodBuilder mb = global_type.DefinePInvokeMethod (name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
 259
 260                         addGlobalMethod (mb);
 261                         return mb;
 262                 }
 263
 264                 public TypeBuilder DefineType (string name) {
 265                         return DefineType (name, 0);
 266                 }
 267
 268                 public TypeBuilder DefineType (string name, TypeAttributes attr) {
 269                         if ((attr & TypeAttributes.Interface) != 0)
 270                                 return DefineType (name, attr, null, null);
 271                         return DefineType (name, attr, typeof(object), null);
 272                 }
 273
 274                 public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent) {
 275                         return DefineType (name, attr, parent, null);
 276                 }
 277
 278                 private void AddType (TypeBuilder tb)
 279                 {
 280                         if (types != null) {
 281                                 if (types.Length == num_types) {
 282                                         TypeBuilder[] new_types = new TypeBuilder [types.Length * 2];
 283                                         System.Array.Copy (types, new_types, num_types);
 284                                         types = new_types;
 285                                 }
 286                         } else {
 287                                 types = new TypeBuilder [1];
 288                         }
 289                         types [num_types] = tb;
 290                         num_types ++;
 291                 }
 292
 293                 private TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, Type[] interfaces, PackingSize packingSize, int typesize) {
 294                         if (name == null)
 295                                 throw new ArgumentNullException ("fullname");
 296                         TypeIdentifier ident = TypeIdentifiers.FromInternal (name);
 297                         if (name_cache.ContainsKey (ident))
 298                                 throw new ArgumentException ("Duplicate type name within an assembly.");
 299                         TypeBuilder res = new TypeBuilder (this, name, attr, parent, interfaces, packingSize, typesize, null);
 300                         AddType (res);
 301
 302                         name_cache.Add (ident, res);
 303
 304                         return res;
 305                 }
 306
 307                 internal void RegisterTypeName (TypeBuilder tb, TypeName name)
 308                 {
 309                         name_cache.Add (name, tb);
 310                 }
 311
 312                 internal TypeBuilder GetRegisteredType (TypeName name)
 313                 {
 314                         TypeBuilder result = null;
 315                         name_cache.TryGetValue (name, out result);
 316                         return result;
 317                 }
 318
 319                 [ComVisible (true)]
 320                 public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, Type[] interfaces) {
 321                         return DefineType (name, attr, parent, interfaces, PackingSize.Unspecified, TypeBuilder.UnspecifiedTypeSize);
 322                 }
 323
 324                 public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, int typesize) {
 325                         return DefineType (name, attr, parent, null, PackingSize.Unspecified, typesize);
 326                 }
 327
 328                 public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, PackingSize packsize) {
 329                         return DefineType (name, attr, parent, null, packsize, TypeBuilder.UnspecifiedTypeSize);
 330                 }
 331
 332                 public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, PackingSize packingSize, int typesize) {
 333                         return DefineType (name, attr, parent, null, packingSize, typesize);
 334                 }
 335
 336                 public MethodInfo GetArrayMethod( Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) {
 337                         return new MonoArrayMethod (arrayClass, methodName, callingConvention, returnType, parameterTypes);
 338                 }
 339
 340                 public EnumBuilder DefineEnum( string name, TypeAttributes visibility, Type underlyingType) {
 341                         TypeIdentifier ident = TypeIdentifiers.FromInternal (name);
 342                         if (name_cache.ContainsKey (ident))
 343                                 throw new ArgumentException ("Duplicate type name within an assembly.");
 344
 345                         EnumBuilder eb = new EnumBuilder (this, name, visibility, underlyingType);
 346                         TypeBuilder res = eb.GetTypeBuilder ();
 347                         AddType (res);
 348                         name_cache.Add (ident, res);
 349                         return eb;
 350                 }
 351
 352                 [ComVisible (true)]
 353                 public override Type GetType( string className) {
 354                         return GetType (className, false, false);
 355                 }
 356
 357                 [ComVisible (true)]
 358                 public override Type GetType( string className, bool ignoreCase) {
 359                         return GetType (className, false, ignoreCase);
 360                 }
 361
 362                 private TypeBuilder search_in_array (TypeBuilder[] arr, int validElementsInArray, TypeName className) {
 363                         int i;
 364                         for (i = 0; i < validElementsInArray; ++i) {
 365                                 if (String.Compare (className.DisplayName, arr [i].FullName, true, CultureInfo.InvariantCulture) == 0) {
 366                                         return arr [i];
 367                                 }
 368                         }
 369                         return null;
 370                 }
 371
 372                 private TypeBuilder search_nested_in_array (TypeBuilder[] arr, int validElementsInArray, TypeName className) {
 373                         int i;
 374                         for (i = 0; i < validElementsInArray; ++i) {
 375                                 if (String.Compare (className.DisplayName, arr [i].Name, true, CultureInfo.InvariantCulture) == 0)
 376                                         return arr [i];
 377                         }
 378                         return null;
 379                 }
 380
 381                 private TypeBuilder GetMaybeNested (TypeBuilder t, IEnumerable<TypeName> nested) {
 382                         TypeBuilder result = t;
 383
 384                         foreach (TypeName pname in nested) {
 385                                 if (result.subtypes == null)
 386                                         return null;
 387                                 result = search_nested_in_array(result.subtypes, result.subtypes.Length, pname);
 388                                 if (result == null)
 389                                         return null;
 390                         }
 391                         return result;
 392                 }
 393
 394                 [ComVisible (true)]
 395                 public override Type GetType (string className, bool throwOnError, bool ignoreCase)
 396                 {
 397                         if (className == null)
 398                                 throw new ArgumentNullException ("className");
 399                         if (className.Length == 0)
 400                                 throw new ArgumentException ("className");
 401
 402                         TypeBuilder result = null;
 403
 404                         if (types == null && throwOnError)
 405                                 throw new TypeLoadException (className);
 406
 407                         TypeSpec ts = TypeSpec.Parse (className);
 408
 409                         if (!ignoreCase) {
 410                                 var displayNestedName = ts.TypeNameWithoutModifiers();
 411                                 name_cache.TryGetValue (displayNestedName, out result);
 412                         } else {
 413                                 if (types != null)
 414                                         result = search_in_array (types, num_types,  ts.Name);
 415                                 if (!ts.IsNested && result != null) {
 416                                         result = GetMaybeNested (result, ts.Nested);
 417                                 }
 418                         }
 419                         if ((result == null) && throwOnError)
 420                                 throw new TypeLoadException (className);
 421                         if (result != null && (ts.HasModifiers || ts.IsByRef)) {
 422                                 Type mt = result;
 423                                 if (result is TypeBuilder) {
 424                                         var tb = result as TypeBuilder;
 425                                         if (tb.is_created)
 426                                                 mt = tb.CreateType ();
 427                                 }
 428                                 foreach (var mod in ts.Modifiers) {
 429                                         if (mod is PointerSpec)
 430                                                 mt = mt.MakePointerType ();
 431                                         else if (mod is ArraySpec) {
 432                                                 var spec = mod as ArraySpec;
 433                                                 if (spec.IsBound)
 434                                                         return null;
 435                                                 if (spec.Rank == 1)
 436                                                         mt = mt.MakeArrayType ();
 437                                                 else
 438                                                         mt = mt.MakeArrayType (spec.Rank);
 439                                         }
 440                                 }
 441                                 if (ts.IsByRef)
 442                                         mt = mt.MakeByRefType ();
 443                                 result = mt as TypeBuilder;
 444                                 if (result == null)
 445                                         return mt;
 446                         }
 447                         if (result != null && result.is_created)
 448                                 return result.CreateType ();
 449                         else
 450                                 return result;
 451                 }
 452
 453                 internal int get_next_table_index (object obj, int table, bool inc) {
 454                         if (table_indexes == null) {
 455                                 table_indexes = new int [64];
 456                                 for (int i=0; i < 64; ++i)
 457                                         table_indexes [i] = 1;
 458                                 /* allow room for .<Module> in TypeDef table */
 459                                 table_indexes [0x02] = 2;
 460                         }
 461                         // Console.WriteLine ("getindex for table "+table.ToString()+" got "+table_indexes [table].ToString());
 462                         if (inc)
 463                                 return table_indexes [table]++;
 464                         return table_indexes [table];
 465                 }
 466
 467                 public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
 468                         if (cattrs != null) {
 469                                 CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
 470                                 cattrs.CopyTo (new_array, 0);
 471                                 new_array [cattrs.Length] = customBuilder;
 472                                 cattrs = new_array;
 473                         } else {
 474                                 cattrs = new CustomAttributeBuilder [1];
 475                                 cattrs [0] = customBuilder;
 476                         }
 477                 }
 478
 479                 [ComVisible (true)]
 480                 public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
 481                         SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
 482                 }
 483
 484                 public ISymbolWriter GetSymWriter () {
 485                         return symbolWriter;
 486                 }
 487
 488                 public ISymbolDocumentWriter DefineDocument (string url, Guid language, Guid languageVendor, Guid documentType)
 489                 {
 490                         if (symbolWriter != null)
 491                                 return symbolWriter.DefineDocument (url, language, languageVendor, documentType);
 492                         else
 493                                 return null;
 494                 }
 495
 496                 public override Type [] GetTypes ()
 497                 {
 498                         if (types == null)
 499                                 return Type.EmptyTypes;
 500
 501                         int n = num_types;
 502                         Type [] copy = new Type [n];
 503                         Array.Copy (types, copy, n);
 504
 505                         // MS replaces the typebuilders with their created types
 506                         for (int i = 0; i < copy.Length; ++i)
 507                                 if (types [i].is_created)
 508                                         copy [i] = types [i].CreateType ();
 509
 510                         return copy;
 511                 }
 512
 513                 public IResourceWriter DefineResource (string name, string description, ResourceAttributes attribute)
 514                 {
 515                         if (name == null)
 516                                 throw new ArgumentNullException ("name");
 517                         if (name == String.Empty)
 518                                 throw new ArgumentException ("name cannot be empty");
 519                         if (transient)
 520                                 throw new InvalidOperationException ("The module is transient");
 521                         if (!assemblyb.IsSave)
 522                                 throw new InvalidOperationException ("The assembly is transient");
 523                         ResourceWriter writer = new ResourceWriter (new MemoryStream ());
 524                         if (resource_writers == null)
 525                                 resource_writers = new Hashtable ();
 526                         resource_writers [name] = writer;
 527
 528                         // The data is filled out later
 529                         if (resources != null) {
 530                                 MonoResource[] new_r = new MonoResource [resources.Length + 1];
 531                                 System.Array.Copy(resources, new_r, resources.Length);
 532                                 resources = new_r;
 533                         } else {
 534                                 resources = new MonoResource [1];
 535                         }
 536                         int p = resources.Length - 1;
 537                         resources [p].name = name;
 538                         resources [p].attrs = attribute;
 539
 540                         return writer;
 541                 }
 542
 543                 public IResourceWriter DefineResource (string name, string description)
 544                 {
 545                         return DefineResource (name, description, ResourceAttributes.Public);
 546                 }
 547
 548                 [MonoTODO]
 549                 public void DefineUnmanagedResource (byte[] resource)
 550                 {
 551                         if (resource == null)
 552                                 throw new ArgumentNullException ("resource");
 553
 554                         throw new NotImplementedException ();
 555                 }
 556
 557                 [MonoTODO]
 558                 public void DefineUnmanagedResource (string resourceFileName)
 559                 {
 560                         if (resourceFileName == null)
 561                                 throw new ArgumentNullException ("resourceFileName");
 562                         if (resourceFileName == String.Empty)
 563                                 throw new ArgumentException ("resourceFileName");
 564                         if (!File.Exists (resourceFileName) || Directory.Exists (resourceFileName))
 565                                 throw new FileNotFoundException ("File '" + resourceFileName + "' does not exist or is a directory.");
 566
 567                         throw new NotImplementedException ();
 568                 }
 569
 570                 public void DefineManifestResource (string name, Stream stream, ResourceAttributes attribute) {
 571                         if (name == null)
 572                                 throw new ArgumentNullException ("name");
 573                         if (name == String.Empty)
 574                                 throw new ArgumentException ("name cannot be empty");
 575                         if (stream == null)
 576                                 throw new ArgumentNullException ("stream");
 577                         if (transient)
 578                                 throw new InvalidOperationException ("The module is transient");
 579                         if (!assemblyb.IsSave)
 580                                 throw new InvalidOperationException ("The assembly is transient");
 581
 582                         if (resources != null) {
 583                                 MonoResource[] new_r = new MonoResource [resources.Length + 1];
 584                                 System.Array.Copy(resources, new_r, resources.Length);
 585                                 resources = new_r;
 586                         } else {
 587                                 resources = new MonoResource [1];
 588                         }
 589                         int p = resources.Length - 1;
 590                         resources [p].name = name;
 591                         resources [p].attrs = attribute;
 592                         resources [p].stream = stream;
 593                 }
 594
 595                 [MonoTODO]
 596                 public void SetSymCustomAttribute (string name, byte[] data)
 597                 {
 598                         throw new NotImplementedException ();
 599                 }
 600
 601                 [MonoTODO]
 602                 public void SetUserEntryPoint (MethodInfo entryPoint)
 603                 {
 604                         if (entryPoint == null)
 605                                 throw new ArgumentNullException ("entryPoint");
 606                         if (entryPoint.DeclaringType.Module != this)
 607                                 throw new InvalidOperationException ("entryPoint is not contained in this module");
 608                         throw new NotImplementedException ();
 609                 }
 610
 611                 public MethodToken GetMethodToken (MethodInfo method)
 612                 {
 613                         if (method == null)
 614                                 throw new ArgumentNullException ("method");
 615
 616                         return new MethodToken (GetToken (method));
 617                 }
 618
 619                 public MethodToken GetMethodToken (MethodInfo method, IEnumerable<Type> optionalParameterTypes)
 620                 {
 621                         if (method == null)
 622                                 throw new ArgumentNullException ("method");
 623
 624                         return new MethodToken (GetToken (method, optionalParameterTypes));
 625                 }
 626
 627                 public MethodToken GetArrayMethodToken (Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
 628                 {
 629                         return GetMethodToken (GetArrayMethod (arrayClass, methodName, callingConvention, returnType, parameterTypes));
 630                 }
 631
 632                 [ComVisible (true)]
 633                 public MethodToken GetConstructorToken (ConstructorInfo con)
 634                 {
 635                         if (con == null)
 636                                 throw new ArgumentNullException ("con");
 637
 638                         return new MethodToken (GetToken (con));
 639                 }
 640
 641                 public MethodToken GetConstructorToken (ConstructorInfo constructor, IEnumerable<Type> optionalParameterTypes)
 642                 {
 643                         if (constructor == null)
 644                                 throw new ArgumentNullException ("constructor");
 645
 646                         return new MethodToken (GetToken (constructor, optionalParameterTypes));
 647                 }
 648
 649                 public FieldToken GetFieldToken (FieldInfo field)
 650                 {
 651                         if (field == null)
 652                                 throw new ArgumentNullException ("field");
 653
 654                         return new FieldToken (GetToken (field));
 655                 }
 656
 657                 [MonoTODO]
 658                 public SignatureToken GetSignatureToken (byte[] sigBytes, int sigLength)
 659                 {
 660                         throw new NotImplementedException ();
 661                 }
 662
 663                 public SignatureToken GetSignatureToken (SignatureHelper sigHelper)
 664                 {
 665                         if (sigHelper == null)
 666                                 throw new ArgumentNullException ("sigHelper");
 667                         return new SignatureToken (GetToken (sigHelper));
 668                 }
 669
 670                 public StringToken GetStringConstant (string str)
 671                 {
 672                         if (str == null)
 673                                 throw new ArgumentNullException ("str");
 674                         return new StringToken (GetToken (str));
 675                 }
 676
 677                 public TypeToken GetTypeToken (Type type)
 678                 {
 679                         if (type == null)
 680                                 throw new ArgumentNullException ("type");
 681                         if (type.IsByRef)
 682                                 throw new ArgumentException ("type can't be a byref type", "type");
 683                         if (!IsTransient () && (type.Module is ModuleBuilder) && ((ModuleBuilder)type.Module).IsTransient ())
 684                                 throw new InvalidOperationException ("a non-transient module can't reference a transient module");
 685                         return new TypeToken (GetToken (type));
 686                 }
 687
 688                 public TypeToken GetTypeToken (string name)
 689                 {
 690                         return GetTypeToken (GetType (name));
 691                 }
 692
 693                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 694                 private static extern int getUSIndex (ModuleBuilder mb, string str);
 695
 696                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 697                 private static extern int getToken (ModuleBuilder mb, object obj, bool create_open_instance);
 698
 699                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 700                 private static extern int getMethodToken (ModuleBuilder mb, MethodBase method,
 701                                                           Type[] opt_param_types);
 702
 703                 internal int GetToken (string str)
 704                 {
 705                         int result;
 706                         if (!us_string_cache.TryGetValue (str, out result)) {
 707                                 result = getUSIndex (this, str);
 708                                 us_string_cache [str] = result;
 709                         }
 710
 711                         return result;
 712                 }
 713
 714                 static int typeref_tokengen =  0x01ffffff;
 715                 static int typedef_tokengen =  0x02ffffff;
 716                 static int typespec_tokengen =  0x1bffffff;
 717                 static int memberref_tokengen =  0x0affffff;
 718                 static int methoddef_tokengen =  0x06ffffff;
 719                 Dictionary<MemberInfo, int> inst_tokens, inst_tokens_open;
 720
 721                 //
 722                 // Assign a pseudo token to the various TypeBuilderInst objects, so the runtime
 723                 // doesn't have to deal with them.
 724                 // For Save assemblies, the tokens will be fixed up later during Save ().
 725                 // For Run assemblies, the tokens will not be fixed up, so the runtime will
 726                 // still encounter these objects, it will resolve them by calling their
 727                 // RuntimeResolve () methods.
 728                 //
 729                 int GetPseudoToken (MemberInfo member, bool create_open_instance)
 730                 {
 731                         int token;
 732                         var dict = create_open_instance ? inst_tokens_open : inst_tokens;
 733                         if (dict == null) {
 734                                 dict = new Dictionary<MemberInfo, int> (ReferenceEqualityComparer<MemberInfo>.Instance);
 735                                 if (create_open_instance)
 736                                         inst_tokens_open = dict;
 737                                 else
 738                                         inst_tokens = dict;
 739                         } else if (dict.TryGetValue (member, out token)) {
 740                                 return token;
 741                         }
 742
 743                         // Count backwards to avoid collisions with the tokens
 744                         // allocated by the runtime
 745                         if (member is TypeBuilderInstantiation || member is SymbolType)
 746                                 token = typespec_tokengen --;
 747                         else if (member is FieldOnTypeBuilderInst)
 748                                 token = memberref_tokengen --;
 749                         else if (member is ConstructorOnTypeBuilderInst)
 750                                 token = memberref_tokengen --;
 751                         else if (member is MethodOnTypeBuilderInst)
 752                                 token = memberref_tokengen --;
 753                         else if (member is FieldBuilder)
 754                                 token = memberref_tokengen --;
 755                         else if (member is TypeBuilder) {
 756                                 if (create_open_instance && (member as TypeBuilder).ContainsGenericParameters)
 757                                         token = typespec_tokengen --;
 758                                 else if (member.Module == this)
 759                                         token = typedef_tokengen --;
 760                                 else
 761                                         token = typeref_tokengen --;
 762                         } else if (member is EnumBuilder) {
 763                                 token = GetPseudoToken ((member as  EnumBuilder).GetTypeBuilder(), create_open_instance);
 764                                 dict[member] = token;
 765                                 // n.b. don't register with the runtime, the TypeBuilder already did it.
 766                                 return token;
 767                         } else if (member is ConstructorBuilder) {
 768                                 if (member.Module == this && !(member as ConstructorBuilder).TypeBuilder.ContainsGenericParameters)
 769                                         token = methoddef_tokengen --;
 770                                 else
 771                                         token = memberref_tokengen --;
 772                         } else if (member is MethodBuilder) {
 773                                 var mb = member as MethodBuilder;
 774                                 if (member.Module == this && !mb.TypeBuilder.ContainsGenericParameters && !mb.IsGenericMethodDefinition)
 775                                         token = methoddef_tokengen --;
 776                                 else
 777                                         token = memberref_tokengen --;
 778                         } else if (member is GenericTypeParameterBuilder) {
 779                                 token = typespec_tokengen --;
 780                         } else
 781                                 throw new NotImplementedException ();
 782
 783                         dict [member] = token;
 784                         RegisterToken (member, token);
 785                         return token;
 786                 }
 787
 788                 internal int GetToken (MemberInfo member) {
 789                         if (member is ConstructorBuilder || member is MethodBuilder)
 790                                 return GetPseudoToken (member, false);
 791                         return getToken (this, member, true);
 792                 }
 793
 794                 internal int GetToken (MemberInfo member, bool create_open_instance) {
 795                         if (member is TypeBuilderInstantiation || member is FieldOnTypeBuilderInst || member is ConstructorOnTypeBuilderInst || member is MethodOnTypeBuilderInst || member is SymbolType || member is FieldBuilder || member is TypeBuilder || member is ConstructorBuilder || member is MethodBuilder || member is GenericTypeParameterBuilder ||
 796                             member is EnumBuilder)
 797                                 return GetPseudoToken (member, create_open_instance);
 798                         return getToken (this, member, create_open_instance);
 799                 }
 800
 801                 internal int GetToken (MethodBase method, IEnumerable<Type> opt_param_types) {
 802                         if (method is ConstructorBuilder || method is MethodBuilder)
 803                                 return GetPseudoToken (method, false);
 804
 805                         if (opt_param_types == null)
 806                                 return getToken (this, method, true);
 807
 808                         var optParamTypes = new List<Type> (opt_param_types);
 809                         return  getMethodToken (this, method, optParamTypes.ToArray ());
 810                 }
 811
 812                 internal int GetToken (MethodBase method, Type[] opt_param_types) {
 813                         if (method is ConstructorBuilder || method is MethodBuilder)
 814                                 return GetPseudoToken (method, false);
 815                         return getMethodToken (this, method, opt_param_types);
 816                 }
 817
 818                 internal int GetToken (SignatureHelper helper) {
 819                         return getToken (this, helper, true);
 820                 }
 821
 822                 /*
 823                  * Register the token->obj mapping with the runtime so the Module.Resolve...
 824                  * methods will work for obj.
 825                  */
 826                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 827                 internal extern void RegisterToken (object obj, int token);
 828
 829                 /*
 830                  * Returns MemberInfo registered with the given token.
 831                  */
 832                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 833                 internal extern object GetRegisteredToken (int token);
 834
 835                 internal TokenGenerator GetTokenGenerator () {
 836                         if (token_gen == null)
 837                                 token_gen = new ModuleBuilderTokenGenerator (this);
 838                         return token_gen;
 839                 }
 840
 841                 // Called from the runtime to return the corresponding finished reflection object
 842                 internal static object RuntimeResolve (object obj) {
 843                         if (obj is MethodBuilder)
 844                                 return (obj as MethodBuilder).RuntimeResolve ();
 845                         if (obj is ConstructorBuilder)
 846                                 return (obj as ConstructorBuilder).RuntimeResolve ();
 847                         if (obj is FieldBuilder)
 848                                 return (obj as FieldBuilder).RuntimeResolve ();
 849                         if (obj is GenericTypeParameterBuilder)
 850                                 return (obj as GenericTypeParameterBuilder).RuntimeResolve ();
 851                         if (obj is FieldOnTypeBuilderInst)
 852                                 return (obj as FieldOnTypeBuilderInst).RuntimeResolve ();
 853                         if (obj is MethodOnTypeBuilderInst)
 854                                 return (obj as MethodOnTypeBuilderInst).RuntimeResolve ();
 855                         if (obj is ConstructorOnTypeBuilderInst)
 856                                 return (obj as ConstructorOnTypeBuilderInst).RuntimeResolve ();
 857                         if (obj is Type)
 858                                 return (obj as Type).RuntimeResolve ();
 859                         throw new NotImplementedException (obj.GetType ().FullName);
 860                 }
 861
 862                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 863                 private static extern void build_metadata (ModuleBuilder mb);
 864
 865                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 866                 private extern void WriteToFile (IntPtr handle);
 867
 868                 void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map, Dictionary<MemberInfo, int> inst_tokens,
 869                                                   bool open) {
 870                         foreach (var v in inst_tokens) {
 871                                 var member = v.Key;
 872                                 var old_token = v.Value;
 873                                 MemberInfo finished = null;
 874
 875                                 // Construct the concrete reflection object corresponding to the
 876                                 // TypeBuilderInst object, and request a token for it instead.
 877                                 if (member is TypeBuilderInstantiation || member is SymbolType) {
 878                                         finished = (member as Type).RuntimeResolve ();
 879                                 } else if (member is FieldOnTypeBuilderInst) {
 880                                         finished = (member as FieldOnTypeBuilderInst).RuntimeResolve ();
 881                                 } else if (member is ConstructorOnTypeBuilderInst) {
 882                                         finished = (member as ConstructorOnTypeBuilderInst).RuntimeResolve ();
 883                                 } else if (member is MethodOnTypeBuilderInst) {
 884                                         finished = (member as MethodOnTypeBuilderInst).RuntimeResolve ();
 885                                 } else if (member is FieldBuilder) {
 886                                         finished = (member as FieldBuilder).RuntimeResolve ();
 887                                 } else if (member is TypeBuilder) {
 888                                         finished = (member as TypeBuilder).RuntimeResolve ();
 889                                 } else if (member is EnumBuilder) {
 890                                         finished = (member as EnumBuilder).RuntimeResolve ();
 891                                 } else if (member is ConstructorBuilder) {
 892                                         finished = (member as ConstructorBuilder).RuntimeResolve ();
 893                                 } else if (member is MethodBuilder) {
 894                                         finished = (member as MethodBuilder).RuntimeResolve ();
 895                                 } else if (member is GenericTypeParameterBuilder) {
 896                                         finished = (member as GenericTypeParameterBuilder).RuntimeResolve ();
 897                                 } else {
 898                                         throw new NotImplementedException ();
 899                                 }
 900
 901                                 int new_token = GetToken (finished, open);
 902                                 token_map [old_token] = new_token;
 903                                 member_map [old_token] = finished;
 904                                 // Replace the token mapping in the runtime so it points to the new object
 905                                 RegisterToken (finished, old_token);
 906                         }
 907                 }
 908
 909                 //
 910                 // Fixup the pseudo tokens assigned to the various SRE objects
 911                 //
 912                 void FixupTokens ()
 913                 {
 914                         var token_map = new Dictionary<int, int> ();
 915                         var member_map = new Dictionary<int, MemberInfo> ();
 916                         if (inst_tokens != null)
 917                                 FixupTokens (token_map, member_map, inst_tokens, false);
 918                         if (inst_tokens_open != null)
 919                                 FixupTokens (token_map, member_map, inst_tokens_open, true);
 920
 921                         // Replace the tokens in the IL stream
 922                         if (types != null) {
 923                                 for (int i = 0; i < num_types; ++i)
 924                                         types [i].FixupTokens (token_map, member_map);
 925                         }
 926                 }
 927
 928                 internal void Save ()
 929                 {
 930                         if (transient && !is_main)
 931                                 return;
 932
 933                         if (types != null) {
 934                                 for (int i = 0; i < num_types; ++i)
 935                                         if (!types [i].is_created)
 936                                                 throw new NotSupportedException ("Type '" + types [i].FullName + "' was not completed.");
 937                         }
 938
 939                         FixupTokens ();
 940
 941                         if ((global_type != null) && (global_type_created == null))
 942                                 global_type_created = global_type.CreateType ();
 943
 944                         if (resources != null) {
 945                                 for (int i = 0; i < resources.Length; ++i) {
 946                                         IResourceWriter rwriter;
 947                                         if (resource_writers != null && (rwriter = resource_writers [resources [i].name] as IResourceWriter) != null) {
 948                                                 ResourceWriter writer = (ResourceWriter)rwriter;
 949                                                 writer.Generate ();
 950                                                 MemoryStream mstream = (MemoryStream)writer._output;
 951                                                 resources [i].data = new byte [mstream.Length];
 952                                                 mstream.Seek (0, SeekOrigin.Begin);
 953                                                 mstream.Read (resources [i].data, 0, (int)mstream.Length);
 954                                                 continue;
 955                                         }
 956                                         Stream stream = resources [i].stream;
 957
 958                                         // According to MSDN docs, the stream is read during assembly save, not earlier
 959                                         if (stream != null) {
 960                                                 try {
 961                                                         long len = stream.Length;
 962                                                         resources [i].data = new byte [len];
 963                                                         stream.Seek (0, SeekOrigin.Begin);
 964                                                         stream.Read (resources [i].data, 0, (int)len);
 965                                                 } catch {
 966                                                         /* do something */
 967                                                 }
 968                                         }
 969                                 }
 970                         }
 971
 972                         build_metadata (this);
 973
 974                         string fileName = fqname;
 975                         if (assemblyb.AssemblyDir != null)
 976                                 fileName = Path.Combine (assemblyb.AssemblyDir, fileName);
 977
 978                         try {
 979                                 // We mmap the file, so unlink the previous version since it may be in use
 980                                 File.Delete (fileName);
 981                         } catch {
 982                                 // We can safely ignore
 983                         }
 984                         using (FileStream file = new FileStream (fileName, FileMode.Create, FileAccess.Write))
 985                                 WriteToFile (file.Handle);
 986
 987                         //
 988                         // The constant 0x80000000 is internal to Mono, it means `make executable'
 989                         //
 990                         File.SetAttributes (fileName, (FileAttributes) (unchecked ((int) 0x80000000)));
 991
 992                         if (types != null && symbolWriter != null) {
 993                                 for (int i = 0; i < num_types; ++i)
 994                                         types [i].GenerateDebugInfo (symbolWriter);
 995                                 symbolWriter.Close ();
 996                         }
 997                 }
 998
 999                 internal string FileName {
1000                         get {
1001                                 return fqname;
1002                         }
1003                 }
1004
1005                 internal bool IsMain {
1006                         set {
1007                                 is_main = value;
1008                         }
1009                 }
1010
1011                 internal void CreateGlobalType () {
1012                         if (global_type == null)
1013                                 global_type = new TypeBuilder (this, 0, 1);
1014                 }
1015
1016                 internal override Guid GetModuleVersionId ()
1017                 {
1018                         return new Guid (guid);
1019                 }
1020
1021                 // Used by mcs, the symbol writer, and mdb through reflection
1022                 internal static Guid Mono_GetGuid (ModuleBuilder mb)
1023                 {
1024                         return mb.GetModuleVersionId ();
1025                 }
1026
1027                 void _ModuleBuilder.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
1028                 {
1029                         throw new NotImplementedException ();
1030                 }
1031
1032                 void _ModuleBuilder.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
1033                 {
1034                         throw new NotImplementedException ();
1035                 }
1036
1037                 void _ModuleBuilder.GetTypeInfoCount (out uint pcTInfo)
1038                 {
1039                         throw new NotImplementedException ();
1040                 }
1041
1042                 void _ModuleBuilder.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
1043                 {
1044                         throw new NotImplementedException ();
1045                 }
1046
1047                 public override Assembly Assembly {
1048                         get { return assemblyb; }
1049                 }
1050
1051                 public override string Name {
1052                         get { return name; }
1053                 }
1054
1055                 public override string ScopeName {
1056                         get { return name; }
1057                 }
1058
1059                 public override Guid ModuleVersionId {
1060                         get {
1061                                 return GetModuleVersionId ();
1062                         }
1063                 }
1064
1065                 //XXX resource modules can't be defined with ModuleBuilder
1066                 public override bool IsResource ()
1067                 {
1068                         return false;
1069                 }
1070
1071                 protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
1072                 {
1073                         if (global_type_created == null)
1074                                 return null;
1075                         if (types == null)
1076                                 return global_type_created.GetMethod (name);
1077                         return global_type_created.GetMethod (name, bindingAttr, binder, callConvention, types, modifiers);
1078                 }
1079
1080                 public override FieldInfo ResolveField (int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments) {
1081                         ResolveTokenError error;
1082
1083                         IntPtr handle = ResolveFieldToken (_impl, metadataToken, ptrs_from_types (genericTypeArguments), ptrs_from_types (genericMethodArguments), out error);
1084                         if (handle == IntPtr.Zero)
1085                                 throw resolve_token_exception (metadataToken, error, "Field");
1086                         else
1087                                 return FieldInfo.GetFieldFromHandle (new RuntimeFieldHandle (handle));
1088                 }
1089
1090                 public override MemberInfo ResolveMember (int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments) {
1091
1092                         ResolveTokenError error;
1093
1094                         MemberInfo m = ResolveMemberToken (_impl, metadataToken, ptrs_from_types (genericTypeArguments), ptrs_from_types (genericMethodArguments), out error);
1095                         if (m == null)
1096                                 throw resolve_token_exception (metadataToken, error, "MemberInfo");
1097                         else
1098                                 return m;
1099                 }
1100
1101                 internal MemberInfo ResolveOrGetRegisteredToken (int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments)
1102                 {
1103                         ResolveTokenError error;
1104                         MemberInfo m = ResolveMemberToken (_impl, metadataToken, ptrs_from_types (genericTypeArguments), ptrs_from_types (genericMethodArguments), out error);
1105                         if (m != null)
1106                                 return m;
1107
1108                         m = GetRegisteredToken (metadataToken) as MemberInfo;
1109                         if (m == null)
1110                                 throw resolve_token_exception (metadataToken, error, "MemberInfo");
1111                         else
1112                                 return m;
1113                 }
1114
1115                 public override MethodBase ResolveMethod (int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments) {
1116                         ResolveTokenError error;
1117
1118                         IntPtr handle = ResolveMethodToken (_impl, metadataToken, ptrs_from_types (genericTypeArguments), ptrs_from_types (genericMethodArguments), out error);
1119                         if (handle == IntPtr.Zero)
1120                                 throw resolve_token_exception (metadataToken, error, "MethodBase");
1121                         else
1122                                 return MethodBase.GetMethodFromHandleNoGenericCheck (new RuntimeMethodHandle (handle));
1123                 }
1124
1125                 public override string ResolveString (int metadataToken) {
1126                         ResolveTokenError error;
1127
1128                         string s = ResolveStringToken (_impl, metadataToken, out error);
1129                         if (s == null)
1130                                 throw resolve_token_exception (metadataToken, error, "string");
1131                         else
1132                                 return s;
1133                 }
1134
1135                 public override byte[] ResolveSignature (int metadataToken) {
1136                         ResolveTokenError error;
1137
1138                     byte[] res = ResolveSignature (_impl, metadataToken, out error);
1139                         if (res == null)
1140                                 throw resolve_token_exception (metadataToken, error, "signature");
1141                         else
1142                                 return res;
1143                 }
1144
1145                 public override Type ResolveType (int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments) {
1146                         ResolveTokenError error;
1147
1148                         IntPtr handle = ResolveTypeToken (_impl, metadataToken, ptrs_from_types (genericTypeArguments), ptrs_from_types (genericMethodArguments), out error);
1149                         if (handle == IntPtr.Zero)
1150                                 throw resolve_token_exception (metadataToken, error, "Type");
1151                         else
1152                                 return Type.GetTypeFromHandle (new RuntimeTypeHandle (handle));
1153                 }
1154
1155                 public override bool Equals (object obj)
1156                 {
1157                         return base.Equals (obj);
1158                 }
1159
1160                 public override int GetHashCode ()
1161                 {
1162                         return base.GetHashCode ();
1163                 }
1164
1165                 public override bool IsDefined (Type attributeType, bool inherit)
1166                 {
1167                         return base.IsDefined (attributeType, inherit);
1168                 }
1169
1170                 public override object[] GetCustomAttributes (bool inherit)
1171                 {
1172                         return base.GetCustomAttributes (inherit);
1173                 }
1174
1175                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
1176                 {
1177                         return base.GetCustomAttributes (attributeType, inherit);
1178                 }
1179
1180                 public override FieldInfo GetField (string name, BindingFlags bindingAttr)
1181                 {
1182                         return base.GetField (name, bindingAttr);
1183                 }
1184
1185                 public override FieldInfo[] GetFields (BindingFlags bindingFlags)
1186                 {
1187                         return base.GetFields (bindingFlags);
1188                 }
1189
1190                 public override MethodInfo[] GetMethods (BindingFlags bindingFlags)
1191                 {
1192                         return base.GetMethods (bindingFlags);
1193                 }
1194
1195                 public override int MetadataToken {
1196                         get {
1197                                 return base.MetadataToken;
1198                         }
1199                 }
1200         }
1201
1202         internal class ModuleBuilderTokenGenerator : TokenGenerator {
1203
1204                 private ModuleBuilder mb;
1205
1206                 public ModuleBuilderTokenGenerator (ModuleBuilder mb) {
1207                         this.mb = mb;
1208                 }
1209
1210                 public int GetToken (string str) {
1211                         return mb.GetToken (str);
1212                 }
1213
1214                 public int GetToken (MemberInfo member, bool create_open_instance) {
1215                         return mb.GetToken (member, create_open_instance);
1216                 }
1217
1218                 public int GetToken (MethodBase method, Type[] opt_param_types) {
1219                         return mb.GetToken (method, opt_param_types);
1220                 }
1221
1222                 public int GetToken (SignatureHelper helper) {
1223                         return mb.GetToken (helper);
1224                 }
1225         }
1226 }
1227
1228 #endif