← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric

« back to all changes in this revision

Viewing changes to src/addins/CSharpBinding/MonoDevelop.CSharp.Parser/mcs/modifiers.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2011-06-27 17:03:13 UTC
  • mto: (1.8.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 54.
  • Revision ID: james.westby@ubuntu.com-20110627170313-6cvz3s19x6e9hqe9
Import upstream version 2.5.92+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CSharpBinding/MonoDevelop.CSharp.Parser/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
}