X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fenum.cs;h=d323e062d02ce2db1676b70944d5eeffe79a3510;hb=732841a4f171062563a831fb8cd3165be1ddfd6e;hp=aeabce500c74d5ef932d897f6f7fe0edc045a3f2;hpb=feb700323765777d4efff14ed48f200c104b3127;p=mono.git diff --git a/mcs/mcs/enum.cs b/mcs/mcs/enum.cs index aeabce500c7..d323e062d02 100644 --- a/mcs/mcs/enum.cs +++ b/mcs/mcs/enum.cs @@ -12,7 +12,6 @@ // using System; -using System.Collections; using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; @@ -20,33 +19,13 @@ using System.Globalization; namespace Mono.CSharp { - public class EnumMember : Const { - protected readonly Enum ParentEnum; - protected readonly Expression ValueExpr; - readonly EnumMember prev_member; - - public EnumMember (Enum parent, EnumMember prev_member, string name, Expression expr, - Attributes attrs, Location loc) - : base (parent, new EnumTypeExpr (parent), name, expr, Modifiers.PUBLIC, - attrs, loc) - { - this.ParentEnum = parent; - this.ValueExpr = expr; - this.prev_member = prev_member; - } - - protected class EnumTypeExpr : TypeExpr + public class EnumMember : Const + { + class EnumTypeExpr : TypeExpr { - public readonly Enum Enum; - - public EnumTypeExpr (Enum e) - { - this.Enum = e; - } - protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec) { - type = Enum.CurrentType != null ? Enum.CurrentType : Enum.TypeBuilder; + type = ec.CurrentType; return this; } @@ -56,7 +35,15 @@ namespace Mono.CSharp { } } - static bool IsValidEnumType (Type t) + public EnumMember (Enum parent, EnumMember prev_member, string name, Expression expr, + Attributes attrs, Location loc) + : base (parent, new EnumTypeExpr (), name, null, Modifiers.PUBLIC, + attrs, loc) + { + initializer = new EnumInitializer (this, expr, prev_member); + } + + static bool IsValidEnumType (TypeSpec t) { return (t == TypeManager.int32_type || t == TypeManager.uint32_type || t == TypeManager.int64_type || t == TypeManager.byte_type || t == TypeManager.sbyte_type || t == TypeManager.short_type || @@ -64,8 +51,24 @@ namespace Mono.CSharp { TypeManager.IsEnumType (t)); } - public object Value { - get { return ResolveValue () ? value.GetValue () : null; } + public override Constant ConvertInitializer (ResolveContext rc, Constant expr) + { + if (expr is EnumConstant) + expr = ((EnumConstant) expr).Child; + + var underlying = ((Enum) Parent).UnderlyingType; + if (expr != null) { + expr = expr.ImplicitConversionRequired (rc, underlying, Location); + if (expr != null && !IsValidEnumType (expr.Type)) { + Enum.Error_1008 (Location, Report); + expr = null; + } + } + + if (expr == null) + expr = New.Constantify (underlying); + + return new EnumConstant (expr, MemberType).Resolve (rc); } public override bool Define () @@ -74,48 +77,45 @@ namespace Mono.CSharp { return false; const FieldAttributes attr = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal; - FieldBuilder = Parent.TypeBuilder.DefineField (Name, MemberType, attr); - Parent.MemberCache.AddMember (FieldBuilder, this); - TypeManager.RegisterConstant (FieldBuilder, this); + FieldBuilder = Parent.TypeBuilder.DefineField (Name, MemberType.GetMetaInfo (), attr); + spec = new ConstSpec (Parent.Definition, this, MemberType, FieldBuilder, ModFlags, initializer); + + Parent.MemberCache.AddMember (spec); return true; } - - protected override Constant DoResolveValue (ResolveContext ec) - { - if (ValueExpr != null) { - Constant c = ValueExpr.ResolveAsConstant (ec, this); - if (c == null) - return null; - - if (c is EnumConstant) - c = ((EnumConstant)c).Child; - - c = c.ImplicitConversionRequired (ec, ParentEnum.UnderlyingType, Location); - if (c == null) - return null; + } - if (!IsValidEnumType (c.Type)) { - Enum.Error_1008 (Location, ec.Report); - return null; - } + class EnumInitializer : ConstInitializer + { + EnumMember prev; - return new EnumConstant (c, MemberType).Resolve (ec); - } + public EnumInitializer (Const field, Expression init, EnumMember prev) + : base (field, init) + { + this.prev = prev; + } - if (prev_member == null) - return new EnumConstant (New.Constantify (ParentEnum.UnderlyingType), MemberType).Resolve (ec); + protected override Expression DoResolveInitializer (ResolveContext rc) + { + if (expr != null) + return base.DoResolveInitializer (rc); - if (!prev_member.ResolveValue ()) - return null; + if (prev == null) + return field.ConvertInitializer (rc, null); try { - return ((EnumConstant) prev_member.value).Increment (); + var ec = prev.DefineValue () as EnumConstant; + expr = ec.Increment ().Resolve (rc); } catch (OverflowException) { - Report.Error (543, Location, "The enumerator value `{0}' is too " + - "large to fit in its type `{1}'", GetSignatureForError (), - TypeManager.CSharpName (ParentEnum.UnderlyingType)); - return null; - } + rc.Report.Error (543, field.Location, + "The enumerator value `{0}' is outside the range of enumerator underlying type `{1}'", + field.GetSignatureForError (), + TypeManager.CSharpName (((Enum) field.Parent).UnderlyingType)); + + expr = field.ConvertInitializer (rc, null); + } + + return expr; } } @@ -128,7 +128,7 @@ namespace Mono.CSharp { TypeExpr base_type; - const int AllowedModifiers = + const Modifiers AllowedModifiers = Modifiers.NEW | Modifiers.PUBLIC | Modifiers.PROTECTED | @@ -136,12 +136,13 @@ namespace Mono.CSharp { Modifiers.PRIVATE; public Enum (NamespaceEntry ns, DeclSpace parent, TypeExpr type, - int mod_flags, MemberName name, Attributes attrs) - : base (ns, parent, name, attrs, Kind.Enum) + Modifiers mod_flags, MemberName name, Attributes attrs) + : base (ns, parent, name, attrs, MemberKind.Enum) { this.base_type = type; - int accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE; - ModFlags = Modifiers.Check (AllowedModifiers, mod_flags, accmods, Location, Report); + var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE; + ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report); + spec = new EnumSpec (null, this, null, null, ModFlags); } public void AddEnumMember (EnumMember em) @@ -166,19 +167,19 @@ namespace Mono.CSharp { if (!base.DefineNestedTypes ()) return false; - // - // Call MapToInternalType for corlib - // - TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType, - FieldAttributes.Public | FieldAttributes.SpecialName - | FieldAttributes.RTSpecialName); + ((EnumSpec) spec).UnderlyingType = UnderlyingType; + + TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType.GetMetaInfo (), + FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName); + + if (!RootContext.StdLib) + RootContext.hack_corlib_enums.Add (this); return true; } protected override bool DoDefineMembers () { - member_cache = new MemberCache (TypeManager.enum_type, this); DefineContainerMembers (constants); return true; } @@ -188,7 +189,7 @@ namespace Mono.CSharp { return true; } - public Type UnderlyingType { + public TypeSpec UnderlyingType { get { return base_type.Type; } @@ -216,9 +217,37 @@ namespace Mono.CSharp { protected override TypeAttributes TypeAttr { get { - return Modifiers.TypeAttr (ModFlags, IsTopLevel) | + return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel) | TypeAttributes.Class | TypeAttributes.Sealed | base.TypeAttr; } } } + + class EnumSpec : TypeSpec + { + TypeSpec underlying; + + public EnumSpec (TypeSpec declaringType, ITypeDefinition definition, TypeSpec underlyingType, Type info, Modifiers modifiers) + : base (MemberKind.Enum, declaringType, definition, info, modifiers | Modifiers.SEALED) + { + this.underlying = underlyingType; + } + + public TypeSpec UnderlyingType { + get { + return underlying; + } + set { + if (underlying != null) + throw new InternalErrorException ("UnderlyingType reset"); + + underlying = value; + } + } + + public static TypeSpec GetUnderlyingType (TypeSpec t) + { + return ((EnumSpec) t.GetDefinition ()).UnderlyingType; + } + } }