// Miguel de Icaza (miguel@ximian.com)
// Marek Safar (marek.safar@seznam.cz)
//
-// (C) 2001 Ximian, Inc.
+// Copyright 2001 Ximian, Inc.
//
//
// Notice that during parsing we create objects of type Literal, but the
// and are fully resolved when born.
//
-using System;
-using System.Reflection;
+#if STATIC
+using IKVM.Reflection.Emit;
+#else
using System.Reflection.Emit;
+#endif
-//
-// I put System.Null just so we do not have to special case it on
-// TypeManager.CSharpName
-//
-namespace System {
- //
- // Represents the Null Type, just used as a placeholder for the type in NullLiteral
- //
- public class Null {
- }
-}
-
namespace Mono.CSharp {
//
- // The NullType just exists to compare type equality, and for
- // expressions that might have the `null type'
+ // The null literal
//
- public class NullType {
- }
-
-
- public class NullConstant : Constant
+ // Note: C# specification null-literal is NullLiteral of NullType type
+ //
+ public class NullLiteral : NullConstant
{
- public NullConstant (Location loc):
- base (loc)
+ //
+ // Default type of null is an object
+ //
+ public NullLiteral (Location loc)
+ : base (InternalType.Null, loc)
{
- eclass = ExprClass.Value;
- type = TypeManager.null_type;
- }
-
- override public string AsString ()
- {
- return "null";
- }
-
- public override object GetValue ()
- {
- return null;
}
- public override void Emit (EmitContext ec)
+ public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec t, bool expl)
{
- ec.ig.Emit(OpCodes.Ldnull);
- }
-
- public override string ExprClassName {
- get {
- return GetSignatureForError ();
+ 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;
}
- }
-
- public override string GetSignatureForError ()
- {
- return "null";
- }
- public override Constant Increment ()
- {
- throw new NotSupportedException ();
- }
+ if (TypeManager.IsValueType (t)) {
+ ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
+ TypeManager.CSharpName(t));
+ return;
+ }
- public override bool IsDefaultValue
- {
- get { return true; }
+ base.Error_ValueCannotBeConverted (ec, loc, t, expl);
}
- public override bool IsNegative
+ public override string GetValueAsLiteral ()
{
- get { return false; }
+ return "null";
}
- public override bool IsZeroInteger
- {
+ public override bool IsLiteral {
get { return true; }
}
- public override Constant ConvertExplicitly(bool inCheckedContext, Type target_type)
- {
- if (!TypeManager.IsValueType (target_type))
- return new EmptyConstantCast (this, target_type);
-
- return null;
- }
-
- public override Constant ConvertImplicitly (Type targetType)
- {
- if (!TypeManager.IsValueType (targetType))
- return new EmptyConstantCast (this, targetType);
-
- return null;
- }
- }
-
- //
- // Represents default(X) when result can be reduced to null
- //
- public class NullDefault : EmptyConstantCast
- {
- public NullDefault(Constant value, Type type)
- : base (value, type)
- {
- }
-
- public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type target, bool expl)
- {
- base.Error_ValueCannotBeConverted (ec, loc, target, expl);
- }
- }
-
- //
- // The null Literal constant
- //
- public class NullLiteral : NullConstant {
- public NullLiteral (Location loc):
- base (loc)
- {
- }
-
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.null_type;
- return this;
- }
-
- public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type t, bool expl)
+ public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
- if (TypeManager.IsGenericParameter (t)) {
- 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);
- } else {
- Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
- TypeManager.CSharpName(t));
- }
+ return System.Linq.Expressions.Expression.Constant (null);
}
-
- public override Constant ConvertImplicitly (Type targetType)
- {
- if (targetType.IsPointer)
- return new EmptyConstantCast (NullPointer.Null, targetType);
-
- if (TypeManager.IsGenericParameter(targetType)) {
- GenericConstraints gc = null;
-
-#if GMCS_SOURCE
- gc = TypeManager.GetTypeParameterConstraints(targetType);
-#endif
- if (gc != null && gc.IsReferenceType)
- return new EmptyConstantCast (this, targetType);
-
- return null;
- }
-
- return base.ConvertImplicitly(targetType);
- }
-
}
//
// A null literal in a pointer context
//
- public class NullPointer : NullLiteral {
- public static readonly NullLiteral Null;
-
- static NullPointer ()
- {
- Null = new NullPointer ();
- }
-
- private NullPointer ():
- base (Location.Null)
+ class NullPointer : NullLiteral {
+ public NullPointer (Location loc):
+ base (loc)
{
type = TypeManager.object_type;
}
public override void Emit (EmitContext ec)
{
- ILGenerator ig = ec.ig;
-
- // TODO: why not use Ldnull instead ?
- ig.Emit (OpCodes.Ldc_I4_0);
- ig.Emit (OpCodes.Conv_U);
+ //
+ // Emits null pointer
+ //
+ ec.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Conv_U);
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.bool_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.char_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- 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.EnumToUnderlying (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 {
+ get { return true; }
+ }
}
public class UIntLiteral : UIntConstant {
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.uint32_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.int64_type;
-
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.uint64_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.float_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
+
}
public class DoubleLiteral : DoubleConstant {
{
}
- 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);
}
+
+ public override bool IsLiteral {
+ get { return true; }
+ }
+
}
public class DecimalLiteral : DecimalConstant {
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.decimal_type;
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
}
{
}
- public override Expression DoResolve (EmitContext ec)
- {
- type = TypeManager.string_type;
-
- return this;
+ public override bool IsLiteral {
+ get { return true; }
}
+
}
}
projects / mono.git / blobdiff