mcs/literal.cs

   1 //
   2 // literal.cs: Literal representation for the IL tree.
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Marek Safar (marek.safar@seznam.cz)
   7 //
   8 // Copyright 2001 Ximian, Inc.
   9 //
  10 //
  11 // Notice that during parsing we create objects of type Literal, but the
  12 // types are not loaded (thats why the Resolve method has to assign the
  13 // type at that point).
  14 //
  15 // Literals differ from the constants in that we know we encountered them
  16 // as a literal in the source code (and some extra rules apply there) and
  17 // they have to be resolved (since during parsing we have not loaded the
  18 // types yet) while constants are created only after types have been loaded
  19 // and are fully resolved when born.
  20 //
  21
  22 using System;
  23 using System.Reflection;
  24 using System.Reflection.Emit;
  25
  26 namespace Mono.CSharp {
  27
  28         //
  29         // The null literal
  30         //
  31         // Note: C# specification null-literal is NullLiteral of NullType type
  32         //
  33         public class NullLiteral : NullConstant
  34         {
  35                 //
  36                 // Default type of null is an object
  37                 //
  38                 public NullLiteral (Location loc)
  39                         : base (typeof (NullLiteral), loc)
  40                 {
  41                 }
  42
  43                 public override Expression CreateExpressionTree (ResolveContext ec)
  44                 {
  45                         // Optimized version, also avoids referencing literal internal type
  46                         Arguments args = new Arguments (1);
  47                         args.Add (new Argument (this));
  48                         return CreateExpressionFactoryCall (ec, "Constant", args);
  49                 }
  50
  51                 public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type t, bool expl)
  52                 {
  53                         if (TypeManager.IsGenericParameter (t)) {
  54                                 ec.Report.Error(403, loc,
  55                                         "Cannot convert null to the type parameter `{0}' because it could be a value " +
  56                                         "type. Consider using `default ({0})' instead", t.Name);
  57                                 return;
  58                         }
  59
  60                         if (TypeManager.IsValueType (t)) {
  61                                 ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
  62                                         TypeManager.CSharpName(t));
  63                                 return;
  64                         }
  65
  66                         base.Error_ValueCannotBeConverted (ec, loc, t, expl);
  67                 }
  68
  69                 public override Constant ConvertImplicitly (Type targetType)
  70                 {
  71                         //
  72                         // Null literal is of object type
  73                         //
  74                         if (targetType == TypeManager.object_type)
  75                                 return this;
  76
  77                         return base.ConvertImplicitly (targetType);
  78                 }
  79
  80                 public override bool IsLiteral {
  81                         get { return true; }
  82                 }
  83
  84 #if NET_4_0
  85                 public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
  86                 {
  87                         return System.Linq.Expressions.Expression.Constant (null);
  88                 }
  89 #endif
  90         }
  91
  92         //
  93         // A null literal in a pointer context
  94         //
  95         class NullPointer : NullLiteral {
  96                 public NullPointer (Location loc):
  97                         base (loc)
  98                 {
  99                         type = TypeManager.object_type;
 100                 }
 101
 102                 public override void Emit (EmitContext ec)
 103                 {
 104                         ILGenerator ig = ec.ig;
 105
 106                         //
 107                         // Emits null pointer
 108                         //
 109                         ig.Emit (OpCodes.Ldc_I4_0);
 110                         ig.Emit (OpCodes.Conv_U);
 111                 }
 112         }
 113
 114         public class BoolLiteral : BoolConstant {
 115                 public BoolLiteral (bool val, Location loc) : base (val, loc)
 116                 {
 117                 }
 118
 119                 public override Expression DoResolve (ResolveContext ec)
 120                 {
 121                         type = TypeManager.bool_type;
 122                         return this;
 123                 }
 124
 125                 public override bool IsLiteral {
 126                         get { return true; }
 127                 }
 128         }
 129
 130         public class CharLiteral : CharConstant {
 131                 public CharLiteral (char c, Location loc) : base (c, loc)
 132                 {
 133                 }
 134
 135                 public override Expression DoResolve (ResolveContext ec)
 136                 {
 137                         type = TypeManager.char_type;
 138                         return this;
 139                 }
 140
 141                 public override bool IsLiteral {
 142                         get { return true; }
 143                 }
 144         }
 145
 146         public class IntLiteral : IntConstant {
 147                 public IntLiteral (int l, Location loc) : base (l, loc)
 148                 {
 149                 }
 150
 151                 public override Expression DoResolve (ResolveContext ec)
 152                 {
 153                         type = TypeManager.int32_type;
 154                         return this;
 155                 }
 156
 157                 public override Constant ConvertImplicitly (Type type)
 158                 {
 159                         ///
 160                         /// The 0 literal can be converted to an enum value,
 161                         ///
 162                         if (Value == 0 && TypeManager.IsEnumType (type)) {
 163                                 Constant c = ConvertImplicitly (TypeManager.GetEnumUnderlyingType (type));
 164                                 if (c == null)
 165                                         return null;
 166
 167                                 return new EnumConstant (c, type);
 168                         }
 169                         return base.ConvertImplicitly (type);
 170                 }
 171
 172                 public override bool IsLiteral {
 173                         get { return true; }
 174                 }
 175         }
 176
 177         public class UIntLiteral : UIntConstant {
 178                 public UIntLiteral (uint l, Location loc) : base (l, loc)
 179                 {
 180                 }
 181
 182                 public override Expression DoResolve (ResolveContext ec)
 183                 {
 184                         type = TypeManager.uint32_type;
 185                         return this;
 186                 }
 187
 188                 public override bool IsLiteral {
 189                         get { return true; }
 190                 }
 191         }
 192
 193         public class LongLiteral : LongConstant {
 194                 public LongLiteral (long l, Location loc) : base (l, loc)
 195                 {
 196                 }
 197
 198                 public override Expression DoResolve (ResolveContext ec)
 199                 {
 200                         type = TypeManager.int64_type;
 201                         return this;
 202                 }
 203
 204                 public override bool IsLiteral {
 205                         get { return true; }
 206                 }
 207         }
 208
 209         public class ULongLiteral : ULongConstant {
 210                 public ULongLiteral (ulong l, Location loc) : base (l, loc)
 211                 {
 212                 }
 213
 214                 public override Expression DoResolve (ResolveContext ec)
 215                 {
 216                         type = TypeManager.uint64_type;
 217                         return this;
 218                 }
 219
 220                 public override bool IsLiteral {
 221                         get { return true; }
 222                 }
 223         }
 224
 225         public class FloatLiteral : FloatConstant {
 226
 227                 public FloatLiteral (float f, Location loc) : base (f, loc)
 228                 {
 229                 }
 230
 231                 public override Expression DoResolve (ResolveContext ec)
 232                 {
 233                         type = TypeManager.float_type;
 234                         return this;
 235                 }
 236
 237                 public override bool IsLiteral {
 238                         get { return true; }
 239                 }
 240
 241         }
 242
 243         public class DoubleLiteral : DoubleConstant {
 244                 public DoubleLiteral (double d, Location loc) : base (d, loc)
 245                 {
 246                 }
 247
 248                 public override Expression DoResolve (ResolveContext ec)
 249                 {
 250                         type = TypeManager.double_type;
 251
 252                         return this;
 253                 }
 254
 255                 public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type target, bool expl)
 256                 {
 257                         if (target == TypeManager.float_type) {
 258                                 Error_664 (ec, loc, "float", "f");
 259                                 return;
 260                         }
 261
 262                         if (target == TypeManager.decimal_type) {
 263                                 Error_664 (ec, loc, "decimal", "m");
 264                                 return;
 265                         }
 266
 267                         base.Error_ValueCannotBeConverted (ec, loc, target, expl);
 268                 }
 269
 270                 static void Error_664 (ResolveContext ec, Location loc, string type, string suffix)
 271                 {
 272                         ec.Report.Error (664, loc,
 273                                 "Literal of type double cannot be implicitly converted to type `{0}'. Add suffix `{1}' to create a literal of this type",
 274                                 type, suffix);
 275                 }
 276
 277                 public override bool IsLiteral {
 278                         get { return true; }
 279                 }
 280
 281         }
 282
 283         public class DecimalLiteral : DecimalConstant {
 284                 public DecimalLiteral (decimal d, Location loc) : base (d, loc)
 285                 {
 286                 }
 287
 288                 public override Expression DoResolve (ResolveContext ec)
 289                 {
 290                         type = TypeManager.decimal_type;
 291                         return this;
 292                 }
 293
 294                 public override bool IsLiteral {
 295                         get { return true; }
 296                 }
 297         }
 298
 299         public class StringLiteral : StringConstant {
 300                 public StringLiteral (string s, Location loc) : base (s, loc)
 301                 {
 302                 }
 303
 304                 public override Expression DoResolve (ResolveContext ec)
 305                 {
 306                         type = TypeManager.string_type;
 307
 308                         return this;
 309                 }
 310
 311                 public override bool IsLiteral {
 312                         get { return true; }
 313                 }
 314
 315         }
 316 }