← Back to branch summary

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

« back to all changes in this revision

Viewing changes to contrib/NRefactory/Project/Src/Ast/Enums.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/NRefactory/Project/Src/Ast/Enums.cs
1
 
// <file>
2
 
//     <copyright see="prj:///doc/copyright.txt"/>
3
 
//     <license see="prj:///doc/license.txt"/>
4
 
//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
5
 
//     <version>$Revision: 4740 $</version>
6
 
// </file>
7
 
 
8
 
using System;
9
 
 
10
 
namespace ICSharpCode.OldNRefactory.Ast
11
 
{
12
 
        [Flags]
13
 
        public enum Modifiers
14
 
        {
15
 
                None      = 0x0000,
16
 
                
17
 
                // Access
18
 
                Private   = 0x0001,
19
 
                /// <summary>C# 'internal', VB 'Friend'</summary>
20
 
                Internal  = 0x0002,
21
 
                Protected = 0x0004,
22
 
                Public    = 0x0008,
23
 
                Dim           = 0x0010, // VB.NET SPECIFIC, for fields/local variables only
24
 
                
25
 
                // Scope
26
 
                Abstract  = 0x0010,  // ==      MustOverride/MustInherit
27
 
                Virtual   = 0x0020,
28
 
                Sealed    = 0x0040,
29
 
                /// <summary>C# 'static', VB 'Shared'</summary>
30
 
                Static    = 0x0080,
31
 
                Override  = 0x0100,
32
 
                /// <summary>For fields: readonly (c# and vb), for properties: get-only (vb)</summary>
33
 
                ReadOnly  = 0x0200,
34
 
                Const     = 0x0400,
35
 
                /// <summary>C# 'new', VB 'Shadows'</summary>
36
 
                New       = 0x0800,
37
 
                Partial   = 0x1000,
38
 
                
39
 
                // Special
40
 
                Extern     = 0x2000,
41
 
                Volatile   = 0x4000,
42
 
                Unsafe     = 0x8000,
43
 
                
44
 
                
45
 
                Overloads  = 0x10000, // VB specific
46
 
                WithEvents = 0x20000, // VB specific
47
 
                Default    = 0x40000, // VB specific
48
 
                Fixed      = 0x80000, // C# specific (fixed size arrays in unsafe structs)
49
 
                
50
 
                ProtectedAndInternal = 0x100000, // C# specific
51
 
                /// <summary>Generated code, not part of parsed code</summary>
52
 
                Synthetic  = 0x200000,
53
 
                /// <summary>Only for VB properties.</summary>
54
 
                WriteOnly  = 0x400000, // VB specific
55
 
                
56
 
                Visibility                                              = Private | Public | Protected | Internal,
57
 
                Classes                                                 = New | Visibility | Abstract | Sealed | Partial | Static,
58
 
                VBModules                                               = Visibility,
59
 
                VBStructures                                    = Visibility | New,
60
 
                VBEnums                                             = Visibility | New,
61
 
                VBInterfacs                                         = Visibility | New,
62
 
                VBDelegates                                         = Visibility | New,
63
 
                VBMethods                                               = Visibility | New | Static | Virtual | Sealed | Abstract | Override | Overloads,
64
 
                VBExternalMethods                               = Visibility | New | Overloads,
65
 
                VBEvents                                                = Visibility | New | Overloads,
66
 
                VBProperties                                    = VBMethods | Default | ReadOnly | WriteOnly,
67
 
                VBCustomEvents                                  = Visibility | New | Overloads,
68
 
                VBOperators                                             = Public | Static | Overloads | New,
69
 
                
70
 
                
71
 
                // this is not documented in the spec
72
 
                VBInterfaceEvents                               = New,
73
 
                VBInterfaceMethods                              = New | Overloads,
74
 
                VBInterfaceProperties                   = New | Overloads | ReadOnly | WriteOnly | Default,
75
 
                VBInterfaceEnums                                = New,
76
 
                
77
 
                Fields                          = New | Visibility | Static   | ReadOnly | Volatile | Fixed,
78
 
                PropertysEventsMethods          = New | Visibility | Static   | Virtual  | Sealed   | Override | Abstract | Extern,
79
 
                Indexers                        = New | Visibility | Virtual  | Sealed   | Override | Abstract | Extern,
80
 
                Operators                       = Public | Static | Extern,
81
 
                Constants                       = New | Visibility,
82
 
                StructsInterfacesEnumsDelegates = New | Visibility | Partial,
83
 
                StaticConstructors              = Extern | Static | Unsafe,
84
 
                Destructors                     = Extern | Unsafe,
85
 
                Constructors                    = Visibility | Extern,
86
 
        }
87
 
        
88
 
        public enum ClassType
89
 
        {
90
 
                Class,
91
 
                Module,
92
 
                Interface,
93
 
                Struct,
94
 
                Enum
95
 
        }
96
 
        
97
 
        public enum ParentType
98
 
        {
99
 
                ClassOrStruct,
100
 
                InterfaceOrEnum,
101
 
                Namespace,
102
 
                Unknown
103
 
        }
104
 
        
105
 
        public enum FieldDirection
106
 
        {
107
 
                None,
108
 
                In,
109
 
                Out,
110
 
                Ref
111
 
        }
112
 
        
113
 
        [Flags]
114
 
        public enum ParameterModifiers
115
 
        {
116
 
                // Values must be the same as in SharpDevelop's ParameterModifiers
117
 
                None = 0,
118
 
                In  = 1,
119
 
                Out = 2,
120
 
                Ref = 4,
121
 
                Params = 8,
122
 
                Optional = 16
123
 
        }
124
 
        
125
 
        public enum AssignmentOperatorType
126
 
        {
127
 
                None,
128
 
                Assign,
129
 
                
130
 
                Add,
131
 
                Subtract,
132
 
                Multiply,
133
 
                Divide,
134
 
                Modulus,
135
 
                
136
 
                Power,         // (VB only)
137
 
                DivideInteger, // (VB only)
138
 
                ConcatString,  // (VB only)
139
 
                
140
 
                ShiftLeft,
141
 
                ShiftRight,
142
 
                
143
 
                BitwiseAnd,
144
 
                BitwiseOr,
145
 
                ExclusiveOr,
146
 
        }
147
 
        
148
 
        public enum BinaryOperatorType
149
 
        {
150
 
                None,
151
 
                
152
 
                /// <summary>'&amp;' in C#, 'And' in VB.</summary>
153
 
                BitwiseAnd,
154
 
                /// <summary>'|' in C#, 'Or' in VB.</summary>
155
 
                BitwiseOr,
156
 
                /// <summary>'&amp;&amp;' in C#, 'AndAlso' in VB.</summary>
157
 
                LogicalAnd,
158
 
                /// <summary>'||' in C#, 'OrElse' in VB.</summary>
159
 
                LogicalOr,
160
 
                /// <summary>'^' in C#, 'Xor' in VB.</summary>
161
 
                ExclusiveOr,
162
 
                
163
 
                /// <summary>&gt;</summary>
164
 
                GreaterThan,
165
 
                /// <summary>&gt;=</summary>
166
 
                GreaterThanOrEqual,
167
 
                /// <summary>'==' in C#, '=' in VB.</summary>
168
 
                Equality,
169
 
                /// <summary>'!=' in C#, '&lt;&gt;' in VB.</summary>
170
 
                InEquality,
171
 
                /// <summary>&lt;</summary>
172
 
                LessThan,
173
 
                /// <summary>&lt;=</summary>
174
 
                LessThanOrEqual,
175
 
                
176
 
                /// <summary>+</summary>
177
 
                Add,
178
 
                /// <summary>-</summary>
179
 
                Subtract,
180
 
                /// <summary>*</summary>
181
 
                Multiply,
182
 
                /// <summary>/</summary>
183
 
                Divide,
184
 
                /// <summary>'%' in C#, 'Mod' in VB.</summary>
185
 
                Modulus,
186
 
                /// <summary>VB-only: \</summary>
187
 
                DivideInteger,
188
 
                /// <summary>VB-only: ^</summary>
189
 
                Power,
190
 
                /// <summary>VB-only: &amp;</summary>
191
 
                Concat,
192
 
                
193
 
                /// <summary>C#: &lt;&lt;</summary>
194
 
                ShiftLeft,
195
 
                /// <summary>C#: &gt;&gt;</summary>
196
 
                ShiftRight,
197
 
                /// <summary>VB-only: Is</summary>
198
 
                ReferenceEquality,
199
 
                /// <summary>VB-only: IsNot</summary>
200
 
                ReferenceInequality,
201
 
                
202
 
                /// <summary>VB-only: Like</summary>
203
 
                Like,
204
 
                /// <summary>
205
 
                ///     C#: ??
206
 
                ///     VB: IF(x, y)
207
 
                /// </summary>
208
 
                NullCoalescing,
209
 
                
210
 
                /// <summary>VB-only: !</summary>
211
 
                DictionaryAccess
212
 
        }
213
 
        
214
 
        public enum CastType
215
 
        {
216
 
                /// <summary>
217
 
                /// direct cast (C#, VB "DirectCast")
218
 
                /// </summary>
219
 
                Cast,
220
 
                /// <summary>
221
 
                /// try cast (C# "as", VB "TryCast")
222
 
                /// </summary>
223
 
                TryCast,
224
 
                /// <summary>
225
 
                /// converting cast (VB "CType")
226
 
                /// </summary>
227
 
                Conversion,
228
 
                /// <summary>
229
 
                /// primitive converting cast (VB "CString" etc.)
230
 
                /// </summary>
231
 
                PrimitiveConversion
232
 
        }
233
 
        
234
 
        public enum UnaryOperatorType
235
 
        {
236
 
                None,
237
 
                Not,
238
 
                BitNot,
239
 
                
240
 
                Minus,
241
 
                Plus,
242
 
                
243
 
                Increment,
244
 
                Decrement,
245
 
                
246
 
                PostIncrement,
247
 
                PostDecrement,
248
 
                
249
 
                /// <summary>Dereferencing pointer</summary>
250
 
                Dereference,
251
 
                /// <summary>Get address of</summary>
252
 
                AddressOf
253
 
        }
254
 
        
255
 
        public enum ContinueType
256
 
        {
257
 
                None,
258
 
                Do,
259
 
                For,
260
 
                While
261
 
        }
262
 
        
263
 
        public enum ConditionType
264
 
        {
265
 
                None,
266
 
                Until,
267
 
                While,
268
 
                DoWhile
269
 
        }
270
 
        
271
 
        public enum ConditionPosition
272
 
        {
273
 
                None,
274
 
                Start,
275
 
                End
276
 
        }
277
 
        
278
 
        public enum ExitType
279
 
        {
280
 
                None,
281
 
                Sub,
282
 
                Function,
283
 
                Property,
284
 
                Do,
285
 
                For,
286
 
                While,
287
 
                Select,
288
 
                Try
289
 
        }
290
 
        
291
 
        public enum ConstructorInitializerType
292
 
        {
293
 
                None,
294
 
                Base,
295
 
                This
296
 
        }
297
 
        
298
 
        public enum ConversionType
299
 
        {
300
 
                None,
301
 
                Implicit,
302
 
                Explicit
303
 
        }
304
 
        
305
 
        public enum OverloadableOperatorType
306
 
        {
307
 
                None,
308
 
                
309
 
                Add,
310
 
                Subtract,
311
 
                Multiply,
312
 
                Divide,
313
 
                Modulus,
314
 
                Concat,
315
 
                
316
 
                UnaryPlus,
317
 
                UnaryMinus,
318
 
                
319
 
                Not,
320
 
                BitNot,
321
 
                
322
 
                BitwiseAnd,
323
 
                BitwiseOr,
324
 
                ExclusiveOr,
325
 
                
326
 
                ShiftLeft,
327
 
                ShiftRight,
328
 
                
329
 
                GreaterThan,
330
 
                GreaterThanOrEqual,
331
 
                Equality,
332
 
                InEquality,
333
 
                LessThan,
334
 
                LessThanOrEqual,
335
 
                
336
 
                Increment,
337
 
                Decrement,
338
 
                
339
 
                IsTrue,
340
 
                IsFalse,
341
 
                
342
 
                // VB specific
343
 
                Like,
344
 
                Power,
345
 
                CType,
346
 
                DivideInteger
347
 
        }
348
 
        
349
 
        ///<summary>
350
 
        /// Charset types, used in external methods
351
 
        /// declarations (VB only).
352
 
        ///</summary>
353
 
        public enum CharsetModifier
354
 
        {
355
 
                None,
356
 
                Auto,
357
 
                Unicode,
358
 
                Ansi
359
 
        }
360
 
        
361
 
        ///<summary>
362
 
        /// Compare type, used in the <c>Option Compare</c>
363
 
        /// pragma (VB only).
364
 
        ///</summary>
365
 
        public enum OptionType
366
 
        {
367
 
                None,
368
 
                Explicit,
369
 
                Strict,
370
 
                CompareBinary,
371
 
                CompareText,
372
 
                Infer
373
 
        }
374
 
        
375
 
        /// <summary>
376
 
        /// Specifies the ordering direction of a QueryExpressionOrdering node.
377
 
        /// </summary>
378
 
        public enum QueryExpressionOrderingDirection
379
 
        {
380
 
                None,
381
 
                Ascending,
382
 
                Descending
383
 
        }
384
 
        
385
 
        /// <summary>
386
 
        /// Specifies the partition type for a VB.NET
387
 
        /// query expression.
388
 
        /// </summary>
389
 
        public enum QueryExpressionPartitionType
390
 
        {
391
 
                Take,
392
 
                TakeWhile,
393
 
                Skip,
394
 
                SkipWhile
395
 
        }
396
 
}