← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/nrefactory/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:
external/nrefactory/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
}