PageRenderTime 73ms CodeModel.GetById 39ms RepoModel.GetById 1ms app.codeStats 0ms

/Languages/IronPython/IronPython/Compiler/Ast/BinaryExpression.Generated.cs

https://github.com/rickardraysearch/main
C# | 154 lines | 121 code | 14 blank | 19 comment | 48 complexity | 208b7a74b66d6406e83a99a31b0ef2fc MD5 | raw file
    

  1. /* ****************************************************************************
    2. 

  2.  *
    3. 

  3.  * Copyright (c) Microsoft Corporation. 
    4. 

  4.  *
    5. 

  5.  * This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
    6. 

  6.  * copy of the license can be found in the License.html file at the root of this distribution. If 
    7. 

  7.  * you cannot locate the  Apache License, Version 2.0, please send an email to 
    8. 

  8.  * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
    9. 

  9.  * by the terms of the Apache License, Version 2.0.
    10. 

  10.  *
    11. 

  11.  * You must not remove this notice, or any other, from this software.
    12. 

  12.  *
    13. 

  13.  *
    14. 

  14.  * ***************************************************************************/
    15. 

  15. 

  16. using System;
    17. 

  17. using System.Collections.Generic;
    18. 

  18. using System.Text;
    19. 

  19. 

  20. using Microsoft.Scripting.Runtime;
    21. 

  21. 

  22. using IronPython.Runtime.Operations;
    23. 

  23. 

  24. #if CLR2
    25. 

  25. using Microsoft.Scripting.Math;
    26. 

  26. using Complex = Microsoft.Scripting.Math.Complex64;
    27. 

  27. #else
    28. 

  28. using System.Numerics;
    29. 

  29. #endif
    30. 

  30. 

  31. namespace IronPython.Compiler.Ast {
    32. 

  32.     public partial class BinaryExpression {
    33. 

  33.         const int MaximumInlineStringLength = 1024 * 1024;
    34. 

  34. 

  35.         internal override ConstantExpression ConstantFold() {
    36. 

  36.             Expression left = _left.ConstantFold();
    37. 

  37.             Expression right = _right.ConstantFold();
    38. 

  38. 

  39.             var constLeft = left as ConstantExpression;
    40. 

  40.             var constRight = right as ConstantExpression;
    41. 

  41.             try {
    42. 

  42.                 if (constLeft != null && constRight != null &&
    43. 

  43.                     constLeft.Value != null && constRight.Value != null &&
    44. 

  44.                     constLeft.Value.GetType() == constRight.Value.GetType()) {
    45. 

  45.                     #region Generated Python Constant Folding
    46. 

  46. 

  47.                     // *** BEGIN GENERATED CODE ***
    48. 

  48.                     // generated by function: gen_constant_folding from: generate_ops.py
    49. 

  49. 

  50.                     if (constLeft.Value.GetType() == typeof(Int32)) {
    51. 

  51.                         switch (_op) {
    52. 

  52.                             case PythonOperator.Add: return new ConstantExpression(Int32Ops.Add((Int32)constLeft.Value, (Int32)constRight.Value));
    53. 

  53.                             case PythonOperator.Subtract: return new ConstantExpression(Int32Ops.Subtract((Int32)constLeft.Value, (Int32)constRight.Value));
    54. 

  54.                             case PythonOperator.Power: return new ConstantExpression(Int32Ops.Power((Int32)constLeft.Value, (Int32)constRight.Value));
    55. 

  55.                             case PythonOperator.Multiply: return new ConstantExpression(Int32Ops.Multiply((Int32)constLeft.Value, (Int32)constRight.Value));
    56. 

  56.                             case PythonOperator.FloorDivide: return new ConstantExpression(Int32Ops.FloorDivide((Int32)constLeft.Value, (Int32)constRight.Value));
    57. 

  57.                             case PythonOperator.Divide: return new ConstantExpression(Int32Ops.Divide((Int32)constLeft.Value, (Int32)constRight.Value));
    58. 

  58.                             case PythonOperator.TrueDivide: return new ConstantExpression(Int32Ops.TrueDivide((Int32)constLeft.Value, (Int32)constRight.Value));
    59. 

  59.                             case PythonOperator.Mod: return new ConstantExpression(Int32Ops.Mod((Int32)constLeft.Value, (Int32)constRight.Value));
    60. 

  60.                             case PythonOperator.LeftShift: return new ConstantExpression(Int32Ops.LeftShift((Int32)constLeft.Value, (Int32)constRight.Value));
    61. 

  61.                             case PythonOperator.RightShift: return new ConstantExpression(Int32Ops.RightShift((Int32)constLeft.Value, (Int32)constRight.Value));
    62. 

  62.                             case PythonOperator.BitwiseAnd: return new ConstantExpression(Int32Ops.BitwiseAnd((Int32)constLeft.Value, (Int32)constRight.Value));
    63. 

  63.                             case PythonOperator.BitwiseOr: return new ConstantExpression(Int32Ops.BitwiseOr((Int32)constLeft.Value, (Int32)constRight.Value));
    64. 

  64.                             case PythonOperator.ExclusiveOr: return new ConstantExpression(Int32Ops.ExclusiveOr((Int32)constLeft.Value, (Int32)constRight.Value));
    65. 

  65.                             case PythonOperator.LessThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) < 0));
    66. 

  66.                             case PythonOperator.GreaterThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) > 0));
    67. 

  67.                             case PythonOperator.LessThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) <= 0));
    68. 

  68.                             case PythonOperator.GreaterThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) >= 0));
    69. 

  69.                             case PythonOperator.Equals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) == 0));
    70. 

  70.                             case PythonOperator.NotEquals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(Int32Ops.Compare((Int32)constLeft.Value, (Int32)constRight.Value) != 0));
    71. 

  71.                         }
    72. 

  72.                     }
    73. 

  73.                     if (constLeft.Value.GetType() == typeof(Double)) {
    74. 

  74.                         switch (_op) {
    75. 

  75.                             case PythonOperator.Add: return new ConstantExpression(DoubleOps.Add((Double)constLeft.Value, (Double)constRight.Value));
    76. 

  76.                             case PythonOperator.Subtract: return new ConstantExpression(DoubleOps.Subtract((Double)constLeft.Value, (Double)constRight.Value));
    77. 

  77.                             case PythonOperator.Power: return new ConstantExpression(DoubleOps.Power((Double)constLeft.Value, (Double)constRight.Value));
    78. 

  78.                             case PythonOperator.Multiply: return new ConstantExpression(DoubleOps.Multiply((Double)constLeft.Value, (Double)constRight.Value));
    79. 

  79.                             case PythonOperator.FloorDivide: return new ConstantExpression(DoubleOps.FloorDivide((Double)constLeft.Value, (Double)constRight.Value));
    80. 

  80.                             case PythonOperator.Divide: return new ConstantExpression(DoubleOps.Divide((Double)constLeft.Value, (Double)constRight.Value));
    81. 

  81.                             case PythonOperator.TrueDivide: return new ConstantExpression(DoubleOps.TrueDivide((Double)constLeft.Value, (Double)constRight.Value));
    82. 

  82.                             case PythonOperator.Mod: return new ConstantExpression(DoubleOps.Mod((Double)constLeft.Value, (Double)constRight.Value));
    83. 

  83.                             case PythonOperator.LessThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) < 0));
    84. 

  84.                             case PythonOperator.GreaterThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) > 0));
    85. 

  85.                             case PythonOperator.LessThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) <= 0));
    86. 

  86.                             case PythonOperator.GreaterThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) >= 0));
    87. 

  87.                             case PythonOperator.Equals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) == 0));
    88. 

  88.                             case PythonOperator.NotEquals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(DoubleOps.Compare((Double)constLeft.Value, (Double)constRight.Value) != 0));
    89. 

  89.                         }
    90. 

  90.                     }
    91. 

  91.                     if (constLeft.Value.GetType() == typeof(BigInteger)) {
    92. 

  92.                         switch (_op) {
    93. 

  93.                             case PythonOperator.Add: return new ConstantExpression(BigIntegerOps.Add((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    94. 

  94.                             case PythonOperator.Subtract: return new ConstantExpression(BigIntegerOps.Subtract((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    95. 

  95.                             case PythonOperator.Power: return new ConstantExpression(BigIntegerOps.Power((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    96. 

  96.                             case PythonOperator.Multiply: return new ConstantExpression(BigIntegerOps.Multiply((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    97. 

  97.                             case PythonOperator.FloorDivide: return new ConstantExpression(BigIntegerOps.FloorDivide((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    98. 

  98.                             case PythonOperator.Divide: return new ConstantExpression(BigIntegerOps.Divide((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    99. 

  99.                             case PythonOperator.TrueDivide: return new ConstantExpression(BigIntegerOps.TrueDivide((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    100. 

  100.                             case PythonOperator.Mod: return new ConstantExpression(BigIntegerOps.Mod((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    101. 

  101.                             case PythonOperator.LeftShift: return new ConstantExpression(BigIntegerOps.LeftShift((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    102. 

  102.                             case PythonOperator.RightShift: return new ConstantExpression(BigIntegerOps.RightShift((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    103. 

  103.                             case PythonOperator.BitwiseAnd: return new ConstantExpression(BigIntegerOps.BitwiseAnd((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    104. 

  104.                             case PythonOperator.BitwiseOr: return new ConstantExpression(BigIntegerOps.BitwiseOr((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    105. 

  105.                             case PythonOperator.ExclusiveOr: return new ConstantExpression(BigIntegerOps.ExclusiveOr((BigInteger)constLeft.Value, (BigInteger)constRight.Value));
    106. 

  106.                             case PythonOperator.LessThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) < 0));
    107. 

  107.                             case PythonOperator.GreaterThan: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) > 0));
    108. 

  108.                             case PythonOperator.LessThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) <= 0));
    109. 

  109.                             case PythonOperator.GreaterThanOrEqual: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) >= 0));
    110. 

  110.                             case PythonOperator.Equals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) == 0));
    111. 

  111.                             case PythonOperator.NotEquals: return new ConstantExpression(ScriptingRuntimeHelpers.BooleanToObject(BigIntegerOps.Compare((BigInteger)constLeft.Value, (BigInteger)constRight.Value) != 0));
    112. 

  112.                         }
    113. 

  113.                     }
    114. 

  114.                     if (constLeft.Value.GetType() == typeof(Complex)) {
    115. 

  115.                         switch (_op) {
    116. 

  116.                             case PythonOperator.Add: return new ConstantExpression(ComplexOps.Add((Complex)constLeft.Value, (Complex)constRight.Value));
    117. 

  117.                             case PythonOperator.Subtract: return new ConstantExpression(ComplexOps.Subtract((Complex)constLeft.Value, (Complex)constRight.Value));
    118. 

  118.                             case PythonOperator.Power: return new ConstantExpression(ComplexOps.Power((Complex)constLeft.Value, (Complex)constRight.Value));
    119. 

  119.                             case PythonOperator.Multiply: return new ConstantExpression(ComplexOps.Multiply((Complex)constLeft.Value, (Complex)constRight.Value));
    120. 

  120.                             case PythonOperator.Divide: return new ConstantExpression(ComplexOps.Divide((Complex)constLeft.Value, (Complex)constRight.Value));
    121. 

  121.                             case PythonOperator.TrueDivide: return new ConstantExpression(ComplexOps.TrueDivide((Complex)constLeft.Value, (Complex)constRight.Value));
    122. 

  122.                         }
    123. 

  123.                     }
    124. 

  124. 

  125.                     // *** END GENERATED CODE ***
    126. 

  126. 

  127.                     #endregion
    128. 

  128. 

  129.                     if (constLeft.Value.GetType() == typeof(string) && _op == PythonOperator.Add) {
    130. 

  130.                         return new ConstantExpression((string)constLeft.Value + (string)constRight.Value);
    131. 

  131.                     }
    132. 

  132.                 } else if (_op == PythonOperator.Multiply && constLeft != null && constRight != null) {
    133. 

  133.                     // 10000 check is to avoid creating massive strings in IL - there's a limit to the number of
    134. 

  134.                     // bytes of strings we get to have so we don't want to use them all up.
    135. 

  135.                     if (constLeft.Value.GetType() == typeof(string) && constRight.Value.GetType() == typeof(int)) {
    136. 

  136.                         var res = StringOps.Multiply((string)constLeft.Value, (int)constRight.Value);
    137. 

  137.                         if (res.Length < MaximumInlineStringLength) {
    138. 

  138.                             return new ConstantExpression(res);
    139. 

  139.                         }
    140. 

  140.                     } else if (constLeft.Value.GetType() == typeof(int) && constRight.Value.GetType() == typeof(string)) {
    141. 

  141.                         var res = StringOps.Multiply((string)constRight.Value, (int)constLeft.Value);
    142. 

  142.                         if (res.Length < MaximumInlineStringLength) {
    143. 

  143.                             return new ConstantExpression(res);
    144. 

  144.                         }
    145. 

  145.                     }
    146. 

  146.                 }   
    147. 

  147.             } catch (ArithmeticException) {
    148. 

  148.             }
    149. 

  149. 

  150.             return null;
    151. 

  151.         }
    152. 

  152. 

  153.     }
    154. 

  154. }
    155. 

  155.