← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/modifiers.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory.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
 
                ASYNC     = 0x4000,
41
 
                TOP       = 0x8000,
42
 
 
43
 
                //
44
 
                // Compiler specific flags
45
 
                //
46
 
                PROPERTY_CUSTOM                 = 0x10000,
47
 
 
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
 
                        case Modifiers.ASYNC:
113
 
                                s = "async"; break;
114
 
                        }
115
 
 
116
 
                        return s;
117
 
                }
118
 
 
119
 
                //
120
 
                // Used by custom property accessors to check whether @modA is more restrictive than @modB
121
 
                //
122
 
                public static bool IsRestrictedModifier (Modifiers modA, Modifiers modB)
123
 
                {
124
 
                        Modifiers flags = 0;
125
 
 
126
 
                        if ((modB & Modifiers.PUBLIC) != 0) {
127
 
                                flags = Modifiers.PROTECTED | Modifiers.INTERNAL | Modifiers.PRIVATE;
128
 
                        } else if ((modB & Modifiers.PROTECTED) != 0) {
129
 
                                if ((modB & Modifiers.INTERNAL) != 0)
130
 
                                        flags = Modifiers.PROTECTED | Modifiers.INTERNAL;
131
 
 
132
 
                                flags |= Modifiers.PRIVATE;
133
 
                        } else if ((modB & Modifiers.INTERNAL) != 0)
134
 
                                flags = Modifiers.PRIVATE;
135
 
 
136
 
                        return modB != modA && (modA & (~flags)) == 0;
137
 
                }
138
 
 
139
 
                public static TypeAttributes TypeAttr (Modifiers mod_flags, bool is_toplevel)
140
 
                {
141
 
                        TypeAttributes t = 0;
142
 
 
143
 
                        if (is_toplevel){
144
 
                                if ((mod_flags & Modifiers.PUBLIC) != 0)
145
 
                                        t = TypeAttributes.Public;
146
 
                                else if ((mod_flags & Modifiers.PRIVATE) != 0)
147
 
                                        t = TypeAttributes.NotPublic;
148
 
                        } else {
149
 
                                if ((mod_flags & Modifiers.PUBLIC) != 0)
150
 
                                        t = TypeAttributes.NestedPublic;
151
 
                                else if ((mod_flags & Modifiers.PRIVATE) != 0)
152
 
                                        t = TypeAttributes.NestedPrivate;
153
 
                                else if ((mod_flags & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL))
154
 
                                        t = TypeAttributes.NestedFamORAssem;
155
 
                                else if ((mod_flags & Modifiers.PROTECTED) != 0)
156
 
                                        t = TypeAttributes.NestedFamily;
157
 
                                else if ((mod_flags & Modifiers.INTERNAL) != 0)
158
 
                                        t = TypeAttributes.NestedAssembly;
159
 
                        }
160
 
 
161
 
                        if ((mod_flags & Modifiers.SEALED) != 0)
162
 
                                t |= TypeAttributes.Sealed;
163
 
                        if ((mod_flags & Modifiers.ABSTRACT) != 0)
164
 
                                t |= TypeAttributes.Abstract;
165
 
 
166
 
                        return t;
167
 
                }
168
 
 
169
 
                public static FieldAttributes FieldAttr (Modifiers mod_flags)
170
 
                {
171
 
                        FieldAttributes fa = 0;
172
 
 
173
 
                        if ((mod_flags & Modifiers.PUBLIC) != 0)
174
 
                                fa |= FieldAttributes.Public;
175
 
                        if ((mod_flags & Modifiers.PRIVATE) != 0)
176
 
                                fa |= FieldAttributes.Private;
177
 
                        if ((mod_flags & Modifiers.PROTECTED) != 0) {
178
 
                                if ((mod_flags & Modifiers.INTERNAL) != 0)
179
 
                                        fa |= FieldAttributes.FamORAssem;
180
 
                                else 
181
 
                                        fa |= FieldAttributes.Family;
182
 
                        } else {
183
 
                                if ((mod_flags & Modifiers.INTERNAL) != 0)
184
 
                                        fa |= FieldAttributes.Assembly;
185
 
                        }
186
 
 
187
 
                        if ((mod_flags & Modifiers.STATIC) != 0)
188
 
                                fa |= FieldAttributes.Static;
189
 
                        if ((mod_flags & Modifiers.READONLY) != 0)
190
 
                                fa |= FieldAttributes.InitOnly;
191
 
 
192
 
                        return fa;
193
 
                }
