//
// Attempt to do the implicit constant expression conversions
- if (expr is IntConstant){
+ if (expr is BoolConstant || expr is IntConstant || expr is LongConstant || expr is DoubleConstant || expr is FloatConstant){
Expression e;
- e = TryImplicitIntConversion (target_type, (IntConstant) expr);
+ e = TryImplicitNumericConversion (target_type, (Constant) expr);
if (e != null)
return e;
- } else if (expr is LongConstant && target_type == TypeManager.uint64_type){
+ if (target_type == TypeManager.byte_type ||
+ target_type == TypeManager.short_type ||
+ target_type == TypeManager.int32_type ||
+ target_type == TypeManager.int64_type ||
+ target_type == TypeManager.float_type) {
+
+ string val = null;
+ if (expr is IntConstant)
+ val = ((IntConstant) expr).Value.ToString();
+ if (expr is LongConstant)
+ val = ((LongConstant) expr).Value.ToString();
+ if (expr is FloatConstant)
+ val = ((FloatConstant) expr).Value.ToString();
+ if (expr is DoubleConstant)
+ val = ((DoubleConstant) expr).Value.ToString();
+ Error_ConstantValueCannotBeConverted(loc, val, target_type);
+ return null;
+ }
+ } else if (expr is LongConstant && target_type == TypeManager.uint64_type) {
//
// Try the implicit constant expression conversion
// from long to ulong, instead of a nice routine,
Type real_target_type = target_type;
- if (expr_type == TypeManager.sbyte_type){
+ if (target_type == TypeManager.bool_type) {
+
+ if (expr_type == TypeManager.decimal_type) {
+ return RTConversionExpression (ec, "System.Convert",".ToBoolean" , expr, loc);
+ }
+
+ if ((expr_type != TypeManager.char_type) &&
+ (expr_type != TypeManager.string_type))
+ return new NumericToBoolCast (expr, expr.Type);
+ }
+
+ if (expr_type == TypeManager.bool_type){
+ //
+ if (real_target_type == TypeManager.sbyte_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.byte_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.int32_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.int64_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.double_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.float_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.short_type)
+ return new BoolToNumericCast (expr, target_type);
+ if (real_target_type == TypeManager.decimal_type)
+ return RTConversionExpression(ec, "DecimalType.FromBoolean", expr, loc);
+ } else if (expr_type == TypeManager.sbyte_type){
//
// From sbyte to short, int, long, float, double.
//
return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
if (real_target_type == TypeManager.double_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+ } else if (expr_type == TypeManager.string_type){
+
+ if (real_target_type == TypeManager.bool_type)
+ return RTConversionExpression (ec, "BooleanType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.decimal_type)
+ return RTConversionExpression (ec, "DecimalType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.float_type)
+ return RTConversionExpression (ec, "SingleType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.short_type)
+ return RTConversionExpression (ec, "ShortType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.int64_type)
+ return RTConversionExpression (ec, "LongType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.int32_type)
+ return RTConversionExpression (ec, "IntegerType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.double_type)
+ return RTConversionExpression (ec, "DoubleType.FromString" , expr, loc);
+ if (real_target_type == TypeManager.byte_type)
+ return RTConversionExpression (ec, "ByteType.FromString" , expr, loc);
} else if (expr_type == TypeManager.float_type){
//
// float to double
//
+ if (real_target_type == TypeManager.decimal_type)
+ return RTConversionExpression (ec, "System.Convert", ".ToDecimal" , expr, loc);
if (real_target_type == TypeManager.double_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
- }
+
+ } else if (expr_type == TypeManager.double_type){
+
+ if (real_target_type == TypeManager.decimal_type)
+ return RTConversionExpression (ec, "System.Convert", ".ToDecimal" , expr, loc);
+ } else if (expr_type == TypeManager.decimal_type){
+
+ if (real_target_type == TypeManager.bool_type)
+ return RTConversionExpression (ec, "BooleanType.FromDecimal" , expr, loc);
+ if (real_target_type == TypeManager.short_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToInt16", expr, loc);
+ if (real_target_type == TypeManager.byte_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToByte", expr, loc);
+ if (real_target_type == TypeManager.int32_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToInt32", expr, loc);
+ if (real_target_type == TypeManager.int64_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToInt64", expr, loc);
+ if (real_target_type == TypeManager.float_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToSingle", expr, loc);
+ if (real_target_type == TypeManager.double_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToDouble", expr, loc);
+ if (real_target_type == TypeManager.char_type)
+ return RTConversionExpression(ec, "System.Convert", ".ToChar", expr, loc);
+ }
return null;
}
public static bool WideningConversionExists (Expression expr, Type expr_type, Type target_type)
{
+
if (expr_type == null || expr_type == TypeManager.void_type)
return false;
return true;
// First numeric conversions
-
+
if (expr_type == TypeManager.sbyte_type){
//
// From sbyte to short, int, long, float, double.
// From byte to short, ushort, int, uint, long, ulong, float, double
//
if ((target_type == TypeManager.short_type) ||
+ (target_type == TypeManager.bool_type) ||
(target_type == TypeManager.ushort_type) ||
(target_type == TypeManager.int32_type) ||
(target_type == TypeManager.uint32_type) ||
// From short to int, long, float, double
//
if ((target_type == TypeManager.int32_type) ||
+ (target_type == TypeManager.bool_type) ||
(target_type == TypeManager.int64_type) ||
(target_type == TypeManager.double_type) ||
(target_type == TypeManager.float_type) ||
// From int to long, float, double
//
if ((target_type == TypeManager.int64_type) ||
+ (target_type == TypeManager.bool_type) ||
(target_type == TypeManager.double_type) ||
(target_type == TypeManager.float_type) ||
(target_type == TypeManager.decimal_type))
// From uint to long, ulong, float, double
//
if ((target_type == TypeManager.int64_type) ||
+ (target_type == TypeManager.bool_type) ||
(target_type == TypeManager.uint64_type) ||
(target_type == TypeManager.double_type) ||
(target_type == TypeManager.float_type) ||
// From long/ulong to float, double
//
if ((target_type == TypeManager.double_type) ||
+ (target_type == TypeManager.bool_type) ||
(target_type == TypeManager.float_type) ||
(target_type == TypeManager.decimal_type))
return true;
(target_type == TypeManager.int64_type) ||
(target_type == TypeManager.float_type) ||
(target_type == TypeManager.double_type) ||
+ (target_type == TypeManager.string_type) ||
(target_type == TypeManager.decimal_type))
return true;
+ } else if (expr_type == TypeManager.decimal_type) {
+ if (target_type == TypeManager.float_type ||
+ target_type == TypeManager.double_type)
+ return true;
} else if (expr_type == TypeManager.float_type){
//
- // float to double
+ // float to double, decimal
//
if (target_type == TypeManager.double_type)
return true;
- }
+ } else if (expr_type == TypeManager.double_type){
+
+ if ((target_type == TypeManager.bool_type))
+ return true;
+ }
if (ImplicitReferenceConversionExists (expr, expr_type, target_type))
return true;
//
// If any operator converts from S then Sx = S
//
- Type source_type = source.Type;
+ Type source_type= source.Type;
foreach (MethodBase mb in me.Methods){
ParameterData pd = Invocation.GetParameterData (mb);
Type param_type = pd.ParameterType (0);
Type expr_type = expr.Type;
Expression e;
+
if (expr_type == target_type)
return expr;
e = ConvertImplicitStandard (ec, expr, target_type, loc);
if (e != null)
return e;
-
+
e = ImplicitUserConversion (ec, expr, target_type, loc);
+
if (e != null)
return e;
e = e.Resolve(ec);
return (e);
}
+
+ static private Expression RTConversionExpression (EmitContext ec, string ns, string method, Expression expr, Location loc)
+ {
+ Expression etmp, e;
+ ArrayList args;
+ Argument arg;
+
+ etmp = Mono.MonoBASIC.Parser.DecomposeQI(ns+method, loc);
+ args = new ArrayList();
+ arg = new Argument (expr, Argument.AType.Expression);
+ args.Add (arg);
+ e = (Expression) new Invocation (etmp, args, loc);
+ e = e.Resolve(ec);
+ return (e);
+ }
+
static public bool NarrowingConversionExists (EmitContext ec, Expression expr, Type target_type)
{
} else if (target_type == TypeManager.char_type){
//
- // To char from ushort, int, uint, long, ulong, float, double
+ // To char from ushort, int, uint, long, ulong, float, double, decimal,string
//
if ((expr_type == TypeManager.ushort_type) ||
(expr_type == TypeManager.int32_type) ||
(expr_type == TypeManager.int64_type) ||
(expr_type == TypeManager.float_type) ||
(expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.decimal_type))
+ (expr_type == TypeManager.decimal_type) ||
+ (expr_type == TypeManager.string_type))
+
return true;
} else if (target_type == TypeManager.float_type){
//
// To sbyte from short, int, long, float, double.
//
- if ((expr_type == TypeManager.int32_type) ||
- (expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.short_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
+ if (expr_type == TypeManager.int32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I1);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I1);
+ if (expr_type == TypeManager.short_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_I1);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I1);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I1);
+ }
} else if (target_type == TypeManager.byte_type){
//
// To byte from short, ushort, int, uint, long, ulong, float, double
//
- if ((expr_type == TypeManager.short_type) ||
- (expr_type == TypeManager.ushort_type) ||
- (expr_type == TypeManager.int32_type) ||
- (expr_type == TypeManager.uint32_type) ||
- (expr_type == TypeManager.uint64_type) ||
- (expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
+ if (expr_type == TypeManager.short_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U1);
+ if (expr_type == TypeManager.ushort_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_U1);
+ if (expr_type == TypeManager.int32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U1);
+ if (expr_type == TypeManager.uint32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U1);
+ if (expr_type == TypeManager.uint64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U1);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U1);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U1);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U1);
+ }
- } else if (target_type == TypeManager.short_type){
+ } else if (target_type == TypeManager.short_type) {
//
// To short from int, long, float, double
//
- if ((expr_type == TypeManager.int32_type) ||
- (expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
+ if (expr_type == TypeManager.int32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I2);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I2);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I2);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I2);
+ }
- } else if (target_type == TypeManager.ushort_type){
+ } else if (target_type == TypeManager.ushort_type) {
//
// To ushort from int, uint, long, ulong, float, double
//
- if ((expr_type == TypeManager.uint32_type) ||
- (expr_type == TypeManager.uint64_type) ||
- (expr_type == TypeManager.int32_type) ||
- (expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
+ if (expr_type == TypeManager.uint32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U2);
+ if (expr_type == TypeManager.uint64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U2);
+ if (expr_type == TypeManager.int32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U2);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U2);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U2);
+ }
+
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U2);
+ }
} else if (target_type == TypeManager.int32_type){
//
// To int from long, float, double
//
- if ((expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I4);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I4);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I4);
+ }
} else if (target_type == TypeManager.uint32_type){
//
// To uint from long, ulong, float, double
//
- if ((expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.uint64_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U4);
+ if (expr_type == TypeManager.uint64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I4);
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U4);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U4);
+ }
- } else if ((target_type == TypeManager.uint64_type) ||
- (target_type == TypeManager.int64_type)) {
+ } else if (target_type == TypeManager.uint64_type) {
//
// To long/ulong from float, double
//
- if ((expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U8);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U8);
+ }
+
+ } else if (target_type == TypeManager.int64_type) {
+ //
+ // To long/ulong from float, double
+ //
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I8);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I8);
+ }
} else if (target_type == TypeManager.char_type){
//
// To char from ushort, int, uint, long, ulong, float, double
//
- if ((expr_type == TypeManager.ushort_type) ||
- (expr_type == TypeManager.int32_type) ||
- (expr_type == TypeManager.uint32_type) ||
- (expr_type == TypeManager.uint64_type) ||
- (expr_type == TypeManager.int64_type) ||
- (expr_type == TypeManager.float_type) ||
- (expr_type == TypeManager.double_type) ||
- (expr_type == TypeManager.decimal_type))
- return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
+ if (expr_type == TypeManager.ushort_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_CH);
+ if (expr_type == TypeManager.int32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_CH);
+ if (expr_type == TypeManager.uint32_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_CH);
+ if (expr_type == TypeManager.uint64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_CH);
+ if (expr_type == TypeManager.int64_type)
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_CH);
+
+ if (expr_type == TypeManager.float_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_CH);
+ }
+ if (expr_type == TypeManager.double_type) {
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_CH);
+ }
} else if (target_type == TypeManager.float_type){
//
// To float from double
//
if (expr_type == TypeManager.double_type)
- return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+ return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_R4);
}
TypeCode dest_type = Type.GetTypeCode (target_type);
TypeCode src_type = Type.GetTypeCode (expr_type);
Expression e = null;
- // VB.NET Objects can be converted to anything by default
- // unless, that is, an exception at runtime blows it all
- if (src_type == TypeCode.Object) {
- Expression cast_type = Mono.MonoBASIC.Parser.DecomposeQI(target_type.ToString(), loc);
- Cast ce = new Cast (cast_type, expr, loc);
- ce.IsRuntimeCast = true;
- return ce.Resolve (ec);
- }
-
switch (dest_type) {
case TypeCode.String:
switch (src_type) {
e = RTConversionExpression(ec, "DateType.FromObject", expr, loc);
break;
}
- break;
+ break;
+ case TypeCode.Char:
+ switch (src_type) {
+
+ case TypeCode.String:
+ e = RTConversionExpression(ec, "CharType.FromString", expr, loc);
+ break;
+
+ }
+ break;
}
// We must examine separately some types that
if (expr_type == typeof(System.String) && target_type == typeof (System.Char[])) {
e = RTConversionExpression(ec, "CharArrayType.FromString", expr, loc);
}
-
- return e;
+ if (e != null)
+ return e;
+ // VB.NET Objects can be converted to anything by default
+ // unless, that is, an exception at runtime blows it all
+ if (src_type == TypeCode.Object) {
+ Expression cast_type = Mono.MonoBASIC.Parser.DecomposeQI(target_type.ToString(), loc);
+ Cast ce = new Cast (cast_type, expr, loc);
+ ce.IsRuntimeCast = true;
+ return ce.Resolve (ec);
+ }
+ return null;
+ }
+
+ static public Expression ConvertNothingToDefaultValues (EmitContext ec, Expression expr,
+ Type target_type, Location loc)
+ {
+ switch (Type.GetTypeCode (target_type)) {
+ case TypeCode.Boolean :
+ return new BoolConstant (false);
+ case TypeCode.Byte :
+ return new ByteConstant (0);
+ case TypeCode.Char :
+ return new CharConstant ((char)0);
+ case TypeCode.SByte :
+ return new SByteConstant (0);
+ case TypeCode.Int16 :
+ return new ShortConstant (0);
+ case TypeCode.Int32 :
+ return new IntConstant (0);
+ case TypeCode.Int64 :
+ return new LongConstant (0);
+ case TypeCode.Decimal :
+ return new DecimalConstant (System.Decimal.Zero);
+ case TypeCode.Single :
+ return new FloatConstant (0.0F);
+ case TypeCode.Double :
+ return new DoubleConstant (0.0);
+ }
+
+ return null;
}
/// <summary>
Type expr_type = expr.Type;
Expression e;
+ if (expr is NullLiteral) {
+ if (target_type == TypeManager.string_type)
+ return expr;
+ e = ConvertNothingToDefaultValues (ec, expr, target_type, loc);
+ if (e != null)
+ return e;
+ }
+
if (expr_type == target_type)
return expr;
e = ImplicitNumericConversion (ec, expr, target_type, loc);
+
if (e != null)
return e;
}
/// <summary>
- /// Attemps to perform an implict constant conversion of the IntConstant
+ /// Attemps to perform an implict constant conversion of the any Numeric Constant
/// into a different data type using casts (See Implicit Constant
/// Expression Conversions)
/// </summary>
- static protected Expression TryImplicitIntConversion (Type target_type, IntConstant ic)
- {
- int value = ic.Value;
+ static protected Expression TryImplicitNumericConversion (Type target_type, Constant ic)
+ {
+ double value = 0;
+ if (ic is BoolConstant) {
+ bool val = (bool) ((BoolConstant)ic).Value;
+ if (val) {
+ if (target_type == TypeManager.byte_type)
+ value = Byte.MaxValue;
+ else
+ value = -1;
+ }
+ }
+ if (ic is IntConstant)
+ value = (double)((IntConstant)ic).Value;
+
+ if (ic is LongConstant)
+ value = (double) ((LongConstant)ic).Value;
+
+ if (ic is FloatConstant) {
+ value = (double) ((FloatConstant)ic).Value;
+ }
+
+ if (ic is DoubleConstant) {
+ value = ((DoubleConstant)ic).Value;
+ }
//
// FIXME: This could return constants instead of EmptyCasts
//
- if (target_type == TypeManager.sbyte_type){
+ if (target_type == TypeManager.bool_type){
+ if (value != 0)
+ return new BoolConstant (true);
+ return new BoolConstant (false);
+ } else if (target_type == TypeManager.sbyte_type){
if (value >= SByte.MinValue && value <= SByte.MaxValue)
- return new SByteConstant ((sbyte) value);
+ return new SByteConstant ((sbyte) System.Math.Round (value));
} else if (target_type == TypeManager.byte_type){
- if (Byte.MinValue >= 0 && value <= Byte.MaxValue)
- return new ByteConstant ((byte) value);
+ if (value >= Byte.MinValue && value <= Byte.MaxValue)
+ return new ByteConstant ((byte) System.Math.Round (value));
} else if (target_type == TypeManager.short_type){
if (value >= Int16.MinValue && value <= Int16.MaxValue)
- return new ShortConstant ((short) value);
+ return new ShortConstant ((short) System.Math.Round (value));
} else if (target_type == TypeManager.ushort_type){
if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
- return new UShortConstant ((ushort) value);
+ return new UShortConstant ((ushort) System.Math.Round (value));
+ } else if (target_type == TypeManager.int32_type){
+ if (value >= Int32.MinValue && value <= Int32.MaxValue)
+ return new IntConstant ((int) System.Math.Round (value));
} else if (target_type == TypeManager.uint32_type){
if (value >= 0)
- return new UIntConstant ((uint) value);
+ return new UIntConstant ((uint) System.Math.Round (value));
+ } else if (target_type == TypeManager.int64_type){
+ return new LongConstant ((long) System.Math.Round (value));
} else if (target_type == TypeManager.uint64_type){
//
// we can optimize this case: a positive int32
// to do it.
//
if (value >= 0)
- return new ULongConstant ((ulong) value);
+ return new ULongConstant ((ulong)System.Math.Round ( value));
+ } else if (target_type == TypeManager.float_type){
+ return new FloatConstant ((float) value);
+ } else if (target_type == TypeManager.double_type){
+ return new DoubleConstant ((double) value);
}
if (value == 0 && ic is IntLiteral && TypeManager.IsEnumType (target_type)){
TypeManager.MonoBASIC_Name (source) + "' to '" +
TypeManager.MonoBASIC_Name (target) + "'";
- Report.Error (29, loc, msg);
+ throw new Exception (msg);
+
+ Report.Error (30512, loc, msg);
}
/// <summary>
Expression e;
e = ConvertImplicit (ec, source, target_type, loc);
+
if (e != null)
return e;
+
if (source is DoubleLiteral && target_type == TypeManager.float_type){
Report.Error (664, loc,
"Double literal cannot be implicitly converted to " +
// ushort, int, uint, long, ulong, char
// or decimal
//
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math",".Round" , expr, loc);
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I1);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U1);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I2);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U2);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I4);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U4);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U4);
if (real_target_type == TypeManager.int64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I8);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I8);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U8);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_CH);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_CH);
} else if (expr_type == TypeManager.double_type){
//
// From double to byte, byte, short,
// ushort, int, uint, long, ulong,
// char, float or decimal
//
+ Expression rounded_expr = RTConversionExpression(ec, "System.Math",".Round" , expr, loc);
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I1);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U1);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I2);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U2);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I4);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U4);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U4);
if (real_target_type == TypeManager.int64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I8);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I8);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U8);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_CH);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_CH);
if (real_target_type == TypeManager.float_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_R4);
+ return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_R4);
}
// decimal is taken care of by the op_Explicit methods.
}
}
+
+ public class NumericToBoolCast : EmptyCast
+ {
+ Type src_type;
+
+ public NumericToBoolCast (Expression src, Type src_type)
+ : base (src, TypeManager.bool_type)
+
+ {
+ this.src_type = src_type;
+ }
+
+ public override Expression DoResolve (EmitContext ec)
+ {
+ return this;
+ }
+
+ public override void Emit (EmitContext ec)
+ {
+ base.Emit (ec);
+
+ if (src_type == TypeManager.byte_type ||
+ src_type == TypeManager.short_type ||
+ src_type == TypeManager.int32_type) {
+
+ ec.ig.Emit (OpCodes.Ldc_I4_0);
+ ec.ig.Emit (OpCodes.Cgt_Un);
+ return;
+ }
+
+ if (src_type == TypeManager.int64_type) {
+ ec.ig.Emit (OpCodes.Ldc_I8, (long) 0);
+ ec.ig.Emit (OpCodes.Cgt_Un);
+ return;
+ }
+
+ if (src_type == TypeManager.float_type) {
+ ec.ig.Emit (OpCodes.Ldc_R4, (float) 0);
+ ec.ig.Emit (OpCodes.Ceq);
+ ec.ig.Emit (OpCodes.Ldc_I4_0);
+ ec.ig.Emit (OpCodes.Ceq);
+ return;
+ }
+
+ if (src_type == TypeManager.double_type) {
+ ec.ig.Emit (OpCodes.Ldc_R8, (double) 0);
+ ec.ig.Emit (OpCodes.Ceq);
+ ec.ig.Emit (OpCodes.Ldc_I4_0);
+ ec.ig.Emit (OpCodes.Ceq);
+ return;
+ }
+ }
+ }
+
+ public class BoolToNumericCast : EmptyCast
+ {
+ Expression src;
+ Type target_type;
+ OpCode conv;
+
+ public BoolToNumericCast (Expression src, Type target_type)
+ : base (src, target_type)
+
+ {
+ this.target_type = target_type;
+ }
+
+ public override Expression DoResolve (EmitContext ec)
+ {
+ return this;
+ }
+
+ public override void Emit (EmitContext ec)
+ {
+ base.Emit (ec);
+
+ if (target_type == TypeManager.byte_type) {
+ conv = OpCodes.Conv_U1;
+ } else if (target_type == TypeManager.short_type) {
+ conv = OpCodes.Conv_I2;
+ } else if (target_type == TypeManager.int32_type) {
+ conv = OpCodes.Conv_I4;
+ } else if (target_type == TypeManager.int64_type) {
+ conv = OpCodes.Conv_I8;
+ } else if (target_type == TypeManager.float_type) {
+ conv = OpCodes.Conv_R4;
+ } else if (target_type == TypeManager.double_type) {
+ conv = OpCodes.Conv_R8;
+ }
+
+ ec.ig.Emit (OpCodes.Ldc_I4_0);
+ ec.ig.Emit (OpCodes.Cgt_Un);
+ ec.ig.Emit (OpCodes.Neg);
+ ec.ig.Emit (conv);
+ return;
+ }
+ }
+
/// <summary>
/// This kind of cast is used to encapsulate a child and cast it
/// to the class requested
{
PropertyInfo = pi;
eclass = ExprClass.PropertyAccess;
- PropertyArgs = new ArrayList();
+ PropertyArgs = null;
is_static = false;
loc = l;
override public Expression DoResolve (EmitContext ec)
{
if (getter == null){
- Report.Error (154, loc,
+ Report.Error (30524, loc,
"The property '" + PropertyInfo.Name +
"' can not be used in " +
"this context because it lacks a get accessor");
override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
{
if (setter == null){
- Report.Error (154, loc,
+ Report.Error (30526, loc,
"The property '" + PropertyInfo.Name +
"' can not be used in " +
"this context because it lacks a set accessor");
return;
}
}
+ if (PropertyArgs == null)
+ PropertyArgs = new ArrayList ();
Invocation.EmitCall (ec, IsBase, IsStatic, instance_expr, getter, null, PropertyArgs, loc);
}
}
}
+ Expression field_expr = null;
+
public override Expression DoResolve (EmitContext ec)
{
if (instance_expr != null) {
return null;
}
+ if (this.DeclaringType == ec.ContainerType) {
+ MemberInfo mi = GetFieldFromEvent (this);
+ if (mi == null)
+ return null;
+ field_expr = ExprClassFromMemberInfo (ec, mi, loc);
+ ((FieldExpr) field_expr).InstanceExpression = instance_expr;
+ field_expr = field_expr.DoResolve (ec);
+ if (field_expr == null)
+ return null;
+ }
+
return this;
}
public override void Emit (EmitContext ec)
{
- Report.Error (70, loc, "The event '" + Name + "' can only appear on the left hand side of += or -= (except on the defining type)");
+ if (field_expr != null)
+ field_expr.Emit (ec);
}
public void EmitAddOrRemove (EmitContext ec, Expression source)
projects / mono.git / blobdiff