fix for different results message

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

diff --git a/mcs/mbas/expression.cs b/mcs/mbas/expression.cs
index dca56559c789ad5a4409ea36d84529487e022fe8..8a9c2bbc3c0c49ef297ab18053b8519123f152dd 100644 (file)
--- a/mcs/mbas/expression.cs
+++ b/mcs/mbas/expression.cs
@@ -1643,7 +1643,7 @@ namespace Mono.MonoBASIC {
                public enum Operator : byte {
                        Exponentiation,
                        Multiply, Division, IntDivision, Modulus,
-                       Addition, Subtraction,
+                       Addition, Subtraction, Concat,
                        LeftShift, RightShift,
                        LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual, 
                        Equality, Inequality,
@@ -2610,6 +2610,10 @@ namespace Mono.MonoBASIC {
 
                public override Expression DoResolve (EmitContext ec)
                {
+                       if (oper == Operator.Concat) {
+                               Expression e = new StringConcat (loc, left, right);
+                               return e.Resolve (ec);
+                       }
                        left = left.Resolve (ec);
                        right = right.Resolve (ec);
 
@@ -3304,8 +3308,9 @@ namespace Mono.MonoBASIC {
                {
                        VariableInfo vi = VariableInfo;
 
-                       if (ec.DoFlowAnalysis)
+                       if (ec.DoFlowAnalysis) {
                                ec.SetVariableAssigned (vi);
+                       }
 
                        Expression e = DoResolve (ec);
 
@@ -3325,7 +3330,24 @@ namespace Mono.MonoBASIC {
                        VariableInfo vi = VariableInfo;
                        ILGenerator ig = ec.ig;
 
-                       ig.Emit (OpCodes.Ldloc, vi.LocalBuilder);
+                       if (vi.Alias != null && vi.Static) {
+                               ArrayList fields = ec.TypeContainer.Fields;
+                               FieldBase fb = null;
+                               for (int i = 0; i < fields.Count; i++) {
+                                       if (((Field) fields[i]).Name == vi.Alias) {
+                                               fb = (Field) fields[i];
+                                               break;
+                                       }
+                               }
+                               if ((fb.ModFlags & Modifiers.STATIC) != 0)
+                                       ig.Emit (OpCodes.Ldsfld, fb.FieldBuilder);
+                               else {
+                                       ig.Emit (OpCodes.Ldarg_0);              
+                                       ig.Emit (OpCodes.Ldfld, fb.FieldBuilder);
+                               }
+                       } else
+                               ig.Emit (OpCodes.Ldloc, vi.LocalBuilder);
+
                        vi.Used = true;
                }
                
@@ -3336,16 +3358,52 @@ namespace Mono.MonoBASIC {
 
                        vi.Assigned = true;
 
-                       source.Emit (ec);
-                       
-                       ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+                       if (vi.Alias != null && vi.Static) {
+                               ArrayList fields = ec.TypeContainer.Fields;
+                               FieldBase fb = null;
+                               for (int i = 0; i < fields.Count; i++) {
+                                       if (((Field) fields[i]).Name == vi.Alias) {
+                                               fb = (Field) fields[i];
+                                               break;
+                                       }
+                               }
+                               if ((fb.ModFlags & Modifiers.STATIC) != 0) {
+                                       source.Emit (ec);
+                                       ig.Emit (OpCodes.Stsfld, fb.FieldBuilder);
+                               }
+                               else {
+                                       ig.Emit (OpCodes.Ldarg_0);
+                                       source.Emit (ec);
+                                       ig.Emit (OpCodes.Stfld, fb.FieldBuilder);
+                               }
+                       }
+                       else {
+                               source.Emit (ec);
+                               ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+                       }
                }
                
                public void AddressOf (EmitContext ec, AddressOp mode)
                {
                        VariableInfo vi = VariableInfo;
 
-                       ec.ig.Emit (OpCodes.Ldloca, vi.LocalBuilder);
+                       if (vi.Alias != null && vi.Static) {
+                               ArrayList fields = ec.TypeContainer.Fields;
+                               FieldBase fb = null;
+                               for (int i = 0; i < fields.Count; i++) {
+                                       if (((Field) fields[i]).Name == vi.Alias) {
+                                               fb = (Field) fields[i];
+                                               break;
+                                       }
+                               }
+                               if ((fb.ModFlags & Modifiers.STATIC) != 0)
+                                       ec.ig.Emit (OpCodes.Ldsflda, fb.FieldBuilder);
+                               else {
+                                       ec.ig.Emit (OpCodes.Ldarg_0);
+                                       ec.ig.Emit (OpCodes.Ldflda, fb.FieldBuilder);
+                               }
+                       } else
+                               ec.ig.Emit (OpCodes.Ldloca, vi.LocalBuilder);
                }
        }
 
@@ -4306,10 +4364,14 @@ namespace Mono.MonoBASIC {
 
                                bool IsDelegate = TypeManager.IsDelegateType (param_type);
                                if (a.ArgType == Argument.AType.NoArg) {
+                                       Expression pdvalue = pd.DefaultValue (i);
+                                       pdvalue.Resolve (ec);
+                                       if (pdvalue != NullLiteral.Null)
+                                               pdvalue = ConvertImplicit (ec, pdvalue, param_type, Location.Null);;
                                        if (argNamesGiven)
-                                               a = new Argument (pd.ParameterName (i), pd.DefaultValue (i), Argument.AType.Expression);
+                                               a = new Argument (pd.ParameterName (i), pdvalue, Argument.AType.Expression);
                                        else
-                                               a = new Argument (pd.DefaultValue (i), Argument.AType.Expression);
+                                               a = new Argument (pdvalue, Argument.AType.Expression);
                                        a.Resolve (ec, Location.Null);
                                }
 
@@ -4339,7 +4401,11 @@ namespace Mono.MonoBASIC {
                                return newarglist;
 
                        for (int i = arg_count; i < pd.Count; i++) {
+                               Type param_type = pd.ParameterType (i);
                                Expression e = pd.DefaultValue (i);
+                               e.Resolve (ec);
+                               if (e != NullLiteral.Null)
+                                       e = ConvertImplicit (ec, e, param_type, Location.Null);
                                Argument a = null;
                                if (argNamesGiven)
                                        a = new Argument (e, Argument.AType.Expression);
@@ -4347,7 +4413,6 @@ namespace Mono.MonoBASIC {
                                        a = new Argument (pd.ParameterName (i), e, Argument.AType.Expression);
                                if ((pd.ParameterModifier (i) & Parameter.Modifier.REF) != 0)
                                        a.ArgType = Argument.AType.Ref;
-                               e.Resolve (ec);
                                a.Resolve (ec, Location.Null);
                                newarglist.Add (a);
                        }
@@ -6495,6 +6560,7 @@ namespace Mono.MonoBASIC {
                                SimpleName child_expr = (SimpleName) expr;
 
                                Expression new_expr = new SimpleName (child_expr.Name + "." + Identifier, loc);
+                               ((SimpleName) new_expr).IsInvocation = is_invocation;
 
                                if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type)
                                        return new_expr.Resolve (ec, flags);