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

public const object __package__ = null;

public const string __name__ = "builtins";

public static object True {

get {

return ScriptingRuntimeHelpers.True;

}

}

public static object False {

get {

return ScriptingRuntimeHelpers.False;

}

}

// This will always stay null

public static readonly object None;

public static IronPython.Runtime.Types.Ellipsis Ellipsis {

get {

return IronPython.Runtime.Types.Ellipsis.Value;

}

}

public static NotImplementedType NotImplemented {

get {

return NotImplementedType.Value;

}

}

public static object exit {

get {

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

}

}

public static object quit {

get {

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

}

}

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

[LightThrowing]

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

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

}

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

[LightThrowing]

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

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

fromlist = new List<object> { fromlist };

}

IList from = fromlist as IList;

PythonContext pc = PythonContext.GetContext(context);

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

if (ret == null) {

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

}

PythonModule mod = ret as PythonModule;

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

string strAttrName;

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

object attrName = from[i];

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

!String.IsNullOrEmpty(strAttrName) &&

strAttrName != "*") {

try {

Importer.ImportFrom(context, mod, strAttrName);

} catch (ImportException) {

continue;

}

}

}

}

return ret;

}

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

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

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

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

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

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

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

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

object value;

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

return value;

}

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

}

public static bool all(object x) {

IEnumerator i = PythonOps.GetEnumerator(x);

while (i.MoveNext()) {

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

}

return true;

}

public static bool any(object x) {

IEnumerator i = PythonOps.GetEnumerator(x);

while (i.MoveNext()) {

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

}

return false;

}

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

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

return PythonOps.CallWithContext(context, func);

}

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

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

}

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

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

}

public static PythonType basestring {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(string));

}

}

public static string bin(int number) {

return Int32Ops.ToBinary(number);

}

public static string bin(Index number) {

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

}

public static string bin(BigInteger number) {

return BigIntegerOps.ToBinary(number);

}

public static string bin(double number) {

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

}

public static PythonType @bool {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(bool));

}

}

public static PythonType buffer {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(PythonBuffer));

}

}

public static PythonType bytes {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(Bytes));

}

}

public static PythonType bytearray {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(ByteArray));

}

}

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

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

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

return PythonOps.IsCallable(context, o);

}

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

[LightThrowing]

public static object chr(int value) {

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

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

}

return ScriptingRuntimeHelpers.CharToString((char)value);

}

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

PythonTypeSlot pts;

PythonType xType = DynamicHelpers.GetPythonType(x);

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

object callable;

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

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

}

}

return NotImplementedType.Value;

}

[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.")]

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

object converted;

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

return PythonTuple.MakeTuple(null, null);

}

converted = TryCoerce(context, x, y);

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

return converted;

}

converted = TryCoerce(context, y, x);

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

PythonTuple pt = converted as PythonTuple;

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

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

}

}

throw PythonOps.TypeError("coercion failed");

}

[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\nsource can either be a string or an AST object")]

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

bool astOnly = false;

int iflags = flags != null ? Converter.ConvertToInt32(flags) : 0;

if ((iflags & _ast.PyCF_ONLY_AST) != 0) {

astOnly = true;

iflags &= ~_ast.PyCF_ONLY_AST;

}

if (mode != "exec" && mode != "eval" && mode != "single") {

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

}

if (source is _ast.AST) {

if (astOnly) {

return source;

} else {

PythonAst ast = _ast.ConvertToPythonAst(context, (_ast.AST) source);

ast.Bind();

ScriptCode code = ast.ToScriptCode();

return ((RunnableScriptCode)code).GetFunctionCode(true);

}

}

string text;

if (source is string)

text = (string)source;

else if (source is PythonBuffer)

text = ((PythonBuffer)source).ToString();

else if (source is ByteArray)

text = ((ByteArray)source).ToString();

else if (source is Bytes)

text = ((Bytes)source).ToString();

else

// cpython accepts either AST or readable buffer object

throw PythonOps.TypeError("srouce can be either AST or string, actual argument: {0}", source.GetType());

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

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

}

text = RemoveBom(text);

bool inheritContext = GetCompilerInheritance(dont_inherit);

CompileFlags cflags = GetCompilerFlags(iflags);

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

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

opts.DontImplyDedent = true;

}

SourceUnit sourceUnit = null;

switch (mode) {

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

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

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

}

return !astOnly ?

(object)FunctionCode.FromSourceUnit(sourceUnit, opts, true) :

