Ooops.

[mono.git] / mcs / class / corlib / System.Reflection.Emit / ModuleBuilder.cs

diff --git a/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs
index abc01249b8c7b9006f74bd357d8297e75dedb59b..3925bcb9f4e0f225bc6bd1a7b53376fcbafcff0e 100644 (file)
--- a/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs
@@ -42,6 +42,11 @@ using System.Resources;
 using System.Globalization;
 
 namespace System.Reflection.Emit {
+#if NET_2_0
+       [ComVisible (true)]
+       [ClassInterfaceAttribute (ClassInterfaceType.None)]
+       [ComDefaultInterfaceAttribute (typeof (_ModuleBuilder))]
+#endif
        public class ModuleBuilder : Module {
                #region Sync with reflection.h
                private IntPtr dynamic_image;
@@ -64,6 +69,7 @@ namespace System.Reflection.Emit {
                bool transient;
                ModuleBuilderTokenGenerator token_gen;
                ArrayList resource_writers = null;
+               ISymbolWriter symbolWriter;
 
                [MethodImplAttribute(MethodImplOptions.InternalCall)]
                private static extern void basic_init (ModuleBuilder ab);
@@ -82,6 +88,18 @@ namespace System.Reflection.Emit {
                        basic_init (this);
 
                        CreateGlobalType ();
+                       
+                       if (emitSymbolInfo) {
+                               Assembly asm = Assembly.LoadWithPartialName ("Mono.CompilerServices.SymbolWriter");
+                               Type t = asm.GetType ("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl");
+                               if (t != null) {
+                                       symbolWriter = (ISymbolWriter) Activator.CreateInstance (t, new object[] { this });
+                                       string fileName = fqname;
+                                       if (assemblyb.AssemblyDir != null)
+                                               fileName = Path.Combine (assemblyb.AssemblyDir, fileName);
+                                       symbolWriter.Initialize (IntPtr.Zero, fileName, true);
+                               }
+                       }
                }
 
                public override string FullyQualifiedName {get { return fqname;}}
@@ -206,6 +224,8 @@ namespace System.Reflection.Emit {
                }
 
                public TypeBuilder DefineType (string name, TypeAttributes attr) {
+                       if ((attr & TypeAttributes.Interface) != 0)
+                               return DefineType (name, attr, null, null);
                        return DefineType (name, attr, typeof(object), null);
                }
 
@@ -213,11 +233,8 @@ namespace System.Reflection.Emit {
                        return DefineType (name, attr, parent, null);
                }
 
-               private TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, Type[] interfaces, PackingSize packsize, int typesize) {
-                       if (name_cache.Contains (name))
-                               throw new ArgumentException ("Duplicate type name within an assembly.");
-
-                       TypeBuilder res = new TypeBuilder (this, name, attr, parent, interfaces, packsize, typesize, null);
+               private void AddType (TypeBuilder tb)
+               {
                        if (types != null) {
                                if (types.Length == num_types) {
                                        TypeBuilder[] new_types = new TypeBuilder [types.Length * 2];
@@ -227,8 +244,16 @@ namespace System.Reflection.Emit {
                        } else {
                                types = new TypeBuilder [1];
                        }
-                       types [num_types] = res;
+                       types [num_types] = tb;
                        num_types ++;
+               }
+
+               private TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, Type[] interfaces, PackingSize packsize, int typesize) {
+                       if (name_cache.Contains (name))
+                               throw new ArgumentException ("Duplicate type name within an assembly.");
+
+                       TypeBuilder res = new TypeBuilder (this, name, attr, parent, interfaces, packsize, typesize, null);
+                       AddType (res);
                        name_cache.Add (name, res);
                        return res;
                }
@@ -237,6 +262,9 @@ namespace System.Reflection.Emit {
                        name_cache.Add (name, tb);
                }
 
+#if NET_2_0
+               [ComVisible (true)]
+#endif
                public TypeBuilder DefineType (string name, TypeAttributes attr, Type parent, Type[] interfaces) {
                        return DefineType (name, attr, parent, interfaces, PackingSize.Unspecified, TypeBuilder.UnspecifiedTypeSize);
                }
@@ -258,14 +286,26 @@ namespace System.Reflection.Emit {
                }
 
                public EnumBuilder DefineEnum( string name, TypeAttributes visibility, Type underlyingType) {
+                       if (name_cache.Contains (name))
+                               throw new ArgumentException ("Duplicate type name within an assembly.");
+
                        EnumBuilder eb = new EnumBuilder (this, name, visibility, underlyingType);
+                       TypeBuilder res = eb.GetTypeBuilder ();
+                       AddType (res);
+                       name_cache.Add (name, res);
                        return eb;
                }
 
+#if NET_2_0
+               [ComVisible (true)]
+#endif
                public override Type GetType( string className) {
                        return GetType (className, false, false);
                }
                
+#if NET_2_0
+               [ComVisible (true)]
+#endif
                public override Type GetType( string className, bool ignoreCase) {
                        return GetType (className, false, ignoreCase);
                }
@@ -313,7 +353,10 @@ namespace System.Reflection.Emit {
                        }
                        return null;
                }
-               
+
+#if NET_2_0
+               [ComVisible (true)]
+#endif         
                public override Type GetType (string className, bool throwOnError, bool ignoreCase) {
                        int subt;
                        string orig = className;
@@ -378,16 +421,24 @@ namespace System.Reflection.Emit {
                                cattrs [0] = customBuilder;
                        }
                }
+
+#if NET_2_0
+               [ComVisible (true)]
+#endif
                public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
                        SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
                }
 
                public ISymbolWriter GetSymWriter () {
-                       return null;
+                       return symbolWriter;
                }
 
-               public ISymbolDocumentWriter DefineDocument (string url, Guid language, Guid languageVendor, Guid documentType) {
-                       return null;
+               public ISymbolDocumentWriter DefineDocument (string url, Guid language, Guid languageVendor, Guid documentType)
+               {
+                       if (symbolWriter != null)
+                               return symbolWriter.DefineDocument (url, language, languageVendor, documentType);
+                       else
+                               return null;
                }
 
                public override Type [] GetTypes ()
@@ -489,7 +540,9 @@ namespace System.Reflection.Emit {
                        return GetMethodToken (GetArrayMethod (arrayClass, methodName, callingConvention, returnType, parameterTypes));
                }
 
-
+#if NET_2_0
+               [ComVisible (true)]
+#endif
                public MethodToken GetConstructorToken (ConstructorInfo con)
                {
                        if (con == null)
@@ -622,6 +675,12 @@ namespace System.Reflection.Emit {
                        // The constant 0x80000000 is internal to Mono, it means `make executable'
                        //
                        File.SetAttributes (fileName, (FileAttributes) (unchecked ((int) 0x80000000)));
+                       
+                       if (types != null && symbolWriter != null) {
+                               for (int i = 0; i < num_types; ++i)
+                                       types [i].GenerateDebugInfo (symbolWriter);
+                               symbolWriter.Close ();
+                       }
                }
 
                internal string FileName {
@@ -672,3 +731,4 @@ namespace System.Reflection.Emit {
                }
        }
 }
+