/IronPython_1_0/Src/IronPython/Compiler/AST/Operator.Generated.cs

# · C# · 127 lines · 84 code · 27 blank · 16 comment · 0 complexity · e27b8340ac847e8c9d5f865470916547 MD5 · raw file 

    

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

    2. 

  2.  *

    3. 

  3.  * Copyright (c) Microsoft Corporation. All rights reserved.

    4. 

  4.  *

    5. 

  5.  * This source code is subject to terms and conditions of the Shared Source License

    6. 

  6.  * for IronPython. A copy of the license can be found in the License.html file

    7. 

  7.  * at the root of this distribution. If you can not locate the Shared Source License

    8. 

  8.  * for IronPython, please send an email to ironpy@microsoft.com.

    9. 

  9.  * By using this source code in any fashion, you are agreeing to be bound by

    10. 

  10.  * the terms of the Shared Source License for IronPython.

    11. 

  11.  *

    12. 

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

    13. 

  13.  *

    14. 

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

    15. 

  15. 

    16. 

  16. using System;

    17. 

  17. using System.Collections.Generic;

    18. 

  18. using System.Text;

    19. 

  19. 

    20. 

  20. using IronPython.Runtime;

    21. 

  21. using IronPython.Runtime.Calls;

    22. 

  22. using IronPython.Runtime.Operations;

    23. 

  23. 

    24. 

  24. namespace IronPython.Compiler.Ast {

    25. 

  25.     public abstract partial class PythonOperator {

    26. 

  26.         #region Generated Operators

    27. 

  27. 

    28. 

  28.         // *** BEGIN GENERATED CODE ***

    29. 

  29. 

    30. 

  30.         private static readonly BinaryOperator add = new BinaryOperator("+", new CallTarget2(Ops.Add), new CallTarget2(Ops.InPlaceAdd), 4);

    31. 

  31.         private static readonly BinaryOperator sub = new BinaryOperator("-", new CallTarget2(Ops.Subtract), new CallTarget2(Ops.InPlaceSubtract), 4);

    32. 

  32.         private static readonly BinaryOperator pow = new BinaryOperator("**", new CallTarget2(Ops.Power), new CallTarget2(Ops.InPlacePower), 6);

    33. 

  33.         private static readonly BinaryOperator mul = new BinaryOperator("*", new CallTarget2(Ops.Multiply), new CallTarget2(Ops.InPlaceMultiply), 5);

    34. 

  34.         private static readonly BinaryOperator floordiv = new BinaryOperator("//", new CallTarget2(Ops.FloorDivide), new CallTarget2(Ops.InPlaceFloorDivide), 5);

    35. 

  35.         private static readonly BinaryOperator div = new DivisionOperator("/", new CallTarget2(Ops.Divide), new CallTarget2(Ops.InPlaceDivide), new CallTarget2(Ops.TrueDivide), new CallTarget2(Ops.InPlaceTrueDivide), 5);

    36. 

  36.         private static readonly BinaryOperator mod = new BinaryOperator("%", new CallTarget2(Ops.Mod), new CallTarget2(Ops.InPlaceMod), 5);

    37. 

  37.         private static readonly BinaryOperator lshift = new BinaryOperator("<<", new CallTarget2(Ops.LeftShift), new CallTarget2(Ops.InPlaceLeftShift), 3);

    38. 

  38.         private static readonly BinaryOperator rshift = new BinaryOperator(">>", new CallTarget2(Ops.RightShift), new CallTarget2(Ops.InPlaceRightShift), 3);

    39. 

  39.         private static readonly BinaryOperator and = new BinaryOperator("&", new CallTarget2(Ops.BitwiseAnd), new CallTarget2(Ops.InPlaceBitwiseAnd), 2);

    40. 

  40.         private static readonly BinaryOperator or = new BinaryOperator("|", new CallTarget2(Ops.BitwiseOr), new CallTarget2(Ops.InPlaceBitwiseOr), 0);

    41. 

  41.         private static readonly BinaryOperator xor = new BinaryOperator("^", new CallTarget2(Ops.Xor), new CallTarget2(Ops.InPlaceXor), 1);

    42. 

  42.         private static readonly BinaryOperator lt = new BinaryOperator("<", new CallTarget2(Ops.LessThan), null, -1);

    43. 

  43.         private static readonly BinaryOperator gt = new BinaryOperator(">", new CallTarget2(Ops.GreaterThan), null, -1);

    44. 

  44.         private static readonly BinaryOperator le = new BinaryOperator("<=", new CallTarget2(Ops.LessThanOrEqual), null, -1);

    45. 

  45.         private static readonly BinaryOperator ge = new BinaryOperator(">=", new CallTarget2(Ops.GreaterThanOrEqual), null, -1);

    46. 

  46.         private static readonly BinaryOperator eq = new BinaryOperator("==", new CallTarget2(Ops.Equal), null, -1);

    47. 

  47.         private static readonly BinaryOperator ne = new BinaryOperator("!=", new CallTarget2(Ops.NotEqual), null, -1);

    48. 

  48. 

    49. 

  49. 

    50. 

  50.         public static BinaryOperator Add {

    51. 

  51.             get { return add; }

    52. 

  52.         }

    53. 

  53. 

    54. 

  54.         public static BinaryOperator Subtract {

    55. 

  55.             get { return sub; }

    56. 

  56.         }

    57. 

  57. 

    58. 

  58.         public static BinaryOperator Power {

    59. 

  59.             get { return pow; }

    60. 

  60.         }

    61. 

  61. 

    62. 

  62.         public static BinaryOperator Multiply {

    63. 

  63.             get { return mul; }

    64. 

  64.         }

    65. 

  65. 

    66. 

  66.         public static BinaryOperator FloorDivide {

    67. 

  67.             get { return floordiv; }

    68. 

  68.         }

    69. 

  69. 

    70. 

  70.         public static BinaryOperator Divide {

    71. 

  71.             get { return div; }

    72. 

  72.         }

    73. 

  73. 

    74. 

  74.         public static BinaryOperator Mod {

    75. 

  75.             get { return mod; }

    76. 

  76.         }

    77. 

  77. 

    78. 

  78.         public static BinaryOperator LeftShift {

    79. 

  79.             get { return lshift; }

    80. 

  80.         }

    81. 

  81. 

    82. 

  82.         public static BinaryOperator RightShift {

    83. 

  83.             get { return rshift; }

    84. 

  84.         }

    85. 

  85. 

    86. 

  86.         public static BinaryOperator BitwiseAnd {

    87. 

  87.             get { return and; }

    88. 

  88.         }

    89. 

  89. 

    90. 

  90.         public static BinaryOperator BitwiseOr {

    91. 

  91.             get { return or; }

    92. 

  92.         }

    93. 

  93. 

    94. 

  94.         public static BinaryOperator Xor {

    95. 

  95.             get { return xor; }

    96. 

  96.         }

    97. 

  97. 

    98. 

  98.         public static BinaryOperator LessThan {

    99. 

  99.             get { return lt; }

    100. 

  100.         }

    101. 

  101. 

    102. 

  102.         public static BinaryOperator GreaterThan {

    103. 

  103.             get { return gt; }

    104. 

  104.         }

    105. 

  105. 

    106. 

  106.         public static BinaryOperator LessThanOrEqual {

    107. 

  107.             get { return le; }

    108. 

  108.         }

    109. 

  109. 

    110. 

  110.         public static BinaryOperator GreaterThanOrEqual {

    111. 

  111.             get { return ge; }

    112. 

  112.         }

    113. 

  113. 

    114. 

  114.         public static BinaryOperator Equal {

    115. 

  115.             get { return eq; }

    116. 

  116.         }

    117. 

  117. 

    118. 

  118.         public static BinaryOperator NotEqual {

    119. 

  119.             get { return ne; }

    120. 

  120.         }

    121. 

  121. 

    122. 

  122. 

    123. 

  123.         // *** END GENERATED CODE ***

    124. 

  124. 

    125. 

  125.         #endregion

    126. 

  126.     }

    127. 

  127. }
    128.