?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-11-15 Jb Evain <jbevain@novell.com>
[mcs.git] / mcs / constant.cs
blobc59a1ff1544f70316f3a3f868bd27c9c11ef2e3d
1 //
2 // constant.cs: Constants.
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Marek Safar (marek.safar@seznam.cz)
7 //
8 // Copyright 2001-2003 Ximian, Inc.
9 // Copyright 2003-2008 Novell, Inc.
10 //
11
12 namespace Mono.CSharp {
13
14 using System;
15 using System.Reflection.Emit;
16 using System.Collections;
17
18 /// <summary>
19 /// Base class for constants and literals.
20 /// </summary>
21 public abstract class Constant : Expression {
22
23 protected Constant (Location loc)
24 {
25 this.loc = loc;
26 }
27
28 /// <remarks>
29 /// This is different from ToString in that ToString
30 /// is supposed to be there for debugging purposes,
31 /// and is not guaranteed to be useful for anything else,
32 /// AsString() will provide something that can be used
33 /// for round-tripping C# code. Maybe it can be used
34 /// for IL assembly as well.
35 /// </remarks>
36 public abstract string AsString ();
37
38 override public string ToString ()
39 {
40 return this.GetType ().Name + " (" + AsString () + ")";
41 }
42
43 public override bool GetAttributableValue (ResolveContext ec, Type value_type, out object value)
44 {
45 if (value_type == TypeManager.object_type) {
46 value = GetTypedValue ();
47 return true;
48 }
49
50 Constant c = ImplicitConversionRequired (ec, value_type, loc);
51 if (c == null) {
52 value = null;
53 return false;
54 }
55
56 value = c.GetTypedValue ();
57 return true;
58 }
59
60 /// <summary>
61 /// This is used to obtain the actual value of the literal
62 /// cast into an object.
63 /// </summary>
64 public abstract object GetValue ();
65
66 public virtual object GetTypedValue ()
67 {
68 return GetValue ();
69 }
70
71 /// <summary>
72 /// Constants are always born in a fully resolved state
73 /// </summary>
74 public override Expression DoResolve (ResolveContext ec)
75 {
76 return this;
77 }
78
79 public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type target, bool expl)
80 {
81 if (!expl && IsLiteral &&
82 (TypeManager.IsPrimitiveType (target) || type == TypeManager.decimal_type) &&
83 (TypeManager.IsPrimitiveType (type) || type == TypeManager.decimal_type)) {
84 ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
85 AsString (), TypeManager.CSharpName (target));
86 } else {
87 base.Error_ValueCannotBeConverted (ec, loc, target, expl);
88 }
89 }
90
91 public Constant ImplicitConversionRequired (ResolveContext ec, Type type, Location loc)
92 {
93 Constant c = ConvertImplicitly (type);
94 if (c == null)
95 Error_ValueCannotBeConverted (ec, loc, type, false);
96 return c;
97 }
98
99 public virtual Constant ConvertImplicitly (Type type)
100 {
101 if (this.type == type)
102 return this;
103
104 if (Convert.ImplicitNumericConversion (this, type) == null)
105 return null;
106
107 bool fail;
108 object constant_value = TypeManager.ChangeType (GetValue (), type, out fail);
109 if (fail){
110 //
111 // We should always catch the error before this is ever
112 // reached, by calling Convert.ImplicitStandardConversionExists
113 //
114 throw new InternalErrorException ("Missing constant conversion between `{0}' and `{1}'",
115 TypeManager.CSharpName (Type), TypeManager.CSharpName (type));
116 }
117
118 return CreateConstant (type, constant_value, loc);
119 }
120
121 /// Returns a constant instance based on Type
122 /// The returned value is already resolved.
123 public static Constant CreateConstant (Type t, object v, Location loc)
124 {
125 if (t == TypeManager.int32_type)
126 return new IntConstant ((int) v, loc);
127 if (t == TypeManager.string_type)
128 return new StringConstant ((string) v, loc);
129 if (t == TypeManager.uint32_type)
130 return new UIntConstant ((uint) v, loc);
131 if (t == TypeManager.int64_type)
132 return new LongConstant ((long) v, loc);
133 if (t == TypeManager.uint64_type)
134 return new ULongConstant ((ulong) v, loc);
135 if (t == TypeManager.float_type)
136 return new FloatConstant ((float) v, loc);
137 if (t == TypeManager.double_type)
138 return new DoubleConstant ((double) v, loc);
139 if (t == TypeManager.short_type)
140 return new ShortConstant ((short)v, loc);
141 if (t == TypeManager.ushort_type)
142 return new UShortConstant ((ushort)v, loc);
143 if (t == TypeManager.sbyte_type)
144 return new SByteConstant ((sbyte)v, loc);
145 if (t == TypeManager.byte_type)
146 return new ByteConstant ((byte)v, loc);
147 if (t == TypeManager.char_type)
148 return new CharConstant ((char)v, loc);
149 if (t == TypeManager.bool_type)
150 return new BoolConstant ((bool) v, loc);
151 if (t == TypeManager.decimal_type)
152 return new DecimalConstant ((decimal) v, loc);
153 if (TypeManager.IsEnumType (t)) {
154 Type real_type = TypeManager.GetEnumUnderlyingType (t);
155 return new EnumConstant (CreateConstant (real_type, v, loc), t);
156 }
157 if (v == null) {
158 if (TypeManager.IsNullableType (t))
159 return Nullable.LiftedNull.Create (t, loc);
160
161 if (TypeManager.IsReferenceType (t))
162 return new NullConstant (t, loc);
163 }
164
165 throw new InternalErrorException ("Constant value `{0}' has unexpected underlying type `{1}'",
166 v, TypeManager.CSharpName (t));
167 }
168
169 public override Expression CreateExpressionTree (ResolveContext ec)
170 {
171 Arguments args = new Arguments (2);
172 args.Add (new Argument (this));
173 args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
174
175 return CreateExpressionFactoryCall (ec, "Constant", args);
176 }
177
178
179 /// <summary>
180 /// Maybe ConvertTo name is better. It tries to convert `this' constant to target_type.
181 /// It throws OverflowException
182 /// </summary>
183 // DON'T CALL THIS METHOD DIRECTLY AS IT DOES NOT HANDLE ENUMS
184 public abstract Constant ConvertExplicitly (bool in_checked_context, Type target_type);
185
186 /// <summary>
187 /// Attempts to do a compile-time folding of a constant cast.
188 /// </summary>
189 public Constant TryReduce (ResolveContext ec, Type target_type, Location loc)
190 {
191 try {
192 return TryReduce (ec, target_type);
193 }
194 catch (OverflowException) {
195 if (ec.ConstantCheckState) {
196 ec.Report.Error (221, loc, "Constant value `{0}' cannot be converted to a `{1}' (use `unchecked' syntax to override)",
197 GetValue ().ToString (), TypeManager.CSharpName (target_type));
198 } else {
199 Error_ValueCannotBeConverted (ec, loc, target_type, false);
200 }
201
202 return New.Constantify (target_type);
203 }
204 }
205
206 Constant TryReduce (ResolveContext ec, Type target_type)
207 {
208 if (Type == target_type)
209 return this;
210
211 if (TypeManager.IsEnumType (target_type)) {
212 Constant c = TryReduce (ec, TypeManager.GetEnumUnderlyingType (target_type));
213 if (c == null)
214 return null;
215
216 return new EnumConstant (c, target_type);
217 }
218
219 return ConvertExplicitly (ec.ConstantCheckState, target_type);
220 }
221
222 public abstract Constant Increment ();
223
224 /// <summary>
225 /// Need to pass type as the constant can require a boxing
226 /// and in such case no optimization is possible
227 /// </summary>
228 public bool IsDefaultInitializer (Type type)
229 {
230 if (type == Type)
231 return IsDefaultValue;
232
233 return this is NullLiteral;
234 }
235
236 public abstract bool IsDefaultValue {
237 get;
238 }
239
240 public abstract bool IsNegative {
241 get;
242 }
243
244 //
245 // When constant is declared as literal
246 //
247 public virtual bool IsLiteral {
248 get { return false; }
249 }
250
251 //
252 // Returns true iff 1) the stack type of this is one of Object,
253 // int32, int64 and 2) this == 0 or this == null.
254 //
255 public virtual bool IsZeroInteger {
256 get { return false; }
257 }
258
259 public override void EmitSideEffect (EmitContext ec)
260 {
261 // do nothing
262 }
263
264 protected override void CloneTo (CloneContext clonectx, Expression target)
265 {
266 // CloneTo: Nothing, we do not keep any state on this expression
267 }
268
269 #if NET_4_0
270 public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
271 {
272 return System.Linq.Expressions.Expression.Constant (GetTypedValue (), type);
273 }
274 #endif
275
276 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
277 {
278 // A constant cannot be of generic type
279 }
280 }
281
282 public abstract class IntegralConstant : Constant {
283 protected IntegralConstant (Location loc) :
284 base (loc)
285 {
286 }
287
288 public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, Type target, bool expl)
289 {
290 try {
291 ConvertExplicitly (true, target);
292 base.Error_ValueCannotBeConverted (ec, loc, target, expl);
293 }
294 catch
295 {
296 ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
297 GetValue ().ToString (), TypeManager.CSharpName (target));
298 }
299 }
300 }
301
302 public class BoolConstant : Constant {
303 public readonly bool Value;
304
305 public BoolConstant (bool val, Location loc):
306 base (loc)
307 {
308 type = TypeManager.bool_type;
309 eclass = ExprClass.Value;
310
311 Value = val;
312 }
313
314 override public string AsString ()
315 {
316 return Value ? "true" : "false";
317 }
318
319 public override object GetValue ()
320 {
321 return (object) Value;
322 }
323
324
325 public override void Emit (EmitContext ec)
326 {
327 if (Value)
328 ec.ig.Emit (OpCodes.Ldc_I4_1);
329 else
330 ec.ig.Emit (OpCodes.Ldc_I4_0);
331 }
332
333 public override Constant Increment ()
334 {
335 throw new NotSupportedException ();
336 }
337
338 public override bool IsDefaultValue {
339 get {
340 return !Value;
341 }
342 }
343
344 public override bool IsNegative {
345 get {
346 return false;
347 }
348 }
349
350 public override bool IsZeroInteger {
351 get { return Value == false; }
352 }
353
354 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
355 {
356 return null;
357 }
358
359 }
360
361 public class ByteConstant : IntegralConstant {
362 public readonly byte Value;
363
364 public ByteConstant (byte v, Location loc):
365 base (loc)
366 {
367 type = TypeManager.byte_type;
368 eclass = ExprClass.Value;
369 Value = v;
370 }
371
372 public override void Emit (EmitContext ec)
373 {
374 IntLiteral.EmitInt (ec.ig, Value);
375 }
376
377 public override string AsString ()
378 {
379 return Value.ToString ();
380 }
381
382 public override object GetValue ()
383 {
384 return Value;
385 }
386
387 public override Constant Increment ()
388 {
389 return new ByteConstant (checked ((byte)(Value + 1)), loc);
390 }
391
392 public override bool IsDefaultValue {
393 get {
394 return Value == 0;
395 }
396 }
397
398 public override bool IsNegative {
399 get {
400 return false;
401 }
402 }
403
404 public override bool IsZeroInteger {
405 get { return Value == 0; }
406 }
407
408 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
409 {
410 if (target_type == TypeManager.sbyte_type) {
411 if (in_checked_context){
412 if (Value > SByte.MaxValue)
413 throw new OverflowException ();
414 }
415 return new SByteConstant ((sbyte) Value, Location);
416 }
417 if (target_type == TypeManager.short_type)
418 return new ShortConstant ((short) Value, Location);
419 if (target_type == TypeManager.ushort_type)
420 return new UShortConstant ((ushort) Value, Location);
421 if (target_type == TypeManager.int32_type)
422 return new IntConstant ((int) Value, Location);
423 if (target_type == TypeManager.uint32_type)
424 return new UIntConstant ((uint) Value, Location);
425 if (target_type == TypeManager.int64_type)
426 return new LongConstant ((long) Value, Location);
427 if (target_type == TypeManager.uint64_type)
428 return new ULongConstant ((ulong) Value, Location);
429 if (target_type == TypeManager.float_type)
430 return new FloatConstant ((float) Value, Location);
431 if (target_type == TypeManager.double_type)
432 return new DoubleConstant ((double) Value, Location);
433 if (target_type == TypeManager.char_type)
434 return new CharConstant ((char) Value, Location);
435 if (target_type == TypeManager.decimal_type)
436 return new DecimalConstant ((decimal) Value, Location);
437
438 return null;
439 }
440
441 }
442
443 public class CharConstant : Constant {
444 public readonly char Value;
445
446 public CharConstant (char v, Location loc):
447 base (loc)
448 {
449 type = TypeManager.char_type;
450 eclass = ExprClass.Value;
451 Value = v;
452 }
453
454 public override void Emit (EmitContext ec)
455 {
456 IntLiteral.EmitInt (ec.ig, Value);
457 }
458
459 static public string descape (char c)
460 {
461 switch (c){
462 case '\a':
463 return "\\a";
464 case '\b':
465 return "\\b";
466 case '\n':
467 return "\\n";
468 case '\t':
469 return "\\t";
470 case '\v':
471 return "\\v";
472 case '\r':
473 return "\\r";
474 case '\\':
475 return "\\\\";
476 case '\f':
477 return "\\f";
478 case '\0':
479 return "\\0";
480 case '"':
481 return "\\\"";
482 case '\'':
483 return "\\\'";
484 }
485 return c.ToString ();
486 }
487
488 public override string AsString ()
489 {
490 return "\"" + descape (Value) + "\"";
491 }
492
493 public override object GetValue ()
494 {
495 return Value;
496 }
497
498 public override Constant Increment ()
499 {
500 return new CharConstant (checked ((char)(Value + 1)), loc);
501 }
502
503 public override bool IsDefaultValue {
504 get {
505 return Value == 0;
506 }
507 }
508
509 public override bool IsNegative {
510 get {
511 return false;
512 }
513 }
514
515 public override bool IsZeroInteger {
516 get { return Value == '\0'; }
517 }
518
519 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
520 {
521 if (target_type == TypeManager.byte_type) {
522 if (in_checked_context){
523 if (Value < Byte.MinValue || Value > Byte.MaxValue)
524 throw new OverflowException ();
525 }
526 return new ByteConstant ((byte) Value, Location);
527 }
528 if (target_type == TypeManager.sbyte_type) {
529 if (in_checked_context){
530 if (Value > SByte.MaxValue)
531 throw new OverflowException ();
532 }
533 return new SByteConstant ((sbyte) Value, Location);
534 }
535 if (target_type == TypeManager.short_type) {
536 if (in_checked_context){
537 if (Value > Int16.MaxValue)
538 throw new OverflowException ();
539 }
540 return new ShortConstant ((short) Value, Location);
541 }
542 if (target_type == TypeManager.int32_type)
543 return new IntConstant ((int) Value, Location);
544 if (target_type == TypeManager.uint32_type)
545 return new UIntConstant ((uint) Value, Location);
546 if (target_type == TypeManager.int64_type)
547 return new LongConstant ((long) Value, Location);
548 if (target_type == TypeManager.uint64_type)
549 return new ULongConstant ((ulong) Value, Location);
550 if (target_type == TypeManager.float_type)
551 return new FloatConstant ((float) Value, Location);
552 if (target_type == TypeManager.double_type)
553 return new DoubleConstant ((double) Value, Location);
554 if (target_type == TypeManager.decimal_type)
555 return new DecimalConstant ((decimal) Value, Location);
556
557 return null;
558 }
559
560 }
561
562 public class SByteConstant : IntegralConstant {
563 public readonly sbyte Value;
564
565 public SByteConstant (sbyte v, Location loc):
566 base (loc)
567 {
568 type = TypeManager.sbyte_type;
569 eclass = ExprClass.Value;
570 Value = v;
571 }
572
573 public override void Emit (EmitContext ec)
574 {
575 IntLiteral.EmitInt (ec.ig, Value);
576 }
577
578 public override string AsString ()
579 {
580 return Value.ToString ();
581 }
582
583 public override object GetValue ()
584 {
585 return Value;
586 }
587
588 public override Constant Increment ()
589 {
590 return new SByteConstant (checked((sbyte)(Value + 1)), loc);
591 }
592
593 public override bool IsDefaultValue {
594 get {
595 return Value == 0;
596 }
597 }
598
599 public override bool IsNegative {
600 get {
601 return Value < 0;
602 }
603 }
604
605 public override bool IsZeroInteger {
606 get { return Value == 0; }
607 }
608
609 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
610 {
611 if (target_type == TypeManager.byte_type) {
612 if (in_checked_context && Value < 0)
613 throw new OverflowException ();
614 return new ByteConstant ((byte) Value, Location);
615 }
616 if (target_type == TypeManager.short_type)
617 return new ShortConstant ((short) Value, Location);
618 if (target_type == TypeManager.ushort_type) {
619 if (in_checked_context && Value < 0)
620 throw new OverflowException ();
621 return new UShortConstant ((ushort) Value, Location);
622 } if (target_type == TypeManager.int32_type)
623 return new IntConstant ((int) Value, Location);
624 if (target_type == TypeManager.uint32_type) {
625 if (in_checked_context && Value < 0)
626 throw new OverflowException ();
627 return new UIntConstant ((uint) Value, Location);
628 } if (target_type == TypeManager.int64_type)
629 return new LongConstant ((long) Value, Location);
630 if (target_type == TypeManager.uint64_type) {
631 if (in_checked_context && Value < 0)
632 throw new OverflowException ();
633 return new ULongConstant ((ulong) Value, Location);
634 }
635 if (target_type == TypeManager.float_type)
636 return new FloatConstant ((float) Value, Location);
637 if (target_type == TypeManager.double_type)
638 return new DoubleConstant ((double) Value, Location);
639 if (target_type == TypeManager.char_type) {
640 if (in_checked_context && Value < 0)
641 throw new OverflowException ();
642 return new CharConstant ((char) Value, Location);
643 }
644 if (target_type == TypeManager.decimal_type)
645 return new DecimalConstant ((decimal) Value, Location);
646
647 return null;
648 }
649
650 }
651
652 public class ShortConstant : IntegralConstant {
653 public readonly short Value;
654
655 public ShortConstant (short v, Location loc):
656 base (loc)
657 {
658 type = TypeManager.short_type;
659 eclass = ExprClass.Value;
660 Value = v;
661 }
662
663 public override void Emit (EmitContext ec)
664 {
665 IntLiteral.EmitInt (ec.ig, Value);
666 }
667
668 public override string AsString ()
669 {
670 return Value.ToString ();
671 }
672
673 public override object GetValue ()
674 {
675 return Value;
676 }
677
678 public override Constant Increment ()
679 {
680 return new ShortConstant (checked((short)(Value + 1)), loc);
681 }
682
683 public override bool IsDefaultValue {
684 get {
685 return Value == 0;
686 }
687 }
688
689 public override bool IsZeroInteger {
690 get { return Value == 0; }
691 }
692
693 public override bool IsNegative {
694 get {
695 return Value < 0;
696 }
697 }
698
699 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
700 {
701 if (target_type == TypeManager.byte_type) {
702 if (in_checked_context){
703 if (Value < Byte.MinValue || Value > Byte.MaxValue)
704 throw new OverflowException ();
705 }
706 return new ByteConstant ((byte) Value, Location);
707 }
708 if (target_type == TypeManager.sbyte_type) {
709 if (in_checked_context){
710 if (Value < SByte.MinValue || Value > SByte.MaxValue)
711 throw new OverflowException ();
712 }
713 return new SByteConstant ((sbyte) Value, Location);
714 }
715 if (target_type == TypeManager.ushort_type) {
716 if (in_checked_context && Value < 0)
717 throw new OverflowException ();
718
719 return new UShortConstant ((ushort) Value, Location);
720 }
721 if (target_type == TypeManager.int32_type)
722 return new IntConstant ((int) Value, Location);
723 if (target_type == TypeManager.uint32_type) {
724 if (in_checked_context && Value < 0)
725 throw new OverflowException ();
726 return new UIntConstant ((uint) Value, Location);
727 }
728 if (target_type == TypeManager.int64_type)
729 return new LongConstant ((long) Value, Location);
730 if (target_type == TypeManager.uint64_type) {
731 if (in_checked_context && Value < 0)
732 throw new OverflowException ();
733 return new ULongConstant ((ulong) Value, Location);
734 }
735 if (target_type == TypeManager.float_type)
736 return new FloatConstant ((float) Value, Location);
737 if (target_type == TypeManager.double_type)
738 return new DoubleConstant ((double) Value, Location);
739 if (target_type == TypeManager.char_type) {
740 if (in_checked_context){
741 if (Value < Char.MinValue)
742 throw new OverflowException ();
743 }
744 return new CharConstant ((char) Value, Location);
745 }
746 if (target_type == TypeManager.decimal_type)
747 return new DecimalConstant ((decimal) Value, Location);
748
749 return null;
750 }
751
752 }
753
754 public class UShortConstant : IntegralConstant {
755 public readonly ushort Value;
756
757 public UShortConstant (ushort v, Location loc):
758 base (loc)
759 {
760 type = TypeManager.ushort_type;
761 eclass = ExprClass.Value;
762 Value = v;
763 }
764
765 public override void Emit (EmitContext ec)
766 {
767 IntLiteral.EmitInt (ec.ig, Value);
768 }
769
770 public override string AsString ()
771 {
772 return Value.ToString ();
773 }
774
775 public override object GetValue ()
776 {
777 return Value;
778 }
779
780 public override Constant Increment ()
781 {
782 return new UShortConstant (checked((ushort)(Value + 1)), loc);
783 }
784
785 public override bool IsDefaultValue {
786 get {
787 return Value == 0;
788 }
789 }
790
791 public override bool IsNegative {
792 get {
793 return false;
794 }
795 }
796
797 public override bool IsZeroInteger {
798 get { return Value == 0; }
799 }
800
801 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
802 {
803 if (target_type == TypeManager.byte_type) {
804 if (in_checked_context){
805 if (Value > Byte.MaxValue)
806 throw new OverflowException ();
807 }
808 return new ByteConstant ((byte) Value, Location);
809 }
810 if (target_type == TypeManager.sbyte_type) {
811 if (in_checked_context){
812 if (Value > SByte.MaxValue)
813 throw new OverflowException ();
814 }
815 return new SByteConstant ((sbyte) Value, Location);
816 }
817 if (target_type == TypeManager.short_type) {
818 if (in_checked_context){
819 if (Value > Int16.MaxValue)
820 throw new OverflowException ();
821 }
822 return new ShortConstant ((short) Value, Location);
823 }
824 if (target_type == TypeManager.int32_type)
825 return new IntConstant ((int) Value, Location);
826 if (target_type == TypeManager.uint32_type)
827 return new UIntConstant ((uint) Value, Location);
828 if (target_type == TypeManager.int64_type)
829 return new LongConstant ((long) Value, Location);
830 if (target_type == TypeManager.uint64_type)
831 return new ULongConstant ((ulong) Value, Location);
832 if (target_type == TypeManager.float_type)
833 return new FloatConstant ((float) Value, Location);
834 if (target_type == TypeManager.double_type)
835 return new DoubleConstant ((double) Value, Location);
836 if (target_type == TypeManager.char_type) {
837 if (in_checked_context){
838 if (Value > Char.MaxValue)
839 throw new OverflowException ();
840 }
841 return new CharConstant ((char) Value, Location);
842 }
843 if (target_type == TypeManager.decimal_type)
844 return new DecimalConstant ((decimal) Value, Location);
845
846 return null;
847 }
848 }
849
850 public class IntConstant : IntegralConstant {
851 public readonly int Value;
852
853 public IntConstant (int v, Location loc):
854 base (loc)
855 {
856 type = TypeManager.int32_type;
857 eclass = ExprClass.Value;
858 Value = v;
859 }
860
861 static public void EmitInt (ILGenerator ig, int i)
862 {
863 switch (i){
864 case -1:
865 ig.Emit (OpCodes.Ldc_I4_M1);
866 break;
867
868 case 0:
869 ig.Emit (OpCodes.Ldc_I4_0);
870 break;
871
872 case 1:
873 ig.Emit (OpCodes.Ldc_I4_1);
874 break;
875
876 case 2:
877 ig.Emit (OpCodes.Ldc_I4_2);
878 break;
879
880 case 3:
881 ig.Emit (OpCodes.Ldc_I4_3);
882 break;
883
884 case 4:
885 ig.Emit (OpCodes.Ldc_I4_4);
886 break;
887
888 case 5:
889 ig.Emit (OpCodes.Ldc_I4_5);
890 break;
891
892 case 6:
893 ig.Emit (OpCodes.Ldc_I4_6);
894 break;
895
896 case 7:
897 ig.Emit (OpCodes.Ldc_I4_7);
898 break;
899
900 case 8:
901 ig.Emit (OpCodes.Ldc_I4_8);
902 break;
903
904 default:
905 if (i >= -128 && i <= 127){
906 ig.Emit (OpCodes.Ldc_I4_S, (sbyte) i);
907 } else
908 ig.Emit (OpCodes.Ldc_I4, i);
909 break;
910 }
911 }
912
913 public override void Emit (EmitContext ec)
914 {
915 EmitInt (ec.ig, Value);
916 }
917
918 public override string AsString ()
919 {
920 return Value.ToString ();
921 }
922
923 public override object GetValue ()
924 {
925 return Value;
926 }
927
928 public override Constant Increment ()
929 {
930 return new IntConstant (checked(Value + 1), loc);
931 }
932
933 public override bool IsDefaultValue {
934 get {
935 return Value == 0;
936 }
937 }
938
939 public override bool IsNegative {
940 get {
941 return Value < 0;
942 }
943 }
944
945 public override bool IsZeroInteger {
946 get { return Value == 0; }
947 }
948
949 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
950 {
951 if (target_type == TypeManager.byte_type) {
952 if (in_checked_context){
953 if (Value < Byte.MinValue || Value > Byte.MaxValue)
954 throw new OverflowException ();
955 }
956 return new ByteConstant ((byte) Value, Location);
957 }
958 if (target_type == TypeManager.sbyte_type) {
959 if (in_checked_context){
960 if (Value < SByte.MinValue || Value > SByte.MaxValue)
961 throw new OverflowException ();
962 }
963 return new SByteConstant ((sbyte) Value, Location);
964 }
965 if (target_type == TypeManager.short_type) {
966 if (in_checked_context){
967 if (Value < Int16.MinValue || Value > Int16.MaxValue)
968 throw new OverflowException ();
969 }
970 return new ShortConstant ((short) Value, Location);
971 }
972 if (target_type == TypeManager.ushort_type) {
973 if (in_checked_context){
974 if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
975 throw new OverflowException ();
976 }
977 return new UShortConstant ((ushort) Value, Location);
978 }
979 if (target_type == TypeManager.uint32_type) {
980 if (in_checked_context){
981 if (Value < UInt32.MinValue)
982 throw new OverflowException ();
983 }
984 return new UIntConstant ((uint) Value, Location);
985 }
986 if (target_type == TypeManager.int64_type)
987 return new LongConstant ((long) Value, Location);
988 if (target_type == TypeManager.uint64_type) {
989 if (in_checked_context && Value < 0)
990 throw new OverflowException ();
991 return new ULongConstant ((ulong) Value, Location);
992 }
993 if (target_type == TypeManager.float_type)
994 return new FloatConstant ((float) Value, Location);
995 if (target_type == TypeManager.double_type)
996 return new DoubleConstant ((double) Value, Location);
997 if (target_type == TypeManager.char_type) {
998 if (in_checked_context){
999 if (Value < Char.MinValue || Value > Char.MaxValue)
1000 throw new OverflowException ();
1001 }
1002 return new CharConstant ((char) Value, Location);
1003 }
1004 if (target_type == TypeManager.decimal_type)
1005 return new DecimalConstant ((decimal) Value, Location);
1006
1007 return null;
1008 }
1009
1010 public override Constant ConvertImplicitly (Type type)
1011 {
1012 if (this.type == type)
1013 return this;
1014
1015 Constant c = TryImplicitIntConversion (type);
1016 if (c != null)
1017 return c;
1018
1019 return base.ConvertImplicitly (type);
1020 }
1021
1022 /// <summary>
1023 /// Attempts to perform an implicit constant conversion of the IntConstant
1024 /// into a different data type using casts (See Implicit Constant
1025 /// Expression Conversions)
1026 /// </summary>
1027 Constant TryImplicitIntConversion (Type target_type)
1028 {
1029 if (target_type == TypeManager.sbyte_type) {
1030 if (Value >= SByte.MinValue && Value <= SByte.MaxValue)
1031 return new SByteConstant ((sbyte) Value, loc);
1032 }
1033 else if (target_type == TypeManager.byte_type) {
1034 if (Value >= Byte.MinValue && Value <= Byte.MaxValue)
1035 return new ByteConstant ((byte) Value, loc);
1036 }
1037 else if (target_type == TypeManager.short_type) {
1038 if (Value >= Int16.MinValue && Value <= Int16.MaxValue)
1039 return new ShortConstant ((short) Value, loc);
1040 }
1041 else if (target_type == TypeManager.ushort_type) {
1042 if (Value >= UInt16.MinValue && Value <= UInt16.MaxValue)
1043 return new UShortConstant ((ushort) Value, loc);
1044 }
1045 else if (target_type == TypeManager.uint32_type) {
1046 if (Value >= 0)
1047 return new UIntConstant ((uint) Value, loc);
1048 }
1049 else if (target_type == TypeManager.uint64_type) {
1050 //
1051 // we can optimize this case: a positive int32
1052 // always fits on a uint64. But we need an opcode
1053 // to do it.
1054 //
1055 if (Value >= 0)
1056 return new ULongConstant ((ulong) Value, loc);
1057 }
1058 else if (target_type == TypeManager.double_type)
1059 return new DoubleConstant ((double) Value, loc);
1060 else if (target_type == TypeManager.float_type)
1061 return new FloatConstant ((float) Value, loc);
1062
1063 return null;
1064 }
1065 }
1066
1067 public class UIntConstant : IntegralConstant {
1068 public readonly uint Value;
1069
1070 public UIntConstant (uint v, Location loc):
1071 base (loc)
1072 {
1073 type = TypeManager.uint32_type;
1074 eclass = ExprClass.Value;
1075 Value = v;
1076 }
1077
1078 public override void Emit (EmitContext ec)
1079 {
1080 IntLiteral.EmitInt (ec.ig, unchecked ((int) Value));
1081 }
1082
1083 public override string AsString ()
1084 {
1085 return Value.ToString ();
1086 }
1087
1088 public override object GetValue ()
1089 {
1090 return Value;
1091 }
1092
1093 public override Constant Increment ()
1094 {
1095 return new UIntConstant (checked(Value + 1), loc);
1096 }
1097
1098 public override bool IsDefaultValue {
1099 get {
1100 return Value == 0;
1101 }
1102 }
1103
1104 public override bool IsNegative {
1105 get {
1106 return false;
1107 }
1108 }
1109
1110 public override bool IsZeroInteger {
1111 get { return Value == 0; }
1112 }
1113
1114 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1115 {
1116 if (target_type == TypeManager.byte_type) {
1117 if (in_checked_context){
1118 if (Value < Char.MinValue || Value > Char.MaxValue)
1119 throw new OverflowException ();
1120 }
1121 return new ByteConstant ((byte) Value, Location);
1122 }
1123 if (target_type == TypeManager.sbyte_type) {
1124 if (in_checked_context){
1125 if (Value > SByte.MaxValue)
1126 throw new OverflowException ();
1127 }
1128 return new SByteConstant ((sbyte) Value, Location);
1129 }
1130 if (target_type == TypeManager.short_type) {
1131 if (in_checked_context){
1132 if (Value > Int16.MaxValue)
1133 throw new OverflowException ();
1134 }
1135 return new ShortConstant ((short) Value, Location);
1136 }
1137 if (target_type == TypeManager.ushort_type) {
1138 if (in_checked_context){
1139 if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
1140 throw new OverflowException ();
1141 }
1142 return new UShortConstant ((ushort) Value, Location);
1143 }
1144 if (target_type == TypeManager.int32_type) {
1145 if (in_checked_context){
1146 if (Value > Int32.MaxValue)
1147 throw new OverflowException ();
1148 }
1149 return new IntConstant ((int) Value, Location);
1150 }
1151 if (target_type == TypeManager.int64_type)
1152 return new LongConstant ((long) Value, Location);
1153 if (target_type == TypeManager.uint64_type)
1154 return new ULongConstant ((ulong) Value, Location);
1155 if (target_type == TypeManager.float_type)
1156 return new FloatConstant ((float) Value, Location);
1157 if (target_type == TypeManager.double_type)
1158 return new DoubleConstant ((double) Value, Location);
1159 if (target_type == TypeManager.char_type) {
1160 if (in_checked_context){
1161 if (Value < Char.MinValue || Value > Char.MaxValue)
1162 throw new OverflowException ();
1163 }
1164 return new CharConstant ((char) Value, Location);
1165 }
1166 if (target_type == TypeManager.decimal_type)
1167 return new DecimalConstant ((decimal) Value, Location);
1168
1169 return null;
1170 }
1171
1172 }
1173
1174 public class LongConstant : IntegralConstant {
1175 public readonly long Value;
1176
1177 public LongConstant (long v, Location loc):
1178 base (loc)
1179 {
1180 type = TypeManager.int64_type;
1181 eclass = ExprClass.Value;
1182 Value = v;
1183 }
1184
1185 public override void Emit (EmitContext ec)
1186 {
1187 EmitLong (ec.ig, Value);
1188 }
1189
1190 static public void EmitLong (ILGenerator ig, long l)
1191 {
1192 if (l >= int.MinValue && l <= int.MaxValue) {
1193 IntLiteral.EmitInt (ig, unchecked ((int) l));
1194 ig.Emit (OpCodes.Conv_I8);
1195 return;
1196 }
1197
1198 if (l >= 0 && l <= uint.MaxValue) {
1199 IntLiteral.EmitInt (ig, unchecked ((int) l));
1200 ig.Emit (OpCodes.Conv_U8);
1201 return;
1202 }
1203
1204 ig.Emit (OpCodes.Ldc_I8, l);
1205 }
1206
1207 public override string AsString ()
1208 {
1209 return Value.ToString ();
1210 }
1211
1212 public override object GetValue ()
1213 {
1214 return Value;
1215 }
1216
1217 public override Constant Increment ()
1218 {
1219 return new LongConstant (checked(Value + 1), loc);
1220 }
1221
1222 public override bool IsDefaultValue {
1223 get {
1224 return Value == 0;
1225 }
1226 }
1227
1228 public override bool IsNegative {
1229 get {
1230 return Value < 0;
1231 }
1232 }
1233
1234 public override bool IsZeroInteger {
1235 get { return Value == 0; }
1236 }
1237
1238 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1239 {
1240 if (target_type == TypeManager.byte_type) {
1241 if (in_checked_context){
1242 if (Value < Byte.MinValue || Value > Byte.MaxValue)
1243 throw new OverflowException ();
1244 }
1245 return new ByteConstant ((byte) Value, Location);
1246 }
1247 if (target_type == TypeManager.sbyte_type) {
1248 if (in_checked_context){
1249 if (Value < SByte.MinValue || Value > SByte.MaxValue)
1250 throw new OverflowException ();
1251 }
1252 return new SByteConstant ((sbyte) Value, Location);
1253 }
1254 if (target_type == TypeManager.short_type) {
1255 if (in_checked_context){
1256 if (Value < Int16.MinValue || Value > Int16.MaxValue)
1257 throw new OverflowException ();
1258 }
1259 return new ShortConstant ((short) Value, Location);
1260 }
1261 if (target_type == TypeManager.ushort_type) {
1262 if (in_checked_context){
1263 if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
1264 throw new OverflowException ();
1265 }
1266 return new UShortConstant ((ushort) Value, Location);
1267 }
1268 if (target_type == TypeManager.int32_type) {
1269 if (in_checked_context){
1270 if (Value < Int32.MinValue || Value > Int32.MaxValue)
1271 throw new OverflowException ();
1272 }
1273 return new IntConstant ((int) Value, Location);
1274 }
1275 if (target_type == TypeManager.uint32_type) {
1276 if (in_checked_context){
1277 if (Value < UInt32.MinValue || Value > UInt32.MaxValue)
1278 throw new OverflowException ();
1279 }
1280 return new UIntConstant ((uint) Value, Location);
1281 }
1282 if (target_type == TypeManager.uint64_type) {
1283 if (in_checked_context && Value < 0)
1284 throw new OverflowException ();
1285 return new ULongConstant ((ulong) Value, Location);
1286 }
1287 if (target_type == TypeManager.float_type)
1288 return new FloatConstant ((float) Value, Location);
1289 if (target_type == TypeManager.double_type)
1290 return new DoubleConstant ((double) Value, Location);
1291 if (target_type == TypeManager.char_type) {
1292 if (in_checked_context){
1293 if (Value < Char.MinValue || Value > Char.MaxValue)
1294 throw new OverflowException ();
1295 }
1296 return new CharConstant ((char) Value, Location);
1297 }
1298 if (target_type == TypeManager.decimal_type)
1299 return new DecimalConstant ((decimal) Value, Location);
1300
1301 return null;
1302 }
1303
1304 public override Constant ConvertImplicitly (Type type)
1305 {
1306 if (Value >= 0 && type == TypeManager.uint64_type) {
1307 return new ULongConstant ((ulong) Value, loc);
1308 }
1309
1310 return base.ConvertImplicitly (type);
1311 }
1312 }
1313
1314 public class ULongConstant : IntegralConstant {
1315 public readonly ulong Value;
1316
1317 public ULongConstant (ulong v, Location loc):
1318 base (loc)
1319 {
1320 type = TypeManager.uint64_type;
1321 eclass = ExprClass.Value;
1322 Value = v;
1323 }
1324
1325 public override void Emit (EmitContext ec)
1326 {
1327 ILGenerator ig = ec.ig;
1328
1329 LongLiteral.EmitLong (ig, unchecked ((long) Value));
1330 }
1331
1332 public override string AsString ()
1333 {
1334 return Value.ToString ();
1335 }
1336
1337 public override object GetValue ()
1338 {
1339 return Value;
1340 }
1341
1342 public override Constant Increment ()
1343 {
1344 return new ULongConstant (checked(Value + 1), loc);
1345 }
1346
1347 public override bool IsDefaultValue {
1348 get {
1349 return Value == 0;
1350 }
1351 }
1352
1353 public override bool IsNegative {
1354 get {
1355 return false;
1356 }
1357 }
1358
1359 public override bool IsZeroInteger {
1360 get { return Value == 0; }
1361 }
1362
1363 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1364 {
1365 if (target_type == TypeManager.byte_type) {
1366 if (in_checked_context && Value > Byte.MaxValue)
1367 throw new OverflowException ();
1368 return new ByteConstant ((byte) Value, Location);
1369 }
1370 if (target_type == TypeManager.sbyte_type) {
1371 if (in_checked_context && Value > ((ulong) SByte.MaxValue))
1372 throw new OverflowException ();
1373 return new SByteConstant ((sbyte) Value, Location);
1374 }
1375 if (target_type == TypeManager.short_type) {
1376 if (in_checked_context && Value > ((ulong) Int16.MaxValue))
1377 throw new OverflowException ();
1378 return new ShortConstant ((short) Value, Location);
1379 }
1380 if (target_type == TypeManager.ushort_type) {
1381 if (in_checked_context && Value > UInt16.MaxValue)
1382 throw new OverflowException ();
1383 return new UShortConstant ((ushort) Value, Location);
1384 }
1385 if (target_type == TypeManager.int32_type) {
1386 if (in_checked_context && Value > UInt32.MaxValue)
1387 throw new OverflowException ();
1388 return new IntConstant ((int) Value, Location);
1389 }
1390 if (target_type == TypeManager.uint32_type) {
1391 if (in_checked_context && Value > UInt32.MaxValue)
1392 throw new OverflowException ();
1393 return new UIntConstant ((uint) Value, Location);
1394 }
1395 if (target_type == TypeManager.int64_type) {
1396 if (in_checked_context && Value > Int64.MaxValue)
1397 throw new OverflowException ();
1398 return new LongConstant ((long) Value, Location);
1399 }
1400 if (target_type == TypeManager.float_type)
1401 return new FloatConstant ((float) Value, Location);
1402 if (target_type == TypeManager.double_type)
1403 return new DoubleConstant ((double) Value, Location);
1404 if (target_type == TypeManager.char_type) {
1405 if (in_checked_context && Value > Char.MaxValue)
1406 throw new OverflowException ();
1407 return new CharConstant ((char) Value, Location);
1408 }
1409 if (target_type == TypeManager.decimal_type)
1410 return new DecimalConstant ((decimal) Value, Location);
1411
1412 return null;
1413 }
1414
1415 }
1416
1417 public class FloatConstant : Constant {
1418 public float Value;
1419
1420 public FloatConstant (float v, Location loc):
1421 base (loc)
1422 {
1423 type = TypeManager.float_type;
1424 eclass = ExprClass.Value;
1425 Value = v;
1426 }
1427
1428 public override void Emit (EmitContext ec)
1429 {
1430 ec.ig.Emit (OpCodes.Ldc_R4, Value);
1431 }
1432
1433 public override string AsString ()
1434 {
1435 return Value.ToString ();
1436 }
1437
1438 public override object GetValue ()
1439 {
1440 return Value;
1441 }
1442
1443 public override Constant Increment ()
1444 {
1445 return new FloatConstant (checked(Value + 1), loc);
1446 }
1447
1448 public override bool IsDefaultValue {
1449 get {
1450 return Value == 0;
1451 }
1452 }
1453
1454 public override bool IsNegative {
1455 get {
1456 return Value < 0;
1457 }
1458 }
1459
1460 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1461 {
1462 if (target_type == TypeManager.byte_type) {
1463 if (in_checked_context){
1464 if (Value < byte.MinValue || Value > byte.MaxValue || float.IsNaN (Value))
1465 throw new OverflowException ();
1466 }
1467 return new ByteConstant ((byte) Value, Location);
1468 }
1469 if (target_type == TypeManager.sbyte_type) {
1470 if (in_checked_context){
1471 if (Value < sbyte.MinValue || Value > sbyte.MaxValue || float.IsNaN (Value))
1472 throw new OverflowException ();
1473 }
1474 return new SByteConstant ((sbyte) Value, Location);
1475 }
1476 if (target_type == TypeManager.short_type) {
1477 if (in_checked_context){
1478 if (Value < short.MinValue || Value > short.MaxValue || float.IsNaN (Value))
1479 throw new OverflowException ();
1480 }
1481 return new ShortConstant ((short) Value, Location);
1482 }
1483 if (target_type == TypeManager.ushort_type) {
1484 if (in_checked_context){
1485 if (Value < ushort.MinValue || Value > ushort.MaxValue || float.IsNaN (Value))
1486 throw new OverflowException ();
1487 }
1488 return new UShortConstant ((ushort) Value, Location);
1489 }
1490 if (target_type == TypeManager.int32_type) {
1491 if (in_checked_context){
1492 if (Value < int.MinValue || Value > int.MaxValue || float.IsNaN (Value))
1493 throw new OverflowException ();
1494 }
1495 return new IntConstant ((int) Value, Location);
1496 }
1497 if (target_type == TypeManager.uint32_type) {
1498 if (in_checked_context){
1499 if (Value < uint.MinValue || Value > uint.MaxValue || float.IsNaN (Value))
1500 throw new OverflowException ();
1501 }
1502 return new UIntConstant ((uint) Value, Location);
1503 }
1504 if (target_type == TypeManager.int64_type) {
1505 if (in_checked_context){
1506 if (Value < long.MinValue || Value > long.MaxValue || float.IsNaN (Value))
1507 throw new OverflowException ();
1508 }
1509 return new LongConstant ((long) Value, Location);
1510 }
1511 if (target_type == TypeManager.uint64_type) {
1512 if (in_checked_context){
1513 if (Value < ulong.MinValue || Value > ulong.MaxValue || float.IsNaN (Value))
1514 throw new OverflowException ();
1515 }
1516 return new ULongConstant ((ulong) Value, Location);
1517 }
1518 if (target_type == TypeManager.double_type)
1519 return new DoubleConstant ((double) Value, Location);
1520 if (target_type == TypeManager.char_type) {
1521 if (in_checked_context){
1522 if (Value < (float) char.MinValue || Value > (float) char.MaxValue || float.IsNaN (Value))
1523 throw new OverflowException ();
1524 }
1525 return new CharConstant ((char) Value, Location);
1526 }
1527 if (target_type == TypeManager.decimal_type)
1528 return new DecimalConstant ((decimal) Value, Location);
1529
1530 return null;
1531 }
1532
1533 }
1534
1535 public class DoubleConstant : Constant {
1536 public double Value;
1537
1538 public DoubleConstant (double v, Location loc):
1539 base (loc)
1540 {
1541 type = TypeManager.double_type;
1542 eclass = ExprClass.Value;
1543 Value = v;
1544 }
1545
1546 public override void Emit (EmitContext ec)
1547 {
1548 ec.ig.Emit (OpCodes.Ldc_R8, Value);
1549 }
1550
1551 public override string AsString ()
1552 {
1553 return Value.ToString ();
1554 }
1555
1556 public override object GetValue ()
1557 {
1558 return Value;
1559 }
1560
1561 public override Constant Increment ()
1562 {
1563 return new DoubleConstant (checked(Value + 1), loc);
1564 }
1565
1566 public override bool IsDefaultValue {
1567 get {
1568 return Value == 0;
1569 }
1570 }
1571
1572 public override bool IsNegative {
1573 get {
1574 return Value < 0;
1575 }
1576 }
1577
1578 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1579 {
1580 if (target_type == TypeManager.byte_type) {
1581 if (in_checked_context){
1582 if (Value < Byte.MinValue || Value > Byte.MaxValue || double.IsNaN (Value))
1583 throw new OverflowException ();
1584 }
1585 return new ByteConstant ((byte) Value, Location);
1586 }
1587 if (target_type == TypeManager.sbyte_type) {
1588 if (in_checked_context){
1589 if (Value < SByte.MinValue || Value > SByte.MaxValue || double.IsNaN (Value))
1590 throw new OverflowException ();
1591 }
1592 return new SByteConstant ((sbyte) Value, Location);
1593 }
1594 if (target_type == TypeManager.short_type) {
1595 if (in_checked_context){
1596 if (Value < short.MinValue || Value > short.MaxValue || double.IsNaN (Value))
1597 throw new OverflowException ();
1598 }
1599 return new ShortConstant ((short) Value, Location);
1600 }
1601 if (target_type == TypeManager.ushort_type) {
1602 if (in_checked_context){
1603 if (Value < ushort.MinValue || Value > ushort.MaxValue || double.IsNaN (Value))
1604 throw new OverflowException ();
1605 }
1606 return new UShortConstant ((ushort) Value, Location);
1607 }
1608 if (target_type == TypeManager.int32_type) {
1609 if (in_checked_context){
1610 if (Value < int.MinValue || Value > int.MaxValue || double.IsNaN (Value))
1611 throw new OverflowException ();
1612 }
1613 return new IntConstant ((int) Value, Location);
1614 }
1615 if (target_type == TypeManager.uint32_type) {
1616 if (in_checked_context){
1617 if (Value < uint.MinValue || Value > uint.MaxValue || double.IsNaN (Value))
1618 throw new OverflowException ();
1619 }
1620 return new UIntConstant ((uint) Value, Location);
1621 }
1622 if (target_type == TypeManager.int64_type) {
1623 if (in_checked_context){
1624 if (Value < long.MinValue || Value > long.MaxValue || double.IsNaN (Value))
1625 throw new OverflowException ();
1626 }
1627 return new LongConstant ((long) Value, Location);
1628 }
1629 if (target_type == TypeManager.uint64_type) {
1630 if (in_checked_context){
1631 if (Value < ulong.MinValue || Value > ulong.MaxValue || double.IsNaN (Value))
1632 throw new OverflowException ();
1633 }
1634 return new ULongConstant ((ulong) Value, Location);
1635 }
1636 if (target_type == TypeManager.float_type)
1637 return new FloatConstant ((float) Value, Location);
1638 if (target_type == TypeManager.char_type) {
1639 if (in_checked_context){
1640 if (Value < (double) char.MinValue || Value > (double) char.MaxValue || double.IsNaN (Value))
1641 throw new OverflowException ();
1642 }
1643 return new CharConstant ((char) Value, Location);
1644 }
1645 if (target_type == TypeManager.decimal_type)
1646 return new DecimalConstant ((decimal) Value, Location);
1647
1648 return null;
1649 }
1650
1651 }
1652
1653 public class DecimalConstant : Constant {
1654 public readonly decimal Value;
1655
1656 public DecimalConstant (decimal d, Location loc):
1657 base (loc)
1658 {
1659 type = TypeManager.decimal_type;
1660 eclass = ExprClass.Value;
1661 Value = d;
1662 }
1663
1664 override public string AsString ()
1665 {
1666 return Value.ToString () + "M";
1667 }
1668
1669 public override object GetValue ()
1670 {
1671 return (object) Value;
1672 }
1673
1674 public override void Emit (EmitContext ec)
1675 {
1676 ILGenerator ig = ec.ig;
1677
1678 int [] words = decimal.GetBits (Value);
1679 int power = (words [3] >> 16) & 0xff;
1680
1681 if (power == 0) {
1682 if (Value <= int.MaxValue && Value >= int.MinValue) {
1683 if (TypeManager.void_decimal_ctor_int_arg == null) {
1684 TypeManager.void_decimal_ctor_int_arg = TypeManager.GetPredefinedConstructor (
1685 TypeManager.decimal_type, loc, TypeManager.int32_type);
1686
1687 if (TypeManager.void_decimal_ctor_int_arg == null)
1688 return;
1689 }
1690
1691 IntConstant.EmitInt (ig, (int) Value);
1692 ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_int_arg);
1693 return;
1694 }
1695
1696 if (Value <= long.MaxValue && Value >= long.MinValue) {
1697 if (TypeManager.void_decimal_ctor_long_arg == null) {
1698 TypeManager.void_decimal_ctor_long_arg = TypeManager.GetPredefinedConstructor (
1699 TypeManager.decimal_type, loc, TypeManager.int64_type);
1700
1701 if (TypeManager.void_decimal_ctor_long_arg == null)
1702 return;
1703 }
1704
1705 LongConstant.EmitLong (ig, (long) Value);
1706 ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_long_arg);
1707 return;
1708 }
1709 }
1710
1711 IntConstant.EmitInt (ig, words [0]);
1712 IntConstant.EmitInt (ig, words [1]);
1713 IntConstant.EmitInt (ig, words [2]);
1714
1715 // sign
1716 IntConstant.EmitInt (ig, words [3] >> 31);
1717
1718 // power
1719 IntConstant.EmitInt (ig, power);
1720
1721 if (TypeManager.void_decimal_ctor_five_args == null) {
1722 TypeManager.void_decimal_ctor_five_args = TypeManager.GetPredefinedConstructor (
1723 TypeManager.decimal_type, loc, TypeManager.int32_type, TypeManager.int32_type,
1724 TypeManager.int32_type, TypeManager.bool_type, TypeManager.byte_type);
1725
1726 if (TypeManager.void_decimal_ctor_five_args == null)
1727 return;
1728 }
1729
1730 ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_five_args);
1731 }
1732
1733 public override Constant Increment ()
1734 {
1735 return new DecimalConstant (checked (Value + 1), loc);
1736 }
1737
1738 public override bool IsDefaultValue {
1739 get {
1740 return Value == 0;
1741 }
1742 }
1743
1744 public override bool IsNegative {
1745 get {
1746 return Value < 0;
1747 }
1748 }
1749
1750 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1751 {
1752 if (target_type == TypeManager.sbyte_type)
1753 return new SByteConstant ((sbyte)Value, loc);
1754 if (target_type == TypeManager.byte_type)
1755 return new ByteConstant ((byte)Value, loc);
1756 if (target_type == TypeManager.short_type)
1757 return new ShortConstant ((short)Value, loc);
1758 if (target_type == TypeManager.ushort_type)
1759 return new UShortConstant ((ushort)Value, loc);
1760 if (target_type == TypeManager.int32_type)
1761 return new IntConstant ((int)Value, loc);
1762 if (target_type == TypeManager.uint32_type)
1763 return new UIntConstant ((uint)Value, loc);
1764 if (target_type == TypeManager.int64_type)
1765 return new LongConstant ((long)Value, loc);
1766 if (target_type == TypeManager.uint64_type)
1767 return new ULongConstant ((ulong)Value, loc);
1768 if (target_type == TypeManager.char_type)
1769 return new CharConstant ((char)Value, loc);
1770 if (target_type == TypeManager.float_type)
1771 return new FloatConstant ((float)Value, loc);
1772 if (target_type == TypeManager.double_type)
1773 return new DoubleConstant ((double)Value, loc);
1774
1775 return null;
1776 }
1777
1778 }
1779
1780 public class StringConstant : Constant {
1781 public readonly string Value;
1782
1783 public StringConstant (string s, Location loc):
1784 base (loc)
1785 {
1786 type = TypeManager.string_type;
1787 eclass = ExprClass.Value;
1788 Value = s;
1789 }
1790
1791 // FIXME: Escape the string.
1792 override public string AsString ()
1793 {
1794 return "\"" + Value + "\"";
1795 }
1796
1797 public override object GetValue ()
1798 {
1799 return Value;
1800 }
1801
1802 public override void Emit (EmitContext ec)
1803 {
1804 if (Value == null) {
1805 ec.ig.Emit (OpCodes.Ldnull);
1806 return;
1807 }
1808
1809 //
1810 // Use string.Empty for both literals and constants even if
1811 // it's not allowed at language level
1812 //
1813 if (Value.Length == 0 && RootContext.Optimize && !TypeManager.IsEqual (ec.CurrentType, TypeManager.string_type)) {
1814 if (TypeManager.string_empty == null)
1815 TypeManager.string_empty = TypeManager.GetPredefinedField (TypeManager.string_type, "Empty", loc);
1816
1817 if (TypeManager.string_empty != null) {
1818 ec.ig.Emit (OpCodes.Ldsfld, TypeManager.string_empty);
1819 return;
1820 }
1821 }
1822
1823 ec.ig.Emit (OpCodes.Ldstr, Value);
1824 }
1825
1826 public override Constant Increment ()
1827 {
1828 throw new NotSupportedException ();
1829 }
1830
1831 public override bool IsDefaultValue {
1832 get {
1833 return Value == null;
1834 }
1835 }
1836
1837 public override bool IsNegative {
1838 get {
1839 return false;
1840 }
1841 }
1842
1843 public override bool IsNull {
1844 get {
1845 return IsDefaultValue;
1846 }
1847 }
1848
1849 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
1850 {
1851 return null;
1852 }
1853 }
1854
1855 //
1856 // Null constant can have its own type, think of `default (Foo)'
1857 //
1858 public class NullConstant : Constant
1859 {
1860 public NullConstant (Type type, Location loc)
1861 : base (loc)
1862 {
1863 eclass = ExprClass.Value;
1864 this.type = type;
1865 }
1866
1867 public override string AsString ()
1868 {
1869 return GetSignatureForError ();
1870 }
1871
1872 public override Expression DoResolve (ResolveContext ec)
1873 {
1874 return this;
1875 }
1876
1877 public override void Emit (EmitContext ec)
1878 {
1879 ec.ig.Emit (OpCodes.Ldnull);
1880
1881 // Only to make verifier happy
1882 if (TypeManager.IsGenericParameter (type))
1883 ec.ig.Emit (OpCodes.Unbox_Any, type);
1884 }
1885
1886 public override string ExprClassName {
1887 get {
1888 return GetSignatureForError ();
1889 }
1890 }
1891
1892 public override string GetSignatureForError ()
1893 {
1894 return "null";
1895 }
1896
1897 public override Constant ConvertExplicitly (bool inCheckedContext, Type targetType)
1898 {
1899 if (targetType.IsPointer) {
1900 if (IsLiteral || this is NullPointer)
1901 return new EmptyConstantCast (new NullPointer (loc), targetType);
1902
1903 return null;
1904 }
1905
1906 // Exlude internal compiler types
1907 if (targetType == InternalType.AnonymousMethod)
1908 return null;
1909
1910 if (!IsLiteral && !Convert.ImplicitStandardConversionExists (this, targetType))
1911 return null;
1912
1913 if (TypeManager.IsReferenceType (targetType))
1914 return new NullConstant (targetType, loc);
1915
1916 if (TypeManager.IsNullableType (targetType))
1917 return Nullable.LiftedNull.Create (targetType, loc);
1918
1919 return null;
1920 }
1921
1922 public override Constant ConvertImplicitly (Type targetType)
1923 {
1924 return ConvertExplicitly (false, targetType);
1925 }
1926
1927 public override object GetValue ()
1928 {
1929 return null;
1930 }
1931
1932 public override Constant Increment ()
1933 {
1934 throw new NotSupportedException ();
1935 }
1936
1937 public override bool IsDefaultValue {
1938 get { return true; }
1939 }
1940
1941 public override bool IsNegative {
1942 get { return false; }
1943 }
1944
1945 public override bool IsNull {
1946 get { return true; }
1947 }
1948
1949 public override bool IsZeroInteger {
1950 get { return true; }
1951 }
1952
1953 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1954 {
1955 type = storey.MutateType (type);
1956 }
1957 }
1958
1959 /// <summary>
1960 /// The value is constant, but when emitted has a side effect. This is
1961 /// used by BitwiseAnd to ensure that the second expression is invoked
1962 /// regardless of the value of the left side.
1963 /// </summary>
1964 public class SideEffectConstant : Constant {
1965 public Constant value;
1966 Expression side_effect;
1967
1968 public SideEffectConstant (Constant value, Expression side_effect, Location loc) : base (loc)
1969 {
1970 this.value = value;
1971 while (side_effect is SideEffectConstant)
1972 side_effect = ((SideEffectConstant) side_effect).side_effect;
1973 this.side_effect = side_effect;
1974 eclass = ExprClass.Value;
1975 type = value.Type;
1976 }
1977
1978 public override string AsString ()
1979 {
1980 return value.AsString ();
1981 }
1982
1983 public override object GetValue ()
1984 {
1985 return value.GetValue ();
1986 }
1987
1988 public override void Emit (EmitContext ec)
1989 {
1990 side_effect.EmitSideEffect (ec);
1991 value.Emit (ec);
1992 }
1993
1994 public override void EmitSideEffect (EmitContext ec)
1995 {
1996 side_effect.EmitSideEffect (ec);
1997 value.EmitSideEffect (ec);
1998 }
1999
2000 public override bool IsDefaultValue {
2001 get { return value.IsDefaultValue; }
2002 }
2003
2004 public override Constant Increment ()
2005 {
2006 throw new NotSupportedException ();
2007 }
2008
2009 public override bool IsNegative {
2010 get { return value.IsNegative; }
2011 }
2012
2013 public override bool IsZeroInteger {
2014 get { return value.IsZeroInteger; }
2015 }
2016
2017 public override Constant ConvertExplicitly (bool in_checked_context, Type target_type)
2018 {
2019 Constant new_value = value.ConvertExplicitly (in_checked_context, target_type);
2020 return new_value == null ? null : new SideEffectConstant (new_value, side_effect, new_value.Location);
2021 }
2022 }
2023 }
git-svn mirror of mcs