(object)_ast.BuildAst(context, sourceUnit, opts, mode);

}

private static string RemoveBom(string source) {

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

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

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

}

return source;

}

public static PythonType classmethod {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(classmethod));

}

}

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

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

}

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

// x = 1e66666

// y = x/x

// cmp(y,y)

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

// we lose object identity.

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

return Int32Ops.Compare(x, y);

}

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

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

return 0;

}

return BigIntegerOps.Compare(x, y);

}

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

return -BigIntegerOps.Compare(y, x);

}

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

return BigIntegerOps.Compare(x, y);

}

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

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

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

if (res >= 1) {

return 1;

} else if (res <= -1) {

return -1;

}

}

return 0;

}

#if FEATURE_SORTKEY

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

return SortKey.Compare(x, y);

}

#endif

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

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

return 0;

}

return x.CompareTo(y);

}

public static PythonType complex {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(Complex));

}

}

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

PythonOps.DeleteAttr(context, o, name);

}

public static PythonType dict {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(PythonDictionary));

}

}

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

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

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

res.sort(context);

return res;

}

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

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

List lret = new List(ret);

lret.sort(context);

return lret;

}

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

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

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

}

public static PythonType enumerate {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(Enumerate));

}

}

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

Debug.Assert(context != null);

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

return eval(context, code, null);

}

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

Debug.Assert(context != null);

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

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

}

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

Debug.Assert(context != null);

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

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

}

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

PythonDictionary attrLocals = null;

if (locals == null) {

if (context.IsTopLevel) {

attrLocals = context.Dict;

}

} else {

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

}

return attrLocals;

}

[LightThrowing]

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

Debug.Assert(context != null);

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

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

}

[LightThrowing]

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

Debug.Assert(context != null);

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

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

}

[LightThrowing]

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

Debug.Assert(context != null);

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

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

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

}

expression = RemoveBom(expression);

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

var pythonContext = PythonContext.GetContext(context);

// TODO: remove TrimStart

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

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

compilerOptions.Module |= ModuleOptions.LightThrow;

compilerOptions.Module &= ~ModuleOptions.ModuleBuiltins;

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

return code.Call(scope);

}

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

execfile(context, filename, null, null);

}

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

execfile(context, filename, globals, null);

}

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

if (filename == null) {

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

}

PythonDictionary g = globals as PythonDictionary;

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

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

}

PythonDictionary l = locals as PythonDictionary;

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

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

}

if (l == null) {

l = g;

}

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

string path = Converter.ConvertToString(filename);

PythonContext pc = PythonContext.GetContext(context);

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

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

}

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

FunctionCode code;

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

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

options.Module &= ~ModuleOptions.Optimized;

try {

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

} catch (UnauthorizedAccessException x) {

throw PythonOps.IOError(x);

}

// Do not attempt evaluation mode for execfile

code.Call(execScope);

}

public static PythonType file {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(PythonFile));

}

}

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

if (function == null) return list;

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

StringBuilder sb = new StringBuilder();

foreach (char c in list) {

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

}

return sb.ToString();

}

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

StringBuilder sb = new StringBuilder();

IEnumerator e = PythonOps.GetEnumerator(list);

while (e.MoveNext()) {

object o = e.Current;

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

if (PythonOps.IsTrue(t)) {

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

}

}

return sb.ToString();

}

/// <summary>

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

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

/// </summary>

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

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

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

object obj = tuple[i];

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

if (PythonOps.IsTrue(t)) {

res.Add(obj);

}

}

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

}

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

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

List ret = new List();

IEnumerator i = PythonOps.GetEnumerator(list);

while (i.MoveNext()) {

if (function == null) {

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

} else {

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

}

}

return ret;

}

public static PythonType @float {

get {

return DynamicHelpers.GetPythonTypeFromType(typeof(double));

}

}

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

object res, formatMethod;

OldInstance oi = argValue as OldInstance;

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

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

} else {

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

PythonTypeOps.TryInvokeBinaryOperator(

context,

argValue,

formatSpec,

"__format__",

out res);

}

string strRes = res as string;

if (strRes == null) {

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

}

return strRes;

}

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

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

}

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

object ret;

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

else return def;

}

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

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

return context.ModuleContext.Globals;

}

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

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

}

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

return PythonContext.Hash(o);

}

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

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

}

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

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

return PythonContext.Hash(o);

}

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

return o;

}

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

return o.GetHashCode();

}

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

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

return hash(context, (object)o);