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