mcs/class/dlr/Runtime/Microsoft.Scripting.Core/Compiler/StackSpiller.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     internal partial class StackSpiller {
  25
  26         /// <summary>
  27         /// Rewrite the expression
  28         /// </summary>
  29         ///
  30         /// <param name="node">Expression to rewrite</param>
  31         /// <param name="stack">State of the stack before the expression is emitted.</param>
  32         /// <returns>Rewritten expression.</returns>
  33         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1505:AvoidUnmaintainableCode")]
  34         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
  35         private Result RewriteExpression(Expression node, Stack stack) {
  36             if (node == null) {
  37                 return new Result(RewriteAction.None, null);
  38             }
  39
  40             Result result;
  41             switch (node.NodeType) {
  42                 #region Generated StackSpiller Switch
  43
  44                 // *** BEGIN GENERATED CODE ***
  45                 // generated by function: gen_stackspiller_switch from: generate_tree.py
  46
  47                 case ExpressionType.Add:
  48                     result = RewriteBinaryExpression(node, stack);
  49                     break;
  50                 case ExpressionType.AddChecked:
  51                     result = RewriteBinaryExpression(node, stack);
  52                     break;
  53                 case ExpressionType.And:
  54                     result = RewriteBinaryExpression(node, stack);
  55                     break;
  56                 case ExpressionType.AndAlso:
  57                     result = RewriteLogicalBinaryExpression(node, stack);
  58                     break;
  59                 case ExpressionType.ArrayLength:
  60                     result = RewriteUnaryExpression(node, stack);
  61                     break;
  62                 case ExpressionType.ArrayIndex:
  63                     result = RewriteBinaryExpression(node, stack);
  64                     break;
  65                 case ExpressionType.Call:
  66                     result = RewriteMethodCallExpression(node, stack);
  67                     break;
  68                 case ExpressionType.Coalesce:
  69                     result = RewriteLogicalBinaryExpression(node, stack);
  70                     break;
  71                 case ExpressionType.Conditional:
  72                     result = RewriteConditionalExpression(node, stack);
  73                     break;
  74                 case ExpressionType.Convert:
  75                     result = RewriteUnaryExpression(node, stack);
  76                     break;
  77                 case ExpressionType.ConvertChecked:
  78                     result = RewriteUnaryExpression(node, stack);
  79                     break;
  80                 case ExpressionType.Divide:
  81                     result = RewriteBinaryExpression(node, stack);
  82                     break;
  83                 case ExpressionType.Equal:
  84                     result = RewriteBinaryExpression(node, stack);
  85                     break;
  86                 case ExpressionType.ExclusiveOr:
  87                     result = RewriteBinaryExpression(node, stack);
  88                     break;
  89                 case ExpressionType.GreaterThan:
  90                     result = RewriteBinaryExpression(node, stack);
  91                     break;
  92                 case ExpressionType.GreaterThanOrEqual:
  93                     result = RewriteBinaryExpression(node, stack);
  94                     break;
  95                 case ExpressionType.Invoke:
  96                     result = RewriteInvocationExpression(node, stack);
  97                     break;
  98                 case ExpressionType.Lambda:
  99                     result = RewriteLambdaExpression(node, stack);
 100                     break;
 101                 case ExpressionType.LeftShift:
 102                     result = RewriteBinaryExpression(node, stack);
 103                     break;
 104                 case ExpressionType.LessThan:
 105                     result = RewriteBinaryExpression(node, stack);
 106                     break;
 107                 case ExpressionType.LessThanOrEqual:
 108                     result = RewriteBinaryExpression(node, stack);
 109                     break;
 110                 case ExpressionType.ListInit:
 111                     result = RewriteListInitExpression(node, stack);
 112                     break;
 113                 case ExpressionType.MemberAccess:
 114                     result = RewriteMemberExpression(node, stack);
 115                     break;
 116                 case ExpressionType.MemberInit:
 117                     result = RewriteMemberInitExpression(node, stack);
 118                     break;
 119                 case ExpressionType.Modulo:
 120                     result = RewriteBinaryExpression(node, stack);
 121                     break;
 122                 case ExpressionType.Multiply:
 123                     result = RewriteBinaryExpression(node, stack);
 124                     break;
 125                 case ExpressionType.MultiplyChecked:
 126                     result = RewriteBinaryExpression(node, stack);
 127                     break;
 128                 case ExpressionType.Negate:
 129                     result = RewriteUnaryExpression(node, stack);
 130                     break;
 131                 case ExpressionType.UnaryPlus:
 132                     result = RewriteUnaryExpression(node, stack);
 133                     break;
 134                 case ExpressionType.NegateChecked:
 135                     result = RewriteUnaryExpression(node, stack);
 136                     break;
 137                 case ExpressionType.New:
 138                     result = RewriteNewExpression(node, stack);
 139                     break;
 140                 case ExpressionType.NewArrayInit:
 141                     result = RewriteNewArrayExpression(node, stack);
 142                     break;
 143                 case ExpressionType.NewArrayBounds:
 144                     result = RewriteNewArrayExpression(node, stack);
 145                     break;
 146                 case ExpressionType.Not:
 147                     result = RewriteUnaryExpression(node, stack);
 148                     break;
 149                 case ExpressionType.NotEqual:
 150                     result = RewriteBinaryExpression(node, stack);
 151                     break;
 152                 case ExpressionType.Or:
 153                     result = RewriteBinaryExpression(node, stack);
 154                     break;
 155                 case ExpressionType.OrElse:
 156                     result = RewriteLogicalBinaryExpression(node, stack);
 157                     break;
 158                 case ExpressionType.Power:
 159                     result = RewriteBinaryExpression(node, stack);
 160                     break;
 161                 case ExpressionType.RightShift:
 162                     result = RewriteBinaryExpression(node, stack);
 163                     break;
 164                 case ExpressionType.Subtract:
 165                     result = RewriteBinaryExpression(node, stack);
 166                     break;
 167                 case ExpressionType.SubtractChecked:
 168                     result = RewriteBinaryExpression(node, stack);
 169                     break;
 170                 case ExpressionType.TypeAs:
 171                     result = RewriteUnaryExpression(node, stack);
 172                     break;
 173                 case ExpressionType.TypeIs:
 174                     result = RewriteTypeBinaryExpression(node, stack);
 175                     break;
 176                 case ExpressionType.Assign:
 177                     result = RewriteAssignBinaryExpression(node, stack);
 178                     break;
 179                 case ExpressionType.Block:
 180                     result = RewriteBlockExpression(node, stack);
 181                     break;
 182                 case ExpressionType.Decrement:
 183                     result = RewriteUnaryExpression(node, stack);
 184                     break;
 185                 case ExpressionType.Dynamic:
 186                     result = RewriteDynamicExpression(node, stack);
 187                     break;
 188                 case ExpressionType.Extension:
 189                     result = RewriteExtensionExpression(node, stack);
 190                     break;
 191                 case ExpressionType.Goto:
 192                     result = RewriteGotoExpression(node, stack);
 193                     break;
 194                 case ExpressionType.Increment:
 195                     result = RewriteUnaryExpression(node, stack);
 196                     break;
 197                 case ExpressionType.Index:
 198                     result = RewriteIndexExpression(node, stack);
 199                     break;
 200                 case ExpressionType.Label:
 201                     result = RewriteLabelExpression(node, stack);
 202                     break;
 203                 case ExpressionType.Loop:
 204                     result = RewriteLoopExpression(node, stack);
 205                     break;
 206                 case ExpressionType.Switch:
 207                     result = RewriteSwitchExpression(node, stack);
 208                     break;
 209                 case ExpressionType.Throw:
 210                     result = RewriteThrowUnaryExpression(node, stack);
 211                     break;
 212                 case ExpressionType.Try:
 213                     result = RewriteTryExpression(node, stack);
 214                     break;
 215                 case ExpressionType.Unbox:
 216                     result = RewriteUnaryExpression(node, stack);
 217                     break;
 218                 case ExpressionType.TypeEqual:
 219                     result = RewriteTypeBinaryExpression(node, stack);
 220                     break;
 221                 case ExpressionType.OnesComplement:
 222                     result = RewriteUnaryExpression(node, stack);
 223                     break;
 224                 case ExpressionType.IsTrue:
 225                     result = RewriteUnaryExpression(node, stack);
 226                     break;
 227                 case ExpressionType.IsFalse:
 228                     result = RewriteUnaryExpression(node, stack);
 229                     break;
 230                 case ExpressionType.AddAssign:
 231                 case ExpressionType.AndAssign:
 232                 case ExpressionType.DivideAssign:
 233                 case ExpressionType.ExclusiveOrAssign:
 234                 case ExpressionType.LeftShiftAssign:
 235                 case ExpressionType.ModuloAssign:
 236                 case ExpressionType.MultiplyAssign:
 237                 case ExpressionType.OrAssign:
 238                 case ExpressionType.PowerAssign:
 239                 case ExpressionType.RightShiftAssign:
 240                 case ExpressionType.SubtractAssign:
 241                 case ExpressionType.AddAssignChecked:
 242                 case ExpressionType.MultiplyAssignChecked:
 243                 case ExpressionType.SubtractAssignChecked:
 244                 case ExpressionType.PreIncrementAssign:
 245                 case ExpressionType.PreDecrementAssign:
 246                 case ExpressionType.PostIncrementAssign:
 247                 case ExpressionType.PostDecrementAssign:
 248                     result = RewriteReducibleExpression(node, stack);
 249                     break;
 250                 case ExpressionType.Quote:
 251                 case ExpressionType.Parameter:
 252                 case ExpressionType.Constant:
 253                 case ExpressionType.RuntimeVariables:
 254                 case ExpressionType.Default:
 255                 case ExpressionType.DebugInfo:
 256                     return new Result(RewriteAction.None, node);
 257
 258                 // *** END GENERATED CODE ***
 259
 260                 #endregion
 261
 262                 default:
 263                     throw ContractUtils.Unreachable;
 264             }
 265
 266             VerifyRewrite(result, node);
 267
 268             return result;
 269         }
 270     }
 271 }
 272