/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/Instructions/NumericConvertInstruction.cs

# · C# · 254 lines · 219 code · 21 blank · 14 comment · 10 complexity · 17b8e65d63fe23fc14c3f3f08d98afe1 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. 

  16. using System;

    17. 

  17. using System.Collections.Generic;

    18. 

  18. using System.Diagnostics;

    19. 

  19. using System.Reflection;

    20. 

  20. using System.Runtime.CompilerServices;

    21. 

  21. using Microsoft.Scripting.Runtime;

    22. 

  22. using Microsoft.Scripting.Utils;

    23. 

  23. 

    24. 

  24. namespace Microsoft.Scripting.Interpreter {

    25. 

  25.     internal abstract class NumericConvertInstruction : Instruction {

    26. 

  26.         internal readonly TypeCode _from, _to;

    27. 

  27. 

    28. 

  28.         protected NumericConvertInstruction(TypeCode from, TypeCode to) {

    29. 

  29.             _from = from;

    30. 

  30.             _to = to;

    31. 

  31.         }

    32. 

  32. 

    33. 

  33.         public override int ConsumedStack { get { return 1; } }

    34. 

  34.         public override int ProducedStack { get { return 1; } }

    35. 

  35. 

    36. 

  36.         public override string ToString() {

    37. 

  37.             return InstructionName + "(" + _from + "->" + _to + ")";

    38. 

  38.         }

    39. 

  39. 

    40. 

  40.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]

    41. 

  41.         public sealed class Unchecked : NumericConvertInstruction {

    42. 

  42.             public override string InstructionName { get { return "UncheckedConvert"; } }

    43. 

  43. 

    44. 

  44.             public Unchecked(TypeCode from, TypeCode to)

    45. 

  45.                 : base(from, to) {

    46. 

  46.             }

    47. 

  47. 

    48. 

  48.             public override int Run(InterpretedFrame frame) {

    49. 

  49.                 frame.Push(Convert(frame.Pop()));

    50. 

  50.                 return +1;

    51. 

  51.             }

    52. 

  52. 

    53. 

  53.             private object Convert(object obj) {

    54. 

  54.                 switch (_from) {

    55. 

  55.                     case TypeCode.Byte: return ConvertInt32((Byte)obj);

    56. 

  56.                     case TypeCode.SByte: return ConvertInt32((SByte)obj);

    57. 

  57.                     case TypeCode.Int16: return ConvertInt32((Int16)obj);

    58. 

  58.                     case TypeCode.Char: return ConvertInt32((Char)obj);

    59. 

  59.                     case TypeCode.Int32: return ConvertInt32((Int32)obj);

    60. 

  60.                     case TypeCode.Int64: return ConvertInt64((Int64)obj);

    61. 

  61.                     case TypeCode.UInt16: return ConvertInt32((UInt16)obj);

    62. 

  62.                     case TypeCode.UInt32: return ConvertInt64((UInt32)obj);

    63. 

  63.                     case TypeCode.UInt64: return ConvertUInt64((UInt64)obj);

    64. 

  64.                     case TypeCode.Single: return ConvertDouble((Single)obj);

    65. 

  65.                     case TypeCode.Double: return ConvertDouble((Double)obj);

    66. 

  66.                     default: throw Assert.Unreachable;

    67. 

  67.                 }

    68. 

  68.             }

    69. 

  69. 

    70. 

  70.             private object ConvertInt32(int obj) {

    71. 

  71.                 unchecked {

    72. 

  72.                     switch (_to) {

    73. 

  73.                         case TypeCode.Byte: return (Byte)obj;

    74. 

  74.                         case TypeCode.SByte: return (SByte)obj;

    75. 

  75.                         case TypeCode.Int16: return (Int16)obj;

    76. 

  76.                         case TypeCode.Char: return (Char)obj;

    77. 

  77.                         case TypeCode.Int32: return (Int32)obj;

    78. 

  78.                         case TypeCode.Int64: return (Int64)obj;

    79. 

  79.                         case TypeCode.UInt16: return (UInt16)obj;

    80. 

  80.                         case TypeCode.UInt32: return (UInt32)obj;

    81. 

  81.                         case TypeCode.UInt64: return (UInt64)obj;

    82. 

  82.                         case TypeCode.Single: return (Single)obj;

    83. 

  83.                         case TypeCode.Double: return (Double)obj;

    84. 

  84.                         default: throw Assert.Unreachable;

    85. 

  85.                     }

    86. 

  86.                 }

    87. 

  87.             }

    88. 

  88. 

    89. 

  89.             private object ConvertInt64(Int64 obj) {

    90. 

  90.                 unchecked {

    91. 

  91.                     switch (_to) {

    92. 

  92.                         case TypeCode.Byte: return (Byte)obj;

    93. 

  93.                         case TypeCode.SByte: return (SByte)obj;

    94. 

  94.                         case TypeCode.Int16: return (Int16)obj;

    95. 

  95.                         case TypeCode.Char: return (Char)obj;

    96. 

  96.                         case TypeCode.Int32: return (Int32)obj;

    97. 

  97.                         case TypeCode.Int64: return (Int64)obj;

    98. 

  98.                         case TypeCode.UInt16: return (UInt16)obj;

    99. 

  99.                         case TypeCode.UInt32: return (UInt32)obj;

    100. 

  100.                         case TypeCode.UInt64: return (UInt64)obj;

    101. 

  101.                         case TypeCode.Single: return (Single)obj;

    102. 

  102.                         case TypeCode.Double: return (Double)obj;

    103. 

  103.                         default: throw Assert.Unreachable;

    104. 

  104.                     }

    105. 

  105.                 }

    106. 

  106.             }

    107. 

  107. 

    108. 

  108.             private object ConvertUInt64(UInt64 obj) {

    109. 

  109.                 unchecked {

    110. 

  110.                     switch (_to) {

    111. 

  111.                         case TypeCode.Byte: return (Byte)obj;

    112. 

  112.                         case TypeCode.SByte: return (SByte)obj;

    113. 

  113.                         case TypeCode.Int16: return (Int16)obj;

    114. 

  114.                         case TypeCode.Char: return (Char)obj;

    115. 

  115.                         case TypeCode.Int32: return (Int32)obj;

    116. 

  116.                         case TypeCode.Int64: return (Int64)obj;

    117. 

  117.                         case TypeCode.UInt16: return (UInt16)obj;

    118. 

  118.                         case TypeCode.UInt32: return (UInt32)obj;

    119. 

  119.                         case TypeCode.UInt64: return (UInt64)obj;

    120. 

  120.                         case TypeCode.Single: return (Single)obj;

    121. 

  121.                         case TypeCode.Double: return (Double)obj;

    122. 

  122.                         default: throw Assert.Unreachable;

    123. 

  123.                     }

    124. 

  124.                 }

    125. 

  125.             }

    126. 

  126. 

    127. 

  127.             private object ConvertDouble(Double obj) {

    128. 

  128.                 unchecked {

    129. 

  129.                     switch (_to) {

    130. 

  130.                         case TypeCode.Byte: return (Byte)obj;

    131. 

  131.                         case TypeCode.SByte: return (SByte)obj;

    132. 

  132.                         case TypeCode.Int16: return (Int16)obj;

    133. 

  133.                         case TypeCode.Char: return (Char)obj;

    134. 

  134.                         case TypeCode.Int32: return (Int32)obj;

    135. 

  135.                         case TypeCode.Int64: return (Int64)obj;

    136. 

  136.                         case TypeCode.UInt16: return (UInt16)obj;

    137. 

  137.                         case TypeCode.UInt32: return (UInt32)obj;

    138. 

  138.                         case TypeCode.UInt64: return (UInt64)obj;

    139. 

  139.                         case TypeCode.Single: return (Single)obj;

    140. 

  140.                         case TypeCode.Double: return (Double)obj;

    141. 

  141.                         default: throw Assert.Unreachable;

    142. 

  142.                     }

    143. 

  143.                 }

    144. 

  144.             }

    145. 

  145.         }

    146. 

  146. 

    147. 

  147.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]

    148. 

  148.         public sealed class Checked : NumericConvertInstruction {

    149. 

  149.             public override string InstructionName { get { return "CheckedConvert"; } }

    150. 

  150. 

    151. 

  151.             public Checked(TypeCode from, TypeCode to)

    152. 

  152.                 : base(from, to) {

    153. 

  153.             }

    154. 

  154. 

    155. 

  155.             public override int Run(InterpretedFrame frame) {

    156. 

  156.                 frame.Push(Convert(frame.Pop()));

    157. 

  157.                 return +1;

    158. 

  158.             }

    159. 

  159. 

    160. 

  160.             private object Convert(object obj) {

    161. 

  161.                 switch (_from) {

    162. 

  162.                     case TypeCode.Byte: return ConvertInt32((Byte)obj);

    163. 

  163.                     case TypeCode.SByte: return ConvertInt32((SByte)obj);

    164. 

  164.                     case TypeCode.Int16: return ConvertInt32((Int16)obj);

    165. 

  165.                     case TypeCode.Char: return ConvertInt32((Char)obj);

    166. 

  166.                     case TypeCode.Int32: return ConvertInt32((Int32)obj);

    167. 

  167.                     case TypeCode.Int64: return ConvertInt64((Int64)obj);

    168. 

  168.                     case TypeCode.UInt16: return ConvertInt32((UInt16)obj);

    169. 

  169.                     case TypeCode.UInt32: return ConvertInt64((UInt32)obj);

    170. 

  170.                     case TypeCode.UInt64: return ConvertUInt64((UInt64)obj);

    171. 

  171.                     case TypeCode.Single: return ConvertDouble((Single)obj);

    172. 

  172.                     case TypeCode.Double: return ConvertDouble((Double)obj);

    173. 

  173.                     default: throw Assert.Unreachable;

    174. 

  174.                 }

    175. 

  175.             }

    176. 

  176. 

    177. 

  177.             private object ConvertInt32(int obj) {

    178. 

  178.                 checked {

    179. 

  179.                     switch (_to) {

    180. 

  180.                         case TypeCode.Byte: return (Byte)obj;

    181. 

  181.                         case TypeCode.SByte: return (SByte)obj;

    182. 

  182.                         case TypeCode.Int16: return (Int16)obj;

    183. 

  183.                         case TypeCode.Char: return (Char)obj;

    184. 

  184.                         case TypeCode.Int32: return (Int32)obj;

    185. 

  185.                         case TypeCode.Int64: return (Int64)obj;

    186. 

  186.                         case TypeCode.UInt16: return (UInt16)obj;

    187. 

  187.                         case TypeCode.UInt32: return (UInt32)obj;

    188. 

  188.                         case TypeCode.UInt64: return (UInt64)obj;

    189. 

  189.                         case TypeCode.Single: return (Single)obj;

    190. 

  190.                         case TypeCode.Double: return (Double)obj;

    191. 

  191.                         default: throw Assert.Unreachable;

    192. 

  192.                     }

    193. 

  193.                 }

    194. 

  194.             }

    195. 

  195. 

    196. 

  196.             private object ConvertInt64(Int64 obj) {

    197. 

  197.                 checked {

    198. 

  198.                     switch (_to) {

    199. 

  199.                         case TypeCode.Byte: return (Byte)obj;

    200. 

  200.                         case TypeCode.SByte: return (SByte)obj;

    201. 

  201.                         case TypeCode.Int16: return (Int16)obj;

    202. 

  202.                         case TypeCode.Char: return (Char)obj;

    203. 

  203.                         case TypeCode.Int32: return (Int32)obj;

    204. 

  204.                         case TypeCode.Int64: return (Int64)obj;

    205. 

  205.                         case TypeCode.UInt16: return (UInt16)obj;

    206. 

  206.                         case TypeCode.UInt32: return (UInt32)obj;

    207. 

  207.                         case TypeCode.UInt64: return (UInt64)obj;

    208. 

  208.                         case TypeCode.Single: return (Single)obj;

    209. 

  209.                         case TypeCode.Double: return (Double)obj;

    210. 

  210.                         default: throw Assert.Unreachable;

    211. 

  211.                     }

    212. 

  212.                 }

    213. 

  213.             }

    214. 

  214. 

    215. 

  215.             private object ConvertUInt64(UInt64 obj) {

    216. 

  216.                 checked {

    217. 

  217.                     switch (_to) {

    218. 

  218.                         case TypeCode.Byte: return (Byte)obj;

    219. 

  219.                         case TypeCode.SByte: return (SByte)obj;

    220. 

  220.                         case TypeCode.Int16: return (Int16)obj;

    221. 

  221.                         case TypeCode.Char: return (Char)obj;

    222. 

  222.                         case TypeCode.Int32: return (Int32)obj;

    223. 

  223.                         case TypeCode.Int64: return (Int64)obj;

    224. 

  224.                         case TypeCode.UInt16: return (UInt16)obj;

    225. 

  225.                         case TypeCode.UInt32: return (UInt32)obj;

    226. 

  226.                         case TypeCode.UInt64: return (UInt64)obj;

    227. 

  227.                         case TypeCode.Single: return (Single)obj;

    228. 

  228.                         case TypeCode.Double: return (Double)obj;

    229. 

  229.                         default: throw Assert.Unreachable;

    230. 

  230.                     }

    231. 

  231.                 }

    232. 

  232.             }

    233. 

  233. 

    234. 

  234.             private object ConvertDouble(Double obj) {

    235. 

  235.                 checked {

    236. 

  236.                     switch (_to) {

    237. 

  237.                         case TypeCode.Byte: return (Byte)obj;

    238. 

  238.                         case TypeCode.SByte: return (SByte)obj;

    239. 

  239.                         case TypeCode.Int16: return (Int16)obj;

    240. 

  240.                         case TypeCode.Char: return (Char)obj;

    241. 

  241.                         case TypeCode.Int32: return (Int32)obj;

    242. 

  242.                         case TypeCode.Int64: return (Int64)obj;

    243. 

  243.                         case TypeCode.UInt16: return (UInt16)obj;

    244. 

  244.                         case TypeCode.UInt32: return (UInt32)obj;

    245. 

  245.                         case TypeCode.UInt64: return (UInt64)obj;

    246. 

  246.                         case TypeCode.Single: return (Single)obj;

    247. 

  247.                         case TypeCode.Double: return (Double)obj;

    248. 

  248.                         default: throw Assert.Unreachable;

    249. 

  249.                     }

    250. 

  250.                 }

    251. 

  251.             }

    252. 

  252.         }

    253. 

  253.     }

    254. 

  254. }
    255.