X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fenum.cs;h=4b0f4a020432e8691595e31a69658726ba7def7b;hb=12d16ae4269e9a008863e6718075d6c168d6d16c;hp=eb47e491f21444a55e71a207bad52df055bbaa64;hpb=029d67e3e22a8cdcc3363fb35aa6f3d1aa413cb1;p=mono.git diff --git a/mcs/mcs/enum.cs b/mcs/mcs/enum.cs index eb47e491f21..4b0f4a02043 100644 --- a/mcs/mcs/enum.cs +++ b/mcs/mcs/enum.cs @@ -12,10 +12,14 @@ // using System; -using System.Collections.Generic; + +#if STATIC +using MetaType = IKVM.Reflection.Type; +using IKVM.Reflection; +#else +using MetaType = System.Type; using System.Reflection; -using System.Reflection.Emit; -using System.Globalization; +#endif namespace Mono.CSharp { @@ -23,15 +27,11 @@ namespace Mono.CSharp { { class EnumTypeExpr : TypeExpr { - protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec) + public override TypeSpec ResolveAsType (IMemberContext ec) { type = ec.CurrentType; - return this; - } - - public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent) - { - return DoResolveAsTypeStep (ec); + eclass = ExprClass.Type; + return type; } } @@ -42,10 +42,20 @@ namespace Mono.CSharp { 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 || - TypeManager.IsEnumType (t)); + switch (t.BuiltinType) { + case BuiltinTypeSpec.Type.Int: + case BuiltinTypeSpec.Type.UInt: + case BuiltinTypeSpec.Type.Long: + case BuiltinTypeSpec.Type.Byte: + case BuiltinTypeSpec.Type.SByte: + case BuiltinTypeSpec.Type.Short: + case BuiltinTypeSpec.Type.UShort: + case BuiltinTypeSpec.Type.ULong: + case BuiltinTypeSpec.Type.Char: + return true; + default: + return t.IsEnum; + } } public override Constant ConvertInitializer (ResolveContext rc, Constant expr) @@ -65,7 +75,7 @@ namespace Mono.CSharp { if (expr == null) expr = New.Constantify (underlying, Location); - return new EnumConstant (expr, MemberType).Resolve (rc); + return new EnumConstant (expr, MemberType); } public override bool Define () @@ -90,7 +100,7 @@ namespace Mono.CSharp { // // Implicit enum member initializer, used when no constant value is provided // - class ImplicitInitializer : Expression + sealed class ImplicitInitializer : Expression { readonly EnumMember prev; readonly EnumMember current; @@ -101,6 +111,11 @@ namespace Mono.CSharp { this.prev = prev; } + public override bool ContainsEmitWithAwait () + { + return false; + } + public override Expression CreateExpressionTree (ResolveContext ec) { throw new NotSupportedException ("Missing Resolve call"); @@ -110,18 +125,18 @@ namespace Mono.CSharp { { // We are the first member if (prev == null) { - return New.Constantify (current.Parent.Definition, Location).Resolve (rc); + return New.Constantify (current.Parent.Definition, Location); } var c = ((ConstSpec) prev.Spec).GetConstant (rc) as EnumConstant; try { - return c.Increment ().Resolve (rc); + return c.Increment (); } catch (OverflowException) { rc.Report.Error (543, current.Location, "The enumerator value `{0}' is outside the range of enumerator underlying type `{1}'", current.GetSignatureForError (), ((Enum) current.Parent).UnderlyingType.GetSignatureForError ()); - return New.Constantify (current.Parent.Definition, current.Location).Resolve (rc); + return New.Constantify (current.Parent.Definition, current.Location); } } @@ -140,11 +155,13 @@ namespace Mono.CSharp { Modifiers.INTERNAL | Modifiers.PRIVATE; - public Enum (NamespaceEntry ns, DeclSpace parent, TypeExpression type, + readonly TypeExpr underlying_type_expr; + + public Enum (NamespaceContainer ns, DeclSpace parent, TypeExpression type, Modifiers mod_flags, MemberName name, Attributes attrs) : base (ns, parent, name, attrs, MemberKind.Enum) { - base_type_expr = type; + underlying_type_expr = type; var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE; ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report); spec = new EnumSpec (null, this, null, null, ModFlags); @@ -160,7 +177,7 @@ namespace Mono.CSharp { public TypeExpr BaseTypeExpression { get { - return base_type_expr; + return underlying_type_expr; } } @@ -179,6 +196,11 @@ namespace Mono.CSharp { #endregion + public override void Accept (StructuralVisitor visitor) + { + visitor.Visit (this); + } + public void AddEnumMember (EnumMember em) { if (em.Name == UnderlyingValueField) { @@ -198,14 +220,11 @@ namespace Mono.CSharp { protected override bool DefineNestedTypes () { - ((EnumSpec) spec).UnderlyingType = base_type_expr == null ? TypeManager.int32_type : base_type_expr.Type; + ((EnumSpec) spec).UnderlyingType = underlying_type_expr == null ? Compiler.BuiltinTypes.Int : underlying_type_expr.Type; TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType.GetMetaInfo (), FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName); - if (!RootContext.StdLib) - RootContext.hack_corlib_enums.Add (this); - return true; } @@ -230,10 +249,10 @@ namespace Mono.CSharp { return true; } - protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) + protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { - base_type = TypeManager.enum_type; - base_class = base_type_expr; + base_type = Compiler.BuiltinTypes.Enum; + base_class = null; return null; } @@ -242,10 +261,13 @@ namespace Mono.CSharp { if (!base.VerifyClsCompliance ()) return false; - if (UnderlyingType == TypeManager.uint32_type || - UnderlyingType == TypeManager.uint64_type || - UnderlyingType == TypeManager.ushort_type) { - Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (UnderlyingType)); + switch (UnderlyingType.BuiltinType) { + case BuiltinTypeSpec.Type.UInt: + case BuiltinTypeSpec.Type.ULong: + case BuiltinTypeSpec.Type.UShort: + Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant", + GetSignatureForError (), TypeManager.CSharpName (UnderlyingType)); + break; } return true; @@ -256,7 +278,7 @@ namespace Mono.CSharp { { TypeSpec underlying; - public EnumSpec (TypeSpec declaringType, ITypeDefinition definition, TypeSpec underlyingType, Type info, Modifiers modifiers) + public EnumSpec (TypeSpec declaringType, ITypeDefinition definition, TypeSpec underlyingType, MetaType info, Modifiers modifiers) : base (MemberKind.Enum, declaringType, definition, info, modifiers | Modifiers.SEALED) { this.underlying = underlyingType; @@ -278,5 +300,22 @@ namespace Mono.CSharp { { return ((EnumSpec) t.GetDefinition ()).UnderlyingType; } + + public static bool IsValidUnderlyingType (TypeSpec type) + { + switch (type.BuiltinType) { + case BuiltinTypeSpec.Type.Int: + case BuiltinTypeSpec.Type.UInt: + case BuiltinTypeSpec.Type.Long: + case BuiltinTypeSpec.Type.Byte: + case BuiltinTypeSpec.Type.SByte: + case BuiltinTypeSpec.Type.Short: + case BuiltinTypeSpec.Type.UShort: + case BuiltinTypeSpec.Type.ULong: + return true; + } + + return false; + } } }