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