Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Python/bltinmodule.c

    r2 r391  
    99
    1010#include <ctype.h>
     11#include <float.h> /* for DBL_MANT_DIG and friends */
    1112
    1213#ifdef RISCOS
    … …  
    3536builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)
    3637{
    37         static char *kwlist[] = {"name", "globals", "locals", "fromlist",
    38                                 "level", 0};
    39         char *name;
    40         PyObject *globals = NULL;
    41         PyObject *locals = NULL;
    42         PyObject *fromlist = NULL;
    43         int level = -1;
    44 
    45         if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",
    46                         kwlist, &name, &globals, &locals, &fromlist, &level))
    47                 return NULL;
    48         return PyImport_ImportModuleLevel(name, globals, locals,
    49                                           fromlist, level);
     38    static char *kwlist[] = {"name", "globals", "locals", "fromlist",
     39                            "level", 0};
     40    char *name;
     41    PyObject *globals = NULL;
     42    PyObject *locals = NULL;
     43    PyObject *fromlist = NULL;
     44    int level = -1;
     45
     46    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",
     47                    kwlist, &name, &globals, &locals, &fromlist, &level))
     48        return NULL;
     49    return PyImport_ImportModuleLevel(name, globals, locals,
     50                                      fromlist, level);
    5051}
    5152
    … …  
    5354"__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\
    5455\n\
    55 Import a module.  The globals are only used to determine the context;\n\
    56 they are not modified.  The locals are currently unused.  The fromlist\n\
     56Import a module. Because this function is meant for use by the Python\n\
     57interpreter and not for general use it is better to use\n\
     58importlib.import_module() to programmatically import a module.\n\
     59\n\
     60The globals argument is only used to determine the context;\n\
     61they are not modified.  The locals argument is unused.  The fromlist\n\
    5762should be a list of names to emulate ``from name import ...'', or an\n\
    5863empty list to emulate ``import name''.\n\
    … …  
    6873builtin_abs(PyObject *self, PyObject *v)
    6974{
    70         return PyNumber_Absolute(v);
     75    return PyNumber_Absolute(v);
    7176}
    7277
    … …  
    7984builtin_all(PyObject *self, PyObject *v)
    8085{
    81         PyObject *it, *item;
    82         PyObject *(*iternext)(PyObject *);
    83         int cmp;
    84 
    85         it = PyObject_GetIter(v);
    86         if (it == NULL)
    87                 return NULL;
    88         iternext = *Py_TYPE(it)->tp_iternext;
    89 
    90         for (;;) {
    91                 item = iternext(it);
    92                 if (item == NULL)
    93                         break;
    94                 cmp = PyObject_IsTrue(item);
    95                 Py_DECREF(item);
    96                 if (cmp < 0) {
    97                         Py_DECREF(it);
    98                         return NULL;
    99                 }
    100                 if (cmp == 0) {
    101                         Py_DECREF(it);
    102                         Py_RETURN_FALSE;
    103                 }
    104         }
    105         Py_DECREF(it);
    106         if (PyErr_Occurred()) {
    107                 if (PyErr_ExceptionMatches(PyExc_StopIteration))
    108                         PyErr_Clear();
    109                 else
    110                         return NULL;
    111         }
    112         Py_RETURN_TRUE;
     86    PyObject *it, *item;
     87    PyObject *(*iternext)(PyObject *);
     88    int cmp;
     89
     90    it = PyObject_GetIter(v);
     91    if (it == NULL)
     92        return NULL;
     93    iternext = *Py_TYPE(it)->tp_iternext;
     94
     95    for (;;) {
     96        item = iternext(it);
     97        if (item == NULL)
     98            break;
     99        cmp = PyObject_IsTrue(item);
     100        Py_DECREF(item);
     101        if (cmp < 0) {
     102            Py_DECREF(it);
     103            return NULL;
     104        }
     105        if (cmp == 0) {
     106            Py_DECREF(it);
     107            Py_RETURN_FALSE;
     108        }
     109    }
     110    Py_DECREF(it);
     111    if (PyErr_Occurred()) {
     112        if (PyErr_ExceptionMatches(PyExc_StopIteration))
     113            PyErr_Clear();
     114        else
     115            return NULL;
     116    }
     117    Py_RETURN_TRUE;
    113118}
    114119
    … …  
    116121"all(iterable) -> bool\n\
    117122\n\
    118 Return True if bool(x) is True for all values x in the iterable.");
     123Return True if bool(x) is True for all values x in the iterable.\n\
     124If the iterable is empty, return True.");
    119125
    120126static PyObject *
    121127builtin_any(PyObject *self, PyObject *v)
    122128{
    123         PyObject *it, *item;
    124         PyObject *(*iternext)(PyObject *);
    125         int cmp;
    126 
    127         it = PyObject_GetIter(v);
    128         if (it == NULL)
    129                 return NULL;
    130         iternext = *Py_TYPE(it)->tp_iternext;
    131 
    132         for (;;) {
    133                 item = iternext(it);
    134                 if (item == NULL)
    135                         break;
    136                 cmp = PyObject_IsTrue(item);
    137                 Py_DECREF(item);
    138                 if (cmp < 0) {
    139                         Py_DECREF(it);
    140                         return NULL;
    141                 }
    142                 if (cmp == 1) {
    143                         Py_DECREF(it);
    144                         Py_RETURN_TRUE;
    145                 }
    146         }
    147         Py_DECREF(it);
    148         if (PyErr_Occurred()) {
    149                 if (PyErr_ExceptionMatches(PyExc_StopIteration))
    150                         PyErr_Clear();
    151                 else
    152                         return NULL;
    153         }
    154         Py_RETURN_FALSE;
     129    PyObject *it, *item;
     130    PyObject *(*iternext)(PyObject *);
     131    int cmp;
     132
     133    it = PyObject_GetIter(v);
     134    if (it == NULL)
     135        return NULL;
     136    iternext = *Py_TYPE(it)->tp_iternext;
     137
     138    for (;;) {
     139        item = iternext(it);
     140        if (item == NULL)
     141            break;
     142        cmp = PyObject_IsTrue(item);
     143        Py_DECREF(item);
     144        if (cmp < 0) {
     145            Py_DECREF(it);
     146            return NULL;
     147        }
     148        if (cmp == 1) {
     149            Py_DECREF(it);
     150            Py_RETURN_TRUE;
     151        }
     152    }
     153    Py_DECREF(it);
     154    if (PyErr_Occurred()) {
     155        if (PyErr_ExceptionMatches(PyExc_StopIteration))
     156            PyErr_Clear();
     157        else
     158            return NULL;
     159    }
     160    Py_RETURN_FALSE;
    155161}
    156162
    … …  
    158164"any(iterable) -> bool\n\
    159165\n\
    160 Return True if bool(x) is True for any x in the iterable.");
     166Return True if bool(x) is True for any x in the iterable.\n\
     167If the iterable is empty, return False.");
    161168
    162169static PyObject *
    163170builtin_apply(PyObject *self, PyObject *args)
    164171{
    165         PyObject *func, *alist = NULL, *kwdict = NULL;
    166         PyObject *t = NULL, *retval = NULL;
    167 
    168         if (PyErr_WarnPy3k("apply() not supported in 3.x; "
    169                            "use func(*args, **kwargs)", 1) < 0)
    170                 return NULL;
    171 
    172         if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))
    173                 return NULL;
    174         if (alist != NULL) {
    175                 if (!PyTuple_Check(alist)) {
    176                         if (!PySequence_Check(alist)) {
    177                                 PyErr_Format(PyExc_TypeError,
    178                                      "apply() arg 2 expected sequence, found %s",
    179                                              alist->ob_type->tp_name);
    180                                 return NULL;
    181                         }
    182                         t = PySequence_Tuple(alist);
    183                         if (t == NULL)
    184                                 return NULL;
    185                         alist = t;
    186                 }
    187         }
    188         if (kwdict != NULL && !PyDict_Check(kwdict)) {
    189                 PyErr_Format(PyExc_TypeError,
    190                              "apply() arg 3 expected dictionary, found %s",
    191                              kwdict->ob_type->tp_name);
    192                 goto finally;
    193         }
    194         retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
     172    PyObject *func, *alist = NULL, *kwdict = NULL;
     173    PyObject *t = NULL, *retval = NULL;
     174
     175    if (PyErr_WarnPy3k("apply() not supported in 3.x; "
     176                       "use func(*args, **kwargs)", 1) < 0)
     177        return NULL;
     178
     179    if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))
     180        return NULL;
     181    if (alist != NULL) {
     182        if (!PyTuple_Check(alist)) {
     183            if (!PySequence_Check(alist)) {
     184                PyErr_Format(PyExc_TypeError,
     185                     "apply() arg 2 expected sequence, found %s",
     186                         alist->ob_type->tp_name);
     187                return NULL;
     188            }
     189            t = PySequence_Tuple(alist);
     190            if (t == NULL)
     191                return NULL;
     192            alist = t;
     193        }
     194    }
     195    if (kwdict != NULL && !PyDict_Check(kwdict)) {
     196        PyErr_Format(PyExc_TypeError,
     197                     "apply() arg 3 expected dictionary, found %s",
     198                     kwdict->ob_type->tp_name);
     199        goto finally;
     200    }
     201    retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
    195202  finally:
    196         Py_XDECREF(t);
    197         return retval;
     203    Py_XDECREF(t);
     204    return retval;
    198205}
    199206
    … …  
    212219builtin_bin(PyObject *self, PyObject *v)
    213220{
    214         return PyNumber_ToBase(v, 2);
     221    return PyNumber_ToBase(v, 2);
    215222}
    216223
    … …  
    224231builtin_callable(PyObject *self, PyObject *v)
    225232{
    226         if (PyErr_WarnPy3k("callable() not supported in 3.x; "
    227                            "use isinstance(x, collections.Callable)", 1) < 0)
    228                 return NULL;
    229         return PyBool_FromLong((long)PyCallable_Check(v));
     233    return PyBool_FromLong((long)PyCallable_Check(v));
    230234}
    231235
    … …  
    240244builtin_filter(PyObject *self, PyObject *args)
    241245{
    242         PyObject *func, *seq, *result, *it, *arg;
    243         Py_ssize_t len;   /* guess for result list size */
    244         register Py_ssize_t j;
    245 
    246         if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
    247                 return NULL;
    248 
    249         /* Strings and tuples return a result of the same type. */
    250         if (PyString_Check(seq))
    251                 return filterstring(func, seq);
     246    PyObject *func, *seq, *result, *it, *arg;
     247    Py_ssize_t len;   /* guess for result list size */
     248    register Py_ssize_t j;
     249
     250    if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
     251        return NULL;
     252
     253    /* Strings and tuples return a result of the same type. */
     254    if (PyString_Check(seq))
     255        return filterstring(func, seq);
    252256#ifdef Py_USING_UNICODE
    253         if (PyUnicode_Check(seq))
    254                 return filterunicode(func, seq);
     257    if (PyUnicode_Check(seq))
     258        return filterunicode(func, seq);
    255259#endif
    256         if (PyTuple_Check(seq))
    257                 return filtertuple(func, seq);
    258 
    259         /* Pre-allocate argument list tuple. */
    260         arg = PyTuple_New(1);
    261         if (arg == NULL)
    262                 return NULL;
    263 
    264         /* Get iterator. */
    265         it = PyObject_GetIter(seq);
    266         if (it == NULL)
    267                 goto Fail_arg;
    268 
    269         /* Guess a result list size. */
    270         len = _PyObject_LengthHint(seq, 8);
    271         if (len == -1)
    272                 goto Fail_it;
    273 
    274         /* Get a result list. */
    275         if (PyList_Check(seq) && seq->ob_refcnt == 1) {
    276                 /* Eww - can modify the list in-place. */
    277                 Py_INCREF(seq);
    278                 result = seq;
    279         }
    280         else {
    281                 result = PyList_New(len);
    282                 if (result == NULL)
    283                         goto Fail_it;
    284         }
    285 
    286         /* Build the result list. */
    287         j = 0;
    288         for (;;) {
    289                 PyObject *item;
    290                 int ok;
    291 
    292                 item = PyIter_Next(it);
    293                 if (item == NULL) {
    294                         if (PyErr_Occurred())
    295                                 goto Fail_result_it;
    296                         break;
    297                 }
    298 
    299                 if (func == (PyObject *)&PyBool_Type || func == Py_None) {
    300                         ok = PyObject_IsTrue(item);
    301                 }
    302                 else {
    303                         PyObject *good;
    304                         PyTuple_SET_ITEM(arg, 0, item);
    305                         good = PyObject_Call(func, arg, NULL);
    306                         PyTuple_SET_ITEM(arg, 0, NULL);
    307                         if (good == NULL) {
    308                                 Py_DECREF(item);
    309                                 goto Fail_result_it;
    310                         }
    311                         ok = PyObject_IsTrue(good);
    312                         Py_DECREF(good);
    313                 }
    314                 if (ok) {
    315                         if (j < len)
    316                                 PyList_SET_ITEM(result, j, item);
    317                         else {
    318                                 int status = PyList_Append(result, item);
    319                                 Py_DECREF(item);
    320                                 if (status < 0)
    321                                         goto Fail_result_it;
    322                         }
    323                         ++j;
    324                 }
    325                 else
    326                         Py_DECREF(item);
    327         }
    328 
    329 
    330         /* Cut back result list if len is too big. */
    331         if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
    332                 goto Fail_result_it;
    333 
    334         Py_DECREF(it);
    335         Py_DECREF(arg);
    336         return result;
     260    if (PyTuple_Check(seq))
     261        return filtertuple(func, seq);
     262
     263    /* Pre-allocate argument list tuple. */
     264    arg = PyTuple_New(1);
     265    if (arg == NULL)
     266        return NULL;
     267
     268    /* Get iterator. */
     269    it = PyObject_GetIter(seq);
     270    if (it == NULL)
     271        goto Fail_arg;
     272
     273    /* Guess a result list size. */
     274    len = _PyObject_LengthHint(seq, 8);
     275    if (len == -1)
     276        goto Fail_it;
     277
     278    /* Get a result list. */
     279    if (PyList_Check(seq) && seq->ob_refcnt == 1) {
     280        /* Eww - can modify the list in-place. */
     281        Py_INCREF(seq);
     282        result = seq;
     283    }
     284    else {
     285        result = PyList_New(len);
     286        if (result == NULL)
     287            goto Fail_it;
     288    }
     289
     290    /* Build the result list. */
     291    j = 0;
     292    for (;;) {
     293        PyObject *item;
     294        int ok;
     295
     296        item = PyIter_Next(it);
     297        if (item == NULL) {
     298            if (PyErr_Occurred())
     299                goto Fail_result_it;
     300            break;
     301        }
     302
     303        if (func == (PyObject *)&PyBool_Type || func == Py_None) {
     304            ok = PyObject_IsTrue(item);
     305        }
     306        else {
     307            PyObject *good;
     308            PyTuple_SET_ITEM(arg, 0, item);
     309            good = PyObject_Call(func, arg, NULL);
     310            PyTuple_SET_ITEM(arg, 0, NULL);
     311            if (good == NULL) {
     312                Py_DECREF(item);
     313                goto Fail_result_it;
     314            }
     315            ok = PyObject_IsTrue(good);
     316            Py_DECREF(good);
     317        }
     318        if (ok > 0) {
     319            if (j < len)
     320                PyList_SET_ITEM(result, j, item);
     321            else {
     322                int status = PyList_Append(result, item);
     323                Py_DECREF(item);
     324                if (status < 0)
     325                    goto Fail_result_it;
     326            }
     327            ++j;
     328        }
     329        else {
     330            Py_DECREF(item);
     331            if (ok < 0)
     332                goto Fail_result_it;
     333        }
     334    }
     335
     336
     337    /* Cut back result list if len is too big. */
     338    if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
     339        goto Fail_result_it;
     340
     341    Py_DECREF(it);
     342    Py_DECREF(arg);
     343    return result;
    337344
    338345Fail_result_it:
    339         Py_DECREF(result);
     346    Py_DECREF(result);
    340347Fail_it:
    341         Py_DECREF(it);
     348    Py_DECREF(it);
    342349Fail_arg:
    343         Py_DECREF(arg);
    344         return NULL;
     350    Py_DECREF(arg);
     351    return NULL;
    345352}
    346353
    … …  
    355362builtin_format(PyObject *self, PyObject *args)
    356363{
    357         PyObject *value;
    358         PyObject *format_spec = NULL;
    359 
    360         if (!PyArg_ParseTuple(args, "O|O:format", &value, &format_spec))
    361                 return NULL;
    362 
    363         return PyObject_Format(value, format_spec);
     364    PyObject *value;
     365    PyObject *format_spec = NULL;
     366
     367    if (!PyArg_ParseTuple(args, "O|O:format", &value, &format_spec))
     368        return NULL;
     369
     370    return PyObject_Format(value, format_spec);
    364371}
    365372
    … …  
    373380builtin_chr(PyObject *self, PyObject *args)
    374381{
    375         long x;
    376         char s[1];
    377 
    378         if (!PyArg_ParseTuple(args, "l:chr", &x))
    379                 return NULL;
    380         if (x < 0 || x >= 256) {
    381                 PyErr_SetString(PyExc_ValueError,
    382                                 "chr() arg not in range(256)");
    383                 return NULL;
    384         }
    385         s[0] = (char)x;
    386         return PyString_FromStringAndSize(s, 1);
     382    long x;
     383    char s[1];
     384
     385    if (!PyArg_ParseTuple(args, "l:chr", &x))
     386        return NULL;
     387    if (x < 0 || x >= 256) {
     388        PyErr_SetString(PyExc_ValueError,
     389                        "chr() arg not in range(256)");
     390        return NULL;
     391    }
     392    s[0] = (char)x;
     393    return PyString_FromStringAndSize(s, 1);
    387394}
    388395
    … …  
    397404builtin_unichr(PyObject *self, PyObject *args)
    398405{
    399         int x;
    400 
    401         if (!PyArg_ParseTuple(args, "i:unichr", &x))
    402                 return NULL;
    403 
    404         return PyUnicode_FromOrdinal(x);
     406    int x;
     407
     408    if (!PyArg_ParseTuple(args, "i:unichr", &x))
     409        return NULL;
     410
     411    return PyUnicode_FromOrdinal(x);
    405412}
    406413
    … …  
    415422builtin_cmp(PyObject *self, PyObject *args)
    416423{
    417         PyObject *a, *b;
    418         int c;
    419 
    420         if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))
    421                 return NULL;
    422         if (PyObject_Cmp(a, b, &c) < 0)
    423                 return NULL;
    424         return PyInt_FromLong((long)c);
     424    PyObject *a, *b;
     425    int c;
     426
     427    if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))
     428        return NULL;
     429    if (PyObject_Cmp(a, b, &c) < 0)
     430        return NULL;
     431    return PyInt_FromLong((long)c);
    425432}
    426433
    … …  
    434441builtin_coerce(PyObject *self, PyObject *args)
    435442{
    436         PyObject *v, *w;
    437         PyObject *res;
    438 
    439         if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
    440                 return NULL;
    441 
    442         if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))
    443                 return NULL;
    444         if (PyNumber_Coerce(&v, &w) < 0)
    445                 return NULL;
    446         res = PyTuple_Pack(2, v, w);
    447         Py_DECREF(v);
    448         Py_DECREF(w);
    449         return res;
     443    PyObject *v, *w;
     444    PyObject *res;
     445
     446    if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
     447        return NULL;
     448
     449    if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))
     450        return NULL;
     451    if (PyNumber_Coerce(&v, &w) < 0)
     452        return NULL;
     453    res = PyTuple_Pack(2, v, w);
     454    Py_DECREF(v);
     455    Py_DECREF(w);
     456    return res;
    450457}
    451458
    … …  
    460467builtin_compile(PyObject *self, PyObject *args, PyObject *kwds)
    461468{
    462         char *str;
    463         char *filename;
    464         char *startstr;
    465         int mode = -1;
    466         int dont_inherit = 0;
    467         int supplied_flags = 0;
    468         int is_ast;
    469         PyCompilerFlags cf;
    470         PyObject *result = NULL, *cmd, *tmp = NULL;
    471         Py_ssize_t length;
    472         static char *kwlist[] = {"source", "filename", "mode", "flags",
    473                                  "dont_inherit", NULL};
    474         int start[] = {Py_file_input, Py_eval_input, Py_single_input};
    475 
    476         if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",
    477                                          kwlist, &cmd, &filename, &startstr,
    478                                          &supplied_flags, &dont_inherit))
    479                 return NULL;
    480 
    481         cf.cf_flags = supplied_flags;
    482 
    483         if (supplied_flags &
    484             ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
    485         {
    486                 PyErr_SetString(PyExc_ValueError,
    487                                 "compile(): unrecognised flags");
    488                 return NULL;
    489         }
    490         /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
    491 
    492         if (!dont_inherit) {
    493                 PyEval_MergeCompilerFlags(&cf);
    494         }
    495 
    496         if (strcmp(startstr, "exec") == 0)
    497                 mode = 0;
    498         else if (strcmp(startstr, "eval") == 0)
    499                 mode = 1;
    500         else if (strcmp(startstr, "single") == 0)
    501                 mode = 2;
    502         else {
    503                 PyErr_SetString(PyExc_ValueError,
    504                                 "compile() arg 3 must be 'exec', 'eval' or 'single'");
    505                 return NULL;
    506         }
    507 
    508         is_ast = PyAST_Check(cmd);
    509         if (is_ast == -1)
    510                 return NULL;
    511         if (is_ast) {
    512                 if (supplied_flags & PyCF_ONLY_AST) {
    513                         Py_INCREF(cmd);
    514                         result = cmd;
    515                 }
    516                 else {
    517                         PyArena *arena;
    518                         mod_ty mod;
    519 
    520                         arena = PyArena_New();
    521                         mod = PyAST_obj2mod(cmd, arena, mode);
    522                         if (mod == NULL) {
    523                                 PyArena_Free(arena);
    524                                 return NULL;
    525                         }
    526                         result = (PyObject*)PyAST_Compile(mod, filename,
    527                                                           &cf, arena);
    528                         PyArena_Free(arena);
    529                 }
    530                 return result;
    531         }
     469    char *str;
     470    char *filename;
     471    char *startstr;
     472    int mode = -1;
     473    int dont_inherit = 0;
     474    int supplied_flags = 0;
     475    int is_ast;
     476    PyCompilerFlags cf;
     477    PyObject *result = NULL, *cmd, *tmp = NULL;
     478    Py_ssize_t length;
     479    static char *kwlist[] = {"source", "filename", "mode", "flags",
     480                             "dont_inherit", NULL};
     481    int start[] = {Py_file_input, Py_eval_input, Py_single_input};
     482
     483    if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",
     484                                     kwlist, &cmd, &filename, &startstr,
     485                                     &supplied_flags, &dont_inherit))
     486        return NULL;
     487
     488    cf.cf_flags = supplied_flags;
     489
     490    if (supplied_flags &
     491        ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
     492    {
     493        PyErr_SetString(PyExc_ValueError,
     494                        "compile(): unrecognised flags");
     495        return NULL;
     496    }
     497    /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
     498
     499    if (!dont_inherit) {
     500        PyEval_MergeCompilerFlags(&cf);
     501    }
     502
     503    if (strcmp(startstr, "exec") == 0)
     504        mode = 0;
     505    else if (strcmp(startstr, "eval") == 0)
     506        mode = 1;
     507    else if (strcmp(startstr, "single") == 0)
     508        mode = 2;
     509    else {
     510        PyErr_SetString(PyExc_ValueError,
     511                        "compile() arg 3 must be 'exec', 'eval' or 'single'");
     512        return NULL;
     513    }
     514
     515    is_ast = PyAST_Check(cmd);
     516    if (is_ast == -1)
     517        return NULL;
     518    if (is_ast) {
     519        if (supplied_flags & PyCF_ONLY_AST) {
     520            Py_INCREF(cmd);
     521            result = cmd;
     522        }
     523        else {
     524            PyArena *arena;
     525            mod_ty mod;
     526
     527            arena = PyArena_New();
     528            if (arena == NULL)
     529                return NULL;
     530            mod = PyAST_obj2mod(cmd, arena, mode);
     531            if (mod == NULL) {
     532                PyArena_Free(arena);
     533                return NULL;
     534            }
     535            result = (PyObject*)PyAST_Compile(mod, filename,
     536                                              &cf, arena);
     537            PyArena_Free(arena);
     538        }
     539        return result;
     540    }
    532541
    533542#ifdef Py_USING_UNICODE
    534         if (PyUnicode_Check(cmd)) {
    535                 tmp = PyUnicode_AsUTF8String(cmd);
    536                 if (tmp == NULL)
    537                         return NULL;
    538                 cmd = tmp;
    539                 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
    540         }
     543    if (PyUnicode_Check(cmd)) {
     544        tmp = PyUnicode_AsUTF8String(cmd);
     545        if (tmp == NULL)
     546            return NULL;
     547        cmd = tmp;
     548        cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
     549    }
    541550#endif
    542551
    543         if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
    544                 goto cleanup;
    545         if ((size_t)length != strlen(str)) {
    546                 PyErr_SetString(PyExc_TypeError,
    547                                 "compile() expected string without null bytes");
    548                 goto cleanup;
    549         }
    550         result = Py_CompileStringFlags(str, filename, start[mode], &cf);
     552    if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
     553        goto cleanup;
     554    if ((size_t)length != strlen(str)) {
     555        PyErr_SetString(PyExc_TypeError,
     556                        "compile() expected string without null bytes");
     557        goto cleanup;
     558    }
     559    result = Py_CompileStringFlags(str, filename, start[mode], &cf);
    551560cleanup:
    552         Py_XDECREF(tmp);
    553         return result;
     561    Py_XDECREF(tmp);
     562    return result;
    554563}
    555564
    … …  
    572581builtin_dir(PyObject *self, PyObject *args)
    573582{
    574         PyObject *arg = NULL;
    575 
    576         if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
    577                 return NULL;
    578         return PyObject_Dir(arg);
     583    PyObject *arg = NULL;
     584
     585    if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
     586        return NULL;
     587    return PyObject_Dir(arg);
    579588}
    580589
    … …  
    596605builtin_divmod(PyObject *self, PyObject *args)
    597606{
    598         PyObject *v, *w;
    599 
    600         if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
    601                 return NULL;
    602         return PyNumber_Divmod(v, w);
     607    PyObject *v, *w;
     608
     609    if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
     610        return NULL;
     611    return PyNumber_Divmod(v, w);
    603612}
    604613
    605614PyDoc_STRVAR(divmod_doc,
    606 "divmod(x, y) -> (div, mod)\n\
     615"divmod(x, y) -> (quotient, remainder)\n\
    607616\n\
    608617Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.");
    … …  
    612621builtin_eval(PyObject *self, PyObject *args)
    613622{
    614         PyObject *cmd, *result, *tmp = NULL;
    615         PyObject *globals = Py_None, *locals = Py_None;
    616         char *str;
    617         PyCompilerFlags cf;
    618 
    619         if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
    620                 return NULL;
    621         if (locals != Py_None && !PyMapping_Check(locals)) {
    622                 PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
    623                 return NULL;
    624         }
    625         if (globals != Py_None && !PyDict_Check(globals)) {
    626                 PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
    627                         "globals must be a real dict; try eval(expr, {}, mapping)"
    628                         : "globals must be a dict");
    629                 return NULL;
    630         }
    631         if (globals == Py_None) {
    632                 globals = PyEval_GetGlobals();
    633                 if (locals == Py_None)
    634                         locals = PyEval_GetLocals();
    635         }
    636         else if (locals == Py_None)
    637                 locals = globals;
    638 
    639         if (globals == NULL || locals == NULL) {
    640                 PyErr_SetString(PyExc_TypeError,
    641                         "eval must be given globals and locals "
    642                         "when called without a frame");
    643                 return NULL;
    644         }
    645 
    646         if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
    647                 if (PyDict_SetItemString(globals, "__builtins__",
    648                                         PyEval_GetBuiltins()) != 0)
    649                         return NULL;
    650         }
    651 
    652         if (PyCode_Check(cmd)) {
    653                 if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
    654                         PyErr_SetString(PyExc_TypeError,
    655                 "code object passed to eval() may not contain free variables");
    656                         return NULL;
    657                 }
    658                 return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
    659         }
    660 
    661         if (!PyString_Check(cmd) &&
    662             !PyUnicode_Check(cmd)) {
    663                 PyErr_SetString(PyExc_TypeError,
    664                            "eval() arg 1 must be a string or code object");
    665                 return NULL;
    666         }
    667         cf.cf_flags = 0;
     623    PyObject *cmd, *result, *tmp = NULL;
     624    PyObject *globals = Py_None, *locals = Py_None;
     625    char *str;
     626    PyCompilerFlags cf;
     627
     628    if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
     629        return NULL;
     630    if (locals != Py_None && !PyMapping_Check(locals)) {
     631        PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
     632        return NULL;
     633    }
     634    if (globals != Py_None && !PyDict_Check(globals)) {
     635        PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
     636            "globals must be a real dict; try eval(expr, {}, mapping)"
     637            : "globals must be a dict");
     638        return NULL;
     639    }
     640    if (globals == Py_None) {
     641        globals = PyEval_GetGlobals();
     642        if (locals == Py_None)
     643            locals = PyEval_GetLocals();
     644    }
     645    else if (locals == Py_None)
     646        locals = globals;
     647
     648    if (globals == NULL || locals == NULL) {
     649        PyErr_SetString(PyExc_TypeError,
     650            "eval must be given globals and locals "
     651            "when called without a frame");
     652        return NULL;
     653    }
     654
     655    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
     656        if (PyDict_SetItemString(globals, "__builtins__",
     657                                PyEval_GetBuiltins()) != 0)
     658            return NULL;
     659    }
     660
     661    if (PyCode_Check(cmd)) {
     662        if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
     663            PyErr_SetString(PyExc_TypeError,
     664        "code object passed to eval() may not contain free variables");
     665            return NULL;
     666        }
     667        return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
     668    }
     669
     670    if (!PyString_Check(cmd) &&
     671        !PyUnicode_Check(cmd)) {
     672        PyErr_SetString(PyExc_TypeError,
     673                   "eval() arg 1 must be a string or code object");
     674        return NULL;
     675    }
     676    cf.cf_flags = 0;
    668677
    669678#ifdef Py_USING_UNICODE
    670         if (PyUnicode_Check(cmd)) {
    671                 tmp = PyUnicode_AsUTF8String(cmd);
    672                 if (tmp == NULL)
    673                         return NULL;
    674                 cmd = tmp;
    675                 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
    676         }
     679    if (PyUnicode_Check(cmd)) {
     680        tmp = PyUnicode_AsUTF8String(cmd);
     681        if (tmp == NULL)
     682            return NULL;
     683        cmd = tmp;
     684        cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
     685    }
    677686#endif
    678         if (PyString_AsStringAndSize(cmd, &str, NULL)) {
    679                 Py_XDECREF(tmp);
    680                 return NULL;
    681         }
    682         while (*str == ' ' || *str == '\t')
    683                 str++;
    684 
    685         (void)PyEval_MergeCompilerFlags(&cf);
    686         result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
    687         Py_XDECREF(tmp);
    688         return result;
     687    if (PyString_AsStringAndSize(cmd, &str, NULL)) {
     688        Py_XDECREF(tmp);
     689        return NULL;
     690    }
     691    while (*str == ' ' || *str == '\t')
     692        str++;
     693
     694    (void)PyEval_MergeCompilerFlags(&cf);
     695    result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
     696    Py_XDECREF(tmp);
     697    return result;
    689698}
    690699
    … …  
    703712builtin_execfile(PyObject *self, PyObject *args)
    704713{
    705         char *filename;
    706         PyObject *globals = Py_None, *locals = Py_None;
    707         PyObject *res;
    708         FILE* fp = NULL;
    709         PyCompilerFlags cf;
    710         int exists;
    711 
    712         if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
    713                            1) < 0)
    714                 return NULL;
    715 
    716         if (!PyArg_ParseTuple(args, "s|O!O:execfile",
    717                         &filename,
    718                         &PyDict_Type, &globals,
    719                         &locals))
    720                 return NULL;
    721         if (locals != Py_None && !PyMapping_Check(locals)) {
    722                 PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
    723                 return NULL;
    724         }
    725         if (globals == Py_None) {
    726                 globals = PyEval_GetGlobals();
    727                 if (locals == Py_None)
    728                         locals = PyEval_GetLocals();
    729         }
    730         else if (locals == Py_None)
    731                 locals = globals;
    732         if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
    733                 if (PyDict_SetItemString(globals, "__builtins__",
    734                                         PyEval_GetBuiltins()) != 0)
    735                         return NULL;
    736         }
    737 
    738         exists = 0;
    739         /* Test for existence or directory. */
     714    char *filename;
     715    PyObject *globals = Py_None, *locals = Py_None;
     716    PyObject *res;
     717    FILE* fp = NULL;
     718    PyCompilerFlags cf;
     719    int exists;
     720
     721    if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
     722                       1) < 0)
     723        return NULL;
     724
     725    if (!PyArg_ParseTuple(args, "s|O!O:execfile",
     726                    &filename,
     727                    &PyDict_Type, &globals,
     728                    &locals))
     729        return NULL;
     730    if (locals != Py_None && !PyMapping_Check(locals)) {
     731        PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
     732        return NULL;
     733    }
     734    if (globals == Py_None) {
     735        globals = PyEval_GetGlobals();
     736        if (locals == Py_None)
     737            locals = PyEval_GetLocals();
     738    }
     739    else if (locals == Py_None)
     740        locals = globals;
     741    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
     742        if (PyDict_SetItemString(globals, "__builtins__",
     743                                PyEval_GetBuiltins()) != 0)
     744            return NULL;
     745    }
     746
     747    exists = 0;
     748    /* Test for existence or directory. */
    740749#if defined(PLAN9)
    741         {
    742                 Dir *d;
    743 
    744                 if ((d = dirstat(filename))!=nil) {
    745                         if(d->mode & DMDIR)
    746                                 werrstr("is a directory");
    747                         else
    748                                 exists = 1;
    749                         free(d);
    750                 }
    751         }
     750    {
     751        Dir *d;
     752
     753        if ((d = dirstat(filename))!=nil) {
     754            if(d->mode & DMDIR)
     755                werrstr("is a directory");
     756            else
     757                exists = 1;
     758            free(d);
     759        }
     760    }
    752761#elif defined(RISCOS)
    753         if (object_exists(filename)) {
    754                 if (isdir(filename))
    755                         errno = EISDIR;
    756                 else
    757                         exists = 1;
    758         }
    759 #else   /* standard Posix */
    760         {
    761                 struct stat s;
    762                 if (stat(filename, &s) == 0) {
    763                         if (S_ISDIR(s.st_mode))
    764 #                               if defined(PYOS_OS2) && defined(PYCC_VACPP)
    765                                         errno = EOS2ERR;
    766 #                               else
    767                                         errno = EISDIR;
    768 #                               endif
    769                         else
    770                                 exists = 1;
    771                 }
    772         }
     762    if (object_exists(filename)) {
     763        if (isdir(filename))
     764            errno = EISDIR;
     765        else
     766            exists = 1;
     767    }
     768#else   /* standard Posix */
     769    {
     770        struct stat s;
     771        if (stat(filename, &s) == 0) {
     772            if (S_ISDIR(s.st_mode))
     773#                               if defined(PYOS_OS2) && defined(PYCC_VACPP)
     774                            errno = EOS2ERR;
     775#                               else
     776                            errno = EISDIR;
     777#                               endif
     778            else
     779                exists = 1;
     780        }
     781    }
    773782#endif
    774783
    775         if (exists) {
    776                 Py_BEGIN_ALLOW_THREADS
    777                 fp = fopen(filename, "r" PY_STDIOTEXTMODE);
    778                 Py_END_ALLOW_THREADS
    779 
    780                 if (fp == NULL) {
    781                         exists = 0;
    782                 }
    783         }
    784 
    785         if (!exists) {
    786                 PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
    787                 return NULL;
    788         }
    789         cf.cf_flags = 0;
    790         if (PyEval_MergeCompilerFlags(&cf))
    791                 res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,
    792                                    locals, 1, &cf);
    793         else
    794                 res = PyRun_FileEx(fp, filename, Py_file_input, globals,
    795                                    locals, 1);
    796         return res;
     784    if (exists) {
     785        Py_BEGIN_ALLOW_THREADS
     786        fp = fopen(filename, "r" PY_STDIOTEXTMODE);
     787        Py_END_ALLOW_THREADS
     788
     789        if (fp == NULL) {
     790            exists = 0;
     791        }
     792    }
     793
     794    if (!exists) {
     795        PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
     796        return NULL;
     797    }
     798    cf.cf_flags = 0;
     799    if (PyEval_MergeCompilerFlags(&cf))
     800        res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,
     801                           locals, 1, &cf);
     802    else
     803        res = PyRun_FileEx(fp, filename, Py_file_input, globals,
     804                           locals, 1);
     805    return res;
    797806}
    798807
    … …  
    808817builtin_getattr(PyObject *self, PyObject *args)
    809818{
    810         PyObject *v, *result, *dflt = NULL;
    811         PyObject *name;
    812 
    813         if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
    814                 return NULL;
     819    PyObject *v, *result, *dflt = NULL;
     820    PyObject *name;
     821
     822    if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
     823        return NULL;
    815824#ifdef Py_USING_UNICODE
    816         if (PyUnicode_Check(name)) {
    817                 name = _PyUnicode_AsDefaultEncodedString(name, NULL);
    818                 if (name == NULL)
    819                         return NULL;
    820         }
     825    if (PyUnicode_Check(name)) {
     826        name = _PyUnicode_AsDefaultEncodedString(name, NULL);
     827        if (name == NULL)
     828            return NULL;
     829    }
    821830#endif
    822831
    823         if (!PyString_Check(name)) {
    824                 PyErr_SetString(PyExc_TypeError,
    825                                 "getattr(): attribute name must be string");
    826                 return NULL;
    827         }
    828         result = PyObject_GetAttr(v, name);
    829         if (result == NULL && dflt != NULL &&
    830             PyErr_ExceptionMatches(PyExc_AttributeError))
    831         {
    832                 PyErr_Clear();
    833                 Py_INCREF(dflt);
    834                 result = dflt;
    835         }
    836         return result;
     832    if (!PyString_Check(name)) {
     833        PyErr_SetString(PyExc_TypeError,
     834                        "getattr(): attribute name must be string");
     835        return NULL;
     836    }
     837    result = PyObject_GetAttr(v, name);
     838    if (result == NULL && dflt != NULL &&
     839        PyErr_ExceptionMatches(PyExc_AttributeError))
     840    {
     841        PyErr_Clear();
     842        Py_INCREF(dflt);
     843        result = dflt;
     844    }
     845    return result;
    837846}
    838847
    … …  
    848857builtin_globals(PyObject *self)
    849858{
    850         PyObject *d;
    851 
    852         d = PyEval_GetGlobals();
    853         Py_XINCREF(d);
    854         return d;
     859    PyObject *d;
     860
     861    d = PyEval_GetGlobals();
     862    Py_XINCREF(d);
     863    return d;
    855864}
    856865
    … …  
    864873builtin_hasattr(PyObject *self, PyObject *args)
    865874{
    866         PyObject *v;
    867         PyObject *name;
    868 
    869         if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
    870                 return NULL;
     875    PyObject *v;
     876    PyObject *name;
     877
     878    if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
     879        return NULL;
    871880#ifdef Py_USING_UNICODE
    872         if (PyUnicode_Check(name)) {
    873                 name = _PyUnicode_AsDefaultEncodedString(name, NULL);
    874                 if (name == NULL)
    875                         return NULL;
    876         }
     881    if (PyUnicode_Check(name)) {
     882        name = _PyUnicode_AsDefaultEncodedString(name, NULL);
     883        if (name == NULL)
     884            return NULL;
     885    }
    877886#endif
    878887
    879         if (!PyString_Check(name)) {
    880                 PyErr_SetString(PyExc_TypeError,
    881                                 "hasattr(): attribute name must be string");
    882                 return NULL;
    883         }
    884         v = PyObject_GetAttr(v, name);
    885         if (v == NULL) {
    886                 if (!PyErr_ExceptionMatches(PyExc_Exception))
    887                         return NULL;
    888                 else {
    889                         PyErr_Clear();
    890                         Py_INCREF(Py_False);
    891                         return Py_False;
    892                 }
    893         }
    894         Py_DECREF(v);
    895         Py_INCREF(Py_True);
    896         return Py_True;
     888    if (!PyString_Check(name)) {
     889        PyErr_SetString(PyExc_TypeError,
     890                        "hasattr(): attribute name must be string");
     891        return NULL;
     892    }
     893    v = PyObject_GetAttr(v, name);
     894    if (v == NULL) {
     895        if (!PyErr_ExceptionMatches(PyExc_Exception))
     896            return NULL;
     897        else {
     898            PyErr_Clear();
     899            Py_INCREF(Py_False);
     900            return Py_False;
     901        }
     902    }
     903    Py_DECREF(v);
     904    Py_INCREF(Py_True);
     905    return Py_True;
    897906}
    898907
    … …  
    907916builtin_id(PyObject *self, PyObject *v)
    908917{
    909         return PyLong_FromVoidPtr(v);
     918    return PyLong_FromVoidPtr(v);
    910919}
    911920
    … …  
    920929builtin_map(PyObject *self, PyObject *args)
    921930{
    922         typedef struct {
    923                 PyObject *it;   /* the iterator object */
    924                 int saw_StopIteration;  /* bool:  did the iterator end? */
    925         } sequence;
    926 
    927         PyObject *func, *result;
    928         sequence *seqs = NULL, *sqp;
    929         Py_ssize_t n, len;
    930         register int i, j;
    931 
    932         n = PyTuple_Size(args);
    933         if (n < 2) {
    934                 PyErr_SetString(PyExc_TypeError,
    935                                 "map() requires at least two args");
    936                 return NULL;
    937         }
    938 
    939         func = PyTuple_GetItem(args, 0);
    940         n--;
    941 
    942         if (func == Py_None) {
    943                 if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
    944                                    "use list(...)", 1) < 0)
    945                         return NULL;
    946                 if (n == 1) {
    947                         /* map(None, S) is the same as list(S). */
    948                         return PySequence_List(PyTuple_GetItem(args, 1));
    949                 }
    950         }
    951 
    952         /* Get space for sequence descriptors.  Must NULL out the iterator
    953         * pointers so that jumping to Fail_2 later doesn't see trash.
    954         */
    955         if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
    956                 PyErr_NoMemory();
    957                 return NULL;
    958         }
    959         for (i = 0; i < n; ++i) {
    960                 seqs[i].it = (PyObject*)NULL;
    961                 seqs[i].saw_StopIteration = 0;
    962         }
    963 
    964         /* Do a first pass to obtain iterators for the arguments, and set len
    965         * to the largest of their lengths.
    966         */
    967         len = 0;
    968         for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
    969                 PyObject *curseq;
    970                 Py_ssize_t curlen;
    971 
    972                 /* Get iterator. */
    973                 curseq = PyTuple_GetItem(args, i+1);
    974                 sqp->it = PyObject_GetIter(curseq);
    975                 if (sqp->it == NULL) {
    976                         static char errmsg[] =
    977                             "argument %d to map() must support iteration";
    978                         char errbuf[sizeof(errmsg) + 25];
    979                         PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
    980                         PyErr_SetString(PyExc_TypeError, errbuf);
    981                         goto Fail_2;
    982                 }
    983 
    984                 /* Update len. */
    985                 curlen = _PyObject_LengthHint(curseq, 8);
    986                 if (curlen > len)
    987                         len = curlen;
    988         }
    989 
    990         /* Get space for the result list. */
    991         if ((result = (PyObject *) PyList_New(len)) == NULL)
    992                 goto Fail_2;
    993 
    994         /* Iterate over the sequences until all have stopped. */
    995         for (i = 0; ; ++i) {
    996                 PyObject *alist, *item=NULL, *value;
    997                 int numactive = 0;
    998 
    999                 if (func == Py_None && n == 1)
    1000                         alist = NULL;
    1001                 else if ((alist = PyTuple_New(n)) == NULL)
    1002                         goto Fail_1;
    1003 
    1004                 for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
    1005                         if (sqp->saw_StopIteration) {
    1006                                 Py_INCREF(Py_None);
    1007                                 item = Py_None;
    1008                         }
    1009                         else {
    1010                                 item = PyIter_Next(sqp->it);
    1011                                 if (item)
    1012                                         ++numactive;
    1013                                 else {
    1014                                         if (PyErr_Occurred()) {
    1015                                                 Py_XDECREF(alist);
    1016                                                 goto Fail_1;
    1017                                         }
    1018                                         Py_INCREF(Py_None);
    1019                                         item = Py_None;
    1020                                         sqp->saw_StopIteration = 1;
    1021                                 }
    1022                         }
    1023                         if (alist)
    1024                                 PyTuple_SET_ITEM(alist, j, item);
    1025                         else
    1026                                 break;
    1027                 }
    1028 
    1029                 if (!alist)
    1030                         alist = item;
    1031 
    1032                 if (numactive == 0) {
    1033                         Py_DECREF(alist);
    1034                         break;
    1035                 }
    1036 
    1037                 if (func == Py_None)
    1038                         value = alist;
    1039                 else {
    1040                         value = PyEval_CallObject(func, alist);
    1041                         Py_DECREF(alist);
    1042                         if (value == NULL)
    1043                                 goto Fail_1;
    1044                 }
    1045                 if (i >= len) {
    1046                         int status = PyList_Append(result, value);
    1047                         Py_DECREF(value);
    1048                         if (status < 0)
    1049                                 goto Fail_1;
    1050                 }
    1051                 else if (PyList_SetItem(result, i, value) < 0)
    1052                         goto Fail_1;
    1053         }
    1054 
    1055         if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
    1056                 goto Fail_1;
    1057 
    1058         goto Succeed;
     931    typedef struct {
     932        PyObject *it;           /* the iterator object */
     933        int saw_StopIteration;  /* bool:  did the iterator end? */
     934    } sequence;
     935
     936    PyObject *func, *result;
     937    sequence *seqs = NULL, *sqp;
     938    Py_ssize_t n, len;
     939    register int i, j;
     940
     941    n = PyTuple_Size(args);
     942    if (n < 2) {
     943        PyErr_SetString(PyExc_TypeError,
     944                        "map() requires at least two args");
     945        return NULL;
     946    }
     947
     948    func = PyTuple_GetItem(args, 0);
     949    n--;
     950
     951    if (func == Py_None) {
     952        if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
     953                           "use list(...)", 1) < 0)
     954            return NULL;
     955        if (n == 1) {
     956            /* map(None, S) is the same as list(S). */
     957            return PySequence_List(PyTuple_GetItem(args, 1));
     958        }
     959    }
     960
     961    /* Get space for sequence descriptors.  Must NULL out the iterator
     962    * pointers so that jumping to Fail_2 later doesn't see trash.
     963    */
     964    if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
     965        PyErr_NoMemory();
     966        return NULL;
     967    }
     968    for (i = 0; i < n; ++i) {
     969        seqs[i].it = (PyObject*)NULL;
     970        seqs[i].saw_StopIteration = 0;
     971    }
     972
     973    /* Do a first pass to obtain iterators for the arguments, and set len
     974    * to the largest of their lengths.
     975    */
     976    len = 0;
     977    for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
     978        PyObject *curseq;
     979        Py_ssize_t curlen;
     980
     981        /* Get iterator. */
     982        curseq = PyTuple_GetItem(args, i+1);
     983        sqp->it = PyObject_GetIter(curseq);
     984        if (sqp->it == NULL) {
     985            static char errmsg[] =
     986                "argument %d to map() must support iteration";
     987            char errbuf[sizeof(errmsg) + 25];
     988            PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
     989            PyErr_SetString(PyExc_TypeError, errbuf);
     990            goto Fail_2;
     991        }
     992
     993        /* Update len. */
     994        curlen = _PyObject_LengthHint(curseq, 8);
     995        if (curlen > len)
     996            len = curlen;
     997    }
     998
     999    /* Get space for the result list. */
     1000    if ((result = (PyObject *) PyList_New(len)) == NULL)
     1001        goto Fail_2;
     1002
     1003    /* Iterate over the sequences until all have stopped. */
     1004    for (i = 0; ; ++i) {
     1005        PyObject *alist, *item=NULL, *value;
     1006        int numactive = 0;
     1007
     1008        if (func == Py_None && n == 1)
     1009            alist = NULL;
     1010        else if ((alist = PyTuple_New(n)) == NULL)
     1011            goto Fail_1;
     1012
     1013        for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
     1014            if (sqp->saw_StopIteration) {
     1015                Py_INCREF(Py_None);
     1016                item = Py_None;
     1017            }
     1018            else {
     1019                item = PyIter_Next(sqp->it);
     1020                if (item)
     1021                    ++numactive;
     1022                else {
     1023                    if (PyErr_Occurred()) {
     1024                        Py_XDECREF(alist);
     1025                        goto Fail_1;
     1026                    }
     1027                    Py_INCREF(Py_None);
     1028                    item = Py_None;
     1029                    sqp->saw_StopIteration = 1;
     1030                }
     1031            }
     1032            if (alist)
     1033                PyTuple_SET_ITEM(alist, j, item);
     1034            else
     1035                break;
     1036        }
     1037
     1038        if (!alist)
     1039            alist = item;
     1040
     1041        if (numactive == 0) {
     1042            Py_DECREF(alist);
     1043            break;
     1044        }
     1045
     1046        if (func == Py_None)
     1047            value = alist;
     1048        else {
     1049            value = PyEval_CallObject(func, alist);
     1050            Py_DECREF(alist);
     1051            if (value == NULL)
     1052                goto Fail_1;
     1053        }
     1054        if (i >= len) {
     1055            int status = PyList_Append(result, value);
     1056            Py_DECREF(value);
     1057            if (status < 0)
     1058                goto Fail_1;
     1059        }
     1060        else if (PyList_SetItem(result, i, value) < 0)
     1061            goto Fail_1;
     1062    }
     1063
     1064    if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
     1065        goto Fail_1;
     1066
     1067    goto Succeed;
    10591068
    10601069Fail_1:
    1061         Py_DECREF(result);
     1070    Py_DECREF(result);
    10621071Fail_2:
    1063         result = NULL;
     1072    result = NULL;
    10641073Succeed:
    1065         assert(seqs);
    1066         for (i = 0; i < n; ++i)
    1067                 Py_XDECREF(seqs[i].it);
    1068         PyMem_DEL(seqs);
    1069         return result;
     1074    assert(seqs);
     1075    for (i = 0; i < n; ++i)
     1076        Py_XDECREF(seqs[i].it);
     1077    PyMem_DEL(seqs);
     1078    return result;
    10701079}
    10711080
    … …  
    10841093builtin_next(PyObject *self, PyObject *args)
    10851094{
    1086         PyObject *it, *res;
    1087         PyObject *def = NULL;
    1088 
    1089         if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
    1090                 return NULL;
    1091         if (!PyIter_Check(it)) {
    1092                 PyErr_Format(PyExc_TypeError,
    1093                         "%.200s object is not an iterator",
    1094                         it->ob_type->tp_name);
    1095                 return NULL;
    1096         }
    1097        
    1098         res = (*it->ob_type->tp_iternext)(it);
    1099         if (res != NULL) {
    1100                 return res;
    1101         } else if (def != NULL) {
    1102                 if (PyErr_Occurred()) {
    1103                         if (!PyErr_ExceptionMatches(PyExc_StopIteration))
    1104                                 return NULL;
    1105                         PyErr_Clear();
    1106                 }
    1107                 Py_INCREF(def);
    1108                 return def;
    1109         } else if (PyErr_Occurred()) {
    1110                 return NULL;
    1111         } else {
    1112                 PyErr_SetNone(PyExc_StopIteration);
    1113                 return NULL;
    1114         }
     1095    PyObject *it, *res;
     1096    PyObject *def = NULL;
     1097
     1098    if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
     1099        return NULL;
     1100    if (!PyIter_Check(it)) {
     1101        PyErr_Format(PyExc_TypeError,
     1102            "%.200s object is not an iterator",
     1103            it->ob_type->tp_name);
     1104        return NULL;
     1105    }
     1106
     1107    res = (*it->ob_type->tp_iternext)(it);
     1108    if (res != NULL) {
     1109        return res;
     1110    } else if (def != NULL) {
     1111        if (PyErr_Occurred()) {
     1112            if (!PyErr_ExceptionMatches(PyExc_StopIteration))
     1113                return NULL;
     1114            PyErr_Clear();
     1115        }
     1116        Py_INCREF(def);
     1117        return def;
     1118    } else if (PyErr_Occurred()) {
     1119        return NULL;
     1120    } else {
     1121        PyErr_SetNone(PyExc_StopIteration);
     1122        return NULL;
     1123    }
    11151124}
    11161125
    … …  
    11251134builtin_setattr(PyObject *self, PyObject *args)
    11261135{
    1127         PyObject *v;
    1128         PyObject *name;
    1129         PyObject *value;
    1130 
    1131         if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
    1132                 return NULL;
    1133         if (PyObject_SetAttr(v, name, value) != 0)
    1134                 return NULL;
    1135         Py_INCREF(Py_None);
    1136         return Py_None;
     1136    PyObject *v;
     1137    PyObject *name;
     1138    PyObject *value;
     1139
     1140    if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
     1141        return NULL;
     1142    if (PyObject_SetAttr(v, name, value) != 0)
     1143        return NULL;
     1144    Py_INCREF(Py_None);
     1145    return Py_None;
    11371146}
    11381147
    … …  
    11471156builtin_delattr(PyObject *self, PyObject *args)
    11481157{
    1149         PyObject *v;
    1150         PyObject *name;
    1151 
    1152         if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
    1153                 return NULL;
    1154         if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
    1155                 return NULL;
    1156         Py_INCREF(Py_None);
    1157         return Py_None;
     1158    PyObject *v;
     1159    PyObject *name;
     1160
     1161    if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
     1162        return NULL;
     1163    if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
     1164        return NULL;
     1165    Py_INCREF(Py_None);
     1166    return Py_None;
    11581167}
    11591168
    … …  
    11681177builtin_hash(PyObject *self, PyObject *v)
    11691178{
    1170         long x;
    1171 
    1172         x = PyObject_Hash(v);
    1173         if (x == -1)
    1174                 return NULL;
    1175         return PyInt_FromLong(x);
     1179    long x;
     1180
     1181    x = PyObject_Hash(v);
     1182    if (x == -1)
     1183        return NULL;
     1184    return PyInt_FromLong(x);
    11761185}
    11771186
    … …  
    11861195builtin_hex(PyObject *self, PyObject *v)
    11871196{
    1188         PyNumberMethods *nb;
    1189         PyObject *res;
    1190 
    1191         if ((nb = v->ob_type->tp_as_number) == NULL ||
    1192             nb->nb_hex == NULL) {
    1193                 PyErr_SetString(PyExc_TypeError,
    1194                            "hex() argument can't be converted to hex");
    1195                 return NULL;
    1196         }
    1197         res = (*nb->nb_hex)(v);
    1198         if (res && !PyString_Check(res)) {
    1199                 PyErr_Format(PyExc_TypeError,
    1200                              "__hex__ returned non-string (type %.200s)",
    1201                              res->ob_type->tp_name);
    1202                 Py_DECREF(res);
    1203                 return NULL;
    1204         }
    1205         return res;
     1197    PyNumberMethods *nb;
     1198    PyObject *res;
     1199
     1200    if ((nb = v->ob_type->tp_as_number) == NULL ||
     1201        nb->nb_hex == NULL) {
     1202        PyErr_SetString(PyExc_TypeError,
     1203                   "hex() argument can't be converted to hex");
     1204        return NULL;
     1205    }
     1206    res = (*nb->nb_hex)(v);
     1207    if (res && !PyString_Check(res)) {
     1208        PyErr_Format(PyExc_TypeError,
     1209                     "__hex__ returned non-string (type %.200s)",
     1210                     res->ob_type->tp_name);
     1211        Py_DECREF(res);
     1212        return NULL;
     1213    }
     1214    return res;
    12061215}
    12071216
    … …  
    12171226builtin_input(PyObject *self, PyObject *args)
    12181227{
    1219         PyObject *line;
    1220         char *str;
    1221         PyObject *res;
    1222         PyObject *globals, *locals;
    1223         PyCompilerFlags cf;
    1224 
    1225         line = builtin_raw_input(self, args);
    1226         if (line == NULL)
    1227                 return line;
    1228         if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
    1229                 return NULL;
    1230         while (*str == ' ' || *str == '\t')
    1231                         str++;
    1232         globals = PyEval_GetGlobals();
    1233         locals = PyEval_GetLocals();
    1234         if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
    1235                 if (PyDict_SetItemString(globals, "__builtins__",
    1236                                         PyEval_GetBuiltins()) != 0)
    1237                         return NULL;
    1238         }
    1239         cf.cf_flags = 0;
    1240         PyEval_MergeCompilerFlags(&cf);
    1241         res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
    1242         Py_DECREF(line);
    1243         return res;
     1228    PyObject *line;
     1229    char *str;
     1230    PyObject *res;
     1231    PyObject *globals, *locals;
     1232    PyCompilerFlags cf;
     1233
     1234    line = builtin_raw_input(self, args);
     1235    if (line == NULL)
     1236        return line;
     1237    if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
     1238        return NULL;
     1239    while (*str == ' ' || *str == '\t')
     1240                    str++;
     1241    globals = PyEval_GetGlobals();
     1242    locals = PyEval_GetLocals();
     1243    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
     1244        if (PyDict_SetItemString(globals, "__builtins__",
     1245                                PyEval_GetBuiltins()) != 0)
     1246            return NULL;
     1247    }
     1248    cf.cf_flags = 0;
     1249    PyEval_MergeCompilerFlags(&cf);
     1250    res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
     1251    Py_DECREF(line);
     1252    return res;
    12441253}
    12451254
    … …  
    12531262builtin_intern(PyObject *self, PyObject *args)
    12541263{
    1255         PyObject *s;
    1256         if (!PyArg_ParseTuple(args, "S:intern", &s))
    1257                 return NULL;
    1258         if (!PyString_CheckExact(s)) {
    1259                 PyErr_SetString(PyExc_TypeError,
    1260                                 "can't intern subclass of string");
    1261                 return NULL;
    1262         }
    1263         Py_INCREF(s);
    1264         PyString_InternInPlace(&s);
    1265         return s;
     1264    PyObject *s;
     1265    if (!PyArg_ParseTuple(args, "S:intern", &s))
     1266        return NULL;
     1267    if (!PyString_CheckExact(s)) {
     1268        PyErr_SetString(PyExc_TypeError,
     1269                        "can't intern subclass of string");
     1270        return NULL;
     1271    }
     1272    Py_INCREF(s);
     1273    PyString_InternInPlace(&s);
     1274    return s;
    12661275}
    12671276
    … …  
    12781287builtin_iter(PyObject *self, PyObject *args)
    12791288{
    1280         PyObject *v, *w = NULL;
    1281 
    1282         if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
    1283                 return NULL;
    1284         if (w == NULL)
    1285                 return PyObject_GetIter(v);
    1286         if (!PyCallable_Check(v)) {
    1287                 PyErr_SetString(PyExc_TypeError,
    1288                                 "iter(v, w): v must be callable");
    1289                 return NULL;
    1290         }
    1291         return PyCallIter_New(v, w);
     1289    PyObject *v, *w = NULL;
     1290
     1291    if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
     1292        return NULL;
     1293    if (w == NULL)
     1294        return PyObject_GetIter(v);
     1295    if (!PyCallable_Check(v)) {
     1296        PyErr_SetString(PyExc_TypeError,
     1297                        "iter(v, w): v must be callable");
     1298        return NULL;
     1299    }
     1300    return PyCallIter_New(v, w);
    12921301}
    12931302
    … …  
    13041313builtin_len(PyObject *self, PyObject *v)
    13051314{
    1306         Py_ssize_t res;
    1307 
    1308         res = PyObject_Size(v);
    1309         if (res < 0 && PyErr_Occurred())
    1310                 return NULL;
    1311         return PyInt_FromSsize_t(res);
     1315    Py_ssize_t res;
     1316
     1317    res = PyObject_Size(v);
     1318    if (res < 0 && PyErr_Occurred())
     1319        return NULL;
     1320    return PyInt_FromSsize_t(res);
    13121321}
    13131322
    … …  
    13211330builtin_locals(PyObject *self)
    13221331{
    1323         PyObject *d;
    1324 
    1325         d = PyEval_GetLocals();
    1326         Py_XINCREF(d);
    1327         return d;
     1332    PyObject *d;
     1333
     1334    d = PyEval_GetLocals();
     1335    Py_XINCREF(d);
     1336    return d;
    13281337}
    13291338
    … …  
    13371346min_max(PyObject *args, PyObject *kwds, int op)
    13381347{
    1339         PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
    1340         const char *name = op == Py_LT ? "min" : "max";
    1341 
    1342         if (PyTuple_Size(args) > 1)
    1343                 v = args;
    1344         else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
    1345                 return NULL;
    1346 
    1347         if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
    1348                 keyfunc = PyDict_GetItemString(kwds, "key");
    1349                 if (PyDict_Size(kwds)!=1  ||  keyfunc == NULL) {
    1350                         PyErr_Format(PyExc_TypeError,
    1351                                 "%s() got an unexpected keyword argument", name);
    1352                         return NULL;
    1353                 }
    1354                 Py_INCREF(keyfunc);
    1355         }
    1356 
    1357         it = PyObject_GetIter(v);
    1358         if (it == NULL) {
    1359                 Py_XDECREF(keyfunc);
    1360                 return NULL;
    1361         }
    1362 
    1363         maxitem = NULL; /* the result */
    1364         maxval = NULL;  /* the value associated with the result */
    1365         while (( item = PyIter_Next(it) )) {
    1366                 /* get the value from the key function */
    1367                 if (keyfunc != NULL) {
    1368                         val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
    1369                         if (val == NULL)
    1370                                 goto Fail_it_item;
    1371                 }
    1372                 /* no key function; the value is the item */
    1373                 else {
    1374                         val = item;
    1375                         Py_INCREF(val);
    1376                 }
    1377 
    1378                 /* maximum value and item are unset; set them */
    1379                 if (maxval == NULL) {
    1380                         maxitem = item;
    1381                         maxval = val;
    1382                 }
    1383                 /* maximum value and item are set; update them as necessary */
    1384                 else {
    1385                         int cmp = PyObject_RichCompareBool(val, maxval, op);
    1386                         if (cmp < 0)
    1387                                 goto Fail_it_item_and_val;
    1388                         else if (cmp > 0) {
    1389                                 Py_DECREF(maxval);
    1390                                 Py_DECREF(maxitem);
    1391                                 maxval = val;
    1392                                 maxitem = item;
    1393                         }
    1394                         else {
    1395                                 Py_DECREF(item);
    1396                                 Py_DECREF(val);
    1397                         }
    1398                 }
    1399         }
    1400         if (PyErr_Occurred())
    1401                 goto Fail_it;
    1402         if (maxval == NULL) {
    1403                 PyErr_Format(PyExc_ValueError,
    1404                              "%s() arg is an empty sequence", name);
    1405                 assert(maxitem == NULL);
    1406         }
    1407         else
    1408                 Py_DECREF(maxval);
    1409         Py_DECREF(it);
    1410         Py_XDECREF(keyfunc);
    1411         return maxitem;
     1348    PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
     1349    const char *name = op == Py_LT ? "min" : "max";
     1350
     1351    if (PyTuple_Size(args) > 1)
     1352        v = args;
     1353    else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
     1354        return NULL;
     1355
     1356    if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
     1357        keyfunc = PyDict_GetItemString(kwds, "key");
     1358        if (PyDict_Size(kwds)!=1  ||  keyfunc == NULL) {
     1359            PyErr_Format(PyExc_TypeError,
     1360                "%s() got an unexpected keyword argument", name);
     1361            return NULL;
     1362        }
     1363        Py_INCREF(keyfunc);
     1364    }
     1365
     1366    it = PyObject_GetIter(v);
     1367    if (it == NULL) {
     1368        Py_XDECREF(keyfunc);
     1369        return NULL;
     1370    }
     1371
     1372    maxitem = NULL; /* the result */
     1373    maxval = NULL;  /* the value associated with the result */
     1374    while (( item = PyIter_Next(it) )) {
     1375        /* get the value from the key function */
     1376        if (keyfunc != NULL) {
     1377            val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
     1378            if (val == NULL)
     1379                goto Fail_it_item;
     1380        }
     1381        /* no key function; the value is the item */
     1382        else {
     1383            val = item;
     1384            Py_INCREF(val);
     1385        }
     1386
     1387        /* maximum value and item are unset; set them */
     1388        if (maxval == NULL) {
     1389            maxitem = item;
     1390            maxval = val;
     1391        }
     1392        /* maximum value and item are set; update them as necessary */
     1393        else {
     1394            int cmp = PyObject_RichCompareBool(val, maxval, op);
     1395            if (cmp < 0)
     1396                goto Fail_it_item_and_val;
     1397            else if (cmp > 0) {
     1398                Py_DECREF(maxval);
     1399                Py_DECREF(maxitem);
     1400                maxval = val;
     1401                maxitem = item;
     1402            }
     1403            else {
     1404                Py_DECREF(item);
     1405                Py_DECREF(val);
     1406            }
     1407        }
     1408    }
     1409    if (PyErr_Occurred())
     1410        goto Fail_it;
     1411    if (maxval == NULL) {
     1412        PyErr_Format(PyExc_ValueError,
     1413                     "%s() arg is an empty sequence", name);
     1414        assert(maxitem == NULL);
     1415    }
     1416    else
     1417        Py_DECREF(maxval);
     1418    Py_DECREF(it);
     1419    Py_XDECREF(keyfunc);
     1420    return maxitem;
    14121421
    14131422Fail_it_item_and_val:
    1414         Py_DECREF(val);
     1423    Py_DECREF(val);
    14151424Fail_it_item:
    1416         Py_DECREF(item);
     1425    Py_DECREF(item);
    14171426Fail_it:
    1418         Py_XDECREF(maxval);
    1419         Py_XDECREF(maxitem);
    1420         Py_DECREF(it);
    1421         Py_XDECREF(keyfunc);
    1422         return NULL;
     1427    Py_XDECREF(maxval);
     1428    Py_XDECREF(maxitem);
     1429    Py_DECREF(it);
     1430    Py_XDECREF(keyfunc);
     1431    return NULL;
    14231432}
    14241433
    … …  
    14261435builtin_min(PyObject *self, PyObject *args, PyObject *kwds)
    14271436{
    1428         return min_max(args, kwds, Py_LT);
     1437    return min_max(args, kwds, Py_LT);
    14291438}
    14301439
    … …  
    14401449builtin_max(PyObject *self, PyObject *args, PyObject *kwds)
    14411450{
    1442         return min_max(args, kwds, Py_GT);
     1451    return min_max(args, kwds, Py_GT);
    14431452}
    14441453
    … …  
    14541463builtin_oct(PyObject *self, PyObject *v)
    14551464{
    1456         PyNumberMethods *nb;
    1457         PyObject *res;
    1458 
    1459         if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
    1460             nb->nb_oct == NULL) {
    1461                 PyErr_SetString(PyExc_TypeError,
    1462                            "oct() argument can't be converted to oct");
    1463                 return NULL;
    1464         }
    1465         res = (*nb->nb_oct)(v);
    1466         if (res && !PyString_Check(res)) {
    1467                 PyErr_Format(PyExc_TypeError,
    1468                              "__oct__ returned non-string (type %.200s)",
    1469                              res->ob_type->tp_name);
    1470                 Py_DECREF(res);
    1471                 return NULL;
    1472         }
    1473         return res;
     1465    PyNumberMethods *nb;
     1466    PyObject *res;
     1467
     1468    if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
     1469        nb->nb_oct == NULL) {
     1470        PyErr_SetString(PyExc_TypeError,
     1471                   "oct() argument can't be converted to oct");
     1472        return NULL;
     1473    }
     1474    res = (*nb->nb_oct)(v);
     1475    if (res && !PyString_Check(res)) {
     1476        PyErr_Format(PyExc_TypeError,
     1477                     "__oct__ returned non-string (type %.200s)",
     1478                     res->ob_type->tp_name);
     1479        Py_DECREF(res);
     1480        return NULL;
     1481    }
     1482    return res;
    14741483}
    14751484
    … …  
    14831492builtin_open(PyObject *self, PyObject *args, PyObject *kwds)
    14841493{
    1485         return PyObject_Call((PyObject*)&PyFile_Type, args, kwds);
     1494    return PyObject_Call((PyObject*)&PyFile_Type, args, kwds);
    14861495}
    14871496
    … …  
    14901499\n\
    14911500Open a file using the file() type, returns a file object.  This is the\n\
    1492 preferred way to open a file.");
     1501preferred way to open a file.  See file.__doc__ for further information.");
    14931502
    14941503
    … …  
    14961505builtin_ord(PyObject *self, PyObject* obj)
    14971506{
    1498         long ord;
    1499         Py_ssize_t size;
    1500 
    1501         if (PyString_Check(obj)) {
    1502                 size = PyString_GET_SIZE(obj);
    1503                 if (size == 1) {
    1504                         ord = (long)((unsigned char)*PyString_AS_STRING(obj));
    1505                         return PyInt_FromLong(ord);
    1506                 }
    1507         } else if (PyByteArray_Check(obj)) {
    1508                 size = PyByteArray_GET_SIZE(obj);
    1509                 if (size == 1) {
    1510                         ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
    1511                         return PyInt_FromLong(ord);
    1512                 }
     1507    long ord;
     1508    Py_ssize_t size;
     1509
     1510    if (PyString_Check(obj)) {
     1511        size = PyString_GET_SIZE(obj);
     1512        if (size == 1) {
     1513            ord = (long)((unsigned char)*PyString_AS_STRING(obj));
     1514            return PyInt_FromLong(ord);
     1515        }
     1516    } else if (PyByteArray_Check(obj)) {
     1517        size = PyByteArray_GET_SIZE(obj);
     1518        if (size == 1) {
     1519            ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
     1520            return PyInt_FromLong(ord);
     1521        }
    15131522
    15141523#ifdef Py_USING_UNICODE
    1515         } else if (PyUnicode_Check(obj)) {
    1516                 size = PyUnicode_GET_SIZE(obj);
    1517                 if (size == 1) {
    1518                         ord = (long)*PyUnicode_AS_UNICODE(obj);
    1519                         return PyInt_FromLong(ord);
    1520                 }
     1524    } else if (PyUnicode_Check(obj)) {
     1525        size = PyUnicode_GET_SIZE(obj);
     1526        if (size == 1) {
     1527            ord = (long)*PyUnicode_AS_UNICODE(obj);
     1528            return PyInt_FromLong(ord);
     1529        }
    15211530#endif
    1522         } else {
    1523                 PyErr_Format(PyExc_TypeError,
    1524                              "ord() expected string of length 1, but " \
    1525                              "%.200s found", obj->ob_type->tp_name);
    1526                 return NULL;
    1527         }
    1528 
    1529         PyErr_Format(PyExc_TypeError,
    1530                      "ord() expected a character, "
    1531                      "but string of length %zd found",
    1532                      size);
    1533         return NULL;
     1531    } else {
     1532        PyErr_Format(PyExc_TypeError,
     1533                     "ord() expected string of length 1, but " \
     1534                     "%.200s found", obj->ob_type->tp_name);
     1535        return NULL;
     1536    }
     1537
     1538    PyErr_Format(PyExc_TypeError,
     1539                 "ord() expected a character, "
     1540                 "but string of length %zd found",
     1541                 size);
     1542    return NULL;
    15341543}
    15351544
    … …  
    15431552builtin_pow(PyObject *self, PyObject *args)
    15441553{
    1545         PyObject *v, *w, *z = Py_None;
    1546 
    1547         if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
    1548                 return NULL;
    1549         return PyNumber_Power(v, w, z);
     1554    PyObject *v, *w, *z = Py_None;
     1555
     1556    if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
     1557        return NULL;
     1558    return PyNumber_Power(v, w, z);
    15501559}
    15511560
    … …  
    15601569builtin_print(PyObject *self, PyObject *args, PyObject *kwds)
    15611570{
    1562         static char *kwlist[] = {"sep", "end", "file", 0};
    1563         static PyObject *dummy_args = NULL;
    1564         static PyObject *unicode_newline = NULL, *unicode_space = NULL;
    1565         static PyObject *str_newline = NULL, *str_space = NULL;
    1566         PyObject *newline, *space;
    1567         PyObject *sep = NULL, *end = NULL, *file = NULL;
    1568         int i, err, use_unicode = 0;
    1569 
    1570         if (dummy_args == NULL) {
    1571                 if (!(dummy_args = PyTuple_New(0)))
    1572                         return NULL;
    1573         }
    1574         if (str_newline == NULL) {
    1575                 str_newline = PyString_FromString("\n");
    1576                 if (str_newline == NULL)
    1577                         return NULL;
    1578                 str_space = PyString_FromString(" ");
    1579                 if (str_space == NULL) {
    1580                         Py_CLEAR(str_newline);
    1581                         return NULL;
    1582                 }
    1583                 unicode_newline = PyUnicode_FromString("\n");
    1584                 if (unicode_newline == NULL) {
    1585                         Py_CLEAR(str_newline);
    1586                         Py_CLEAR(str_space);
    1587                         return NULL;
    1588                 }
    1589                 unicode_space = PyUnicode_FromString(" ");
    1590                 if (unicode_space == NULL) {
    1591                         Py_CLEAR(str_newline);
    1592                         Py_CLEAR(str_space);
    1593                         Py_CLEAR(unicode_space);
    1594                         return NULL;
    1595                 }
    1596         }
    1597         if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
    1598                                          kwlist, &sep, &end, &file))
    1599                 return NULL;
    1600         if (file == NULL || file == Py_None) {
    1601                 file = PySys_GetObject("stdout");
    1602                 /* sys.stdout may be None when FILE* stdout isn't connected */
    1603                 if (file == Py_None)
    1604                         Py_RETURN_NONE;
    1605         }
    1606         if (sep == Py_None) {
    1607                 sep = NULL;
    1608         }
    1609         else if (sep) {
    1610                 if (PyUnicode_Check(sep)) {
    1611                         use_unicode = 1;
    1612                 }
    1613                 else if (!PyString_Check(sep)) {
    1614                         PyErr_Format(PyExc_TypeError,
    1615                                      "sep must be None, str or unicode, not %.200s",
    1616                                      sep->ob_type->tp_name);
    1617                         return NULL;
    1618                 }
    1619         }
    1620         if (end == Py_None)
    1621                 end = NULL;
    1622         else if (end) {
    1623                 if (PyUnicode_Check(end)) {
    1624                         use_unicode = 1;
    1625                 }
    1626                 else if (!PyString_Check(end)) {
    1627                         PyErr_Format(PyExc_TypeError,
    1628                                      "end must be None, str or unicode, not %.200s",
    1629                                      end->ob_type->tp_name);
    1630                         return NULL;
    1631                 }
    1632         }
    1633 
    1634         if (!use_unicode) {
    1635                 for (i = 0; i < PyTuple_Size(args); i++) {
    1636                         if (PyUnicode_Check(PyTuple_GET_ITEM(args, i))) {
    1637                                 use_unicode = 1;
    1638                                 break;
    1639                         }
    1640                 }
    1641         }
    1642         if (use_unicode) {
    1643                 newline = unicode_newline;
    1644                 space = unicode_space;
    1645         }
    1646         else {
    1647                 newline = str_newline;
    1648                 space = str_space;
    1649         }
    1650 
    1651         for (i = 0; i < PyTuple_Size(args); i++) {
    1652                 if (i > 0) {
    1653                         if (sep == NULL)
    1654                                 err = PyFile_WriteObject(space, file,
    1655                                                          Py_PRINT_RAW);
    1656                         else
    1657                                 err = PyFile_WriteObject(sep, file,
    1658                                                          Py_PRINT_RAW);
    1659                         if (err)
    1660                                 return NULL;
    1661                 }
    1662                 err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
    1663                                          Py_PRINT_RAW);
    1664                 if (err)
    1665                         return NULL;
    1666         }
    1667 
    1668         if (end == NULL)
    1669                 err = PyFile_WriteObject(newline, file, Py_PRINT_RAW);
    1670         else
    1671                 err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
    1672         if (err)
    1673                 return NULL;
    1674 
    1675         Py_RETURN_NONE;
     1571    static char *kwlist[] = {"sep", "end", "file", 0};
     1572    static PyObject *dummy_args = NULL;
     1573    static PyObject *unicode_newline = NULL, *unicode_space = NULL;
     1574    static PyObject *str_newline = NULL, *str_space = NULL;
     1575    PyObject *newline, *space;
     1576    PyObject *sep = NULL, *end = NULL, *file = NULL;
     1577    int i, err, use_unicode = 0;
     1578
     1579    if (dummy_args == NULL) {
     1580        if (!(dummy_args = PyTuple_New(0)))
     1581            return NULL;
     1582    }
     1583    if (str_newline == NULL) {
     1584        str_newline = PyString_FromString("\n");
     1585        if (str_newline == NULL)
     1586            return NULL;
     1587        str_space = PyString_FromString(" ");
     1588        if (str_space == NULL) {
     1589            Py_CLEAR(str_newline);
     1590            return NULL;
     1591        }
     1592#ifdef Py_USING_UNICODE
     1593        unicode_newline = PyUnicode_FromString("\n");
     1594        if (unicode_newline == NULL) {
     1595            Py_CLEAR(str_newline);
     1596            Py_CLEAR(str_space);
     1597            return NULL;
     1598        }
     1599        unicode_space = PyUnicode_FromString(" ");
     1600        if (unicode_space == NULL) {
     1601            Py_CLEAR(str_newline);
     1602            Py_CLEAR(str_space);
     1603            Py_CLEAR(unicode_space);
     1604            return NULL;
     1605        }
     1606#endif
     1607    }
     1608    if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
     1609                                     kwlist, &sep, &end, &file))
     1610        return NULL;
     1611    if (file == NULL || file == Py_None) {
     1612        file = PySys_GetObject("stdout");
     1613        /* sys.stdout may be None when FILE* stdout isn't connected */
     1614        if (file == Py_None)
     1615            Py_RETURN_NONE;
     1616    }
     1617    if (sep == Py_None) {
     1618        sep = NULL;
     1619    }
     1620    else if (sep) {
     1621        if (PyUnicode_Check(sep)) {
     1622            use_unicode = 1;
     1623        }
     1624        else if (!PyString_Check(sep)) {
     1625            PyErr_Format(PyExc_TypeError,
     1626                         "sep must be None, str or unicode, not %.200s",
     1627                         sep->ob_type->tp_name);
     1628            return NULL;
     1629        }
     1630    }
     1631    if (end == Py_None)
     1632        end = NULL;
     1633    else if (end) {
     1634        if (PyUnicode_Check(end)) {
     1635            use_unicode = 1;
     1636        }
     1637        else if (!PyString_Check(end)) {
     1638            PyErr_Format(PyExc_TypeError,
     1639                         "end must be None, str or unicode, not %.200s",
     1640                         end->ob_type->tp_name);
     1641            return NULL;
     1642        }
     1643    }
     1644
     1645    if (!use_unicode) {
     1646        for (i = 0; i < PyTuple_Size(args); i++) {
     1647            if (PyUnicode_Check(PyTuple_GET_ITEM(args, i))) {
     1648                use_unicode = 1;
     1649                break;
     1650            }
     1651        }
     1652    }
     1653    if (use_unicode) {
     1654        newline = unicode_newline;
     1655        space = unicode_space;
     1656    }
     1657    else {
     1658        newline = str_newline;
     1659        space = str_space;
     1660    }
     1661
     1662    for (i = 0; i < PyTuple_Size(args); i++) {
     1663        if (i > 0) {
     1664            if (sep == NULL)
     1665                err = PyFile_WriteObject(space, file,
     1666                                         Py_PRINT_RAW);
     1667            else
     1668                err = PyFile_WriteObject(sep, file,
     1669                                         Py_PRINT_RAW);
     1670            if (err)
     1671                return NULL;
     1672        }
     1673        err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
     1674                                 Py_PRINT_RAW);
     1675        if (err)
     1676            return NULL;
     1677    }
     1678
     1679    if (end == NULL)
     1680        err = PyFile_WriteObject(newline, file, Py_PRINT_RAW);
     1681    else
     1682        err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
     1683    if (err)
     1684        return NULL;
     1685
     1686    Py_RETURN_NONE;
    16761687}
    16771688
    … …  
    16951706get_len_of_range_longs(PyObject *lo, PyObject *hi, PyObject *step)
    16961707{
    1697         /* -------------------------------------------------------------
    1698         Algorithm is equal to that of get_len_of_range(), but it operates
    1699         on PyObjects (which are assumed to be PyLong or PyInt objects).
    1700         ---------------------------------------------------------------*/
    1701         long n;
    1702         PyObject *diff = NULL;
    1703         PyObject *one = NULL;
    1704         PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
    1705                 /* holds sub-expression evaluations */
    1706 
    1707         /* if (lo >= hi), return length of 0. */
    1708         if (PyObject_Compare(lo, hi) >= 0)
    1709                 return 0;
    1710 
    1711         if ((one = PyLong_FromLong(1L)) == NULL)
    1712                 goto Fail;
    1713 
    1714         if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
    1715                 goto Fail;
    1716 
    1717         if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
    1718                 goto Fail;
    1719 
    1720         if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
    1721                 goto Fail;
    1722 
    1723         if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
    1724                 goto Fail;
    1725 
    1726         n = PyLong_AsLong(tmp3);
    1727         if (PyErr_Occurred()) {  /* Check for Overflow */
    1728                 PyErr_Clear();
    1729                 goto Fail;
    1730         }
    1731 
    1732         Py_DECREF(tmp3);
    1733         Py_DECREF(tmp2);
    1734         Py_DECREF(diff);
    1735         Py_DECREF(tmp1);
    1736         Py_DECREF(one);
    1737         return n;
     1708    /* -------------------------------------------------------------
     1709    Algorithm is equal to that of get_len_of_range(), but it operates
     1710    on PyObjects (which are assumed to be PyLong or PyInt objects).
     1711    ---------------------------------------------------------------*/
     1712    long n;
     1713    PyObject *diff = NULL;
     1714    PyObject *one = NULL;
     1715    PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
     1716        /* holds sub-expression evaluations */
     1717
     1718    /* if (lo >= hi), return length of 0. */
     1719    if (PyObject_Compare(lo, hi) >= 0)
     1720        return 0;
     1721
     1722    if ((one = PyLong_FromLong(1L)) == NULL)
     1723        goto Fail;
     1724
     1725    if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
     1726        goto Fail;
     1727
     1728    if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
     1729        goto Fail;
     1730
     1731    if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
     1732        goto Fail;
     1733
     1734    if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
     1735        goto Fail;
     1736
     1737    n = PyLong_AsLong(tmp3);
     1738    if (PyErr_Occurred()) {  /* Check for Overflow */
     1739        PyErr_Clear();
     1740        goto Fail;
     1741    }
     1742
     1743    Py_DECREF(tmp3);
     1744    Py_DECREF(tmp2);
     1745    Py_DECREF(diff);
     1746    Py_DECREF(tmp1);
     1747    Py_DECREF(one);
     1748    return n;
    17381749
    17391750  Fail:
    1740         Py_XDECREF(tmp3);
    1741         Py_XDECREF(tmp2);
    1742         Py_XDECREF(diff);
    1743         Py_XDECREF(tmp1);
    1744         Py_XDECREF(one);
    1745         return -1;
     1751    Py_XDECREF(tmp3);
     1752    Py_XDECREF(tmp2);
     1753    Py_XDECREF(diff);
     1754    Py_XDECREF(tmp1);
     1755    Py_XDECREF(one);
     1756    return -1;
     1757}
     1758
     1759/* Helper function for handle_range_longs.  If arg is int or long
     1760   object, returns it with incremented reference count.  If arg is
     1761   float, raises type error. As a last resort, creates a new int by
     1762   calling arg type's nb_int method if it is defined.  Returns NULL
     1763   and sets exception on error.
     1764
     1765   Returns a new reference to an int object. */
     1766static PyObject *
     1767get_range_long_argument(PyObject *arg, const char *name)
     1768{
     1769    PyObject *v;
     1770    PyNumberMethods *nb;
     1771    if (PyInt_Check(arg) || PyLong_Check(arg)) {
     1772        Py_INCREF(arg);
     1773        return arg;
     1774    }
     1775    if (PyFloat_Check(arg) ||
     1776        (nb = Py_TYPE(arg)->tp_as_number) == NULL ||
     1777        nb->nb_int == NULL) {
     1778        PyErr_Format(PyExc_TypeError,
     1779                     "range() integer %s argument expected, got %s.",
     1780                     name, arg->ob_type->tp_name);
     1781        return NULL;
     1782    }
     1783    v = nb->nb_int(arg);
     1784    if (v == NULL)
     1785        return NULL;
     1786    if (PyInt_Check(v) || PyLong_Check(v))
     1787        return v;
     1788    Py_DECREF(v);
     1789    PyErr_SetString(PyExc_TypeError,
     1790                    "__int__ should return int object");
     1791    return NULL;
    17461792}
    17471793
    … …  
    17511797handle_range_longs(PyObject *self, PyObject *args)
    17521798{
    1753         PyObject *ilow;
    1754         PyObject *ihigh = NULL;
    1755         PyObject *istep = NULL;
    1756 
    1757         PyObject *curnum = NULL;
    1758         PyObject *v = NULL;
    1759         long bign;
    1760         int i, n;
    1761         int cmp_result;
    1762 
    1763         PyObject *zero = PyLong_FromLong(0);
    1764 
    1765         if (zero == NULL)
    1766                 return NULL;
    1767 
    1768         if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
    1769                 Py_DECREF(zero);
    1770                 return NULL;
    1771         }
    1772 
    1773         /* Figure out which way we were called, supply defaults, and be
    1774          * sure to incref everything so that the decrefs at the end
    1775          * are correct.
    1776          */
    1777         assert(ilow != NULL);
    1778         if (ihigh == NULL) {
    1779                 /* only 1 arg -- it's the upper limit */
    1780                 ihigh = ilow;
    1781                 ilow = NULL;
    1782         }
    1783         assert(ihigh != NULL);
    1784         Py_INCREF(ihigh);
    1785 
    1786         /* ihigh correct now; do ilow */
    1787         if (ilow == NULL)
    1788                 ilow = zero;
    1789         Py_INCREF(ilow);
    1790 
    1791         /* ilow and ihigh correct now; do istep */
    1792         if (istep == NULL) {
    1793                 istep = PyLong_FromLong(1L);
    1794                 if (istep == NULL)
    1795                         goto Fail;
    1796         }
    1797         else {
    1798                 Py_INCREF(istep);
    1799         }
    1800 
    1801         if (!PyInt_Check(ilow) && !PyLong_Check(ilow)) {
    1802                 PyErr_Format(PyExc_TypeError,
    1803                              "range() integer start argument expected, got %s.",
    1804                              ilow->ob_type->tp_name);
    1805                 goto Fail;
    1806         }
    1807 
    1808         if (!PyInt_Check(ihigh) && !PyLong_Check(ihigh)) {
    1809                 PyErr_Format(PyExc_TypeError,
    1810                              "range() integer end argument expected, got %s.",
    1811                              ihigh->ob_type->tp_name);
    1812                 goto Fail;
    1813         }
    1814 
    1815         if (!PyInt_Check(istep) && !PyLong_Check(istep)) {
    1816                 PyErr_Format(PyExc_TypeError,
    1817                              "range() integer step argument expected, got %s.",
    1818                              istep->ob_type->tp_name);
    1819                 goto Fail;
    1820         }
    1821 
    1822         if (PyObject_Cmp(istep, zero, &cmp_result) == -1)
    1823                 goto Fail;
    1824         if (cmp_result == 0) {
    1825                 PyErr_SetString(PyExc_ValueError,
    1826                                 "range() step argument must not be zero");
    1827                 goto Fail;
    1828         }
    1829 
    1830         if (cmp_result > 0)
    1831                 bign = get_len_of_range_longs(ilow, ihigh, istep);
    1832         else {
    1833                 PyObject *neg_istep = PyNumber_Negative(istep);
    1834                 if (neg_istep == NULL)
    1835                         goto Fail;
    1836                 bign = get_len_of_range_longs(ihigh, ilow, neg_istep);
    1837                 Py_DECREF(neg_istep);
    1838         }
    1839 
    1840         n = (int)bign;
    1841         if (bign < 0 || (long)n != bign) {
    1842                 PyErr_SetString(PyExc_OverflowError,
    1843                                 "range() result has too many items");
    1844                 goto Fail;
    1845         }
    1846 
    1847         v = PyList_New(n);
    1848         if (v == NULL)
    1849                 goto Fail;
    1850 
    1851         curnum = ilow;
    1852         Py_INCREF(curnum);
    1853 
    1854         for (i = 0; i < n; i++) {
    1855                 PyObject *w = PyNumber_Long(curnum);
    1856                 PyObject *tmp_num;
    1857                 if (w == NULL)
    1858                         goto Fail;
    1859 
    1860                 PyList_SET_ITEM(v, i, w);
    1861 
    1862                 tmp_num = PyNumber_Add(curnum, istep);
    1863                 if (tmp_num == NULL)
    1864                         goto Fail;
    1865 
    1866                 Py_DECREF(curnum);
    1867                 curnum = tmp_num;
    1868         }
    1869         Py_DECREF(ilow);
    1870         Py_DECREF(ihigh);
    1871         Py_DECREF(istep);
    1872         Py_DECREF(zero);
    1873         Py_DECREF(curnum);
    1874         return v;
     1799    PyObject *ilow = NULL;
     1800    PyObject *ihigh = NULL;
     1801    PyObject *istep = NULL;
     1802
     1803    PyObject *low = NULL;
     1804    PyObject *high = NULL;
     1805    PyObject *step = NULL;
     1806
     1807    PyObject *curnum = NULL;
     1808    PyObject *v = NULL;
     1809    long bign;
     1810    Py_ssize_t i, n;
     1811    int cmp_result;
     1812
     1813    PyObject *zero = PyLong_FromLong(0);
     1814
     1815    if (zero == NULL)
     1816        return NULL;
     1817
     1818    if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
     1819        Py_DECREF(zero);
     1820        return NULL;
     1821    }
     1822
     1823    /* Figure out which way we were called, supply defaults, and be
     1824     * sure to incref everything so that the decrefs at the end
     1825     * are correct. NB: ilow, ihigh and istep are borrowed references.
     1826     */
     1827    assert(ilow != NULL);
     1828    if (ihigh == NULL) {
     1829        /* only 1 arg -- it's the upper limit */
     1830        ihigh = ilow;
     1831        ilow = NULL;
     1832    }
     1833
     1834    /* convert ihigh if necessary */
     1835    assert(ihigh != NULL);
     1836    high = get_range_long_argument(ihigh, "end");
     1837    if (high == NULL)
     1838        goto Fail;
     1839
     1840    /* ihigh correct now; do ilow */
     1841    if (ilow == NULL) {
     1842        Py_INCREF(zero);
     1843        low = zero;
     1844    }
     1845    else {
     1846        low = get_range_long_argument(ilow, "start");
     1847        if (low == NULL)
     1848            goto Fail;
     1849    }
     1850
     1851    /* ilow and ihigh correct now; do istep */
     1852    if (istep == NULL)
     1853        step = PyLong_FromLong(1);
     1854    else
     1855        step = get_range_long_argument(istep, "step");
     1856    if (step == NULL)
     1857        goto Fail;
     1858
     1859    if (PyObject_Cmp(step, zero, &cmp_result) == -1)
     1860        goto Fail;
     1861
     1862    if (cmp_result == 0) {
     1863        PyErr_SetString(PyExc_ValueError,
     1864                        "range() step argument must not be zero");
     1865        goto Fail;
     1866    }
     1867
     1868    if (cmp_result > 0)
     1869        bign = get_len_of_range_longs(low, high, step);
     1870    else {
     1871        PyObject *neg_step = PyNumber_Negative(step);
     1872        if (neg_step == NULL)
     1873            goto Fail;
     1874        bign = get_len_of_range_longs(high, low, neg_step);
     1875        Py_DECREF(neg_step);
     1876    }
     1877
     1878    n = (Py_ssize_t)bign;
     1879    if (bign < 0 || (long)n != bign) {
     1880        PyErr_SetString(PyExc_OverflowError,
     1881                        "range() result has too many items");
     1882        goto Fail;
     1883    }
     1884
     1885    v = PyList_New(n);
     1886    if (v == NULL)
     1887        goto Fail;
     1888
     1889    curnum = low;
     1890    Py_INCREF(curnum);
     1891
     1892    for (i = 0; i < n; i++) {
     1893        PyObject *w = PyNumber_Long(curnum);
     1894        PyObject *tmp_num;
     1895        if (w == NULL)
     1896            goto Fail;
     1897
     1898        PyList_SET_ITEM(v, i, w);
     1899
     1900        tmp_num = PyNumber_Add(curnum, step);
     1901        if (tmp_num == NULL)
     1902            goto Fail;
     1903
     1904        Py_DECREF(curnum);
     1905        curnum = tmp_num;
     1906    }
     1907    Py_DECREF(low);
     1908    Py_DECREF(high);
     1909    Py_DECREF(step);
     1910    Py_DECREF(zero);
     1911    Py_DECREF(curnum);
     1912    return v;
    18751913
    18761914  Fail:
    1877         Py_DECREF(ilow);
    1878         Py_DECREF(ihigh);
    1879         Py_XDECREF(istep);
    1880         Py_DECREF(zero);
    1881         Py_XDECREF(curnum);
    1882         Py_XDECREF(v);
    1883         return NULL;
     1915    Py_XDECREF(low);
     1916    Py_XDECREF(high);
     1917    Py_XDECREF(step);
     1918    Py_DECREF(zero);
     1919    Py_XDECREF(curnum);
     1920    Py_XDECREF(v);
     1921    return NULL;
    18841922}
    18851923
    … …  
    18911929get_len_of_range(long lo, long hi, long step)
    18921930{
    1893         /* -------------------------------------------------------------
    1894         If lo >= hi, the range is empty.
    1895         Else if n values are in the range, the last one is
    1896         lo + (n-1)*step, which must be <= hi-1.  Rearranging,
    1897         n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
    1898         the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
    1899         the RHS is non-negative and so truncation is the same as the
    1900         floor.  Letting M be the largest positive long, the worst case
    1901         for the RHS numerator is hi=M, lo=-M-1, and then
    1902         hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
    1903         precision to compute the RHS exactly.
    1904         ---------------------------------------------------------------*/
    1905         long n = 0;
    1906         if (lo < hi) {
    1907                 unsigned long uhi = (unsigned long)hi;
    1908                 unsigned long ulo = (unsigned long)lo;
    1909                 unsigned long diff = uhi - ulo - 1;
    1910                 n = (long)(diff / (unsigned long)step + 1);
    1911         }
    1912         return n;
     1931    /* -------------------------------------------------------------
     1932    If lo >= hi, the range is empty.
     1933    Else if n values are in the range, the last one is
     1934    lo + (n-1)*step, which must be <= hi-1.  Rearranging,
     1935    n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
     1936    the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
     1937    the RHS is non-negative and so truncation is the same as the
     1938    floor.  Letting M be the largest positive long, the worst case
     1939    for the RHS numerator is hi=M, lo=-M-1, and then
     1940    hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
     1941    precision to compute the RHS exactly.
     1942    ---------------------------------------------------------------*/
     1943    long n = 0;
     1944    if (lo < hi) {
     1945        unsigned long uhi = (unsigned long)hi;
     1946        unsigned long ulo = (unsigned long)lo;
     1947        unsigned long diff = uhi - ulo - 1;
     1948        n = (long)(diff / (unsigned long)step + 1);
     1949    }
     1950    return n;
    19131951}
    19141952
    … …  
    19161954builtin_range(PyObject *self, PyObject *args)
    19171955{
    1918         long ilow = 0, ihigh = 0, istep = 1;
    1919         long bign;
    1920         int i, n;
    1921 
    1922         PyObject *v;
    1923 
    1924         if (PyTuple_Size(args) <= 1) {
    1925                 if (!PyArg_ParseTuple(args,
    1926                                 "l;range() requires 1-3 int arguments",
    1927                                 &ihigh)) {
    1928                         PyErr_Clear();
    1929                         return handle_range_longs(self, args);
    1930                 }
    1931         }
    1932         else {
    1933                 if (!PyArg_ParseTuple(args,
    1934                                 "ll|l;range() requires 1-3 int arguments",
    1935                                 &ilow, &ihigh, &istep)) {
    1936                         PyErr_Clear();
    1937                         return handle_range_longs(self, args);
    1938                 }
    1939         }
    1940         if (istep == 0) {
    1941                 PyErr_SetString(PyExc_ValueError,
    1942                                 "range() step argument must not be zero");
    1943                 return NULL;
    1944         }
    1945         if (istep > 0)
    1946                 bign = get_len_of_range(ilow, ihigh, istep);
    1947         else
    1948                 bign = get_len_of_range(ihigh, ilow, -istep);
    1949         n = (int)bign;
    1950         if (bign < 0 || (long)n != bign) {
    1951                 PyErr_SetString(PyExc_OverflowError,
    1952                                 "range() result has too many items");
    1953                 return NULL;
    1954         }
    1955         v = PyList_New(n);
    1956         if (v == NULL)
    1957                 return NULL;
    1958         for (i = 0; i < n; i++) {
    1959                 PyObject *w = PyInt_FromLong(ilow);
    1960                 if (w == NULL) {
    1961                         Py_DECREF(v);
    1962                         return NULL;
    1963                 }
    1964                 PyList_SET_ITEM(v, i, w);
    1965                 ilow += istep;
    1966         }
    1967         return v;
     1956    long ilow = 0, ihigh = 0, istep = 1;
     1957    long bign;
     1958    Py_ssize_t i, n;
     1959
     1960    PyObject *v;
     1961
     1962    if (PyTuple_Size(args) <= 1) {
     1963        if (!PyArg_ParseTuple(args,
     1964                        "l;range() requires 1-3 int arguments",
     1965                        &ihigh)) {
     1966            PyErr_Clear();
     1967            return handle_range_longs(self, args);
     1968        }
     1969    }
     1970    else {
     1971        if (!PyArg_ParseTuple(args,
     1972                        "ll|l;range() requires 1-3 int arguments",
     1973                        &ilow, &ihigh, &istep)) {
     1974            PyErr_Clear();
     1975            return handle_range_longs(self, args);
     1976        }
     1977    }
     1978    if (istep == 0) {
     1979        PyErr_SetString(PyExc_ValueError,
     1980                        "range() step argument must not be zero");
     1981        return NULL;
     1982    }
     1983    if (istep > 0)
     1984        bign = get_len_of_range(ilow, ihigh, istep);
     1985    else
     1986        bign = get_len_of_range(ihigh, ilow, -istep);
     1987    n = (Py_ssize_t)bign;
     1988    if (bign < 0 || (long)n != bign) {
     1989        PyErr_SetString(PyExc_OverflowError,
     1990                        "range() result has too many items");
     1991        return NULL;
     1992    }
     1993    v = PyList_New(n);
     1994    if (v == NULL)
     1995        return NULL;
     1996    for (i = 0; i < n; i++) {
     1997        PyObject *w = PyInt_FromLong(ilow);
     1998        if (w == NULL) {
     1999            Py_DECREF(v);
     2000            return NULL;
     2001        }
     2002        PyList_SET_ITEM(v, i, w);
     2003        ilow += istep;
     2004    }
     2005    return v;
    19682006}
    19692007
    19702008PyDoc_STRVAR(range_doc,
    1971 "range([start,] stop[, step]) -> list of integers\n\
     2009"range(stop) -> list of integers\n\
     2010range(start, stop[, step]) -> list of integers\n\
    19722011\n\
    19732012Return a list containing an arithmetic progression of integers.\n\
    … …  
    19812020builtin_raw_input(PyObject *self, PyObject *args)
    19822021{
    1983         PyObject *v = NULL;
    1984         PyObject *fin = PySys_GetObject("stdin");
    1985         PyObject *fout = PySys_GetObject("stdout");
    1986 
    1987         if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
    1988                 return NULL;
    1989 
    1990         if (fin == NULL) {
    1991                 PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
    1992                 return NULL;
    1993         }
    1994         if (fout == NULL) {
    1995                 PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
    1996                 return NULL;
    1997         }
    1998         if (PyFile_SoftSpace(fout, 0)) {
    1999                 if (PyFile_WriteString(" ", fout) != 0)
    2000                         return NULL;
    2001         }
    2002         if (PyFile_AsFile(fin) && PyFile_AsFile(fout)
    2003             && isatty(fileno(PyFile_AsFile(fin)))
    2004             && isatty(fileno(PyFile_AsFile(fout)))) {
    2005                 PyObject *po;
    2006                 char *prompt;
    2007                 char *s;
    2008                 PyObject *result;
    2009                 if (v != NULL) {
    2010                         po = PyObject_Str(v);
    2011                         if (po == NULL)
    2012                                 return NULL;
    2013                         prompt = PyString_AsString(po);
    2014                         if (prompt == NULL)
    2015                                 return NULL;
    2016                 }
    2017                 else {
    2018                         po = NULL;
    2019                         prompt = "";
    2020                 }
    2021                 s = PyOS_Readline(PyFile_AsFile(fin), PyFile_AsFile(fout),
    2022                                   prompt);
    2023                 Py_XDECREF(po);
    2024                 if (s == NULL) {
    2025                         if (!PyErr_Occurred())
    2026                                 PyErr_SetNone(PyExc_KeyboardInterrupt);
    2027                         return NULL;
    2028                 }
    2029                 if (*s == '\0') {
    2030                         PyErr_SetNone(PyExc_EOFError);
    2031                         result = NULL;
    2032                 }
    2033                 else { /* strip trailing '\n' */
    2034                         size_t len = strlen(s);
    2035                         if (len > PY_SSIZE_T_MAX) {
    2036                                 PyErr_SetString(PyExc_OverflowError,
    2037                                                 "[raw_]input: input too long");
    2038                                 result = NULL;
    2039                         }
    2040                         else {
    2041                                 result = PyString_FromStringAndSize(s, len-1);
    2042                         }
    2043                 }
    2044                 PyMem_FREE(s);
    2045                 return result;
    2046         }
    2047         if (v != NULL) {
    2048                 if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
    2049                         return NULL;
    2050         }
    2051         return PyFile_GetLine(fin, -1);
     2022    PyObject *v = NULL;
     2023    PyObject *fin = PySys_GetObject("stdin");
     2024    PyObject *fout = PySys_GetObject("stdout");
     2025
     2026    if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
     2027        return NULL;
     2028
     2029    if (fin == NULL) {
     2030        PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
     2031        return NULL;
     2032    }
     2033    if (fout == NULL) {
     2034        PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
     2035        return NULL;
     2036    }
     2037    if (PyFile_SoftSpace(fout, 0)) {
     2038        if (PyFile_WriteString(" ", fout) != 0)
     2039            return NULL;
     2040    }
     2041    if (PyFile_AsFile(fin) && PyFile_AsFile(fout)
     2042        && isatty(fileno(PyFile_AsFile(fin)))
     2043        && isatty(fileno(PyFile_AsFile(fout)))) {
     2044        PyObject *po;
     2045        char *prompt;
     2046        char *s;
     2047        PyObject *result;
     2048        if (v != NULL) {
     2049            po = PyObject_Str(v);
     2050            if (po == NULL)
     2051                return NULL;
     2052            prompt = PyString_AsString(po);
     2053            if (prompt == NULL)
     2054                return NULL;
     2055        }
     2056        else {
     2057            po = NULL;
     2058            prompt = "";
     2059        }
     2060        s = PyOS_Readline(PyFile_AsFile(fin), PyFile_AsFile(fout),
     2061                          prompt);
     2062        Py_XDECREF(po);
     2063        if (s == NULL) {
     2064            if (!PyErr_Occurred())
     2065                PyErr_SetNone(PyExc_KeyboardInterrupt);
     2066            return NULL;
     2067        }
     2068        if (*s == '\0') {
     2069            PyErr_SetNone(PyExc_EOFError);
     2070            result = NULL;
     2071        }
     2072        else { /* strip trailing '\n' */
     2073            size_t len = strlen(s);
     2074            if (len > PY_SSIZE_T_MAX) {
     2075                PyErr_SetString(PyExc_OverflowError,
     2076                                "[raw_]input: input too long");
     2077                result = NULL;
     2078            }
     2079            else {
     2080                result = PyString_FromStringAndSize(s, len-1);
     2081            }
     2082        }
     2083        PyMem_FREE(s);
     2084        return result;
     2085    }
     2086    if (v != NULL) {
     2087        if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
     2088            return NULL;
     2089    }
     2090    return PyFile_GetLine(fin, -1);
    20522091}
    20532092
    … …  
    20642103builtin_reduce(PyObject *self, PyObject *args)
    20652104{
    2066         static PyObject *functools_reduce = NULL;
    2067 
    2068         if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
    2069                            "use functools.reduce()", 1) < 0)
    2070                 return NULL;
    2071 
    2072         if (functools_reduce == NULL) {
    2073                 PyObject *functools = PyImport_ImportModule("functools");
    2074                 if (functools == NULL)
    2075                         return NULL;
    2076                 functools_reduce = PyObject_GetAttrString(functools, "reduce");
    2077                 Py_DECREF(functools);
    2078                 if (functools_reduce == NULL)
    2079                         return NULL;
    2080         }
    2081         return PyObject_Call(functools_reduce, args, NULL);
     2105    static PyObject *functools_reduce = NULL;
     2106
     2107    if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
     2108                       "use functools.reduce()", 1) < 0)
     2109        return NULL;
     2110
     2111    if (functools_reduce == NULL) {
     2112        PyObject *functools = PyImport_ImportModule("functools");
     2113        if (functools == NULL)
     2114            return NULL;
     2115        functools_reduce = PyObject_GetAttrString(functools, "reduce");
     2116        Py_DECREF(functools);
     2117        if (functools_reduce == NULL)
     2118            return NULL;
     2119    }
     2120    return PyObject_Call(functools_reduce, args, NULL);
    20822121}
    20832122
    … …  
    20962135builtin_reload(PyObject *self, PyObject *v)
    20972136{
    2098         if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
    2099                            1) < 0)
    2100                 return NULL;
    2101 
    2102         return PyImport_ReloadModule(v);
     2137    if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
     2138                       1) < 0)
     2139        return NULL;
     2140
     2141    return PyImport_ReloadModule(v);
    21032142}
    21042143
    … …  
    21122151builtin_repr(PyObject *self, PyObject *v)
    21132152{
    2114         return PyObject_Repr(v);
     2153    return PyObject_Repr(v);
    21152154}
    21162155
    … …  
    21252164builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
    21262165{
    2127         double number, abs_number, abs_result;
    2128         double f;
    2129         int ndigits = 0;
    2130         int i;
    2131         static char *kwlist[] = {"number", "ndigits", 0};
    2132 
    2133         if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|i:round",
    2134                 kwlist, &number, &ndigits))
    2135                 return NULL;
    2136         f = 1.0;
    2137         i = abs(ndigits);
    2138         while  (--i >= 0)
    2139                 f = f*10.0;
    2140         if (ndigits < 0)
    2141                 number /= f;
    2142         else
    2143                 number *= f;
    2144 
    2145         /* round `number` to nearest integer, rounding halves away from zero */
    2146         abs_number = fabs(number);
    2147         abs_result = floor(abs_number);
    2148         if (abs_number - abs_result >= 0.5)
    2149                 abs_result += 1.0;
    2150         number = copysign(abs_result, number);
    2151 
    2152         if (ndigits < 0)
    2153                 number *= f;
    2154         else
    2155                 number /= f;
    2156         return PyFloat_FromDouble(number);
     2166    double x;
     2167    PyObject *o_ndigits = NULL;
     2168    Py_ssize_t ndigits;
     2169    static char *kwlist[] = {"number", "ndigits", 0};
     2170
     2171    if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|O:round",
     2172        kwlist, &x, &o_ndigits))
     2173        return NULL;
     2174
     2175    if (o_ndigits == NULL) {
     2176        /* second argument defaults to 0 */
     2177        ndigits = 0;
     2178    }
     2179    else {
     2180        /* interpret 2nd argument as a Py_ssize_t; clip on overflow */
     2181        ndigits = PyNumber_AsSsize_t(o_ndigits, NULL);
     2182        if (ndigits == -1 && PyErr_Occurred())
     2183            return NULL;
     2184    }
     2185
     2186    /* nans, infinities and zeros round to themselves */
     2187    if (!Py_IS_FINITE(x) || x == 0.0)
     2188        return PyFloat_FromDouble(x);
     2189
     2190    /* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
     2191       always rounds to itself.  For ndigits < NDIGITS_MIN, x always
     2192       rounds to +-0.0.  Here 0.30103 is an upper bound for log10(2). */
     2193#define NDIGITS_MAX ((int)((DBL_MANT_DIG-DBL_MIN_EXP) * 0.30103))
     2194#define NDIGITS_MIN (-(int)((DBL_MAX_EXP + 1) * 0.30103))
     2195    if (ndigits > NDIGITS_MAX)
     2196        /* return x */
     2197        return PyFloat_FromDouble(x);
     2198    else if (ndigits < NDIGITS_MIN)
     2199        /* return 0.0, but with sign of x */
     2200        return PyFloat_FromDouble(0.0*x);
     2201    else
     2202        /* finite x, and ndigits is not unreasonably large */
     2203        /* _Py_double_round is defined in floatobject.c */
     2204        return _Py_double_round(x, (int)ndigits);
     2205#undef NDIGITS_MAX
     2206#undef NDIGITS_MIN
    21572207}
    21582208
    … …  
    21662216builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds)
    21672217{
    2168         PyObject *newlist, *v, *seq, *compare=NULL, *keyfunc=NULL, *newargs;
    2169         PyObject *callable;
    2170         static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
    2171         int reverse;
    2172 
    2173         /* args 1-4 should match listsort in Objects/listobject.c */
    2174         if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOi:sorted",
    2175                 kwlist, &seq, &compare, &keyfunc, &reverse))
    2176                 return NULL;
    2177 
    2178         newlist = PySequence_List(seq);
    2179         if (newlist == NULL)
    2180                 return NULL;
    2181 
    2182         callable = PyObject_GetAttrString(newlist, "sort");
    2183         if (callable == NULL) {
    2184                 Py_DECREF(newlist);
    2185                 return NULL;
    2186         }
    2187 
    2188         newargs = PyTuple_GetSlice(args, 1, 4);
    2189         if (newargs == NULL) {
    2190                 Py_DECREF(newlist);
    2191                 Py_DECREF(callable);
    2192                 return NULL;
    2193         }
    2194 
    2195         v = PyObject_Call(callable, newargs, kwds);
    2196         Py_DECREF(newargs);
    2197         Py_DECREF(callable);
    2198         if (v == NULL) {
    2199                 Py_DECREF(newlist);
    2200                 return NULL;
    2201         }
    2202         Py_DECREF(v);
    2203         return newlist;
     2218    PyObject *newlist, *v, *seq, *compare=NULL, *keyfunc=NULL, *newargs;
     2219    PyObject *callable;
     2220    static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
     2221    int reverse;
     2222
     2223    /* args 1-4 should match listsort in Objects/listobject.c */
     2224    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOi:sorted",
     2225        kwlist, &seq, &compare, &keyfunc, &reverse))
     2226        return NULL;
     2227
     2228    newlist = PySequence_List(seq);
     2229    if (newlist == NULL)
     2230        return NULL;
     2231
     2232    callable = PyObject_GetAttrString(newlist, "sort");
     2233    if (callable == NULL) {
     2234        Py_DECREF(newlist);
     2235        return NULL;
     2236    }
     2237
     2238    newargs = PyTuple_GetSlice(args, 1, 4);
     2239    if (newargs == NULL) {
     2240        Py_DECREF(newlist);
     2241        Py_DECREF(callable);
     2242        return NULL;
     2243    }
     2244
     2245    v = PyObject_Call(callable, newargs, kwds);
     2246    Py_DECREF(newargs);
     2247    Py_DECREF(callable);
     2248    if (v == NULL) {
     2249        Py_DECREF(newlist);
     2250        return NULL;
     2251    }
     2252    Py_DECREF(v);
     2253    return newlist;
    22042254}
    22052255
    … …  
    22102260builtin_vars(PyObject *self, PyObject *args)
    22112261{
    2212         PyObject *v = NULL;
    2213         PyObject *d;
    2214 
    2215         if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
    2216                 return NULL;
    2217         if (v == NULL) {
    2218                 d = PyEval_GetLocals();
    2219                 if (d == NULL) {
    2220                         if (!PyErr_Occurred())
    2221                                 PyErr_SetString(PyExc_SystemError,
    2222                                                 "vars(): no locals!?");
    2223                 }
    2224                 else
    2225                         Py_INCREF(d);
    2226         }
    2227         else {
    2228                 d = PyObject_GetAttrString(v, "__dict__");
    2229                 if (d == NULL) {
    2230                         PyErr_SetString(PyExc_TypeError,
    2231                             "vars() argument must have __dict__ attribute");
    2232                         return NULL;
    2233                 }
    2234         }
    2235         return d;
     2262    PyObject *v = NULL;
     2263    PyObject *d;
     2264
     2265    if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
     2266        return NULL;
     2267    if (v == NULL) {
     2268        d = PyEval_GetLocals();
     2269        if (d == NULL) {
     2270            if (!PyErr_Occurred())
     2271                PyErr_SetString(PyExc_SystemError,
     2272                                "vars(): no locals!?");
     2273        }
     2274        else
     2275            Py_INCREF(d);
     2276    }
     2277    else {
     2278        d = PyObject_GetAttrString(v, "__dict__");
     2279        if (d == NULL) {
     2280            PyErr_SetString(PyExc_TypeError,
     2281                "vars() argument must have __dict__ attribute");
     2282            return NULL;
     2283        }
     2284    }
     2285    return d;
    22362286}
    22372287
    … …  
    22462296builtin_sum(PyObject *self, PyObject *args)
    22472297{
    2248         PyObject *seq;
    2249         PyObject *result = NULL;
    2250         PyObject *temp, *item, *iter;
    2251 
    2252         if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
    2253                 return NULL;
    2254 
    2255         iter = PyObject_GetIter(seq);
    2256         if (iter == NULL)
    2257                 return NULL;
    2258 
    2259         if (result == NULL) {
    2260                 result = PyInt_FromLong(0);
    2261                 if (result == NULL) {
    2262                         Py_DECREF(iter);
    2263                         return NULL;
    2264                 }
    2265         } else {
    2266                 /* reject string values for 'start' parameter */
    2267                 if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
    2268                         PyErr_SetString(PyExc_TypeError,
    2269                                 "sum() can't sum strings [use ''.join(seq) instead]");
    2270                         Py_DECREF(iter);
    2271                         return NULL;
    2272                 }
    2273                 Py_INCREF(result);
    2274         }
     2298    PyObject *seq;
     2299    PyObject *result = NULL;
     2300    PyObject *temp, *item, *iter;
     2301
     2302    if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
     2303        return NULL;
     2304
     2305    iter = PyObject_GetIter(seq);
     2306    if (iter == NULL)
     2307        return NULL;
     2308
     2309    if (result == NULL) {
     2310        result = PyInt_FromLong(0);
     2311        if (result == NULL) {
     2312            Py_DECREF(iter);
     2313            return NULL;
     2314        }
     2315    } else {
     2316        /* reject string values for 'start' parameter */
     2317        if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
     2318            PyErr_SetString(PyExc_TypeError,
     2319                "sum() can't sum strings [use ''.join(seq) instead]");
     2320            Py_DECREF(iter);
     2321            return NULL;
     2322        }
     2323        Py_INCREF(result);
     2324    }
    22752325
    22762326#ifndef SLOW_SUM
    2277         /* Fast addition by keeping temporary sums in C instead of new Python objects.
    2278            Assumes all inputs are the same type.  If the assumption fails, default
    2279            to the more general routine.
    2280         */
    2281         if (PyInt_CheckExact(result)) {
    2282                 long i_result = PyInt_AS_LONG(result);
    2283                 Py_DECREF(result);
    2284                 result = NULL;
    2285                 while(result == NULL) {
    2286                         item = PyIter_Next(iter);
    2287                         if (item == NULL) {
    2288                                 Py_DECREF(iter);
    2289                                 if (PyErr_Occurred())
    2290                                         return NULL;
    2291                                 return PyInt_FromLong(i_result);
    2292                         }
    2293                         if (PyInt_CheckExact(item)) {
    2294                                 long b = PyInt_AS_LONG(item);
    2295                                 long x = i_result + b;
    2296                                 if ((x^i_result) >= 0 || (x^b) >= 0) {
    2297                                         i_result = x;
    2298                                         Py_DECREF(item);
    2299                                         continue;
    2300                                 }
    2301                         }
    2302                         /* Either overflowed or is not an int. Restore real objects and process normally */
    2303                         result = PyInt_FromLong(i_result);
    2304                         temp = PyNumber_Add(result, item);
    2305                         Py_DECREF(result);
    2306                         Py_DECREF(item);
    2307                         result = temp;
    2308                         if (result == NULL) {
    2309                                 Py_DECREF(iter);
    2310                                 return NULL;
    2311                         }
    2312                 }
    2313         }
    2314 
    2315         if (PyFloat_CheckExact(result)) {
    2316                 double f_result = PyFloat_AS_DOUBLE(result);
    2317                 Py_DECREF(result);
    2318                 result = NULL;
    2319                 while(result == NULL) {
    2320                         item = PyIter_Next(iter);
    2321                         if (item == NULL) {
    2322                                 Py_DECREF(iter);
    2323                                 if (PyErr_Occurred())
    2324                                         return NULL;
    2325                                 return PyFloat_FromDouble(f_result);
    2326                         }
    2327                         if (PyFloat_CheckExact(item)) {
    2328                                 PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
    2329                                 f_result += PyFloat_AS_DOUBLE(item);
    2330                                 PyFPE_END_PROTECT(f_result)
    2331                                 Py_DECREF(item);
    2332                                 continue;
    2333                         }
    2334                         if (PyInt_CheckExact(item)) {
    2335                                 PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
    2336                                 f_result += (double)PyInt_AS_LONG(item);
    2337                                 PyFPE_END_PROTECT(f_result)
    2338                                 Py_DECREF(item);
    2339                                 continue;
    2340                         }
    2341                         result = PyFloat_FromDouble(f_result);
    2342                         temp = PyNumber_Add(result, item);
    2343                         Py_DECREF(result);
    2344                         Py_DECREF(item);
    2345                         result = temp;
    2346                         if (result == NULL) {
    2347                                 Py_DECREF(iter);
    2348                                 return NULL;
    2349                         }
    2350                 }
    2351         }
     2327    /* Fast addition by keeping temporary sums in C instead of new Python objects.
     2328       Assumes all inputs are the same type.  If the assumption fails, default
     2329       to the more general routine.
     2330    */
     2331    if (PyInt_CheckExact(result)) {
     2332        long i_result = PyInt_AS_LONG(result);
     2333        Py_DECREF(result);
     2334        result = NULL;
     2335        while(result == NULL) {
     2336            item = PyIter_Next(iter);
     2337            if (item == NULL) {
     2338                Py_DECREF(iter);
     2339                if (PyErr_Occurred())
     2340                    return NULL;
     2341                return PyInt_FromLong(i_result);
     2342            }
     2343            if (PyInt_CheckExact(item)) {
     2344                long b = PyInt_AS_LONG(item);
     2345                long x = i_result + b;
     2346                if ((x^i_result) >= 0 || (x^b) >= 0) {
     2347                    i_result = x;
     2348                    Py_DECREF(item);
     2349                    continue;
     2350                }
     2351            }
     2352            /* Either overflowed or is not an int. Restore real objects and process normally */
     2353            result = PyInt_FromLong(i_result);
     2354            temp = PyNumber_Add(result, item);
     2355            Py_DECREF(result);
     2356            Py_DECREF(item);
     2357            result = temp;
     2358            if (result == NULL) {
     2359                Py_DECREF(iter);
     2360                return NULL;
     2361            }
     2362        }
     2363    }
     2364
     2365    if (PyFloat_CheckExact(result)) {
     2366        double f_result = PyFloat_AS_DOUBLE(result);
     2367        Py_DECREF(result);
     2368        result = NULL;
     2369        while(result == NULL) {
     2370            item = PyIter_Next(iter);
     2371            if (item == NULL) {
     2372                Py_DECREF(iter);
     2373                if (PyErr_Occurred())
     2374                    return NULL;
     2375                return PyFloat_FromDouble(f_result);
     2376            }
     2377            if (PyFloat_CheckExact(item)) {
     2378                PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
     2379                f_result += PyFloat_AS_DOUBLE(item);
     2380                PyFPE_END_PROTECT(f_result)
     2381                Py_DECREF(item);
     2382                continue;
     2383            }
     2384            if (PyInt_CheckExact(item)) {
     2385                PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
     2386                f_result += (double)PyInt_AS_LONG(item);
     2387                PyFPE_END_PROTECT(f_result)
     2388                Py_DECREF(item);
     2389                continue;
     2390            }
     2391            result = PyFloat_FromDouble(f_result);
     2392            temp = PyNumber_Add(result, item);
     2393            Py_DECREF(result);
     2394            Py_DECREF(item);
     2395            result = temp;
     2396            if (result == NULL) {
     2397                Py_DECREF(iter);
     2398                return NULL;
     2399            }
     2400        }
     2401    }
    23522402#endif
    23532403
    2354         for(;;) {
    2355                 item = PyIter_Next(iter);
    2356                 if (item == NULL) {
    2357                         /* error, or end-of-sequence */
    2358                         if (PyErr_Occurred()) {
    2359                                 Py_DECREF(result);
    2360                                 result = NULL;
    2361                         }
    2362                         break;
    2363                 }
    2364                 temp = PyNumber_Add(result, item);
    2365                 Py_DECREF(result);
    2366                 Py_DECREF(item);
    2367                 result = temp;
    2368                 if (result == NULL)
    2369                         break;
    2370         }
    2371         Py_DECREF(iter);
    2372         return result;
     2404    for(;;) {
     2405        item = PyIter_Next(iter);
     2406        if (item == NULL) {
     2407            /* error, or end-of-sequence */
     2408            if (PyErr_Occurred()) {
     2409                Py_DECREF(result);
     2410                result = NULL;
     2411            }
     2412            break;
     2413        }
     2414        /* It's tempting to use PyNumber_InPlaceAdd instead of
     2415           PyNumber_Add here, to avoid quadratic running time
     2416           when doing 'sum(list_of_lists, [])'.  However, this
     2417           would produce a change in behaviour: a snippet like
     2418
     2419             empty = []
     2420             sum([[x] for x in range(10)], empty)
     2421
     2422           would change the value of empty. */
     2423        temp = PyNumber_Add(result, item);
     2424        Py_DECREF(result);
     2425        Py_DECREF(item);
     2426        result = temp;
     2427        if (result == NULL)
     2428            break;
     2429    }
     2430    Py_DECREF(iter);
     2431    return result;
    23732432}
    23742433
    … …  
    23762435"sum(sequence[, start]) -> value\n\
    23772436\n\
    2378 Returns the sum of a sequence of numbers (NOT strings) plus the value\n\
     2437Return the sum of a sequence of numbers (NOT strings) plus the value\n\
    23792438of parameter 'start' (which defaults to 0).  When the sequence is\n\
    2380 empty, returns start.");
     2439empty, return start.");
    23812440
    23822441
    … …  
    23842443builtin_isinstance(PyObject *self, PyObject *args)
    23852444{
    2386         PyObject *inst;
    2387         PyObject *cls;
    2388         int retval;
    2389 
    2390         if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
    2391                 return NULL;
    2392 
    2393         retval = PyObject_IsInstance(inst, cls);
    2394         if (retval < 0)
    2395                 return NULL;
    2396         return PyBool_FromLong(retval);
     2445    PyObject *inst;
     2446    PyObject *cls;
     2447    int retval;
     2448
     2449    if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
     2450        return NULL;
     2451
     2452    retval = PyObject_IsInstance(inst, cls);
     2453    if (retval < 0)
     2454        return NULL;
     2455    return PyBool_FromLong(retval);
    23972456}
    23982457
    … …  
    24092468builtin_issubclass(PyObject *self, PyObject *args)
    24102469{
    2411         PyObject *derived;
    2412         PyObject *cls;
    2413         int retval;
    2414 
    2415         if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
    2416                 return NULL;
    2417 
    2418         retval = PyObject_IsSubclass(derived, cls);
    2419         if (retval < 0)
    2420                 return NULL;
    2421         return PyBool_FromLong(retval);
     2470    PyObject *derived;
     2471    PyObject *cls;
     2472    int retval;
     2473
     2474    if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
     2475        return NULL;
     2476
     2477    retval = PyObject_IsSubclass(derived, cls);
     2478    if (retval < 0)
     2479        return NULL;
     2480    return PyBool_FromLong(retval);
    24222481}
    24232482
    … …  
    24332492builtin_zip(PyObject *self, PyObject *args)
    24342493{
    2435         PyObject *ret;
    2436         const Py_ssize_t itemsize = PySequence_Length(args);
    2437         Py_ssize_t i;
    2438         PyObject *itlist;  /* tuple of iterators */
    2439         Py_ssize_t len;    /* guess at result length */
    2440 
    2441         if (itemsize == 0)
    2442                 return PyList_New(0);
    2443 
    2444         /* args must be a tuple */
    2445         assert(PyTuple_Check(args));
    2446 
    2447         /* Guess at result length:  the shortest of the input lengths.
    2448            If some argument refuses to say, we refuse to guess too, lest
    2449            an argument like xrange(sys.maxint) lead us astray.*/
    2450         len = -1;       /* unknown */
    2451         for (i = 0; i < itemsize; ++i) {
    2452                 PyObject *item = PyTuple_GET_ITEM(args, i);
    2453                 Py_ssize_t thislen = _PyObject_LengthHint(item, -1);
    2454                 if (thislen < 0) {
    2455                         len = -1;
    2456                         break;
    2457                 }
    2458                 else if (len < 0 || thislen < len)
    2459                         len = thislen;
    2460         }
    2461 
    2462         /* allocate result list */
    2463         if (len < 0)
    2464                 len = 10;       /* arbitrary */
    2465         if ((ret = PyList_New(len)) == NULL)
    2466                 return NULL;
    2467 
    2468         /* obtain iterators */
    2469         itlist = PyTuple_New(itemsize);
    2470         if (itlist == NULL)
    2471                 goto Fail_ret;
    2472         for (i = 0; i < itemsize; ++i) {
    2473                 PyObject *item = PyTuple_GET_ITEM(args, i);
    2474                 PyObject *it = PyObject_GetIter(item);
    2475                 if (it == NULL) {
    2476                         if (PyErr_ExceptionMatches(PyExc_TypeError))
    2477                                 PyErr_Format(PyExc_TypeError,
    2478                                     "zip argument #%zd must support iteration",
    2479                                     i+1);
    2480                         goto Fail_ret_itlist;
    2481                 }
    2482                 PyTuple_SET_ITEM(itlist, i, it);
    2483         }
    2484 
    2485         /* build result into ret list */
    2486         for (i = 0; ; ++i) {
    2487                 int j;
    2488                 PyObject *next = PyTuple_New(itemsize);
    2489                 if (!next)
    2490                         goto Fail_ret_itlist;
    2491 
    2492                 for (j = 0; j < itemsize; j++) {
    2493                         PyObject *it = PyTuple_GET_ITEM(itlist, j);
    2494                         PyObject *item = PyIter_Next(it);
    2495                         if (!item) {
    2496                                 if (PyErr_Occurred()) {
    2497                                         Py_DECREF(ret);
    2498                                         ret = NULL;
    2499                                 }
    2500                                 Py_DECREF(next);
    2501                                 Py_DECREF(itlist);
    2502                                 goto Done;
    2503                         }
    2504                         PyTuple_SET_ITEM(next, j, item);
    2505                 }
    2506 
    2507                 if (i < len)
    2508                         PyList_SET_ITEM(ret, i, next);
    2509                 else {
    2510                         int status = PyList_Append(ret, next);
    2511                         Py_DECREF(next);
    2512                         ++len;
    2513                         if (status < 0)
    2514                                 goto Fail_ret_itlist;
    2515                 }
    2516         }
     2494    PyObject *ret;
     2495    const Py_ssize_t itemsize = PySequence_Length(args);
     2496    Py_ssize_t i;
     2497    PyObject *itlist;  /* tuple of iterators */
     2498    Py_ssize_t len;        /* guess at result length */
     2499
     2500    if (itemsize == 0)
     2501        return PyList_New(0);
     2502
     2503    /* args must be a tuple */
     2504    assert(PyTuple_Check(args));
     2505
     2506    /* Guess at result length:  the shortest of the input lengths.
     2507       If some argument refuses to say, we refuse to guess too, lest
     2508       an argument like xrange(sys.maxint) lead us astray.*/
     2509    len = -1;           /* unknown */
     2510    for (i = 0; i < itemsize; ++i) {
     2511        PyObject *item = PyTuple_GET_ITEM(args, i);
     2512        Py_ssize_t thislen = _PyObject_LengthHint(item, -2);
     2513        if (thislen < 0) {
     2514            if (thislen == -1)
     2515                return NULL;
     2516            len = -1;
     2517            break;
     2518        }
     2519        else if (len < 0 || thislen < len)
     2520            len = thislen;
     2521    }
     2522
     2523    /* allocate result list */
     2524    if (len < 0)
     2525        len = 10;               /* arbitrary */
     2526    if ((ret = PyList_New(len)) == NULL)
     2527        return NULL;
     2528
     2529    /* obtain iterators */
     2530    itlist = PyTuple_New(itemsize);
     2531    if (itlist == NULL)
     2532        goto Fail_ret;
     2533    for (i = 0; i < itemsize; ++i) {
     2534        PyObject *item = PyTuple_GET_ITEM(args, i);
     2535        PyObject *it = PyObject_GetIter(item);
     2536        if (it == NULL) {
     2537            if (PyErr_ExceptionMatches(PyExc_TypeError))
     2538                PyErr_Format(PyExc_TypeError,
     2539                    "zip argument #%zd must support iteration",
     2540                    i+1);
     2541            goto Fail_ret_itlist;
     2542        }
     2543        PyTuple_SET_ITEM(itlist, i, it);
     2544    }
     2545
     2546    /* build result into ret list */
     2547    for (i = 0; ; ++i) {
     2548        int j;
     2549        PyObject *next = PyTuple_New(itemsize);
     2550        if (!next)
     2551            goto Fail_ret_itlist;
     2552
     2553        for (j = 0; j < itemsize; j++) {
     2554            PyObject *it = PyTuple_GET_ITEM(itlist, j);
     2555            PyObject *item = PyIter_Next(it);
     2556            if (!item) {
     2557                if (PyErr_Occurred()) {
     2558                    Py_DECREF(ret);
     2559                    ret = NULL;
     2560                }
     2561                Py_DECREF(next);
     2562                Py_DECREF(itlist);
     2563                goto Done;
     2564            }
     2565            PyTuple_SET_ITEM(next, j, item);
     2566        }
     2567
     2568        if (i < len)
     2569            PyList_SET_ITEM(ret, i, next);
     2570        else {
     2571            int status = PyList_Append(ret, next);
     2572            Py_DECREF(next);
     2573            ++len;
     2574            if (status < 0)
     2575                goto Fail_ret_itlist;
     2576        }
     2577    }
    25172578
    25182579Done:
    2519         if (ret != NULL && i < len) {
    2520                 /* The list is too big. */
    2521                 if (PyList_SetSlice(ret, i, len, NULL) < 0)
    2522                         return NULL;
    2523         }
    2524         return ret;
     2580    if (ret != NULL && i < len) {
     2581        /* The list is too big. */
     2582        if (PyList_SetSlice(ret, i, len, NULL) < 0)
     2583            return NULL;
     2584    }
     2585    return ret;
    25252586
    25262587Fail_ret_itlist:
    2527         Py_DECREF(itlist);
     2588    Py_DECREF(itlist);
    25282589Fail_ret:
    2529         Py_DECREF(ret);
    2530         return NULL;
     2590    Py_DECREF(ret);
     2591    return NULL;
    25312592}
    25322593
    … …  
    25412602
    25422603static PyMethodDef builtin_methods[] = {
    2543         {"__import__",  (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
    2544         {"abs",         builtin_abs,        METH_O, abs_doc},
    2545         {"all",         builtin_all,        METH_O, all_doc},
    2546         {"any",         builtin_any,        METH_O, any_doc},
    2547         {"apply",       builtin_apply,      METH_VARARGS, apply_doc},
    2548         {"bin",         builtin_bin,        METH_O, bin_doc},
    2549         {"callable",    builtin_callable,   METH_O, callable_doc},
    2550         {"chr",         builtin_chr,        METH_VARARGS, chr_doc},
    2551         {"cmp",         builtin_cmp,        METH_VARARGS, cmp_doc},
    2552         {"coerce",      builtin_coerce,     METH_VARARGS, coerce_doc},
    2553         {"compile",     (PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
    2554         {"delattr",     builtin_delattr,    METH_VARARGS, delattr_doc},
    2555         {"dir",         builtin_dir,        METH_VARARGS, dir_doc},
    2556         {"divmod",      builtin_divmod,     METH_VARARGS, divmod_doc},
    2557         {"eval",        builtin_eval,       METH_VARARGS, eval_doc},
    2558         {"execfile",    builtin_execfile,   METH_VARARGS, execfile_doc},
    2559         {"filter",      builtin_filter,     METH_VARARGS, filter_doc},
    2560         {"format",      builtin_format,     METH_VARARGS, format_doc},
    2561         {"getattr",     builtin_getattr,    METH_VARARGS, getattr_doc},
    2562         {"globals",     (PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
    2563         {"hasattr",     builtin_hasattr,    METH_VARARGS, hasattr_doc},
    2564         {"hash",        builtin_hash,       METH_O, hash_doc},
    2565         {"hex",         builtin_hex,        METH_O, hex_doc},
    2566         {"id",          builtin_id,         METH_O, id_doc},
    2567         {"input",       builtin_input,      METH_VARARGS, input_doc},
    2568         {"intern",      builtin_intern,     METH_VARARGS, intern_doc},
    2569         {"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
    2570         {"issubclass",  builtin_issubclass, METH_VARARGS, issubclass_doc},
    2571         {"iter",        builtin_iter,       METH_VARARGS, iter_doc},
    2572         {"len",         builtin_len,        METH_O, len_doc},
    2573         {"locals",      (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
    2574         {"map",         builtin_map,        METH_VARARGS, map_doc},
    2575         {"max",         (PyCFunction)builtin_max,        METH_VARARGS | METH_KEYWORDS, max_doc},
    2576         {"min",         (PyCFunction)builtin_min,        METH_VARARGS | METH_KEYWORDS, min_doc},
    2577         {"next",        builtin_next,       METH_VARARGS, next_doc},
    2578         {"oct",         builtin_oct,        METH_O, oct_doc},
    2579         {"open",        (PyCFunction)builtin_open,       METH_VARARGS | METH_KEYWORDS, open_doc},
    2580         {"ord",         builtin_ord,        METH_O, ord_doc},
    2581         {"pow",         builtin_pow,        METH_VARARGS, pow_doc},
    2582         {"print",       (PyCFunction)builtin_print,      METH_VARARGS | METH_KEYWORDS, print_doc},
    2583         {"range",       builtin_range,      METH_VARARGS, range_doc},
    2584         {"raw_input",   builtin_raw_input,  METH_VARARGS, raw_input_doc},
    2585         {"reduce",      builtin_reduce,     METH_VARARGS, reduce_doc},
    2586         {"reload",      builtin_reload,     METH_O, reload_doc},
    2587         {"repr",        builtin_repr,       METH_O, repr_doc},
    2588         {"round",       (PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
    2589         {"setattr",     builtin_setattr,    METH_VARARGS, setattr_doc},
    2590         {"sorted",      (PyCFunction)builtin_sorted,     METH_VARARGS | METH_KEYWORDS, sorted_doc},
    2591         {"sum",         builtin_sum,        METH_VARARGS, sum_doc},
     2604    {"__import__",      (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
     2605    {"abs",             builtin_abs,        METH_O, abs_doc},
     2606    {"all",             builtin_all,        METH_O, all_doc},
     2607    {"any",             builtin_any,        METH_O, any_doc},
     2608    {"apply",           builtin_apply,      METH_VARARGS, apply_doc},
     2609    {"bin",             builtin_bin,        METH_O, bin_doc},
     2610    {"callable",        builtin_callable,   METH_O, callable_doc},
     2611    {"chr",             builtin_chr,        METH_VARARGS, chr_doc},
     2612    {"cmp",             builtin_cmp,        METH_VARARGS, cmp_doc},
     2613    {"coerce",          builtin_coerce,     METH_VARARGS, coerce_doc},
     2614    {"compile",         (PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
     2615    {"delattr",         builtin_delattr,    METH_VARARGS, delattr_doc},
     2616    {"dir",             builtin_dir,        METH_VARARGS, dir_doc},
     2617    {"divmod",          builtin_divmod,     METH_VARARGS, divmod_doc},
     2618    {"eval",            builtin_eval,       METH_VARARGS, eval_doc},
     2619    {"execfile",        builtin_execfile,   METH_VARARGS, execfile_doc},
     2620    {"filter",          builtin_filter,     METH_VARARGS, filter_doc},
     2621    {"format",          builtin_format,     METH_VARARGS, format_doc},
     2622    {"getattr",         builtin_getattr,    METH_VARARGS, getattr_doc},
     2623    {"globals",         (PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
     2624    {"hasattr",         builtin_hasattr,    METH_VARARGS, hasattr_doc},
     2625    {"hash",            builtin_hash,       METH_O, hash_doc},
     2626    {"hex",             builtin_hex,        METH_O, hex_doc},
     2627    {"id",              builtin_id,         METH_O, id_doc},
     2628    {"input",           builtin_input,      METH_VARARGS, input_doc},
     2629    {"intern",          builtin_intern,     METH_VARARGS, intern_doc},
     2630    {"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
     2631    {"issubclass",  builtin_issubclass, METH_VARARGS, issubclass_doc},
     2632    {"iter",            builtin_iter,       METH_VARARGS, iter_doc},
     2633    {"len",             builtin_len,        METH_O, len_doc},
     2634    {"locals",          (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
     2635    {"map",             builtin_map,        METH_VARARGS, map_doc},
     2636    {"max",             (PyCFunction)builtin_max,        METH_VARARGS | METH_KEYWORDS, max_doc},
     2637    {"min",             (PyCFunction)builtin_min,        METH_VARARGS | METH_KEYWORDS, min_doc},
     2638    {"next",            builtin_next,       METH_VARARGS, next_doc},
     2639    {"oct",             builtin_oct,        METH_O, oct_doc},
     2640    {"open",            (PyCFunction)builtin_open,       METH_VARARGS | METH_KEYWORDS, open_doc},
     2641    {"ord",             builtin_ord,        METH_O, ord_doc},
     2642    {"pow",             builtin_pow,        METH_VARARGS, pow_doc},
     2643    {"print",           (PyCFunction)builtin_print,      METH_VARARGS | METH_KEYWORDS, print_doc},
     2644    {"range",           builtin_range,      METH_VARARGS, range_doc},
     2645    {"raw_input",       builtin_raw_input,  METH_VARARGS, raw_input_doc},
     2646    {"reduce",          builtin_reduce,     METH_VARARGS, reduce_doc},
     2647    {"reload",          builtin_reload,     METH_O, reload_doc},
     2648    {"repr",            builtin_repr,       METH_O, repr_doc},
     2649    {"round",           (PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
     2650    {"setattr",         builtin_setattr,    METH_VARARGS, setattr_doc},
     2651    {"sorted",          (PyCFunction)builtin_sorted,     METH_VARARGS | METH_KEYWORDS, sorted_doc},
     2652    {"sum",             builtin_sum,        METH_VARARGS, sum_doc},
    25922653#ifdef Py_USING_UNICODE
    2593         {"unichr",      builtin_unichr,     METH_VARARGS, unichr_doc},
     2654    {"unichr",          builtin_unichr,     METH_VARARGS, unichr_doc},
    25942655#endif
    2595         {"vars",        builtin_vars,       METH_VARARGS, vars_doc},
    2596         {"zip",         builtin_zip,        METH_VARARGS, zip_doc},
    2597         {NULL,          NULL},
     2656    {"vars",            builtin_vars,       METH_VARARGS, vars_doc},
     2657    {"zip",         builtin_zip,        METH_VARARGS, zip_doc},
     2658    {NULL,              NULL},
    25982659};
    25992660
    … …  
    26062667_PyBuiltin_Init(void)
    26072668{
    2608         PyObject *mod, *dict, *debug;
    2609         mod = Py_InitModule4("__builtin__", builtin_methods,
    2610                              builtin_doc, (PyObject *)NULL,
    2611                              PYTHON_API_VERSION);
    2612         if (mod == NULL)
    2613                 return NULL;
    2614         dict = PyModule_GetDict(mod);
     2669    PyObject *mod, *dict, *debug;
     2670    mod = Py_InitModule4("__builtin__", builtin_methods,
     2671                         builtin_doc, (PyObject *)NULL,
     2672                         PYTHON_API_VERSION);
     2673    if (mod == NULL)
     2674        return NULL;
     2675    dict = PyModule_GetDict(mod);
    26152676
    26162677#ifdef Py_TRACE_REFS
    2617         /* __builtin__ exposes a number of statically allocated objects
    2618         * that, before this code was added in 2.3, never showed up in
    2619         * the list of "all objects" maintained by Py_TRACE_REFS.  As a
    2620         * result, programs leaking references to None and False (etc)
    2621         * couldn't be diagnosed by examining sys.getobjects(0).
    2622         */
     2678    /* __builtin__ exposes a number of statically allocated objects
     2679    * that, before this code was added in 2.3, never showed up in
     2680    * the list of "all objects" maintained by Py_TRACE_REFS.  As a
     2681    * result, programs leaking references to None and False (etc)
     2682    * couldn't be diagnosed by examining sys.getobjects(0).
     2683    */
    26232684#define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
    26242685#else
    … …  
    26272688
    26282689#define SETBUILTIN(NAME, OBJECT) \
    2629         if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)   \
    2630                 return NULL;                                            \
    2631         ADD_TO_ALL(OBJECT)
    2632 
    2633         SETBUILTIN("None",              Py_None);
    2634         SETBUILTIN("Ellipsis",          Py_Ellipsis);
    2635         SETBUILTIN("NotImplemented",    Py_NotImplemented);
    2636         SETBUILTIN("False",             Py_False);
    2637         SETBUILTIN("True",              Py_True);
    2638         SETBUILTIN("basestring",        &PyBaseString_Type);
    2639         SETBUILTIN("bool",              &PyBool_Type);
    2640         /*      SETBUILTIN("memoryview",        &PyMemoryView_Type); */
    2641         SETBUILTIN("bytearray",         &PyByteArray_Type);
    2642         SETBUILTIN("bytes",             &PyString_Type);
    2643         SETBUILTIN("buffer",            &PyBuffer_Type);
    2644         SETBUILTIN("classmethod",       &PyClassMethod_Type);
     2690    if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)       \
     2691        return NULL;                                                    \
     2692    ADD_TO_ALL(OBJECT)
     2693
     2694    SETBUILTIN("None",                  Py_None);
     2695    SETBUILTIN("Ellipsis",              Py_Ellipsis);
     2696    SETBUILTIN("NotImplemented",        Py_NotImplemented);
     2697    SETBUILTIN("False",                 Py_False);
     2698    SETBUILTIN("True",                  Py_True);
     2699    SETBUILTIN("basestring",            &PyBaseString_Type);
     2700    SETBUILTIN("bool",                  &PyBool_Type);
     2701    SETBUILTIN("memoryview",        &PyMemoryView_Type);
     2702    SETBUILTIN("bytearray",             &PyByteArray_Type);
     2703    SETBUILTIN("bytes",                 &PyString_Type);
     2704    SETBUILTIN("buffer",                &PyBuffer_Type);
     2705    SETBUILTIN("classmethod",           &PyClassMethod_Type);
    26452706#ifndef WITHOUT_COMPLEX
    2646         SETBUILTIN("complex",           &PyComplex_Type);
     2707    SETBUILTIN("complex",               &PyComplex_Type);
    26472708#endif
    2648         SETBUILTIN("dict",              &PyDict_Type);
    2649         SETBUILTIN("enumerate",         &PyEnum_Type);
    2650         SETBUILTIN("file",              &PyFile_Type);
    2651         SETBUILTIN("float",             &PyFloat_Type);
    2652         SETBUILTIN("frozenset",         &PyFrozenSet_Type);
    2653         SETBUILTIN("property",          &PyProperty_Type);
    2654         SETBUILTIN("int",               &PyInt_Type);
    2655         SETBUILTIN("list",              &PyList_Type);
    2656         SETBUILTIN("long",              &PyLong_Type);
    2657         SETBUILTIN("object",            &PyBaseObject_Type);
    2658         SETBUILTIN("reversed",          &PyReversed_Type);
    2659         SETBUILTIN("set",               &PySet_Type);
    2660         SETBUILTIN("slice",             &PySlice_Type);
    2661         SETBUILTIN("staticmethod",      &PyStaticMethod_Type);
    2662         SETBUILTIN("str",               &PyString_Type);
    2663         SETBUILTIN("super",             &PySuper_Type);
    2664         SETBUILTIN("tuple",             &PyTuple_Type);
    2665         SETBUILTIN("type",              &PyType_Type);
    2666         SETBUILTIN("xrange",            &PyRange_Type);
     2709    SETBUILTIN("dict",                  &PyDict_Type);
     2710    SETBUILTIN("enumerate",             &PyEnum_Type);
     2711    SETBUILTIN("file",                  &PyFile_Type);
     2712    SETBUILTIN("float",                 &PyFloat_Type);
     2713    SETBUILTIN("frozenset",             &PyFrozenSet_Type);
     2714    SETBUILTIN("property",              &PyProperty_Type);
     2715    SETBUILTIN("int",                   &PyInt_Type);
     2716    SETBUILTIN("list",                  &PyList_Type);
     2717    SETBUILTIN("long",                  &PyLong_Type);
     2718    SETBUILTIN("object",                &PyBaseObject_Type);
     2719    SETBUILTIN("reversed",              &PyReversed_Type);
     2720    SETBUILTIN("set",                   &PySet_Type);
     2721    SETBUILTIN("slice",                 &PySlice_Type);
     2722    SETBUILTIN("staticmethod",          &PyStaticMethod_Type);
     2723    SETBUILTIN("str",                   &PyString_Type);
     2724    SETBUILTIN("super",                 &PySuper_Type);
     2725    SETBUILTIN("tuple",                 &PyTuple_Type);
     2726    SETBUILTIN("type",                  &PyType_Type);
     2727    SETBUILTIN("xrange",                &PyRange_Type);
    26672728#ifdef Py_USING_UNICODE
    2668         SETBUILTIN("unicode",           &PyUnicode_Type);
     2729    SETBUILTIN("unicode",               &PyUnicode_Type);
    26692730#endif
    2670         debug = PyBool_FromLong(Py_OptimizeFlag == 0);
    2671         if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
    2672                 Py_XDECREF(debug);
    2673                 return NULL;
    2674         }
    2675         Py_XDECREF(debug);
    2676 
    2677         return mod;
     2731    debug = PyBool_FromLong(Py_OptimizeFlag == 0);
     2732    if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
     2733        Py_XDECREF(debug);
     2734        return NULL;
     2735    }
     2736    Py_XDECREF(debug);
     2737
     2738    return mod;
    26782739#undef ADD_TO_ALL
    26792740#undef SETBUILTIN
    … …  
    26852746filtertuple(PyObject *func, PyObject *tuple)
    26862747{
    2687         PyObject *result;
    2688         Py_ssize_t i, j;
    2689         Py_ssize_t len = PyTuple_Size(tuple);
    2690 
    2691         if (len == 0) {
    2692                 if (PyTuple_CheckExact(tuple))
    2693                         Py_INCREF(tuple);
    2694                 else
    2695                         tuple = PyTuple_New(0);
    2696                 return tuple;
    2697         }
    2698 
    2699         if ((result = PyTuple_New(len)) == NULL)
    2700                 return NULL;
    2701 
    2702         for (i = j = 0; i < len; ++i) {
    2703                 PyObject *item, *good;
    2704                 int ok;
    2705 
    2706                 if (tuple->ob_type->tp_as_sequence &&
    2707                     tuple->ob_type->tp_as_sequence->sq_item) {
    2708                         item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
    2709                         if (item == NULL)
    2710                                 goto Fail_1;
    2711                 } else {
    2712                         PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
    2713                         goto Fail_1;
    2714                 }
    2715                 if (func == Py_None) {
    2716                         Py_INCREF(item);
    2717                         good = item;
    2718                 }
    2719                 else {
    2720                         PyObject *arg = PyTuple_Pack(1, item);
    2721                         if (arg == NULL) {
    2722                                 Py_DECREF(item);
    2723                                 goto Fail_1;
    2724                         }
    2725                         good = PyEval_CallObject(func, arg);
    2726                         Py_DECREF(arg);
    2727                         if (good == NULL) {
    2728                                 Py_DECREF(item);
    2729                                 goto Fail_1;
    2730                         }
    2731                 }
    2732                 ok = PyObject_IsTrue(good);
    2733                 Py_DECREF(good);
    2734                 if (ok) {
    2735                         if (PyTuple_SetItem(result, j++, item) < 0)
    2736                                 goto Fail_1;
    2737                 }
    2738                 else
    2739                         Py_DECREF(item);
    2740         }
    2741 
    2742         if (_PyTuple_Resize(&result, j) < 0)
    2743                 return NULL;
    2744 
    2745         return result;
     2748    PyObject *result;
     2749    Py_ssize_t i, j;
     2750    Py_ssize_t len = PyTuple_Size(tuple);
     2751
     2752    if (len == 0) {
     2753        if (PyTuple_CheckExact(tuple))
     2754            Py_INCREF(tuple);
     2755        else
     2756            tuple = PyTuple_New(0);
     2757        return tuple;
     2758    }
     2759
     2760    if ((result = PyTuple_New(len)) == NULL)
     2761        return NULL;
     2762
     2763    for (i = j = 0; i < len; ++i) {
     2764        PyObject *item, *good;
     2765        int ok;
     2766
     2767        if (tuple->ob_type->tp_as_sequence &&
     2768            tuple->ob_type->tp_as_sequence->sq_item) {
     2769            item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
     2770            if (item == NULL)
     2771                goto Fail_1;
     2772        } else {
     2773            PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
     2774            goto Fail_1;
     2775        }
     2776        if (func == Py_None) {
     2777            Py_INCREF(item);
     2778            good = item;
     2779        }
     2780        else {
     2781            PyObject *arg = PyTuple_Pack(1, item);
     2782            if (arg == NULL) {
     2783                Py_DECREF(item);
     2784                goto Fail_1;
     2785            }
     2786            good = PyEval_CallObject(func, arg);
     2787            Py_DECREF(arg);
     2788            if (good == NULL) {
     2789                Py_DECREF(item);
     2790                goto Fail_1;
     2791            }
     2792        }
     2793        ok = PyObject_IsTrue(good);
     2794        Py_DECREF(good);
     2795        if (ok > 0) {
     2796            if (PyTuple_SetItem(result, j++, item) < 0)
     2797                goto Fail_1;
     2798        }
     2799        else {
     2800            Py_DECREF(item);
     2801            if (ok < 0)
     2802                goto Fail_1;
     2803        }
     2804    }
     2805
     2806    if (_PyTuple_Resize(&result, j) < 0)
     2807        return NULL;
     2808
     2809    return result;
    27462810
    27472811Fail_1:
    2748         Py_DECREF(result);
    2749         return NULL;
     2812    Py_DECREF(result);
     2813    return NULL;
    27502814}
    27512815
    … …  
    27562820filterstring(PyObject *func, PyObject *strobj)
    27572821{
    2758         PyObject *result;
    2759         Py_ssize_t i, j;
    2760         Py_ssize_t len = PyString_Size(strobj);
    2761         Py_ssize_t outlen = len;
    2762 
    2763         if (func == Py_None) {
    2764                 /* If it's a real string we can return the original,
    2765                  * as no character is ever false and __getitem__
    2766                  * does return this character. If it's a subclass
    2767                  * we must go through the __getitem__ loop */
    2768                 if (PyString_CheckExact(strobj)) {
    2769                         Py_INCREF(strobj);
    2770                         return strobj;
    2771                 }
    2772         }
    2773         if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
    2774                 return NULL;
    2775 
    2776         for (i = j = 0; i < len; ++i) {
    2777                 PyObject *item;
    2778                 int ok;
    2779 
    2780                 item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
    2781                 if (item == NULL)
    2782                         goto Fail_1;
    2783                 if (func==Py_None) {
    2784                         ok = 1;
    2785                 } else {
    2786                         PyObject *arg, *good;
    2787                         arg = PyTuple_Pack(1, item);
    2788                         if (arg == NULL) {
    2789                                 Py_DECREF(item);
    2790                                 goto Fail_1;
    2791                         }
    2792                         good = PyEval_CallObject(func, arg);
    2793                         Py_DECREF(arg);
    2794                         if (good == NULL) {
    2795                                 Py_DECREF(item);
    2796                                 goto Fail_1;
    2797                         }
    2798                         ok = PyObject_IsTrue(good);
    2799                         Py_DECREF(good);
    2800                 }
    2801                 if (ok) {
    2802                         Py_ssize_t reslen;
    2803                         if (!PyString_Check(item)) {
    2804                                 PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
    2805                                         " __getitem__ returned different type");
    2806                                 Py_DECREF(item);
    2807                                 goto Fail_1;
    2808                         }
    2809                         reslen = PyString_GET_SIZE(item);
    2810                         if (reslen == 1) {
    2811                                 PyString_AS_STRING(result)[j++] =
    2812                                         PyString_AS_STRING(item)[0];
    2813                         } else {
    2814                                 /* do we need more space? */
    2815                                 Py_ssize_t need = j;
    2816 
    2817                                 /* calculate space requirements while checking for overflow */
    2818                                 if (need > PY_SSIZE_T_MAX - reslen) {
    2819                                         Py_DECREF(item);
    2820                                         goto Fail_1;
    2821                                 }
    2822 
    2823                                 need += reslen;
    2824 
    2825                                 if (need > PY_SSIZE_T_MAX - len) {
    2826                                         Py_DECREF(item);
    2827                                         goto Fail_1;
    2828                                 }
    2829 
    2830                                 need += len;
    2831 
    2832                                 if (need <= i) {
    2833                                         Py_DECREF(item);
    2834                                         goto Fail_1;
    2835                                 }
    2836 
    2837                                 need = need - i - 1;
    2838 
    2839                                 assert(need >= 0);
    2840                                 assert(outlen >= 0);
    2841 
    2842                                 if (need > outlen) {
    2843                                         /* overallocate, to avoid reallocations */
    2844                                         if (outlen > PY_SSIZE_T_MAX / 2) {
    2845                                                 Py_DECREF(item);
    2846                                                 return NULL;
    2847                                         }
    2848 
    2849                                         if (need<2*outlen) {
    2850                                                 need = 2*outlen;
    2851           }
    2852                                         if (_PyString_Resize(&result, need)) {
    2853                                                 Py_DECREF(item);
    2854                                                 return NULL;
    2855                                         }
    2856                                         outlen = need;
    2857                                 }
    2858                                 memcpy(
    2859                                         PyString_AS_STRING(result) + j,
    2860                                         PyString_AS_STRING(item),
    2861                                         reslen
    2862                                 );
    2863                                 j += reslen;
    2864                         }
    2865                 }
    2866                 Py_DECREF(item);
    2867         }
    2868 
    2869         if (j < outlen)
    2870                 _PyString_Resize(&result, j);
    2871 
    2872         return result;
     2822    PyObject *result;
     2823    Py_ssize_t i, j;
     2824    Py_ssize_t len = PyString_Size(strobj);
     2825    Py_ssize_t outlen = len;
     2826
     2827    if (func == Py_None) {
     2828        /* If it's a real string we can return the original,
     2829         * as no character is ever false and __getitem__
     2830         * does return this character. If it's a subclass
     2831         * we must go through the __getitem__ loop */
     2832        if (PyString_CheckExact(strobj)) {
     2833            Py_INCREF(strobj);
     2834            return strobj;
     2835        }
     2836    }
     2837    if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
     2838        return NULL;
     2839
     2840    for (i = j = 0; i < len; ++i) {
     2841        PyObject *item;
     2842        int ok;
     2843
     2844        item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
     2845        if (item == NULL)
     2846            goto Fail_1;
     2847        if (func==Py_None) {
     2848            ok = 1;
     2849        } else {
     2850            PyObject *arg, *good;
     2851            arg = PyTuple_Pack(1, item);
     2852            if (arg == NULL) {
     2853                Py_DECREF(item);
     2854                goto Fail_1;
     2855            }
     2856            good = PyEval_CallObject(func, arg);
     2857            Py_DECREF(arg);
     2858            if (good == NULL) {
     2859                Py_DECREF(item);
     2860                goto Fail_1;
     2861            }
     2862            ok = PyObject_IsTrue(good);
     2863            Py_DECREF(good);
     2864        }
     2865        if (ok > 0) {
     2866            Py_ssize_t reslen;
     2867            if (!PyString_Check(item)) {
     2868                PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
     2869                    " __getitem__ returned different type");
     2870                Py_DECREF(item);
     2871                goto Fail_1;
     2872            }
     2873            reslen = PyString_GET_SIZE(item);
     2874            if (reslen == 1) {
     2875                PyString_AS_STRING(result)[j++] =
     2876                    PyString_AS_STRING(item)[0];
     2877            } else {
     2878                /* do we need more space? */
     2879                Py_ssize_t need = j;
     2880
     2881                /* calculate space requirements while checking for overflow */
     2882                if (need > PY_SSIZE_T_MAX - reslen) {
     2883                    Py_DECREF(item);
     2884                    goto Fail_1;
     2885                }
     2886
     2887                need += reslen;
     2888
     2889                if (need > PY_SSIZE_T_MAX - len) {
     2890                    Py_DECREF(item);
     2891                    goto Fail_1;
     2892                }
     2893
     2894                need += len;
     2895
     2896                if (need <= i) {
     2897                    Py_DECREF(item);
     2898                    goto Fail_1;
     2899                }
     2900
     2901                need = need - i - 1;
     2902
     2903                assert(need >= 0);
     2904                assert(outlen >= 0);
     2905
     2906                if (need > outlen) {
     2907                    /* overallocate, to avoid reallocations */
     2908                    if (outlen > PY_SSIZE_T_MAX / 2) {
     2909                        Py_DECREF(item);
     2910                        return NULL;
     2911                    }
     2912
     2913                    if (need<2*outlen) {
     2914                        need = 2*outlen;
     2915      }
     2916                                    if (_PyString_Resize(&result, need)) {
     2917                                            Py_DECREF(item);
     2918                                            return NULL;
     2919                                    }
     2920                                    outlen = need;
     2921                            }
     2922                            memcpy(
     2923                                    PyString_AS_STRING(result) + j,
     2924                                    PyString_AS_STRING(item),
     2925                                    reslen
     2926                            );
     2927                            j += reslen;
     2928                    }
     2929        }
     2930        Py_DECREF(item);
     2931        if (ok < 0)
     2932            goto Fail_1;
     2933    }
     2934
     2935    if (j < outlen)
     2936        _PyString_Resize(&result, j);
     2937
     2938    return result;
    28732939
    28742940Fail_1:
    2875         Py_DECREF(result);
    2876         return NULL;
     2941    Py_DECREF(result);
     2942    return NULL;
    28772943}
    28782944
    … …  
    28832949filterunicode(PyObject *func, PyObject *strobj)
    28842950{
    2885         PyObject *result;
    2886         register Py_ssize_t i, j;
    2887         Py_ssize_t len = PyUnicode_GetSize(strobj);
    2888         Py_ssize_t outlen = len;
    2889 
    2890         if (func == Py_None) {
    2891                 /* If it's a real string we can return the original,
    2892                  * as no character is ever false and __getitem__
    2893                  * does return this character. If it's a subclass
    2894                  * we must go through the __getitem__ loop */
    2895                 if (PyUnicode_CheckExact(strobj)) {
    2896                         Py_INCREF(strobj);
    2897                         return strobj;
    2898                 }
    2899         }
    2900         if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
    2901                 return NULL;
    2902 
    2903         for (i = j = 0; i < len; ++i) {
    2904                 PyObject *item, *arg, *good;
    2905                 int ok;
    2906 
    2907                 item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
    2908                 if (item == NULL)
    2909                         goto Fail_1;
    2910                 if (func == Py_None) {
    2911                         ok = 1;
    2912                 } else {
    2913                         arg = PyTuple_Pack(1, item);
    2914                         if (arg == NULL) {
    2915                                 Py_DECREF(item);
    2916                                 goto Fail_1;
    2917                         }
    2918                         good = PyEval_CallObject(func, arg);
    2919                         Py_DECREF(arg);
    2920                         if (good == NULL) {
    2921                                 Py_DECREF(item);
    2922                                 goto Fail_1;
    2923                         }
    2924                         ok = PyObject_IsTrue(good);
    2925                         Py_DECREF(good);
    2926                 }
    2927                 if (ok) {
    2928                         Py_ssize_t reslen;
    2929                         if (!PyUnicode_Check(item)) {
    2930                                 PyErr_SetString(PyExc_TypeError,
    2931                                 "can't filter unicode to unicode:"
    2932                                 " __getitem__ returned different type");
    2933                                 Py_DECREF(item);
    2934                                 goto Fail_1;
    2935                         }
    2936                         reslen = PyUnicode_GET_SIZE(item);
    2937                         if (reslen == 1)
    2938                                 PyUnicode_AS_UNICODE(result)[j++] =
    2939                                         PyUnicode_AS_UNICODE(item)[0];
    2940                         else {
    2941                                 /* do we need more space? */
    2942                                 Py_ssize_t need = j + reslen + len - i - 1;
    2943        
    2944                                 /* check that didnt overflow */
    2945                                 if ((j > PY_SSIZE_T_MAX - reslen) ||
    2946                                         ((j + reslen) > PY_SSIZE_T_MAX - len) ||
    2947                                                 ((j + reslen + len) < i) ||
    2948                                                         ((j + reslen + len - i) <= 0)) {
    2949                                         Py_DECREF(item);
    2950                                         return NULL;
    2951                                 }
    2952 
    2953                                 assert(need >= 0);
    2954                                 assert(outlen >= 0);
    2955                                
    2956                                 if (need > outlen) {
    2957                                         /* overallocate,
    2958                                            to avoid reallocations */
    2959                                         if (need < 2 * outlen) {
    2960             if (outlen > PY_SSIZE_T_MAX / 2) {
    2961               Py_DECREF(item);
    2962               return NULL;
    2963                                                 } else {
    2964                                                         need = 2 * outlen;
    2965                                     }
    2966           }
    2967 
    2968                                         if (PyUnicode_Resize(
    2969                                                 &result, need) < 0) {
    2970                                                 Py_DECREF(item);
    2971                                                 goto Fail_1;
    2972                                         }
    2973                                         outlen = need;
    2974                                 }
    2975                                 memcpy(PyUnicode_AS_UNICODE(result) + j,
    2976                                        PyUnicode_AS_UNICODE(item),
    2977                                        reslen*sizeof(Py_UNICODE));
    2978                                 j += reslen;
    2979                         }
    2980                 }
    2981                 Py_DECREF(item);
    2982         }
    2983 
    2984         if (j < outlen)
    2985                 PyUnicode_Resize(&result, j);
    2986 
    2987         return result;
     2951    PyObject *result;
     2952    register Py_ssize_t i, j;
     2953    Py_ssize_t len = PyUnicode_GetSize(strobj);
     2954    Py_ssize_t outlen = len;
     2955
     2956    if (func == Py_None) {
     2957        /* If it's a real string we can return the original,
     2958         * as no character is ever false and __getitem__
     2959         * does return this character. If it's a subclass
     2960         * we must go through the __getitem__ loop */
     2961        if (PyUnicode_CheckExact(strobj)) {
     2962            Py_INCREF(strobj);
     2963            return strobj;
     2964        }
     2965    }
     2966    if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
     2967        return NULL;
     2968
     2969    for (i = j = 0; i < len; ++i) {
     2970        PyObject *item, *arg, *good;
     2971        int ok;
     2972
     2973        item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
     2974        if (item == NULL)
     2975            goto Fail_1;
     2976        if (func == Py_None) {
     2977            ok = 1;
     2978        } else {
     2979            arg = PyTuple_Pack(1, item);
     2980            if (arg == NULL) {
     2981                Py_DECREF(item);
     2982                goto Fail_1;
     2983            }
     2984            good = PyEval_CallObject(func, arg);
     2985            Py_DECREF(arg);
     2986            if (good == NULL) {
     2987                Py_DECREF(item);
     2988                goto Fail_1;
     2989            }
     2990            ok = PyObject_IsTrue(good);
     2991            Py_DECREF(good);
     2992        }
     2993        if (ok > 0) {
     2994            Py_ssize_t reslen;
     2995            if (!PyUnicode_Check(item)) {
     2996                PyErr_SetString(PyExc_TypeError,
     2997                "can't filter unicode to unicode:"
     2998                " __getitem__ returned different type");
     2999                Py_DECREF(item);
     3000                goto Fail_1;
     3001            }
     3002            reslen = PyUnicode_GET_SIZE(item);
     3003            if (reslen == 1)
     3004                PyUnicode_AS_UNICODE(result)[j++] =
     3005                    PyUnicode_AS_UNICODE(item)[0];
     3006            else {
     3007                /* do we need more space? */
     3008                Py_ssize_t need = j + reslen + len - i - 1;
     3009
     3010                /* check that didnt overflow */
     3011                if ((j > PY_SSIZE_T_MAX - reslen) ||
     3012                    ((j + reslen) > PY_SSIZE_T_MAX - len) ||
     3013                        ((j + reslen + len) < i) ||
     3014                            ((j + reslen + len - i) <= 0)) {
     3015                    Py_DECREF(item);
     3016                    return NULL;
     3017                }
     3018
     3019                assert(need >= 0);
     3020                assert(outlen >= 0);
     3021
     3022                if (need > outlen) {
     3023                    /* overallocate,
     3024                       to avoid reallocations */
     3025                    if (need < 2 * outlen) {
     3026        if (outlen > PY_SSIZE_T_MAX / 2) {
     3027          Py_DECREF(item);
     3028          return NULL;
     3029                                            } else {
     3030                                                    need = 2 * outlen;
     3031                                }
     3032      }
     3033
     3034                                    if (PyUnicode_Resize(
     3035                                            &result, need) < 0) {
     3036                                            Py_DECREF(item);
     3037                                            goto Fail_1;
     3038                                    }
     3039                                    outlen = need;
     3040                            }
     3041                            memcpy(PyUnicode_AS_UNICODE(result) + j,
     3042                                   PyUnicode_AS_UNICODE(item),
     3043                                   reslen*sizeof(Py_UNICODE));
     3044                            j += reslen;
     3045                    }
     3046        }
     3047        Py_DECREF(item);
     3048        if (ok < 0)
     3049            goto Fail_1;
     3050    }
     3051
     3052    if (j < outlen)
     3053        PyUnicode_Resize(&result, j);
     3054
     3055    return result;
    29883056
    29893057Fail_1:
    2990         Py_DECREF(result);
    2991         return NULL;
     3058    Py_DECREF(result);
     3059    return NULL;
    29923060}
    29933061#endif
Note: See TracChangeset for help on using the changeset viewer.