Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2389-EpsLexicase/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Parser/mcs/constant.cs

Last change on this file was 11700, checked in by jkarder, 10 years ago

#2077: created branch and added first version
File size: 64.0 KB
Line 
1//
2// constant.cs: Constants.
3//
4// Author:
5//   Miguel de Icaza (miguel@ximian.com)
6//   Marek Safar (marek.safar@gmail.com)
7//
8// Copyright 2001-2003 Ximian, Inc.
9// Copyright 2003-2008 Novell, Inc.
10// Copyright 2011-2013 Xamarin Inc
11//
12
13using System;
14using System.Globalization;
15
16#if STATIC
17using IKVM.Reflection.Emit;
18#else
19using System.Reflection.Emit;
20#endif
21
22namespace Mono.CSharp {
23
24  /// <summary>
25  ///   Base class for constants and literals.
26  /// </summary>
27  public abstract class Constant : Expression
28  {
29    static readonly NumberFormatInfo nfi = CultureInfo.InvariantCulture.NumberFormat;
30
31    protected Constant (Location loc)
32    {
33      this.loc = loc;
34    }
35
36    override public string ToString ()
37    {
38      return this.GetType ().Name + " (" + GetValueAsLiteral () + ")";
39    }
40
41    /// <summary>
42    ///  This is used to obtain the actual value of the literal
43    ///  cast into an object.
44    /// </summary>
45    public abstract object GetValue ();
46
47    public abstract long GetValueAsLong ();
48
49    public abstract string GetValueAsLiteral ();
50
51#if !STATIC
52    //
53    // Returns an object value which is typed to contant type
54    //
55    public virtual object GetTypedValue ()
56    {
57      return GetValue ();
58    }
59#endif
60
61    public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
62    {
63      if (!expl && IsLiteral &&
64        BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (target) &&
65        BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (type)) {
66        ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
67          GetValueAsLiteral (), target.GetSignatureForError ());
68      } else {
69        base.Error_ValueCannotBeConverted (ec, target, expl);
70      }
71    }
72
73    public Constant ImplicitConversionRequired (ResolveContext ec, TypeSpec type)
74    {
75      Constant c = ConvertImplicitly (type);
76      if (c == null)
77        Error_ValueCannotBeConverted (ec, type, false);
78
79      return c;
80    }
81
82    public override bool ContainsEmitWithAwait ()
83    {
84      return false;
85    }
86
87    public virtual Constant ConvertImplicitly (TypeSpec type)
88    {
89      if (this.type == type)
90        return this;
91
92      if (!Convert.ImplicitNumericConversionExists (this.type, type))
93        return null;
94
95      bool fail;     
96      object constant_value = ChangeType (GetValue (), type, out fail);
97      if (fail){
98        //
99        // We should always catch the error before this is ever
100        // reached, by calling Convert.ImplicitStandardConversionExists
101        //
102        throw new InternalErrorException ("Missing constant conversion between `{0}' and `{1}'",
103         Type.GetSignatureForError (), type.GetSignatureForError ());
104      }
105
106      return CreateConstantFromValue (type, constant_value, loc);
107    }
108
109    //
110    //  Returns a constant instance based on Type
111    //
112    public static Constant CreateConstantFromValue (TypeSpec t, object v, Location loc)
113    {
114      switch (t.BuiltinType) {
115      case BuiltinTypeSpec.Type.Int:
116        return new IntConstant (t, (int) v, loc);
117      case BuiltinTypeSpec.Type.String:
118        return new StringConstant (t, (string) v, loc);
119      case BuiltinTypeSpec.Type.UInt:
120        return new UIntConstant (t, (uint) v, loc);
121      case BuiltinTypeSpec.Type.Long:
122        return new LongConstant (t, (long) v, loc);
123      case BuiltinTypeSpec.Type.ULong:
124        return new ULongConstant (t, (ulong) v, loc);
125      case BuiltinTypeSpec.Type.Float:
126        return new FloatConstant (t, (float) v, loc);
127      case BuiltinTypeSpec.Type.Double:
128        return new DoubleConstant (t, (double) v, loc);
129      case BuiltinTypeSpec.Type.Short:
130        return new ShortConstant (t, (short) v, loc);
131      case BuiltinTypeSpec.Type.UShort:
132        return new UShortConstant (t, (ushort) v, loc);
133      case BuiltinTypeSpec.Type.SByte:
134        return new SByteConstant (t, (sbyte) v, loc);
135      case BuiltinTypeSpec.Type.Byte:
136        return new ByteConstant (t, (byte) v, loc);
137      case BuiltinTypeSpec.Type.Char:
138        return new CharConstant (t, (char) v, loc);
139      case BuiltinTypeSpec.Type.Bool:
140        return new BoolConstant (t, (bool) v, loc);
141      case BuiltinTypeSpec.Type.Decimal:
142        return new DecimalConstant (t, (decimal) v, loc);
143      }
144
145      if (t.IsEnum) {
146        var real_type = EnumSpec.GetUnderlyingType (t);
147        return new EnumConstant (CreateConstantFromValue (real_type, v, loc), t);
148      }
149
150      if (v == null) {
151        if (t.IsNullableType)
152          return Nullable.LiftedNull.Create (t, loc);
153
154        if (TypeSpec.IsReferenceType (t))
155          return new NullConstant (t, loc);
156      }
157
158#if STATIC
159      throw new InternalErrorException ("Constant value `{0}' has unexpected underlying type `{1}'", v, t.GetSignatureForError ());
160#else
161      return null;
162#endif
163    }
164
165    //
166    // Returns a constant instance based on value and type. This is probing version of
167    // CreateConstantFromValue
168    //
169    public static Constant ExtractConstantFromValue (TypeSpec t, object v, Location loc)
170    {
171      switch (t.BuiltinType) {
172      case BuiltinTypeSpec.Type.Int:
173        if (v is int)
174          return new IntConstant (t, (int) v, loc);
175        break;
176      case BuiltinTypeSpec.Type.String:
177        if (v is string)
178          return new StringConstant (t, (string) v, loc);
179        break;
180      case BuiltinTypeSpec.Type.UInt:
181        if (v is uint)
182          return new UIntConstant (t, (uint) v, loc);
183        break;
184      case BuiltinTypeSpec.Type.Long:
185        if (v is long)
186          return new LongConstant (t, (long) v, loc);
187        break;
188      case BuiltinTypeSpec.Type.ULong:
189        if (v is ulong)
190          return new ULongConstant (t, (ulong) v, loc);
191        break;
192      case BuiltinTypeSpec.Type.Float:
193        if (v is float)
194          return new FloatConstant (t, (float) v, loc);
195        break;
196      case BuiltinTypeSpec.Type.Double:
197        if (v is double)
198          return new DoubleConstant (t, (double) v, loc);
199        break;
200      case BuiltinTypeSpec.Type.Short:
201        if (v is short)
202          return new ShortConstant (t, (short) v, loc);
203        break;
204      case BuiltinTypeSpec.Type.UShort:
205        if (v is ushort)
206          return new UShortConstant (t, (ushort) v, loc);
207        break;
208      case BuiltinTypeSpec.Type.SByte:
209        if (v is sbyte)
210          return new SByteConstant (t, (sbyte) v, loc);
211        break;
212      case BuiltinTypeSpec.Type.Byte:
213        if (v is byte)
214          return new ByteConstant (t, (byte) v, loc);
215        break;
216      case BuiltinTypeSpec.Type.Char:
217        if (v is char)
218          return new CharConstant (t, (char) v, loc);
219        break;
220      case BuiltinTypeSpec.Type.Bool:
221        if (v is bool)
222          return new BoolConstant (t, (bool) v, loc);
223        break;
224      case BuiltinTypeSpec.Type.Decimal:
225        if (v is decimal)
226          return new DecimalConstant (t, (decimal) v, loc);
227        break;
228      }
229
230      if (t.IsEnum) {
231        var real_type = EnumSpec.GetUnderlyingType (t);
232        return new EnumConstant (CreateConstantFromValue (real_type, v, loc), t);
233      }
234
235      if (v == null) {
236        if (t.IsNullableType)
237          return Nullable.LiftedNull.Create (t, loc);
238
239        if (TypeSpec.IsReferenceType (t))
240          return new NullConstant (t, loc);
241      }
242
243      return null;
244    }
245
246
247    public override Expression CreateExpressionTree (ResolveContext ec)
248    {
249      Arguments args = new Arguments (2);
250      args.Add (new Argument (this));
251      args.Add (new Argument (new TypeOf (type, loc)));
252
253      return CreateExpressionFactoryCall (ec, "Constant", args);
254    }
255
256    /// <summary>
257    /// Maybe ConvertTo name is better. It tries to convert `this' constant to target_type.
258    /// It throws OverflowException
259    /// </summary>
260    // DON'T CALL THIS METHOD DIRECTLY AS IT DOES NOT HANDLE ENUMS
261    public abstract Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type);
262
263    // This is a custom version of Convert.ChangeType() which works
264    // with the TypeBuilder defined types when compiling corlib.
265    static object ChangeType (object value, TypeSpec targetType, out bool error)
266    {
267      IConvertible convert_value = value as IConvertible;
268
269      if (convert_value == null) {
270        error = true;
271        return null;
272      }
273
274      //
275      // We cannot rely on build-in type conversions as they are
276      // more limited than what C# supports.
277      // See char -> float/decimal/double conversion
278      //
279      error = false;
280      try {
281        switch (targetType.BuiltinType) {
282        case BuiltinTypeSpec.Type.Bool:
283          return convert_value.ToBoolean (nfi);
284        case BuiltinTypeSpec.Type.Byte:
285          return convert_value.ToByte (nfi);
286        case BuiltinTypeSpec.Type.Char:
287          return convert_value.ToChar (nfi);
288        case BuiltinTypeSpec.Type.Short:
289          return convert_value.ToInt16 (nfi);
290        case BuiltinTypeSpec.Type.Int:
291          return convert_value.ToInt32 (nfi);
292        case BuiltinTypeSpec.Type.Long:
293          return convert_value.ToInt64 (nfi);
294        case BuiltinTypeSpec.Type.SByte:
295          return convert_value.ToSByte (nfi);
296        case BuiltinTypeSpec.Type.Decimal:
297          if (convert_value.GetType () == typeof (char))
298            return (decimal) convert_value.ToInt32 (nfi);
299          return convert_value.ToDecimal (nfi);
300        case BuiltinTypeSpec.Type.Double:
301          if (convert_value.GetType () == typeof (char))
302            return (double) convert_value.ToInt32 (nfi);
303          return convert_value.ToDouble (nfi);
304        case BuiltinTypeSpec.Type.Float:
305          if (convert_value.GetType () == typeof (char))
306            return (float) convert_value.ToInt32 (nfi);
307          return convert_value.ToSingle (nfi);
308        case BuiltinTypeSpec.Type.String:
309          return convert_value.ToString (nfi);
310        case BuiltinTypeSpec.Type.UShort:
311          return convert_value.ToUInt16 (nfi);
312        case BuiltinTypeSpec.Type.UInt:
313          return convert_value.ToUInt32 (nfi);
314        case BuiltinTypeSpec.Type.ULong:
315          return convert_value.ToUInt64 (nfi);
316        case BuiltinTypeSpec.Type.Object:
317          return value;
318        }
319      } catch {
320      }
321
322      error = true;
323      return null;
324    }
325
326    protected override Expression DoResolve (ResolveContext rc)
327    {
328      return this;
329    }
330
331    //
332    // Attempts to do a compile-time folding of a constant cast and handles
333    // error reporting for constant overlows only, on normal conversion
334    // errors returns null
335    //
336    public Constant Reduce (ResolveContext ec, TypeSpec target_type)
337    {
338      try {
339        return TryReduceConstant (ec, target_type);
340      } catch (OverflowException) {
341        if (ec.ConstantCheckState && Type.BuiltinType != BuiltinTypeSpec.Type.Decimal) {
342          ec.Report.Error (221, loc,
343            "Constant value `{0}' cannot be converted to a `{1}' (use `unchecked' syntax to override)",
344            GetValueAsLiteral (), target_type.GetSignatureForError ());
345        } else {
346          Error_ValueCannotBeConverted (ec, target_type, false);
347        }
348
349        return New.Constantify (target_type, loc);
350      }
351    }
352
353    public Constant TryReduce (ResolveContext rc, TypeSpec targetType)
354    {
355      try {
356        return TryReduceConstant (rc, targetType);
357      } catch (OverflowException) {
358        return null;
359      }
360    }
361
362    Constant TryReduceConstant (ResolveContext ec, TypeSpec target_type)
363    {
364      if (Type == target_type) {
365        //
366        // Reducing literal value produces a new constant. Syntactically 10 is not same as (int)10
367        //
368        if (IsLiteral)
369          return CreateConstantFromValue (target_type, GetValue (), loc);
370
371        return this;
372      }
373
374      Constant c;
375      if (target_type.IsEnum) {
376        c = TryReduceConstant (ec, EnumSpec.GetUnderlyingType (target_type));
377        if (c == null)
378          return null;
379
380        return new EnumConstant (c, target_type);
381      }
382
383      return ConvertExplicitly (ec.ConstantCheckState, target_type);
384    }
385
386    /// <summary>
387    /// Need to pass type as the constant can require a boxing
388    /// and in such case no optimization is possible
389    /// </summary>
390    public bool IsDefaultInitializer (TypeSpec type)
391    {
392      if (type == Type)
393        return IsDefaultValue;
394
395      return this is NullLiteral;
396    }
397
398    public abstract bool IsDefaultValue {
399      get;
400    }
401
402    public abstract bool IsNegative {
403      get;
404    }
405
406    //
407    // When constant is declared as literal
408    //
409    public virtual bool IsLiteral {
410      get { return false; }
411    }
412   
413    public virtual bool IsOneInteger {
414      get { return false; }
415    }
416
417    public override bool IsSideEffectFree {
418      get {
419        return true;
420      }
421    }
422
423    //
424    // Returns true iff 1) the stack type of this is one of Object,
425    // int32, int64 and 2) this == 0 or this == null.
426    //
427    public virtual bool IsZeroInteger {
428      get { return false; }
429    }
430
431    public override void EmitSideEffect (EmitContext ec)
432    {
433      // do nothing
434    }
435
436    public sealed override Expression Clone (CloneContext clonectx)
437    {
438      // No cloning is not needed for constants
439      return this;
440    }
441
442    protected override void CloneTo (CloneContext clonectx, Expression target)
443    {
444      throw new NotSupportedException ("should not be reached");
445    }
446
447    public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
448    {
449#if STATIC
450      return base.MakeExpression (ctx);
451#else
452      return System.Linq.Expressions.Expression.Constant (GetTypedValue (), type.GetMetaInfo ());
453#endif
454    }
455
456    public new bool Resolve (ResolveContext rc)
457    {
458      // It exists only as hint not to call Resolve on constants
459      return true;
460    }
461   
462    public override object Accept (StructuralVisitor visitor)
463    {
464      return visitor.Visit (this);
465    }
466
467  }
468
469  public abstract class IntegralConstant : Constant
470  {
471    protected IntegralConstant (TypeSpec type, Location loc)
472      : base (loc)
473    {
474      this.type = type;
475      eclass = ExprClass.Value;
476    }
477
478    public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
479    {
480      try {
481        ConvertExplicitly (true, target);
482        base.Error_ValueCannotBeConverted (ec, target, expl);
483      }
484      catch
485      {
486        ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
487          GetValue ().ToString (), target.GetSignatureForError ());
488      }
489    }
490
491    public override string GetValueAsLiteral ()
492    {
493      return GetValue ().ToString ();
494    }
495   
496    public abstract Constant Increment ();
497  }
498 
499  public class BoolConstant : Constant {
500    public readonly bool Value;
501
502    public BoolConstant (BuiltinTypes types, bool val, Location loc)
503      : this (types.Bool, val, loc)
504    {
505    }
506   
507    public BoolConstant (TypeSpec type, bool val, Location loc)
508      : base (loc)
509    {
510      eclass = ExprClass.Value;
511      this.type = type;
512
513      Value = val;
514    }
515
516    public override object GetValue ()
517    {
518      return (object) Value;
519    }
520
521    public override string GetValueAsLiteral ()
522    {
523      return Value ? "true" : "false";
524    }
525
526    public override long GetValueAsLong ()
527    {
528      return Value ? 1 : 0;
529    }
530
531    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
532    {
533      enc.Encode (Value);
534    }
535   
536    public override void Emit (EmitContext ec)
537    {
538      if (Value)
539        ec.EmitInt (1);
540      else
541        ec.EmitInt (0);
542    }
543
544    public override bool IsDefaultValue {
545      get {
546        return !Value;
547      }
548    }
549
550    public override bool IsNegative {
551      get {
552        return false;
553      }
554    }
555 
556    public override bool IsZeroInteger {
557      get { return Value == false; }
558    }
559
560    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
561    {
562      return null;
563    }
564
565  }
566
567  public class ByteConstant : IntegralConstant
568  {
569    public readonly byte Value;
570
571    public ByteConstant (BuiltinTypes types, byte v, Location loc)
572      : this (types.Byte, v, loc)
573    {
574    }
575
576    public ByteConstant (TypeSpec type, byte v, Location loc)
577      : base (type, loc)
578    {
579      Value = v;
580    }
581
582    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
583    {
584      enc.Encode (Value);
585    }
586
587    public override void Emit (EmitContext ec)
588    {
589      ec.EmitInt (Value);
590    }
591
592    public override object GetValue ()
593    {
594      return Value;
595    }
596
597    public override long GetValueAsLong ()
598    {
599      return Value;
600    }
601
602    public override Constant Increment ()
603    {
604      return new ByteConstant (type, checked ((byte)(Value + 1)), loc);
605    }
606
607    public override bool IsDefaultValue {
608      get {
609        return Value == 0;
610      }
611    }
612
613    public override bool IsOneInteger {
614      get {
615        return Value == 1;
616      }
617    }   
618
619    public override bool IsNegative {
620      get {
621        return false;
622      }
623    }
624
625    public override bool IsZeroInteger {
626      get { return Value == 0; }
627    }
628
629    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
630    {
631      switch (target_type.BuiltinType) {
632      case BuiltinTypeSpec.Type.SByte:
633        if (in_checked_context){
634          if (Value > SByte.MaxValue)
635            throw new OverflowException ();
636        }
637        return new SByteConstant (target_type, (sbyte) Value, Location);
638      case BuiltinTypeSpec.Type.Short:
639        return new ShortConstant (target_type, (short) Value, Location);
640      case BuiltinTypeSpec.Type.UShort:
641        return new UShortConstant (target_type, (ushort) Value, Location);
642      case BuiltinTypeSpec.Type.Int:
643        return new IntConstant (target_type, (int) Value, Location);
644      case BuiltinTypeSpec.Type.UInt:
645        return new UIntConstant (target_type, (uint) Value, Location);
646      case BuiltinTypeSpec.Type.Long:
647        return new LongConstant (target_type, (long) Value, Location);
648      case BuiltinTypeSpec.Type.ULong:
649        return new ULongConstant (target_type, (ulong) Value, Location);
650      case BuiltinTypeSpec.Type.Float:
651        return new FloatConstant (target_type, (float) Value, Location);
652      case BuiltinTypeSpec.Type.Double:
653        return new DoubleConstant (target_type, (double) Value, Location);
654      case BuiltinTypeSpec.Type.Char:
655        return new CharConstant (target_type, (char) Value, Location);
656      case BuiltinTypeSpec.Type.Decimal:
657        return new DecimalConstant (target_type, (decimal) Value, Location);
658      }
659
660      return null;
661    }
662
663  }
664
665  public class CharConstant : Constant {
666    public readonly char Value;
667
668    public CharConstant (BuiltinTypes types, char v, Location loc)
669      : this (types.Char, v, loc)
670    {
671    }
672
673    public CharConstant (TypeSpec type, char v, Location loc)
674      : base (loc)
675    {
676      this.type = type;
677      eclass = ExprClass.Value;
678
679      Value = v;
680    }
681
682    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
683    {
684      enc.Encode ((ushort) Value);
685    }
686
687    public override void Emit (EmitContext ec)
688    {
689      ec.EmitInt (Value);
690    }
691
692    static string descape (char c)
693    {
694      switch (c){
695      case '\a':
696        return "\\a";
697      case '\b':
698        return "\\b";
699      case '\n':
700        return "\\n";
701      case '\t':
702        return "\\t";
703      case '\v':
704        return "\\v";
705      case '\r':
706        return "\\r";
707      case '\\':
708        return "\\\\";
709      case '\f':
710        return "\\f";
711      case '\0':
712        return "\\0";
713      case '"':
714        return "\\\"";
715      case '\'':
716        return "\\\'";
717      }
718      return c.ToString ();
719    }
720
721    public override object GetValue ()
722    {
723      return Value;
724    }
725
726    public override long GetValueAsLong ()
727    {
728      return Value;
729    }
730
731    public override string GetValueAsLiteral ()
732    {
733      return "\"" + descape (Value) + "\"";
734    }
735
736    public override bool IsDefaultValue {
737      get {
738        return Value == 0;
739      }
740    }
741
742    public override bool IsNegative {
743      get {
744        return false;
745      }
746    }
747
748    public override bool IsZeroInteger {
749      get { return Value == '\0'; }
750    }
751
752    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
753    {
754      switch (target_type.BuiltinType) {
755      case BuiltinTypeSpec.Type.Byte:
756        if (in_checked_context) {
757          if (Value < Byte.MinValue || Value > Byte.MaxValue)
758            throw new OverflowException ();
759        }
760        return new ByteConstant (target_type, (byte) Value, Location);
761      case BuiltinTypeSpec.Type.SByte:
762        if (in_checked_context) {
763          if (Value > SByte.MaxValue)
764            throw new OverflowException ();
765        }
766        return new SByteConstant (target_type, (sbyte) Value, Location);
767
768      case BuiltinTypeSpec.Type.Short:
769        if (in_checked_context) {
770          if (Value > Int16.MaxValue)
771            throw new OverflowException ();
772        }
773        return new ShortConstant (target_type, (short) Value, Location);
774      case BuiltinTypeSpec.Type.Int:
775        return new IntConstant (target_type, (int) Value, Location);
776      case BuiltinTypeSpec.Type.UInt:
777        return new UIntConstant (target_type, (uint) Value, Location);
778      case BuiltinTypeSpec.Type.Long:
779        return new LongConstant (target_type, (long) Value, Location);
780      case BuiltinTypeSpec.Type.ULong:
781        return new ULongConstant (target_type, (ulong) Value, Location);
782      case BuiltinTypeSpec.Type.Float:
783        return new FloatConstant (target_type, (float) Value, Location);
784      case BuiltinTypeSpec.Type.Double:
785        return new DoubleConstant (target_type, (double) Value, Location);
786      case BuiltinTypeSpec.Type.Decimal:
787        return new DecimalConstant (target_type, (decimal) Value, Location);
788      }
789
790      return null;
791    }
792
793  }
794
795  public class SByteConstant : IntegralConstant
796  {
797    public readonly sbyte Value;
798
799    public SByteConstant (BuiltinTypes types, sbyte v, Location loc)
800      : this (types.SByte, v, loc)
801    {
802    }
803
804    public SByteConstant (TypeSpec type, sbyte v, Location loc)
805      : base (type, loc)
806    {
807      Value = v;
808    }
809
810    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
811    {
812      enc.Encode (Value);
813    }
814
815    public override void Emit (EmitContext ec)
816    {
817      ec.EmitInt (Value);
818    }
819
820    public override object GetValue ()
821    {
822      return Value;
823    }
824
825    public override long GetValueAsLong ()
826    {
827      return Value;
828    }
829
830    public override Constant Increment ()
831    {
832        return new SByteConstant (type, checked((sbyte)(Value + 1)), loc);
833    }
834
835    public override bool IsDefaultValue {
836      get {
837        return Value == 0;
838      }
839    }
840
841    public override bool IsNegative {
842      get {
843        return Value < 0;
844      }
845    }
846   
847    public override bool IsOneInteger {
848      get {
849        return Value == 1;
850      }
851    }   
852   
853    public override bool IsZeroInteger {
854      get { return Value == 0; }
855    }
856
857    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
858    {
859      switch (target_type.BuiltinType) {
860      case BuiltinTypeSpec.Type.Byte:
861        if (in_checked_context && Value < 0)
862          throw new OverflowException ();
863        return new ByteConstant (target_type, (byte) Value, Location);
864      case BuiltinTypeSpec.Type.Short:
865        return new ShortConstant (target_type, (short) Value, Location);
866      case BuiltinTypeSpec.Type.UShort:
867        if (in_checked_context && Value < 0)
868          throw new OverflowException ();
869        return new UShortConstant (target_type, (ushort) Value, Location);
870      case BuiltinTypeSpec.Type.Int:
871        return new IntConstant (target_type, (int) Value, Location);
872      case BuiltinTypeSpec.Type.UInt:
873        if (in_checked_context && Value < 0)
874          throw new OverflowException ();
875        return new UIntConstant (target_type, (uint) Value, Location);
876      case BuiltinTypeSpec.Type.Long:
877        return new LongConstant (target_type, (long) Value, Location);
878      case BuiltinTypeSpec.Type.ULong:
879        if (in_checked_context && Value < 0)
880          throw new OverflowException ();
881        return new ULongConstant (target_type, (ulong) Value, Location);
882      case BuiltinTypeSpec.Type.Float:
883        return new FloatConstant (target_type, (float) Value, Location);
884      case BuiltinTypeSpec.Type.Double:
885        return new DoubleConstant (target_type, (double) Value, Location);
886      case BuiltinTypeSpec.Type.Char:
887        if (in_checked_context && Value < 0)
888          throw new OverflowException ();
889        return new CharConstant (target_type, (char) Value, Location);
890      case BuiltinTypeSpec.Type.Decimal:
891        return new DecimalConstant (target_type, (decimal) Value, Location);
892      }
893
894      return null;
895    }
896
897  }
898
899  public class ShortConstant : IntegralConstant {
900    public readonly short Value;
901
902    public ShortConstant (BuiltinTypes types, short v, Location loc)
903      : this (types.Short, v, loc)
904    {
905    }
906
907    public ShortConstant (TypeSpec type, short v, Location loc)
908      : base (type, loc)
909    {
910      Value = v;
911    }
912
913    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
914    {
915      enc.Encode (Value);
916    }
917
918    public override void Emit (EmitContext ec)
919    {
920      ec.EmitInt (Value);
921    }
922
923    public override object GetValue ()
924    {
925      return Value;
926    }
927
928    public override long GetValueAsLong ()
929    {
930      return Value;
931    }
932
933    public override Constant Increment ()
934    {
935      return new ShortConstant (type, checked((short)(Value + 1)), loc);
936    }
937
938    public override bool IsDefaultValue {
939      get {
940        return Value == 0;
941      }
942    }
943   
944    public override bool IsZeroInteger {
945      get { return Value == 0; }
946    }
947
948    public override bool IsNegative {
949      get {
950        return Value < 0;
951      }
952    }
953   
954    public override bool IsOneInteger {
955      get {
956        return Value == 1;
957      }
958    }   
959
960    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
961    {
962      switch (target_type.BuiltinType) {
963      case BuiltinTypeSpec.Type.Byte:
964        if (in_checked_context) {
965          if (Value < Byte.MinValue || Value > Byte.MaxValue)
966            throw new OverflowException ();
967        }
968        return new ByteConstant (target_type, (byte) Value, Location);
969      case BuiltinTypeSpec.Type.SByte:
970        if (in_checked_context) {
971          if (Value < SByte.MinValue || Value > SByte.MaxValue)
972            throw new OverflowException ();
973        }
974        return new SByteConstant (target_type, (sbyte) Value, Location);
975      case BuiltinTypeSpec.Type.UShort:
976        if (in_checked_context && Value < 0)
977          throw new OverflowException ();
978
979        return new UShortConstant (target_type, (ushort) Value, Location);
980      case BuiltinTypeSpec.Type.Int:
981        return new IntConstant (target_type, (int) Value, Location);
982      case BuiltinTypeSpec.Type.UInt:
983        if (in_checked_context && Value < 0)
984          throw new OverflowException ();
985        return new UIntConstant (target_type, (uint) Value, Location);
986      case BuiltinTypeSpec.Type.Long:
987        return new LongConstant (target_type, (long) Value, Location);
988      case BuiltinTypeSpec.Type.ULong:
989        if (in_checked_context && Value < 0)
990          throw new OverflowException ();
991        return new ULongConstant (target_type, (ulong) Value, Location);
992      case BuiltinTypeSpec.Type.Float:
993        return new FloatConstant (target_type, (float) Value, Location);
994      case BuiltinTypeSpec.Type.Double:
995        return new DoubleConstant (target_type, (double) Value, Location);
996      case BuiltinTypeSpec.Type.Char:
997        if (in_checked_context) {
998          if (Value < Char.MinValue)
999            throw new OverflowException ();
1000        }
1001        return new CharConstant (target_type, (char) Value, Location);
1002      case BuiltinTypeSpec.Type.Decimal:
1003        return new DecimalConstant (target_type, (decimal) Value, Location);
1004      }
1005
1006      return null;
1007    }
1008
1009  }
1010
1011  public class UShortConstant : IntegralConstant
1012  {
1013    public readonly ushort Value;
1014
1015    public UShortConstant (BuiltinTypes types, ushort v, Location loc)
1016      : this (types.UShort, v, loc)
1017    {
1018    }
1019
1020    public UShortConstant (TypeSpec type, ushort v, Location loc)
1021      : base (type, loc)
1022    {
1023      Value = v;
1024    }
1025
1026    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1027    {
1028      enc.Encode (Value);
1029    }
1030
1031    public override void Emit (EmitContext ec)
1032    {
1033      ec.EmitInt (Value);
1034    }
1035
1036    public override object GetValue ()
1037    {
1038      return Value;
1039    }
1040
1041    public override long GetValueAsLong ()
1042    {
1043      return Value;
1044    }
1045 
1046    public override Constant Increment ()
1047    {
1048      return new UShortConstant (type, checked((ushort)(Value + 1)), loc);
1049    }
1050
1051    public override bool IsDefaultValue {
1052      get {
1053        return Value == 0;
1054      }
1055    }
1056
1057    public override bool IsNegative {
1058      get {
1059        return false;
1060      }
1061    }
1062   
1063    public override bool IsOneInteger {
1064      get {
1065        return Value == 1;
1066      }
1067    }   
1068 
1069    public override bool IsZeroInteger {
1070      get { return Value == 0; }
1071    }
1072
1073    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1074    {
1075      switch (target_type.BuiltinType) {
1076      case BuiltinTypeSpec.Type.Byte:
1077        if (in_checked_context) {
1078          if (Value > Byte.MaxValue)
1079            throw new OverflowException ();
1080        }
1081        return new ByteConstant (target_type, (byte) Value, Location);
1082      case BuiltinTypeSpec.Type.SByte:
1083        if (in_checked_context) {
1084          if (Value > SByte.MaxValue)
1085            throw new OverflowException ();
1086        }
1087        return new SByteConstant (target_type, (sbyte) Value, Location);
1088      case BuiltinTypeSpec.Type.Short:
1089        if (in_checked_context) {
1090          if (Value > Int16.MaxValue)
1091            throw new OverflowException ();
1092        }
1093        return new ShortConstant (target_type, (short) Value, Location);
1094      case BuiltinTypeSpec.Type.Int:
1095        return new IntConstant (target_type, (int) Value, Location);
1096      case BuiltinTypeSpec.Type.UInt:
1097        return new UIntConstant (target_type, (uint) Value, Location);
1098      case BuiltinTypeSpec.Type.Long:
1099        return new LongConstant (target_type, (long) Value, Location);
1100      case BuiltinTypeSpec.Type.ULong:
1101        return new ULongConstant (target_type, (ulong) Value, Location);
1102      case BuiltinTypeSpec.Type.Float:
1103        return new FloatConstant (target_type, (float) Value, Location);
1104      case BuiltinTypeSpec.Type.Double:
1105        return new DoubleConstant (target_type, (double) Value, Location);
1106      case BuiltinTypeSpec.Type.Char:
1107        if (in_checked_context) {
1108          if (Value > Char.MaxValue)
1109            throw new OverflowException ();
1110        }
1111        return new CharConstant (target_type, (char) Value, Location);
1112      case BuiltinTypeSpec.Type.Decimal:
1113        return new DecimalConstant (target_type, (decimal) Value, Location);
1114      }
1115
1116      return null;
1117    }
1118  }
1119
1120  public class IntConstant : IntegralConstant
1121  {
1122    public readonly int Value;
1123
1124    public IntConstant (BuiltinTypes types, int v, Location loc)
1125      : this (types.Int, v, loc)
1126    {
1127    }
1128
1129    public IntConstant (TypeSpec type, int v, Location loc)
1130      : base (type, loc)
1131    {
1132      Value = v;
1133    }
1134
1135    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1136    {
1137      enc.Encode (Value);
1138    }
1139
1140    public override void Emit (EmitContext ec)
1141    {
1142      ec.EmitInt (Value);
1143    }
1144
1145    public override object GetValue ()
1146    {
1147      return Value;
1148    }
1149
1150    public override long GetValueAsLong ()
1151    {
1152      return Value;
1153    }
1154
1155    public override Constant Increment ()
1156    {
1157      return new IntConstant (type, checked(Value + 1), loc);
1158    }
1159
1160    public override bool IsDefaultValue {
1161      get {
1162        return Value == 0;
1163      }
1164    }
1165   
1166    public override bool IsNegative {
1167      get {
1168        return Value < 0;
1169      }
1170    }
1171   
1172    public override bool IsOneInteger {
1173      get {
1174        return Value == 1;
1175      }
1176    }   
1177
1178    public override bool IsZeroInteger {
1179      get { return Value == 0; }
1180    }
1181
1182    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1183    {
1184      switch (target_type.BuiltinType) {
1185      case BuiltinTypeSpec.Type.Byte:
1186        if (in_checked_context) {
1187          if (Value < Byte.MinValue || Value > Byte.MaxValue)
1188            throw new OverflowException ();
1189        }
1190        return new ByteConstant (target_type, (byte) Value, Location);
1191      case BuiltinTypeSpec.Type.SByte:
1192        if (in_checked_context) {
1193          if (Value < SByte.MinValue || Value > SByte.MaxValue)
1194            throw new OverflowException ();
1195        }
1196        return new SByteConstant (target_type, (sbyte) Value, Location);
1197      case BuiltinTypeSpec.Type.Short:
1198        if (in_checked_context) {
1199          if (Value < Int16.MinValue || Value > Int16.MaxValue)
1200            throw new OverflowException ();
1201        }
1202        return new ShortConstant (target_type, (short) Value, Location);
1203      case BuiltinTypeSpec.Type.UShort:
1204        if (in_checked_context) {
1205          if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
1206            throw new OverflowException ();
1207        }
1208        return new UShortConstant (target_type, (ushort) Value, Location);
1209      case BuiltinTypeSpec.Type.UInt:
1210        if (in_checked_context) {
1211          if (Value < UInt32.MinValue)
1212            throw new OverflowException ();
1213        }
1214        return new UIntConstant (target_type, (uint) Value, Location);
1215      case BuiltinTypeSpec.Type.Long:
1216        return new LongConstant (target_type, (long) Value, Location);
1217      case BuiltinTypeSpec.Type.ULong:
1218        if (in_checked_context && Value < 0)
1219          throw new OverflowException ();
1220        return new ULongConstant (target_type, (ulong) Value, Location);
1221      case BuiltinTypeSpec.Type.Float:
1222        return new FloatConstant (target_type, (float) Value, Location);
1223      case BuiltinTypeSpec.Type.Double:
1224        return new DoubleConstant (target_type, (double) Value, Location);
1225      case BuiltinTypeSpec.Type.Char:
1226        if (in_checked_context) {
1227          if (Value < Char.MinValue || Value > Char.MaxValue)
1228            throw new OverflowException ();
1229        }
1230        return new CharConstant (target_type, (char) Value, Location);
1231      case BuiltinTypeSpec.Type.Decimal:
1232        return new DecimalConstant (target_type, (decimal) Value, Location);
1233      }
1234
1235      return null;
1236    }
1237
1238    public override Constant ConvertImplicitly (TypeSpec type)
1239    {
1240      if (this.type == type)
1241        return this;
1242
1243      Constant c = TryImplicitIntConversion (type);
1244      if (c != null)
1245        return c; //.Resolve (rc);
1246
1247      return base.ConvertImplicitly (type);
1248    }
1249
1250    /// <summary>
1251    ///   Attempts to perform an implicit constant conversion of the IntConstant
1252    ///   into a different data type using casts (See Implicit Constant
1253    ///   Expression Conversions)
1254    /// </summary>
1255    Constant TryImplicitIntConversion (TypeSpec target_type)
1256    {
1257      switch (target_type.BuiltinType) {
1258      case BuiltinTypeSpec.Type.SByte:
1259        if (Value >= SByte.MinValue && Value <= SByte.MaxValue)
1260          return new SByteConstant (target_type, (sbyte) Value, loc);
1261        break;
1262      case BuiltinTypeSpec.Type.Byte:
1263        if (Value >= Byte.MinValue && Value <= Byte.MaxValue)
1264          return new ByteConstant (target_type, (byte) Value, loc);
1265        break;
1266      case BuiltinTypeSpec.Type.Short:
1267        if (Value >= Int16.MinValue && Value <= Int16.MaxValue)
1268          return new ShortConstant (target_type, (short) Value, loc);
1269        break;
1270      case BuiltinTypeSpec.Type.UShort:
1271        if (Value >= UInt16.MinValue && Value <= UInt16.MaxValue)
1272          return new UShortConstant (target_type, (ushort) Value, loc);
1273        break;
1274      case BuiltinTypeSpec.Type.UInt:
1275        if (Value >= 0)
1276          return new UIntConstant (target_type, (uint) Value, loc);
1277        break;
1278      case BuiltinTypeSpec.Type.ULong:
1279        //
1280        // we can optimize this case: a positive int32
1281        // always fits on a uint64.  But we need an opcode
1282        // to do it.
1283        //
1284        if (Value >= 0)
1285          return new ULongConstant (target_type, (ulong) Value, loc);
1286        break;
1287      case BuiltinTypeSpec.Type.Double:
1288        return new DoubleConstant (target_type, (double) Value, loc);
1289      case BuiltinTypeSpec.Type.Float:
1290        return new FloatConstant (target_type, (float) Value, loc);
1291      }
1292
1293      return null;
1294    }
1295  }
1296
1297  public class UIntConstant : IntegralConstant {
1298    public readonly uint Value;
1299
1300    public UIntConstant (BuiltinTypes types, uint v, Location loc)
1301      : this (types.UInt, v, loc)
1302    {
1303    }
1304
1305    public UIntConstant (TypeSpec type, uint v, Location loc)
1306      : base (type, loc)
1307    {
1308      Value = v;
1309    }
1310
1311    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1312    {
1313      enc.Encode (Value);
1314    }
1315
1316    public override void Emit (EmitContext ec)
1317    {
1318      ec.EmitInt (unchecked ((int) Value));
1319    }
1320
1321    public override object GetValue ()
1322    {
1323      return Value;
1324    }
1325
1326    public override long GetValueAsLong ()
1327    {
1328      return Value;
1329    }
1330
1331    public override Constant Increment ()
1332    {
1333      return new UIntConstant (type, checked(Value + 1), loc);
1334    }
1335 
1336    public override bool IsDefaultValue {
1337      get {
1338        return Value == 0;
1339      }
1340    }
1341
1342    public override bool IsNegative {
1343      get {
1344        return false;
1345      }
1346    }
1347   
1348    public override bool IsOneInteger {
1349      get {
1350        return Value == 1;
1351      }
1352    }   
1353
1354    public override bool IsZeroInteger {
1355      get { return Value == 0; }
1356    }
1357
1358    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1359    {
1360      switch (target_type.BuiltinType) {
1361      case BuiltinTypeSpec.Type.Byte:
1362        if (in_checked_context) {
1363          if (Value < 0 || Value > byte.MaxValue)
1364            throw new OverflowException ();
1365        }
1366        return new ByteConstant (target_type, (byte) Value, Location);
1367      case BuiltinTypeSpec.Type.SByte:
1368        if (in_checked_context) {
1369          if (Value > SByte.MaxValue)
1370            throw new OverflowException ();
1371        }
1372        return new SByteConstant (target_type, (sbyte) Value, Location);
1373      case BuiltinTypeSpec.Type.Short:
1374        if (in_checked_context) {
1375          if (Value > Int16.MaxValue)
1376            throw new OverflowException ();
1377        }
1378        return new ShortConstant (target_type, (short) Value, Location);
1379      case BuiltinTypeSpec.Type.UShort:
1380        if (in_checked_context) {
1381          if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
1382            throw new OverflowException ();
1383        }
1384        return new UShortConstant (target_type, (ushort) Value, Location);
1385      case BuiltinTypeSpec.Type.Int:
1386        if (in_checked_context) {
1387          if (Value > Int32.MaxValue)
1388            throw new OverflowException ();
1389        }
1390        return new IntConstant (target_type, (int) Value, Location);
1391      case BuiltinTypeSpec.Type.Long:
1392        return new LongConstant (target_type, (long) Value, Location);
1393      case BuiltinTypeSpec.Type.ULong:
1394        return new ULongConstant (target_type, (ulong) Value, Location);
1395      case BuiltinTypeSpec.Type.Float:
1396        return new FloatConstant (target_type, (float) Value, Location);
1397      case BuiltinTypeSpec.Type.Double:
1398        return new DoubleConstant (target_type, (double) Value, Location);
1399      case BuiltinTypeSpec.Type.Char:
1400        if (in_checked_context) {
1401          if (Value < Char.MinValue || Value > Char.MaxValue)
1402            throw new OverflowException ();
1403        }
1404        return new CharConstant (target_type, (char) Value, Location);
1405      case BuiltinTypeSpec.Type.Decimal:
1406        return new DecimalConstant (target_type, (decimal) Value, Location);
1407      }
1408
1409      return null;
1410    }
1411
1412  }
1413
1414  public class LongConstant : IntegralConstant {
1415    public readonly long Value;
1416
1417    public LongConstant (BuiltinTypes types, long v, Location loc)
1418      : this (types.Long, v, loc)
1419    {
1420    }
1421
1422    public LongConstant (TypeSpec type, long v, Location loc)
1423      : base (type, loc)
1424    {
1425      Value = v;
1426    }
1427
1428    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1429    {
1430      enc.Encode (Value);
1431    }
1432
1433    public override void Emit (EmitContext ec)
1434    {
1435      ec.EmitLong (Value);
1436    }
1437
1438    public override object GetValue ()
1439    {
1440      return Value;
1441    }
1442
1443    public override long GetValueAsLong ()
1444    {
1445      return Value;
1446    }
1447
1448    public override Constant Increment ()
1449    {
1450      return new LongConstant (type, checked(Value + 1), loc);
1451    }
1452   
1453    public override bool IsDefaultValue {
1454      get {
1455        return Value == 0;
1456      }
1457    }
1458
1459    public override bool IsNegative {
1460      get {
1461        return Value < 0;
1462      }
1463    }
1464   
1465    public override bool IsOneInteger {
1466      get {
1467        return Value == 1;
1468      }
1469    }   
1470
1471    public override bool IsZeroInteger {
1472      get { return Value == 0; }
1473    }
1474
1475    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1476    {
1477      switch (target_type.BuiltinType) {
1478      case BuiltinTypeSpec.Type.Byte:
1479        if (in_checked_context) {
1480          if (Value < Byte.MinValue || Value > Byte.MaxValue)
1481            throw new OverflowException ();
1482        }
1483        return new ByteConstant (target_type, (byte) Value, Location);
1484      case BuiltinTypeSpec.Type.SByte:
1485        if (in_checked_context) {
1486          if (Value < SByte.MinValue || Value > SByte.MaxValue)
1487            throw new OverflowException ();
1488        }
1489        return new SByteConstant (target_type, (sbyte) Value, Location);
1490      case BuiltinTypeSpec.Type.Short:
1491        if (in_checked_context) {
1492          if (Value < Int16.MinValue || Value > Int16.MaxValue)
1493            throw new OverflowException ();
1494        }
1495        return new ShortConstant (target_type, (short) Value, Location);
1496      case BuiltinTypeSpec.Type.UShort:
1497        if (in_checked_context) {
1498          if (Value < UInt16.MinValue || Value > UInt16.MaxValue)
1499            throw new OverflowException ();
1500        }
1501        return new UShortConstant (target_type, (ushort) Value, Location);
1502      case BuiltinTypeSpec.Type.Int:
1503        if (in_checked_context) {
1504          if (Value < Int32.MinValue || Value > Int32.MaxValue)
1505            throw new OverflowException ();
1506        }
1507        return new IntConstant (target_type, (int) Value, Location);
1508      case BuiltinTypeSpec.Type.UInt:
1509        if (in_checked_context) {
1510          if (Value < UInt32.MinValue || Value > UInt32.MaxValue)
1511            throw new OverflowException ();
1512        }
1513        return new UIntConstant (target_type, (uint) Value, Location);
1514      case BuiltinTypeSpec.Type.ULong:
1515        if (in_checked_context && Value < 0)
1516          throw new OverflowException ();
1517        return new ULongConstant (target_type, (ulong) Value, Location);
1518      case BuiltinTypeSpec.Type.Float:
1519        return new FloatConstant (target_type, (float) Value, Location);
1520      case BuiltinTypeSpec.Type.Double:
1521        return new DoubleConstant (target_type, (double) Value, Location);
1522      case BuiltinTypeSpec.Type.Char:
1523        if (in_checked_context) {
1524          if (Value < Char.MinValue || Value > Char.MaxValue)
1525            throw new OverflowException ();
1526        }
1527        return new CharConstant (target_type, (char) Value, Location);
1528      case BuiltinTypeSpec.Type.Decimal:
1529        return new DecimalConstant (target_type, (decimal) Value, Location);
1530      }
1531
1532      return null;
1533    }
1534
1535    public override Constant ConvertImplicitly (TypeSpec type)
1536    {
1537      if (Value >= 0 && type.BuiltinType == BuiltinTypeSpec.Type.ULong) {
1538        return new ULongConstant (type, (ulong) Value, loc);
1539      }
1540
1541      return base.ConvertImplicitly (type);
1542    }
1543  }
1544
1545  public class ULongConstant : IntegralConstant {
1546    public readonly ulong Value;
1547
1548    public ULongConstant (BuiltinTypes types, ulong v, Location loc)
1549      : this (types.ULong, v, loc)
1550    {
1551    }
1552
1553    public ULongConstant (TypeSpec type, ulong v, Location loc)
1554      : base (type, loc)
1555    {
1556      Value = v;
1557    }
1558
1559    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1560    {
1561      enc.Encode (Value);
1562    }
1563
1564    public override void Emit (EmitContext ec)
1565    {
1566      ec.EmitLong (unchecked ((long) Value));
1567    }
1568
1569    public override object GetValue ()
1570    {
1571      return Value;
1572    }
1573
1574    public override long GetValueAsLong ()
1575    {
1576      return (long) Value;
1577    }
1578
1579    public override Constant Increment ()
1580    {
1581      return new ULongConstant (type, checked(Value + 1), loc);
1582    }
1583
1584    public override bool IsDefaultValue {
1585      get {
1586        return Value == 0;
1587      }
1588    }
1589
1590    public override bool IsNegative {
1591      get {
1592        return false;
1593      }
1594    }
1595   
1596    public override bool IsOneInteger {
1597      get {
1598        return Value == 1;
1599      }
1600    }   
1601
1602    public override bool IsZeroInteger {
1603      get { return Value == 0; }
1604    }
1605
1606    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1607    {
1608      switch (target_type.BuiltinType) {
1609      case BuiltinTypeSpec.Type.Byte:
1610        if (in_checked_context && Value > Byte.MaxValue)
1611          throw new OverflowException ();
1612        return new ByteConstant (target_type, (byte) Value, Location);
1613      case BuiltinTypeSpec.Type.SByte:
1614        if (in_checked_context && Value > ((ulong) SByte.MaxValue))
1615          throw new OverflowException ();
1616        return new SByteConstant (target_type, (sbyte) Value, Location);
1617      case BuiltinTypeSpec.Type.Short:
1618        if (in_checked_context && Value > ((ulong) Int16.MaxValue))
1619          throw new OverflowException ();
1620        return new ShortConstant (target_type, (short) Value, Location);
1621      case BuiltinTypeSpec.Type.UShort:
1622        if (in_checked_context && Value > UInt16.MaxValue)
1623          throw new OverflowException ();
1624        return new UShortConstant (target_type, (ushort) Value, Location);
1625      case BuiltinTypeSpec.Type.Int:
1626        if (in_checked_context && Value > UInt32.MaxValue)
1627          throw new OverflowException ();
1628        return new IntConstant (target_type, (int) Value, Location);
1629      case BuiltinTypeSpec.Type.UInt:
1630        if (in_checked_context && Value > UInt32.MaxValue)
1631          throw new OverflowException ();
1632        return new UIntConstant (target_type, (uint) Value, Location);
1633      case BuiltinTypeSpec.Type.Long:
1634        if (in_checked_context && Value > Int64.MaxValue)
1635          throw new OverflowException ();
1636        return new LongConstant (target_type, (long) Value, Location);
1637      case BuiltinTypeSpec.Type.Float:
1638        return new FloatConstant (target_type, (float) Value, Location);
1639      case BuiltinTypeSpec.Type.Double:
1640        return new DoubleConstant (target_type, (double) Value, Location);
1641      case BuiltinTypeSpec.Type.Char:
1642        if (in_checked_context && Value > Char.MaxValue)
1643          throw new OverflowException ();
1644        return new CharConstant (target_type, (char) Value, Location);
1645      case BuiltinTypeSpec.Type.Decimal:
1646        return new DecimalConstant (target_type, (decimal) Value, Location);
1647      }
1648
1649      return null;
1650    }
1651
1652  }
1653
1654  public class FloatConstant : Constant {
1655    //
1656    // Store constant value as double because float constant operations
1657    // need to work on double value to match JIT
1658    //
1659    public readonly double DoubleValue;
1660
1661    public FloatConstant (BuiltinTypes types, double v, Location loc)
1662      : this (types.Float, v, loc)
1663    {
1664    }
1665
1666    public FloatConstant (TypeSpec type, double v, Location loc)
1667      : base (loc)
1668    {
1669      this.type = type;
1670      eclass = ExprClass.Value;
1671
1672      DoubleValue = v;
1673    }
1674
1675    public override Constant ConvertImplicitly (TypeSpec type)
1676    {
1677      if (type.BuiltinType == BuiltinTypeSpec.Type.Double)
1678        return new DoubleConstant (type, DoubleValue, loc);
1679
1680      return base.ConvertImplicitly (type);
1681    }
1682
1683    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1684    {
1685      enc.Encode (Value);
1686    }
1687
1688    public override void Emit (EmitContext ec)
1689    {
1690      ec.Emit (OpCodes.Ldc_R4, Value);
1691    }
1692
1693    public float Value {
1694      get {
1695        return (float) DoubleValue;
1696      }
1697    }
1698
1699    public override object GetValue ()
1700    {
1701      return Value;
1702    }
1703
1704    public override string GetValueAsLiteral ()
1705    {
1706      return Value.ToString ();
1707    }
1708
1709    public override long GetValueAsLong ()
1710    {
1711      throw new NotSupportedException ();
1712    }
1713
1714    public override bool IsDefaultValue {
1715      get {
1716        return Value == 0;
1717      }
1718    }
1719
1720    public override bool IsNegative {
1721      get {
1722        return Value < 0;
1723      }
1724    }
1725
1726    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1727    {
1728      switch (target_type.BuiltinType) {
1729      case BuiltinTypeSpec.Type.Byte:
1730        if (in_checked_context) {
1731          if (Value < byte.MinValue || Value > byte.MaxValue || float.IsNaN (Value))
1732            throw new OverflowException ();
1733        }
1734        return new ByteConstant (target_type, (byte) DoubleValue, Location);
1735      case BuiltinTypeSpec.Type.SByte:
1736        if (in_checked_context) {
1737          if (Value < sbyte.MinValue || Value > sbyte.MaxValue || float.IsNaN (Value))
1738            throw new OverflowException ();
1739        }
1740        return new SByteConstant (target_type, (sbyte) DoubleValue, Location);
1741      case BuiltinTypeSpec.Type.Short:
1742        if (in_checked_context) {
1743          if (Value < short.MinValue || Value > short.MaxValue || float.IsNaN (Value))
1744            throw new OverflowException ();
1745        }
1746        return new ShortConstant (target_type, (short) DoubleValue, Location);
1747      case BuiltinTypeSpec.Type.UShort:
1748        if (in_checked_context) {
1749          if (Value < ushort.MinValue || Value > ushort.MaxValue || float.IsNaN (Value))
1750            throw new OverflowException ();
1751        }
1752        return new UShortConstant (target_type, (ushort) DoubleValue, Location);
1753      case BuiltinTypeSpec.Type.Int:
1754        if (in_checked_context) {
1755          if (Value < int.MinValue || Value > int.MaxValue || float.IsNaN (Value))
1756            throw new OverflowException ();
1757        }
1758        return new IntConstant (target_type, (int) DoubleValue, Location);
1759      case BuiltinTypeSpec.Type.UInt:
1760        if (in_checked_context) {
1761          if (Value < uint.MinValue || Value > uint.MaxValue || float.IsNaN (Value))
1762            throw new OverflowException ();
1763        }
1764        return new UIntConstant (target_type, (uint) DoubleValue, Location);
1765      case BuiltinTypeSpec.Type.Long:
1766        if (in_checked_context) {
1767          if (Value < long.MinValue || Value > long.MaxValue || float.IsNaN (Value))
1768            throw new OverflowException ();
1769        }
1770        return new LongConstant (target_type, (long) DoubleValue, Location);
1771      case BuiltinTypeSpec.Type.ULong:
1772        if (in_checked_context) {
1773          if (Value < ulong.MinValue || Value > ulong.MaxValue || float.IsNaN (Value))
1774            throw new OverflowException ();
1775        }
1776        return new ULongConstant (target_type, (ulong) DoubleValue, Location);
1777      case BuiltinTypeSpec.Type.Double:
1778        return new DoubleConstant (target_type, DoubleValue, Location);
1779      case BuiltinTypeSpec.Type.Char:
1780        if (in_checked_context) {
1781          if (Value < (float) char.MinValue || Value > (float) char.MaxValue || float.IsNaN (Value))
1782            throw new OverflowException ();
1783        }
1784        return new CharConstant (target_type, (char) DoubleValue, Location);
1785      case BuiltinTypeSpec.Type.Decimal:
1786        return new DecimalConstant (target_type, (decimal) DoubleValue, Location);
1787      }
1788
1789      return null;
1790    }
1791
1792  }
1793
1794  public class DoubleConstant : Constant
1795  {
1796    public readonly double Value;
1797
1798    public DoubleConstant (BuiltinTypes types, double v, Location loc)
1799      : this (types.Double, v, loc)
1800    {
1801    }
1802
1803    public DoubleConstant (TypeSpec type, double v, Location loc)
1804      : base (loc)
1805    {
1806      this.type = type;
1807      eclass = ExprClass.Value;
1808
1809      Value = v;
1810    }
1811
1812    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
1813    {
1814      enc.Encode (Value);
1815    }
1816
1817    public override void Emit (EmitContext ec)
1818    {
1819      ec.Emit (OpCodes.Ldc_R8, Value);
1820    }
1821
1822    public override object GetValue ()
1823    {
1824      return Value;
1825    }
1826
1827    public override string GetValueAsLiteral ()
1828    {
1829      return Value.ToString ();
1830    }
1831
1832    public override long GetValueAsLong ()
1833    {
1834      throw new NotSupportedException ();
1835    }
1836
1837    public override bool IsDefaultValue {
1838      get {
1839        return Value == 0;
1840      }
1841    }
1842
1843    public override bool IsNegative {
1844      get {
1845        return Value < 0;
1846      }
1847    }
1848
1849    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1850    {
1851      switch (target_type.BuiltinType) {
1852      case BuiltinTypeSpec.Type.Byte:
1853        if (in_checked_context) {
1854          if (Value < Byte.MinValue || Value > Byte.MaxValue || double.IsNaN (Value))
1855            throw new OverflowException ();
1856        }
1857        return new ByteConstant (target_type, (byte) Value, Location);
1858      case BuiltinTypeSpec.Type.SByte:
1859        if (in_checked_context) {
1860          if (Value < SByte.MinValue || Value > SByte.MaxValue || double.IsNaN (Value))
1861            throw new OverflowException ();
1862        }
1863        return new SByteConstant (target_type, (sbyte) Value, Location);
1864      case BuiltinTypeSpec.Type.Short:
1865        if (in_checked_context) {
1866          if (Value < short.MinValue || Value > short.MaxValue || double.IsNaN (Value))
1867            throw new OverflowException ();
1868        }
1869        return new ShortConstant (target_type, (short) Value, Location);
1870      case BuiltinTypeSpec.Type.UShort:
1871        if (in_checked_context) {
1872          if (Value < ushort.MinValue || Value > ushort.MaxValue || double.IsNaN (Value))
1873            throw new OverflowException ();
1874        }
1875        return new UShortConstant (target_type, (ushort) Value, Location);
1876      case BuiltinTypeSpec.Type.Int:
1877        if (in_checked_context) {
1878          if (Value < int.MinValue || Value > int.MaxValue || double.IsNaN (Value))
1879            throw new OverflowException ();
1880        }
1881        return new IntConstant (target_type, (int) Value, Location);
1882      case BuiltinTypeSpec.Type.UInt:
1883        if (in_checked_context) {
1884          if (Value < uint.MinValue || Value > uint.MaxValue || double.IsNaN (Value))
1885            throw new OverflowException ();
1886        }
1887        return new UIntConstant (target_type, (uint) Value, Location);
1888      case BuiltinTypeSpec.Type.Long:
1889        if (in_checked_context) {
1890          if (Value < long.MinValue || Value > long.MaxValue || double.IsNaN (Value))
1891            throw new OverflowException ();
1892        }
1893        return new LongConstant (target_type, (long) Value, Location);
1894      case BuiltinTypeSpec.Type.ULong:
1895        if (in_checked_context) {
1896          if (Value < ulong.MinValue || Value > ulong.MaxValue || double.IsNaN (Value))
1897            throw new OverflowException ();
1898        }
1899        return new ULongConstant (target_type, (ulong) Value, Location);
1900      case BuiltinTypeSpec.Type.Float:
1901        return new FloatConstant (target_type, (float) Value, Location);
1902      case BuiltinTypeSpec.Type.Char:
1903        if (in_checked_context) {
1904          if (Value < (double) char.MinValue || Value > (double) char.MaxValue || double.IsNaN (Value))
1905            throw new OverflowException ();
1906        }
1907        return new CharConstant (target_type, (char) Value, Location);
1908      case BuiltinTypeSpec.Type.Decimal:
1909        return new DecimalConstant (target_type, (decimal) Value, Location);
1910      }
1911
1912      return null;
1913    }
1914
1915  }
1916
1917  public class DecimalConstant : Constant {
1918    public readonly decimal Value;
1919
1920    public DecimalConstant (BuiltinTypes types, decimal d, Location loc)
1921      : this (types.Decimal, d, loc)
1922    {
1923    }
1924
1925    public DecimalConstant (TypeSpec type, decimal d, Location loc)
1926      : base (loc)
1927    {
1928      this.type = type;
1929      eclass = ExprClass.Value;
1930
1931      Value = d;
1932    }
1933
1934    public override void Emit (EmitContext ec)
1935    {
1936      MethodSpec m;
1937
1938      int [] words = decimal.GetBits (Value);
1939      int power = (words [3] >> 16) & 0xff;
1940
1941      if (power == 0) {
1942        if (Value <= int.MaxValue && Value >= int.MinValue) {
1943          m = ec.Module.PredefinedMembers.DecimalCtorInt.Resolve (loc);
1944          if (m == null) {
1945            return;
1946          }
1947
1948          ec.EmitInt ((int) Value);
1949          ec.Emit (OpCodes.Newobj, m);
1950          return;
1951        }
1952
1953        if (Value <= long.MaxValue && Value >= long.MinValue) {
1954          m = ec.Module.PredefinedMembers.DecimalCtorLong.Resolve (loc);
1955          if (m == null) {
1956            return;
1957          }
1958
1959          ec.EmitLong ((long) Value);
1960          ec.Emit (OpCodes.Newobj, m);
1961          return;
1962        }
1963      }
1964
1965      ec.EmitInt (words [0]);
1966      ec.EmitInt (words [1]);
1967      ec.EmitInt (words [2]);
1968
1969      // sign
1970      ec.EmitInt (words [3] >> 31);
1971
1972      // power
1973      ec.EmitInt (power);
1974
1975      m = ec.Module.PredefinedMembers.DecimalCtor.Resolve (loc);
1976      if (m != null) {
1977        ec.Emit (OpCodes.Newobj, m);
1978      }
1979    }
1980
1981    public override bool IsDefaultValue {
1982      get {
1983        return Value == 0;
1984      }
1985    }
1986
1987    public override bool IsNegative {
1988      get {
1989        return Value < 0;
1990      }
1991    }
1992
1993    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
1994    {
1995      switch (target_type.BuiltinType) {
1996      case BuiltinTypeSpec.Type.SByte:
1997        return new SByteConstant (target_type, (sbyte) Value, loc);
1998      case BuiltinTypeSpec.Type.Byte:
1999        return new ByteConstant (target_type, (byte) Value, loc);
2000      case BuiltinTypeSpec.Type.Short:
2001        return new ShortConstant (target_type, (short) Value, loc);
2002      case BuiltinTypeSpec.Type.UShort:
2003        return new UShortConstant (target_type, (ushort) Value, loc);
2004      case BuiltinTypeSpec.Type.Int:
2005        return new IntConstant (target_type, (int) Value, loc);
2006      case BuiltinTypeSpec.Type.UInt:
2007        return new UIntConstant (target_type, (uint) Value, loc);
2008      case BuiltinTypeSpec.Type.Long:
2009        return new LongConstant (target_type, (long) Value, loc);
2010      case BuiltinTypeSpec.Type.ULong:
2011        return new ULongConstant (target_type, (ulong) Value, loc);
2012      case BuiltinTypeSpec.Type.Char:
2013        return new CharConstant (target_type, (char) Value, loc);
2014      case BuiltinTypeSpec.Type.Float:
2015        return new FloatConstant (target_type, (float) Value, loc);
2016      case BuiltinTypeSpec.Type.Double:
2017        return new DoubleConstant (target_type, (double) Value, loc);
2018      }
2019
2020      return null;
2021    }
2022
2023    public override object GetValue ()
2024    {
2025      return Value;
2026    }
2027
2028    public override string GetValueAsLiteral ()
2029    {
2030      return Value.ToString () + "M";
2031    }
2032
2033    public override long GetValueAsLong ()
2034    {
2035      throw new NotSupportedException ();
2036    }
2037  }
2038
2039  public class StringConstant : Constant {
2040    public StringConstant (BuiltinTypes types, string s, Location loc)
2041      : this (types.String, s, loc)
2042    {
2043    }
2044
2045    public StringConstant (TypeSpec type, string s, Location loc)
2046      : base (loc)
2047    {
2048      this.type = type;
2049      eclass = ExprClass.Value;
2050
2051      Value = s;
2052    }
2053
2054    protected StringConstant (Location loc)
2055      : base (loc)
2056    {
2057    }
2058
2059    public string Value { get; protected set; }
2060
2061    public override object GetValue ()
2062    {
2063      return Value;
2064    }
2065
2066    public override string GetValueAsLiteral ()
2067    {
2068      // FIXME: Escape the string.
2069      return "\"" + Value + "\"";
2070    }
2071
2072    public override long GetValueAsLong ()
2073    {
2074      throw new NotSupportedException ();
2075    }
2076   
2077    public override void Emit (EmitContext ec)
2078    {
2079      if (Value == null) {
2080        ec.EmitNull ();
2081        return;
2082      }
2083
2084      //
2085      // Use string.Empty for both literals and constants even if
2086      // it's not allowed at language level
2087      //
2088      if (Value.Length == 0 && ec.Module.Compiler.Settings.Optimize) {
2089        var string_type = ec.BuiltinTypes.String;
2090        if (ec.CurrentType != string_type) {
2091          var m = ec.Module.PredefinedMembers.StringEmpty.Get ();
2092          if (m != null) {
2093            ec.Emit (OpCodes.Ldsfld, m);
2094            return;
2095          }
2096        }
2097      }
2098
2099      ec.Emit (OpCodes.Ldstr, Value);
2100    }
2101
2102    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
2103    {
2104      // cast to object
2105      if (type != targetType)
2106        enc.Encode (type);
2107
2108      enc.Encode (Value);
2109    }
2110
2111    public override bool IsDefaultValue {
2112      get {
2113        return Value == null;
2114      }
2115    }
2116
2117    public override bool IsNegative {
2118      get {
2119        return false;
2120      }
2121    }
2122
2123    public override bool IsNull {
2124      get {
2125        return IsDefaultValue;
2126      }
2127    }
2128
2129    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
2130    {
2131      return null;
2132    }
2133
2134    public override Constant ConvertImplicitly (TypeSpec type)
2135    {
2136      if (IsDefaultValue && type.BuiltinType == BuiltinTypeSpec.Type.Object)
2137        return new NullConstant (type, loc);
2138
2139      return base.ConvertImplicitly (type);
2140    }
2141  }
2142
2143  class NameOf : StringConstant
2144  {
2145    readonly SimpleName name;
2146
2147    public NameOf (SimpleName name)
2148      : base (name.Location)
2149    {
2150      this.name = name;
2151    }
2152
2153    protected override Expression DoResolve (ResolveContext rc)
2154    {
2155      throw new NotSupportedException ();
2156    }
2157
2158    bool ResolveArgumentExpression (ResolveContext rc, Expression expr)
2159    {
2160      var sn = expr as SimpleName;
2161      if (sn != null) {
2162        Value = sn.Name;
2163
2164        if (rc.Module.Compiler.Settings.Version < LanguageVersion.V_6)
2165          rc.Report.FeatureIsNotAvailable (rc.Module.Compiler, Location, "nameof operator");
2166
2167        if (sn.HasTypeArguments) {
2168          // TODO: csc compatible but unhelpful error message
2169          rc.Report.Error (1001, loc, "Identifier expected");
2170          return true;
2171        }
2172
2173        sn.LookupNameExpression (rc, MemberLookupRestrictions.IgnoreArity | MemberLookupRestrictions.IgnoreAmbiguity);
2174        return true;
2175      }
2176
2177      var ma = expr as MemberAccess;
2178      if (ma != null) {
2179        FullNamedExpression fne = ma.LeftExpression as ATypeNameExpression;
2180        if (fne == null) {
2181          var qam = ma as QualifiedAliasMember;
2182          if (qam == null)
2183            return false;
2184
2185          fne = qam.CreateExpressionFromAlias (rc);
2186          if (fne == null)
2187            return true;
2188        }
2189
2190        Value = ma.Name;
2191
2192        if (rc.Module.Compiler.Settings.Version < LanguageVersion.V_6)
2193          rc.Report.FeatureIsNotAvailable (rc.Module.Compiler, Location, "nameof operator");
2194
2195        if (ma.HasTypeArguments) {
2196          // TODO: csc compatible but unhelpful error message
2197          rc.Report.Error (1001, loc, "Identifier expected");
2198          return true;
2199        }
2200         
2201        var left = fne.ResolveAsTypeOrNamespace (rc, true);
2202        if (left == null)
2203          return true;
2204
2205        var ns = left as NamespaceExpression;
2206        if (ns != null) {
2207          FullNamedExpression retval = ns.LookupTypeOrNamespace (rc, ma.Name, 0, LookupMode.NameOf, loc);
2208          if (retval == null)
2209            ns.Error_NamespaceDoesNotExist (rc, ma.Name, 0);
2210
2211          return true;
2212        }
2213
2214        if (left.Type.IsGenericOrParentIsGeneric && left.Type.GetDefinition () != left.Type) {
2215          rc.Report.Error (8071, loc, "Type arguments are not allowed in the nameof operator");
2216        }
2217
2218        var mexpr = MemberLookup (rc, false, left.Type, ma.Name, 0, MemberLookupRestrictions.IgnoreArity | MemberLookupRestrictions.IgnoreAmbiguity, loc);
2219        if (mexpr == null) {
2220          ma.Error_IdentifierNotFound (rc, left.Type);
2221          return true;
2222        }
2223
2224        return true;
2225      }
2226
2227      return false;
2228    }
2229
2230    public Expression ResolveOverload (ResolveContext rc, Arguments args)
2231    {
2232      if (args == null || args.Count != 1) {
2233        name.Error_NameDoesNotExist (rc);
2234        return null;
2235      }
2236
2237      var arg = args [0];
2238      var res = ResolveArgumentExpression (rc, arg.Expr);
2239      if (!res) {
2240        name.Error_NameDoesNotExist (rc);
2241        return null;
2242      }
2243
2244      type = rc.BuiltinTypes.String;
2245      eclass = ExprClass.Value;
2246      return this;
2247    }
2248  }
2249
2250  //
2251  // Null constant can have its own type, think of `default (Foo)'
2252  //
2253  public class NullConstant : Constant
2254  {
2255    public NullConstant (TypeSpec type, Location loc)
2256      : base (loc)
2257    {
2258      eclass = ExprClass.Value;
2259      this.type = type;
2260    }
2261
2262    public override Expression CreateExpressionTree (ResolveContext ec)
2263    {
2264      if (type == InternalType.NullLiteral || type.BuiltinType == BuiltinTypeSpec.Type.Object) {
2265        // Optimized version, also avoids referencing literal internal type
2266        Arguments args = new Arguments (1);
2267        args.Add (new Argument (this));
2268        return CreateExpressionFactoryCall (ec, "Constant", args);
2269      }
2270
2271      return base.CreateExpressionTree (ec);
2272    }
2273
2274    public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
2275    {
2276      switch (targetType.BuiltinType) {
2277      case BuiltinTypeSpec.Type.Object:
2278        // Type it as string cast
2279        enc.Encode (rc.Module.Compiler.BuiltinTypes.String);
2280        goto case BuiltinTypeSpec.Type.String;
2281      case BuiltinTypeSpec.Type.String:
2282      case BuiltinTypeSpec.Type.Type:
2283        enc.Encode (byte.MaxValue);
2284        return;
2285      default:
2286        var ac = targetType as ArrayContainer;
2287        if (ac != null && ac.Rank == 1 && !ac.Element.IsArray) {
2288          enc.Encode (uint.MaxValue);
2289          return;
2290        }
2291
2292        break;
2293      }
2294
2295      base.EncodeAttributeValue (rc, enc, targetType, parameterType);
2296    }
2297
2298    public override void Emit (EmitContext ec)
2299    {
2300      ec.EmitNull ();
2301
2302      // Only to make verifier happy
2303      if (type.IsGenericParameter)
2304        ec.Emit (OpCodes.Unbox_Any, type);
2305    }
2306
2307    public override string ExprClassName {
2308      get {
2309        return GetSignatureForError ();
2310      }
2311    }
2312
2313    public override Constant ConvertExplicitly (bool inCheckedContext, TypeSpec targetType)
2314    {
2315      if (targetType.IsPointer) {
2316        if (IsLiteral || this is NullPointer)
2317          return new NullPointer (targetType, loc);
2318
2319        return null;
2320      }
2321
2322      // Exlude internal compiler types
2323      if (targetType.Kind == MemberKind.InternalCompilerType && targetType.BuiltinType != BuiltinTypeSpec.Type.Dynamic)
2324        return null;
2325
2326      if (!IsLiteral && !Convert.ImplicitStandardConversionExists (this, targetType))
2327        return null;
2328
2329      if (TypeSpec.IsReferenceType (targetType))
2330        return new NullConstant (targetType, loc);
2331
2332      if (targetType.IsNullableType)
2333        return Nullable.LiftedNull.Create (targetType, loc);
2334
2335      return null;
2336    }
2337
2338    public override Constant ConvertImplicitly (TypeSpec targetType)
2339    {
2340      return ConvertExplicitly (false, targetType);
2341    }
2342
2343    public override string GetSignatureForError ()
2344    {
2345      return "null";
2346    }
2347
2348    public override object GetValue ()
2349    {
2350      return null;
2351    }
2352
2353    public override string GetValueAsLiteral ()
2354    {
2355      return GetSignatureForError ();
2356    }
2357
2358    public override long GetValueAsLong ()
2359    {
2360      throw new NotSupportedException ();
2361    }
2362
2363    public override bool IsDefaultValue {
2364      get { return true; }
2365    }
2366
2367    public override bool IsNegative {
2368      get { return false; }
2369    }
2370
2371    public override bool IsNull {
2372      get { return true; }
2373    }
2374
2375    public override bool IsZeroInteger {
2376      get { return true; }
2377    }
2378  }
2379
2380
2381  //
2382  // A null constant in a pointer context
2383  //
2384  class NullPointer : NullConstant
2385  {
2386    public NullPointer (TypeSpec type, Location loc)
2387      : base (type, loc)
2388    {
2389    }
2390
2391    public override Expression CreateExpressionTree (ResolveContext ec)
2392    {
2393      Error_PointerInsideExpressionTree (ec);
2394      return base.CreateExpressionTree (ec);
2395    }
2396
2397    public override void Emit (EmitContext ec)
2398    {
2399      //
2400      // Emits null pointer
2401      //
2402      ec.EmitInt (0);
2403      ec.Emit (OpCodes.Conv_U);
2404    }
2405  }
2406
2407  /// <summary>
2408  ///   The value is constant, but when emitted has a side effect.  This is
2409  ///   used by BitwiseAnd to ensure that the second expression is invoked
2410  ///   regardless of the value of the left side. 
2411  /// </summary>
2412  public class SideEffectConstant : Constant
2413  {
2414    public readonly Constant value;
2415    Expression side_effect;
2416   
2417    public SideEffectConstant (Constant value, Expression side_effect, Location loc)
2418      : base (loc)
2419    {
2420      this.value = value;
2421      type = value.Type;
2422      eclass = ExprClass.Value;
2423
2424      while (side_effect is SideEffectConstant)
2425        side_effect = ((SideEffectConstant) side_effect).side_effect;
2426      this.side_effect = side_effect;
2427    }
2428
2429    public override bool IsSideEffectFree {
2430      get {
2431        return false;
2432      }
2433    }
2434
2435    public override bool ContainsEmitWithAwait ()
2436    {
2437      return side_effect.ContainsEmitWithAwait ();
2438    }
2439
2440    public override object GetValue ()
2441    {
2442      return value.GetValue ();
2443    }
2444
2445    public override string GetValueAsLiteral ()
2446    {
2447      return value.GetValueAsLiteral ();
2448    }
2449
2450    public override long GetValueAsLong ()
2451    {
2452      return value.GetValueAsLong ();
2453    }
2454
2455    public override void Emit (EmitContext ec)
2456    {
2457      side_effect.EmitSideEffect (ec);
2458      value.Emit (ec);
2459    }
2460
2461    public override void EmitSideEffect (EmitContext ec)
2462    {
2463      side_effect.EmitSideEffect (ec);
2464      value.EmitSideEffect (ec);
2465    }
2466
2467    public override void FlowAnalysis (FlowAnalysisContext fc)
2468    {
2469      side_effect.FlowAnalysis (fc);
2470    }
2471
2472    public override bool IsDefaultValue {
2473      get { return value.IsDefaultValue; }
2474    }
2475
2476    public override bool IsNegative {
2477      get { return value.IsNegative; }
2478    }
2479
2480    public override bool IsZeroInteger {
2481      get { return value.IsZeroInteger; }
2482    }
2483
2484    public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
2485    {
2486      Constant new_value = value.ConvertExplicitly (in_checked_context, target_type);
2487      if (new_value == null)
2488        return null;
2489
2490      var c = new SideEffectConstant (new_value, side_effect, new_value.Location);
2491      c.type = target_type;
2492      c.eclass = eclass;
2493      return c;
2494    }
2495  }
2496}
Note: See TracBrowser for help on using the repository browser.