Support for 'LateSet', 'LateIndexGet', 'LateIndexSet'

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

diff --git a/mcs/mbas/ecore.cs b/mcs/mbas/ecore.cs
index e0a594aae944b355e340d1d1450eb04e3906bb2a..c8f6624453439b18cac1f1fb0cdb0192bf05aa52 100644 (file)
--- a/mcs/mbas/ecore.cs
+++ b/mcs/mbas/ecore.cs
@@ -834,7 +834,8 @@ namespace Mono.MonoBASIC {
                                }
 
                                if ((expr_type != TypeManager.char_type) && 
-                                   (expr_type != TypeManager.string_type))
+                                   (expr_type != TypeManager.string_type) &&
+                                   (expr_type != TypeManager.object_type))
                                        return new NumericToBoolCast (expr, expr.Type);
                        }
 
@@ -1757,7 +1758,7 @@ namespace Mono.MonoBASIC {
                        
                        if (e != null)
                                return e;
-                               
+
                        e = NarrowingConversion (ec, expr, target_type, loc);
                        if (e != null)
                                return e;                               
@@ -1805,6 +1806,15 @@ namespace Mono.MonoBASIC {
                static public bool NarrowingConversionExists (EmitContext ec, Expression expr, Type target_type)
                {
                        Type expr_type = expr.Type;
+                       if (expr_type.IsSubclassOf (TypeManager.enum_type))
+                               expr_type = TypeManager.EnumToUnderlying (expr_type);
+       
+                       if (target_type.IsSubclassOf (TypeManager.enum_type))
+                               target_type = TypeManager.EnumToUnderlying (target_type);
+
+
+                       if (expr_type == target_type)
+                               return true;
 
                        if (target_type == TypeManager.sbyte_type){
                                //
@@ -1920,6 +1930,15 @@ namespace Mono.MonoBASIC {
                {
                        Type expr_type = expr.Type;
 
+                       if (expr_type.IsSubclassOf (TypeManager.enum_type))
+                               expr_type = TypeManager.EnumToUnderlying (expr_type);
+       
+                       if (target_type.IsSubclassOf (TypeManager.enum_type))
+                               target_type = TypeManager.EnumToUnderlying (target_type);
+
+                       if (expr_type == target_type)
+                               return expr;
+
                        if (target_type == TypeManager.sbyte_type){
                                //
                                // To sbyte from short, int, long, float, double.
@@ -2216,6 +2235,16 @@ namespace Mono.MonoBASIC {
                                        // Ok, this *is* broken
                                        e = RTConversionExpression(ec, "ByteType.FromObject", expr, loc);
                                        break;  
+                               case TypeCode.Boolean:  
+                                       switch (src_type) {                                             
+                                               case TypeCode.String:                           
+                                                       e = RTConversionExpression(ec, "BooleanType.FromString", expr, loc);
+                                                       break;          
+                                               case TypeCode.Object:                           
+                                                       e = RTConversionExpression(ec, "BooleanType.FromObject", expr, loc);
+                                                       break;                                                                                  
+                                       }
+                                       break;
                                case TypeCode.DateTime: 
                                        switch (src_type) {                                             
                                                case TypeCode.String:                           
@@ -2299,6 +2328,10 @@ namespace Mono.MonoBASIC {
                                                                  Type target_type, Location loc)
                {
                        Type expr_type = expr.Type;
+
+                       if (expr_type.IsSubclassOf (TypeManager.enum_type))
+                               expr_type = TypeManager.EnumToUnderlying (expr_type);
+
                        Expression e;
 
                        if (expr is NullLiteral) {
@@ -4127,7 +4160,6 @@ namespace Mono.MonoBASIC {
 
        public class BoolToNumericCast : EmptyCast 
        {
-               Expression src;
                Type target_type;
                OpCode conv;