mcs/enum.cs

   1 //
   2 // enum.cs: Enum handling.
   3 //
   4 // Author: Miguel de Icaza (miguel@gnu.org)
   5 //         Ravi Pratap     (ravi@ximian.com)
   6 //         Marek Safar     (marek.safar@seznam.cz)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2003-2003 Novell, Inc (http://www.novell.com)
  12 //
  13
  14 using System;
  15 using System.Collections.Generic;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18 using System.Globalization;
  19
  20 namespace Mono.CSharp {
  21
  22         public class EnumMember : Const {
  23                 protected readonly Enum ParentEnum;
  24                 protected readonly Expression ValueExpr;
  25                 readonly EnumMember prev_member;
  26
  27                 public EnumMember (Enum parent, EnumMember prev_member, string name, Expression expr,
  28                                    Attributes attrs, Location loc)
  29                         : base (parent, new EnumTypeExpr (parent), name, expr, Modifiers.PUBLIC,
  30                                 attrs, loc)
  31                 {
  32                         this.ParentEnum = parent;
  33                         this.ValueExpr = expr;
  34                         this.prev_member = prev_member;
  35                 }
  36
  37                 protected class EnumTypeExpr : TypeExpr
  38                 {
  39                         public readonly Enum Enum;
  40
  41                         public EnumTypeExpr (Enum e)
  42                         {
  43                                 this.Enum = e;
  44                         }
  45
  46                         protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
  47                         {
  48                                 type = Enum.CurrentType != null ? Enum.CurrentType : Enum.TypeBuilder;
  49                                 return this;
  50                         }
  51
  52                         public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent)
  53                         {
  54                                 return DoResolveAsTypeStep (ec);
  55                         }
  56                 }
  57
  58                 static bool IsValidEnumType (Type t)
  59                 {
  60                         return (t == TypeManager.int32_type || t == TypeManager.uint32_type || t == TypeManager.int64_type ||
  61                                 t == TypeManager.byte_type || t == TypeManager.sbyte_type || t == TypeManager.short_type ||
  62                                 t == TypeManager.ushort_type || t == TypeManager.uint64_type || t == TypeManager.char_type ||
  63                                 TypeManager.IsEnumType (t));
  64                 }
  65
  66                 public object Value {
  67                         get { return ResolveValue () ? value.GetValue () : null; }
  68                 }
  69
  70                 public override bool Define ()
  71                 {
  72                         if (!ResolveMemberType ())
  73                                 return false;
  74
  75                         const FieldAttributes attr = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal;
  76                         FieldBuilder = Parent.TypeBuilder.DefineField (Name, MemberType, attr);
  77                         Parent.MemberCache.AddMember (FieldBuilder, this);
  78                         TypeManager.RegisterConstant (FieldBuilder, this);
  79                         return true;
  80                 }
  81
  82                 protected override Constant DoResolveValue (ResolveContext ec)
  83                 {
  84                         if (ValueExpr != null) {
  85                                 Constant c = ValueExpr.ResolveAsConstant (ec, this);
  86                                 if (c == null)
  87                                         return null;
  88
  89                                 if (c is EnumConstant)
  90                                         c = ((EnumConstant)c).Child;
  91
  92                                 c = c.ImplicitConversionRequired (ec, ParentEnum.UnderlyingType, Location);
  93                                 if (c == null)
  94                                         return null;
  95
  96                                 if (!IsValidEnumType (c.Type)) {
  97                                         Enum.Error_1008 (Location, ec.Report);
  98                                         return null;
  99                                 }
 100
 101                                 return new EnumConstant (c, MemberType).Resolve (ec);
 102                         }
 103
 104                         if (prev_member == null)
 105                                 return new EnumConstant (New.Constantify (ParentEnum.UnderlyingType), MemberType).Resolve (ec);
 106
 107                         if (!prev_member.ResolveValue ())
 108                                 return null;
 109
 110                         try {
 111                                 return ((EnumConstant) prev_member.value).Increment ();
 112                         } catch (OverflowException) {
 113                                 Report.Error (543, Location, "The enumerator value `{0}' is too " +
 114                                               "large to fit in its type `{1}'", GetSignatureForError (),
 115                                               TypeManager.CSharpName (ParentEnum.UnderlyingType));
 116                                 return null;
 117                         }
 118                 }
 119         }
 120
 121         /// <summary>
 122         ///   Enumeration container
 123         /// </summary>
 124         public class Enum : TypeContainer
 125         {
 126                 public static readonly string UnderlyingValueField = "value__";
 127
 128                 TypeExpr base_type;
 129
 130                 const Modifiers AllowedModifiers =
 131                         Modifiers.NEW |
 132                         Modifiers.PUBLIC |
 133                         Modifiers.PROTECTED |
 134                         Modifiers.INTERNAL |
 135                         Modifiers.PRIVATE;
 136
 137                 public Enum (NamespaceEntry ns, DeclSpace parent, TypeExpr type,
 138                              Modifiers mod_flags, MemberName name, Attributes attrs)
 139                         : base (ns, parent, name, attrs, Kind.Enum)
 140                 {
 141                         this.base_type = type;
 142                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
 143                         ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report);
 144                 }
 145
 146                 public void AddEnumMember (EnumMember em)
 147                 {
 148                         if (em.Name == UnderlyingValueField) {
 149                                 Report.Error (76, em.Location, "An item in an enumeration cannot have an identifier `{0}'",
 150                                         UnderlyingValueField);
 151                                 return;
 152                         }
 153
 154                         AddConstant (em);
 155                 }
 156
 157                 public static void Error_1008 (Location loc, Report Report)
 158                 {
 159                         Report.Error (1008, loc, "Type byte, sbyte, short, ushort, " +
 160                                       "int, uint, long or ulong expected");
 161                 }
 162
 163                 protected override bool DefineNestedTypes ()
 164                 {
 165                         if (!base.DefineNestedTypes ())
 166                                 return false;
 167
 168                         //
 169                         // Call MapToInternalType for corlib
 170                         //
 171                         TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType,
 172                                                  FieldAttributes.Public | FieldAttributes.SpecialName
 173                                                  | FieldAttributes.RTSpecialName);
 174
 175                         return true;
 176                 }
 177
 178                 protected override bool DoDefineMembers ()
 179                 {
 180                         member_cache = new MemberCache (TypeManager.enum_type, this);
 181                         DefineContainerMembers (constants);
 182                         return true;
 183                 }
 184
 185                 public override bool IsUnmanagedType ()
 186                 {
 187                         return true;
 188                 }
 189
 190                 public Type UnderlyingType {
 191                         get {
 192                                 return base_type.Type;
 193                         }
 194                 }
 195
 196                 protected override bool VerifyClsCompliance ()
 197                 {
 198                         if (!base.VerifyClsCompliance ())
 199                                 return false;
 200
 201                         if (UnderlyingType == TypeManager.uint32_type ||
 202                                 UnderlyingType == TypeManager.uint64_type ||
 203                                 UnderlyingType == TypeManager.ushort_type) {
 204                                 Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (UnderlyingType));
 205                         }
 206
 207                         return true;
 208                 }
 209
 210                 public override AttributeTargets AttributeTargets {
 211                         get {
 212                                 return AttributeTargets.Enum;
 213                         }
 214                 }
 215
 216                 protected override TypeAttributes TypeAttr {
 217                         get {
 218                                 return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel) |
 219                                         TypeAttributes.Class | TypeAttributes.Sealed | base.TypeAttr;
 220                         }
 221                 }
 222         }
 223 }