X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fenum.cs;h=d323e062d02ce2db1676b70944d5eeffe79a3510;hb=732841a4f171062563a831fb8cd3165be1ddfd6e;hp=2523e0cf76c1cc701b5fb638ac8bc2d7254e300b;hpb=6f5a0b555436eba699f9dd2659471044097b951b;p=mono.git diff --git a/mcs/mcs/enum.cs b/mcs/mcs/enum.cs index 2523e0cf76c..d323e062d02 100644 --- a/mcs/mcs/enum.cs +++ b/mcs/mcs/enum.cs @@ -12,60 +12,63 @@ // using System; -using System.Collections; -using System.Collections.Specialized; +using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; 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) + protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec) { - this.Enum = e; - } - - protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec) - { - type = Enum.CurrentType != null ? Enum.CurrentType : Enum.TypeBuilder; + type = ec.CurrentType; return this; } - public override TypeExpr ResolveAsTypeTerminal (IResolveContext ec, bool silent) + public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent) { return DoResolveAsTypeStep (ec); } } - 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 || t == TypeManager.ushort_type || t == TypeManager.uint64_type || t == TypeManager.char_type || - t.IsEnum); + 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,49 +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 (EmitContext 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); - return null; - } + class EnumInitializer : ConstInitializer + { + EnumMember prev; - return new EnumConstant (c, MemberType); - } + 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); + 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; } } @@ -129,7 +128,7 @@ namespace Mono.CSharp { TypeExpr base_type; - const int AllowedModifiers = + const Modifiers AllowedModifiers = Modifiers.NEW | Modifiers.PUBLIC | Modifiers.PROTECTED | @@ -137,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); + 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) @@ -156,7 +156,7 @@ namespace Mono.CSharp { AddConstant (em); } - public static void Error_1008 (Location loc) + public static void Error_1008 (Location loc, Report Report) { Report.Error (1008, loc, "Type byte, sbyte, short, ushort, " + "int, uint, long or ulong expected"); @@ -167,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; } - public override bool Define () + protected override bool DoDefineMembers () { - member_cache = new MemberCache (TypeManager.enum_type, this); DefineContainerMembers (constants); return true; } @@ -189,7 +189,7 @@ namespace Mono.CSharp { return true; } - public Type UnderlyingType { + public TypeSpec UnderlyingType { get { return base_type.Type; } @@ -217,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; + } + } }