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