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                 ASYNC     = 0x4000,
  41                 TOP       = 0x8000,
  42
  43                 //
  44                 // Compiler specific flags
  45                 //
  46                 PROPERTY_CUSTOM                 = 0x10000,
  47
  48                 PARTIAL                                 = 0x20000,
  49                 DEFAULT_ACCESS_MODIFIER = 0x40000,
  50                 METHOD_EXTENSION                = 0x80000,
  51                 COMPILER_GENERATED              = 0x100000,
  52                 BACKING_FIELD                   = 0x200000,
  53                 DEBUGGER_HIDDEN                 = 0x400000,
  54                 DEBUGGER_STEP_THROUGH   = 0x800000,
  55                 AutoProperty                    = 0x1000000,
  56
  57                 AccessibilityMask = PUBLIC | PROTECTED | INTERNAL | PRIVATE,
  58                 AllowedExplicitImplFlags = UNSAFE | EXTERN,
  59         }
  60
  61         static class ModifiersExtensions
  62         {
  63                 public static string AccessibilityName (Modifiers mod)
  64                 {
  65                         switch (mod & Modifiers.AccessibilityMask) {
  66                         case Modifiers.PUBLIC:
  67                                 return "public";
  68                         case Modifiers.PROTECTED:
  69                                 return "protected";
  70                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
  71                                 return "protected internal";
  72                         case Modifiers.INTERNAL:
  73                                 return "internal";
  74                         case Modifiers.PRIVATE:
  75                                 return "private";
  76                         default:
  77                                 throw new NotImplementedException (mod.ToString ());
  78                         }
  79                 }
  80
  81                 static public string Name (Modifiers i)
  82                 {
  83                         string s = "";
  84
  85                         switch (i) {
  86                         case Modifiers.NEW:
  87                                 s = "new"; break;
  88                         case Modifiers.PUBLIC:
  89                                 s = "public"; break;
  90                         case Modifiers.PROTECTED:
  91                                 s = "protected"; break;
  92                         case Modifiers.INTERNAL:
  93                                 s = "internal"; break;
  94                         case Modifiers.PRIVATE:
  95                                 s = "private"; break;
  96                         case Modifiers.ABSTRACT:
  97                                 s = "abstract"; break;
  98                         case Modifiers.SEALED:
  99                                 s = "sealed"; break;
 100                         case Modifiers.STATIC:
 101                                 s = "static"; break;
 102                         case Modifiers.READONLY:
 103                                 s = "readonly"; break;
 104                         case Modifiers.VIRTUAL:
 105                                 s = "virtual"; break;
 106                         case Modifiers.OVERRIDE:
 107                                 s = "override"; break;
 108                         case Modifiers.EXTERN:
 109                                 s = "extern"; break;
 110                         case Modifiers.VOLATILE:
 111                                 s = "volatile"; break;
 112                         case Modifiers.UNSAFE:
 113                                 s = "unsafe"; break;
 114                         case Modifiers.ASYNC:
 115                                 s = "async"; break;
 116                         }
 117
 118                         return s;
 119                 }
 120
 121                 //
 122                 // Used by custom property accessors to check whether @modA is more restrictive than @modB
 123                 //
 124                 public static bool IsRestrictedModifier (Modifiers modA, Modifiers modB)
 125                 {
 126                         Modifiers flags = 0;
 127
 128                         if ((modB & Modifiers.PUBLIC) != 0) {
 129                                 flags = Modifiers.PROTECTED | Modifiers.INTERNAL | Modifiers.PRIVATE;
 130                         } else if ((modB & Modifiers.PROTECTED) != 0) {
 131                                 if ((modB & Modifiers.INTERNAL) != 0)
 132                                         flags = Modifiers.PROTECTED | Modifiers.INTERNAL;
 133
 134                                 flags |= Modifiers.PRIVATE;
 135                         } else if ((modB & Modifiers.INTERNAL) != 0)
 136                                 flags = Modifiers.PRIVATE;
 137
 138                         return modB != modA && (modA & (~flags)) == 0;
 139                 }
 140
 141                 public static TypeAttributes TypeAttr (Modifiers mod_flags, bool is_toplevel)
 142                 {
 143                         TypeAttributes t = 0;
 144
 145                         if (is_toplevel){
 146                                 if ((mod_flags & Modifiers.PUBLIC) != 0)
 147                                         t = TypeAttributes.Public;
 148                                 else if ((mod_flags & Modifiers.PRIVATE) != 0)
 149                                         t = TypeAttributes.NotPublic;
 150                         } else {
 151                                 if ((mod_flags & Modifiers.PUBLIC) != 0)
 152                                         t = TypeAttributes.NestedPublic;
 153                                 else if ((mod_flags & Modifiers.PRIVATE) != 0)
 154                                         t = TypeAttributes.NestedPrivate;
 155                                 else if ((mod_flags & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL))
 156                                         t = TypeAttributes.NestedFamORAssem;
 157                                 else if ((mod_flags & Modifiers.PROTECTED) != 0)
 158                                         t = TypeAttributes.NestedFamily;
 159                                 else if ((mod_flags & Modifiers.INTERNAL) != 0)
 160                                         t = TypeAttributes.NestedAssembly;
 161                         }
 162
 163                         if ((mod_flags & Modifiers.SEALED) != 0)
 164                                 t |= TypeAttributes.Sealed;
 165                         if ((mod_flags & Modifiers.ABSTRACT) != 0)
 166                                 t |= TypeAttributes.Abstract;
 167
 168                         return t;
 169                 }
 170
 171                 public static FieldAttributes FieldAttr (Modifiers mod_flags)
 172                 {
 173                         FieldAttributes fa = 0;
 174
 175                         if ((mod_flags & Modifiers.PUBLIC) != 0)
 176                                 fa |= FieldAttributes.Public;
 177                         if ((mod_flags & Modifiers.PRIVATE) != 0)
 178                                 fa |= FieldAttributes.Private;
 179                         if ((mod_flags & Modifiers.PROTECTED) != 0) {
 180                                 if ((mod_flags & Modifiers.INTERNAL) != 0)
 181                                         fa |= FieldAttributes.FamORAssem;
 182                                 else
 183                                         fa |= FieldAttributes.Family;
 184                         } else {
 185                                 if ((mod_flags & Modifiers.INTERNAL) != 0)
 186                                         fa |= FieldAttributes.Assembly;
 187                         }
 188
 189                         if ((mod_flags & Modifiers.STATIC) != 0)
 190                                 fa |= FieldAttributes.Static;
 191                         if ((mod_flags & Modifiers.READONLY) != 0)
 192                                 fa |= FieldAttributes.InitOnly;
 193
 194                         return fa;
 195                 }
 196
 197                 public static MethodAttributes MethodAttr (Modifiers mod_flags)
 198                 {
 199                         MethodAttributes ma = MethodAttributes.HideBySig;
 200
 201                         switch (mod_flags & Modifiers.AccessibilityMask) {
 202                         case Modifiers.PUBLIC:
 203                                 ma |= MethodAttributes.Public;
 204                                 break;
 205                         case Modifiers.PRIVATE:
 206                                 ma |= MethodAttributes.Private;
 207                                 break;
 208                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
 209                                 ma |= MethodAttributes.FamORAssem;
 210                                 break;
 211                         case Modifiers.PROTECTED:
 212                                 ma |= MethodAttributes.Family;
 213                                 break;
 214                         case Modifiers.INTERNAL:
 215                                 ma |= MethodAttributes.Assembly;
 216                                 break;
 217                         default:
 218                                 throw new NotImplementedException (mod_flags.ToString ());
 219                         }
 220
 221                         if ((mod_flags & Modifiers.STATIC) != 0)
 222                                 ma |= MethodAttributes.Static;
 223                         if ((mod_flags & Modifiers.ABSTRACT) != 0) {
 224                                 ma |= MethodAttributes.Abstract | MethodAttributes.Virtual;
 225                         }
 226                         if ((mod_flags & Modifiers.SEALED) != 0)
 227                                 ma |= MethodAttributes.Final;
 228
 229                         if ((mod_flags & Modifiers.VIRTUAL) != 0)
 230                                 ma |= MethodAttributes.Virtual;
 231
 232                         if ((mod_flags & Modifiers.OVERRIDE) != 0) {
 233                                 ma |= MethodAttributes.Virtual;
 234                         } else {
 235                                 if ((ma & MethodAttributes.Virtual) != 0)
 236                                         ma |= MethodAttributes.NewSlot;
 237                         }
 238
 239                         return ma;
 240                 }
 241
 242                 // <summary>
 243                 //   Checks the object @mod modifiers to be in @allowed.
 244                 //   Returns the new mask.  Side effect: reports any
 245                 //   incorrect attributes.
 246                 // </summary>
 247                 public static Modifiers Check (Modifiers allowed, Modifiers mod, Modifiers def_access, Location l, Report Report)
 248                 {
 249                         int invalid_flags = (~(int) allowed) & ((int) mod & ((int) Modifiers.TOP - 1));
 250                         int i;
 251
 252                         if (invalid_flags == 0){
 253                                 //
 254                                 // If no accessibility bits provided
 255                                 // then provide the defaults.
 256                                 //
 257                                 if ((mod & Modifiers.AccessibilityMask) == 0) {
 258                                         mod |= def_access;
 259                                         if (def_access != 0)
 260                                                 mod |= Modifiers.DEFAULT_ACCESS_MODIFIER;
 261                                         return mod;
 262                                 }
 263
 264                                 return mod;
 265                         }
 266
 267                         for (i = 1; i < (int) Modifiers.TOP; i <<= 1) {
 268                                 if ((i & invalid_flags) == 0)
 269                                         continue;
 270
 271                                 Error_InvalidModifier ((Modifiers)i, l, Report);
 272                         }
 273
 274                         return allowed & mod;
 275                 }
 276
 277                 static void Error_InvalidModifier (Modifiers mod, Location l, Report Report)
 278                 {
 279                         Report.Error (106, l, "The modifier `{0}' is not valid for this item",
 280                                 Name (mod));
 281                 }
 282         }
 283 }