PageRenderTime 63ms CodeModel.GetById 40ms app.highlight 7ms RepoModel.GetById 13ms app.codeStats 0ms

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

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