194
 
 
195
 
                public static MethodAttributes MethodAttr (Modifiers mod_flags)
196
 
                {
197
 
                        MethodAttributes ma = MethodAttributes.HideBySig;
198
 
 
199
 
                        switch (mod_flags & Modifiers.AccessibilityMask) {
200
 
                        case Modifiers.PUBLIC:
201
 
                                ma |= MethodAttributes.Public;
202
 
                                break;
203
 
                        case Modifiers.PRIVATE:
204
 
                                ma |= MethodAttributes.Private;
205
 
                                break;
206
 
                        case Modifiers.PROTECTED | Modifiers.INTERNAL:
207
 
                                ma |= MethodAttributes.FamORAssem;
208
 
                                break;
209
 
                        case Modifiers.PROTECTED:
210
 
                                ma |= MethodAttributes.Family;
211
 
                                break;
212
 
                        case Modifiers.INTERNAL:
213
 
                                ma |= MethodAttributes.Assembly;
214
 
                                break;
215
 
                        default:
216
 
                                throw new NotImplementedException (mod_flags.ToString ());
217
 
                        }
218
 
 
219
 
                        if ((mod_flags & Modifiers.STATIC) != 0)
220
 
                                ma |= MethodAttributes.Static;
221
 
                        if ((mod_flags & Modifiers.ABSTRACT) != 0) {
222
 
                                ma |= MethodAttributes.Abstract | MethodAttributes.Virtual;
223
 
                        }
224
 
                        if ((mod_flags & Modifiers.SEALED) != 0)
225
 
                                ma |= MethodAttributes.Final;
226
 
 
227
 
                        if ((mod_flags & Modifiers.VIRTUAL) != 0)
228
 
                                ma |= MethodAttributes.Virtual;
229
 
 
230
 
                        if ((mod_flags & Modifiers.OVERRIDE) != 0) {
231
 
                                ma |= MethodAttributes.Virtual;
232
 
                        } else {
233
 
                                if ((ma & MethodAttributes.Virtual) != 0)
234
 
                                        ma |= MethodAttributes.NewSlot;
235
 
                        }
236
 
                        
237
 
                        return ma;
238
 
                }
239
 
 
240
 
                // <summary>
241
 
                //   Checks the object @mod modifiers to be in @allowed.
242
 
                //   Returns the new mask.  Side effect: reports any
243
 
                //   incorrect attributes. 
244
 
                // </summary>
245
 
                public static Modifiers Check (Modifiers allowed, Modifiers mod, Modifiers def_access, Location l, Report Report)
246
 
                {
247
 
                        int invalid_flags = (~(int) allowed) & ((int) mod & ((int) Modifiers.TOP - 1));
248
 
                        int i;
249
 
 
250
 
                        if (invalid_flags == 0){
251
 
                                //
252
 
                                // If no accessibility bits provided
253
 
                                // then provide the defaults.
254
 
                                //
255
 
                                if ((mod & Modifiers.AccessibilityMask) == 0) {
256
 
                                        mod |= def_access;
257
 
                                        if (def_access != 0)
258
 
                                                mod |= Modifiers.DEFAULT_ACCESS_MODIFER;
259
 
                                        return mod;
260
 
                                }
261
 
 
262
 
                                return mod;
263
 
                        }
264
 
 
265
 
                        for (i = 1; i <= (int) Modifiers.TOP; i <<= 1) {
266
 
                                if ((i & invalid_flags) == 0)
267
 
                                        continue;
268
 
 
269
 
                                Error_InvalidModifier ((Modifiers)i, l, Report);
270
 
                        }
271
 
 
272
 
                        return allowed & mod;
273
 
                }
274
 
 
275
 
                static void Error_InvalidModifier (Modifiers mod, Location l, Report Report)
276
 
                {
277
 
                        Report.Error (106, l, "The modifier `{0}' is not valid for this item",
278
 
                                Name (mod));
279
 
                }
280
 
        }
281
 
}