X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fliteral.cs;h=0fd978219bcb87a393c8dafe248be6ba812005e5;hb=d660494ca016170ecf2204473ba6847c430a3b21;hp=7276689d1a722b11d8adc728007e79c200db4618;hpb=e5fe6c826dda8b351c309ba62d0032cc0bcd926e;p=mono.git diff --git a/mcs/mcs/literal.cs b/mcs/mcs/literal.cs index 7276689d1a7..0fd978219bc 100644 --- a/mcs/mcs/literal.cs +++ b/mcs/mcs/literal.cs @@ -30,78 +30,27 @@ namespace Mono.CSharp { // // Note: C# specification null-literal is NullLiteral of NullType type // - class NullLiteral : Constant + public class NullLiteral : NullConstant { // // Default type of null is an object // - public NullLiteral (Location loc): - this (typeof (NullLiteral), loc) + public NullLiteral (Location loc) + : base (InternalType.Null, loc) { } - // - // Null can have its own type, think of default (Foo) - // - public NullLiteral (Type type, Location loc) - : base (loc) - { - eclass = ExprClass.Value; - this.type = type; - } - - override public string AsString () - { - return GetSignatureForError (); - } - - public override Expression CreateExpressionTree (EmitContext ec) - { - // HACK: avoid referencing mcs internal type - if (type == typeof (NullLiteral)) - type = TypeManager.object_type; - - return base.CreateExpressionTree (ec); - } - - public override Expression DoResolve (EmitContext ec) - { - return this; - } - - public override void Emit (EmitContext ec) - { - ec.ig.Emit (OpCodes.Ldnull); - -#if GMCS_SOURCE - // Only to make verifier happy - if (TypeManager.IsGenericParameter (type)) - ec.ig.Emit (OpCodes.Unbox_Any, type); -#endif - } - - public override string ExprClassName { - get { - return GetSignatureForError (); - } - } - - public override string GetSignatureForError () - { - return "null"; - } - - public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type t, bool expl) + public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec t, bool expl) { - if (TypeManager.IsGenericParameter (t)) { - Report.Error(403, loc, + if (t.IsGenericParameter) { + ec.Report.Error(403, loc, "Cannot convert null to the type parameter `{0}' because it could be a value " + "type. Consider using `default ({0})' instead", t.Name); return; } if (TypeManager.IsValueType (t)) { - Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type", + ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type", TypeManager.CSharpName(t)); return; } @@ -109,67 +58,13 @@ namespace Mono.CSharp { base.Error_ValueCannotBeConverted (ec, loc, t, expl); } - public override Constant ConvertExplicitly (bool inCheckedContext, Type targetType) - { - if (targetType.IsPointer) { - if (type == TypeManager.null_type || this is NullPointer) - return new EmptyConstantCast (new NullPointer (loc), targetType); - - return null; - } - - // Exlude internal compiler types - if (targetType == TypeManager.anonymous_method_type) - return null; - - if (TypeManager.IsReferenceType (targetType)) - return new NullLiteral (targetType, loc); - - if (TypeManager.IsNullableType (targetType)) - return Nullable.LiftedNull.Create (targetType, loc); - - return null; - } - - public override Constant ConvertImplicitly (Type targetType) - { - // - // Null literal is of object type - // - if (targetType == TypeManager.object_type) - return this; - - return ConvertExplicitly (false, targetType); - } - - public override object GetValue () - { - return null; - } - - public override Constant Increment () - { - throw new NotSupportedException (); - } - - public override bool IsDefaultValue { - get { return true; } - } - public override bool IsLiteral { get { return true; } } - public override bool IsNegative { - get { return false; } - } - - public override bool IsNull { - get { return true; } - } - - public override bool IsZeroInteger { - get { return true; } + public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx) + { + return System.Linq.Expressions.Expression.Constant (null); } } @@ -185,13 +80,11 @@ namespace Mono.CSharp { public override void Emit (EmitContext ec) { - ILGenerator ig = ec.ig; - // // Emits null pointer // - ig.Emit (OpCodes.Ldc_I4_0); - ig.Emit (OpCodes.Conv_U); + ec.Emit (OpCodes.Ldc_I4_0); + ec.Emit (OpCodes.Conv_U); } } @@ -200,12 +93,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.bool_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -216,12 +103,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.char_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -232,25 +113,20 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) + public override Constant ConvertImplicitly (ResolveContext rc, TypeSpec type) { - type = TypeManager.int32_type; - return this; - } - - public override Constant ConvertImplicitly (Type type) - { - /// - /// The 0 literal can be converted to an enum value, - /// + // + // The 0 literal can be converted to an enum value + // if (Value == 0 && TypeManager.IsEnumType (type)) { - Constant c = ConvertImplicitly (TypeManager.GetEnumUnderlyingType (type)); + Constant c = ConvertImplicitly (rc, EnumSpec.GetUnderlyingType (type)); if (c == null) return null; - return new EnumConstant (c, type); + return new EnumConstant (c, type).Resolve (rc); } - return base.ConvertImplicitly (type); + + return base.ConvertImplicitly (rc, type); } public override bool IsLiteral { @@ -263,12 +139,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.uint32_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -279,12 +149,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.int64_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -295,12 +159,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.uint64_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -312,12 +170,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.float_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -329,31 +181,24 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.double_type; - - return this; - } - - public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type target, bool expl) + public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec target, bool expl) { if (target == TypeManager.float_type) { - Error_664 (loc, "float", "f"); + Error_664 (ec, loc, "float", "f"); return; } if (target == TypeManager.decimal_type) { - Error_664 (loc, "decimal", "m"); + Error_664 (ec, loc, "decimal", "m"); return; } base.Error_ValueCannotBeConverted (ec, loc, target, expl); } - static void Error_664 (Location loc, string type, string suffix) + static void Error_664 (ResolveContext ec, Location loc, string type, string suffix) { - Report.Error (664, loc, + ec.Report.Error (664, loc, "Literal of type double cannot be implicitly converted to type `{0}'. Add suffix `{1}' to create a literal of this type", type, suffix); } @@ -369,12 +214,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.decimal_type; - return this; - } - public override bool IsLiteral { get { return true; } } @@ -385,13 +224,6 @@ namespace Mono.CSharp { { } - public override Expression DoResolve (EmitContext ec) - { - type = TypeManager.string_type; - - return this; - } - public override bool IsLiteral { get { return true; } }