Fix #73038.

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

diff --git a/mcs/mcs/constant.cs b/mcs/mcs/constant.cs
old mode 100755 (executable)
new mode 100644 (file)
index 2e79afb..5bf0335
--- a/mcs/mcs/constant.cs
+++ b/mcs/mcs/constant.cs
@@ -116,6 +116,21 @@ namespace Mono.CSharp {
 
                        return c;
                }
+
+               public DecimalConstant ToDecimal (Location loc)
+               {
+                       DecimalConstant c = ConvertToDecimal ();
+
+                       if (c == null)
+                               Convert.Error_CannotConvertType (loc, Type, TypeManager.decimal_type);
+
+                       return c;
+               }
+
+               public virtual DecimalConstant ConvertToDecimal ()
+               {
+                       return null;
+               }
                
                public virtual DoubleConstant ConvertToDouble ()
                {
@@ -146,6 +161,22 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+               
+               public abstract bool IsDefaultValue {
+                       get;
+               }
+
+               public abstract bool IsNegative {
+                       get;
+               }
+
+               //
+               // Returns true iff 1) the stack type of this is one of Object, 
+               // int32, int64 and 2) this == 0 or this == null.
+               //
+               public virtual bool IsZeroInteger {
+                       get { return false; }
+               }
        }
        
        public class BoolConstant : Constant {
@@ -177,6 +208,22 @@ namespace Mono.CSharp {
                        else
                                ec.ig.Emit (OpCodes.Ldc_I4_0);
                }
+       
+               public override bool IsDefaultValue {
+                       get {
+                               return !Value;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+       
+               public override bool IsZeroInteger {
+                       get { return Value == false; }
+               }
        }
 
        public class ByteConstant : Constant {
@@ -233,6 +280,22 @@ namespace Mono.CSharp {
                {
                        return new IntConstant (Value);
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class CharConstant : Constant {
@@ -318,6 +381,22 @@ namespace Mono.CSharp {
                {
                        return new IntConstant (Value);
                }
+               
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == '\0'; }
+               }
        }
 
        public class SByteConstant : Constant {
@@ -377,6 +456,22 @@ namespace Mono.CSharp {
                {
                        return new IntConstant (Value);
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
+               
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class ShortConstant : Constant {
@@ -433,6 +528,22 @@ namespace Mono.CSharp {
                {
                        return new IntConstant (Value);
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+               
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
        }
 
        public class UShortConstant : Constant {
@@ -489,6 +600,22 @@ namespace Mono.CSharp {
                {
                        return new IntConstant (Value);
                }
+       
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+       
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class IntConstant : Constant {
@@ -568,6 +695,11 @@ namespace Mono.CSharp {
                        return Value;
                }
 
+               public override DecimalConstant ConvertToDecimal()
+               {
+                       return new DecimalConstant (Value);
+               }
+
                public override DoubleConstant ConvertToDouble ()
                {
                        return new DoubleConstant (Value);
@@ -603,6 +735,22 @@ namespace Mono.CSharp {
                {
                        return this;
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+               
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class UIntConstant : Constant {
@@ -659,6 +807,22 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+               
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class LongConstant : Constant {
@@ -730,6 +894,22 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+               
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class ULongConstant : Constant {
@@ -788,6 +968,22 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
+               }
+
+               public override bool IsZeroInteger {
+                       get { return Value == 0; }
+               }
        }
 
        public class FloatConstant : Constant {
@@ -839,6 +1035,18 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
        }
 
        public class DoubleConstant : Constant {
@@ -895,6 +1103,18 @@ namespace Mono.CSharp {
                {
                        return null;
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
        }
 
        public class DecimalConstant : Constant {
@@ -919,15 +1139,24 @@ namespace Mono.CSharp {
 
                public override void Emit (EmitContext ec)
                {
+                       ILGenerator ig = ec.ig;
+
                        int [] words = Decimal.GetBits (Value);
+                       int power = (words [3] >> 16) & 0xff;
+
+                       if (power == 0 && Value <= int.MaxValue && Value >= int.MinValue)
+                       {
+                               IntConstant.EmitInt (ig, (int)Value);
+                               ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_int_arg);
+                               return;
+                       }
+
                        
                        //
                        // FIXME: we could optimize this, and call a better 
                        // constructor
                        //
 
-                       ILGenerator ig = ec.ig;
-                       
                        IntConstant.EmitInt (ig, words [0]);
                        IntConstant.EmitInt (ig, words [1]);
                        IntConstant.EmitInt (ig, words [2]);
@@ -936,10 +1165,22 @@ namespace Mono.CSharp {
                        IntConstant.EmitInt (ig, words [3] >> 31);
 
                        // power
-                       IntConstant.EmitInt (ig, (words [3] >> 16) & 0xff);
+                       IntConstant.EmitInt (ig, power);
 
                        ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_five_args);
                }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == 0;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return Value < 0;
+                       }
+               }
        }
 
        public class StringConstant : Constant {
@@ -965,7 +1206,22 @@ namespace Mono.CSharp {
                
                public override void Emit (EmitContext ec)
                {
-                       ec.ig.Emit (OpCodes.Ldstr, Value);
+                       if (Value == null)
+                               ec.ig.Emit (OpCodes.Ldnull);
+                       else
+                               ec.ig.Emit (OpCodes.Ldstr, Value);
+               }
+
+               public override bool IsDefaultValue {
+                       get {
+                               return Value == null;
+                       }
+               }
+
+               public override bool IsNegative {
+                       get {
+                               return false;
+                       }
                }
        }