mcs/class/dlr/Runtime/Microsoft.Scripting.Core/Compiler/LambdaCompiler.Generated.cs

   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  * ***************************************************************************/
  15 using System; using Microsoft;
  16
  17
  18 using System.Diagnostics;
  19 #if CODEPLEX_40
  20 using System.Dynamic.Utils;
  21 #else
  22 using Microsoft.Scripting.Utils;
  23 #endif
  24
  25 #if CODEPLEX_40
  26 namespace System.Linq.Expressions.Compiler {
  27 #else
  28 namespace Microsoft.Linq.Expressions.Compiler {
  29 #endif
  30     partial class LambdaCompiler {
  31
  32         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1505:AvoidUnmaintainableCode"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
  33         private void EmitExpression(Expression node, CompilationFlags flags) {
  34             Debug.Assert(node != null);
  35
  36             bool emitStart = (flags & CompilationFlags.EmitExpressionStartMask) == CompilationFlags.EmitExpressionStart;
  37
  38             CompilationFlags startEmitted = emitStart ? EmitExpressionStart(node) : CompilationFlags.EmitNoExpressionStart;
  39             // only pass tail call flags to emit the expression
  40             flags = flags & CompilationFlags.EmitAsTailCallMask;
  41
  42             switch (node.NodeType) {
  43                 #region Generated Expression Compiler
  44
  45                 // *** BEGIN GENERATED CODE ***
  46                 // generated by function: gen_compiler from: generate_tree.py
  47
  48                 case ExpressionType.Add:
  49                     EmitBinaryExpression(node, flags);
  50                     break;
  51                 case ExpressionType.AddChecked:
  52                     EmitBinaryExpression(node, flags);
  53                     break;
  54                 case ExpressionType.And:
  55                     EmitBinaryExpression(node, flags);
  56                     break;
  57                 case ExpressionType.AndAlso:
  58                     EmitAndAlsoBinaryExpression(node, flags);
  59                     break;
  60                 case ExpressionType.ArrayLength:
  61                     EmitUnaryExpression(node, flags);
  62                     break;
  63                 case ExpressionType.ArrayIndex:
  64                     EmitBinaryExpression(node, flags);
  65                     break;
  66                 case ExpressionType.Call:
  67                     EmitMethodCallExpression(node, flags);
  68                     break;
  69                 case ExpressionType.Coalesce:
  70                     EmitCoalesceBinaryExpression(node);
  71                     break;
  72                 case ExpressionType.Conditional:
  73                     EmitConditionalExpression(node, flags);
  74                     break;
  75                 case ExpressionType.Constant:
  76                     EmitConstantExpression(node);
  77                     break;
  78                 case ExpressionType.Convert:
  79                     EmitConvertUnaryExpression(node, flags);
  80                     break;
  81                 case ExpressionType.ConvertChecked:
  82                     EmitConvertUnaryExpression(node, flags);
  83                     break;
  84                 case ExpressionType.Divide:
  85                     EmitBinaryExpression(node, flags);
  86                     break;
  87                 case ExpressionType.Equal:
  88                     EmitBinaryExpression(node, flags);
  89                     break;
  90                 case ExpressionType.ExclusiveOr:
  91                     EmitBinaryExpression(node, flags);
  92                     break;
  93                 case ExpressionType.GreaterThan:
  94                     EmitBinaryExpression(node, flags);
  95                     break;
  96                 case ExpressionType.GreaterThanOrEqual:
  97                     EmitBinaryExpression(node, flags);
  98                     break;
  99                 case ExpressionType.Invoke:
 100                     EmitInvocationExpression(node, flags);
 101                     break;
 102                 case ExpressionType.Lambda:
 103                     EmitLambdaExpression(node);
 104                     break;
 105                 case ExpressionType.LeftShift:
 106                     EmitBinaryExpression(node, flags);
 107                     break;
 108                 case ExpressionType.LessThan:
 109                     EmitBinaryExpression(node, flags);
 110                     break;
 111                 case ExpressionType.LessThanOrEqual:
 112                     EmitBinaryExpression(node, flags);
 113                     break;
 114                 case ExpressionType.ListInit:
 115                     EmitListInitExpression(node);
 116                     break;
 117                 case ExpressionType.MemberAccess:
 118                     EmitMemberExpression(node);
 119                     break;
 120                 case ExpressionType.MemberInit:
 121                     EmitMemberInitExpression(node);
 122                     break;
 123                 case ExpressionType.Modulo:
 124                     EmitBinaryExpression(node, flags);
 125                     break;
 126                 case ExpressionType.Multiply:
 127                     EmitBinaryExpression(node, flags);
 128                     break;
 129                 case ExpressionType.MultiplyChecked:
 130                     EmitBinaryExpression(node, flags);
 131                     break;
 132                 case ExpressionType.Negate:
 133                     EmitUnaryExpression(node, flags);
 134                     break;
 135                 case ExpressionType.UnaryPlus:
 136                     EmitUnaryExpression(node, flags);
 137                     break;
 138                 case ExpressionType.NegateChecked:
 139                     EmitUnaryExpression(node, flags);
 140                     break;
 141                 case ExpressionType.New:
 142                     EmitNewExpression(node);
 143                     break;
 144                 case ExpressionType.NewArrayInit:
 145                     EmitNewArrayExpression(node);
 146                     break;
 147                 case ExpressionType.NewArrayBounds:
 148                     EmitNewArrayExpression(node);
 149                     break;
 150                 case ExpressionType.Not:
 151                     EmitUnaryExpression(node, flags);
 152                     break;
 153                 case ExpressionType.NotEqual:
 154                     EmitBinaryExpression(node, flags);
 155                     break;
 156                 case ExpressionType.Or:
 157                     EmitBinaryExpression(node, flags);
 158                     break;
 159                 case ExpressionType.OrElse:
 160                     EmitOrElseBinaryExpression(node, flags);
 161                     break;
 162                 case ExpressionType.Parameter:
 163                     EmitParameterExpression(node);
 164                     break;
 165                 case ExpressionType.Power:
 166                     EmitBinaryExpression(node, flags);
 167                     break;
 168                 case ExpressionType.Quote:
 169                     EmitQuoteUnaryExpression(node);
 170                     break;
 171                 case ExpressionType.RightShift:
 172                     EmitBinaryExpression(node, flags);
 173                     break;
 174                 case ExpressionType.Subtract:
 175                     EmitBinaryExpression(node, flags);
 176                     break;
 177                 case ExpressionType.SubtractChecked:
 178                     EmitBinaryExpression(node, flags);
 179                     break;
 180                 case ExpressionType.TypeAs:
 181                     EmitUnaryExpression(node, flags);
 182                     break;
 183                 case ExpressionType.TypeIs:
 184                     EmitTypeBinaryExpression(node);
 185                     break;
 186                 case ExpressionType.Assign:
 187                     EmitAssignBinaryExpression(node);
 188                     break;
 189                 case ExpressionType.Block:
 190                     EmitBlockExpression(node, flags);
 191                     break;
 192                 case ExpressionType.DebugInfo:
 193                     EmitDebugInfoExpression(node);
 194                     break;
 195                 case ExpressionType.Decrement:
 196                     EmitUnaryExpression(node, flags);
 197                     break;
 198                 case ExpressionType.Dynamic:
 199                     EmitDynamicExpression(node);
 200                     break;
 201                 case ExpressionType.Default:
 202                     EmitDefaultExpression(node);
 203                     break;
 204                 case ExpressionType.Extension:
 205                     EmitExtensionExpression(node);
 206                     break;
 207                 case ExpressionType.Goto:
 208                     EmitGotoExpression(node, flags);
 209                     break;
 210                 case ExpressionType.Increment:
 211                     EmitUnaryExpression(node, flags);
 212                     break;
 213                 case ExpressionType.Index:
 214                     EmitIndexExpression(node);
 215                     break;
 216                 case ExpressionType.Label:
 217                     EmitLabelExpression(node, flags);
 218                     break;
 219                 case ExpressionType.RuntimeVariables:
 220                     EmitRuntimeVariablesExpression(node);
 221                     break;
 222                 case ExpressionType.Loop:
 223                     EmitLoopExpression(node);
 224                     break;
 225                 case ExpressionType.Switch:
 226                     EmitSwitchExpression(node, flags);
 227                     break;
 228                 case ExpressionType.Throw:
 229                     EmitThrowUnaryExpression(node);
 230                     break;
 231                 case ExpressionType.Try:
 232                     EmitTryExpression(node);
 233                     break;
 234                 case ExpressionType.Unbox:
 235                     EmitUnboxUnaryExpression(node);
 236                     break;
 237                 case ExpressionType.TypeEqual:
 238                     EmitTypeBinaryExpression(node);
 239                     break;
 240                 case ExpressionType.OnesComplement:
 241                     EmitUnaryExpression(node, flags);
 242                     break;
 243                 case ExpressionType.IsTrue:
 244                     EmitUnaryExpression(node, flags);
 245                     break;
 246                 case ExpressionType.IsFalse:
 247                     EmitUnaryExpression(node, flags);
 248                     break;
 249
 250                 // *** END GENERATED CODE ***
 251
 252                 #endregion
 253
 254                 default:
 255                     throw ContractUtils.Unreachable;
 256             }
 257
 258             if (emitStart) {
 259                 EmitExpressionEnd(startEmitted);
 260             }
 261         }
 262
 263         private static bool IsChecked(ExpressionType op) {
 264             switch (op) {
 265                 #region Generated Checked Operations
 266
 267                 // *** BEGIN GENERATED CODE ***
 268                 // generated by function: gen_checked_ops from: generate_tree.py
 269
 270                 case ExpressionType.AddChecked:
 271                 case ExpressionType.ConvertChecked:
 272                 case ExpressionType.MultiplyChecked:
 273                 case ExpressionType.NegateChecked:
 274                 case ExpressionType.SubtractChecked:
 275                 case ExpressionType.AddAssignChecked:
 276                 case ExpressionType.MultiplyAssignChecked:
 277                 case ExpressionType.SubtractAssignChecked:
 278
 279                 // *** END GENERATED CODE ***
 280
 281                 #endregion
 282                     return true;
 283             }
 284             return false;
 285         }
 286
 287     }
 288 }