2006-08-17 Atsushi Enomoto <atsushi@ximian.com>

[mono.git] / mcs / mbas / parameter.cs

diff --git a/mcs/mbas/parameter.cs b/mcs/mbas/parameter.cs
index b21b78ab51ee99f3e700ecafdc3c1bfadc71499b..5350497e138d4b29c66f3900f85b5ac8eeeed952 100644 (file)
--- a/mcs/mbas/parameter.cs
+++ b/mcs/mbas/parameter.cs
@@ -28,7 +28,7 @@ namespace Mono.MonoBASIC {
                        NONE    = 0,
                        VAL     = 0,
                        REF     = 1,
-                       OUT     = 2,
+//                     OUT     = 2,
                        PARAMS  = 4,
                        // This is a flag which says that it's either REF or OUT.
                        ISBYREF = 8,
@@ -39,7 +39,7 @@ namespace Mono.MonoBASIC {
                public readonly Modifier ModFlags;
                public readonly string Name;
                public Type parameter_type;
-               public readonly Expression ParameterInitializer;
+               public Expression ParameterInitializer;
                public readonly bool IsOptional;
 
                public Parameter (Expression type, string name, Modifier mod, Attributes attrs)
@@ -123,14 +123,16 @@ namespace Mono.MonoBASIC {
                
                public ParameterAttributes Attributes {
                        get {
-                               int flags = ((int) ModFlags) & ~((int) Parameter.Modifier.ISBYREF);
+                               int flags = ((int) ModFlags) & ~((int) Parameter.Modifier.ISBYREF | (int) Parameter.Modifier.REF);
                                switch ((Modifier) flags) {
                                case Modifier.NONE:
                                        return ParameterAttributes.None;
                                case Modifier.REF:
                                        return ParameterAttributes.None;
+/*
                                case Modifier.OUT:
                                        return ParameterAttributes.Out;
+*/
                                case Modifier.OPTIONAL:
                                        return ParameterAttributes.Optional;
                                case Modifier.PARAMS:
@@ -155,29 +157,47 @@ namespace Mono.MonoBASIC {
                        return ExternalType (ds, loc).FullName;
                }
 
-               public void DefineParameter (EmitContext ec, MethodBuilder mb, ConstructorBuilder cb, int index, Location loc)
+               public bool DefineParameter (EmitContext ec, MethodBuilder mb, ConstructorBuilder cb, int index, Location loc)
                {
                        if (mb == null)
                                builder = cb.DefineParameter (index, Attributes, Name);
                        else 
                                builder = mb.DefineParameter (index, Attributes, Name);
 
-                       if (ParameterInitializer != null)       {
+                       if (ParameterInitializer != null) {
                                if (ParameterInitializer is MemberAccess) {
                                        MemberAccess ma = ParameterInitializer as MemberAccess;
 
-                                       Expression const_ex = ma.Resolve(ec);
-                                       if (const_ex is EnumConstant)
-                                               builder.SetConstant (((EnumConstant) const_ex).Child.GetValue());
-                                       else
-                                               Report.Error(-1, "Internal error - Non supported argument type in optional parameter");
+                                       ParameterInitializer = ma.Resolve(ec);
+                               } else 
+                                       ParameterInitializer = ParameterInitializer.Resolve (ec);
+
+                               if (ParameterInitializer == null) {
+                                       Report.Error(-1, "Internal error - Non supported argument type in optional parameter");
+                                       return false;
                                }
-                               else
-                                       builder.SetConstant (((Constant) ParameterInitializer).GetValue());
+
+                               if (parameter_type != ParameterInitializer.Type) {
+                                       Expression conv = Expression.ConvertImplicit (ec, ParameterInitializer, parameter_type, loc);
+                                       if (conv == null) {
+                                               Report.Error (30439, loc, "Constant expression '" + ParameterInitializer + "' not representable in type '" + parameter_type + "'");
+                                               return false;
+                                       }
+                                       ParameterInitializer = conv;
+                               }
+
+                               if (!(ParameterInitializer is Constant)) {
+                                       Report.Error (30059, loc, "Constant expression is required");
+                                       return false;
+                               }
+
+                               builder.SetConstant (((Constant) ParameterInitializer).GetValue());
+
                        }
 
                        if (OptAttributes != null)
                                OptAttributes.Emit (ec, this);
+                       return true;
                }
        }
 
@@ -345,13 +365,13 @@ namespace Mono.MonoBASIC {
                                string base_name = FixedParameters [i].Name;
                                
                                for (j = i + 1; j < count; j++){
-                                       if (base_name != FixedParameters [j].Name)
+                                       if (base_name.ToLower () != FixedParameters [j].Name.ToLower ())
                                                continue;
                                        Error_DuplicateParameterName (base_name);
                                        return false;
                                }
 
-                               if (base_name == array_par_name){
+                               if ((array_par_name != null) && (base_name.ToLower () == array_par_name.ToLower ())) {
                                        Error_DuplicateParameterName (base_name);
                                        return false;
                                }
@@ -383,7 +403,7 @@ namespace Mono.MonoBASIC {
 
                        if (FixedParameters != null){
                                foreach (Parameter par in FixedParameters){
-                                       if (par.Name == name){
+                                       if (par.Name.ToLower() == name.ToLower()) {
                                                idx = i;
                                                return par;
                                        }
@@ -392,7 +412,7 @@ namespace Mono.MonoBASIC {
                        }
 
                        if (ArrayParameter != null){
-                               if (name == ArrayParameter.Name){
+                               if (name.ToLower () == ArrayParameter.Name.ToLower ()) {
                                        idx = i;
                                        return ArrayParameter;
                                }
@@ -561,7 +581,7 @@ namespace Mono.MonoBASIC {
                        Parameter p = FixedParameters [idx];
                        mod = p.ModFlags;
 
-                       if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0)
+                       if ((mod & (Parameter.Modifier.REF )) != 0)
                                mod |= Parameter.Modifier.ISBYREF;
 
                        return p.ParameterType;