2002-12-20 Gonzalo Paniagua Javier <gonzalo@ximian.com>

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

diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs
index 02aa36b6ff9ac867a21999b10564b46bcb3f5b10..93ff972d7b60667a42c4d49292b26d687cbbb21a 100755 (executable)
--- a/mcs/mcs/support.cs
+++ b/mcs/mcs/support.cs
@@ -13,43 +13,62 @@ using System.Text;
 using System.Reflection;
 using System.Collections;
 using System.Reflection.Emit;
+using System.Globalization;
 
 namespace Mono.CSharp {
 
        public interface ParameterData {
                Type ParameterType (int pos);
                int  Count { get; }
+               string ParameterName (int pos);
                string ParameterDesc (int pos);
                Parameter.Modifier ParameterModifier (int pos);
        }
 
        public class ReflectionParameters : ParameterData {
                ParameterInfo [] pi;
-               bool last_arg_is_params;
+               bool last_arg_is_params = false;
                
                public ReflectionParameters (ParameterInfo [] pi)
                {
-                       object [] a;
+                       object [] attrs;
                        
                        this.pi = pi;
-
                        int count = pi.Length-1;
 
-                       if (count > 0) {
-                               a = pi [count].GetCustomAttributes (TypeManager.param_array_type, false);
+                       if (count >= 0) {
+                               attrs = pi [count].GetCustomAttributes (TypeManager.param_array_type, true);
+
+                               if (attrs == null)
+                                       return;
+                               
+                               if (attrs.Length == 0)
+                                       return;
 
-                               if (a != null)
-                                       if (a.Length != 0)
-                                               last_arg_is_params = true;
-                       } 
+                               last_arg_is_params = true;
+                       }
                }
                       
                public Type ParameterType (int pos)
                {
                        if (last_arg_is_params && pos >= pi.Length - 1)
-                               return pi [pi.Length -1].ParameterType;
+                               return pi [pi.Length - 1].ParameterType;
+                       else {
+                               Type t = pi [pos].ParameterType;
+
+                               if (t.IsByRef)
+                                       return t.GetElementType ();
+                               else
+                                       return t;
+                       }
+               }
+
+               public string ParameterName (int pos)
+               {
+                       if (last_arg_is_params && pos >= pi.Length - 1)
+                               return pi [pi.Length - 1].Name;
                        else 
-                               return pi [pos].ParameterType;
+                               return pi [pos].Name;
                }
 
                public string ParameterDesc (int pos)
@@ -62,7 +81,7 @@ namespace Mono.CSharp {
                        if (pi [pos].IsIn)
                                sb.Append ("in ");
 
-                       if (pos == pi.Length - 1)
+                       if (pos >= pi.Length - 1 && last_arg_is_params)
                                sb.Append ("params ");
                        
                        sb.Append (TypeManager.CSharpName (ParameterType (pos)));
@@ -73,12 +92,19 @@ namespace Mono.CSharp {
 
                public Parameter.Modifier ParameterModifier (int pos)
                {
-                       if (pos >= pi.Length - 1) 
+                       int len = pi.Length;
+
+                       if (pos >= len - 1)
                                if (last_arg_is_params)
                                        return Parameter.Modifier.PARAMS;
-
-                       if (pi [pos].IsOut)
-                               return Parameter.Modifier.OUT;
+                       
+                       Type t = pi [pos].ParameterType;
+                       if (t.IsByRef){
+                               if ((pi [pos].Attributes & ParameterAttributes.Out) != 0)
+                                       return Parameter.Modifier.ISBYREF | Parameter.Modifier.OUT;
+                               else
+                                       return Parameter.Modifier.ISBYREF | Parameter.Modifier.REF;
+                       }
                        
                        return Parameter.Modifier.NONE;
                }
@@ -94,16 +120,16 @@ namespace Mono.CSharp {
        public class InternalParameters : ParameterData {
                Type [] param_types;
 
-               Parameters parameters;
+               public readonly Parameters Parameters;
                
                public InternalParameters (Type [] param_types, Parameters parameters)
                {
                        this.param_types = param_types;
-                       this.parameters = parameters;
+                       this.Parameters = parameters;
                }
 
-               public InternalParameters (TypeContainer tc, Parameters parameters)
-                       : this (parameters.GetParameterInfo (tc), parameters)
+               public InternalParameters (DeclSpace ds, Parameters parameters)
+                       : this (parameters.GetParameterInfo (ds), parameters)
                {
                }
 
@@ -116,37 +142,44 @@ namespace Mono.CSharp {
                        }
                }
 
+               Parameter GetParameter (int pos)
+               {
+                       Parameter [] fixed_pars = Parameters.FixedParameters;
+                       if (fixed_pars != null){
+                               int len = fixed_pars.Length;
+                               if (pos < len)
+                                       return Parameters.FixedParameters [pos];
+                       }
+
+                       return Parameters.ArrayParameter;
+               }
+
                public Type ParameterType (int pos)
                {
                        if (param_types == null)
                                return null;
 
-                       int len = parameters.FixedParameters.Length;
+                       return GetParameter (pos).ParameterType;
+               }
 
-                       if (pos < len)
-                               return parameters.FixedParameters [pos].ParameterType;
-                       else 
-                               return parameters.ArrayParameter.ParameterType;
 
-                       //
-                       // Return the internal type.
-                       //
-                       //return p.ParameterType;
+               public string ParameterName (int pos)
+               {
+                       return GetParameter (pos).Name;
                }
 
                public string ParameterDesc (int pos)
                {
-                       string tmp = null;
-                       Parameter p;
+                       string tmp = String.Empty;
+                       Parameter p = GetParameter (pos);
 
-                       if (pos >= parameters.FixedParameters.Length)
-                               p = parameters.ArrayParameter;
-                       else
-                               p = parameters.FixedParameters [pos];
-                       
-                       if (p.ModFlags == Parameter.Modifier.REF)
+                       //
+                       // We need to and for REF/OUT, because if either is set the
+                       // extra flag ISBYREF will be set as well
+                       //
+                       if ((p.ModFlags & Parameter.Modifier.REF) != 0)
                                tmp = "ref ";
-                       else if (p.ModFlags == Parameter.Modifier.OUT)
+                       else if ((p.ModFlags & Parameter.Modifier.OUT) != 0)
                                tmp = "out ";
                        else if (p.ModFlags == Parameter.Modifier.PARAMS)
                                tmp = "params ";
@@ -158,10 +191,12 @@ namespace Mono.CSharp {
 
                public Parameter.Modifier ParameterModifier (int pos)
                {
-                       if (pos >= parameters.FixedParameters.Length)
-                               return parameters.ArrayParameter.ModFlags;
-                       else
-                               return parameters.FixedParameters [pos].ModFlags;
+                       Parameter.Modifier mod = GetParameter (pos).ModFlags;
+
+                       if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0)
+                               mod |= Parameter.Modifier.ISBYREF;
+
+                       return mod;
                }
                
        }
@@ -211,9 +246,10 @@ namespace Mono.CSharp {
                public object Second;
                
                public Pair (object f, object s)
-                       {
-                               First = f;
-                               Second = s;
-                       }
+               {
+                       First = f;
+                       Second = s;
+               }
        }
+
 }