Fri Jul 12 11:34:58 CEST 2002 Paolo Molaro <lupus@ximian.com>

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

diff --git a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs
index bdfaaf5ec64079d483f64c9c8446afa294fefd59..e00a3b99ba0b40e59b71713138d67a3385fa663b 100755 (executable)
--- a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs
@@ -13,6 +13,7 @@ using System.Reflection;
 using System.Reflection.Emit;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit {
        public sealed class MethodBuilder : MethodInfo {
@@ -20,28 +21,57 @@ namespace System.Reflection.Emit {
                private Type rtype;
                private Type[] parameters;
                private MethodAttributes attrs;
+               private MethodImplAttributes iattrs;
                private string name;
                private int table_idx;
                private byte[] code;
                private ILGenerator ilgen;
-               internal TypeBuilder type;
+               private TypeBuilder type;
                private ParameterBuilder[] pinfo;
+               private CustomAttributeBuilder[] cattrs;
+               private MethodInfo override_method;
+               private string pi_dll;
+               private string pi_entry;
+               private CharSet ncharset;
+               private CallingConvention native_cc;
+               private CallingConventions call_conv;
+               private bool init_locals = true;
 
                internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) {
                        this.name = name;
                        this.attrs = attributes;
-                       // call conv
+                       this.call_conv = callingConvention;
                        this.rtype = returnType;
                        if (parameterTypes != null) {
                                this.parameters = new Type [parameterTypes.Length];
                                System.Array.Copy (parameterTypes, this.parameters, parameterTypes.Length);
                        }
                        type = tb;
-                       table_idx = tb.module.assemblyb.get_next_table_index (0x06, true);
+                       table_idx = get_next_table_index (this, 0x06, true);
+                       //Console.WriteLine ("index for "+name+" set to "+table_idx.ToString());
+               }
+
+               internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, 
+                       CallingConventions callingConvention, Type returnType, Type[] parameterTypes, 
+                       String dllName, String entryName, CallingConvention nativeCConv, CharSet nativeCharset) 
+                       : this (tb, name, attributes, callingConvention, returnType, parameterTypes) {
+                       pi_dll = dllName;
+                       pi_entry = entryName;
+                       native_cc = nativeCConv;
+                       ncharset = nativeCharset;
+               }
+
+               public bool InitLocals {
+                       get {return init_locals;}
+                       set {init_locals = value;}
+               }
+
+               internal TypeBuilder TypeBuilder {
+                       get {return type;}
                }
                
                public override Type ReturnType {get {return rtype;}}
-               public override Type ReflectedType {get {return null;}}
+               public override Type ReflectedType {get {return type;}}
                public override Type DeclaringType {get {return type;}}
                public override string Name {get {return name;}}
                public override RuntimeMethodHandle MethodHandle {get {return mhandle;}}
@@ -57,16 +87,23 @@ namespace System.Reflection.Emit {
                        return null;
                }
                public override MethodImplAttributes GetMethodImplementationFlags() {
-                       return (MethodImplAttributes)0;
+                       return iattrs;
                }
                public override ParameterInfo[] GetParameters() {
-                       return null;
+                       if ((parameters == null) || (pinfo == null))
+                               return null;
+
+                       ParameterInfo[] retval = new ParameterInfo [parameters.Length];
+                       for (int i = 1; i < parameters.Length + 1; i++) {
+                               if (pinfo [i] == null)
+                                       return null;
+
+                               retval [i - 1] = new ParameterInfo (pinfo [i], parameters [i - 1], this);
+                       }
+
+                       return retval;
                }
                
-               /*
-                * FIXME: this method signature needs to be expanded to handle also
-                * a ILGenerator.
-                */
                public void CreateMethodBody( byte[] il, int count) {
                        code = new byte [count];
                        System.Array.Copy(il, code, count);
@@ -90,10 +127,15 @@ namespace System.Reflection.Emit {
                        ilgen = new ILGenerator (this, size);
                        return ilgen;
                }
-
-               public ParameterBuilder DefineParameter( int position, ParameterAttributes attributes, string strParamName) {
+               
+               [MonoTODO]
+               public ParameterBuilder DefineParameter (int position, ParameterAttributes attributes, string strParamName)
+               {
                        ParameterBuilder pb = new ParameterBuilder (this, position, attributes, strParamName);
-                       /* FIXME: add it to pinfo */
+                       // check position
+                       if (pinfo == null)
+                               pinfo = new ParameterBuilder [parameters.Length + 1];
+                       pinfo [position] = pb;
                        return pb;
                }
 
@@ -101,6 +143,40 @@ namespace System.Reflection.Emit {
                        if (ilgen != null)
                                ilgen.label_fixup ();
                }
+
+               public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
+                       string attrname = customBuilder.Ctor.ReflectedType.FullName;
+                       if (attrname == "System.Runtime.CompilerServices.MethodImplAttribute") {
+                               byte[] data = customBuilder.Data;
+                               int impla; // the (stupid) ctor takes a short or an int ... 
+                               impla = (int)data [2];
+                               impla |= ((int)data [3]) << 8;
+                               SetImplementationFlags ((MethodImplAttributes)impla);
+                               return;
+                       }
+                       if (cattrs != null) {
+                               CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
+                               cattrs.CopyTo (new_array, 0);
+                               new_array [cattrs.Length] = customBuilder;
+                               cattrs = new_array;
+                       } else {
+                               cattrs = new CustomAttributeBuilder [1];
+                               cattrs [0] = customBuilder;
+                       }
+               }
+               public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
+                       SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
+               }
+               public void SetImplementationFlags( MethodImplAttributes attributes) {
+                       iattrs = attributes;
+               }
+               internal override int get_next_table_index (object obj, int table, bool inc) {
+                       return type.get_next_table_index (obj, table, inc);
+               }
+
+               internal void set_override (MethodInfo mdecl) {
+                       override_method = mdecl;
+               }
        }
 }