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         {
  24                 class EnumTypeExpr : TypeExpr
  25                 {
  26                         protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
  27                         {
  28                                 type = ec.CurrentType;
  29                                 return this;
  30                         }
  31
  32                         public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent)
  33                         {
  34                                 return DoResolveAsTypeStep (ec);
  35                         }
  36                 }
  37
  38                 public EnumMember (Enum parent, EnumMember prev_member, string name, Expression expr,
  39                                    Attributes attrs, Location loc)
  40                         : base (parent, new EnumTypeExpr (), name, null, Modifiers.PUBLIC,
  41                                 attrs, loc)
  42                 {
  43                         initializer = new EnumInitializer (this, expr, prev_member);
  44                 }
  45
  46                 static bool IsValidEnumType (TypeSpec t)
  47                 {
  48                         return (t == TypeManager.int32_type || t == TypeManager.uint32_type || t == TypeManager.int64_type ||
  49                                 t == TypeManager.byte_type || t == TypeManager.sbyte_type || t == TypeManager.short_type ||
  50                                 t == TypeManager.ushort_type || t == TypeManager.uint64_type || t == TypeManager.char_type ||
  51                                 TypeManager.IsEnumType (t));
  52                 }
  53
  54                 public override Constant ConvertInitializer (ResolveContext rc, Constant expr)
  55                 {
  56                         if (expr is EnumConstant)
  57                                 expr = ((EnumConstant) expr).Child;
  58
  59                         var underlying = ((Enum) Parent).UnderlyingType;
  60                         if (expr != null) {
  61                                 expr = expr.ImplicitConversionRequired (rc, underlying, Location);
  62                                 if (expr != null && !IsValidEnumType (expr.Type)) {
  63                                         Enum.Error_1008 (Location, Report);
  64                                         expr = null;
  65                                 }
  66                         }
  67
  68                         if (expr == null)
  69                                 expr = New.Constantify (underlying);
  70
  71                         return new EnumConstant (expr, MemberType).Resolve (rc);
  72                 }
  73
  74                 public override bool Define ()
  75                 {
  76                         if (!ResolveMemberType ())
  77                                 return false;
  78
  79                         const FieldAttributes attr = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal;
  80                         FieldBuilder = Parent.TypeBuilder.DefineField (Name, MemberType.GetMetaInfo (), attr);
  81                         spec = new ConstSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags, initializer);
  82
  83                         Parent.MemberCache.AddMember (spec);
  84                         return true;
  85                 }
  86         }
  87
  88         class EnumInitializer : ConstInitializer
  89         {
  90                 EnumMember prev;
  91
  92                 public EnumInitializer (Const field, Expression init, EnumMember prev)
  93                         : base (field, init)
  94                 {
  95                         this.prev = prev;
  96                 }
  97
  98                 protected override Expression DoResolveInitializer (ResolveContext rc)
  99                 {
 100                         if (expr != null)
 101                                 return base.DoResolveInitializer (rc);
 102
 103                         if (prev == null)
 104                                 return field.ConvertInitializer (rc, null);
 105
 106                         try {
 107                                 var ec = prev.DefineValue () as EnumConstant;
 108                                 expr = ec.Increment ().Resolve (rc);
 109                         } catch (OverflowException) {
 110                                 rc.Report.Error (543, field.Location,
 111                                         "The enumerator value `{0}' is outside the range of enumerator underlying type `{1}'",
 112                                         field.GetSignatureForError (),
 113                                         TypeManager.CSharpName (((Enum) field.Parent).UnderlyingType));
 114
 115                                 expr = field.ConvertInitializer (rc, null);
 116                         }
 117
 118                         return expr;
 119                 }
 120         }
 121
 122         /// <summary>
 123         ///   Enumeration container
 124         /// </summary>
 125         public class Enum : TypeContainer
 126         {
 127                 public static readonly string UnderlyingValueField = "value__";
 128
 129                 const Modifiers AllowedModifiers =
 130                         Modifiers.NEW |
 131                         Modifiers.PUBLIC |
 132                         Modifiers.PROTECTED |
 133                         Modifiers.INTERNAL |
 134                         Modifiers.PRIVATE;
 135
 136                 public Enum (NamespaceEntry ns, DeclSpace parent, TypeExpression type,
 137                              Modifiers mod_flags, MemberName name, Attributes attrs)
 138                         : base (ns, parent, name, attrs, MemberKind.Enum)
 139                 {
 140                         base_type_expr = type;
 141                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
 142                         ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report);
 143                         spec = new EnumSpec (null, this, null, null, ModFlags);
 144                 }
 145
 146                 #region Properties
 147
 148                 public override AttributeTargets AttributeTargets {
 149                         get {
 150                                 return AttributeTargets.Enum;
 151                         }
 152                 }
 153
 154                 public TypeExpr BaseTypeExpression {
 155                         get {
 156                                 return base_type_expr;
 157                         }
 158                 }
 159
 160                 protected override TypeAttributes TypeAttr {
 161                         get {
 162                                 return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel) |
 163                                         TypeAttributes.Class | TypeAttributes.Sealed | base.TypeAttr;
 164                         }
 165                 }
 166
 167                 public TypeSpec UnderlyingType {
 168                         get {
 169                                 return ((EnumSpec) spec).UnderlyingType;
 170                         }
 171                 }
 172
 173                 #endregion
 174
 175                 public void AddEnumMember (EnumMember em)
 176                 {
 177                         if (em.Name == UnderlyingValueField) {
 178                                 Report.Error (76, em.Location, "An item in an enumeration cannot have an identifier `{0}'",
 179                                         UnderlyingValueField);
 180                                 return;
 181                         }
 182
 183                         AddConstant (em);
 184                 }
 185
 186                 public static void Error_1008 (Location loc, Report Report)
 187                 {
 188                         Report.Error (1008, loc,
 189                                 "Type byte, sbyte, short, ushort, int, uint, long or ulong expected");
 190                 }
 191
 192                 protected override bool DefineNestedTypes ()
 193                 {
 194                         ((EnumSpec) spec).UnderlyingType = base_type_expr == null ? TypeManager.int32_type : base_type_expr.Type;
 195
 196                         TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType.GetMetaInfo (),
 197                                 FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
 198
 199                         if (!RootContext.StdLib)
 200                                 RootContext.hack_corlib_enums.Add (this);
 201
 202                         return true;
 203                 }
 204
 205                 protected override bool DoDefineMembers ()
 206                 {
 207                         DefineContainerMembers (constants);
 208                         return true;
 209                 }
 210
 211                 public override bool IsUnmanagedType ()
 212                 {
 213                         return true;
 214                 }
 215
 216                 protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
 217                 {
 218                         base_type = TypeManager.enum_type;
 219                         base_class = base_type_expr;
 220                         return null;
 221                 }
 222
 223                 protected override bool VerifyClsCompliance ()
 224                 {
 225                         if (!base.VerifyClsCompliance ())
 226                                 return false;
 227
 228                         if (UnderlyingType == TypeManager.uint32_type ||
 229                                 UnderlyingType == TypeManager.uint64_type ||
 230                                 UnderlyingType == TypeManager.ushort_type) {
 231                                 Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (UnderlyingType));
 232                         }
 233
 234                         return true;
 235                 }
 236         }
 237
 238         class EnumSpec : TypeSpec
 239         {
 240                 TypeSpec underlying;
 241
 242                 public EnumSpec (TypeSpec declaringType, ITypeDefinition definition, TypeSpec underlyingType, Type info, Modifiers modifiers)
 243                         : base (MemberKind.Enum, declaringType, definition, info, modifiers | Modifiers.SEALED)
 244                 {
 245                         this.underlying = underlyingType;
 246                 }
 247
 248                 public TypeSpec UnderlyingType {
 249                         get {
 250                                 return underlying;
 251                         }
 252                         set {
 253                                 if (underlying != null)
 254                                         throw new InternalErrorException ("UnderlyingType reset");
 255
 256                                 underlying = value;
 257                         }
 258                 }
 259
 260                 public static TypeSpec GetUnderlyingType (TypeSpec t)
 261                 {
 262                         return ((EnumSpec) t.GetDefinition ()).UnderlyingType;
 263                 }
 264         }
 265 }