Without arguments, equivalent to locals().\n\With an argument, equivalent to object.__dict__."); static PyObject*builtin_sum(PyObject *self, PyObject *args){ PyObject *seq; PyObject *result = NULL; PyObject *temp, *item, *iter; if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result)) return NULL; iter = PyObject_GetIter(seq); if (iter == NULL) return NULL; if (result == NULL) { result = PyInt_FromLong(0); if (result == NULL) { Py_DECREF(iter); return NULL; } } else { /* reject string values for 'start' parameter */ if (PyObject_TypeCheck(result, &PyBaseString_Type)) { PyErr_SetString(PyExc_TypeError, "sum() can't sum strings [use ''.join(seq) instead]"); Py_DECREF(iter); return NULL; } Py_INCREF(result); } for(;;) { item = PyIter_Next(iter); if (item == NULL) { /* error, or end-of-sequence */ if (PyErr_Occurred()) { Py_DECREF(result); result = NULL; } break; } temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); result = temp; if (result == NULL) break; } Py_DECREF(iter); return result;} PyDoc_STRVAR(sum_doc,"sum(sequence, start=0) -> value\n\\n\Returns the sum of a sequence of numbers (NOT strings) plus the value\n\of parameter 'start'. When the sequence is empty, returns start."); static PyObject *builtin_isinstance(PyObject *self, PyObject *args){ PyObject *inst; PyObject *cls; int retval; if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls)) return NULL; retval = PyObject_IsInstance(inst, cls); if (retval < 0) return NULL; return PyBool_FromLong(retval);} PyDoc_STRVAR(isinstance_doc,"isinstance(object, class-or-type-or-tuple) -> bool\n\\n\Return whether an object is an instance of a class or of a subclass thereof.\n\With a type as second argument, return whether that is the object's type.\n\The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\isinstance(x, A) or isinstance(x, B) or ... (etc.)."); static PyObject *builtin_issubclass(PyObject *self, PyObject *args){ PyObject *derived; PyObject *cls; int retval; if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls)) return NULL; retval = PyObject_IsSubclass(derived, cls); if (retval < 0) return NULL; return PyBool_FromLong(retval);} PyDoc_STRVAR(issubclass_doc,"issubclass(C, B) -> bool\n\\n\Return whether class C is a subclass (i.e., a derived class) of class B.\n\When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.)."); static PyObject*builtin_zip(PyObject *self, PyObject *args){ PyObject *ret; const Py_ssize_t itemsize = PySequence_Length(args); Py_ssize_t i; PyObject *itlist; /* tuple of iterators */ Py_ssize_t len; /* guess at result length */ if (itemsize == 0) return PyList_New(0); /* args must be a tuple */ assert(PyTuple_Check(args)); /* Guess at result length: the shortest of the input lengths. If some argument refuses to say, we refuse to guess too, lest an argument like xrange(sys.maxint) lead us astray.*/ len = -1; /* unknown */ for (i = 0; i < itemsize; ++i) { PyObject *item = PyTuple_GET_ITEM(args, i); Py_ssize_t thislen = _PyObject_LengthHint(item); if (thislen < 0) { if (!PyErr_ExceptionMatches(PyExc_TypeError) && !PyErr_ExceptionMatches(PyExc_AttributeError)) { return NULL; } PyErr_Clear(); len = -1; break; } else if (len < 0 || thislen < len) len = thislen; } /* allocate result list */ if (len < 0) len = 10; /* arbitrary */ if ((ret = PyList_New(len)) == NULL) return NULL; /* obtain iterators */ itlist = PyTuple_New(itemsize); if (itlist == NULL) goto Fail_ret; for (i = 0; i < itemsize; ++i) { PyObject *item = PyTuple_GET_ITEM(args, i); PyObject *it = PyObject_GetIter(item); if (it == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Format(PyExc_TypeError, "zip argument #%zd must support iteration", i+1); goto Fail_ret_itlist; } PyTuple_SET_ITEM(itlist, i, it); } /* build result into ret list */ for (i = 0; ; ++i) { int j; PyObject *next = PyTuple_New(itemsize); if (!next) goto Fail_ret_itlist; for (j = 0; j < itemsize; j++) { PyObject *it = PyTuple_GET_ITEM(itlist, j); PyObject *item = PyIter_Next(it); if (!item) { if (PyErr_Occurred()) { Py_DECREF(ret); ret = NULL; } Py_DECREF(next); Py_DECREF(itlist); goto Done; } PyTuple_SET_ITEM(next, j, item); } if (i < len) PyList_SET_ITEM(ret, i, next); else { int status = PyList_Append(ret, next); Py_DECREF(next); ++len; if (status < 0) goto Fail_ret_itlist; } } Done: if (ret != NULL && i < len) { /* The list is too big. */ if (PyList_SetSlice(ret, i, len, NULL) < 0) return NULL; } return ret; Fail_ret_itlist: Py_DECREF(itlist);Fail_ret: Py_DECREF(ret); return NULL;} PyDoc_STRVAR(zip_doc,"zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\\n\Return a list of tuples, where each tuple contains the i-th element\n\from each of the argument sequences. The returned list is truncated\n\in length to the length of the shortest argument sequence."); static PyMethodDef builtin_methods[] = { {"__import__", (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc}, {"abs", builtin_abs, METH_O, abs_doc}, {"all", builtin_all, METH_O, all_doc}, {"any", builtin_any, METH_O, any_doc}, {"apply", builtin_apply, METH_VARARGS, apply_doc}, {"callable", builtin_callable, METH_O, callable_doc}, {"chr", builtin_chr, METH_VARARGS, chr_doc}, {"cmp", builtin_cmp, METH_VARARGS, cmp_doc}, {"coerce", builtin_coerce, METH_VARARGS, coerce_doc}, {"compile", builtin_compile, METH_VARARGS, compile_doc}, {"delattr", builtin_delattr, METH_VARARGS, delattr_doc}, {"dir", builtin_dir, METH_VARARGS, dir_doc}, {"divmod", builtin_divmod, METH_VARARGS, divmod_doc}, {"eval", builtin_eval, METH_VARARGS, eval_doc}, {"execfile", builtin_execfile, METH_VARARGS, execfile_doc}, {"filter", builtin_filter, METH_VARARGS, filter_doc}, {"getattr", builtin_getattr, METH_VARARGS, getattr_doc}, {"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc}, {"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc}, {"hash", builtin_hash, METH_O, hash_doc}, {"hex", builtin_hex, METH_O, hex_doc}, {"id", builtin_id, METH_O, id_doc}, {"input", builtin_input, METH_VARARGS, input_doc}, {"intern", builtin_intern, METH_VARARGS, intern_doc}, {"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc}, {"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc}, {"iter", builtin_iter, METH_VARARGS, iter_doc}, {"len", builtin_len, METH_O, len_doc}, {"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc}, {"map", builtin_map, METH_VARARGS, map_doc}, {"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc}, {"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc}, {"oct", builtin_oct, METH_O, oct_doc}, {"open", (PyCFunction)builtin_open, METH_VARARGS | METH_KEYWORDS, open_doc}, {"ord", builtin_ord, METH_O, ord_doc}, {"pow", builtin_pow, METH_VARARGS, pow_doc}, {"range", builtin_range, METH_VARARGS, range_doc}, {"raw_input", builtin_raw_input, METH_VARARGS, raw_input_doc}, {"reduce", builtin_reduce, METH_VARARGS, reduce_doc}, {"reload", builtin_reload, METH_O, reload_doc}, {"repr", builtin_repr, METH_O, repr_doc}, {"round", (PyCFunction)builtin_round, METH_VARARGS | METH_KEYWORDS, round_doc}, {"setattr", builtin_setattr, METH_VARARGS, setattr_doc}, {"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc}, {"sum", builtin_sum, METH_VARARGS, sum_doc},#ifdef Py_USING_UNICODE {"unichr", builtin_unichr, METH_VARARGS, unichr_doc},#endif {"vars", builtin_vars, METH_VARARGS, vars_doc}, {"zip", builtin_zip, METH_VARARGS, zip_doc}, {NULL, NULL},}; PyDoc_STRVAR(builtin_doc,"Built-in functions, exceptions, and other objects.\n\\n\Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices."); PyObject *_PyBuiltin_Init(void){ PyObject *mod, *dict, *debug; mod = Py_InitModule4("__builtin__", builtin_methods, builtin_doc, (PyObject *)NULL, PYTHON_API_VERSION); if (mod == NULL) return NULL; dict = PyModule_GetDict(mod); #ifdef Py_TRACE_REFS /* __builtin__ exposes a number of statically allocated objects * that, before this code was added in 2.3, never showed up in * the list of "all objects" maintained by Py_TRACE_REFS. As a * result, programs leaking references to None and False (etc) * couldn't be diagnosed by examining sys.getobjects(0). */#define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)#else#define ADD_TO_ALL(OBJECT) (void)0#endif #define SETBUILTIN(NAME, OBJECT) \ if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \ return NULL; \ ADD_TO_ALL(OBJECT) SETBUILTIN("None", Py_None); SETBUILTIN("Ellipsis", Py_Ellipsis); SETBUILTIN("NotImplemented", Py_NotImplemented); SETBUILTIN("False", Py_False); SETBUILTIN("True", Py_True); SETBUILTIN("basestring", &PyBaseString_Type); SETBUILTIN("bool", &PyBool_Type); SETBUILTIN("buffer", &PyBuffer_Type); SETBUILTIN("classmethod", &PyClassMethod_Type);#ifndef WITHOUT_COMPLEX SETBUILTIN("complex", &PyComplex_Type);#endif SETBUILTIN("dict", &PyDict_Type); SETBUILTIN("enumerate", &PyEnum_Type); SETBUILTIN("file", &PyFile_Type); SETBUILTIN("float", &PyFloat_Type); SETBUILTIN("frozenset", &PyFrozenSet_Type); SETBUILTIN("property", &PyProperty_Type); SETBUILTIN("int", &PyInt_Type); SETBUILTIN("list", &PyList_Type); SETBUILTIN("long", &PyLong_Type); SETBUILTIN("object", &PyBaseObject_Type); SETBUILTIN("reversed", &PyReversed_Type); SETBUILTIN("set", &PySet_Type); SETBUILTIN("slice", &PySlice_Type); SETBUILTIN("staticmethod", &PyStaticMethod_Type); SETBUILTIN("str", &PyString_Type); SETBUILTIN("super", &PySuper_Type); SETBUILTIN("tuple", &PyTuple_Type); SETBUILTIN("type", &PyType_Type); SETBUILTIN("xrange", &PyRange_Type);#ifdef Py_USING_UNICODE SETBUILTIN("unicode", &PyUnicode_Type);#endif debug = PyBool_FromLong(Py_OptimizeFlag == 0); if (PyDict_SetItemString(dict, "__debug__", debug) < 0) { Py_XDECREF(debug); return NULL; } Py_XDECREF(debug); return mod;#undef ADD_TO_ALL#undef SETBUILTIN} /* Helper for filter(): filter a tuple through a function */ static PyObject *filtertuple(PyObject *func, PyObject *tuple){ PyObject *result; Py_ssize_t i, j; Py_ssize_t len = PyTuple_Size(tuple); if (len == 0) { if (PyTuple_CheckExact(tuple)) Py_INCREF(tuple); else tuple = PyTuple_New(0); return tuple; } if ((result = PyTuple_New(len)) == NULL) return NULL; for (i = j = 0; i < len; ++i) { PyObject *item, *good; int ok; if (tuple->ob_type->tp_as_sequence && tuple->ob_type->tp_as_sequence->sq_item) { item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i); if (item == NULL) goto Fail_1; } else { PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple"); goto Fail_1; } if (func == Py_None) { Py_INCREF(item); good = item; } else { PyObject *arg = PyTuple_Pack(1, item); if (arg == NULL) { Py_DECREF(item); goto Fail_1; } good = PyEval_CallObject(func, arg); Py_DECREF(arg); if (good == NULL) { Py_DECREF(item); goto Fail_1; } } ok = PyObject_IsTrue(good); Py_DECREF(good); if (ok) { if (PyTuple_SetItem(result, j++, item) < 0) goto Fail_1; } else Py_DECREF(item); } if (_PyTuple_Resize(&result, j) < 0) return NULL; return result; Fail_1: Py_DECREF(result); return NULL;} /* Helper for filter(): filter a string through a function */ static PyObject *filterstring(PyObject *func, PyObject *strobj){ PyObject *result; Py_ssize_t i, j; Py_ssize_t len = PyString_Size(strobj); Py_ssize_t outlen = len; if (func == Py_None) { /* If it's a real string we can return the original, * as no character is ever false and __getitem__ * does return this character. If it's a subclass * we must go through the __getitem__ loop */ if (PyString_CheckExact(strobj)) { Py_INCREF(strobj); return strobj; } } if ((result = PyString_FromStringAndSize(NULL, len)) == NULL) return NULL; for (i = j = 0; i < len; ++i) { PyObject *item; int ok; item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i); if (item == NULL) goto Fail_1; if (func==Py_None) { ok = 1; } else { PyObject *arg, *good; arg = PyTuple_Pack(1, item); if (arg == NULL) { Py_DECREF(item); goto Fail_1; } good = PyEval_CallObject(func, arg); Py_DECREF(arg); if (good == NULL) { Py_DECREF(item); goto Fail_1; } ok = PyObject_IsTrue(good); Py_DECREF(good); } if (ok) { Py_ssize_t reslen; if (!PyString_Check(item)) { PyErr_SetString(PyExc_TypeError, "can't filter str to str:" " __getitem__ returned different type"); Py_DECREF(item); goto Fail_1; } reslen = PyString_GET_SIZE(item); if (reslen == 1) { PyString_AS_STRING(result)[j++] = PyString_AS_STRING(item)[0]; } else { /* do we need more space? */ Py_ssize_t need = j + reslen + len-i-1; if (need > outlen) { /* overallocate, to avoid reallocations */ if (need<2*outlen) need = 2*outlen; if (_PyString_Resize(&result, need)) { Py_DECREF(item);Lines 2001–2500 of 2620. Previous lines Load more
Without arguments, equivalent to locals().\n\ With an argument, equivalent to object.__dict__."); static PyObject* builtin_sum(PyObject *self, PyObject *args) { PyObject *seq; PyObject *result = NULL; PyObject *temp, *item, *iter; if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result)) return NULL; iter = PyObject_GetIter(seq); if (iter == NULL) return NULL; if (result == NULL) { result = PyInt_FromLong(0); if (result == NULL) { Py_DECREF(iter); return NULL; } } else { /* reject string values for 'start' parameter */ if (PyObject_TypeCheck(result, &PyBaseString_Type)) { PyErr_SetString(PyExc_TypeError, "sum() can't sum strings [use ''.join(seq) instead]"); Py_DECREF(iter); return NULL; } Py_INCREF(result); } for(;;) { item = PyIter_Next(iter); if (item == NULL) { /* error, or end-of-sequence */ if (PyErr_Occurred()) { Py_DECREF(result); result = NULL; } break; } temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); result = temp; if (result == NULL) break; } Py_DECREF(iter); return result; } PyDoc_STRVAR(sum_doc, "sum(sequence, start=0) -> value\n\ \n\ Returns the sum of a sequence of numbers (NOT strings) plus the value\n\ of parameter 'start'. When the sequence is empty, returns start."); static PyObject * builtin_isinstance(PyObject *self, PyObject *args) { PyObject *inst; PyObject *cls; int retval; if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls)) return NULL; retval = PyObject_IsInstance(inst, cls); if (retval < 0) return NULL; return PyBool_FromLong(retval); } PyDoc_STRVAR(isinstance_doc, "isinstance(object, class-or-type-or-tuple) -> bool\n\ \n\ Return whether an object is an instance of a class or of a subclass thereof.\n\ With a type as second argument, return whether that is the object's type.\n\ The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\ isinstance(x, A) or isinstance(x, B) or ... (etc.)."); static PyObject * builtin_issubclass(PyObject *self, PyObject *args) { PyObject *derived; PyObject *cls; int retval; if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls)) return NULL; retval = PyObject_IsSubclass(derived, cls); if (retval < 0) return NULL; return PyBool_FromLong(retval); } PyDoc_STRVAR(issubclass_doc, "issubclass(C, B) -> bool\n\ \n\ Return whether class C is a subclass (i.e., a derived class) of class B.\n\ When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\ is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.)."); static PyObject* builtin_zip(PyObject *self, PyObject *args) { PyObject *ret; const Py_ssize_t itemsize = PySequence_Length(args); Py_ssize_t i; PyObject *itlist; /* tuple of iterators */ Py_ssize_t len; /* guess at result length */ if (itemsize == 0) return PyList_New(0); /* args must be a tuple */ assert(PyTuple_Check(args)); /* Guess at result length: the shortest of the input lengths. If some argument refuses to say, we refuse to guess too, lest an argument like xrange(sys.maxint) lead us astray.*/ len = -1; /* unknown */ for (i = 0; i < itemsize; ++i) { PyObject *item = PyTuple_GET_ITEM(args, i); Py_ssize_t thislen = _PyObject_LengthHint(item); if (thislen < 0) { if (!PyErr_ExceptionMatches(PyExc_TypeError) && !PyErr_ExceptionMatches(PyExc_AttributeError)) { return NULL; } PyErr_Clear(); len = -1; break; } else if (len < 0 || thislen < len) len = thislen; } /* allocate result list */ if (len < 0) len = 10; /* arbitrary */ if ((ret = PyList_New(len)) == NULL) return NULL; /* obtain iterators */ itlist = PyTuple_New(itemsize); if (itlist == NULL) goto Fail_ret; for (i = 0; i < itemsize; ++i) { PyObject *item = PyTuple_GET_ITEM(args, i); PyObject *it = PyObject_GetIter(item); if (it == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Format(PyExc_TypeError, "zip argument #%zd must support iteration", i+1); goto Fail_ret_itlist; } PyTuple_SET_ITEM(itlist, i, it); } /* build result into ret list */ for (i = 0; ; ++i) { int j; PyObject *next = PyTuple_New(itemsize); if (!next) goto Fail_ret_itlist; for (j = 0; j < itemsize; j++) { PyObject *it = PyTuple_GET_ITEM(itlist, j); PyObject *item = PyIter_Next(it); if (!item) { if (PyErr_Occurred()) { Py_DECREF(ret); ret = NULL; } Py_DECREF(next); Py_DECREF(itlist); goto Done; } PyTuple_SET_ITEM(next, j, item); } if (i < len) PyList_SET_ITEM(ret, i, next); else { int status = PyList_Append(ret, next); Py_DECREF(next); ++len; if (status < 0) goto Fail_ret_itlist; } } Done: if (ret != NULL && i < len) { /* The list is too big. */ if (PyList_SetSlice(ret, i, len, NULL) < 0) return NULL; } return ret; Fail_ret_itlist: Py_DECREF(itlist); Fail_ret: Py_DECREF(ret); return NULL; } PyDoc_STRVAR(zip_doc, "zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\ \n\ Return a list of tuples, where each tuple contains the i-th element\n\ from each of the argument sequences. The returned list is truncated\n\ in length to the length of the shortest argument sequence."); static PyMethodDef builtin_methods[] = { {"__import__", (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc}, {"abs", builtin_abs, METH_O, abs_doc}, {"all", builtin_all, METH_O, all_doc}, {"any", builtin_any, METH_O, any_doc}, {"apply", builtin_apply, METH_VARARGS, apply_doc}, {"callable", builtin_callable, METH_O, callable_doc}, {"chr", builtin_chr, METH_VARARGS, chr_doc}, {"cmp", builtin_cmp, METH_VARARGS, cmp_doc}, {"coerce", builtin_coerce, METH_VARARGS, coerce_doc}, {"compile", builtin_compile, METH_VARARGS, compile_doc}, {"delattr", builtin_delattr, METH_VARARGS, delattr_doc}, {"dir", builtin_dir, METH_VARARGS, dir_doc}, {"divmod", builtin_divmod, METH_VARARGS, divmod_doc}, {"eval", builtin_eval, METH_VARARGS, eval_doc}, {"execfile", builtin_execfile, METH_VARARGS, execfile_doc}, {"filter", builtin_filter, METH_VARARGS, filter_doc}, {"getattr", builtin_getattr, METH_VARARGS, getattr_doc}, {"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc}, {"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc}, {"hash", builtin_hash, METH_O, hash_doc}, {"hex", builtin_hex, METH_O, hex_doc}, {"id", builtin_id, METH_O, id_doc}, {"input", builtin_input, METH_VARARGS, input_doc}, {"intern", builtin_intern, METH_VARARGS, intern_doc}, {"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc}, {"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc}, {"iter", builtin_iter, METH_VARARGS, iter_doc}, {"len", builtin_len, METH_O, len_doc}, {"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc}, {"map", builtin_map, METH_VARARGS, map_doc}, {"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc}, {"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc}, {"oct", builtin_oct, METH_O, oct_doc}, {"open", (PyCFunction)builtin_open, METH_VARARGS | METH_KEYWORDS, open_doc}, {"ord", builtin_ord, METH_O, ord_doc}, {"pow", builtin_pow, METH_VARARGS, pow_doc}, {"range", builtin_range, METH_VARARGS, range_doc}, {"raw_input", builtin_raw_input, METH_VARARGS, raw_input_doc}, {"reduce", builtin_reduce, METH_VARARGS, reduce_doc}, {"reload", builtin_reload, METH_O, reload_doc}, {"repr", builtin_repr, METH_O, repr_doc}, {"round", (PyCFunction)builtin_round, METH_VARARGS | METH_KEYWORDS, round_doc}, {"setattr", builtin_setattr, METH_VARARGS, setattr_doc}, {"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc}, {"sum", builtin_sum, METH_VARARGS, sum_doc}, #ifdef Py_USING_UNICODE {"unichr", builtin_unichr, METH_VARARGS, unichr_doc}, #endif {"vars", builtin_vars, METH_VARARGS, vars_doc}, {"zip", builtin_zip, METH_VARARGS, zip_doc}, {NULL, NULL}, }; PyDoc_STRVAR(builtin_doc, "Built-in functions, exceptions, and other objects.\n\ \n\ Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices."); PyObject * _PyBuiltin_Init(void) { PyObject *mod, *dict, *debug; mod = Py_InitModule4("__builtin__", builtin_methods, builtin_doc, (PyObject *)NULL, PYTHON_API_VERSION); if (mod == NULL) return NULL; dict = PyModule_GetDict(mod); #ifdef Py_TRACE_REFS /* __builtin__ exposes a number of statically allocated objects * that, before this code was added in 2.3, never showed up in * the list of "all objects" maintained by Py_TRACE_REFS. As a * result, programs leaking references to None and False (etc) * couldn't be diagnosed by examining sys.getobjects(0). */ #define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0) #else #define ADD_TO_ALL(OBJECT) (void)0 #endif #define SETBUILTIN(NAME, OBJECT) \ if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \ return NULL; \ ADD_TO_ALL(OBJECT) SETBUILTIN("None", Py_None); SETBUILTIN("Ellipsis", Py_Ellipsis); SETBUILTIN("NotImplemented", Py_NotImplemented); SETBUILTIN("False", Py_False); SETBUILTIN("True", Py_True); SETBUILTIN("basestring", &PyBaseString_Type); SETBUILTIN("bool", &PyBool_Type); SETBUILTIN("buffer", &PyBuffer_Type); SETBUILTIN("classmethod", &PyClassMethod_Type); #ifndef WITHOUT_COMPLEX SETBUILTIN("complex", &PyComplex_Type); #endif SETBUILTIN("dict", &PyDict_Type); SETBUILTIN("enumerate", &PyEnum_Type); SETBUILTIN("file", &PyFile_Type); SETBUILTIN("float", &PyFloat_Type); SETBUILTIN("frozenset", &PyFrozenSet_Type); SETBUILTIN("property", &PyProperty_Type); SETBUILTIN("int", &PyInt_Type); SETBUILTIN("list", &PyList_Type); SETBUILTIN("long", &PyLong_Type); SETBUILTIN("object", &PyBaseObject_Type); SETBUILTIN("reversed", &PyReversed_Type); SETBUILTIN("set", &PySet_Type); SETBUILTIN("slice", &PySlice_Type); SETBUILTIN("staticmethod", &PyStaticMethod_Type); SETBUILTIN("str", &PyString_Type); SETBUILTIN("super", &PySuper_Type); SETBUILTIN("tuple", &PyTuple_Type); SETBUILTIN("type", &PyType_Type); SETBUILTIN("xrange", &PyRange_Type); #ifdef Py_USING_UNICODE SETBUILTIN("unicode", &PyUnicode_Type); #endif debug = PyBool_FromLong(Py_OptimizeFlag == 0); if (PyDict_SetItemString(dict, "__debug__", debug) < 0) { Py_XDECREF(debug); return NULL; } Py_XDECREF(debug); return mod; #undef ADD_TO_ALL #undef SETBUILTIN } /* Helper for filter(): filter a tuple through a function */ static PyObject * filtertuple(PyObject *func, PyObject *tuple) { PyObject *result; Py_ssize_t i, j; Py_ssize_t len = PyTuple_Size(tuple); if (len == 0) { if (PyTuple_CheckExact(tuple)) Py_INCREF(tuple); else tuple = PyTuple_New(0); return tuple; } if ((result = PyTuple_New(len)) == NULL) return NULL; for (i = j = 0; i < len; ++i) { PyObject *item, *good; int ok; if (tuple->ob_type->tp_as_sequence && tuple->ob_type->tp_as_sequence->sq_item) { item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i); if (item == NULL) goto Fail_1; } else { PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple"); goto Fail_1; } if (func == Py_None) { Py_INCREF(item); good = item; } else { PyObject *arg = PyTuple_Pack(1, item); if (arg == NULL) { Py_DECREF(item); goto Fail_1; } good = PyEval_CallObject(func, arg); Py_DECREF(arg); if (good == NULL) { Py_DECREF(item); goto Fail_1; } } ok = PyObject_IsTrue(good); Py_DECREF(good); if (ok) { if (PyTuple_SetItem(result, j++, item) < 0) goto Fail_1; } else Py_DECREF(item); } if (_PyTuple_Resize(&result, j) < 0) return NULL; return result; Fail_1: Py_DECREF(result); return NULL; } /* Helper for filter(): filter a string through a function */ static PyObject * filterstring(PyObject *func, PyObject *strobj) { PyObject *result; Py_ssize_t i, j; Py_ssize_t len = PyString_Size(strobj); Py_ssize_t outlen = len; if (func == Py_None) { /* If it's a real string we can return the original, * as no character is ever false and __getitem__ * does return this character. If it's a subclass * we must go through the __getitem__ loop */ if (PyString_CheckExact(strobj)) { Py_INCREF(strobj); return strobj; } } if ((result = PyString_FromStringAndSize(NULL, len)) == NULL) return NULL; for (i = j = 0; i < len; ++i) { PyObject *item; int ok; item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i); if (item == NULL) goto Fail_1; if (func==Py_None) { ok = 1; } else { PyObject *arg, *good; arg = PyTuple_Pack(1, item); if (arg == NULL) { Py_DECREF(item); goto Fail_1; } good = PyEval_CallObject(func, arg); Py_DECREF(arg); if (good == NULL) { Py_DECREF(item); goto Fail_1; } ok = PyObject_IsTrue(good); Py_DECREF(good); } if (ok) { Py_ssize_t reslen; if (!PyString_Check(item)) { PyErr_SetString(PyExc_TypeError, "can't filter str to str:" " __getitem__ returned different type"); Py_DECREF(item); goto Fail_1; } reslen = PyString_GET_SIZE(item); if (reslen == 1) { PyString_AS_STRING(result)[j++] = PyString_AS_STRING(item)[0]; } else { /* do we need more space? */ Py_ssize_t need = j + reslen + len-i-1; if (need > outlen) { /* overallocate, to avoid reallocations */ if (need<2*outlen) need = 2*outlen; if (_PyString_Resize(&result, need)) { Py_DECREF(item);