2002-10-19 Ravi Pratap <ravi@ximian.com>

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

diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs
index 53edbdc9ecb807f3a83ed91eeae3899ded788d6a..3db32ac9da6489dabdf8413799d523126a93821f 100755 (executable)
--- a/mcs/mcs/support.cs
+++ b/mcs/mcs/support.cs
@@ -13,45 +13,59 @@ 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 (a != null)
-                                       if (a.Length != 0)
-                                               last_arg_is_params = true;
-                       } 
+                               if (attrs == null)
+                                       return;
+                               
+                               if (attrs.Length == 0)
+                                       return;
+
+                               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 
                                return pi [pos].ParameterType;
                }
 
+               public string ParameterName (int pos)
+               {
+                       if (last_arg_is_params && pos >= pi.Length - 1)
+                               return pi [pi.Length - 1].Name;
+                       else 
+                               return pi [pos].Name;
+               }
+
                public string ParameterDesc (int pos)
                {
                        StringBuilder sb = new StringBuilder ();
@@ -73,13 +87,15 @@ 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;
-
+                       
                        Type t = pi [pos].ParameterType;
                        if (t.IsByRef)
-                               return Parameter.Modifier.OUT;
+                               return Parameter.Modifier.ISBYREF;
                        
                        return Parameter.Modifier.NONE;
                }
@@ -95,16 +111,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)
                {
                }
 
@@ -122,26 +138,38 @@ namespace Mono.CSharp {
                        if (param_types == null)
                                return null;
 
-                       Parameter [] fixed_pars = parameters.FixedParameters;
+                       Parameter [] fixed_pars = Parameters.FixedParameters;
                        if (fixed_pars != null){
                                int len = fixed_pars.Length;
                                if (pos < len)
-                                       return parameters.FixedParameters [pos].ParameterType;
+                                       return Parameters.FixedParameters [pos].ParameterType;
                                else 
-                                       return parameters.ArrayParameter.ParameterType;
+                                       return Parameters.ArrayParameter.ParameterType;
                        } else
-                               return parameters.ArrayParameter.ParameterType;
+                               return Parameters.ArrayParameter.ParameterType;
+               }
+
+               public string ParameterName (int pos)
+               {
+                       Parameter p;
+
+                       if (pos >= Parameters.FixedParameters.Length)
+                               p = Parameters.ArrayParameter;
+                       else
+                               p = Parameters.FixedParameters [pos];
+
+                       return p.Name;
                }
 
                public string ParameterDesc (int pos)
                {
-                       string tmp = null;
+                       string tmp = String.Empty;
                        Parameter p;
 
-                       if (pos >= parameters.FixedParameters.Length)
-                               p = parameters.ArrayParameter;
+                       if (pos >= Parameters.FixedParameters.Length)
+                               p = Parameters.ArrayParameter;
                        else
-                               p = parameters.FixedParameters [pos];
+                               p = Parameters.FixedParameters [pos];
                        
                        if (p.ModFlags == Parameter.Modifier.REF)
                                tmp = "ref ";
@@ -157,23 +185,22 @@ namespace Mono.CSharp {
 
                public Parameter.Modifier ParameterModifier (int pos)
                {
-                       if (parameters.FixedParameters == null)
-                               return parameters.ArrayParameter.ModFlags;
-                       
-                       if (pos >= parameters.FixedParameters.Length)
-                               return parameters.ArrayParameter.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;
-                       }
+                       Parameter.Modifier mod;
+
+                       if (Parameters.FixedParameters == null) {
+                               if (Parameters.ArrayParameter != null) 
+                                       mod = Parameters.ArrayParameter.ModFlags;
+                               else
+                                       mod = Parameter.Modifier.NONE;
+                       } else if (pos >= Parameters.FixedParameters.Length)
+                               mod = Parameters.ArrayParameter.ModFlags;
+                       else
+                               mod = Parameters.FixedParameters [pos].ModFlags;
+
+                       if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0)
+                               mod |= Parameter.Modifier.ISBYREF;
+
+                       return mod;
                }
                
        }