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                 TypeExpr base_type;
 130
 131                 const Modifiers AllowedModifiers =
 132                         Modifiers.NEW |
 133                         Modifiers.PUBLIC |
 134                         Modifiers.PROTECTED |
 135                         Modifiers.INTERNAL |
 136                         Modifiers.PRIVATE;
 137
 138                 public Enum (NamespaceEntry ns, DeclSpace parent, TypeExpr type,
 139                              Modifiers mod_flags, MemberName name, Attributes attrs)
 140                         : base (ns, parent, name, attrs, MemberKind.Enum)
 141                 {
 142                         this.base_type = type;
 143                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
 144                         ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report);
 145                         spec = new EnumSpec (null, this, null, null, ModFlags);
 146                 }
 147
 148                 public void AddEnumMember (EnumMember em)
 149                 {
 150                         if (em.Name == UnderlyingValueField) {
 151                                 Report.Error (76, em.Location, "An item in an enumeration cannot have an identifier `{0}'",
 152                                         UnderlyingValueField);
 153                                 return;
 154                         }
 155
 156                         AddConstant (em);
 157                 }
 158
 159                 public static void Error_1008 (Location loc, Report Report)
 160                 {
 161                         Report.Error (1008, loc, "Type byte, sbyte, short, ushort, " +
 162                                       "int, uint, long or ulong expected");
 163                 }
 164
 165                 protected override bool DefineNestedTypes ()
 166                 {
 167                         if (!base.DefineNestedTypes ())
 168                                 return false;
 169
 170                         ((EnumSpec) spec).UnderlyingType = UnderlyingType;
 171
 172                         TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType.GetMetaInfo (),
 173                                 FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
 174
 175                         if (!RootContext.StdLib)
 176                                 RootContext.hack_corlib_enums.Add (this);
 177
 178                         return true;
 179                 }
 180
 181                 protected override bool DoDefineMembers ()
 182                 {
 183                         DefineContainerMembers (constants);
 184                         return true;
 185                 }
 186
 187                 public override bool IsUnmanagedType ()
 188                 {
 189                         return true;
 190                 }
 191
 192                 public TypeSpec UnderlyingType {
 193                         get {
 194                                 return base_type.Type;
 195                         }
 196                 }
 197
 198                 protected override bool VerifyClsCompliance ()
 199                 {
 200                         if (!base.VerifyClsCompliance ())
 201                                 return false;
 202
 203                         if (UnderlyingType == TypeManager.uint32_type ||
 204                                 UnderlyingType == TypeManager.uint64_type ||
 205                                 UnderlyingType == TypeManager.ushort_type) {
 206                                 Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (UnderlyingType));
 207                         }
 208
 209                         return true;
 210                 }
 211
 212                 public override AttributeTargets AttributeTargets {
 213                         get {
 214                                 return AttributeTargets.Enum;
 215                         }
 216                 }
 217
 218                 protected override TypeAttributes TypeAttr {
 219                         get {
 220                                 return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel) |
 221                                         TypeAttributes.Class | TypeAttributes.Sealed | base.TypeAttr;
 222                         }
 223                 }
 224         }
 225
 226         class EnumSpec : TypeSpec
 227         {
 228                 TypeSpec underlying;
 229
 230                 public EnumSpec (TypeSpec declaringType, ITypeDefinition definition, TypeSpec underlyingType, Type info, Modifiers modifiers)
 231                         : base (MemberKind.Enum, declaringType, definition, info, modifiers | Modifiers.SEALED)
 232                 {
 233                         this.underlying = underlyingType;
 234                 }
 235
 236                 public TypeSpec UnderlyingType {
 237                         get {
 238                                 return underlying;
 239                         }
 240                         set {
 241                                 if (underlying != null)
 242                                         throw new InternalErrorException ("UnderlyingType reset");
 243
 244                                 underlying = value;
 245                         }
 246                 }
 247
 248                 public static TypeSpec GetUnderlyingType (TypeSpec t)
 249                 {
 250                         return ((EnumSpec) t.GetDefinition ()).UnderlyingType;
 251                 }
 252         }
 253 }