X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fconstant.cs;h=18ca2dd7bdd3d8f57defbfb04817b737b351abec;hb=a4c049eb2217fb63d763181b7a1280b2190ebe31;hp=bee3c077a038d7628a34d1f508082a2558471dfd;hpb=08c8eaa6cd668fb552117ead1d3c6b5577deea24;p=mono.git diff --git a/mcs/mcs/constant.cs b/mcs/mcs/constant.cs index bee3c077a03..18ca2dd7bdd 100644 --- a/mcs/mcs/constant.cs +++ b/mcs/mcs/constant.cs @@ -3,6 +3,7 @@ // // Author: // Miguel de Icaza (miguel@ximian.com) +// Marek Safar (marek.safar@seznam.cz) // // (C) 2001 Ximian, Inc. // @@ -17,6 +18,12 @@ namespace Mono.CSharp { /// Base class for constants and literals. /// public abstract class Constant : Expression { + + protected Constant (Location loc) + { + this.loc = loc; + } + /// /// This is different from ToString in that ToString /// is supposed to be there for debugging purposes, @@ -51,17 +58,6 @@ namespace Mono.CSharp { return this; } - public override void Error_ValueCannotBeConverted (Location loc, Type t) - { - // string is not real constant - if (type == TypeManager.string_type) - base.Error_ValueCannotBeConverted (loc, t); - else - Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'", - AsString (), TypeManager.CSharpName (t)); - } - - // // The various ToXXXX conversion functions are used by the constant // folding evaluator. A null value is returned if the conversion is @@ -78,7 +74,7 @@ namespace Mono.CSharp { DoubleConstant c = ConvertToDouble (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.double_type); + Error_ValueCannotBeConverted (loc, TypeManager.double_type, false); return c; } @@ -88,7 +84,7 @@ namespace Mono.CSharp { FloatConstant c = ConvertToFloat (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.float_type); + Error_ValueCannotBeConverted (loc, TypeManager.float_type, false); return c; } @@ -98,7 +94,7 @@ namespace Mono.CSharp { ULongConstant c = ConvertToULong (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.uint64_type); + Error_ValueCannotBeConverted (loc, TypeManager.uint64_type, false); return c; } @@ -108,7 +104,7 @@ namespace Mono.CSharp { LongConstant c = ConvertToLong (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.int64_type); + Error_ValueCannotBeConverted (loc, TypeManager.int64_type, false); return c; } @@ -118,7 +114,7 @@ namespace Mono.CSharp { UIntConstant c = ConvertToUInt (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.uint32_type); + Error_ValueCannotBeConverted (loc, TypeManager.uint32_type, false); return c; } @@ -128,7 +124,7 @@ namespace Mono.CSharp { IntConstant c = ConvertToInt (); if (c == null) - Convert.Error_CannotImplicitConversion (loc, Type, TypeManager.int32_type); + Error_ValueCannotBeConverted (loc, TypeManager.int32_type, false); return c; } @@ -138,7 +134,7 @@ namespace Mono.CSharp { DecimalConstant c = ConvertToDecimal (); if (c == null) - Convert.Error_CannotConvertType (loc, Type, TypeManager.decimal_type); + Error_ValueCannotBeConverted (loc, TypeManager.decimal_type, false); return c; } @@ -152,7 +148,7 @@ namespace Mono.CSharp { return this; if (!Convert.ImplicitStandardConversionExists (Convert.ConstantEC, this, type)){ - Error_ValueCannotBeConverted (loc, type); + Error_ValueCannotBeConverted (loc, type, false); return null; } @@ -165,7 +161,7 @@ namespace Mono.CSharp { bool fail; object constant_value = TypeManager.ChangeType (GetValue (), type, out fail); if (fail){ - Convert.Error_CannotImplicitConversion (loc, Type, type); + Error_ValueCannotBeConverted (loc, type, false); // // We should always catch the error before this is ever @@ -177,39 +173,102 @@ namespace Mono.CSharp { Constant retval; if (type == TypeManager.int32_type) - retval = new IntConstant ((int) constant_value); + retval = new IntConstant ((int) constant_value, loc); else if (type == TypeManager.uint32_type) - retval = new UIntConstant ((uint) constant_value); + retval = new UIntConstant ((uint) constant_value, loc); else if (type == TypeManager.int64_type) - retval = new LongConstant ((long) constant_value); + retval = new LongConstant ((long) constant_value, loc); else if (type == TypeManager.uint64_type) - retval = new ULongConstant ((ulong) constant_value); + retval = new ULongConstant ((ulong) constant_value, loc); else if (type == TypeManager.float_type) - retval = new FloatConstant ((float) constant_value); + retval = new FloatConstant ((float) constant_value, loc); else if (type == TypeManager.double_type) - retval = new DoubleConstant ((double) constant_value); + retval = new DoubleConstant ((double) constant_value, loc); else if (type == TypeManager.string_type) - retval = new StringConstant ((string) constant_value); + retval = new StringConstant ((string) constant_value, loc); else if (type == TypeManager.short_type) - retval = new ShortConstant ((short) constant_value); + retval = new ShortConstant ((short) constant_value, loc); else if (type == TypeManager.ushort_type) - retval = new UShortConstant ((ushort) constant_value); + retval = new UShortConstant ((ushort) constant_value, loc); else if (type == TypeManager.sbyte_type) - retval = new SByteConstant ((sbyte) constant_value); + retval = new SByteConstant ((sbyte) constant_value, loc); else if (type == TypeManager.byte_type) - retval = new ByteConstant ((byte) constant_value); + retval = new ByteConstant ((byte) constant_value, loc); else if (type == TypeManager.char_type) - retval = new CharConstant ((char) constant_value); + retval = new CharConstant ((char) constant_value, loc); else if (type == TypeManager.bool_type) - retval = new BoolConstant ((bool) constant_value); + retval = new BoolConstant ((bool) constant_value, loc); else if (type == TypeManager.decimal_type) - retval = new DecimalConstant ((decimal) constant_value); + retval = new DecimalConstant ((decimal) constant_value, loc); else throw new Exception ("LookupConstantValue: Unhandled constant type: " + type); return retval; } + protected void CheckRange (EmitContext ec, ulong value, Type type, ulong max) + { + if (!ec.ConstantCheckState) + return; + + if (value > max) + throw new OverflowException (); + } + + protected void CheckRange (EmitContext ec, double value, Type type, long min, long max) + { + if (!ec.ConstantCheckState) + return; + + if (((value < min) || (value > max))) + throw new OverflowException (); + } + + protected void CheckUnsigned (EmitContext ec, long value, Type type) + { + if (!ec.ConstantCheckState) + return; + + if (value < 0) + throw new OverflowException (); + } + + public abstract Constant Reduce (EmitContext ec, Type target_type); + + /// + /// Attempts to do a compile-time folding of a constant cast. + /// + public Constant TryReduce (EmitContext ec, Type target_type, Location loc) + { + try { + return TryReduce (ec, target_type); + } + catch (OverflowException) { + if (ec.ConstantCheckState) { + Report.Error (221, loc, "Constant value `{0}' cannot be converted to a `{1}' (use `unchecked' syntax to override)", + this.GetValue (), TypeManager.CSharpName (target_type)); + } + return null; + } + } + + Constant TryReduce (EmitContext ec, Type target_type) + { + if (Type == target_type) + return this; + + if (TypeManager.IsEnumType (target_type)) { + Constant c = TryReduce (ec, TypeManager.EnumToUnderlying (target_type)); + if (c == null) + return null; + + return new EnumConstant (c, target_type); + } + + return Reduce (ec, target_type); + } + + public virtual DecimalConstant ConvertToDecimal () { return null; @@ -267,7 +326,8 @@ namespace Mono.CSharp { public class BoolConstant : Constant { public readonly bool Value; - public BoolConstant (bool val) + public BoolConstant (bool val, Location loc): + base (loc) { type = TypeManager.bool_type; eclass = ExprClass.Value; @@ -314,12 +374,19 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == false; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + return null; + } + } public class ByteConstant : Constant { public readonly byte Value; - public ByteConstant (byte v) + public ByteConstant (byte v, Location loc): + base (loc) { type = TypeManager.byte_type; eclass = ExprClass.Value; @@ -343,37 +410,37 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () { - return new ULongConstant (Value); + return new ULongConstant (Value, loc); } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () { - return new UIntConstant (Value); + return new UIntConstant (Value, loc); } public override IntConstant ConvertToInt () { - return new IntConstant (Value); + return new IntConstant (Value, loc); } public override Constant Increment () { - return new ByteConstant (checked ((byte)(Value + 1))); + return new ByteConstant (checked ((byte)(Value + 1)), loc); } public override bool IsDefaultValue { @@ -391,12 +458,44 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) + return new ShortConstant ((short) Value, Location); + if (target_type == TypeManager.ushort_type) + return new UShortConstant ((ushort) Value, Location); + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint) Value, Location); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) + return new CharConstant ((char) Value, Location); + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class CharConstant : Constant { public readonly char Value; - public CharConstant (char v) + public CharConstant (char v, Location loc): + base (loc) { type = TypeManager.char_type; eclass = ExprClass.Value; @@ -449,37 +548,37 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () { - return new ULongConstant (Value); + return new ULongConstant (Value, loc); } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () { - return new UIntConstant (Value); + return new UIntConstant (Value, loc); } public override IntConstant ConvertToInt () { - return new IntConstant (Value); + return new IntConstant (Value, loc); } public override Constant Increment () { - return new CharConstant (checked ((char)(Value + 1))); + return new CharConstant (checked ((char)(Value + 1)), loc); } public override bool IsDefaultValue { @@ -497,12 +596,46 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == '\0'; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, Int16.MinValue, Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint) Value, Location); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class SByteConstant : Constant { public readonly sbyte Value; - public SByteConstant (sbyte v) + public SByteConstant (sbyte v, Location loc): + base (loc) { type = TypeManager.sbyte_type; eclass = ExprClass.Value; @@ -526,25 +659,25 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () { if (Value >= 0) - return new ULongConstant ((ulong) Value); + return new ULongConstant ((ulong) Value, loc); return null; } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () @@ -554,12 +687,12 @@ namespace Mono.CSharp { public override IntConstant ConvertToInt () { - return new IntConstant (Value); + return new IntConstant (Value, loc); } public override Constant Increment () { - return new SByteConstant (checked((sbyte)(Value + 1))); + return new SByteConstant (checked((sbyte)(Value + 1)), loc); } public override bool IsDefaultValue { @@ -577,12 +710,50 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckUnsigned (ec, Value, target_type); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.short_type) + return new ShortConstant ((short) Value, Location); + if (target_type == TypeManager.ushort_type) { + CheckUnsigned (ec, Value, target_type); + return new UShortConstant ((ushort) Value, Location); + } if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) { + CheckUnsigned (ec, Value, target_type); + return new UIntConstant ((uint) Value, Location); + } if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) { + CheckUnsigned (ec, Value, target_type); + return new ULongConstant ((ulong) Value, Location); + } + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckUnsigned (ec, Value, target_type); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class ShortConstant : Constant { public readonly short Value; - public ShortConstant (short v) + public ShortConstant (short v, Location loc): + base (loc) { type = TypeManager.short_type; eclass = ExprClass.Value; @@ -606,12 +777,12 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () @@ -621,7 +792,7 @@ namespace Mono.CSharp { public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () @@ -631,12 +802,12 @@ namespace Mono.CSharp { public override IntConstant ConvertToInt () { - return new IntConstant (Value); + return new IntConstant (Value, loc); } public override Constant Increment () { - return new ShortConstant (checked((short)(Value + 1))); + return new ShortConstant (checked((short)(Value + 1)), loc); } public override bool IsDefaultValue { @@ -654,12 +825,54 @@ namespace Mono.CSharp { return Value < 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.ushort_type) { + CheckUnsigned (ec, Value, target_type); + return new UShortConstant ((ushort) Value, Location); + } + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) { + CheckUnsigned (ec, Value, target_type); + return new UIntConstant ((uint) Value, Location); + } + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) { + CheckUnsigned (ec, Value, target_type); + return new ULongConstant ((ulong) Value, Location); + } + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class UShortConstant : Constant { public readonly ushort Value; - public UShortConstant (ushort v) + public UShortConstant (ushort v, Location loc): + base (loc) { type = TypeManager.ushort_type; eclass = ExprClass.Value; @@ -683,37 +896,37 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () { - return new ULongConstant (Value); + return new ULongConstant (Value, loc); } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () { - return new UIntConstant (Value); + return new UIntConstant (Value, loc); } public override IntConstant ConvertToInt () { - return new IntConstant (Value); + return new IntConstant (Value, loc); } public override Constant Increment () { - return new UShortConstant (checked((ushort)(Value + 1))); + return new UShortConstant (checked((ushort)(Value + 1)), loc); } public override bool IsDefaultValue { @@ -731,12 +944,49 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, Int16.MinValue, Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint) Value, Location); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } } public class IntConstant : Constant { public readonly int Value; - public IntConstant (int v) + public IntConstant (int v, Location loc): + base (loc) { type = TypeManager.int32_type; eclass = ExprClass.Value; @@ -812,17 +1062,17 @@ namespace Mono.CSharp { public override DecimalConstant ConvertToDecimal() { - return new DecimalConstant (Value); + return new DecimalConstant (Value, loc); } public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () @@ -830,12 +1080,12 @@ namespace Mono.CSharp { if (Value < 0) return null; - return new ULongConstant ((ulong) Value); + return new ULongConstant ((ulong) Value, loc); } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () @@ -843,7 +1093,7 @@ namespace Mono.CSharp { if (Value < 0) return null; - return new UIntConstant ((uint) Value); + return new UIntConstant ((uint) Value, loc); } public override IntConstant ConvertToInt () @@ -853,7 +1103,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new IntConstant (checked(Value + 1)); + return new IntConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -871,12 +1121,55 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, Int16.MinValue, Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.ushort_type) { + CheckRange (ec, Value, target_type, UInt16.MinValue, UInt16.MaxValue); + return new UShortConstant ((ushort) Value, Location); + } + if (target_type == TypeManager.uint32_type) { + CheckRange (ec, Value, target_type, Int32.MinValue, Int32.MaxValue); + return new UIntConstant ((uint) Value, Location); + } + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) { + CheckUnsigned (ec, Value, target_type); + return new ULongConstant ((ulong) Value, Location); + } + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } } public class UIntConstant : Constant { public readonly uint Value; - public UIntConstant (uint v) + public UIntConstant (uint v, Location loc): + base (loc) { type = TypeManager.uint32_type; eclass = ExprClass.Value; @@ -900,22 +1193,22 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () { - return new ULongConstant (Value); + return new ULongConstant (Value, loc); } public override LongConstant ConvertToLong () { - return new LongConstant (Value); + return new LongConstant (Value, loc); } public override UIntConstant ConvertToUInt () @@ -930,7 +1223,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new UIntConstant (checked(Value + 1)); + return new UIntConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -948,12 +1241,54 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, Int16.MinValue, Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.ushort_type) { + CheckRange (ec, Value, target_type, UInt16.MinValue, UInt16.MaxValue); + return new UShortConstant ((ushort) Value, Location); + } + if (target_type == TypeManager.int32_type) { + CheckRange (ec, Value, target_type, Int32.MinValue, Int32.MaxValue); + return new IntConstant ((int) Value, Location); + } + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class LongConstant : Constant { public readonly long Value; - public LongConstant (long v) + public LongConstant (long v, Location loc): + base (loc) { type = TypeManager.int64_type; eclass = ExprClass.Value; @@ -989,12 +1324,12 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () @@ -1002,7 +1337,7 @@ namespace Mono.CSharp { if (Value < 0) return null; - return new ULongConstant ((ulong) Value); + return new ULongConstant ((ulong) Value, loc); } public override LongConstant ConvertToLong () @@ -1022,7 +1357,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new LongConstant (checked(Value + 1)); + return new LongConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -1040,12 +1375,58 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, Int16.MinValue, Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.ushort_type) { + CheckRange (ec, Value, target_type, UInt16.MinValue, UInt16.MaxValue); + return new UShortConstant ((ushort) Value, Location); + } + if (target_type == TypeManager.int32_type) { + CheckRange (ec, Value, target_type, Int32.MinValue, Int32.MaxValue); + return new IntConstant ((int) Value, Location); + } + if (target_type == TypeManager.uint32_type) { + CheckRange (ec, Value, target_type, UInt32.MinValue, UInt32.MaxValue); + return new UIntConstant ((uint) Value, Location); + } + if (target_type == TypeManager.uint64_type) { + CheckUnsigned (ec, Value, target_type); + return new ULongConstant ((ulong) Value, Location); + } + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MinValue, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class ULongConstant : Constant { public readonly ulong Value; - public ULongConstant (ulong v) + public ULongConstant (ulong v, Location loc): + base (loc) { type = TypeManager.uint64_type; eclass = ExprClass.Value; @@ -1071,12 +1452,12 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () { - return new FloatConstant (Value); + return new FloatConstant (Value, loc); } public override ULongConstant ConvertToULong () @@ -1101,7 +1482,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new ULongConstant (checked(Value + 1)); + return new ULongConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -1119,12 +1500,58 @@ namespace Mono.CSharp { public override bool IsZeroInteger { get { return Value == 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, (ulong) SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) { + CheckRange (ec, Value, target_type, (ulong) Int16.MaxValue); + return new ShortConstant ((short) Value, Location); + } + if (target_type == TypeManager.ushort_type) { + CheckRange (ec, Value, target_type, UInt16.MaxValue); + return new UShortConstant ((ushort) Value, Location); + } + if (target_type == TypeManager.int32_type) { + CheckRange (ec, Value, target_type, Int32.MaxValue); + return new IntConstant ((int) Value, Location); + } + if (target_type == TypeManager.uint32_type) { + CheckRange (ec, Value, target_type, UInt32.MaxValue); + return new UIntConstant ((uint) Value, Location); + } + if (target_type == TypeManager.int64_type) { + CheckRange (ec, Value, target_type, (ulong) Int64.MaxValue); + return new LongConstant ((long) Value, Location); + } + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, Char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class FloatConstant : Constant { public readonly float Value; - public FloatConstant (float v) + public FloatConstant (float v, Location loc): + base (loc) { type = TypeManager.float_type; eclass = ExprClass.Value; @@ -1148,7 +1575,7 @@ namespace Mono.CSharp { public override DoubleConstant ConvertToDouble () { - return new DoubleConstant (Value); + return new DoubleConstant (Value, loc); } public override FloatConstant ConvertToFloat () @@ -1173,7 +1600,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new FloatConstant (checked(Value + 1)); + return new FloatConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -1187,12 +1614,42 @@ namespace Mono.CSharp { return Value < 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) + return new ByteConstant ((byte) Value, Location); + if (target_type == TypeManager.sbyte_type) + return new SByteConstant ((sbyte) Value, Location); + if (target_type == TypeManager.short_type) + return new ShortConstant ((short) Value, Location); + if (target_type == TypeManager.ushort_type) + return new UShortConstant ((ushort) Value, Location); + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint) Value, Location); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double) Value, Location); + if (target_type == TypeManager.char_type) + return new CharConstant ((char) Value, Location); + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class DoubleConstant : Constant { public readonly double Value; - public DoubleConstant (double v) + public DoubleConstant (double v, Location loc): + base (loc) { type = TypeManager.double_type; eclass = ExprClass.Value; @@ -1246,7 +1703,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new DoubleConstant (checked(Value + 1)); + return new DoubleConstant (checked(Value + 1), loc); } public override bool IsDefaultValue { @@ -1260,12 +1717,48 @@ namespace Mono.CSharp { return Value < 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.byte_type) { + CheckRange (ec, Value, target_type, Byte.MinValue, Byte.MaxValue); + return new ByteConstant ((byte) Value, Location); + } + if (target_type == TypeManager.sbyte_type) { + CheckRange (ec, Value, target_type, SByte.MinValue, SByte.MaxValue); + return new SByteConstant ((sbyte) Value, Location); + } + if (target_type == TypeManager.short_type) + return new ShortConstant ((short) Value, Location); + if (target_type == TypeManager.ushort_type) + return new UShortConstant ((ushort) Value, Location); + if (target_type == TypeManager.int32_type) + return new IntConstant ((int) Value, Location); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint) Value, Location); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long) Value, Location); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong) Value, Location); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float) Value, Location); + if (target_type == TypeManager.char_type) { + CheckRange (ec, Value, target_type, char.MinValue, char.MaxValue); + return new CharConstant ((char) Value, Location); + } + if (target_type == TypeManager.decimal_type) + return new DecimalConstant ((decimal) Value, Location); + + return null; + } + } public class DecimalConstant : Constant { public readonly decimal Value; - public DecimalConstant (decimal d) + public DecimalConstant (decimal d, Location loc): + base (loc) { type = TypeManager.decimal_type; eclass = ExprClass.Value; @@ -1317,7 +1810,7 @@ namespace Mono.CSharp { public override Constant Increment () { - return new DecimalConstant (checked (Value + 1)); + return new DecimalConstant (checked (Value + 1), loc); } public override bool IsDefaultValue { @@ -1331,12 +1824,42 @@ namespace Mono.CSharp { return Value < 0; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + if (target_type == TypeManager.sbyte_type) + return new SByteConstant ((sbyte)Value, loc); + if (target_type == TypeManager.byte_type) + return new ByteConstant ((byte)Value, loc); + if (target_type == TypeManager.short_type) + return new ShortConstant ((short)Value, loc); + if (target_type == TypeManager.ushort_type) + return new UShortConstant ((ushort)Value, loc); + if (target_type == TypeManager.int32_type) + return new IntConstant ((int)Value, loc); + if (target_type == TypeManager.uint32_type) + return new UIntConstant ((uint)Value, loc); + if (target_type == TypeManager.int64_type) + return new LongConstant ((long)Value, loc); + if (target_type == TypeManager.uint64_type) + return new ULongConstant ((ulong)Value, loc); + if (target_type == TypeManager.char_type) + return new CharConstant ((char)Value, loc); + if (target_type == TypeManager.float_type) + return new FloatConstant ((float)Value, loc); + if (target_type == TypeManager.double_type) + return new DoubleConstant ((double)Value, loc); + + return null; + } + } public class StringConstant : Constant { public readonly string Value; - public StringConstant (string s) + public StringConstant (string s, Location loc): + base (loc) { type = TypeManager.string_type; eclass = ExprClass.Value; @@ -1378,6 +1901,11 @@ namespace Mono.CSharp { return false; } } + + public override Constant Reduce (EmitContext ec, Type target_type) + { + return null; + } } }