mcs/mcs/modifiers.cs

   1 //
   2 // modifiers.cs: Modifiers handling
   3 //
   4 // Authors: Miguel de Icaza (miguel@gnu.org)
   5 //          Marek Safar (marek.safar@gmail.com)
   6 //
   7 // Dual licensed under the terms of the MIT X11 or GNU GPL
   8 //
   9 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  10 // Copyright 2004-2010 Novell, Inc
  11 //
  12
  13 using System;
  14
  15 #if STATIC
  16 using IKVM.Reflection;
  17 #else
  18 using System.Reflection;
  19 #endif
  20
  21 namespace Mono.CSharp
  22 {
  23         [Flags]
  24         public enum Modifiers
  25         {
  26                 PROTECTED = 0x0001,
  27                 PUBLIC    = 0x0002,
  28                 PRIVATE   = 0x0004,
  29                 INTERNAL  = 0x0008,
  30                 NEW       = 0x0010,
  31                 ABSTRACT  = 0x0020,
  32                 SEALED    = 0x0040,
  33                 STATIC    = 0x0080,
  34                 READONLY  = 0x0100,
  35                 VIRTUAL   = 0x0200,
  36                 OVERRIDE  = 0x0400,
  37                 EXTERN    = 0x0800,
  38                 VOLATILE  = 0x1000,
  39                 UNSAFE    = 0x2000,
  40                 TOP       = 0x4000,
  41
  42                 //
  43                 // Compiler specific flags
  44                 //
  45                 PROPERTY_CUSTOM                 = 0x4000,
  46
  47                 ASYNC                                   = 0x10000,
  48                 PARTIAL                                 = 0x20000,
  49                 DEFAULT_ACCESS_MODIFER  = 0x40000,
  50                 METHOD_EXTENSION                = 0x80000,
  51                 COMPILER_GENERATED              = 0x100000,
  52                 BACKING_FIELD                   = 0x200000,
  53                 DEBUGGER_HIDDEN                 = 0x400000,
  54
  55                 AccessibilityMask = PUBLIC | PROTECTED | INTERNAL | PRIVATE,
  56                 AllowedExplicitImplFlags = UNSAFE | EXTERN,
  57         }
  58
  59         static class ModifiersExtensions
  60         {
  61                 public static string AccessibilityName (Modifiers mod)
  62                 {
  63                         switch (mod & Modifiers.AccessibilityMask) {
  64                         case Modifiers.PUBLIC:
  65                                 return "public";
  66                         case Modifiers.PROTECTED:
  67                                 return "protected";
  68                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
  69                                 return "protected internal";
  70                         case Modifiers.INTERNAL:
  71                                 return "internal";
  72                         case Modifiers.PRIVATE:
  73                                 return "private";
  74                         default:
  75                                 throw new NotImplementedException (mod.ToString ());
  76                         }
  77                 }
  78
  79                 static public string Name (Modifiers i)
  80                 {
  81                         string s = "";
  82
  83                         switch (i) {
  84                         case Modifiers.NEW:
  85                                 s = "new"; break;
  86                         case Modifiers.PUBLIC:
  87                                 s = "public"; break;
  88                         case Modifiers.PROTECTED:
  89                                 s = "protected"; break;
  90                         case Modifiers.INTERNAL:
  91                                 s = "internal"; break;
  92                         case Modifiers.PRIVATE:
  93                                 s = "private"; break;
  94                         case Modifiers.ABSTRACT:
  95                                 s = "abstract"; break;
  96                         case Modifiers.SEALED:
  97                                 s = "sealed"; break;
  98                         case Modifiers.STATIC:
  99                                 s = "static"; break;
 100                         case Modifiers.READONLY:
 101                                 s = "readonly"; break;
 102                         case Modifiers.VIRTUAL:
 103                                 s = "virtual"; break;
 104                         case Modifiers.OVERRIDE:
 105                                 s = "override"; break;
 106                         case Modifiers.EXTERN:
 107                                 s = "extern"; break;
 108                         case Modifiers.VOLATILE:
 109                                 s = "volatile"; break;
 110                         case Modifiers.UNSAFE:
 111                                 s = "unsafe"; break;
 112                         }
 113
 114                         return s;
 115                 }
 116
 117                 //
 118                 // Used by custom property accessors to check whether @modA is more restrictive than @modB
 119                 //
 120                 public static bool IsRestrictedModifier (Modifiers modA, Modifiers modB)
 121                 {
 122                         Modifiers flags = 0;
 123
 124                         if ((modB & Modifiers.PUBLIC) != 0) {
 125                                 flags = Modifiers.PROTECTED | Modifiers.INTERNAL | Modifiers.PRIVATE;
 126                         } else if ((modB & Modifiers.PROTECTED) != 0) {
 127                                 if ((modB & Modifiers.INTERNAL) != 0)
 128                                         flags = Modifiers.PROTECTED | Modifiers.INTERNAL;
 129
 130                                 flags |= Modifiers.PRIVATE;
 131                         } else if ((modB & Modifiers.INTERNAL) != 0)
 132                                 flags = Modifiers.PRIVATE;
 133
 134                         return modB != modA && (modA & (~flags)) == 0;
 135                 }
 136
 137                 public static TypeAttributes TypeAttr (Modifiers mod_flags, bool is_toplevel)
 138                 {
 139                         TypeAttributes t = 0;
 140
 141                         if (is_toplevel){
 142                                 if ((mod_flags & Modifiers.PUBLIC) != 0)
 143                                         t = TypeAttributes.Public;
 144                                 else if ((mod_flags & Modifiers.PRIVATE) != 0)
 145                                         t = TypeAttributes.NotPublic;
 146                         } else {
 147                                 if ((mod_flags & Modifiers.PUBLIC) != 0)
 148                                         t = TypeAttributes.NestedPublic;
 149                                 else if ((mod_flags & Modifiers.PRIVATE) != 0)
 150                                         t = TypeAttributes.NestedPrivate;
 151                                 else if ((mod_flags & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL))
 152                                         t = TypeAttributes.NestedFamORAssem;
 153                                 else if ((mod_flags & Modifiers.PROTECTED) != 0)
 154                                         t = TypeAttributes.NestedFamily;
 155                                 else if ((mod_flags & Modifiers.INTERNAL) != 0)
 156                                         t = TypeAttributes.NestedAssembly;
 157                         }
 158
 159                         if ((mod_flags & Modifiers.SEALED) != 0)
 160                                 t |= TypeAttributes.Sealed;
 161                         if ((mod_flags & Modifiers.ABSTRACT) != 0)
 162                                 t |= TypeAttributes.Abstract;
 163
 164                         return t;
 165                 }
 166
 167                 public static FieldAttributes FieldAttr (Modifiers mod_flags)
 168                 {
 169                         FieldAttributes fa = 0;
 170
 171                         if ((mod_flags & Modifiers.PUBLIC) != 0)
 172                                 fa |= FieldAttributes.Public;
 173                         if ((mod_flags & Modifiers.PRIVATE) != 0)
 174                                 fa |= FieldAttributes.Private;
 175                         if ((mod_flags & Modifiers.PROTECTED) != 0) {
 176                                 if ((mod_flags & Modifiers.INTERNAL) != 0)
 177                                         fa |= FieldAttributes.FamORAssem;
 178                                 else
 179                                         fa |= FieldAttributes.Family;
 180                         } else {
 181                                 if ((mod_flags & Modifiers.INTERNAL) != 0)
 182                                         fa |= FieldAttributes.Assembly;
 183                         }
 184
 185                         if ((mod_flags & Modifiers.STATIC) != 0)
 186                                 fa |= FieldAttributes.Static;
 187                         if ((mod_flags & Modifiers.READONLY) != 0)
 188                                 fa |= FieldAttributes.InitOnly;
 189
 190                         return fa;
 191                 }
 192
 193                 public static MethodAttributes MethodAttr (Modifiers mod_flags)
 194                 {
 195                         MethodAttributes ma = MethodAttributes.HideBySig;
 196
 197                         switch (mod_flags & Modifiers.AccessibilityMask) {
 198                         case Modifiers.PUBLIC:
 199                                 ma |= MethodAttributes.Public;
 200                                 break;
 201                         case Modifiers.PRIVATE:
 202                                 ma |= MethodAttributes.Private;
 203                                 break;
 204                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
 205                                 ma |= MethodAttributes.FamORAssem;
 206                                 break;
 207                         case Modifiers.PROTECTED:
 208                                 ma |= MethodAttributes.Family;
 209                                 break;
 210                         case Modifiers.INTERNAL:
 211                                 ma |= MethodAttributes.Assembly;
 212                                 break;
 213                         default:
 214                                 throw new NotImplementedException (mod_flags.ToString ());
 215                         }
 216
 217                         if ((mod_flags & Modifiers.STATIC) != 0)
 218                                 ma |= MethodAttributes.Static;
 219                         if ((mod_flags & Modifiers.ABSTRACT) != 0) {
 220                                 ma |= MethodAttributes.Abstract | MethodAttributes.Virtual;
 221                         }
 222                         if ((mod_flags & Modifiers.SEALED) != 0)
 223                                 ma |= MethodAttributes.Final;
 224
 225                         if ((mod_flags & Modifiers.VIRTUAL) != 0)
 226                                 ma |= MethodAttributes.Virtual;
 227
 228                         if ((mod_flags & Modifiers.OVERRIDE) != 0) {
 229                                 ma |= MethodAttributes.Virtual;
 230                         } else {
 231                                 if ((ma & MethodAttributes.Virtual) != 0)
 232                                         ma |= MethodAttributes.NewSlot;
 233                         }
 234
 235                         return ma;
 236                 }
 237
 238                 // <summary>
 239                 //   Checks the object @mod modifiers to be in @allowed.
 240                 //   Returns the new mask.  Side effect: reports any
 241                 //   incorrect attributes.
 242                 // </summary>
 243                 public static Modifiers Check (Modifiers allowed, Modifiers mod, Modifiers def_access, Location l, Report Report)
 244                 {
 245                         int invalid_flags = (~(int) allowed) & ((int) mod & ((int) Modifiers.TOP - 1));
 246                         int i;
 247
 248                         if (invalid_flags == 0){
 249                                 //
 250                                 // If no accessibility bits provided
 251                                 // then provide the defaults.
 252                                 //
 253                                 if ((mod & Modifiers.AccessibilityMask) == 0) {
 254                                         mod |= def_access;
 255                                         if (def_access != 0)
 256                                                 mod |= Modifiers.DEFAULT_ACCESS_MODIFER;
 257                                         return mod;
 258                                 }
 259
 260                                 return mod;
 261                         }
 262
 263                         for (i = 1; i <= (int) Modifiers.TOP; i <<= 1) {
 264                                 if ((i & invalid_flags) == 0)
 265                                         continue;
 266
 267                                 Error_InvalidModifier ((Modifiers)i, l, Report);
 268                         }
 269
 270                         return allowed & mod;
 271                 }
 272
 273                 static void Error_InvalidModifier (Modifiers mod, Location l, Report Report)
 274                 {
 275                         Report.Error (106, l, "The modifier `{0}' is not valid for this item",
 276                                 Name (mod));
 277                 }
 278         }
 279 }