2002-07-02 Martin Baulig <martin@gnome.org>

[mono.git] / mcs / mcs / support.cs

diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs
index 5af0355279f59bace468929e1808069ee2b1d0c1..b62aabd16f8cfb786eee1cb859ccbb7596d9d5df 100755 (executable)
--- a/mcs/mcs/support.cs
+++ b/mcs/mcs/support.cs
@@ -8,12 +8,14 @@
 // (C) 2001 Ximian, Inc (http://www.ximian.com)
 //
 
-using System.Reflection.Emit;
-using System.Reflection;
 using System;
 using System.Text;
+using System.Reflection;
+using System.Collections;
+using System.Reflection.Emit;
+using System.Globalization;
 
-namespace CIR {
+namespace Mono.CSharp {
 
        public interface ParameterData {
                Type ParameterType (int pos);
@@ -24,15 +26,35 @@ namespace CIR {
 
        public class ReflectionParameters : ParameterData {
                ParameterInfo [] pi;
-
+               bool last_arg_is_params = false;
+               
                public ReflectionParameters (ParameterInfo [] pi)
                {
+                       object [] attrs;
+                       
                        this.pi = pi;
+
+                       int count = pi.Length-1;
+
+                       if (count >= 0) {
+                               attrs = pi [count].GetCustomAttributes (TypeManager.param_array_type, true);
+
+                               if (attrs == null)
+                                       return;
+                               
+                               if (attrs.Length == 0)
+                                       return;
+
+                               last_arg_is_params = true;
+                       }
                }
                       
                public Type ParameterType (int pos)
                {
-                       return pi [pos].ParameterType;
+                       if (last_arg_is_params && pos >= pi.Length - 1)
+                               return pi [pi.Length - 1].ParameterType;
+                       else 
+                               return pi [pos].ParameterType;
                }
 
                public string ParameterDesc (int pos)
@@ -45,6 +67,9 @@ namespace CIR {
                        if (pi [pos].IsIn)
                                sb.Append ("in ");
 
+                       if (pos >= pi.Length - 1 && last_arg_is_params)
+                               sb.Append ("params ");
+                       
                        sb.Append (TypeManager.CSharpName (ParameterType (pos)));
 
                        return sb.ToString ();
@@ -53,9 +78,16 @@ namespace CIR {
 
                public Parameter.Modifier ParameterModifier (int pos)
                {
-                       if (pi [pos].IsOut)
+                       int len = pi.Length;
+                       
+                       if (pos >= len - 1)
+                               if (last_arg_is_params)
+                                       return Parameter.Modifier.PARAMS;
+                       
+                       Type t = pi [pos].ParameterType;
+                       if (t.IsByRef)
                                return Parameter.Modifier.OUT;
-
+                       
                        return Parameter.Modifier.NONE;
                }
 
@@ -72,12 +104,17 @@ namespace CIR {
 
                Parameters parameters;
                
-               public InternalParameters (TypeContainer tc, Parameters parameters)
+               public InternalParameters (Type [] param_types, Parameters parameters)
                {
-                       this.param_types = parameters.GetParameterInfo (tc);
+                       this.param_types = param_types;
                        this.parameters = parameters;
                }
 
+               public InternalParameters (DeclSpace ds, Parameters parameters)
+                       : this (parameters.GetParameterInfo (ds), parameters)
+               {
+               }
+
                public int Count {
                        get {
                                if (param_types == null)
@@ -92,29 +129,23 @@ namespace CIR {
                        if (param_types == null)
                                return null;
 
-                       Parameter p;
-                       
-                       if (pos == parameters.FixedParameters.Length)
-                               p = parameters.ArrayParameter;
-                       else
-                               p = parameters.FixedParameters [pos];
-
-                       Type t = param_types [pos];
-                       string name = t.FullName;
-                       
-                       if (p.ModFlags == Parameter.Modifier.REF ||
-                           p.ModFlags == Parameter.Modifier.OUT)
-                               t = Type.GetType (name.Substring (0, name.Length - 1));
-                       
-                       return t;
+                       Parameter [] fixed_pars = parameters.FixedParameters;
+                       if (fixed_pars != null){
+                               int len = fixed_pars.Length;
+                               if (pos < len)
+                                       return parameters.FixedParameters [pos].ParameterType;
+                               else 
+                                       return parameters.ArrayParameter.ParameterType;
+                       } else
+                               return parameters.ArrayParameter.ParameterType;
                }
 
                public string ParameterDesc (int pos)
                {
-                       string tmp = null;
+                       string tmp = String.Empty;
                        Parameter p;
 
-                       if (pos == parameters.FixedParameters.Length)
+                       if (pos >= parameters.FixedParameters.Length)
                                p = parameters.ArrayParameter;
                        else
                                p = parameters.FixedParameters [pos];
@@ -133,11 +164,79 @@ namespace CIR {
 
                public Parameter.Modifier ParameterModifier (int pos)
                {
-                       if (pos == parameters.FixedParameters.Length)
+                       if (parameters.FixedParameters == null) {
+                               if (parameters.ArrayParameter != null) 
+                                       return parameters.ArrayParameter.ModFlags;
+                               else
+                                       return Parameter.Modifier.NONE;
+                       }
+                       
+                       if (pos >= parameters.FixedParameters.Length)
                                return parameters.ArrayParameter.ModFlags;
-                       else
-                               return parameters.FixedParameters [pos].ModFlags;
+                       else {
+                               Parameter.Modifier m = parameters.FixedParameters [pos].ModFlags;
+
+                               //
+                               // We use a return value of "OUT" for "reference" parameters.
+                               // both out and ref flags in the source map to reference parameters.
+                               //
+                               if (m == Parameter.Modifier.OUT || m == Parameter.Modifier.REF)
+                                       return Parameter.Modifier.OUT;
+                               
+                               return Parameter.Modifier.NONE;
+                       }
+               }
+               
+       }
+
+       class PtrHashtable : Hashtable {
+               class PtrComparer : IComparer {
+                       public int Compare (object x, object y)
+                       {
+                               if (x == y)
+                                       return 0;
+                               else
+                                       return 1;
+                       }
                }
                
+               public PtrHashtable ()
+               {
+                       comparer = new PtrComparer ();
+               }
+       }
+
+       //
+       // Compares member infos based on their name and
+       // also allows one argument to be a string
+       //
+       class MemberInfoCompare : IComparer {
+
+               public int Compare (object a, object b)
+               {
+                       if (a == null || b == null){
+                               Console.WriteLine ("Invalid information passed");
+                               throw new Exception ();
+                       }
+                       
+                       if (a is string)
+                               return String.Compare ((string) a, ((MemberInfo)b).Name);
+
+                       if (b is string)
+                               return String.Compare (((MemberInfo)a).Name, (string) b);
+
+                       return String.Compare (((MemberInfo)a).Name, ((MemberInfo)b).Name);
+               }
+       }
+
+       struct Pair {
+               public object First;
+               public object Second;
+               
+               public Pair (object f, object s)
+               {
+                       First = f;
+                       Second = s;
+               }
        }
 }