PageRenderTime 70ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 1ms

/IronPython_Main/Languages/IronPython/IronPython/Modules/Builtin.cs

#
C# | 2444 lines | 1970 code | 387 blank | 87 comment | 547 complexity | 706f312386539879a298f0829e19be28 MD5 | raw file
Possible License(s): GPL-2.0, MPL-2.0-no-copyleft-exception, CPL-1.0, CC-BY-SA-3.0, BSD-3-Clause, ISC, AGPL-3.0, LGPL-2.1, Apache-2.0 
    

  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;

    18. 

  18. using System.Collections.Generic;

    19. 

  19. using System.Diagnostics;

    20. 

  20. using System.IO;

    21. 

  21. using System.Runtime.CompilerServices;

    22. 

  22. using System.Runtime.InteropServices;

    23. 

  23. using System.Text;

    24. 

  24. using System.Threading;

    25. 

  25. 

    26. 

  26. using Microsoft.Scripting;

    27. 

  27. using Microsoft.Scripting.Actions;

    28. 

  28. using Microsoft.Scripting.Runtime;

    29. 

  29. using Microsoft.Scripting.Utils;

    30. 

  30. 

    31. 

  31. using IronPython.Compiler;

    32. 

  32. using IronPython.Runtime;

    33. 

  33. using IronPython.Runtime.Binding;

    34. 

  34. using IronPython.Runtime.Exceptions;

    35. 

  35. using IronPython.Runtime.Operations;

    36. 

  36. using IronPython.Runtime.Types;

    37. 

  37. 

    38. 

  38. #if CLR2

    39. 

  39. using Microsoft.Scripting.Math;

    40. 

  40. using Complex = Microsoft.Scripting.Math.Complex64;

    41. 

  41. #else

    42. 

  42. using System.Numerics;

    43. 

  43. #endif

    44. 

  44. 

    45. 

  45. [assembly: PythonModule("__builtin__", typeof(IronPython.Modules.Builtin))]

    46. 

  46. namespace IronPython.Modules {

    47. 

  47.     [Documentation("")]  // Documentation suppresses XML Doc on startup.

    48. 

  48.     public static partial class Builtin {

    49. 

  49.         public const string __doc__ = "Provides access to commonly used built-in functions, exception objects, etc...";

    50. 

  50.         public const object __package__ = null;

    51. 

  51.         public const string __name__ = "__builtin__";

    52. 

  52. 

    53. 

  53.         public static object True {

    54. 

  54.             get {

    55. 

  55.                 return ScriptingRuntimeHelpers.True;

    56. 

  56.             }

    57. 

  57.         }

    58. 

  58. 

    59. 

  59.         public static object False {

    60. 

  60.             get {

    61. 

  61.                 return ScriptingRuntimeHelpers.False;

    62. 

  62.             }

    63. 

  63.         }

    64. 

  64. 

    65. 

  65.         // This will always stay null

    66. 

  66.         public static readonly object None;

    67. 

  67. 

    68. 

  68.         public static IronPython.Runtime.Types.Ellipsis Ellipsis {

    69. 

  69.             get {

    70. 

  70.                 return IronPython.Runtime.Types.Ellipsis.Value;

    71. 

  71.             }

    72. 

  72.         }

    73. 

  73. 

    74. 

  74.         public static NotImplementedType NotImplemented {

    75. 

  75.             get {

    76. 

  76.                 return NotImplementedType.Value;

    77. 

  77.             }

    78. 

  78.         }

    79. 

  79. 

    80. 

  80.         public static object exit {

    81. 

  81.             get {

    82. 

  82.                 return "Use Ctrl-Z plus Return to exit";

    83. 

  83.             }

    84. 

  84.         }

    85. 

  85. 

    86. 

  86.         public static object quit {

    87. 

  87.             get {

    88. 

  88.                 return "Use Ctrl-Z plus Return to exit";

    89. 

  89.             }

    90. 

  90.         }

    91. 

  91. 

    92. 

  92.         [Documentation("__import__(name) -> module\n\nImport a module.")]

    93. 

  93.         [LightThrowing]

    94. 

  94.         public static object __import__(CodeContext/*!*/ context, string name) {

    95. 

  95.             return __import__(context, name, null, null, null, -1);

    96. 

  96.         }

    97. 

  97. 

    98. 

  98.         [Documentation("__import__(name, globals, locals, fromlist, level) -> module\n\nImport a module.")]

    99. 

  99.         [LightThrowing]

    100. 

  100.         public static object __import__(CodeContext/*!*/ context, string name, [DefaultParameterValue(null)]object globals, [DefaultParameterValue(null)]object locals, [DefaultParameterValue(null)]object fromlist, [DefaultParameterValue(-1)]int level) {

    101. 

  101.             if (fromlist is string || fromlist is Extensible<string>) {

    102. 

  102.                 fromlist = new List<object> { fromlist };

    103. 

  103.             }

    104. 

  104. 

    105. 

  105.             IList from = fromlist as IList;

    106. 

  106.             PythonContext pc = PythonContext.GetContext(context);

    107. 

  107. 

    108. 

  108.             object ret = Importer.ImportModule(context, globals, name, from != null && from.Count > 0, level);

    109. 

  109.             if (ret == null) {

    110. 

  110.                 return LightExceptions.Throw(PythonOps.ImportError("No module named {0}", name));

    111. 

  111.             }

    112. 

  112. 

    113. 

  113.             PythonModule mod = ret as PythonModule;

    114. 

  114.             if (mod != null && from != null) {

    115. 

  115.                 string strAttrName;

    116. 

  116.                 for (int i = 0; i < from.Count; i++) {

    117. 

  117.                     object attrName = from[i];

    118. 

  118. 

    119. 

  119.                     if (pc.TryConvertToString(attrName, out strAttrName) &&

    120. 

  120.                         !String.IsNullOrEmpty(strAttrName) &&

    121. 

  121.                         strAttrName != "*") {

    122. 

  122.                         try {

    123. 

  123.                             Importer.ImportFrom(context, mod, strAttrName);

    124. 

  124.                         } catch (ImportException) {

    125. 

  125.                             continue;

    126. 

  126.                         }

    127. 

  127.                     }

    128. 

  128.                 }

    129. 

  129.             }

    130. 

  130. 

    131. 

  131.             return ret;

    132. 

  132.         }

    133. 

  133. 

    134. 

  134.         [Documentation("abs(number) -> number\n\nReturn the absolute value of the argument.")]

    135. 

  135.         public static object abs(CodeContext/*!*/ context, object o) {

    136. 

  136.             if (o is int) return Int32Ops.Abs((int)o);

    137. 

  137.             if (o is long) return Int64Ops.Abs((long)o);

    138. 

  138.             if (o is double) return DoubleOps.Abs((double)o);

    139. 

  139.             if (o is bool) return (((bool)o) ? 1 : 0);

    140. 

  140. 

    141. 

  141.             if (o is BigInteger) return BigIntegerOps.__abs__((BigInteger)o);

    142. 

  142.             if (o is Complex) return ComplexOps.Abs((Complex)o);

    143. 

  143. 

    144. 

  144.             object value;

    145. 

  145.             if (PythonTypeOps.TryInvokeUnaryOperator(context, o, "__abs__", out value)) {

    146. 

  146.                 return value;

    147. 

  147.             }

    148. 

  148. 

    149. 

  149.             throw PythonOps.TypeError("bad operand type for abs(): '{0}'", PythonTypeOps.GetName(o));

    150. 

  150.         }

    151. 

  151. 

    152. 

  152.         public static bool all(object x) {

    153. 

  153.             IEnumerator i = PythonOps.GetEnumerator(x);

    154. 

  154.             while (i.MoveNext()) {

    155. 

  155.                 if (!PythonOps.IsTrue(i.Current)) return false;

    156. 

  156.             }

    157. 

  157.             return true;

    158. 

  158.         }

    159. 

  159. 

    160. 

  160.         public static bool any(object x) {

    161. 

  161.             IEnumerator i = PythonOps.GetEnumerator(x);

    162. 

  162.             while (i.MoveNext()) {

    163. 

  163.                 if (PythonOps.IsTrue(i.Current)) return true;

    164. 

  164.             }

    165. 

  165.             return false;

    166. 

  166.         }

    167. 

  167. 

    168. 

  168.         [Documentation("apply(object[, args[, kwargs]]) -> value\n\nDeprecated.\nInstead, use:\n    function(*args, **keywords).")]

    169. 

  169.         public static object apply(CodeContext/*!*/ context, object func) {

    170. 

  170.             return PythonOps.CallWithContext(context, func);

    171. 

  171.         }

    172. 

  172. 

    173. 

  173.         public static object apply(CodeContext/*!*/ context, object func, object args) {

    174. 

  174.             return PythonOps.CallWithArgsTupleAndContext(context, func, ArrayUtils.EmptyObjects, args);

    175. 

  175.         }

    176. 

  176. 

    177. 

  177.         public static object apply(CodeContext/*!*/ context, object func, object args, object kws) {

    178. 

  178.             return context.LanguageContext.CallWithKeywords(func, args, kws);

    179. 

  179.         }

    180. 

  180. 

    181. 

  181.         public static PythonType basestring {

    182. 

  182.             get {

    183. 

  183.                 return DynamicHelpers.GetPythonTypeFromType(typeof(string));

    184. 

  184.             }

    185. 

  185.         }

    186. 

  186. 

    187. 

  187.         public static string bin(int number) {

    188. 

  188.             return Int32Ops.ToBinary(number);

    189. 

  189.         }

    190. 

  190. 

    191. 

  191.         public static string bin(Index number) {

    192. 

  192.             return Int32Ops.ToBinary(Converter.ConvertToIndex(number));

    193. 

  193.         }

    194. 

  194. 

    195. 

  195.         public static string bin(BigInteger number) {

    196. 

  196.             return BigIntegerOps.ToBinary(number);

    197. 

  197.         }

    198. 

  198. 

    199. 

  199.         public static string bin(double number) {

    200. 

  200.             throw PythonOps.TypeError("'float' object cannot be interpreted as an index");

    201. 

  201.         }

    202. 

  202. 

    203. 

  203.         public static PythonType @bool {

    204. 

  204.             get {

    205. 

  205.                 return DynamicHelpers.GetPythonTypeFromType(typeof(bool));

    206. 

  206.             }

    207. 

  207.         }

    208. 

  208. 

    209. 

  209. 

    210. 

  210.         public static PythonType buffer {

    211. 

  211.             get {

    212. 

  212.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonBuffer));

    213. 

  213.             }

    214. 

  214.         }

    215. 

  215. 

    216. 

  216.         public static PythonType bytes {

    217. 

  217.             get {

    218. 

  218.                 return DynamicHelpers.GetPythonTypeFromType(typeof(Bytes));

    219. 

  219.             }

    220. 

  220.         }

    221. 

  221. 

    222. 

  222.         public static PythonType bytearray {

    223. 

  223.             get {

    224. 

  224.                 return DynamicHelpers.GetPythonTypeFromType(typeof(ByteArray));

    225. 

  225.             }

    226. 

  226.         }

    227. 

  227. 

    228. 

  228.         [Documentation("callable(object) -> bool\n\nReturn whether the object is callable (i.e., some kind of function).")]

    229. 

  229.         [Python3Warning("callable() is removed in 3.x. instead call hasattr(obj, '__call__')")]

    230. 

  230.         public static bool callable(CodeContext/*!*/ context, object o) {

    231. 

  231.             return PythonOps.IsCallable(context, o);

    232. 

  232.         }

    233. 

  233. 

    234. 

  234.         [Documentation("chr(i) -> character\n\nReturn a string of one character with ordinal i; 0 <= i< 256.")]

    235. 

  235.         [LightThrowing]

    236. 

  236.         public static object chr(int value) {

    237. 

  237.             if (value < 0 || value > 0xFF) {

    238. 

  238.                 return LightExceptions.Throw(PythonOps.ValueError("{0} is not in required range", value));

    239. 

  239.             }

    240. 

  240.             return ScriptingRuntimeHelpers.CharToString((char)value);

    241. 

  241.         }

    242. 

  242. 

    243. 

  243.         internal static object TryCoerce(CodeContext/*!*/ context, object x, object y) {

    244. 

  244.             PythonTypeSlot pts;

    245. 

  245.             PythonType xType = DynamicHelpers.GetPythonType(x);

    246. 

  246. 

    247. 

  247.             if (xType.TryResolveSlot(context, "__coerce__", out pts)) {

    248. 

  248.                 object callable;

    249. 

  249.                 if (pts.TryGetValue(context, x, xType, out callable)) {

    250. 

  250.                     return PythonCalls.Call(context, callable, y);

    251. 

  251.                 }

    252. 

  252.             }

    253. 

  253.             return NotImplementedType.Value;

    254. 

  254.         }

    255. 

  255. 

    256. 

  256.         [Documentation("coerce(x, y) -> (x1, y1)\n\nReturn a tuple consisting of the two numeric arguments converted to\na common type. If coercion is not possible, raise TypeError.")]

    257. 

  257.         public static object coerce(CodeContext/*!*/ context, object x, object y) {

    258. 

  258.             object converted;

    259. 

  259. 

    260. 

  260.             if (x == null && y == null) {

    261. 

  261.                 return PythonTuple.MakeTuple(null, null);

    262. 

  262.             }

    263. 

  263. 

    264. 

  264.             converted = TryCoerce(context, x, y);

    265. 

  265.             if (converted != null && converted != NotImplementedType.Value) {

    266. 

  266.                 return converted;

    267. 

  267.             }

    268. 

  268. 

    269. 

  269.             converted = TryCoerce(context, y, x);

    270. 

  270.             if (converted != null && converted != NotImplementedType.Value) {

    271. 

  271.                 PythonTuple pt = converted as PythonTuple;

    272. 

  272.                 if (pt != null && pt.Count == 2) {

    273. 

  273.                     return PythonTuple.MakeTuple(pt[1], pt[0]);

    274. 

  274.                 }

    275. 

  275.             }

    276. 

  276. 

    277. 

  277.             throw PythonOps.TypeError("coercion failed");

    278. 

  278.         }

    279. 

  279. 

    280. 

  280.         [Documentation("compile a unit of source code.\n\nThe source can be compiled either as exec, eval, or single.\nexec compiles the code as if it were a file\neval compiles the code as if were an expression\nsingle compiles a single statement\n\n")]

    281. 

  281.         public static object compile(CodeContext/*!*/ context, string source, string filename, string mode, [DefaultParameterValue(null)]object flags, [DefaultParameterValue(null)]object dont_inherit) {

    282. 

  282.             if (source.IndexOf('\0') != -1) {

    283. 

  283.                 throw PythonOps.TypeError("compile() expected string without null bytes");

    284. 

  284.             }

    285. 

  285. 

    286. 

  286.             source = RemoveBom(source);

    287. 

  287. 

    288. 

  288.             bool inheritContext = GetCompilerInheritance(dont_inherit);

    289. 

  289.             CompileFlags cflags = GetCompilerFlags(flags);

    290. 

  290.             PythonCompilerOptions opts = GetRuntimeGeneratedCodeCompilerOptions(context, inheritContext, cflags);

    291. 

  291.             if ((cflags & CompileFlags.CO_DONT_IMPLY_DEDENT) != 0) {

    292. 

  292.                 opts.DontImplyDedent = true;

    293. 

  293.             }

    294. 

  294. 

    295. 

  295.             SourceUnit sourceUnit;

    296. 

  296.             string unitPath = String.IsNullOrEmpty(filename) ? null : filename;

    297. 

  297. 

    298. 

  298.             switch (mode) {

    299. 

  299.                 case "exec": sourceUnit = context.LanguageContext.CreateSnippet(source, filename, SourceCodeKind.Statements); break;

    300. 

  300.                 case "eval": sourceUnit = context.LanguageContext.CreateSnippet(source, filename, SourceCodeKind.Expression); break;

    301. 

  301.                 case "single": sourceUnit = context.LanguageContext.CreateSnippet(source, filename, SourceCodeKind.InteractiveCode); break;

    302. 

  302.                 default:

    303. 

  303.                     throw PythonOps.ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'");

    304. 

  304.             }

    305. 

  305. 

    306. 

  306.             return FunctionCode.FromSourceUnit(sourceUnit, opts, true);

    307. 

  307.         }

    308. 

  308. 

    309. 

  309.         private static string RemoveBom(string source) {

    310. 

  310.             // skip BOM (TODO: this is ugly workaround that is in fact not strictly correct, we need binary strings to handle it correctly)

    311. 

  311.             if (source.StartsWith("\u00ef\u00bb\u00bf", StringComparison.Ordinal)) {

    312. 

  312.                 source = source.Substring(3, source.Length - 3);

    313. 

  313.             }

    314. 

  314.             return source;

    315. 

  315.         }

    316. 

  316. 

    317. 

  317.         public static PythonType classmethod {

    318. 

  318.             get {

    319. 

  319.                 return DynamicHelpers.GetPythonTypeFromType(typeof(classmethod));

    320. 

  320.             }

    321. 

  321.         }

    322. 

  322. 

    323. 

  323.         public static int cmp(CodeContext/*!*/ context, object x, object y) {

    324. 

  324.             return PythonOps.Compare(context, x, y);

    325. 

  325.         }

    326. 

  326. 

    327. 

  327.         // having a cmp overload for double would be nice, but it breaks:

    328. 

  328.         // x = 1e66666

    329. 

  329.         // y = x/x

    330. 

  330.         // cmp(y,y)

    331. 

  331.         // which returns 0 because id(y) == id(y).  If we added a double overload

    332. 

  332.         // we lose object identity.

    333. 

  333. 

    334. 

  334.         public static int cmp(CodeContext/*!*/ context, int x, int y) {

    335. 

  335.             return Int32Ops.Compare(x, y);

    336. 

  336.         }

    337. 

  337. 

    338. 

  338.         public static int cmp(CodeContext/*!*/ context, [NotNull]BigInteger x, [NotNull]BigInteger y) {

    339. 

  339.             if ((object)x == (object)y) {

    340. 

  340.                 return 0;

    341. 

  341.             }

    342. 

  342.             return BigIntegerOps.Compare(x, y);

    343. 

  343.         }

    344. 

  344. 

    345. 

  345.         public static int cmp(CodeContext/*!*/ context, double x, [NotNull]BigInteger y) {

    346. 

  346.             return -BigIntegerOps.Compare(y, x);

    347. 

  347.         }

    348. 

  348. 

    349. 

  349.         public static int cmp(CodeContext/*!*/ context, [NotNull]BigInteger x, double y) {

    350. 

  350.             return BigIntegerOps.Compare(x, y);

    351. 

  351.         }

    352. 

  352. 

    353. 

  353.         public static int cmp(CodeContext/*!*/ context, [NotNull]string x, [NotNull]string y) {

    354. 

  354.             if ((object)x != (object)y) {

    355. 

  355.                 int res = string.CompareOrdinal(x, y);

    356. 

  356.                 if (res >= 1) {

    357. 

  357.                     return 1;

    358. 

  358.                 } else if (res <= -1) {

    359. 

  359.                     return -1;

    360. 

  360.                 }

    361. 

  361.             }

    362. 

  362. 

    363. 

  363.             return 0;

    364. 

  364.         }

    365. 

  365. 

    366. 

  366.         public static int cmp(CodeContext/*!*/ context, [NotNull]PythonTuple x, [NotNull]PythonTuple y) {

    367. 

  367.             if ((object)x == (object)y) {

    368. 

  368.                 return 0;

    369. 

  369.             }

    370. 

  370.             return x.CompareTo(y);

    371. 

  371.         }

    372. 

  372. 

    373. 

  373.         public static PythonType complex {

    374. 

  374.             get {

    375. 

  375.                 return DynamicHelpers.GetPythonTypeFromType(typeof(Complex));

    376. 

  376.             }

    377. 

  377.         }

    378. 

  378. 

    379. 

  379.         public static void delattr(CodeContext/*!*/ context, object o, string name) {

    380. 

  380.             PythonOps.DeleteAttr(context, o, name);

    381. 

  381.         }

    382. 

  382. 

    383. 

  383.         public static PythonType dict {

    384. 

  384.             get {

    385. 

  385.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonDictionary));

    386. 

  386.             }

    387. 

  387.         }

    388. 

  388. 

    389. 

  389.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]

    390. 

  390.         public static List dir(CodeContext/*!*/ context) {

    391. 

  391.             List res = PythonOps.MakeListFromSequence(context.Dict.Keys);

    392. 

  392. 

    393. 

  393.             res.sort(context);

    394. 

  394.             return res;

    395. 

  395.         }

    396. 

  396. 

    397. 

  397.         public static List dir(CodeContext/*!*/ context, object o) {

    398. 

  398.             IList<object> ret = PythonOps.GetAttrNames(context, o);

    399. 

  399.             List lret = new List(ret);

    400. 

  400.             lret.sort(context);

    401. 

  401.             return lret;

    402. 

  402.         }

    403. 

  403. 

    404. 

  404.         public static object divmod(CodeContext/*!*/ context, object x, object y) {

    405. 

  405.             Debug.Assert(NotImplementedType.Value != null);

    406. 

  406. 

    407. 

  407.             return PythonContext.GetContext(context).DivMod(x, y);

    408. 

  408.         }

    409. 

  409. 

    410. 

  410.         public static PythonType enumerate {

    411. 

  411.             get {

    412. 

  412.                 return DynamicHelpers.GetPythonTypeFromType(typeof(Enumerate));

    413. 

  413.             }

    414. 

  414.         }

    415. 

  415. 

    416. 

  416.         public static object eval(CodeContext/*!*/ context, FunctionCode code) {

    417. 

  417.             Debug.Assert(context != null);

    418. 

  418.             if (code == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    419. 

  419. 

    420. 

  420.             return eval(context, code, null);

    421. 

  421.         }

    422. 

  422. 

    423. 

  423.         public static object eval(CodeContext/*!*/ context, FunctionCode code, PythonDictionary globals) {

    424. 

  424.             Debug.Assert(context != null);

    425. 

  425.             if (code == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    426. 

  426. 

    427. 

  427.             return eval(context, code, globals, globals);

    428. 

  428.         }

    429. 

  429. 

    430. 

  430.         public static object eval(CodeContext/*!*/ context, FunctionCode code, PythonDictionary globals, object locals) {

    431. 

  431.             Debug.Assert(context != null);

    432. 

  432.             if (code == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    433. 

  433. 

    434. 

  434.             return code.Call(GetExecEvalScopeOptional(context, globals, locals, false));

    435. 

  435.         }

    436. 

  436. 

    437. 

  437.         internal static PythonDictionary GetAttrLocals(CodeContext/*!*/ context, object locals) {

    438. 

  438.             PythonDictionary attrLocals = null;

    439. 

  439.             if (locals == null) {

    440. 

  440.                 if (context.IsTopLevel) {

    441. 

  441.                     attrLocals = context.Dict;

    442. 

  442.                 }

    443. 

  443.             } else {

    444. 

  444.                 attrLocals = locals as PythonDictionary ?? new PythonDictionary(new ObjectAttributesAdapter(context, locals));

    445. 

  445.             }

    446. 

  446.             return attrLocals;

    447. 

  447.         }

    448. 

  448. 

    449. 

  449.         [LightThrowing]

    450. 

  450.         public static object eval(CodeContext/*!*/ context, string expression) {

    451. 

  451.             Debug.Assert(context != null);

    452. 

  452.             if (expression == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    453. 

  453. 

    454. 

  454.             return eval(context, expression, globals(context), locals(context));

    455. 

  455.         }

    456. 

  456. 

    457. 

  457.         [LightThrowing]

    458. 

  458.         public static object eval(CodeContext/*!*/ context, string expression, PythonDictionary globals) {

    459. 

  459.             Debug.Assert(context != null);

    460. 

  460.             if (expression == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    461. 

  461. 

    462. 

  462.             return eval(context, expression, globals, globals);

    463. 

  463.         }

    464. 

  464. 

    465. 

  465.         [LightThrowing]

    466. 

  466.         public static object eval(CodeContext/*!*/ context, string expression, PythonDictionary globals, object locals) {

    467. 

  467.             Debug.Assert(context != null);

    468. 

  468.             if (expression == null) throw PythonOps.TypeError("eval() argument 1 must be string or code object");

    469. 

  469. 

    470. 

  470.             if (locals != null && PythonOps.IsMappingType(context, locals) == ScriptingRuntimeHelpers.False) {

    471. 

  471.                 throw PythonOps.TypeError("locals must be mapping");

    472. 

  472.             }

    473. 

  473. 

    474. 

  474.             expression = RemoveBom(expression);

    475. 

  475.             var scope = GetExecEvalScopeOptional(context, globals, locals, false);

    476. 

  476.             var pythonContext = PythonContext.GetContext(context);

    477. 

  477. 

    478. 

  478.             // TODO: remove TrimStart

    479. 

  479.             var sourceUnit = pythonContext.CreateSnippet(expression.TrimStart(' ', '\t'), SourceCodeKind.Expression);

    480. 

  480.             var compilerOptions = GetRuntimeGeneratedCodeCompilerOptions(context, true, 0);

    481. 

  481.             compilerOptions.Module |= ModuleOptions.LightThrow;

    482. 

  482.             compilerOptions.Module &= ~ModuleOptions.ModuleBuiltins;

    483. 

  483.             var code = FunctionCode.FromSourceUnit(sourceUnit, compilerOptions, false);

    484. 

  484. 

    485. 

  485.             return code.Call(scope);

    486. 

  486.         }

    487. 

  487. 

    488. 

  488.         public static void execfile(CodeContext/*!*/ context, object/*!*/ filename) {

    489. 

  489.             execfile(context, filename, null, null);

    490. 

  490.         }

    491. 

  491. 

    492. 

  492.         public static void execfile(CodeContext/*!*/ context, object/*!*/ filename, object globals) {

    493. 

  493.             execfile(context, filename, globals, null);

    494. 

  494.         }

    495. 

  495. 

    496. 

  496.         public static void execfile(CodeContext/*!*/ context, object/*!*/ filename, object globals, object locals) {

    497. 

  497.             if (filename == null) {

    498. 

  498.                 throw PythonOps.TypeError("execfile() argument 1 must be string, not None");

    499. 

  499.             }

    500. 

  500.             

    501. 

  501.             PythonDictionary g = globals as PythonDictionary;

    502. 

  502.             if (g == null && globals != null) {

    503. 

  503.                 throw PythonOps.TypeError("execfile() arg 2 must be dictionary");

    504. 

  504.             }

    505. 

  505. 

    506. 

  506.             PythonDictionary l = locals as PythonDictionary;

    507. 

  507.             if (l == null && locals != null) {

    508. 

  508.                 throw PythonOps.TypeError("execfile() arg 3 must be dictionary");

    509. 

  509.             }

    510. 

  510. 

    511. 

  511.             if (l == null) {

    512. 

  512.                 l = g;

    513. 

  513.             }

    514. 

  514. 

    515. 

  515.             var execScope = GetExecEvalScopeOptional(context, g, l, true);

    516. 

  516.             string path = Converter.ConvertToString(filename);

    517. 

  517.             PythonContext pc = PythonContext.GetContext(context);

    518. 

  518.             if (!pc.DomainManager.Platform.FileExists(path)) {

    519. 

  519.                 throw PythonOps.IOError("execfile: specified file doesn't exist");

    520. 

  520.             }

    521. 

  521. 

    522. 

  522.             SourceUnit sourceUnit = pc.CreateFileUnit(path, pc.DefaultEncoding, SourceCodeKind.Statements);

    523. 

  523.             FunctionCode code;

    524. 

  524. 

    525. 

  525.             var options = GetRuntimeGeneratedCodeCompilerOptions(context, true, 0);

    526. 

  526.             //always generate an unoptimized module since we run these against a dictionary namespace

    527. 

  527.             options.Module &= ~ModuleOptions.Optimized;

    528. 

  528. 

    529. 

  529.             try {

    530. 

  530.                 code = FunctionCode.FromSourceUnit(sourceUnit, options, false);

    531. 

  531.             } catch (UnauthorizedAccessException x) {

    532. 

  532.                 throw PythonOps.IOError(x);

    533. 

  533.             }

    534. 

  534. 

    535. 

  535.             // Do not attempt evaluation mode for execfile

    536. 

  536.             code.Call(execScope);

    537. 

  537.         }

    538. 

  538. 

    539. 

  539.         public static PythonType file {

    540. 

  540.             get {

    541. 

  541.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonFile));

    542. 

  542.             }

    543. 

  543.         }

    544. 

  544. 

    545. 

  545.         public static string filter(CodeContext/*!*/ context, object function, [NotNull]string list) {

    546. 

  546.             if (function == null) return list;

    547. 

  547.             if (list == null) throw PythonOps.TypeError("NoneType is not iterable");

    548. 

  548. 

    549. 

  549.             StringBuilder sb = new StringBuilder();

    550. 

  550.             foreach (char c in list) {

    551. 

  551.                 if (PythonOps.IsTrue(PythonCalls.Call(context, function, ScriptingRuntimeHelpers.CharToString(c)))) sb.Append(c);

    552. 

  552.             }

    553. 

  553. 

    554. 

  554.             return sb.ToString();

    555. 

  555.         }

    556. 

  556. 

    557. 

  557.         public static string filter(CodeContext/*!*/ context, object function, [NotNull]ExtensibleString list) {

    558. 

  558.             StringBuilder sb = new StringBuilder();

    559. 

  559.             IEnumerator e = PythonOps.GetEnumerator(list);

    560. 

  560.             while (e.MoveNext()) {

    561. 

  561.                 object o = e.Current;

    562. 

  562.                 object t = (function != null) ? PythonCalls.Call(context, function, o) : o;

    563. 

  563. 

    564. 

  564.                 if (PythonOps.IsTrue(t)) {

    565. 

  565.                     sb.Append(Converter.ConvertToString(o));

    566. 

  566.                 }

    567. 

  567.             }

    568. 

  568.             return sb.ToString();

    569. 

  569.         }

    570. 

  570. 

    571. 

  571.         /// <summary>

    572. 

  572.         /// Specialized version because enumerating tuples by Python's definition

    573. 

  573.         /// doesn't call __getitem__, but filter does!

    574. 

  574.         /// </summary>

    575. 

  575.         public static PythonTuple filter(CodeContext/*!*/ context, object function, [NotNull]PythonTuple tuple) {

    576. 

  576.             List<object> res = new List<object>(tuple.__len__());

    577. 

  577. 

    578. 

  578.             for (int i = 0; i < tuple.__len__(); i++) {

    579. 

  579.                 object obj = tuple[i];

    580. 

  580.                 object t = (function != null) ? PythonCalls.Call(context, function, obj) : obj;

    581. 

  581. 

    582. 

  582.                 if (PythonOps.IsTrue(t)) {

    583. 

  583.                     res.Add(obj);

    584. 

  584.                 }

    585. 

  585.             }

    586. 

  586. 

    587. 

  587.             return PythonTuple.MakeTuple(res.ToArray());

    588. 

  588.         }

    589. 

  589. 

    590. 

  590.         public static List filter(CodeContext/*!*/ context, object function, object list) {

    591. 

  591.             if (list == null) throw PythonOps.TypeError("NoneType is not iterable");

    592. 

  592.             List ret = new List();

    593. 

  593. 

    594. 

  594.             IEnumerator i = PythonOps.GetEnumerator(list);

    595. 

  595.             while (i.MoveNext()) {

    596. 

  596.                 if (function == null) {

    597. 

  597.                     if (PythonOps.IsTrue(i.Current)) ret.AddNoLock(i.Current);

    598. 

  598.                 } else {

    599. 

  599.                     if (PythonOps.IsTrue(PythonCalls.Call(context, function, i.Current))) ret.AddNoLock(i.Current);

    600. 

  600.                 }

    601. 

  601.             }

    602. 

  602. 

    603. 

  603.             return ret;

    604. 

  604.         }

    605. 

  605. 

    606. 

  606.         public static PythonType @float {

    607. 

  607.             get {

    608. 

  608.                 return DynamicHelpers.GetPythonTypeFromType(typeof(double));

    609. 

  609.             }

    610. 

  610.         }

    611. 

  611. 

    612. 

  612.         public static string format(CodeContext/*!*/ context, object argValue, [DefaultParameterValue("")]string formatSpec) {

    613. 

  613.             object res, formatMethod;

    614. 

  614.             OldInstance oi = argValue as OldInstance;

    615. 

  615.             if (oi != null && oi.TryGetBoundCustomMember(context, "__format__", out formatMethod)) {

    616. 

  616.                 res = PythonOps.CallWithContext(context, formatMethod, formatSpec);

    617. 

  617.             } else {

    618. 

  618.                 // call __format__ with the format spec (__format__ is defined on object, so this always succeeds)

    619. 

  619.                 PythonTypeOps.TryInvokeBinaryOperator(

    620. 

  620.                     context,

    621. 

  621.                     argValue,

    622. 

  622.                     formatSpec,

    623. 

  623.                     "__format__",

    624. 

  624.                     out res);

    625. 

  625.             }

    626. 

  626. 

    627. 

  627.             string strRes = res as string;

    628. 

  628.             if (strRes == null) {

    629. 

  629.                 throw PythonOps.TypeError("{0}.__format__ must return string or unicode, not {1}", PythonTypeOps.GetName(argValue), PythonTypeOps.GetName(res));

    630. 

  630.             }

    631. 

  631. 

    632. 

  632.             return strRes;

    633. 

  633.         }

    634. 

  634. 

    635. 

  635.         public static object getattr(CodeContext/*!*/ context, object o, string name) {

    636. 

  636.             return PythonOps.GetBoundAttr(context, o, name);

    637. 

  637.         }

    638. 

  638. 

    639. 

  639.         public static object getattr(CodeContext/*!*/ context, object o, string name, object def) {

    640. 

  640.             object ret;

    641. 

  641.             if (PythonOps.TryGetBoundAttr(context, o, name, out ret)) return ret;

    642. 

  642.             else return def;

    643. 

  643.         }

    644. 

  644. 

    645. 

  645.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]

    646. 

  646.         public static PythonDictionary globals(CodeContext/*!*/ context) {

    647. 

  647.             return context.ModuleContext.Globals;

    648. 

  648.         }

    649. 

  649. 

    650. 

  650.         public static bool hasattr(CodeContext/*!*/ context, object o, string name) {

    651. 

  651.             return PythonOps.HasAttr(context, o, name);

    652. 

  652.         }

    653. 

  653. 

    654. 

  654.         public static int hash(CodeContext/*!*/ context, object o) {

    655. 

  655.             return PythonContext.Hash(o);

    656. 

  656.         }

    657. 

  657. 

    658. 

  658.         public static int hash(CodeContext/*!*/ context, [NotNull]PythonTuple o) {

    659. 

  659.             return ((IStructuralEquatable)o).GetHashCode(PythonContext.GetContext(context).EqualityComparerNonGeneric);

    660. 

  660.         }

    661. 

  661. 

    662. 

  662.         // this is necessary because overload resolution selects the int form.

    663. 

  663.         public static int hash(CodeContext/*!*/ context, char o) {

    664. 

  664.             return PythonContext.Hash(o);

    665. 

  665.         }

    666. 

  666. 

    667. 

  667.         public static int hash(CodeContext/*!*/ context, int o) {

    668. 

  668.             return o;

    669. 

  669.         }

    670. 

  670. 

    671. 

  671.         public static int hash(CodeContext/*!*/ context, [NotNull]string o) {

    672. 

  672.             return o.GetHashCode();

    673. 

  673.         }

    674. 

  674. 

    675. 

  675.         // this is necessary because overload resolution will coerce extensible strings to strings.

    676. 

  676.         public static int hash(CodeContext/*!*/ context, [NotNull]ExtensibleString o) {

    677. 

  677.             return hash(context, (object)o);

    678. 

  678.         }

    679. 

  679. 

    680. 

  680.         public static int hash(CodeContext/*!*/ context, [NotNull]BigInteger o) {

    681. 

  681.             return BigIntegerOps.__hash__(o);

    682. 

  682.         }

    683. 

  683. 

    684. 

  684.         public static int hash(CodeContext/*!*/ context, [NotNull]Extensible<BigInteger> o) {

    685. 

  685.             return hash(context, (object)o);

    686. 

  686.         }

    687. 

  687. 

    688. 

  688.         public static int hash(CodeContext/*!*/ context, double o) {

    689. 

  689.             return DoubleOps.__hash__(o);

    690. 

  690.         }

    691. 

  691. 

    692. 

  692.         public static void help(CodeContext/*!*/ context, object o) {

    693. 

  693.             StringBuilder doc = new StringBuilder();

    694. 

  694.             List<object> doced = new List<object>();  // document things only once

    695. 

  695. 

    696. 

  696.             help(context, doced, doc, 0, o);

    697. 

  697. 

    698. 

  698.             if (doc.Length == 0) {

    699. 

  699.                 if (!(o is string)) {

    700. 

  700.                     help(context, DynamicHelpers.GetPythonType(o));

    701. 

  701.                     return;

    702. 

  702.                 }

    703. 

  703.                 doc.Append("no documentation found for ");

    704. 

  704.                 doc.Append(PythonOps.Repr(context, o));

    705. 

  705.             }

    706. 

  706. 

    707. 

  707.             string[] strings = doc.ToString().Split('\n');

    708. 

  708.             for (int i = 0; i < strings.Length; i++) {

    709. 

  709.                 /* should read only a key, not a line, but we don't seem

    710. 

  710.                  * to have a way to do that...

    711. 

  711.                 if ((i % Console.WindowHeight) == 0) {

    712. 

  712.                     Ops.Print(context.SystemState, "-- More --");

    713. 

  713.                     Ops.ReadLineFromSrc(context.SystemState);

    714. 

  714.                 }*/

    715. 

  715.                 PythonOps.Print(context, strings[i]);

    716. 

  716.             }

    717. 

  717.         }

    718. 

  718. 

    719. 

  719.         private static void help(CodeContext/*!*/ context, List<object>/*!*/ doced, StringBuilder/*!*/ doc, int indent, object obj) {

    720. 

  720.             PythonType type;

    721. 

  721.             BuiltinFunction builtinFunction;

    722. 

  722.             PythonFunction function;

    723. 

  723.             BuiltinMethodDescriptor methodDesc;

    724. 

  724.             Method method;

    725. 

  725.             string strVal;

    726. 

  726.             PythonModule pyModule;

    727. 

  727.             OldClass oldClass;

    728. 

  728. 

    729. 

  729.             if (doced.Contains(obj)) return;  // document things only once

    730. 

  730.             doced.Add(obj);

    731. 

  731. 

    732. 

  732.             if ((strVal = obj as string) != null) {

    733. 

  733.                 if (indent != 0) return;

    734. 

  734. 

    735. 

  735.                 // try and find things that string could refer to,

    736. 

  736.                 // then call help on them.

    737. 

  737.                 foreach (object module in PythonContext.GetContext(context).SystemStateModules.Values) {

    738. 

  738.                     IList<object> attrs = PythonOps.GetAttrNames(context, module);

    739. 

  739.                     List candidates = new List();

    740. 

  740.                     foreach (string s in attrs) {

    741. 

  741.                         if (s == strVal) {

    742. 

  742.                             object modVal;

    743. 

  743.                             if (!PythonOps.TryGetBoundAttr(context, module, strVal, out modVal))

    744. 

  744.                                 continue;

    745. 

  745. 

    746. 

  746.                             candidates.append(modVal);

    747. 

  747.                         }

    748. 

  748.                     }

    749. 

  749. 

    750. 

  750.                     // favor types, then built-in functions, then python functions,

    751. 

  751.                     // and then only display help for one.

    752. 

  752.                     type = null;

    753. 

  753.                     builtinFunction = null;

    754. 

  754.                     function = null;

    755. 

  755.                     for (int i = 0; i < candidates.__len__(); i++) {

    756. 

  756.                         if ((type = candidates[i] as PythonType) != null) {

    757. 

  757.                             break;

    758. 

  758.                         }

    759. 

  759. 

    760. 

  760.                         if (builtinFunction == null && (builtinFunction = candidates[i] as BuiltinFunction) != null)

    761. 

  761.                             continue;

    762. 

  762. 

    763. 

  763.                         if (function == null && (function = candidates[i] as PythonFunction) != null)

    764. 

  764.                             continue;

    765. 

  765.                     }

    766. 

  766. 

    767. 

  767.                     if (type != null) help(context, doced, doc, indent, type);

    768. 

  768.                     else if (builtinFunction != null) help(context, doced, doc, indent, builtinFunction);

    769. 

  769.                     else if (function != null) help(context, doced, doc, indent, function);

    770. 

  770.                 }

    771. 

  771.             } else if ((type = obj as PythonType) != null) {

    772. 

  772.                 // find all the functions, and display their 

    773. 

  773.                 // documentation                

    774. 

  774.                 if (indent == 0) {

    775. 

  775.                     doc.AppendFormat("Help on {0} in module {1}\n\n", type.Name, PythonOps.GetBoundAttr(context, type, "__module__"));

    776. 

  776.                 }

    777. 

  777. 

    778. 

  778.                 PythonTypeSlot dts;

    779. 

  779.                 if (type.TryResolveSlot(context, "__doc__", out dts)) {

    780. 

  780.                     object docText;

    781. 

  781.                     if (dts.TryGetValue(context, null, type, out docText) && docText != null)

    782. 

  782.                         AppendMultiLine(doc, docText.ToString() + Environment.NewLine, indent);

    783. 

  783.                     AppendIndent(doc, indent);

    784. 

  784.                     doc.AppendLine("Data and other attributes defined here:");

    785. 

  785.                     AppendIndent(doc, indent);

    786. 

  786.                     doc.AppendLine();

    787. 

  787.                 }

    788. 

  788. 

    789. 

  789.                 List names = type.GetMemberNames(context);

    790. 

  790.                 names.sort(context);

    791. 

  791. 

    792. 

  792.                 foreach (string name in names) {

    793. 

  793.                     if (name == "__class__") continue;

    794. 

  794. 

    795. 

  795.                     PythonTypeSlot value;

    796. 

  796.                     object val;

    797. 

  797.                     if (type.TryLookupSlot(context, name, out value) &&

    798. 

  798.                         value.TryGetValue(context, null, type, out val)) {

    799. 

  799.                         help(context, doced, doc, indent + 1, val);

    800. 

  800.                     }

    801. 

  801.                 }

    802. 

  802.             } else if ((methodDesc = obj as BuiltinMethodDescriptor) != null) {

    803. 

  803.                 if (indent == 0) doc.AppendFormat("Help on method-descriptor {0}\n\n", methodDesc.__name__);

    804. 

  804.                 AppendIndent(doc, indent);

    805. 

  805.                 doc.Append(methodDesc.__name__);

    806. 

  806.                 doc.Append("(...)\n");

    807. 

  807. 

    808. 

  808.                 AppendMultiLine(doc, methodDesc.__doc__, indent + 1);

    809. 

  809.             } else if ((builtinFunction = obj as BuiltinFunction) != null) {

    810. 

  810.                 if (indent == 0) doc.AppendFormat("Help on built-in function {0}\n\n", builtinFunction.Name);

    811. 

  811.                 AppendIndent(doc, indent);

    812. 

  812.                 doc.Append(builtinFunction.Name);

    813. 

  813.                 doc.Append("(...)\n");

    814. 

  814. 

    815. 

  815.                 AppendMultiLine(doc, builtinFunction.__doc__, indent + 1);

    816. 

  816.             } else if ((function = obj as PythonFunction) != null) {

    817. 

  817.                 if (indent == 0) doc.AppendFormat("Help on function {0} in module {1}:\n\n", function.__name__, function.__module__);

    818. 

  818. 

    819. 

  819.                 AppendIndent(doc, indent);

    820. 

  820.                 doc.Append(function.GetSignatureString());

    821. 

  821.                 string pfDoc = Converter.ConvertToString(function.__doc__);

    822. 

  822.                 if (!String.IsNullOrEmpty(pfDoc)) {

    823. 

  823.                     AppendMultiLine(doc, pfDoc, indent);

    824. 

  824.                 }

    825. 

  825.             } else if ((method = obj as Method) != null && ((function = method.im_func as PythonFunction) != null)) {

    826. 

  826.                 if (indent == 0) doc.AppendFormat("Help on method {0} in module {1}:\n\n", function.__name__, function.__module__);

    827. 

  827. 

    828. 

  828.                 AppendIndent(doc, indent);

    829. 

  829.                 doc.Append(function.GetSignatureString());

    830. 

  830. 

    831. 

  831.                 if (method.im_self == null) {

    832. 

  832.                     doc.AppendFormat(" unbound {0} method\n", PythonOps.ToString(method.im_class));

    833. 

  833.                 } else {

    834. 

  834.                     doc.AppendFormat(" method of {0} instance\n", PythonOps.ToString(method.im_class));

    835. 

  835.                 }

    836. 

  836. 

    837. 

  837.                 string pfDoc = Converter.ConvertToString(function.__doc__);

    838. 

  838.                 if (!String.IsNullOrEmpty(pfDoc)) {

    839. 

  839.                     AppendMultiLine(doc, pfDoc, indent);

    840. 

  840.                 }

    841. 

  841.             } else if ((pyModule = obj as PythonModule) != null) {

    842. 

  842.                 foreach (string name in pyModule.__dict__.Keys) {

    843. 

  843.                     if (name == "__class__" || name == "__builtins__") continue;

    844. 

  844. 

    845. 

  845.                     object value;

    846. 

  846.                     if (pyModule.__dict__.TryGetValue(name, out value)) {

    847. 

  847.                         help(context, doced, doc, indent + 1, value);

    848. 

  848.                     }

    849. 

  849.                 }

    850. 

  850.             } else if ((oldClass = obj as OldClass) != null) {

    851. 

  851.                 if (indent == 0) {

    852. 

  852.                     doc.AppendFormat("Help on {0} in module {1}\n\n", oldClass.Name, PythonOps.GetBoundAttr(context, oldClass, "__module__"));

    853. 

  853.                 }

    854. 

  854. 

    855. 

  855.                 object docText;

    856. 

  856.                 if (oldClass.TryLookupSlot("__doc__", out docText) && docText != null) {

    857. 

  857.                     AppendMultiLine(doc, docText.ToString() + Environment.NewLine, indent);

    858. 

  858.                     AppendIndent(doc, indent);

    859. 

  859.                     doc.AppendLine("Data and other attributes defined here:");

    860. 

  860.                     AppendIndent(doc, indent);

    861. 

  861.                     doc.AppendLine();

    862. 

  862.                 }

    863. 

  863. 

    864. 

  864.                 IList<object> names = ((IPythonMembersList)oldClass).GetMemberNames(context);

    865. 

  865.                 List sortNames = new List(names);

    866. 

  866.                 sortNames.sort(context);

    867. 

  867.                 names = sortNames;

    868. 

  868.                 foreach (string name in names) {

    869. 

  869.                     if (name == "__class__") continue;

    870. 

  870. 

    871. 

  871.                     object value;

    872. 

  872. 

    873. 

  873.                     if (oldClass.TryLookupSlot(name, out value))

    874. 

  874.                         help(context, doced, doc, indent + 1, value);

    875. 

  875.                 }

    876. 

  876.             }

    877. 

  877.         }

    878. 

  878. 

    879. 

  879.         private static void AppendMultiLine(StringBuilder doc, string multiline, int indent) {

    880. 

  880.             string[] docs = multiline.Split('\n');

    881. 

  881.             for (int i = 0; i < docs.Length; i++) {

    882. 

  882.                 AppendIndent(doc, indent + 1);

    883. 

  883.                 doc.Append(docs[i]);

    884. 

  884.                 doc.Append('\n');

    885. 

  885.             }

    886. 

  886.         }

    887. 

  887. 

    888. 

  888.         private static void AppendIndent(StringBuilder doc, int indent) {

    889. 

  889.             doc.Append(" |  ");

    890. 

  890.             for (int i = 0; i < indent; i++) doc.Append("    ");

    891. 

  891.         }

    892. 

  892. 

    893. 

  893.         //??? type this to string

    894. 

  894.         public static object hex(object o) {

    895. 

  895.             return PythonOps.Hex(o);

    896. 

  896.         }

    897. 

  897. 

    898. 

  898.         public static object id(object o) {

    899. 

  899.             long res = PythonOps.Id(o);

    900. 

  900.             if (PythonOps.Id(o) <= Int32.MaxValue) {

    901. 

  901.                 return (int)res;

    902. 

  902.             }

    903. 

  903.             return (BigInteger)res;

    904. 

  904.         }

    905. 

  905. 

    906. 

  906.         [LightThrowing]

    907. 

  907.         public static object input(CodeContext/*!*/ context) {

    908. 

  908.             return input(context, null);

    909. 

  909.         }

    910. 

  910. 

    911. 

  911.         [LightThrowing]

    912. 

  912.         public static object input(CodeContext/*!*/ context, object prompt) {

    913. 

  913.             return eval(context, raw_input(context, prompt));

    914. 

  914.         }

    915. 

  915. 

    916. 

  916.         public static PythonType @int {

    917. 

  917.             get {

    918. 

  918.                 return DynamicHelpers.GetPythonTypeFromType(typeof(int));

    919. 

  919.             }

    920. 

  920.         }

    921. 

  921. 

    922. 

  922.         public static string intern(object o) {

    923. 

  923.             string s = o as string;

    924. 

  924.             if (s == null) {

    925. 

  925.                 throw PythonOps.TypeError("intern: argument must be string");

    926. 

  926.             }

    927. 

  927.             return string.Intern(s);

    928. 

  928.         }

    929. 

  929. 

    930. 

  930.         public static bool isinstance(object o, [NotNull]PythonType typeinfo) {

    931. 

  931.             return PythonOps.IsInstance(o, typeinfo);

    932. 

  932.         }

    933. 

  933. 

    934. 

  934.         public static bool isinstance(CodeContext context, object o, [NotNull]PythonTuple typeinfo) {

    935. 

  935.             return PythonOps.IsInstance(context, o, typeinfo);

    936. 

  936.         }

    937. 

  937. 

    938. 

  938.         public static bool isinstance(CodeContext context, object o, object typeinfo) {

    939. 

  939.             return PythonOps.IsInstance(context, o, typeinfo);

    940. 

  940.         }

    941. 

  941. 

    942. 

  942.         public static bool issubclass(CodeContext context, [NotNull]OldClass c, object typeinfo) {

    943. 

  943.             return PythonOps.IsSubClass(context, c.TypeObject, typeinfo);

    944. 

  944.         }

    945. 

  945. 

    946. 

  946.         public static bool issubclass(CodeContext context, [NotNull]PythonType c, object typeinfo) {

    947. 

  947.             return PythonOps.IsSubClass(context, c, typeinfo);

    948. 

  948.         }

    949. 

  949. 

    950. 

  950.         public static bool issubclass(CodeContext context, [NotNull]PythonType c, [NotNull]PythonType typeinfo) {

    951. 

  951.             return PythonOps.IsSubClass(c, typeinfo);

    952. 

  952.         }

    953. 

  953. 

    954. 

  954.         [LightThrowing]

    955. 

  955.         public static object issubclass(CodeContext/*!*/ context, object o, object typeinfo) {

    956. 

  956.             PythonTuple pt = typeinfo as PythonTuple;

    957. 

  957.             if (pt != null) {

    958. 

  958.                 // Recursively inspect nested tuple(s)

    959. 

  959.                 foreach (object subTypeInfo in pt) {

    960. 

  960.                     try {

    961. 

  961.                         PythonOps.FunctionPushFrame(PythonContext.GetContext(context));

    962. 

  962.                         var res = issubclass(context, o, subTypeInfo);

    963. 

  963.                         if (res == ScriptingRuntimeHelpers.True) {

    964. 

  964.                             return ScriptingRuntimeHelpers.True;

    965. 

  965.                         } else if (LightExceptions.IsLightException(res)) {

    966. 

  966.                             return res;

    967. 

  967.                         }

    968. 

  968.                     } finally {

    969. 

  969.                         PythonOps.FunctionPopFrame();

    970. 

  970.                     }

    971. 

  971.                 }

    972. 

  972.                 return ScriptingRuntimeHelpers.False;

    973. 

  973.             }

    974. 

  974. 

    975. 

  975.             object bases;

    976. 

  976.             PythonTuple tupleBases;

    977. 

  977. 

    978. 

  978.             if (!PythonOps.TryGetBoundAttr(o, "__bases__", out bases) || (tupleBases = bases as PythonTuple) == null) {

    979. 

  979.                 return LightExceptions.Throw(PythonOps.TypeError("issubclass() arg 1 must be a class"));

    980. 

  980.             }

    981. 

  981. 

    982. 

  982.             if (o == typeinfo) {

    983. 

  983.                 return ScriptingRuntimeHelpers.True;

    984. 

  984.             }

    985. 

  985.             foreach (object baseCls in tupleBases) {

    986. 

  986.                 PythonType pyType;

    987. 

  987.                 OldClass oc;

    988. 

  988. 

    989. 

  989.                 if (baseCls == typeinfo) {

    990. 

  990.                     return ScriptingRuntimeHelpers.True;

    991. 

  991.                 } else if ((pyType = baseCls as PythonType) != null) {

    992. 

  992.                     if (issubclass(context, pyType, typeinfo)) {

    993. 

  993.                         return ScriptingRuntimeHelpers.True;

    994. 

  994.                     }

    995. 

  995.                 } else if ((oc = baseCls as OldClass) != null) {

    996. 

  996.                     if (issubclass(context, oc, typeinfo)) {

    997. 

  997.                         return ScriptingRuntimeHelpers.True;

    998. 

  998.                     }

    999. 

  999.                 } else if (hasattr(context, baseCls, "__bases__")) {

    1000. 

  1000.                     var res = issubclass(context, baseCls, typeinfo);

    1001. 

  1001.                     if (res == ScriptingRuntimeHelpers.True) {

    1002. 

  1002.                         return ScriptingRuntimeHelpers.True;

    1003. 

  1003.                     } else if (LightExceptions.IsLightException(res)) {

    1004. 

  1004.                         return res;

    1005. 

  1005.                     }

    1006. 

  1006.                 }

    1007. 

  1007.             }

    1008. 

  1008. 

    1009. 

  1009.             return ScriptingRuntimeHelpers.False;

    1010. 

  1010.         }

    1011. 

  1011. 

    1012. 

  1012.         public static object iter(CodeContext/*!*/ context, object o) {

    1013. 

  1013.             return PythonOps.GetEnumeratorObject(context, o);

    1014. 

  1014.         }

    1015. 

  1015. 

    1016. 

  1016.         public static object iter(CodeContext/*!*/ context, object func, object sentinel) {

    1017. 

  1017.             if (!PythonOps.IsCallable(context, func)) {

    1018. 

  1018.                 throw PythonOps.TypeError("iter(v, w): v must be callable");

    1019. 

  1019.             }

    1020. 

  1020.             return new SentinelIterator(context, func, sentinel);

    1021. 

  1021.         }

    1022. 

  1022. 

    1023. 

  1023.         public static int len([NotNull]string/*!*/ str) {

    1024. 

  1024.             return str.Length;

    1025. 

  1025.         }

    1026. 

  1026. 

    1027. 

  1027.         public static int len([NotNull]ExtensibleString/*!*/ str) {

    1028. 

  1028.             return str.__len__();

    1029. 

  1029.         }

    1030. 

  1030. 

    1031. 

  1031.         public static int len([NotNull]List/*!*/ list) {

    1032. 

  1032.             return list.__len__();

    1033. 

  1033.         }

    1034. 

  1034. 

    1035. 

  1035.         public static int len([NotNull]PythonTuple/*!*/ tuple) {

    1036. 

  1036.             return tuple.__len__();

    1037. 

  1037.         }

    1038. 

  1038. 

    1039. 

  1039.         public static int len([NotNull]PythonDictionary/*!*/ dict) {

    1040. 

  1040.             return dict.__len__();

    1041. 

  1041.         }

    1042. 

  1042. 

    1043. 

  1043.         public static int len([NotNull]ICollection/*!*/ collection) {

    1044. 

  1044.             return collection.Count;

    1045. 

  1045.         }

    1046. 

  1046. 

    1047. 

  1047.         public static int len(object o) {

    1048. 

  1048.             return PythonOps.Length(o);

    1049. 

  1049.         }

    1050. 

  1050. 

    1051. 

  1051.         public static PythonType set {

    1052. 

  1052.             get {

    1053. 

  1053.                 return DynamicHelpers.GetPythonTypeFromType(typeof(SetCollection));

    1054. 

  1054.             }

    1055. 

  1055.         }

    1056. 

  1056. 

    1057. 

  1057.         public static PythonType frozenset {

    1058. 

  1058.             get {

    1059. 

  1059.                 return DynamicHelpers.GetPythonTypeFromType(typeof(FrozenSetCollection));

    1060. 

  1060.             }

    1061. 

  1061.         }

    1062. 

  1062. 

    1063. 

  1063.         public static PythonType list {

    1064. 

  1064.             get {

    1065. 

  1065.                 return DynamicHelpers.GetPythonTypeFromType(typeof(List));

    1066. 

  1066.             }

    1067. 

  1067.         }

    1068. 

  1068. 

    1069. 

  1069.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]

    1070. 

  1070.         public static object locals(CodeContext/*!*/ context) {

    1071. 

  1071.             PythonDictionary dict = context.Dict;

    1072. 

  1072.             ObjectAttributesAdapter adapter = dict._storage as ObjectAttributesAdapter;

    1073. 

  1073.             if (adapter != null) {

    1074. 

  1074.                 // we've wrapped Locals in an PythonDictionary, give the user back the

    1075. 

  1075.                 // original object.

    1076. 

  1076.                 return adapter.Backing;

    1077. 

  1077.             }

    1078. 

  1078. 

    1079. 

  1079.             return context.Dict;

    1080. 

  1080.         }

    1081. 

  1081. 

    1082. 

  1082.         public static PythonType @long {

    1083. 

  1083.             get {

    1084. 

  1084.                 return TypeCache.BigInteger;

    1085. 

  1085.             }

    1086. 

  1086.         }

    1087. 

  1087. 

    1088. 

  1088.         public static PythonType memoryview {

    1089. 

  1089.             get {

    1090. 

  1090.                 return DynamicHelpers.GetPythonTypeFromType(typeof(MemoryView));

    1091. 

  1091.             }

    1092. 

  1092.         }

    1093. 

  1093. 

    1094. 

  1094.         private static CallSite<Func<CallSite, CodeContext, T, T1, object>> MakeMapSite<T, T1>(CodeContext/*!*/ context) {

    1095. 

  1095.             return CallSite<Func<CallSite, CodeContext, T, T1, object>>.Create(

    1096. 

  1096.                 PythonContext.GetContext(context).InvokeOne

    1097. 

  1097.             );

    1098. 

  1098.         }

    1099. 

  1099. 

    1100. 

  1100.         public static List map(CodeContext/*!*/ context, object func, [NotNull]IEnumerable enumerator) {

    1101. 

  1101.             IEnumerator en = PythonOps.GetEnumerator(enumerator);

    1102. 

  1102.             

    1103. 

  1103.             List ret = new List();            

    1104. 

  1104.             CallSite<Func<CallSite, CodeContext, object, object, object>> mapSite = null;

    1105. 

  1105. 

    1106. 

  1106.             if (func != null) {

    1107. 

  1107.                 mapSite = MakeMapSite<object, object>(context);

    1108. 

  1108.             }

    1109. 

  1109. 

    1110. 

  1110.             while (en.MoveNext()) {

    1111. 

  1111.                 if (func == null) {

    1112. 

  1112.                     ret.AddNoLock(en.Current);

    1113. 

  1113.                 } else {

    1114. 

  1114.                     ret.AddNoLock(mapSite.Target(mapSite, context, func, en.Current));

    1115. 

  1115.                 }

    1116. 

  1116.             }

    1117. 

  1117.         

    1118. 

  1118.             return ret;

    1119. 

  1119.         }

    1120. 

  1120. 

    1121. 

  1121.         public static List map(

    1122. 

  1122.             CodeContext/*!*/ context,

    1123. 

  1123.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, object, object, object>>> storage,

    1124. 

  1124.             object func,

    1125. 

  1125.             [NotNull]string enumerator

    1126. 

  1126.         ) {

    1127. 

  1127.             CallSite<Func<CallSite, CodeContext, object, object, object>> mapSite;

    1128. 

  1128.             if (storage.Data == null && func != null) {

    1129. 

  1129.                 storage.Data = MakeMapSite<object, object>(context);

    1130. 

  1130.             }

    1131. 

  1131.             mapSite = storage.Data;

    1132. 

  1132. 

    1133. 

  1133.             List ret = new List(enumerator.Length);

    1134. 

  1134.             foreach (char o in enumerator) {

    1135. 

  1135.                 if (func == null) {

    1136. 

  1136.                     ret.AddNoLock(ScriptingRuntimeHelpers.CharToString(o));

    1137. 

  1137.                 } else {

    1138. 

  1138.                     ret.AddNoLock(mapSite.Target(mapSite, context, func, ScriptingRuntimeHelpers.CharToString(o)));

    1139. 

  1139.                 }

    1140. 

  1140.             }

    1141. 

  1141. 

    1142. 

  1142.             return ret;

    1143. 

  1143.         }

    1144. 

  1144. 

    1145. 

  1145.         public static List map(

    1146. 

  1146.             CodeContext/*!*/ context,

    1147. 

  1147.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, PythonType, object, object>>> storage,

    1148. 

  1148.             [NotNull]PythonType/*!*/ func,

    1149. 

  1149.             [NotNull]string enumerator

    1150. 

  1150.         ) {

    1151. 

  1151.             CallSite<Func<CallSite, CodeContext, PythonType, string, object>> mapSite = MakeMapSite<PythonType, string>(context);

    1152. 

  1152. 

    1153. 

  1153.             List ret = new List(enumerator.Length);

    1154. 

  1154.             foreach (char o in enumerator) {

    1155. 

  1155.                 ret.AddNoLock(mapSite.Target(mapSite, context, func, ScriptingRuntimeHelpers.CharToString(o)));

    1156. 

  1156.             }

    1157. 

  1157.             return ret;

    1158. 

  1158.         }

    1159. 

  1159. 

    1160. 

  1160.         public static List map(

    1161. 

  1161.             CodeContext/*!*/ context,

    1162. 

  1162.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, PythonType, object, object>>> storage,

    1163. 

  1163.             [NotNull]PythonType/*!*/ func,

    1164. 

  1164.             [NotNull]IEnumerable enumerator

    1165. 

  1165.         ) {

    1166. 

  1166.             CallSite<Func<CallSite, CodeContext, PythonType, object, object>> mapSite;

    1167. 

  1167.             if (storage.Data == null) {

    1168. 

  1168.                 storage.Data = MakeMapSite<PythonType, object>(context);

    1169. 

  1169.             }

    1170. 

  1170.             mapSite = storage.Data;

    1171. 

  1171. 

    1172. 

  1172.             IEnumerator en = PythonOps.GetEnumerator(enumerator);

    1173. 

  1173.             List ret = new List();

    1174. 

  1174.             while (en.MoveNext()) {

    1175. 

  1175.                 ret.AddNoLock(mapSite.Target(mapSite, context, func, en.Current));

    1176. 

  1176.             }

    1177. 

  1177.             return ret;

    1178. 

  1178.         }

    1179. 

  1179. 

    1180. 

  1180.         public static List map(

    1181. 

  1181.             CodeContext/*!*/ context,

    1182. 

  1182.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, BuiltinFunction, object, object>>> storage,

    1183. 

  1183.             [NotNull]BuiltinFunction/*!*/ func,

    1184. 

  1184.             [NotNull]string enumerator

    1185. 

  1185.         ) {

    1186. 

  1186.             CallSite<Func<CallSite, CodeContext, BuiltinFunction, object, object>> mapSite;

    1187. 

  1187.             if (storage.Data == null) {

    1188. 

  1188.                 storage.Data = MakeMapSite<BuiltinFunction, object>(context);

    1189. 

  1189.             }

    1190. 

  1190.             mapSite = storage.Data;

    1191. 

  1191. 

    1192. 

  1192.             List ret = new List(enumerator.Length);

    1193. 

  1193.             foreach (char o in enumerator) {

    1194. 

  1194.                 ret.AddNoLock(mapSite.Target(mapSite, context, func, ScriptingRuntimeHelpers.CharToString(o)));

    1195. 

  1195.             }

    1196. 

  1196.             return ret;

    1197. 

  1197.         }

    1198. 

  1198. 

    1199. 

  1199.         public static List map(

    1200. 

  1200.             CodeContext/*!*/ context,

    1201. 

  1201.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, BuiltinFunction, object, object>>> storage,

    1202. 

  1202.             [NotNull]BuiltinFunction/*!*/ func,

    1203. 

  1203.             [NotNull]IEnumerable enumerator

    1204. 

  1204.         ) {

    1205. 

  1205.             CallSite<Func<CallSite, CodeContext, BuiltinFunction, object, object>> mapSite;

    1206. 

  1206.             if (storage.Data == null) {

    1207. 

  1207.                 storage.Data = MakeMapSite<BuiltinFunction, object>(context);

    1208. 

  1208.             }

    1209. 

  1209.             mapSite = storage.Data;

    1210. 

  1210. 

    1211. 

  1211.             IEnumerator en = PythonOps.GetEnumerator(enumerator);

    1212. 

  1212.             List ret = new List();

    1213. 

  1213.             while (en.MoveNext()) {

    1214. 

  1214.                 ret.AddNoLock(mapSite.Target(mapSite, context, func, en.Current));

    1215. 

  1215.             }

    1216. 

  1216.             return ret;

    1217. 

  1217.         }

    1218. 

  1218. 

    1219. 

  1219.         public static List map(

    1220. 

  1220.             CodeContext/*!*/ context,

    1221. 

  1221.             SiteLocalStorage<CallSite<Func<CallSite, CodeContext, PythonFunction, object, object>>> storage,

    1222. 

  1222.             [NotNull]PythonFunction/*!*/ func,

    1223. 

  1223.             [NotNull]IList enumerator

    1224. 

  1224.         ) {

    1225. 

  1225.             CallSite<Func<CallSite, CodeContext, PythonFunction, object, object>> mapSite;

    1226. 

  1226.             if (storage.Data == null) {

    1227. 

  1227.                 storage.Data = MakeMapSite<PythonFunction, object>(context);

    1228. 

  1228.             }

    1229. 

  1229.             mapSite = storage.Data;

    1230. 

  1230. 

    1231. 

  1231.             IEnumerator en = PythonOps.GetEnumerator(enumerator);

    1232. 

  1232.             List ret = new List(enumerator.Count);

    1233. 

  1233.             while (en.MoveNext()) {

    1234. 

  1234.                 ret.AddNoLock(mapSite.Target(mapSite, context, func, en.Current));

    1235. 

  1235.             }

    1236. 

  1236.             return ret;

    1237. 

  1237.         }

    1238. 

  1238. 

    1239. 

  1239.         public static List map(CodeContext/*!*/ context, params object[] param) {

    1240. 

  1240.             if (param == null || param.Length < 2) {

    1241. 

  1241.                 throw PythonOps.TypeError("at least 2 arguments required to map");

    1242. 

  1242.             }

    1243. 

  1243.             List ret = new List();

    1244. 

  1244.             object func = param[0];

    1245. 

  1245. 

    1246. 

  1246.             IEnumerator[] enums = new IEnumerator[param.Length - 1];

    1247. 

  1247.             for (int i = 0; i < enums.Length; i++) {

    1248. 

  1248.                 enums[i] = PythonOps.GetEnumerator(param[i + 1]);

    1249. 

  1249.             }

    1250. 

  1250. 

    1251. 

  1251.             object[] args = new object[enums.Length];

    1252. 

  1252.             while (true) {

    1253. 

  1253.                 bool done = true;

    1254. 

  1254.                 for (int i = 0; i < enums.Length; i++) {

    1255. 

  1255.                     if (enums[i].MoveNext()) {

    1256. 

  1256.                         args[i] = enums[i].Current;

    1257. 

  1257.                         done = false;

    1258. 

  1258.                     } else {

    1259. 

  1259.                         args[i] = null;

    1260. 

  1260.                     }

    1261. 

  1261.                 }

    1262. 

  1262.                 if (done) {

    1263. 

  1263.                     return ret;

    1264. 

  1264.                 }

    1265. 

  1265.                 if (func != null) {

    1266. 

  1266.                     // splat call w/ args, can't use site here yet...

    1267. 

  1267.                     ret.AddNoLock(PythonCalls.Call(context, func, args));

    1268. 

  1268.                 } else if (args.Length == 1) {

    1269. 

  1269.                     ret.AddNoLock(args[0]);

    1270. 

  1270.                 } else {

    1271. 

  1271.                     ret.AddNoLock(PythonTuple.MakeTuple(args));

    1272. 

  1272.                     args = new object[enums.Length];    // Tuple does not copy the array, allocate new one.

    1273. 

  1273.                 }

    1274. 

  1274.             }

    1275. 

  1275.         }

    1276. 

  1276. 

    1277. 

  1277.         public static object max(CodeContext/*!*/ context, object x) {

    1278. 

  1278.             IEnumerator i = PythonOps.GetEnumerator(x);

    1279. 

  1279.             if (!i.MoveNext())

    1280. 

  1280.                 throw PythonOps.ValueError("max() arg is an empty sequence");

    1281. 

  1281.             object ret = i.Current;

    1282. 

  1282.             PythonContext pc = PythonContext.GetContext(context);

    1283. 

  1283.             while (i.MoveNext()) {

    1284. 

  1284.                 if (pc.GreaterThan(i.Current, ret)) ret = i.Current;

    1285. 

  1285.             }

    1286. 

  1286.             return ret;

    1287. 

  1287.         }

    1288. 

  1288. 

    1289. 

  1289.         public static object max(CodeContext/*!*/ context, object x, object y) {

    1290. 

  1290.             return PythonContext.GetContext(context).GreaterThan(x, y) ? x : y;

    1291. 

  1291.         }

    1292. 

  1292. 

    1293. 

  1293.         public static object max(CodeContext/*!*/ context, params object[] args) {

    1294. 

  1294.             if (args.Length > 0) {

    1295. 

  1295.                 object ret = args[0];

    1296. 

  1296.                 if (args.Length == 1) {

    1297. 

  1297.                     return max(context, ret);

    1298. 

  1298.                 }

    1299. 

  1299. 

    1300. 

  1300.                 PythonContext pc = PythonContext.GetContext(context);

    1301. 

  1301.                 for (int i = 1; i < args.Length; i++) {

    1302. 

  1302.                     if (pc.GreaterThan(args[i], ret)) {

    1303. 

  1303.                         ret = args[i];

    1304. 

  1304.                     }

    1305. 

  1305.                 }

    1306. 

  1306.                 return ret;

    1307. 

  1307.             } else {

    1308. 

  1308.                 throw PythonOps.TypeError("max expecting 1 arguments, got 0");

    1309. 

  1309.             }

    1310. 

  1310. 

    1311. 

  1311.         }

    1312. 

  1312. 

    1313. 

  1313.         public static object max(CodeContext/*!*/ context, object x, [ParamDictionary]IDictionary<object, object> dict) {

    1314. 

  1314.             IEnumerator i = PythonOps.GetEnumerator(x);

    1315. 

  1315.             if (!i.MoveNext())

    1316. 

  1316.                 throw PythonOps.ValueError(" max() arg is an empty sequence");

    1317. 

  1317.             object method = GetMaxKwArg(dict);

    1318. 

  1318.             object ret = i.Current;

    1319. 

  1319.             object retValue = PythonCalls.Call(context, method, i.Current);

    1320. 

  1320.             PythonContext pc = PythonContext.GetContext(context);

    1321. 

  1321.             while (i.MoveNext()) {

    1322. 

  1322.                 object tmpRetValue = PythonCalls.Call(context, method, i.Current);

    1323. 

  1323.                 if (pc.GreaterThan(tmpRetValue, retValue)) {

    1324. 

  1324.                     ret = i.Current;

    1325. 

  1325.                     retValue = tmpRetValue;

    1326. 

  1326.                 }

    1327. 

  1327.             }

    1328. 

  1328.             return ret;

    1329. 

  1329.         }

    1330. 

  1330. 

    1331. 

  1331.         public static object max(CodeContext/*!*/ context, object x, object y, [ParamDictionary] IDictionary<object, object> dict) {

    1332. 

  1332.             object method = GetMaxKwArg(dict);

    1333. 

  1333.             PythonContext pc = PythonContext.GetContext(context);

    1334. 

  1334.             return pc.GreaterThan(PythonCalls.Call(context, method, x), PythonCalls.Call(context, method, y)) ? x : y;

    1335. 

  1335.         }

    1336. 

  1336. 

    1337. 

  1337.         public static object max(CodeContext/*!*/ context, [ParamDictionary]IDictionary<object, object> dict, params object[] args) {

    1338. 

  1338.             if (args.Length > 0) {

    1339. 

  1339.                 int retIndex = 0;

    1340. 

  1340.                 if (args.Length == 1) {

    1341. 

  1341.                     return max(context, args[retIndex], dict);

    1342. 

  1342.                 }

    1343. 

  1343.                 object method = GetMaxKwArg(dict);

    1344. 

  1344.                 object retValue = PythonCalls.Call(context, method, args[retIndex]);

    1345. 

  1345.                 PythonContext pc = PythonContext.GetContext(context);

    1346. 

  1346.                 for (int i = 1; i < args.Length; i++) {

    1347. 

  1347.                     object tmpRetValue = PythonCalls.Call(context, method, args[i]);

    1348. 

  1348.                     if (pc.GreaterThan(tmpRetValue, retValue)) {

    1349. 

  1349.                         retIndex = i;

    1350. 

  1350.                         retValue = tmpRetValue;

    1351. 

  1351.                     }

    1352. 

  1352.                 }

    1353. 

  1353.                 return args[retIndex];

    1354. 

  1354.             } else {

    1355. 

  1355.                 throw PythonOps.TypeError("max expecting 1 arguments, got 0");

    1356. 

  1356.             }

    1357. 

  1357.         }

    1358. 

  1358. 

    1359. 

  1359.         private static object GetMaxKwArg(IDictionary<object, object> dict) {

    1360. 

  1360.             if (dict.Count != 1)

    1361. 

  1361.                 throw PythonOps.TypeError(" max() should have only 1 keyword argument, but got {0} keyword arguments", dict.Count);

    1362. 

  1362. 

    1363. 

  1363.             return VerifyKeys("max", dict);

    1364. 

  1364.         }

    1365. 

  1365. 

    1366. 

  1366.         public static object min(CodeContext/*!*/ context, object x) {

    1367. 

  1367.             IEnumerator i = PythonOps.GetEnumerator(x);

    1368. 

  1368.             if (!i.MoveNext()) {

    1369. 

  1369.                 throw PythonOps.ValueError("empty sequence");

    1370. 

  1370.             }

    1371. 

  1371.             object ret = i.Current;

    1372. 

  1372.             PythonContext pc = PythonContext.GetContext(context);

    1373. 

  1373.             while (i.MoveNext()) {

    1374. 

  1374.                 if (pc.LessThan(i.Current, ret)) ret = i.Current;

    1375. 

  1375.             }

    1376. 

  1376.             return ret;

    1377. 

  1377.         }

    1378. 

  1378. 

    1379. 

  1379.         public static object min(CodeContext/*!*/ context, object x, object y) {

    1380. 

  1380.             return PythonContext.GetContext(context).LessThan(x, y) ? x : y;

    1381. 

  1381.         }

    1382. 

  1382. 

    1383. 

  1383.         public static object min(CodeContext/*!*/ context, params object[] args) {

    1384. 

  1384.             if (args.Length > 0) {

    1385. 

  1385.                 object ret = args[0];

    1386. 

  1386.                 if (args.Length == 1) {

    1387. 

  1387.                     return min(context, ret);

    1388. 

  1388.                 }

    1389. 

  1389. 

    1390. 

  1390.                 PythonContext pc = PythonContext.GetContext(context);

    1391. 

  1391.                 for (int i = 1; i < args.Length; i++) {

    1392. 

  1392.                     if (pc.LessThan(args[i], ret)) ret = args[i];

    1393. 

  1393.                 }

    1394. 

  1394.                 return ret;

    1395. 

  1395.             } else {

    1396. 

  1396.                 throw PythonOps.TypeError("min expecting 1 arguments, got 0");

    1397. 

  1397.             }

    1398. 

  1398.         }

    1399. 

  1399. 

    1400. 

  1400.         public static object min(CodeContext/*!*/ context, object x, [ParamDictionary]IDictionary<object, object> dict) {

    1401. 

  1401.             IEnumerator i = PythonOps.GetEnumerator(x);

    1402. 

  1402.             if (!i.MoveNext())

    1403. 

  1403.                 throw PythonOps.ValueError(" min() arg is an empty sequence");

    1404. 

  1404.             object method = GetMinKwArg(dict);

    1405. 

  1405.             object ret = i.Current;

    1406. 

  1406.             object retValue = PythonCalls.Call(context, method, i.Current);

    1407. 

  1407.             PythonContext pc = PythonContext.GetContext(context);

    1408. 

  1408.             while (i.MoveNext()) {

    1409. 

  1409.                 object tmpRetValue = PythonCalls.Call(context, method, i.Current);

    1410. 

  1410. 

    1411. 

  1411.                 if (pc.LessThan(tmpRetValue, retValue)) {

    1412. 

  1412.                     ret = i.Current;

    1413. 

  1413.                     retValue = tmpRetValue;

    1414. 

  1414.                 }

    1415. 

  1415.             }

    1416. 

  1416.             return ret;

    1417. 

  1417.         }

    1418. 

  1418. 

    1419. 

  1419.         public static object min(CodeContext/*!*/ context, object x, object y, [ParamDictionary]IDictionary<object, object> dict) {

    1420. 

  1420.             object method = GetMinKwArg(dict);

    1421. 

  1421.             return PythonContext.GetContext(context).LessThan(PythonCalls.Call(context, method, x), PythonCalls.Call(context, method, y)) ? x : y;

    1422. 

  1422.         }

    1423. 

  1423. 

    1424. 

  1424.         public static object min(CodeContext/*!*/ context, [ParamDictionary]IDictionary<object, object> dict, params object[] args) {

    1425. 

  1425.             if (args.Length > 0) {

    1426. 

  1426.                 int retIndex = 0;

    1427. 

  1427.                 if (args.Length == 1) {

    1428. 

  1428.                     return min(context, args[retIndex], dict);

    1429. 

  1429.                 }

    1430. 

  1430.                 object method = GetMinKwArg(dict);

    1431. 

  1431.                 object retValue = PythonCalls.Call(context, method, args[retIndex]);

    1432. 

  1432.                 PythonContext pc = PythonContext.GetContext(context);

    1433. 

  1433. 

    1434. 

  1434.                 for (int i = 1; i < args.Length; i++) {

    1435. 

  1435.                     object tmpRetValue = PythonCalls.Call(context, method, args[i]);

    1436. 

  1436. 

    1437. 

  1437.                     if (pc.LessThan(tmpRetValue, retValue)) {

    1438. 

  1438.                         retIndex = i;

    1439. 

  1439.                         retValue = tmpRetValue;

    1440. 

  1440.                     }

    1441. 

  1441.                 }

    1442. 

  1442.                 return args[retIndex];

    1443. 

  1443.             } else {

    1444. 

  1444.                 throw PythonOps.TypeError("min expecting 1 arguments, got 0");

    1445. 

  1445.             }

    1446. 

  1446.         }

    1447. 

  1447. 

    1448. 

  1448.         private static object GetMinKwArg([ParamDictionary]IDictionary<object, object> dict) {

    1449. 

  1449.             if (dict.Count != 1)

    1450. 

  1450.                 throw PythonOps.TypeError(" min() should have only 1 keyword argument, but got {0} keyword arguments", dict.Count);

    1451. 

  1451. 

    1452. 

  1452.             return VerifyKeys("min", dict);

    1453. 

  1453.         }

    1454. 

  1454. 

    1455. 

  1455.         private static object VerifyKeys(string name, IDictionary<object, object> dict) {

    1456. 

  1456.             object value;

    1457. 

  1457.             if (!dict.TryGetValue("key", out value)) {

    1458. 

  1458.                 ICollection<object> keys = dict.Keys;

    1459. 

  1459.                 IEnumerator<object> en = keys.GetEnumerator();

    1460. 

  1460.                 if (en.MoveNext()) {

    1461. 

  1461.                     throw PythonOps.TypeError(" {1}() got an unexpected keyword argument ({0})", en.Current, name);

    1462. 

  1462.                 }

    1463. 

  1463.             }

    1464. 

  1464.             return value;

    1465. 

  1465.         }

    1466. 

  1466. 

    1467. 

  1467.         public static object next(IEnumerator iter) {

    1468. 

  1468.             if (iter.MoveNext()) {

    1469. 

  1469.                 return iter.Current;

    1470. 

  1470.             } else {

    1471. 

  1471.                 throw PythonOps.StopIteration();

    1472. 

  1472.             }

    1473. 

  1473.         }

    1474. 

  1474. 

    1475. 

  1475.         public static object next(IEnumerator iter, object defaultVal) {

    1476. 

  1476.             if (iter.MoveNext()) {

    1477. 

  1477.                 return iter.Current;

    1478. 

  1478.             } else {

    1479. 

  1479.                 return defaultVal;

    1480. 

  1480.             }

    1481. 

  1481.         }

    1482. 

  1482. 

    1483. 

  1483.         [LightThrowing]

    1484. 

  1484.         public static object next(PythonGenerator gen) {

    1485. 

  1485.             return gen.next();

    1486. 

  1486.         }

    1487. 

  1487. 

    1488. 

  1488.         [LightThrowing]

    1489. 

  1489.         public static object next(PythonGenerator gen, object defaultVal) {

    1490. 

  1490.             object res = gen.next();

    1491. 

  1491.             Exception exc = LightExceptions.GetLightException(res);

    1492. 

  1492.             

    1493. 

  1493.             if (exc != null && exc is StopIterationException) {

    1494. 

  1494.                 return defaultVal;

    1495. 

  1495.             }

    1496. 

  1496. 

    1497. 

  1497.             return res;

    1498. 

  1498.         }

    1499. 

  1499. 

    1500. 

  1500.         public static object next(CodeContext/*!*/ context, object iter) {

    1501. 

  1501.             return PythonOps.Invoke(context, iter, "next");

    1502. 

  1502.         }

    1503. 

  1503. 

    1504. 

  1504.         public static object next(CodeContext/*!*/ context, object iter, object defaultVal) {

    1505. 

  1505.             try {

    1506. 

  1506.                 return PythonOps.Invoke(context, iter, "next");

    1507. 

  1507.             } catch (StopIterationException) {

    1508. 

  1508.                 return defaultVal;

    1509. 

  1509.             }

    1510. 

  1510.         }

    1511. 

  1511. 

    1512. 

  1512.         public static PythonType @object {

    1513. 

  1513.             get {

    1514. 

  1514.                 return DynamicHelpers.GetPythonTypeFromType(typeof(object));

    1515. 

  1515.             }

    1516. 

  1516.         }

    1517. 

  1517. 

    1518. 

  1518.         public static object oct(object o) {

    1519. 

  1519.             return PythonOps.Oct(o);

    1520. 

  1520.         }

    1521. 

  1521. 

    1522. 

  1522.         /// <summary>

    1523. 

  1523.         /// Opens a file and returns a new file object.

    1524. 

  1524.         /// 

    1525. 

  1525.         /// name -> the name of the file to open.

    1526. 

  1526.         /// mode -> the mode to open the file (r for reading, w for writing, a for appending, default is r).

    1527. 

  1527.         /// bufsize -> the size of the buffer to be used (&lt;= 0 indicates to use the default size)

    1528. 

  1528.         /// </summary>

    1529. 

  1529.         public static PythonFile open(CodeContext context, string name, [DefaultParameterValue("r")]string mode, [DefaultParameterValue(-1)]int buffering) {

    1530. 

  1530.             PythonFile res = new PythonFile(context);

    1531. 

  1531.             res.__init__(context, name, mode, buffering);

    1532. 

  1532.             return res;            

    1533. 

  1533.         }

    1534. 

  1534. 

    1535. 

  1535.         /// <summary>

    1536. 

  1536.         /// Creates a new Python file object from a .NET stream object.

    1537. 

  1537.         /// 

    1538. 

  1538.         /// stream -> the stream to wrap in a file object.

    1539. 

  1539.         /// </summary>

    1540. 

  1540.         public static PythonFile open(CodeContext context, [NotNull]Stream stream) {

    1541. 

  1541.             PythonFile res = new PythonFile(context);

    1542. 

  1542.             res.__init__(context, stream);

    1543. 

  1543.             return res;            

    1544. 

  1544.         }

    1545. 

  1545. 

    1546. 

  1546.         public static int ord(object value) {

    1547. 

  1547.             if (value is char) {

    1548. 

  1548.                 return (char)value;

    1549. 

  1549.             } 

    1550. 

  1550. 

    1551. 

  1551.             string stringValue = value as string;

    1552. 

  1552.             if (stringValue == null) {

    1553. 

  1553.                 ExtensibleString es = value as ExtensibleString;

    1554. 

  1554.                 if (es != null) stringValue = es.Value;

    1555. 

  1555.             }

    1556. 

  1556.             

    1557. 

  1557.             if (stringValue != null) {

    1558. 

  1558.                 if (stringValue.Length != 1) {

    1559. 

  1559.                     throw PythonOps.TypeError("expected a character, but string of length {0} found", stringValue.Length);

    1560. 

  1560.                 }

    1561. 

  1561.                 return stringValue[0];

    1562. 

  1562.             }

    1563. 

  1563. 

    1564. 

  1564.             IList<byte> bytes = value as IList<byte>;

    1565. 

  1565.             if (bytes != null) {

    1566. 

  1566.                 if (bytes.Count != 1) {

    1567. 

  1567.                     throw PythonOps.TypeError("expected a character, but string of length {0} found", bytes.Count);

    1568. 

  1568.                 }

    1569. 

  1569. 

    1570. 

  1570.                 return bytes[0];

    1571. 

  1571.             }

    1572. 

  1572.                 

    1573. 

  1573.             throw PythonOps.TypeError("expected a character, but {0} found", PythonTypeOps.GetName(value));

    1574. 

  1574.         }

    1575. 

  1575. 

    1576. 

  1576.         public static object pow(CodeContext/*!*/ context, object x, object y) {

    1577. 

  1577.             return PythonContext.GetContext(context).Operation(PythonOperationKind.Power, x, y);

    1578. 

  1578.         }

    1579. 

  1579. 

    1580. 

  1580.         public static object pow(CodeContext/*!*/ context, object x, object y, object z) {

    1581. 

  1581.             try {

    1582. 

  1582.                 return PythonOps.PowerMod(context, x, y, z);

    1583. 

  1583.             } catch (DivideByZeroException) {

    1584. 

  1584.                 throw PythonOps.ValueError("3rd argument cannot be 0");

    1585. 

  1585.             }

    1586. 

  1586.         }

    1587. 

  1587. 

    1588. 

  1588.         public static void print(CodeContext/*!*/ context, params object[] args) {

    1589. 

  1589.             print(context, " ", "\n", null, args);

    1590. 

  1590.         }

    1591. 

  1591. 

    1592. 

  1592.         public static void print(CodeContext/*!*/ context, [ParamDictionary]IDictionary<object, object> kwargs, params object[] args) {

    1593. 

  1593.             object sep = AttrCollectionPop(kwargs, "sep", " ");

    1594. 

  1594.             if (sep != null && !(sep is string)) {

    1595. 

  1595.                 throw PythonOps.TypeError("sep must be None or str, not {0}", PythonTypeOps.GetName(sep));

    1596. 

  1596.             }

    1597. 

  1597. 

    1598. 

  1598.             object end = AttrCollectionPop(kwargs, "end", "\n");

    1599. 

  1599.             if (sep != null && !(sep is string)) {

    1600. 

  1600.                 throw PythonOps.TypeError("end must be None or str, not {0}", PythonTypeOps.GetName(end));

    1601. 

  1601.             }

    1602. 

  1602. 

    1603. 

  1603.             object file = AttrCollectionPop(kwargs, "file", null);

    1604. 

  1604. 

    1605. 

  1605.             if (kwargs.Count != 0) {

    1606. 

  1606.                 throw PythonOps.TypeError(

    1607. 

  1607.                     "'{0}' is an invalid keyword argument for this function", 

    1608. 

  1608.                     new List<object>(kwargs.Keys)[0]

    1609. 

  1609.                 );

    1610. 

  1610.             }

    1611. 

  1611. 

    1612. 

  1612.             print(context, (string)sep ?? " ", (string)end ?? "\n", file, args);

    1613. 

  1613.         }

    1614. 

  1614. 

    1615. 

  1615.         private static object AttrCollectionPop(IDictionary<object, object> kwargs, string name, object defaultValue) {

    1616. 

  1616.             object res;

    1617. 

  1617.             if (kwargs.TryGetValue(name, out res)) {

    1618. 

  1618.                 kwargs.Remove(name);

    1619. 

  1619.             } else {

    1620. 

  1620.                 res = defaultValue;

    1621. 

  1621.             }

    1622. 

  1622.             return res;

    1623. 

  1623.         }

    1624. 

  1624. 

    1625. 

  1625.         private static void print(CodeContext/*!*/ context, string/*!*/ sep, string/*!*/ end, object file, object[]/*!*/ args) {

    1626. 

  1626.             PythonContext pc = PythonContext.GetContext(context);

    1627. 

  1627. 

    1628. 

  1628.             if (file == null) {

    1629. 

  1629.                 file = pc.SystemStandardOut;

    1630. 

  1630.             }

    1631. 

  1631.             if (file == null) {

    1632. 

  1632.                 throw PythonOps.RuntimeError("lost sys.std_out");

    1633. 

  1633.             }

    1634. 

  1634. 

    1635. 

  1635.             if (args == null) {

    1636. 

  1636.                 // passing None to print passes a null object array

    1637. 

  1637.                 args = new object[1];

    1638. 

  1638.             }

    1639. 

  1639. 

    1640. 

  1640.             PythonFile pf = file as PythonFile;

    1641. 

  1641. 

    1642. 

  1642.             for (int i = 0; i < args.Length; i++) {

    1643. 

  1643.                 string text = PythonOps.ToString(context, args[i]);

    1644. 

  1644. 

    1645. 

  1645.                 if (pf != null) {

    1646. 

  1646.                     pf.write(text);

    1647. 

  1647.                 } else {

    1648. 

  1648.                     pc.WriteCallSite.Target(

    1649. 

  1649.                         pc.WriteCallSite,

    1650. 

  1650.                         context,

    1651. 

  1651.                         PythonOps.GetBoundAttr(context, file, "write"),

    1652. 

  1652.                         text

    1653. 

  1653.                     );

    1654. 

  1654.                 }

    1655. 

  1655. 

    1656. 

  1656.                 if (i != args.Length - 1) {

    1657. 

  1657.                     if (pf != null) {

    1658. 

  1658.                         pf.write(sep);

    1659. 

  1659.                     } else {

    1660. 

  1660.                         pc.WriteCallSite.Target(

    1661. 

  1661.                             pc.WriteCallSite,

    1662. 

  1662.                             context,

    1663. 

  1663.                             PythonOps.GetBoundAttr(context, file, "write"),

    1664. 

  1664.                             sep

    1665. 

  1665.                         );

    1666. 

  1666.                     }

    1667. 

  1667.                 }

    1668. 

  1668.             }

    1669. 

  1669. 

    1670. 

  1670.             if (pf != null) {

    1671. 

  1671.                 pf.write(end);

    1672. 

  1672.             } else {

    1673. 

  1673.                 pc.WriteCallSite.Target(

    1674. 

  1674.                     pc.WriteCallSite,

    1675. 

  1675.                     context,

    1676. 

  1676.                     PythonOps.GetBoundAttr(context, file, "write"),

    1677. 

  1677.                     end

    1678. 

  1678.                 );

    1679. 

  1679.             }

    1680. 

  1680.         }

    1681. 

  1681. 

    1682. 

  1682.         public static PythonType property {

    1683. 

  1683.             get {

    1684. 

  1684.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonProperty));

    1685. 

  1685.             }

    1686. 

  1686.         }

    1687. 

  1687. 

    1688. 

  1688.         [return: SequenceTypeInfo(typeof(int))]

    1689. 

  1689.         public static List range(int stop) {

    1690. 

  1690.             return rangeWorker(stop);

    1691. 

  1691.         }

    1692. 

  1692. 

    1693. 

  1693.         [return: SequenceTypeInfo(typeof(int))]

    1694. 

  1694.         public static List range(BigInteger stop) {

    1695. 

  1695.             return rangeWorker(stop);

    1696. 

  1696.         }

    1697. 

  1697. 

    1698. 

  1698.         private static List rangeWorker(int stop) {

    1699. 

  1699.             if (stop < 0) {

    1700. 

  1700.                 stop = 0;

    1701. 

  1701.             }

    1702. 

  1702. 

    1703. 

  1703.             List ret = PythonOps.MakeEmptyList(stop);

    1704. 

  1704.             for (int i = 0; i < stop; i++) ret.AddNoLock(ScriptingRuntimeHelpers.Int32ToObject(i));

    1705. 

  1705.             return ret;

    1706. 

  1706.         }

    1707. 

  1707. 

    1708. 

  1708.         private static List rangeWorker(BigInteger stop) {

    1709. 

  1709.             if (stop < BigInteger.Zero) {

    1710. 

  1710.                 return range(0);

    1711. 

  1711.             }

    1712. 

  1712.             int istop;

    1713. 

  1713.             if (stop.AsInt32(out istop)) {

    1714. 

  1714.                 return range(istop);

    1715. 

  1715.             }

    1716. 

  1716.             throw PythonOps.OverflowError("too many items in the range");

    1717. 

  1717.         }

    1718. 

  1718. 

    1719. 

  1719.         [return: SequenceTypeInfo(typeof(int))]

    1720. 

  1720.         public static List range(int start, int stop) {

    1721. 

  1721.             return rangeWorker(start, stop);

    1722. 

  1722.         }

    1723. 

  1723. 

    1724. 

  1724.         [return: SequenceTypeInfo(typeof(int))]

    1725. 

  1725.         public static List range(BigInteger start, BigInteger stop) {

    1726. 

  1726.             return rangeWorker(start, stop);

    1727. 

  1727.         }

    1728. 

  1728. 

    1729. 

  1729.         private static List rangeWorker(int start, int stop) {

    1730. 

  1730.             if (start > stop) {

    1731. 

  1731.                 stop = start;

    1732. 

  1732.             }

    1733. 

  1733. 

    1734. 

  1734.             long length = (long)stop - (long)start;

    1735. 

  1735.             if (Int32.MinValue <= length && length <= Int32.MaxValue) {

    1736. 

  1736.                 List ret = PythonOps.MakeEmptyList(stop - start);

    1737. 

  1737.                 for (int i = start; i < stop; i++) ret.AddNoLock(ScriptingRuntimeHelpers.Int32ToObject(i));

    1738. 

  1738.                 return ret;

    1739. 

  1739.             }

    1740. 

  1740.             throw PythonOps.OverflowError("too many items in the list");

    1741. 

  1741.         }

    1742. 

  1742. 

    1743. 

  1743.         private static List rangeWorker(BigInteger start, BigInteger stop) {

    1744. 

  1744.             if (start > stop) {

    1745. 

  1745.                 stop = start;

    1746. 

  1746.             }

    1747. 

  1747.             BigInteger length = stop - start;

    1748. 

  1748.             int ilength;

    1749. 

  1749.             if (length.AsInt32(out ilength)) {

    1750. 

  1750.                 List ret = PythonOps.MakeEmptyList(ilength);

    1751. 

  1751.                 for (int i = 0; i < ilength; i++) {

    1752. 

  1752.                     ret.AddNoLock(start + i);

    1753. 

  1753.                 }

    1754. 

  1754.                 return ret;

    1755. 

  1755.             }

    1756. 

  1756.             throw PythonOps.OverflowError("too many items in the range");

    1757. 

  1757.         }

    1758. 

  1758. 

    1759. 

  1759.         [return: SequenceTypeInfo(typeof(int))]

    1760. 

  1760.         public static List range(int start, int stop, int step) {

    1761. 

  1761.             return rangeWorker(start, stop, step);

    1762. 

  1762.         }

    1763. 

  1763. 

    1764. 

  1764.         [return: SequenceTypeInfo(typeof(int))]

    1765. 

  1765.         public static List range(BigInteger start, BigInteger stop, BigInteger step) {

    1766. 

  1766.             return rangeWorker(start, stop, step);

    1767. 

  1767.         }

    1768. 

  1768. 

    1769. 

  1769.         private static List rangeWorker(int start, int stop, int step) {

    1770. 

  1770.             if (step == 0) {

    1771. 

  1771.                 throw PythonOps.ValueError("step of 0");

    1772. 

  1772.             }

    1773. 

  1773. 

    1774. 

  1774.             List ret;

    1775. 

  1775.             if (step > 0) {

    1776. 

  1776.                 if (start > stop) stop = start;

    1777. 

  1777.                 ret = PythonOps.MakeEmptyList((stop - start) / step);

    1778. 

  1778.                 for (int i = start; i < stop; i += step) {

    1779. 

  1779.                     ret.AddNoLock(ScriptingRuntimeHelpers.Int32ToObject(i));

    1780. 

  1780.                 }

    1781. 

  1781.             } else {

    1782. 

  1782.                 if (start < stop) stop = start;

    1783. 

  1783.                 ret = PythonOps.MakeEmptyList((stop - start) / step);

    1784. 

  1784.                 for (int i = start; i > stop; i += step) {

    1785. 

  1785.                     ret.AddNoLock(ScriptingRuntimeHelpers.Int32ToObject(i));

    1786. 

  1786.                 }

    1787. 

  1787.             }

    1788. 

  1788.             return ret;

    1789. 

  1789.         }

    1790. 

  1790. 

    1791. 

  1791.         private static List rangeWorker(BigInteger start, BigInteger stop, BigInteger step) {

    1792. 

  1792.             if (step == BigInteger.Zero) {

    1793. 

  1793.                 throw PythonOps.ValueError("step of 0");

    1794. 

  1794.             }

    1795. 

  1795.             BigInteger length;

    1796. 

  1796.             if (step > BigInteger.Zero) {

    1797. 

  1797.                 if (start > stop) stop = start;

    1798. 

  1798.                 length = (stop - start + step - 1) / step;

    1799. 

  1799.             } else {

    1800. 

  1800.                 if (start < stop) stop = start;

    1801. 

  1801.                 length = (stop - start + step + 1) / step;

    1802. 

  1802.             }

    1803. 

  1803. 

    1804. 

  1804.             int ilength;

    1805. 

  1805.             if (length.AsInt32(out ilength)) {

    1806. 

  1806.                 List ret = PythonOps.MakeEmptyList(ilength);

    1807. 

  1807.                 for (int i = 0; i < ilength; i++) {

    1808. 

  1808.                     ret.AddNoLock(start);

    1809. 

  1809.                     start = start + step;

    1810. 

  1810.                 }

    1811. 

  1811.                 return ret;

    1812. 

  1812.             }

    1813. 

  1813.             throw PythonOps.OverflowError("too many items for list");

    1814. 

  1814.         }

    1815. 

  1815. 

    1816. 

  1816.         /// <summary>

    1817. 

  1817.         /// object overload of range - attempts to convert via __int__, and __trunc__ if arg is

    1818. 

  1818.         /// an OldInstance

    1819. 

  1819.         /// </summary>

    1820. 

  1820.         [return: SequenceTypeInfo(typeof(int))]

    1821. 

  1821.         public static List range(CodeContext/*!*/ context, object stop) {

    1822. 

  1822.             return range(GetRangeInt(context, stop, "end"));

    1823. 

  1823.         }

    1824. 

  1824. 

    1825. 

  1825.         /// <summary>

    1826. 

  1826.         /// object overload of range - attempts to convert via __int__, and __trunc__ if arg is

    1827. 

  1827.         /// an OldInstance

    1828. 

  1828.         /// </summary>

    1829. 

  1829.         [return: SequenceTypeInfo(typeof(int))]

    1830. 

  1830.         public static List range(CodeContext/*!*/ context, object start, object stop, [DefaultParameterValue(1)]object step) {

    1831. 

  1831.             BigInteger stopInt = GetRangeInt(context, stop, "end");

    1832. 

  1832.             BigInteger startInt = GetRangeInt(context, start, "start");

    1833. 

  1833.             BigInteger stepInt = GetRangeInt(context, step, "step");

    1834. 

  1834. 

    1835. 

  1835.             return range(startInt, stopInt, stepInt);

    1836. 

  1836.         }

    1837. 

  1837. 

    1838. 

  1838.         private static bool FastGetRangeInt(object arg, out BigInteger res) {

    1839. 

  1839.             if (arg is int) {

    1840. 

  1840.                 res = (BigInteger)(int)arg;

    1841. 

  1841.                 return true;

    1842. 

  1842.             } else if (arg is BigInteger) {

    1843. 

  1843.                 res = (BigInteger)arg;

    1844. 

  1844.                 return true;

    1845. 

  1845.             }

    1846. 

  1846.             

    1847. 

  1847.             Extensible<int> ei;

    1848. 

  1848.             Extensible<BigInteger> ebi;

    1849. 

  1849.             if ((ei = arg as Extensible<int>) != null) {

    1850. 

  1850.                 res = (BigInteger)ei.Value;

    1851. 

  1851.                 return true;

    1852. 

  1852.             } else if ((ebi = arg as Extensible<BigInteger>) != null) {

    1853. 

  1853.                 res = ebi.Value;

    1854. 

  1854.                 return true;

    1855. 

  1855.             }

    1856. 

  1856. 

    1857. 

  1857.             res = BigInteger.Zero;

    1858. 

  1858.             return false;

    1859. 

  1859.         }

    1860. 

  1860. 

    1861. 

  1861.         private static BigInteger GetRangeInt(CodeContext/*!*/ context, object arg, string pos) {

    1862. 

  1862.             BigInteger res;

    1863. 

  1863.             if (FastGetRangeInt(arg, out res)) {

    1864. 

  1864.                 return res;

    1865. 

  1865.             }

    1866. 

  1866. 

    1867. 

  1867.             if (arg is double || arg is Extensible<double>) {

    1868. 

  1868.                 throw PythonOps.TypeError(

    1869. 

  1869.                     "range() integer {0} argument expected, got {1}.",

    1870. 

  1870.                     pos, PythonTypeOps.GetName(arg)

    1871. 

  1871.                 );

    1872. 

  1872.             }

    1873. 

  1873.             

    1874. 

  1874.             object Conversion;

    1875. 

  1875.             if (PythonOps.TryGetBoundAttr(context, arg, "__int__", out Conversion)) {

    1876. 

  1876.                 if (!FastGetRangeInt(PythonOps.CallWithContext(context, Conversion), out res)) {

    1877. 

  1877.                     throw PythonOps.TypeError("__int__ should return int object");

    1878. 

  1878.                 }

    1879. 

  1879.                 return res;

    1880. 

  1880.             } else if (arg is OldInstance) {

    1881. 

  1881.                 if (PythonOps.TryGetBoundAttr(context, arg, "__trunc__", out Conversion)) {

    1882. 

  1882.                     if (!FastGetRangeInt(PythonOps.CallWithContext(context, Conversion), out res)) {

    1883. 

  1883.                         throw PythonOps.TypeError(

    1884. 

  1884.                             "__trunc__ returned non-Integral (type {0})",

    1885. 

  1885.                             PythonTypeOps.GetOldName(arg)

    1886. 

  1886.                         );

    1887. 

  1887.                     }

    1888. 

  1888.                     return res;

    1889. 

  1889.                 }

    1890. 

  1890. 

    1891. 

  1891.                 throw PythonOps.AttributeError(

    1892. 

  1892.                     "{0} instance has no attribute __trunc__",

    1893. 

  1893.                     PythonTypeOps.GetOldName(arg)

    1894. 

  1894.                 );

    1895. 

  1895.             }

    1896. 

  1896. 

    1897. 

  1897.             throw PythonOps.TypeError(

    1898. 

  1898.                 "range() integer {0} argument expected, got {1}.",

    1899. 

  1899.                 pos, PythonTypeOps.GetName(arg)

    1900. 

  1900.             );

    1901. 

  1901.         }

    1902. 

  1902. 

    1903. 

  1903.         public static string raw_input(CodeContext/*!*/ context) {

    1904. 

  1904.             return raw_input(context, null);

    1905. 

  1905.         }

    1906. 

  1906. 

    1907. 

  1907.         public static string raw_input(CodeContext/*!*/ context, object prompt) {

    1908. 

  1908.             if (prompt != null) {

    1909. 

  1909.                 PythonOps.PrintNoNewline(context, prompt);

    1910. 

  1910.             }

    1911. 

  1911.             string line = PythonOps.ReadLineFromSrc(context, PythonContext.GetContext(context).SystemStandardIn) as string;

    1912. 

  1912.             if (line != null && line.EndsWith("\n")) return line.Substring(0, line.Length - 1);

    1913. 

  1913.             return line;

    1914. 

  1914.         }

    1915. 

  1915. 

    1916. 

  1916.         public static object reduce(CodeContext/*!*/ context, SiteLocalStorage<CallSite<Func<CallSite, CodeContext, object, object, object, object>>> siteData, object func, object seq) {

    1917. 

  1917.             IEnumerator i = PythonOps.GetEnumerator(seq);

    1918. 

  1918.             if (!i.MoveNext()) {

    1919. 

  1919.                 throw PythonOps.TypeError("reduce() of empty sequence with no initial value");

    1920. 

  1920.             }

    1921. 

  1921.             EnsureReduceData(context, siteData);

    1922. 

  1922. 

    1923. 

  1923.             CallSite<Func<CallSite, CodeContext, object, object, object, object>> site = siteData.Data;

    1924. 

  1924. 

    1925. 

  1925.             object ret = i.Current;

    1926. 

  1926.             while (i.MoveNext()) {

    1927. 

  1927.                 ret = site.Target(site, context, func, ret, i.Current);

    1928. 

  1928.             }

    1929. 

  1929.             return ret;

    1930. 

  1930.         }

    1931. 

  1931. 

    1932. 

  1932.         public static object reduce(CodeContext/*!*/ context, SiteLocalStorage<CallSite<Func<CallSite, CodeContext, object, object, object, object>>> siteData, object func, object seq, object initializer) {

    1933. 

  1933.             IEnumerator i = PythonOps.GetEnumerator(seq);

    1934. 

  1934.             EnsureReduceData(context, siteData);

    1935. 

  1935.             

    1936. 

  1936.             CallSite<Func<CallSite, CodeContext, object, object, object, object>> site = siteData.Data;

    1937. 

  1937.             

    1938. 

  1938.             object ret = initializer;

    1939. 

  1939.             while (i.MoveNext()) {

    1940. 

  1940.                 ret = site.Target(site, context, func, ret, i.Current);

    1941. 

  1941.             }

    1942. 

  1942.             return ret;

    1943. 

  1943.         }

    1944. 

  1944. 

    1945. 

  1945.         private static void EnsureReduceData(CodeContext context, SiteLocalStorage<CallSite<Func<CallSite, CodeContext, object, object, object, object>>> siteData) {

    1946. 

  1946.             if (siteData.Data == null) {

    1947. 

  1947.                 siteData.Data = CallSite<Func<CallSite, CodeContext, object, object, object, object>>.Create(

    1948. 

  1948.                     PythonContext.GetContext(context).Invoke(

    1949. 

  1949.                         new CallSignature(2)

    1950. 

  1950.                     )

    1951. 

  1951.                 );

    1952. 

  1952. 

    1953. 

  1953.             }

    1954. 

  1954.         }

    1955. 

  1955. 

    1956. 

  1956.         [ThreadStatic]

    1957. 

  1957.         private static List<PythonModule> _reloadStack;

    1958. 

  1958. 

    1959. 

  1959.         public static object reload(CodeContext/*!*/ context, PythonModule/*!*/ module) {

    1960. 

  1960.             if (module == null) {

    1961. 

  1961.                 throw PythonOps.TypeError("unexpected type: NoneType");

    1962. 

  1962.             }

    1963. 

  1963. 

    1964. 

  1964.             if (_reloadStack == null) {

    1965. 

  1965.                 Interlocked.CompareExchange(ref _reloadStack, new List<PythonModule>(), null);

    1966. 

  1966.             }

    1967. 

  1967. 

    1968. 

  1968.             // if a module attempts to reload it's self while already reloading it's 

    1969. 

  1969.             // self we just return the original module.

    1970. 

  1970.             if (_reloadStack.Contains(module)) {

    1971. 

  1971.                 return module;

    1972. 

  1972.             }

    1973. 

  1973. 

    1974. 

  1974.             _reloadStack.Add(module);

    1975. 

  1975.             try {

    1976. 

  1976.                 return Importer.ReloadModule(context, module);

    1977. 

  1977.             } finally {

    1978. 

  1978.                 _reloadStack.RemoveAt(_reloadStack.Count - 1);

    1979. 

  1979.             }

    1980. 

  1980.         }

    1981. 

  1981. 

    1982. 

  1982.         public static object repr(CodeContext/*!*/ context, object o) {

    1983. 

  1983.             object res = PythonOps.Repr(context, o);

    1984. 

  1984. 

    1985. 

  1985.             if (!(res is String) && !(res is ExtensibleString)) {

    1986. 

  1986.                 throw PythonOps.TypeError("__repr__ returned non-string (type {0})", PythonOps.GetPythonTypeName(o));

    1987. 

  1987.             }

    1988. 

  1988. 

    1989. 

  1989.             return res;

    1990. 

  1990.         }

    1991. 

  1991. 

    1992. 

  1992.         public static PythonType reversed {

    1993. 

  1993.             get {

    1994. 

  1994.                 return DynamicHelpers.GetPythonTypeFromType(typeof(ReversedEnumerator));

    1995. 

  1995.             }

    1996. 

  1996.         }

    1997. 

  1997.         

    1998. 

  1998.         public static double round(double number) {

    1999. 

  1999.             return MathUtils.RoundAwayFromZero(number);

    2000. 

  2000.         }

    2001. 

  2001. 

    2002. 

  2002.         public static double round(double number, int ndigits) {

    2003. 

  2003.             return PythonOps.CheckMath(number, MathUtils.RoundAwayFromZero(number, ndigits));

    2004. 

  2004.         }

    2005. 

  2005. 

    2006. 

  2006.         public static double round(double number, BigInteger ndigits) {

    2007. 

  2007.             int n;

    2008. 

  2008.             if (ndigits.AsInt32(out n)) {

    2009. 

  2009.                 return round(number, n);

    2010. 

  2010.             }

    2011. 

  2011. 

    2012. 

  2012.             return ndigits > 0 ? number : 0.0;

    2013. 

  2013.         }

    2014. 

  2014. 

    2015. 

  2015.         public static double round(double number, double ndigits) {

    2016. 

  2016.             throw PythonOps.TypeError("'float' object cannot be interpreted as an index");

    2017. 

  2017.         }

    2018. 

  2018. 

    2019. 

  2019.         public static void setattr(CodeContext/*!*/ context, object o, string name, object val) {

    2020. 

  2020.             PythonOps.SetAttr(context, o, name, val);

    2021. 

  2021.         }

    2022. 

  2022. 

    2023. 

  2023.         public static PythonType slice {

    2024. 

  2024.             get {

    2025. 

  2025.                 return DynamicHelpers.GetPythonTypeFromType(typeof(Slice));

    2026. 

  2026.             }

    2027. 

  2027.         }

    2028. 

  2028. 

    2029. 

  2029.         public static List sorted(CodeContext/*!*/ context, object iterable) {

    2030. 

  2030.             return sorted(context, iterable, null, null, false);

    2031. 

  2031.         }

    2032. 

  2032. 

    2033. 

  2033.         public static List sorted(CodeContext/*!*/ context, object iterable, object cmp) {

    2034. 

  2034.             return sorted(context, iterable, cmp, null, false);

    2035. 

  2035.         }

    2036. 

  2036. 

    2037. 

  2037.         public static List sorted(CodeContext/*!*/ context, object iterable, object cmp, object key) {

    2038. 

  2038.             return sorted(context, iterable, cmp, key, false);

    2039. 

  2039.         }

    2040. 

  2040. 

    2041. 

  2041.         public static List sorted(CodeContext/*!*/ context,

    2042. 

  2042.             [DefaultParameterValue(null)] object iterable,

    2043. 

  2043.             [DefaultParameterValue(null)]object cmp,

    2044. 

  2044.             [DefaultParameterValue(null)]object key,

    2045. 

  2045.             [DefaultParameterValue(false)]bool reverse) {

    2046. 

  2046. 

    2047. 

  2047.             IEnumerator iter = PythonOps.GetEnumerator(iterable);

    2048. 

  2048.             List l = PythonOps.MakeEmptyList(10);

    2049. 

  2049.             while (iter.MoveNext()) {

    2050. 

  2050.                 l.AddNoLock(iter.Current);

    2051. 

  2051.             }

    2052. 

  2052.             l.sort(context, cmp, key, reverse);

    2053. 

  2053.             return l;

    2054. 

  2054.         }

    2055. 

  2055. 

    2056. 

  2056.         public static PythonType staticmethod {

    2057. 

  2057.             get {

    2058. 

  2058.                 return DynamicHelpers.GetPythonTypeFromType(typeof(staticmethod));

    2059. 

  2059.             }

    2060. 

  2060.         }

    2061. 

  2061. 

    2062. 

  2062.         public static object sum(CodeContext/*!*/ context, object sequence) {

    2063. 

  2063.             return sum(context, sequence, 0);

    2064. 

  2064.         }

    2065. 

  2065. 

    2066. 

  2066.         public static object sum(CodeContext/*!*/ context, [NotNull]List sequence) {

    2067. 

  2067.             return sum(context, sequence, 0);

    2068. 

  2068.         }

    2069. 

  2069. 

    2070. 

  2070.         public static object sum(CodeContext/*!*/ context, [NotNull]PythonTuple sequence) {

    2071. 

  2071.             return sum(context, sequence, 0);

    2072. 

  2072.         }

    2073. 

  2073. 

    2074. 

  2074.         public static object sum(CodeContext/*!*/ context, object sequence, object start) {

    2075. 

  2075.             IEnumerator i = PythonOps.GetEnumerator(sequence);

    2076. 

  2076. 

    2077. 

  2077.             if (start is string) {

    2078. 

  2078.                 throw PythonOps.TypeError("Cannot sum strings, use '{0}'.join(seq)", start);

    2079. 

  2079.             }

    2080. 

  2080. 

    2081. 

  2081.             var sumState = new SumState(context.LanguageContext, start);

    2082. 

  2082.             object ret = start;

    2083. 

  2083.             

    2084. 

  2084.             while (i.MoveNext()) {

    2085. 

  2085.                 SumOne(ref sumState, i.Current);

    2086. 

  2086.             }

    2087. 

  2087. 

    2088. 

  2088.             return sumState.CurrentValue;

    2089. 

  2089.         }

    2090. 

  2090. 

    2091. 

  2091.         public static object sum(CodeContext/*!*/ context, [NotNull]List sequence, object start) {

    2092. 

  2092.             if (start is string) {

    2093. 

  2093.                 throw PythonOps.TypeError("Cannot sum strings, use '{0}'.join(seq)", start);

    2094. 

  2094.             }

    2095. 

  2095. 

    2096. 

  2096.             var sumState = new SumState(context.LanguageContext, start);

    2097. 

  2097.             for (int i = 0; i < sequence._size; i++) {

    2098. 

  2098.                 SumOne(ref sumState, sequence._data[i]);

    2099. 

  2099.             }

    2100. 

  2100. 

    2101. 

  2101.             return sumState.CurrentValue;

    2102. 

  2102.         }

    2103. 

  2103. 

    2104. 

  2104.         public static object sum(CodeContext/*!*/ context, [NotNull]PythonTuple sequence, object start) {

    2105. 

  2105.             if (start is string) {

    2106. 

  2106.                 throw PythonOps.TypeError("Cannot sum strings, use '{0}'.join(seq)", start);

    2107. 

  2107.             }

    2108. 

  2108. 

    2109. 

  2109.             var sumState = new SumState(context.LanguageContext, start);

    2110. 

  2110.             var arr = sequence._data;

    2111. 

  2111.             for (int i = 0; i < arr.Length; i++) {

    2112. 

  2112.                 SumOne(ref sumState, arr[i]);

    2113. 

  2113.             }

    2114. 

  2114. 

    2115. 

  2115.             return sumState.CurrentValue;

    2116. 

  2116.         }

    2117. 

  2117. 

    2118. 

  2118.         #region Optimized sum

    2119. 

  2119. 

    2120. 

  2120.         private static void SumOne(ref SumState state, object current) {

    2121. 

  2121.             if (current != null) {

    2122. 

  2122.                 if (state.CurType == SumVariantType.Int) {

    2123. 

  2123.                     if (current.GetType() == typeof(int)) {

    2124. 

  2124.                         try {

    2125. 

  2125.                             state.IntVal = checked(state.IntVal + ((int)current));

    2126. 

  2126.                         } catch (OverflowException) {

    2127. 

  2127.                             state.BigIntVal = (BigInteger)state.IntVal + (BigInteger)(int)current;

    2128. 

  2128.                             state.CurType = SumVariantType.BigInt;

    2129. 

  2129.                         }

    2130. 

  2130.                     } else if (current.GetType() == typeof(double)) {

    2131. 

  2131.                         state.DoubleVal = state.IntVal + ((double)current);

    2132. 

  2132.                         state.CurType = SumVariantType.Double;

    2133. 

  2133.                     } else if (current.GetType() == typeof(BigInteger)) {

    2134. 

  2134.                         state.BigIntVal = (BigInteger)state.IntVal + (BigInteger)current;

    2135. 

  2135.                         state.CurType = SumVariantType.BigInt;

    2136. 

  2136.                     } else {

    2137. 

  2137.                         SumObject(ref state, state.IntVal, current);

    2138. 

  2138.                     }

    2139. 

  2139.                 } else if (state.CurType == SumVariantType.Double) {

    2140. 

  2140.                     if (current.GetType() == typeof(double)) {

    2141. 

  2141.                         state.DoubleVal = state.DoubleVal + ((double)current);

    2142. 

  2142.                     } else if (current.GetType() == typeof(int)) {

    2143. 

  2143.                         state.DoubleVal = state.DoubleVal + ((int)current);

    2144. 

  2144.                     } else if (current.GetType() == typeof(BigInteger)) {

    2145. 

  2145.                         SumBigIntAndDouble(ref state, (BigInteger)current, state.DoubleVal);

    2146. 

  2146.                     } else {

    2147. 

  2147.                         SumObject(ref state, state.DoubleVal, current);

    2148. 

  2148.                     }

    2149. 

  2149.                 } else if (state.CurType == SumVariantType.BigInt) {

    2150. 

  2150.                     if (current.GetType() == typeof(BigInteger)) {

    2151. 

  2151.                         state.BigIntVal = state.BigIntVal + ((BigInteger)current);

    2152. 

  2152.                     } else if (current.GetType() == typeof(int)) {

    2153. 

  2153.                         state.BigIntVal = state.BigIntVal + ((int)current);

    2154. 

  2154.                     } else if (current.GetType() == typeof(double)) {

    2155. 

  2155.                         SumBigIntAndDouble(ref state, state.BigIntVal, (double)current);

    2156. 

  2156.                     } else {

    2157. 

  2157.                         SumObject(ref state, state.BigIntVal, current);

    2158. 

  2158.                     }

    2159. 

  2159.                 } else if (state.CurType == SumVariantType.Object) {

    2160. 

  2160.                     state.ObjectVal = state.AddSite.Target(state.AddSite, state.ObjectVal, current);

    2161. 

  2161.                 }

    2162. 

  2162.             } else {

    2163. 

  2163.                 SumObject(ref state, state.BigIntVal, current);

    2164. 

  2164.             }

    2165. 

  2165.         }

    2166. 

  2166. #if CLR2

    2167. 

  2167.         private static BigInteger MaxDouble = BigInteger.Create(Double.MaxValue);

    2168. 

  2168.         private static BigInteger MinDouble = BigInteger.Create(Double.MinValue);

    2169. 

  2169. #else

    2170. 

  2170.         private static BigInteger MaxDouble = new BigInteger(Double.MaxValue);

    2171. 

  2171.         private static BigInteger MinDouble = new BigInteger(Double.MinValue);

    2172. 

  2172. #endif

    2173. 

  2173. 

    2174. 

  2174.         private static void SumBigIntAndDouble(ref SumState state, BigInteger bigInt, double dbl) {

    2175. 

  2175.             if (bigInt <= MaxDouble && bigInt >= MinDouble) {

    2176. 

  2176.                 state.DoubleVal = (double)bigInt + dbl;

    2177. 

  2177.                 state.CurType = SumVariantType.Double;

    2178. 

  2178.             } else {

    2179. 

  2179.                 // fallback to normal add to report error

    2180. 

  2180.                 SumObject(ref state, dbl, bigInt);

    2181. 

  2181.             }

    2182. 

  2182.         }

    2183. 

  2183. 

    2184. 

  2184.         private static void SumObject(ref SumState state, object value, object current) {

    2185. 

  2185.             state.ObjectVal = state.AddSite.Target(state.AddSite, value, current);

    2186. 

  2186.             state.CurType = SumVariantType.Object;

    2187. 

  2187.         }

    2188. 

  2188. 

    2189. 

  2189.         enum SumVariantType {

    2190. 

  2190.             Double,

    2191. 

  2191.             Int,

    2192. 

  2192.             BigInt,

    2193. 

  2193.             Object

    2194. 

  2194.         }

    2195. 

  2195. 

    2196. 

  2196.         struct SumState {

    2197. 

  2197.             public double DoubleVal;

    2198. 

  2198.             public int IntVal;

    2199. 

  2199.             public object ObjectVal;

    2200. 

  2200.             public BigInteger BigIntVal;

    2201. 

  2201.             public SumVariantType CurType;

    2202. 

  2202.             public CallSite<Func<CallSite, object, object, object>> AddSite;

    2203. 

  2203. 

    2204. 

  2204.             public SumState(PythonContext context, object start) {

    2205. 

  2205.                 DoubleVal = 0;

    2206. 

  2206.                 IntVal = 0;

    2207. 

  2207.                 ObjectVal = start;

    2208. 

  2208.                 BigIntVal = BigInteger.Zero;

    2209. 

  2209.                 AddSite = context.EnsureAddSite();

    2210. 

  2210. 

    2211. 

  2211.                 if (start != null) {

    2212. 

  2212.                     if (start.GetType() == typeof(int)) {

    2213. 

  2213.                         CurType = SumVariantType.Int;

    2214. 

  2214.                         IntVal = (int)start;

    2215. 

  2215.                     } else if (start.GetType() == typeof(double)) {

    2216. 

  2216.                         CurType = SumVariantType.Double;

    2217. 

  2217.                         DoubleVal = (double)start;

    2218. 

  2218.                     } else if (start.GetType() == typeof(BigInteger)) {

    2219. 

  2219.                         CurType = SumVariantType.BigInt;

    2220. 

  2220.                         BigIntVal = (BigInteger)start;

    2221. 

  2221.                     } else {

    2222. 

  2222.                         CurType = SumVariantType.Object;

    2223. 

  2223.                     }

    2224. 

  2224.                 } else {

    2225. 

  2225.                     CurType = SumVariantType.Object;

    2226. 

  2226.                 }

    2227. 

  2227.             }

    2228. 

  2228. 

    2229. 

  2229.             public object CurrentValue {

    2230. 

  2230.                 get {

    2231. 

  2231.                     switch (CurType) {

    2232. 

  2232.                         case SumVariantType.BigInt: return BigIntVal;

    2233. 

  2233.                         case SumVariantType.Double: return DoubleVal;

    2234. 

  2234.                         case SumVariantType.Int: return IntVal;

    2235. 

  2235.                         case SumVariantType.Object: return ObjectVal;

    2236. 

  2236.                         default: throw Assert.Unreachable;

    2237. 

  2237.                     }

    2238. 

  2238.                 }

    2239. 

  2239.             }

    2240. 

  2240.         }

    2241. 

  2241. 

    2242. 

  2242.         #endregion

    2243. 

  2243. 

    2244. 

  2244.         public static PythonType super {

    2245. 

  2245.             get {

    2246. 

  2246.                 return DynamicHelpers.GetPythonTypeFromType(typeof(Super));

    2247. 

  2247.             }

    2248. 

  2248.         }

    2249. 

  2249. 

    2250. 

  2250.         public static PythonType str {

    2251. 

  2251.             get {

    2252. 

  2252.                 return DynamicHelpers.GetPythonTypeFromType(typeof(string));

    2253. 

  2253.             }

    2254. 

  2254.         }

    2255. 

  2255. 

    2256. 

  2256.         public static PythonType tuple {

    2257. 

  2257.             get {

    2258. 

  2258.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonTuple));

    2259. 

  2259.             }

    2260. 

  2260.         }

    2261. 

  2261. 

    2262. 

  2262.         public static PythonType type {

    2263. 

  2263.             get {

    2264. 

  2264.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonType));

    2265. 

  2265.             }

    2266. 

  2266.         }

    2267. 

  2267. 

    2268. 

  2268.         public static string unichr(int i) {

    2269. 

  2269.             if (i < Char.MinValue || i > Char.MaxValue) {

    2270. 

  2270.                 throw PythonOps.ValueError("{0} is not in required range", i);

    2271. 

  2271.             }

    2272. 

  2272.             return ScriptingRuntimeHelpers.CharToString((char)i);

    2273. 

  2273.         }

    2274. 

  2274. 

    2275. 

  2275.         public static PythonType unicode {

    2276. 

  2276.             get {

    2277. 

  2277.                 return DynamicHelpers.GetPythonTypeFromType(typeof(string));

    2278. 

  2278.             }

    2279. 

  2279.         }

    2280. 

  2280. 

    2281. 

  2281.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]

    2282. 

  2282.         [Documentation("vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.")]

    2283. 

  2283.         public static object vars(CodeContext/*!*/ context) {

    2284. 

  2284.             return locals(context);

    2285. 

  2285.         }

    2286. 

  2286. 

    2287. 

  2287.         public static object vars(CodeContext/*!*/ context, object @object) {

    2288. 

  2288.             object value;

    2289. 

  2289.             if (!PythonOps.TryGetBoundAttr(@object, "__dict__", out value)) {

    2290. 

  2290.                 throw PythonOps.TypeError("vars() argument must have __dict__ attribute");

    2291. 

  2291.             }

    2292. 

  2292.             return value;

    2293. 

  2293.         }

    2294. 

  2294. 

    2295. 

  2295.         public static PythonType xrange {

    2296. 

  2296.             get {

    2297. 

  2297.                 return DynamicHelpers.GetPythonTypeFromType(typeof(XRange));

    2298. 

  2298.             }

    2299. 

  2299.         }

    2300. 

  2300. 

    2301. 

  2301.         public static List zip(object s0, object s1) {

    2302. 

  2302.             IEnumerator i0 = PythonOps.GetEnumerator(s0);

    2303. 

  2303.             IEnumerator i1 = PythonOps.GetEnumerator(s1);

    2304. 

  2304.             List ret = new List();

    2305. 

  2305.             while(true) {

    2306. 

  2306.                 object obj0, obj1;

    2307. 

  2307.                 if(!i0.MoveNext()) {

    2308. 

  2308.                     break;

    2309. 

  2309.                 }

    2310. 

  2310.                 obj0 = i0.Current;

    2311. 

  2311.                 if(!i1.MoveNext()) {

    2312. 

  2312.                     break;

    2313. 

  2313.                 }

    2314. 

  2314. 

    2315. 

  2315.                 obj1 = i1.Current;

    2316. 

  2316.                 ret.AddNoLock(PythonTuple.MakeTuple(obj0, obj1));

    2317. 

  2317.             }

    2318. 

  2318.             return ret;

    2319. 

  2319.         }

    2320. 

  2320. 

    2321. 

  2321.         //??? should we fastpath the 1,2,3 item cases???

    2322. 

  2322.         public static List zip(params object[] seqs) {

    2323. 

  2323.             if (seqs == null) throw PythonOps.TypeError("zip argument must support iteration, got None");

    2324. 

  2324. 

    2325. 

  2325.             int N = seqs.Length;

    2326. 

  2326.             if (N == 2) return zip(seqs[0], seqs[1]);

    2327. 

  2327.             if (N == 0) return PythonOps.MakeList();

    2328. 

  2328.             IEnumerator[] iters = new IEnumerator[N];

    2329. 

  2329.             for (int i = 0; i < N; i++) iters[i] = PythonOps.GetEnumerator(seqs[i]);

    2330. 

  2330. 

    2331. 

  2331.             List ret = new List();

    2332. 

  2332.             while (true) {

    2333. 

  2333.                 object[] items = new object[N];

    2334. 

  2334.                 for (int i = 0; i < N; i++) {

    2335. 

  2335.                     // first iterator which is no longer iterable ends the 

    2336. 

  2336.                     // loop.

    2337. 

  2337.                     if (!iters[i].MoveNext()) return ret;

    2338. 

  2338.                     items[i] = iters[i].Current;

    2339. 

  2339.                 }

    2340. 

  2340.                 ret.AddNoLock(PythonTuple.MakeTuple(items));

    2341. 

  2341.             }

    2342. 

  2342.         }

    2343. 

  2343. 

    2344. 

  2344.         public static PythonType BaseException {

    2345. 

  2345.             get {

    2346. 

  2346.                 return DynamicHelpers.GetPythonTypeFromType(typeof(PythonExceptions.BaseException));

    2347. 

  2347.             }

    2348. 

  2348.         }

    2349. 

  2349. 

    2350. 

  2350.         /// <summary>

    2351. 

  2351.         /// Gets the appropriate LanguageContext to be used for code compiled with Python's compile, eval, execfile, etc...

    2352. 

  2352.         /// </summary>

    2353. 

  2353.         internal static PythonCompilerOptions GetRuntimeGeneratedCodeCompilerOptions(CodeContext/*!*/ context, bool inheritContext, CompileFlags cflags) {

    2354. 

  2354.             PythonCompilerOptions pco;

    2355. 

  2355.             if (inheritContext) {

    2356. 

  2356.                 pco = new PythonCompilerOptions(context.ModuleContext.Features);

    2357. 

  2357.             } else {

    2358. 

  2358.                 pco = DefaultContext.DefaultPythonContext.GetPythonCompilerOptions();

    2359. 

  2359.             }

    2360. 

  2360.             

    2361. 

  2361.             if (((cflags & (CompileFlags.CO_FUTURE_DIVISION | CompileFlags.CO_FUTURE_ABSOLUTE_IMPORT | CompileFlags.CO_FUTURE_WITH_STATEMENT)) != 0)) {

    2362. 

  2362.                 ModuleOptions langFeat = ModuleOptions.None;

    2363. 

  2363.                 if ((cflags & CompileFlags.CO_FUTURE_DIVISION) != 0) {

    2364. 

  2364.                     langFeat |= ModuleOptions.TrueDivision;

    2365. 

  2365.                 }

    2366. 

  2366.                 if ((cflags & CompileFlags.CO_FUTURE_WITH_STATEMENT) != 0) {

    2367. 

  2367.                     langFeat |= ModuleOptions.WithStatement;

    2368. 

  2368.                 }

    2369. 

  2369.                 if ((cflags & CompileFlags.CO_FUTURE_ABSOLUTE_IMPORT) != 0) {

    2370. 

  2370.                     langFeat |= ModuleOptions.AbsoluteImports;

    2371. 

  2371.                 }

    2372. 

  2372.                 pco.Module |= langFeat;

    2373. 

  2373.             } 

    2374. 

  2374. 

    2375. 

  2375.             // The options created this way never creates

    2376. 

  2376.             // optimized module (exec, compile)

    2377. 

  2377.             pco.Module &= ~(ModuleOptions.Optimized | ModuleOptions.Initialize);

    2378. 

  2378.             pco.Module |= ModuleOptions.Interpret | ModuleOptions.ExecOrEvalCode;

    2379. 

  2379.             pco.CompilationMode = CompilationMode.Lookup;

    2380. 

  2380.             return pco;

    2381. 

  2381.         }

    2382. 

  2382. 

    2383. 

  2383.         /// <summary> Returns true if we should inherit our callers context (true division, etc...), false otherwise </summary>

    2384. 

  2384.         private static bool GetCompilerInheritance(object dontInherit) {

    2385. 

  2385.             return dontInherit == null || Converter.ConvertToInt32(dontInherit) == 0;

    2386. 

  2386.         }

    2387. 

  2387. 

    2388. 

  2388.         /// <summary> Returns the default compiler flags or the flags the user specified. </summary>

    2389. 

  2389.         private static CompileFlags GetCompilerFlags(object flags) {

    2390. 

  2390.             CompileFlags cflags = 0;

    2391. 

  2391.             if (flags != null) {

    2392. 

  2392.                 cflags = (CompileFlags)Converter.ConvertToInt32(flags);

    2393. 

  2393.                 if ((cflags & ~(CompileFlags.CO_NESTED | CompileFlags.CO_GENERATOR_ALLOWED | CompileFlags.CO_FUTURE_DIVISION | CompileFlags.CO_DONT_IMPLY_DEDENT | 

    2394. 

  2394.                     CompileFlags.CO_FUTURE_ABSOLUTE_IMPORT | CompileFlags.CO_FUTURE_WITH_STATEMENT)) != 0) {

    2395. 

  2395.                     throw PythonOps.ValueError("unrecognized flags");

    2396. 

  2396.                 }

    2397. 

  2397.             }

    2398. 

  2398. 

    2399. 

  2399.             return cflags;

    2400. 

  2400.         }

    2401. 

  2401. 

    2402. 

  2402.         /// <summary>

    2403. 

  2403.         /// Gets a scope used for executing new code in optionally replacing the globals and locals dictionaries.

    2404. 

  2404.         /// </summary>

    2405. 

  2405.         private static CodeContext/*!*/ GetExecEvalScopeOptional(CodeContext/*!*/ context, PythonDictionary globals, object localsDict, bool copyModule) {

    2406. 

  2406.             Assert.NotNull(context);

    2407. 

  2407. 

    2408. 

  2408.             if (globals == null) globals = Builtin.globals(context);

    2409. 

  2409.             if (localsDict == null) localsDict = locals(context);

    2410. 

  2410. 

    2411. 

  2411.             return GetExecEvalScope(context, globals, GetAttrLocals(context, localsDict), copyModule, true);

    2412. 

  2412.         }

    2413. 

  2413. 

    2414. 

  2414.         internal static CodeContext/*!*/ GetExecEvalScope(CodeContext/*!*/ context, PythonDictionary/*!*/ globals,

    2415. 

  2415.             PythonDictionary locals, bool copyModule, bool setBuiltinsToModule) {

    2416. 

  2416. 

    2417. 

  2417.             Assert.NotNull(context, globals);

    2418. 

  2418.             PythonContext python = PythonContext.GetContext(context);

    2419. 

  2419. 

    2420. 

  2420.             // TODO: Need to worry about propagating changes to MC out?

    2421. 

  2421.             var mc = new ModuleContext(PythonDictionary.FromIAC(context, globals), context.LanguageContext);

    2422. 

  2422.             CodeContext localContext;

    2423. 

  2423.             if (locals == null) {

    2424. 

  2424.                 localContext = mc.GlobalContext;

    2425. 

  2425.             } else {

    2426. 

  2426.                 localContext = new CodeContext(PythonDictionary.FromIAC(context, locals), mc);

    2427. 

  2427.             }

    2428. 

  2428. 

    2429. 

  2429.             if (!globals.ContainsKey("__builtins__")) {

    2430. 

  2430.                 if (setBuiltinsToModule) {

    2431. 

  2431.                     globals["__builtins__"] = python.SystemStateModules["__builtin__"];

    2432. 

  2432.                 } else {

    2433. 

  2433.                     globals["__builtins__"] = python.BuiltinModuleDict;

    2434. 

  2434.                 }

    2435. 

  2435.             }

    2436. 

  2436.             return localContext;

    2437. 

  2437.         }

    2438. 

  2438. 

    2439. 

  2439.         [SpecialName]

    2440. 

  2440.         public static void PerformModuleReload(PythonContext context, PythonDictionary dict) {

    2441. 

  2441.             dict["__debug__"] = ScriptingRuntimeHelpers.BooleanToObject(!context.PythonOptions.Optimize);

    2442. 

  2442.         }

    2443. 

  2443.     }

    2444. 

  2444. }

    2445. 

  2445.