PageRenderTime 37ms CodeModel.GetById 14ms app.highlight 14ms RepoModel.GetById 1ms app.codeStats 0ms

/IronPython_Main/Runtime/Microsoft.Scripting.Core/Ast/ExpressionType.cs

#
C# | 377 lines | 95 code | 7 blank | 275 comment | 0 complexity | 381f0b4cbb15739f2dab797f91ed37a6 MD5 | raw file
  1/* ****************************************************************************
  2 *
  3 * Copyright (c) Microsoft Corporation. 
  4 *
  5 * This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
  6 * copy of the license can be found in the License.html file at the root of this distribution. If 
  7 * you cannot locate the  Apache License, Version 2.0, please send an email to 
  8 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
  9 * by the terms of the Apache License, Version 2.0.
 10 *
 11 * You must not remove this notice, or any other, from this software.
 12 *
 13 *
 14 * ***************************************************************************/
 15
 16#if CLR2
 17namespace Microsoft.Scripting.Ast {
 18#else
 19namespace System.Linq.Expressions {
 20#endif
 21
 22    /// <summary>
 23    /// Describes the node types for the nodes of an expression tree.
 24    /// </summary>
 25    public enum ExpressionType {
 26
 27        #region Generated Expression Tree Node Types
 28
 29        // *** BEGIN GENERATED CODE ***
 30        // generated by function: gen_tree_nodes from: generate_tree.py
 31
 32        /// <summary>
 33        /// A node that represents arithmetic addition without overflow checking.
 34        /// </summary>
 35        Add,
 36        /// <summary>
 37        /// A node that represents arithmetic addition with overflow checking.
 38        /// </summary>
 39        AddChecked,
 40        /// <summary>
 41        /// A node that represents a bitwise AND operation.
 42        /// </summary>
 43        And,
 44        /// <summary>
 45        /// A node that represents a short-circuiting conditional AND operation.
 46        /// </summary>
 47        AndAlso,
 48        /// <summary>
 49        /// A node that represents getting the length of a one-dimensional array.
 50        /// </summary>
 51        ArrayLength,
 52        /// <summary>
 53        /// A node that represents indexing into a one-dimensional array.
 54        /// </summary>
 55        ArrayIndex,
 56        /// <summary>
 57        /// A node that represents represents a method call.
 58        /// </summary>
 59        Call,
 60        /// <summary>
 61        /// A node that represents a null coalescing operation.
 62        /// </summary>
 63        Coalesce,
 64        /// <summary>
 65        /// A node that represents a conditional operation.
 66        /// </summary>
 67        Conditional,
 68        /// <summary>
 69        /// A node that represents an expression that has a constant value.
 70        /// </summary>
 71        Constant,
 72        /// <summary>
 73        /// A node that represents a cast or conversion operation. If the operation is a numeric conversion, it overflows silently if the converted value does not fit the target type.
 74        /// </summary>
 75        Convert,
 76        /// <summary>
 77        /// A node that represents a cast or conversion operation. If the operation is a numeric conversion, an exception is thrown if the converted value does not fit the target type.
 78        /// </summary>
 79        ConvertChecked,
 80        /// <summary>
 81        /// A node that represents arithmetic division.
 82        /// </summary>
 83        Divide,
 84        /// <summary>
 85        /// A node that represents an equality comparison.
 86        /// </summary>
 87        Equal,
 88        /// <summary>
 89        /// A node that represents a bitwise XOR operation.
 90        /// </summary>
 91        ExclusiveOr,
 92        /// <summary>
 93        /// A node that represents a "greater than" numeric comparison.
 94        /// </summary>
 95        GreaterThan,
 96        /// <summary>
 97        /// A node that represents a "greater than or equal" numeric comparison.
 98        /// </summary>
 99        GreaterThanOrEqual,
100        /// <summary>
101        /// A node that represents applying a delegate or lambda expression to a list of argument expressions.
102        /// </summary>
103        Invoke,
104        /// <summary>
105        /// A node that represents a lambda expression.
106        /// </summary>
107        Lambda,
108        /// <summary>
109        /// A node that represents a bitwise left-shift operation.
110        /// </summary>
111        LeftShift,
112        /// <summary>
113        /// A node that represents a "less than" numeric comparison.
114        /// </summary>
115        LessThan,
116        /// <summary>
117        /// A node that represents a "less than or equal" numeric comparison.
118        /// </summary>
119        LessThanOrEqual,
120        /// <summary>
121        /// A node that represents creating a new IEnumerable object and initializing it from a list of elements.
122        /// </summary>
123        ListInit,
124        /// <summary>
125        /// A node that represents reading from a field or property.
126        /// </summary>
127        MemberAccess,
128        /// <summary>
129        /// A node that represents creating a new object and initializing one or more of its members.
130        /// </summary>
131        MemberInit,
132        /// <summary>
133        /// A node that represents an arithmetic remainder operation.
134        /// </summary>
135        Modulo,
136        /// <summary>
137        /// A node that represents arithmetic multiplication without overflow checking.
138        /// </summary>
139        Multiply,
140        /// <summary>
141        /// A node that represents arithmetic multiplication with overflow checking.
142        /// </summary>
143        MultiplyChecked,
144        /// <summary>
145        /// A node that represents an arithmetic negation operation.
146        /// </summary>
147        Negate,
148        /// <summary>
149        /// A node that represents a unary plus operation. The result of a predefined unary plus operation is simply the value of the operand, but user-defined implementations may have non-trivial results.
150        /// </summary>
151        UnaryPlus,
152        /// <summary>
153        /// A node that represents an arithmetic negation operation that has overflow checking.
154        /// </summary>
155        NegateChecked,
156        /// <summary>
157        /// A node that represents calling a constructor to create a new object.
158        /// </summary>
159        New,
160        /// <summary>
161        /// A node that represents creating a new one-dimensional array and initializing it from a list of elements.
162        /// </summary>
163        NewArrayInit,
164        /// <summary>
165        /// A node that represents creating a new array where the bounds for each dimension are specified.
166        /// </summary>
167        NewArrayBounds,
168        /// <summary>
169        /// A node that represents a bitwise complement operation.
170        /// </summary>
171        Not,
172        /// <summary>
173        /// A node that represents an inequality comparison.
174        /// </summary>
175        NotEqual,
176        /// <summary>
177        /// A node that represents a bitwise OR operation.
178        /// </summary>
179        Or,
180        /// <summary>
181        /// A node that represents a short-circuiting conditional OR operation.
182        /// </summary>
183        OrElse,
184        /// <summary>
185        /// A node that represents a reference to a parameter or variable defined in the context of the expression.
186        /// </summary>
187        Parameter,
188        /// <summary>
189        /// A node that represents raising a number to a power.
190        /// </summary>
191        Power,
192        /// <summary>
193        /// A node that represents an expression that has a constant value of type Expression. A Quote node can contain references to parameters defined in the context of the expression it represents.
194        /// </summary>
195        Quote,
196        /// <summary>
197        /// A node that represents a bitwise right-shift operation.
198        /// </summary>
199        RightShift,
200        /// <summary>
201        /// A node that represents arithmetic subtraction without overflow checking.
202        /// </summary>
203        Subtract,
204        /// <summary>
205        /// A node that represents arithmetic subtraction with overflow checking.
206        /// </summary>
207        SubtractChecked,
208        /// <summary>
209        /// A node that represents an explicit reference or boxing conversion where null reference (Nothing in Visual Basic) is supplied if the conversion fails.
210        /// </summary>
211        TypeAs,
212        /// <summary>
213        /// A node that represents a type test.
214        /// </summary>
215        TypeIs,
216        /// <summary>
217        /// A node that represents an assignment.
218        /// </summary>
219        Assign,
220        /// <summary>
221        /// A node that represents a block of expressions.
222        /// </summary>
223        Block,
224        /// <summary>
225        /// A node that represents a debugging information.
226        /// </summary>
227        DebugInfo,
228        /// <summary>
229        /// A node that represents a unary decrement.
230        /// </summary>
231        Decrement,
232        /// <summary>
233        /// A node that represents a dynamic operation.
234        /// </summary>
235        Dynamic,
236        /// <summary>
237        /// A node that represents a default value.
238        /// </summary>
239        Default,
240        /// <summary>
241        /// A node that represents an extension expression.
242        /// </summary>
243        Extension,
244        /// <summary>
245        /// A node that represents a goto.
246        /// </summary>
247        Goto,
248        /// <summary>
249        /// A node that represents a unary increment.
250        /// </summary>
251        Increment,
252        /// <summary>
253        /// A node that represents an index operation.
254        /// </summary>
255        Index,
256        /// <summary>
257        /// A node that represents a label.
258        /// </summary>
259        Label,
260        /// <summary>
261        /// A node that represents a list of runtime variables.
262        /// </summary>
263        RuntimeVariables,
264        /// <summary>
265        /// A node that represents a loop.
266        /// </summary>
267        Loop,
268        /// <summary>
269        /// A node that represents a switch operation.
270        /// </summary>
271        Switch,
272        /// <summary>
273        /// A node that represents a throwing of an exception.
274        /// </summary>
275        Throw,
276        /// <summary>
277        /// A node that represents a try-catch expression.
278        /// </summary>
279        Try,
280        /// <summary>
281        /// A node that represents an unbox value type operation.
282        /// </summary>
283        Unbox,
284        /// <summary>
285        /// A node that represents an arithmetic addition compound assignment without overflow checking.
286        /// </summary>
287        AddAssign,
288        /// <summary>
289        /// A node that represents a bitwise AND compound assignment.
290        /// </summary>
291        AndAssign,
292        /// <summary>
293        /// A node that represents an arithmetic division compound assignment .
294        /// </summary>
295        DivideAssign,
296        /// <summary>
297        /// A node that represents a bitwise XOR compound assignment.
298        /// </summary>
299        ExclusiveOrAssign,
300        /// <summary>
301        /// A node that represents a bitwise left-shift compound assignment.
302        /// </summary>
303        LeftShiftAssign,
304        /// <summary>
305        /// A node that represents an arithmetic remainder compound assignment.
306        /// </summary>
307        ModuloAssign,
308        /// <summary>
309        /// A node that represents arithmetic multiplication compound assignment without overflow checking.
310        /// </summary>
311        MultiplyAssign,
312        /// <summary>
313        /// A node that represents a bitwise OR compound assignment.
314        /// </summary>
315        OrAssign,
316        /// <summary>
317        /// A node that represents raising a number to a power compound assignment.
318        /// </summary>
319        PowerAssign,
320        /// <summary>
321        /// A node that represents a bitwise right-shift compound assignment.
322        /// </summary>
323        RightShiftAssign,
324        /// <summary>
325        /// A node that represents arithmetic subtraction compound assignment without overflow checking.
326        /// </summary>
327        SubtractAssign,
328        /// <summary>
329        /// A node that represents an arithmetic addition compound assignment with overflow checking.
330        /// </summary>
331        AddAssignChecked,
332        /// <summary>
333        /// A node that represents arithmetic multiplication compound assignment with overflow checking.
334        /// </summary>
335        MultiplyAssignChecked,
336        /// <summary>
337        /// A node that represents arithmetic subtraction compound assignment with overflow checking.
338        /// </summary>
339        SubtractAssignChecked,
340        /// <summary>
341        /// A node that represents an unary prefix increment.
342        /// </summary>
343        PreIncrementAssign,
344        /// <summary>
345        /// A node that represents an unary prefix decrement.
346        /// </summary>
347        PreDecrementAssign,
348        /// <summary>
349        /// A node that represents an unary postfix increment.
350        /// </summary>
351        PostIncrementAssign,
352        /// <summary>
353        /// A node that represents an unary postfix decrement.
354        /// </summary>
355        PostDecrementAssign,
356        /// <summary>
357        /// A node that represents a exact type test.
358        /// </summary>
359        TypeEqual,
360        /// <summary>
361        /// A node that represents a ones complement.
362        /// </summary>
363        OnesComplement,
364        /// <summary>
365        /// A node that represents a true condition value.
366        /// </summary>
367        IsTrue,
368        /// <summary>
369        /// A node that represents a false condition value.
370        /// </summary>
371        IsFalse,
372
373        // *** END GENERATED CODE ***
374
375        #endregion
376    }
377}