2003-12-08 Zoltan Varga <vargaz@freemail.hu>

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

diff --git a/mcs/class/corlib/System.Reflection.Emit/SignatureHelper.cs b/mcs/class/corlib/System.Reflection.Emit/SignatureHelper.cs
index 9838728d5413061ba857037e575ccdc5624c35b3..21332ceccbaf0635970b0bd17839b261e02c251c 100755 (executable)
--- a/mcs/class/corlib/System.Reflection.Emit/SignatureHelper.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/SignatureHelper.cs
@@ -16,39 +16,136 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit {
+
        public sealed class SignatureHelper {
-               public static SignatureHelper GetFieldSigHelper (Module mod) {
-                       return null;
+               internal enum SignatureHelperType {
+                       HELPER_FIELD,
+                       HELPER_LOCAL,
+                       HELPER_METHOD,
+                       HELPER_PROPERTY
+               }
+
+               private ModuleBuilder module;
+               private Type[] arguments;
+               private SignatureHelperType type;
+               private Type returnType;
+               private CallingConventions callConv;
+               private CallingConvention unmanagedCallConv;
+
+               internal SignatureHelper (ModuleBuilder module, SignatureHelperType type)
+               {
+                       this.type = type;
+                       this.module = module;
                }
-               public static SignatureHelper GetLocalVarSigHelper( Module mod) {
-                       return null;
+
+               public static SignatureHelper GetFieldSigHelper (Module mod)
+               {
+                       if (!(mod is ModuleBuilder))
+                               throw new NotImplementedException ();
+
+                       return new SignatureHelper ((ModuleBuilder) mod, SignatureHelperType.HELPER_FIELD);
+               }
+
+               public static SignatureHelper GetLocalVarSigHelper (Module mod)
+               {
+                       if (!(mod is ModuleBuilder))
+                               throw new NotImplementedException ();
+
+                       return new SignatureHelper ((ModuleBuilder) mod, SignatureHelperType.HELPER_LOCAL);
+               }
+
+               public static SignatureHelper GetMethodSigHelper( Module mod, CallingConventions callingConvention, Type returnType)
+               {
+                       return GetMethodSigHelper (mod, callingConvention, (CallingConvention)0, returnType, null);
                }
-               public static SignatureHelper GetMethodSigHelper( Module mod, CallingConventions callingConvention, Type returnType) {
-                       return null;
+
+               public static SignatureHelper GetMethodSigHelper( Module mod, CallingConvention unmanagedCallingConvention, Type returnType)
+               {
+                       return GetMethodSigHelper (mod, CallingConventions.Standard, unmanagedCallingConvention, returnType, null);
                }
-               public static SignatureHelper GetMethodSigHelper( Module mod, Type returnType, Type[] parameterTypes) {
-                       return null;
+
+               public static SignatureHelper GetMethodSigHelper( Module mod, Type returnType, Type[] parameterTypes)
+               {
+                       return GetMethodSigHelper (mod, CallingConventions.Standard, 
+                                                                          (CallingConvention)0, returnType, 
+                                                                          parameterTypes);
                }
-               public static SignatureHelper GetPropertySigHelper( Module mod, Type returnType, Type[] parameterTypes) {
-                       return null;
+               [MonoTODO]
+               public static SignatureHelper GetPropertySigHelper( Module mod, Type returnType, Type[] parameterTypes)
+               {
+                       throw new NotImplementedException ();
                }
-               public void AddArgument( Type clsArgument) {
+
+               public void AddArgument (Type clsArgument)
+               {
+                       if (arguments != null) {
+                               Type[] new_a = new Type [arguments.Length + 1];
+                               System.Array.Copy (arguments, new_a, arguments.Length);
+                               new_a [arguments.Length] = clsArgument;
+                               arguments = new_a;
+                       } else {
+                               arguments = new Type [1];
+                               arguments [0] = clsArgument;
+                       }
                }
-               public void AddSentinel() {
+               [MonoTODO]
+               public void AddSentinel ()
+               {
+                       throw new NotImplementedException ();
                }
-               public override bool Equals( object obj) {
-                       return false;
+               [MonoTODO]
+               public override bool Equals (object obj)
+               {
+                       throw new NotImplementedException ();
                }
-               public override int GetHashCode() {
-                       return 0;
+               [MonoTODO]
+               public override int GetHashCode ()
+               {
+                       throw new NotImplementedException ();
                }
-               public byte[] GetSignature() {
-                       return null;
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern byte[] get_signature_local ();
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern byte[] get_signature_field ();
+
+               public byte[] GetSignature ()
+               {
+                       switch (type) {
+                       case SignatureHelperType.HELPER_LOCAL:
+                               return get_signature_local ();
+                       case SignatureHelperType.HELPER_FIELD:
+                               return get_signature_field ();
+                       default:
+                               throw new NotImplementedException ();
+                       }
                }
+
                public override string ToString() {
                        return "SignatureHelper";
                }
 
+               internal static SignatureHelper GetMethodSigHelper( Module mod, CallingConventions callConv, CallingConvention unmanagedCallConv, Type returnType,
+                                                                                                                  Type [] parameters)
+               {
+                       if (!(mod is ModuleBuilder))
+                               throw new NotImplementedException ();
+
+                       SignatureHelper helper = 
+                               new SignatureHelper ((ModuleBuilder)mod, SignatureHelperType.HELPER_METHOD);
+                       helper.returnType = returnType;
+                       helper.callConv = callConv;
+                       helper.unmanagedCallConv = unmanagedCallConv;
+
+                       if (parameters != null) {
+                               helper.arguments = new Type [parameters.Length];
+                               for (int i = 0; i < parameters.Length; ++i)
+                                       helper.arguments [i] = parameters [i];
+                       }
+
+                       return helper;
+               }
 
 
        }