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/Objects/tupleobject.c

    r2 r391  
    66/* Speed optimization to avoid frequent malloc/free of small tuples */
    77#ifndef PyTuple_MAXSAVESIZE
    8 #define PyTuple_MAXSAVESIZE     20  /* Largest tuple to save on free list */
    9 #endif
    10 #ifndef PyTuple_MAXFREELIST 
     8#define PyTuple_MAXSAVESIZE     20  /* Largest tuple to save on free list */
     9#endif
     10#ifndef PyTuple_MAXFREELIST
    1111#define PyTuple_MAXFREELIST  2000  /* Maximum number of tuples of each size to save */
    1212#endif
    … …  
    2020#endif
    2121#ifdef COUNT_ALLOCS
    22 int fast_tuple_allocs;
    23 int tuple_zero_allocs;
    24 #endif
     22Py_ssize_t fast_tuple_allocs;
     23Py_ssize_t tuple_zero_allocs;
     24#endif
     25
     26/* Debug statistic to count GC tracking of tuples.
     27   Please note that tuples are only untracked when considered by the GC, and
     28   many of them will be dead before. Therefore, a tracking rate close to 100%
     29   does not necessarily prove that the heuristic is inefficient.
     30*/
     31#ifdef SHOW_TRACK_COUNT
     32static Py_ssize_t count_untracked = 0;
     33static Py_ssize_t count_tracked = 0;
     34
     35static void
     36show_track(void)
     37{
     38    fprintf(stderr, "Tuples created: %" PY_FORMAT_SIZE_T "d\n",
     39        count_tracked + count_untracked);
     40    fprintf(stderr, "Tuples tracked by the GC: %" PY_FORMAT_SIZE_T
     41        "d\n", count_tracked);
     42    fprintf(stderr, "%.2f%% tuple tracking rate\n\n",
     43        (100.0*count_tracked/(count_untracked+count_tracked)));
     44}
     45#endif
     46
    2547
    2648PyObject *
    2749PyTuple_New(register Py_ssize_t size)
    2850{
    29         register PyTupleObject *op;
    30         Py_ssize_t i;
    31         if (size < 0) {
    32                 PyErr_BadInternalCall();
    33                 return NULL;
    34         }
     51    register PyTupleObject *op;
     52    Py_ssize_t i;
     53    if (size < 0) {
     54        PyErr_BadInternalCall();
     55        return NULL;
     56    }
    3557#if PyTuple_MAXSAVESIZE > 0
    36         if (size == 0 && free_list[0]) {
    37                 op = free_list[0];
    38                 Py_INCREF(op);
     58    if (size == 0 && free_list[0]) {
     59        op = free_list[0];
     60        Py_INCREF(op);
    3961#ifdef COUNT_ALLOCS
    40                 tuple_zero_allocs++;
    41 #endif
    42                 return (PyObject *) op;
    43         }
    44         if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
    45                 free_list[size] = (PyTupleObject *) op->ob_item[0];
    46                 numfree[size]--;
     62        tuple_zero_allocs++;
     63#endif
     64        return (PyObject *) op;
     65    }
     66    if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
     67        free_list[size] = (PyTupleObject *) op->ob_item[0];
     68        numfree[size]--;
    4769#ifdef COUNT_ALLOCS
    48                 fast_tuple_allocs++;
    49 #endif
    50                 /* Inline PyObject_InitVar */
     70        fast_tuple_allocs++;
     71#endif
     72        /* Inline PyObject_InitVar */
    5173#ifdef Py_TRACE_REFS
    52                 Py_SIZE(op) = size;
    53                 Py_TYPE(op) = &PyTuple_Type;
    54 #endif
    55                 _Py_NewReference((PyObject *)op);
    56         }
    57         else
    58 #endif
    59         {
    60                 Py_ssize_t nbytes = size * sizeof(PyObject *);
    61                 /* Check for overflow */
    62                 if (nbytes / sizeof(PyObject *) != (size_t)size ||
    63                     (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
    64                 {
    65                         return PyErr_NoMemory();
    66                 }
    67                 nbytes += sizeof(PyTupleObject) - sizeof(PyObject *);
    68 
    69                 op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
    70                 if (op == NULL)
    71                         return NULL;
    72         }
    73         for (i=0; i < size; i++)
    74                 op->ob_item[i] = NULL;
     74        Py_SIZE(op) = size;
     75        Py_TYPE(op) = &PyTuple_Type;
     76#endif
     77        _Py_NewReference((PyObject *)op);
     78    }
     79    else
     80#endif
     81    {
     82        Py_ssize_t nbytes = size * sizeof(PyObject *);
     83        /* Check for overflow */
     84        if (nbytes / sizeof(PyObject *) != (size_t)size ||
     85            (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
     86        {
     87            return PyErr_NoMemory();
     88        }
     89
     90        op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
     91        if (op == NULL)
     92            return NULL;
     93    }
     94    for (i=0; i < size; i++)
     95        op->ob_item[i] = NULL;
    7596#if PyTuple_MAXSAVESIZE > 0
    76         if (size == 0) {
    77                 free_list[0] = op;
    78                 ++numfree[0];
    79                 Py_INCREF(op);  /* extra INCREF so that this is never freed */
    80         }
    81 #endif
    82         _PyObject_GC_TRACK(op);
    83         return (PyObject *) op;
     97    if (size == 0) {
     98        free_list[0] = op;
     99        ++numfree[0];
     100        Py_INCREF(op);          /* extra INCREF so that this is never freed */
     101    }
     102#endif
     103#ifdef SHOW_TRACK_COUNT
     104    count_tracked++;
     105#endif
     106    _PyObject_GC_TRACK(op);
     107    return (PyObject *) op;
    84108}
    85109
    … …  
    87111PyTuple_Size(register PyObject *op)
    88112{
    89         if (!PyTuple_Check(op)) {
    90                 PyErr_BadInternalCall();
    91                 return -1;
    92         }
    93         else
    94                 return Py_SIZE(op);
     113    if (!PyTuple_Check(op)) {
     114        PyErr_BadInternalCall();
     115        return -1;
     116    }
     117    else
     118        return Py_SIZE(op);
    95119}
    96120
    … …  
    98122PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
    99123{
    100         if (!PyTuple_Check(op)) {
    101                 PyErr_BadInternalCall();
    102                 return NULL;
    103         }
    104         if (i < 0 || i >= Py_SIZE(op)) {
    105                 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
    106                 return NULL;
    107         }
    108         return ((PyTupleObject *)op) -> ob_item[i];
     124    if (!PyTuple_Check(op)) {
     125        PyErr_BadInternalCall();
     126        return NULL;
     127    }
     128    if (i < 0 || i >= Py_SIZE(op)) {
     129        PyErr_SetString(PyExc_IndexError, "tuple index out of range");
     130        return NULL;
     131    }
     132    return ((PyTupleObject *)op) -> ob_item[i];
    109133}
    110134
    … …  
    112136PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
    113137{
    114         register PyObject *olditem;
    115         register PyObject **p;
    116         if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
    117                 Py_XDECREF(newitem);
    118                 PyErr_BadInternalCall();
    119                 return -1;
    120         }
    121         if (i < 0 || i >= Py_SIZE(op)) {
    122                 Py_XDECREF(newitem);
    123                 PyErr_SetString(PyExc_IndexError,
    124                                 "tuple assignment index out of range");
    125                 return -1;
    126         }
    127         p = ((PyTupleObject *)op) -> ob_item + i;
    128         olditem = *p;
    129         *p = newitem;
    130         Py_XDECREF(olditem);
    131         return 0;
     138    register PyObject *olditem;
     139    register PyObject **p;
     140    if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
     141        Py_XDECREF(newitem);
     142        PyErr_BadInternalCall();
     143        return -1;
     144    }
     145    if (i < 0 || i >= Py_SIZE(op)) {
     146        Py_XDECREF(newitem);
     147        PyErr_SetString(PyExc_IndexError,
     148                        "tuple assignment index out of range");
     149        return -1;
     150    }
     151    p = ((PyTupleObject *)op) -> ob_item + i;
     152    olditem = *p;
     153    *p = newitem;
     154    Py_XDECREF(olditem);
     155    return 0;
     156}
     157
     158void
     159_PyTuple_MaybeUntrack(PyObject *op)
     160{
     161    PyTupleObject *t;
     162    Py_ssize_t i, n;
     163
     164    if (!PyTuple_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op))
     165        return;
     166    t = (PyTupleObject *) op;
     167    n = Py_SIZE(t);
     168    for (i = 0; i < n; i++) {
     169        PyObject *elt = PyTuple_GET_ITEM(t, i);
     170        /* Tuple with NULL elements aren't
     171           fully constructed, don't untrack
     172           them yet. */
     173        if (!elt ||
     174            _PyObject_GC_MAY_BE_TRACKED(elt))
     175            return;
     176    }
     177#ifdef SHOW_TRACK_COUNT
     178    count_tracked--;
     179    count_untracked++;
     180#endif
     181    _PyObject_GC_UNTRACK(op);
    132182}
    133183
    … …  
    135185PyTuple_Pack(Py_ssize_t n, ...)
    136186{
    137         Py_ssize_t i;
    138         PyObject *o;
    139         PyObject *result;
    140         PyObject **items;
    141         va_list vargs;
    142 
    143         va_start(vargs, n);
    144         result = PyTuple_New(n);
    145         if (result == NULL)
    146                 return NULL;
    147         items = ((PyTupleObject *)result)->ob_item;
    148         for (i = 0; i < n; i++) {
    149                 o = va_arg(vargs, PyObject *);
    150                 Py_INCREF(o);
    151                 items[i] = o;
    152         }
    153         va_end(vargs);
    154         return result;
     187    Py_ssize_t i;
     188    PyObject *o;
     189    PyObject *result;
     190    PyObject **items;
     191    va_list vargs;
     192
     193    va_start(vargs, n);
     194    result = PyTuple_New(n);
     195    if (result == NULL) {
     196        va_end(vargs);
     197        return NULL;
     198    }
     199    items = ((PyTupleObject *)result)->ob_item;
     200    for (i = 0; i < n; i++) {
     201        o = va_arg(vargs, PyObject *);
     202        Py_INCREF(o);
     203        items[i] = o;
     204    }
     205    va_end(vargs);
     206    return result;
    155207}
    156208
    … …  
    161213tupledealloc(register PyTupleObject *op)
    162214{
    163         register Py_ssize_t i;
    164         register Py_ssize_t len =  Py_SIZE(op);
    165         PyObject_GC_UnTrack(op);
    166         Py_TRASHCAN_SAFE_BEGIN(op)
    167         if (len > 0) {
    168                 i = len;
    169                 while (--i >= 0)
    170                         Py_XDECREF(op->ob_item[i]);
     215    register Py_ssize_t i;
     216    register Py_ssize_t len =  Py_SIZE(op);
     217    PyObject_GC_UnTrack(op);
     218    Py_TRASHCAN_SAFE_BEGIN(op)
     219    if (len > 0) {
     220        i = len;
     221        while (--i >= 0)
     222            Py_XDECREF(op->ob_item[i]);
    171223#if PyTuple_MAXSAVESIZE > 0
    172                 if (len < PyTuple_MAXSAVESIZE &&
    173                     numfree[len] < PyTuple_MAXFREELIST &&
    174                     Py_TYPE(op) == &PyTuple_Type)
    175                 {
    176                         op->ob_item[0] = (PyObject *) free_list[len];
    177                         numfree[len]++;
    178                         free_list[len] = op;
    179                         goto done; /* return */
    180                 }
    181 #endif
    182         }
    183         Py_TYPE(op)->tp_free((PyObject *)op);
     224        if (len < PyTuple_MAXSAVESIZE &&
     225            numfree[len] < PyTuple_MAXFREELIST &&
     226            Py_TYPE(op) == &PyTuple_Type)
     227        {
     228            op->ob_item[0] = (PyObject *) free_list[len];
     229            numfree[len]++;
     230            free_list[len] = op;
     231            goto done; /* return */
     232        }
     233#endif
     234    }
     235    Py_TYPE(op)->tp_free((PyObject *)op);
    184236done:
    185         Py_TRASHCAN_SAFE_END(op)
     237    Py_TRASHCAN_SAFE_END(op)
    186238}
    187239
    … …  
    189241tupleprint(PyTupleObject *op, FILE *fp, int flags)
    190242{
    191         Py_ssize_t i;
    192         Py_BEGIN_ALLOW_THREADS
    193         fprintf(fp, "(");
    194         Py_END_ALLOW_THREADS
    195         for (i = 0; i < Py_SIZE(op); i++) {
    196                 if (i > 0) {
    197                         Py_BEGIN_ALLOW_THREADS
    198                         fprintf(fp, ", ");
    199                         Py_END_ALLOW_THREADS
    200                 }
    201                 if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
    202                         return -1;
    203         }
    204         i = Py_SIZE(op);
    205         Py_BEGIN_ALLOW_THREADS
    206         if (i == 1)
    207                 fprintf(fp, ",");
    208         fprintf(fp, ")");
    209         Py_END_ALLOW_THREADS
    210         return 0;
     243    Py_ssize_t i;
     244    Py_BEGIN_ALLOW_THREADS
     245    fprintf(fp, "(");
     246    Py_END_ALLOW_THREADS
     247    for (i = 0; i < Py_SIZE(op); i++) {
     248        if (i > 0) {
     249            Py_BEGIN_ALLOW_THREADS
     250            fprintf(fp, ", ");
     251            Py_END_ALLOW_THREADS
     252        }
     253        if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
     254            return -1;
     255    }
     256    i = Py_SIZE(op);
     257    Py_BEGIN_ALLOW_THREADS
     258    if (i == 1)
     259        fprintf(fp, ",");
     260    fprintf(fp, ")");
     261    Py_END_ALLOW_THREADS
     262    return 0;
    211263}
    212264
    … …  
    214266tuplerepr(PyTupleObject *v)
    215267{
    216         Py_ssize_t i, n;
    217         PyObject *s, *temp;
    218         PyObject *pieces, *result = NULL;
    219 
    220         n = Py_SIZE(v);
    221         if (n == 0)
    222                 return PyString_FromString("()");
    223 
    224         /* While not mutable, it is still possible to end up with a cycle in a
    225            tuple through an object that stores itself within a tuple (and thus
    226            infinitely asks for the repr of itself). This should only be
    227            possible within a type. */
    228         i = Py_ReprEnter((PyObject *)v);
    229         if (i != 0) {
    230                 return i > 0 ? PyString_FromString("(...)") : NULL;
    231         }
    232 
    233         pieces = PyTuple_New(n);
    234         if (pieces == NULL)
    235                 return NULL;
    236 
    237         /* Do repr() on each element. */
    238         for (i = 0; i < n; ++i) {
    239                 if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
    240                         goto Done;
    241                 s = PyObject_Repr(v->ob_item[i]);
    242                 Py_LeaveRecursiveCall();
    243                 if (s == NULL)
    244                         goto Done;
    245                 PyTuple_SET_ITEM(pieces, i, s);
    246         }
    247 
    248         /* Add "()" decorations to the first and last items. */
    249         assert(n > 0);
    250         s = PyString_FromString("(");
    251         if (s == NULL)
    252                 goto Done;
    253         temp = PyTuple_GET_ITEM(pieces, 0);
    254         PyString_ConcatAndDel(&s, temp);
    255         PyTuple_SET_ITEM(pieces, 0, s);
    256         if (s == NULL)
    257                 goto Done;
    258 
    259         s = PyString_FromString(n == 1 ? ",)" : ")");
    260         if (s == NULL)
    261                 goto Done;
    262         temp = PyTuple_GET_ITEM(pieces, n-1);
    263         PyString_ConcatAndDel(&temp, s);
    264         PyTuple_SET_ITEM(pieces, n-1, temp);
    265         if (temp == NULL)
    266                 goto Done;
    267 
    268         /* Paste them all together with ", " between. */
    269         s = PyString_FromString(", ");
    270         if (s == NULL)
    271                 goto Done;
    272         result = _PyString_Join(s, pieces);
    273         Py_DECREF(s);   
     268    Py_ssize_t i, n;
     269    PyObject *s, *temp;
     270    PyObject *pieces, *result = NULL;
     271
     272    n = Py_SIZE(v);
     273    if (n == 0)
     274        return PyString_FromString("()");
     275
     276    /* While not mutable, it is still possible to end up with a cycle in a
     277       tuple through an object that stores itself within a tuple (and thus
     278       infinitely asks for the repr of itself). This should only be
     279       possible within a type. */
     280    i = Py_ReprEnter((PyObject *)v);
     281    if (i != 0) {
     282        return i > 0 ? PyString_FromString("(...)") : NULL;
     283    }
     284
     285    pieces = PyTuple_New(n);
     286    if (pieces == NULL)
     287        return NULL;
     288
     289    /* Do repr() on each element. */
     290    for (i = 0; i < n; ++i) {
     291        if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
     292            goto Done;
     293        s = PyObject_Repr(v->ob_item[i]);
     294        Py_LeaveRecursiveCall();
     295        if (s == NULL)
     296            goto Done;
     297        PyTuple_SET_ITEM(pieces, i, s);
     298    }
     299
     300    /* Add "()" decorations to the first and last items. */
     301    assert(n > 0);
     302    s = PyString_FromString("(");
     303    if (s == NULL)
     304        goto Done;
     305    temp = PyTuple_GET_ITEM(pieces, 0);
     306    PyString_ConcatAndDel(&s, temp);
     307    PyTuple_SET_ITEM(pieces, 0, s);
     308    if (s == NULL)
     309        goto Done;
     310
     311    s = PyString_FromString(n == 1 ? ",)" : ")");
     312    if (s == NULL)
     313        goto Done;
     314    temp = PyTuple_GET_ITEM(pieces, n-1);
     315    PyString_ConcatAndDel(&temp, s);
     316    PyTuple_SET_ITEM(pieces, n-1, temp);
     317    if (temp == NULL)
     318        goto Done;
     319
     320    /* Paste them all together with ", " between. */
     321    s = PyString_FromString(", ");
     322    if (s == NULL)
     323        goto Done;
     324    result = _PyString_Join(s, pieces);
     325    Py_DECREF(s);
    274326
    275327Done:
    276         Py_DECREF(pieces);
    277         Py_ReprLeave((PyObject *)v);
    278         return result;
    279 }
    280 
    281 /* The addend 82520, was selected from the range(0, 1000000) for 
    282    generating the greatest number of prime multipliers for tuples 
     328    Py_DECREF(pieces);
     329    Py_ReprLeave((PyObject *)v);
     330    return result;
     331}
     332
     333/* The addend 82520, was selected from the range(0, 1000000) for
     334   generating the greatest number of prime multipliers for tuples
    283335   upto length eight:
    284336
    285      1082527, 1165049, 1082531, 1165057, 1247581, 1330103, 1082533, 
     337     1082527, 1165049, 1082531, 1165057, 1247581, 1330103, 1082533,
    286338     1330111, 1412633, 1165069, 1247599, 1495177, 1577699
    287339*/
    … …  
    290342tuplehash(PyTupleObject *v)
    291343{
    292         register long x, y;
    293         register Py_ssize_t len = Py_SIZE(v);
    294         register PyObject **p;
    295         long mult = 1000003L;
    296         x = 0x345678L;
    297         p = v->ob_item;
    298         while (--len >= 0) {
    299                 y = PyObject_Hash(*p++);
    300                 if (y == -1)
    301                         return -1;
    302                 x = (x ^ y) * mult;
    303                 /* the cast might truncate len; that doesn't change hash stability */
    304                 mult += (long)(82520L + len + len);
    305         }
    306         x += 97531L;
    307         if (x == -1)
    308                 x = -2;
    309         return x;
     344    register long x, y;
     345    register Py_ssize_t len = Py_SIZE(v);
     346    register PyObject **p;
     347    long mult = 1000003L;
     348    x = 0x345678L;
     349    p = v->ob_item;
     350    while (--len >= 0) {
     351        y = PyObject_Hash(*p++);
     352        if (y == -1)
     353            return -1;
     354        x = (x ^ y) * mult;
     355        /* the cast might truncate len; that doesn't change hash stability */
     356        mult += (long)(82520L + len + len);
     357    }
     358    x += 97531L;
     359    if (x == -1)
     360        x = -2;
     361    return x;
    310362}
    311363
    … …  
    313365tuplelength(PyTupleObject *a)
    314366{
    315         return Py_SIZE(a);
     367    return Py_SIZE(a);
    316368}
    317369
    … …  
    319371tuplecontains(PyTupleObject *a, PyObject *el)
    320372{
    321         Py_ssize_t i;
    322         int cmp;
    323 
    324         for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
    325                 cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
    326                                                    Py_EQ);
    327         return cmp;
     373    Py_ssize_t i;
     374    int cmp;
     375
     376    for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
     377        cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
     378                                           Py_EQ);
     379    return cmp;
    328380}
    329381
    … …  
    331383tupleitem(register PyTupleObject *a, register Py_ssize_t i)
    332384{
    333         if (i < 0 || i >= Py_SIZE(a)) {
    334                 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
    335                 return NULL;
    336         }
    337         Py_INCREF(a->ob_item[i]);
    338         return a->ob_item[i];
    339 }
    340 
    341 static PyObject *
    342 tupleslice(register PyTupleObject *a, register Py_ssize_t ilow, 
    343            register Py_ssize_t ihigh)
    344 {
    345         register PyTupleObject *np;
    346         PyObject **src, **dest;
    347         register Py_ssize_t i;
    348         Py_ssize_t len;
    349         if (ilow < 0)
    350                 ilow = 0;
    351         if (ihigh > Py_SIZE(a))
    352                 ihigh = Py_SIZE(a);
    353         if (ihigh < ilow)
    354                 ihigh = ilow;
    355         if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
    356                 Py_INCREF(a);
    357                 return (PyObject *)a;
    358         }
    359         len = ihigh - ilow;
    360         np = (PyTupleObject *)PyTuple_New(len);
    361         if (np == NULL)
    362                 return NULL;
    363         src = a->ob_item + ilow;
    364         dest = np->ob_item;
    365         for (i = 0; i < len; i++) {
    366                 PyObject *v = src[i];
    367                 Py_INCREF(v);
    368                 dest[i] = v;
    369         }
    370         return (PyObject *)np;
     385    if (i < 0 || i >= Py_SIZE(a)) {
     386        PyErr_SetString(PyExc_IndexError, "tuple index out of range");
     387        return NULL;
     388    }
     389    Py_INCREF(a->ob_item[i]);
     390    return a->ob_item[i];
     391}
     392
     393static PyObject *
     394tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
     395           register Py_ssize_t ihigh)
     396{
     397    register PyTupleObject *np;
     398    PyObject **src, **dest;
     399    register Py_ssize_t i;
     400    Py_ssize_t len;
     401    if (ilow < 0)
     402        ilow = 0;
     403    if (ihigh > Py_SIZE(a))
     404        ihigh = Py_SIZE(a);
     405    if (ihigh < ilow)
     406        ihigh = ilow;
     407    if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
     408        Py_INCREF(a);
     409        return (PyObject *)a;
     410    }
     411    len = ihigh - ilow;
     412    np = (PyTupleObject *)PyTuple_New(len);
     413    if (np == NULL)
     414        return NULL;
     415    src = a->ob_item + ilow;
     416    dest = np->ob_item;
     417    for (i = 0; i < len; i++) {
     418        PyObject *v = src[i];
     419        Py_INCREF(v);
     420        dest[i] = v;
     421    }
     422    return (PyObject *)np;
    371423}
    372424
    … …  
    374426PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
    375427{
    376         if (op == NULL || !PyTuple_Check(op)) {
    377                 PyErr_BadInternalCall();
    378                 return NULL;
    379         }
    380         return tupleslice((PyTupleObject *)op, i, j);
     428    if (op == NULL || !PyTuple_Check(op)) {
     429        PyErr_BadInternalCall();
     430        return NULL;
     431    }
     432    return tupleslice((PyTupleObject *)op, i, j);
    381433}
    382434
    … …  
    384436tupleconcat(register PyTupleObject *a, register PyObject *bb)
    385437{
    386         register Py_ssize_t size;
    387         register Py_ssize_t i;
    388         PyObject **src, **dest;
    389         PyTupleObject *np;
    390         if (!PyTuple_Check(bb)) {
    391                 PyErr_Format(PyExc_TypeError,
    392                      "can only concatenate tuple (not \"%.200s\") to tuple",
    393                              Py_TYPE(bb)->tp_name);
    394                 return NULL;
    395         }
     438    register Py_ssize_t size;
     439    register Py_ssize_t i;
     440    PyObject **src, **dest;
     441    PyTupleObject *np;
     442    if (!PyTuple_Check(bb)) {
     443        PyErr_Format(PyExc_TypeError,
     444             "can only concatenate tuple (not \"%.200s\") to tuple",
     445                 Py_TYPE(bb)->tp_name);
     446        return NULL;
     447    }
    396448#define b ((PyTupleObject *)bb)
    397         size = Py_SIZE(a) + Py_SIZE(b);
    398         if (size < 0)
    399                 return PyErr_NoMemory();
    400         np = (PyTupleObject *) PyTuple_New(size);
    401         if (np == NULL) {
    402                 return NULL;
    403         }
    404         src = a->ob_item;
    405         dest = np->ob_item;
    406         for (i = 0; i < Py_SIZE(a); i++) {
    407                 PyObject *v = src[i];
    408                 Py_INCREF(v);
    409                 dest[i] = v;
    410         }
    411         src = b->ob_item;
    412         dest = np->ob_item + Py_SIZE(a);
    413         for (i = 0; i < Py_SIZE(b); i++) {
    414                 PyObject *v = src[i];
    415                 Py_INCREF(v);
    416                 dest[i] = v;
    417         }
    418         return (PyObject *)np;
     449    size = Py_SIZE(a) + Py_SIZE(b);
     450    if (size < 0)
     451        return PyErr_NoMemory();
     452    np = (PyTupleObject *) PyTuple_New(size);
     453    if (np == NULL) {
     454        return NULL;
     455    }
     456    src = a->ob_item;
     457    dest = np->ob_item;
     458    for (i = 0; i < Py_SIZE(a); i++) {
     459        PyObject *v = src[i];
     460        Py_INCREF(v);
     461        dest[i] = v;
     462    }
     463    src = b->ob_item;
     464    dest = np->ob_item + Py_SIZE(a);
     465    for (i = 0; i < Py_SIZE(b); i++) {
     466        PyObject *v = src[i];
     467        Py_INCREF(v);
     468        dest[i] = v;
     469    }
     470    return (PyObject *)np;
    419471#undef b
    420472}
    … …  
    423475tuplerepeat(PyTupleObject *a, Py_ssize_t n)
    424476{
    425         Py_ssize_t i, j;
    426         Py_ssize_t size;
    427         PyTupleObject *np;
    428         PyObject **p, **items;
    429         if (n < 0)
    430                 n = 0;
    431         if (Py_SIZE(a) == 0 || n == 1) {
    432                 if (PyTuple_CheckExact(a)) {
    433                         /* Since tuples are immutable, we can return a shared
    434                            copy in this case */
    435                         Py_INCREF(a);
    436                         return (PyObject *)a;
    437                 }
    438                 if (Py_SIZE(a) == 0)
    439                         return PyTuple_New(0);
    440         }
    441         size = Py_SIZE(a) * n;
    442         if (size/Py_SIZE(a) != n)
    443                 return PyErr_NoMemory();
    444         np = (PyTupleObject *) PyTuple_New(size);
    445         if (np == NULL)
    446                 return NULL;
    447         p = np->ob_item;
    448         items = a->ob_item;
    449         for (i = 0; i < n; i++) {
    450                 for (j = 0; j < Py_SIZE(a); j++) {
    451                         *p = items[j];
    452                         Py_INCREF(*p);
    453                         p++;
    454                 }
    455         }
    456         return (PyObject *) np;
     477    Py_ssize_t i, j;
     478    Py_ssize_t size;
     479    PyTupleObject *np;
     480    PyObject **p, **items;
     481    if (n < 0)
     482        n = 0;
     483    if (Py_SIZE(a) == 0 || n == 1) {
     484        if (PyTuple_CheckExact(a)) {
     485            /* Since tuples are immutable, we can return a shared
     486               copy in this case */
     487            Py_INCREF(a);
     488            return (PyObject *)a;
     489        }
     490        if (Py_SIZE(a) == 0)
     491            return PyTuple_New(0);
     492    }
     493    size = Py_SIZE(a) * n;
     494    if (size/Py_SIZE(a) != n)
     495        return PyErr_NoMemory();
     496    np = (PyTupleObject *) PyTuple_New(size);
     497    if (np == NULL)
     498        return NULL;
     499    p = np->ob_item;
     500    items = a->ob_item;
     501    for (i = 0; i < n; i++) {
     502        for (j = 0; j < Py_SIZE(a); j++) {
     503            *p = items[j];
     504            Py_INCREF(*p);
     505            p++;
     506        }
     507    }
     508    return (PyObject *) np;
    457509}
    458510
    … …  
    460512tupleindex(PyTupleObject *self, PyObject *args)
    461513{
    462         Py_ssize_t i, start=0, stop=Py_SIZE(self);
    463         PyObject *v;
    464 
    465         if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
    466                                     _PyEval_SliceIndex, &start,
    467                                     _PyEval_SliceIndex, &stop))
    468                 return NULL;
    469         if (start < 0) {
    470                 start += Py_SIZE(self);
    471                 if (start < 0)
    472                         start = 0;
    473         }
    474         if (stop < 0) {
    475                 stop += Py_SIZE(self);
    476                 if (stop < 0)
    477                         stop = 0;
    478         }
    479         for (i = start; i < stop && i < Py_SIZE(self); i++) {
    480                 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
    481                 if (cmp > 0)
    482                         return PyInt_FromSsize_t(i);
    483                 else if (cmp < 0)
    484                         return NULL;
    485         }
    486         PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in list");
    487         return NULL;
     514    Py_ssize_t i, start=0, stop=Py_SIZE(self);
     515    PyObject *v;
     516
     517    if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
     518                                _PyEval_SliceIndex, &start,
     519                                _PyEval_SliceIndex, &stop))
     520        return NULL;
     521    if (start < 0) {
     522        start += Py_SIZE(self);
     523        if (start < 0)
     524            start = 0;
     525    }
     526    if (stop < 0) {
     527        stop += Py_SIZE(self);
     528        if (stop < 0)
     529            stop = 0;
     530    }
     531    for (i = start; i < stop && i < Py_SIZE(self); i++) {
     532        int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
     533        if (cmp > 0)
     534            return PyInt_FromSsize_t(i);
     535        else if (cmp < 0)
     536            return NULL;
     537    }
     538    PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in tuple");
     539    return NULL;
    488540}
    489541
    … …  
    491543tuplecount(PyTupleObject *self, PyObject *v)
    492544{
    493         Py_ssize_t count = 0;
    494         Py_ssize_t i;
    495 
    496         for (i = 0; i < Py_SIZE(self); i++) {
    497                 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
    498                 if (cmp > 0)
    499                         count++;
    500                 else if (cmp < 0)
    501                         return NULL;
    502         }
    503         return PyInt_FromSsize_t(count);
     545    Py_ssize_t count = 0;
     546    Py_ssize_t i;
     547
     548    for (i = 0; i < Py_SIZE(self); i++) {
     549        int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
     550        if (cmp > 0)
     551            count++;
     552        else if (cmp < 0)
     553            return NULL;
     554    }
     555    return PyInt_FromSsize_t(count);
    504556}
    505557
    … …  
    507559tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
    508560{
    509         Py_ssize_t i;
    510 
    511         for (i = Py_SIZE(o); --i >= 0; )
    512                 Py_VISIT(o->ob_item[i]);
    513         return 0;
     561    Py_ssize_t i;
     562
     563    for (i = Py_SIZE(o); --i >= 0; )
     564        Py_VISIT(o->ob_item[i]);
     565    return 0;
    514566}
    515567
    … …  
    517569tuplerichcompare(PyObject *v, PyObject *w, int op)
    518570{
    519         PyTupleObject *vt, *wt;
    520         Py_ssize_t i;
    521         Py_ssize_t vlen, wlen;
    522 
    523         if (!PyTuple_Check(v) || !PyTuple_Check(w)) {
    524                 Py_INCREF(Py_NotImplemented);
    525                 return Py_NotImplemented;
    526         }
    527 
    528         vt = (PyTupleObject *)v;
    529         wt = (PyTupleObject *)w;
    530 
    531         vlen = Py_SIZE(vt);
    532         wlen = Py_SIZE(wt);
    533 
    534         /* Note:  the corresponding code for lists has an "early out" test
    535         * here when op is EQ or NE and the lengths differ.  That pays there,
    536         * but Tim was unable to find any real code where EQ/NE tuple
    537         * compares don't have the same length, so testing for it here would
    538         * have cost without benefit.
    539         */
    540 
    541         /* Search for the first index where items are different.
    542         * Note that because tuples are immutable, it's safe to reuse
    543         * vlen and wlen across the comparison calls.
    544         */
    545         for (i = 0; i < vlen && i < wlen; i++) {
    546                 int k = PyObject_RichCompareBool(vt->ob_item[i],
    547                                                 wt->ob_item[i], Py_EQ);
    548                 if (k < 0)
    549                         return NULL;
    550                 if (!k)
    551                         break;
    552         }
    553 
    554         if (i >= vlen || i >= wlen) {
    555                 /* No more items to compare -- compare sizes */
    556                 int cmp;
    557                 PyObject *res;
    558                 switch (op) {
    559                 case Py_LT: cmp = vlen <  wlen; break;
    560                 case Py_LE: cmp = vlen <= wlen; break;
    561                 case Py_EQ: cmp = vlen == wlen; break;
    562                 case Py_NE: cmp = vlen != wlen; break;
    563                 case Py_GT: cmp = vlen >  wlen; break;
    564                 case Py_GE: cmp = vlen >= wlen; break;
    565                 default: return NULL; /* cannot happen */
    566                 }
    567                 if (cmp)
    568                         res = Py_True;
    569                 else
    570                         res = Py_False;
    571                 Py_INCREF(res);
    572                 return res;
    573         }
    574 
    575         /* We have an item that differs -- shortcuts for EQ/NE */
    576         if (op == Py_EQ) {
    577                 Py_INCREF(Py_False);
    578                 return Py_False;
    579         }
    580         if (op == Py_NE) {
    581                 Py_INCREF(Py_True);
    582                 return Py_True;
    583         }
    584 
    585         /* Compare the final item again using the proper operator */
    586         return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);
     571    PyTupleObject *vt, *wt;
     572    Py_ssize_t i;
     573    Py_ssize_t vlen, wlen;
     574
     575    if (!PyTuple_Check(v) || !PyTuple_Check(w)) {
     576        Py_INCREF(Py_NotImplemented);
     577        return Py_NotImplemented;
     578    }
     579
     580    vt = (PyTupleObject *)v;
     581    wt = (PyTupleObject *)w;
     582
     583    vlen = Py_SIZE(vt);
     584    wlen = Py_SIZE(wt);
     585
     586    /* Note:  the corresponding code for lists has an "early out" test
     587    * here when op is EQ or NE and the lengths differ.  That pays there,
     588    * but Tim was unable to find any real code where EQ/NE tuple
     589    * compares don't have the same length, so testing for it here would
     590    * have cost without benefit.
     591    */
     592
     593    /* Search for the first index where items are different.
     594    * Note that because tuples are immutable, it's safe to reuse
     595    * vlen and wlen across the comparison calls.
     596    */
     597    for (i = 0; i < vlen && i < wlen; i++) {
     598        int k = PyObject_RichCompareBool(vt->ob_item[i],
     599                                        wt->ob_item[i], Py_EQ);
     600        if (k < 0)
     601            return NULL;
     602        if (!k)
     603            break;
     604    }
     605
     606    if (i >= vlen || i >= wlen) {
     607        /* No more items to compare -- compare sizes */
     608        int cmp;
     609        PyObject *res;
     610        switch (op) {
     611        case Py_LT: cmp = vlen <  wlen; break;
     612        case Py_LE: cmp = vlen <= wlen; break;
     613        case Py_EQ: cmp = vlen == wlen; break;
     614        case Py_NE: cmp = vlen != wlen; break;
     615        case Py_GT: cmp = vlen >  wlen; break;
     616        case Py_GE: cmp = vlen >= wlen; break;
     617        default: return NULL; /* cannot happen */
     618        }
     619        if (cmp)
     620            res = Py_True;
     621        else
     622            res = Py_False;
     623        Py_INCREF(res);
     624        return res;
     625    }
     626
     627    /* We have an item that differs -- shortcuts for EQ/NE */
     628    if (op == Py_EQ) {
     629        Py_INCREF(Py_False);
     630        return Py_False;
     631    }
     632    if (op == Py_NE) {
     633        Py_INCREF(Py_True);
     634        return Py_True;
     635    }
     636
     637    /* Compare the final item again using the proper operator */
     638    return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);
    587639}
    588640
    … …  
    593645tuple_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    594646{
    595         PyObject *arg = NULL;
    596         static char *kwlist[] = {"sequence", 0};
    597 
    598         if (type != &PyTuple_Type)
    599                 return tuple_subtype_new(type, args, kwds);
    600         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:tuple", kwlist, &arg))
    601                 return NULL;
    602 
    603         if (arg == NULL)
    604                 return PyTuple_New(0);
    605         else
    606                 return PySequence_Tuple(arg);
     647    PyObject *arg = NULL;
     648    static char *kwlist[] = {"sequence", 0};
     649
     650    if (type != &PyTuple_Type)
     651        return tuple_subtype_new(type, args, kwds);
     652    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:tuple", kwlist, &arg))
     653        return NULL;
     654
     655    if (arg == NULL)
     656        return PyTuple_New(0);
     657    else
     658        return PySequence_Tuple(arg);
    607659}
    608660
    … …  
    610662tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    611663{
    612         PyObject *tmp, *newobj, *item;
    613         Py_ssize_t i, n;
    614 
    615         assert(PyType_IsSubtype(type, &PyTuple_Type));
    616         tmp = tuple_new(&PyTuple_Type, args, kwds);
    617         if (tmp == NULL)
    618                 return NULL;
    619         assert(PyTuple_Check(tmp));
    620         newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
    621         if (newobj == NULL)
    622                 return NULL;
    623         for (i = 0; i < n; i++) {
    624                 item = PyTuple_GET_ITEM(tmp, i);
    625                 Py_INCREF(item);
    626                 PyTuple_SET_ITEM(newobj, i, item);
    627         }
    628         Py_DECREF(tmp);
    629         return newobj;
     664    PyObject *tmp, *newobj, *item;
     665    Py_ssize_t i, n;
     666
     667    assert(PyType_IsSubtype(type, &PyTuple_Type));
     668    tmp = tuple_new(&PyTuple_Type, args, kwds);
     669    if (tmp == NULL)
     670        return NULL;
     671    assert(PyTuple_Check(tmp));
     672    newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
     673    if (newobj == NULL)
     674        return NULL;
     675    for (i = 0; i < n; i++) {
     676        item = PyTuple_GET_ITEM(tmp, i);
     677        Py_INCREF(item);
     678        PyTuple_SET_ITEM(newobj, i, item);
     679    }
     680    Py_DECREF(tmp);
     681    return newobj;
    630682}
    631683
    … …  
    637689
    638690static PySequenceMethods tuple_as_sequence = {
    639         (lenfunc)tuplelength,                   /* sq_length */
    640         (binaryfunc)tupleconcat,                /* sq_concat */
    641         (ssizeargfunc)tuplerepeat,              /* sq_repeat */
    642         (ssizeargfunc)tupleitem,                /* sq_item */
    643         (ssizessizeargfunc)tupleslice,          /* sq_slice */
    644         0,                                      /* sq_ass_item */
    645         0,                                      /* sq_ass_slice */
    646         (objobjproc)tuplecontains,              /* sq_contains */
     691    (lenfunc)tuplelength,                       /* sq_length */
     692    (binaryfunc)tupleconcat,                    /* sq_concat */
     693    (ssizeargfunc)tuplerepeat,                  /* sq_repeat */
     694    (ssizeargfunc)tupleitem,                    /* sq_item */
     695    (ssizessizeargfunc)tupleslice,              /* sq_slice */
     696    0,                                          /* sq_ass_item */
     697    0,                                          /* sq_ass_slice */
     698    (objobjproc)tuplecontains,                  /* sq_contains */
    647699};
    648700
    … …  
    650702tuplesubscript(PyTupleObject* self, PyObject* item)
    651703{
    652         if (PyIndex_Check(item)) {
    653                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
    654                 if (i == -1 && PyErr_Occurred())
    655                         return NULL;
    656                 if (i < 0)
    657                         i += PyTuple_GET_SIZE(self);
    658                 return tupleitem(self, i);
    659         }
    660         else if (PySlice_Check(item)) {
    661                 Py_ssize_t start, stop, step, slicelength, cur, i;
    662                 PyObject* result;
    663                 PyObject* it;
    664                 PyObject **src, **dest;
    665 
    666                 if (PySlice_GetIndicesEx((PySliceObject*)item,
    667                                 PyTuple_GET_SIZE(self),
    668                                 &start, &stop, &step, &slicelength) < 0) {
    669                         return NULL;
    670                 }
    671 
    672                 if (slicelength <= 0) {
    673                         return PyTuple_New(0);
    674                 }
    675                 else if (start == 0 && step == 1 &&
    676                         slicelength == PyTuple_GET_SIZE(self) &&
    677                         PyTuple_CheckExact(self)) {
    678                         Py_INCREF(self);
    679                         return (PyObject *)self;
    680                 }
    681                 else {
    682                         result = PyTuple_New(slicelength);
    683                         if (!result) return NULL;
    684 
    685                         src = self->ob_item;
    686                         dest = ((PyTupleObject *)result)->ob_item;
    687                         for (cur = start, i = 0; i < slicelength;
    688                              cur += step, i++) {
    689                                 it = src[cur];
    690                                 Py_INCREF(it);
    691                                 dest[i] = it;
    692                         }
    693                        
    694                         return result;
    695                 }
    696         }
    697         else {
    698                 PyErr_Format(PyExc_TypeError,
    699                              "tuple indices must be integers, not %.200s",
    700                              Py_TYPE(item)->tp_name);
    701                 return NULL;
    702         }
     704    if (PyIndex_Check(item)) {
     705        Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
     706        if (i == -1 && PyErr_Occurred())
     707            return NULL;
     708        if (i < 0)
     709            i += PyTuple_GET_SIZE(self);
     710        return tupleitem(self, i);
     711    }
     712    else if (PySlice_Check(item)) {
     713        Py_ssize_t start, stop, step, slicelength, cur, i;
     714        PyObject* result;
     715        PyObject* it;
     716        PyObject **src, **dest;
     717
     718        if (PySlice_GetIndicesEx((PySliceObject*)item,
     719                        PyTuple_GET_SIZE(self),
     720                        &start, &stop, &step, &slicelength) < 0) {
     721            return NULL;
     722        }
     723
     724        if (slicelength <= 0) {
     725            return PyTuple_New(0);
     726        }
     727        else if (start == 0 && step == 1 &&
     728                slicelength == PyTuple_GET_SIZE(self) &&
     729                PyTuple_CheckExact(self)) {
     730            Py_INCREF(self);
     731            return (PyObject *)self;
     732        }
     733        else {
     734            result = PyTuple_New(slicelength);
     735            if (!result) return NULL;
     736
     737            src = self->ob_item;
     738            dest = ((PyTupleObject *)result)->ob_item;
     739            for (cur = start, i = 0; i < slicelength;
     740                 cur += step, i++) {
     741                it = src[cur];
     742                Py_INCREF(it);
     743                dest[i] = it;
     744            }
     745
     746            return result;
     747        }
     748    }
     749    else {
     750        PyErr_Format(PyExc_TypeError,
     751                     "tuple indices must be integers, not %.200s",
     752                     Py_TYPE(item)->tp_name);
     753        return NULL;
     754    }
    703755}
    704756
    … …  
    706758tuple_getnewargs(PyTupleObject *v)
    707759{
    708         return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
    709        
     760    return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
     761
    710762}
    711763
    … …  
    713765tuple_sizeof(PyTupleObject *self)
    714766{
    715         Py_ssize_t res;
    716 
    717         res = PyTuple_Type.tp_basicsize + Py_SIZE(self) * sizeof(PyObject *);
    718         return PyInt_FromSsize_t(res);
     767    Py_ssize_t res;
     768
     769    res = PyTuple_Type.tp_basicsize + Py_SIZE(self) * sizeof(PyObject *);
     770    return PyInt_FromSsize_t(res);
    719771}
    720772
    … …  
    729781
    730782static PyMethodDef tuple_methods[] = {
    731         {"__getnewargs__",      (PyCFunction)tuple_getnewargs,  METH_NOARGS},
    732         {"__sizeof__",  (PyCFunction)tuple_sizeof, METH_NOARGS, sizeof_doc},
    733         {"index",       (PyCFunction)tupleindex,  METH_VARARGS, index_doc},
    734         {"count",       (PyCFunction)tuplecount,  METH_O, count_doc},
    735         {NULL,          NULL}           /* sentinel */
     783    {"__getnewargs__",          (PyCFunction)tuple_getnewargs,  METH_NOARGS},
     784    {"__sizeof__",      (PyCFunction)tuple_sizeof, METH_NOARGS, sizeof_doc},
     785    {"index",           (PyCFunction)tupleindex,  METH_VARARGS, index_doc},
     786    {"count",           (PyCFunction)tuplecount,  METH_O, count_doc},
     787    {NULL,              NULL}           /* sentinel */
    736788};
    737789
    738790static PyMappingMethods tuple_as_mapping = {
    739         (lenfunc)tuplelength,
    740         (binaryfunc)tuplesubscript,
    741         0
     791    (lenfunc)tuplelength,
     792    (binaryfunc)tuplesubscript,
     793    0
    742794};
    743795
    … …  
    745797
    746798PyTypeObject PyTuple_Type = {
    747         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    748         "tuple",
    749         sizeof(PyTupleObject) - sizeof(PyObject *),
    750         sizeof(PyObject *),
    751         (destructor)tupledealloc,               /* tp_dealloc */
    752         (printfunc)tupleprint,                  /* tp_print */
    753         0,                                      /* tp_getattr */
    754         0,                                      /* tp_setattr */
    755         0,                                      /* tp_compare */
    756         (reprfunc)tuplerepr,                    /* tp_repr */
    757         0,                                      /* tp_as_number */
    758         &tuple_as_sequence,                     /* tp_as_sequence */
    759         &tuple_as_mapping,                      /* tp_as_mapping */
    760         (hashfunc)tuplehash,                    /* tp_hash */
    761         0,                                      /* tp_call */
    762         0,                                      /* tp_str */
    763         PyObject_GenericGetAttr,                /* tp_getattro */
    764         0,                                      /* tp_setattro */
    765         0,                                      /* tp_as_buffer */
    766         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    767                 Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, /* tp_flags */
    768         tuple_doc,                              /* tp_doc */
    769         (traverseproc)tupletraverse,            /* tp_traverse */
    770         0,                                      /* tp_clear */
    771         tuplerichcompare,                       /* tp_richcompare */
    772         0,                                      /* tp_weaklistoffset */
    773         tuple_iter,                             /* tp_iter */
    774         0,                                      /* tp_iternext */
    775         tuple_methods,                          /* tp_methods */
    776         0,                                      /* tp_members */
    777         0,                                      /* tp_getset */
    778         0,                                      /* tp_base */
    779         0,                                      /* tp_dict */
    780         0,                                      /* tp_descr_get */
    781         0,                                      /* tp_descr_set */
    782         0,                                      /* tp_dictoffset */
    783         0,                                      /* tp_init */
    784         0,                                      /* tp_alloc */
    785         tuple_new,                              /* tp_new */
    786         PyObject_GC_Del,                        /* tp_free */
     799    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     800    "tuple",
     801    sizeof(PyTupleObject) - sizeof(PyObject *),
     802    sizeof(PyObject *),
     803    (destructor)tupledealloc,                   /* tp_dealloc */
     804    (printfunc)tupleprint,                      /* tp_print */
     805    0,                                          /* tp_getattr */
     806    0,                                          /* tp_setattr */
     807    0,                                          /* tp_compare */
     808    (reprfunc)tuplerepr,                        /* tp_repr */
     809    0,                                          /* tp_as_number */
     810    &tuple_as_sequence,                         /* tp_as_sequence */
     811    &tuple_as_mapping,                          /* tp_as_mapping */
     812    (hashfunc)tuplehash,                        /* tp_hash */
     813    0,                                          /* tp_call */
     814    0,                                          /* tp_str */
     815    PyObject_GenericGetAttr,                    /* tp_getattro */
     816    0,                                          /* tp_setattro */
     817    0,                                          /* tp_as_buffer */
     818    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
     819        Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, /* tp_flags */
     820    tuple_doc,                                  /* tp_doc */
     821    (traverseproc)tupletraverse,                /* tp_traverse */
     822    0,                                          /* tp_clear */
     823    tuplerichcompare,                           /* tp_richcompare */
     824    0,                                          /* tp_weaklistoffset */
     825    tuple_iter,                                 /* tp_iter */
     826    0,                                          /* tp_iternext */
     827    tuple_methods,                              /* tp_methods */
     828    0,                                          /* tp_members */
     829    0,                                          /* tp_getset */
     830    0,                                          /* tp_base */
     831    0,                                          /* tp_dict */
     832    0,                                          /* tp_descr_get */
     833    0,                                          /* tp_descr_set */
     834    0,                                          /* tp_dictoffset */
     835    0,                                          /* tp_init */
     836    0,                                          /* tp_alloc */
     837    tuple_new,                                  /* tp_new */
     838    PyObject_GC_Del,                            /* tp_free */
    787839};
    788840
    … …  
    797849_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
    798850{
    799         register PyTupleObject *v;
    800         register PyTupleObject *sv;
    801         Py_ssize_t i;
    802         Py_ssize_t oldsize;
    803 
    804         v = (PyTupleObject *) *pv;
    805         if (v == NULL || Py_TYPE(v) != &PyTuple_Type ||
    806             (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {
    807                 *pv = 0;
    808                 Py_XDECREF(v);
    809                 PyErr_BadInternalCall();
    810                 return -1;
    811         }
    812         oldsize = Py_SIZE(v);
    813         if (oldsize == newsize)
    814                 return 0;
    815 
    816         if (oldsize == 0) {
    817                 /* Empty tuples are often shared, so we should never
    818                    resize them in-place even if we do own the only
    819                    (current) reference */
    820                 Py_DECREF(v);
    821                 *pv = PyTuple_New(newsize);
    822                 return *pv == NULL ? -1 : 0;
    823         }
    824 
    825         /* XXX UNREF/NEWREF interface should be more symmetrical */
    826         _Py_DEC_REFTOTAL;
    827         _PyObject_GC_UNTRACK(v);
    828         _Py_ForgetReference((PyObject *) v);
    829         /* DECREF items deleted by shrinkage */
    830         for (i = newsize; i < oldsize; i++) {
    831                 Py_XDECREF(v->ob_item[i]);
    832                 v->ob_item[i] = NULL;
    833         }
    834         sv = PyObject_GC_Resize(PyTupleObject, v, newsize);
    835         if (sv == NULL) {
    836                 *pv = NULL;
    837                 PyObject_GC_Del(v);
    838                 return -1;
    839         }
    840         _Py_NewReference((PyObject *) sv);
    841         /* Zero out items added by growing */
    842         if (newsize > oldsize)
    843                 memset(&sv->ob_item[oldsize], 0,
    844                        sizeof(*sv->ob_item) * (newsize - oldsize));
    845         *pv = (PyObject *) sv;
    846         _PyObject_GC_TRACK(sv);
    847         return 0;
     851    register PyTupleObject *v;
     852    register PyTupleObject *sv;
     853    Py_ssize_t i;
     854    Py_ssize_t oldsize;
     855
     856    v = (PyTupleObject *) *pv;
     857    if (v == NULL || Py_TYPE(v) != &PyTuple_Type ||
     858        (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {
     859        *pv = 0;
     860        Py_XDECREF(v);
     861        PyErr_BadInternalCall();
     862        return -1;
     863    }
     864    oldsize = Py_SIZE(v);
     865    if (oldsize == newsize)
     866        return 0;
     867
     868    if (oldsize == 0) {
     869        /* Empty tuples are often shared, so we should never
     870           resize them in-place even if we do own the only
     871           (current) reference */
     872        Py_DECREF(v);
     873        *pv = PyTuple_New(newsize);
     874        return *pv == NULL ? -1 : 0;
     875    }
     876
     877    /* XXX UNREF/NEWREF interface should be more symmetrical */
     878    _Py_DEC_REFTOTAL;
     879    if (_PyObject_GC_IS_TRACKED(v))
     880        _PyObject_GC_UNTRACK(v);
     881    _Py_ForgetReference((PyObject *) v);
     882    /* DECREF items deleted by shrinkage */
     883    for (i = newsize; i < oldsize; i++) {
     884        Py_XDECREF(v->ob_item[i]);
     885        v->ob_item[i] = NULL;
     886    }
     887    sv = PyObject_GC_Resize(PyTupleObject, v, newsize);
     888    if (sv == NULL) {
     889        *pv = NULL;
     890        PyObject_GC_Del(v);
     891        return -1;
     892    }
     893    _Py_NewReference((PyObject *) sv);
     894    /* Zero out items added by growing */
     895    if (newsize > oldsize)
     896        memset(&sv->ob_item[oldsize], 0,
     897               sizeof(*sv->ob_item) * (newsize - oldsize));
     898    *pv = (PyObject *) sv;
     899    _PyObject_GC_TRACK(sv);
     900    return 0;
    848901}
    849902
    … …  
    851904PyTuple_ClearFreeList(void)
    852905{
    853         int freelist_size = 0;
     906    int freelist_size = 0;
    854907#if PyTuple_MAXSAVESIZE > 0
    855         int i;
    856         for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
    857                 PyTupleObject *p, *q;
    858                 p = free_list[i];
    859                 freelist_size += numfree[i];
    860                 free_list[i] = NULL;
    861                 numfree[i] = 0;
    862                 while (p) {
    863                         q = p;
    864                         p = (PyTupleObject *)(p->ob_item[0]);
    865                         PyObject_GC_Del(q);
    866                 }
    867         }
    868 #endif
    869         return freelist_size;
    870 }
    871        
     908    int i;
     909    for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
     910        PyTupleObject *p, *q;
     911        p = free_list[i];
     912        freelist_size += numfree[i];
     913        free_list[i] = NULL;
     914        numfree[i] = 0;
     915        while (p) {
     916            q = p;
     917            p = (PyTupleObject *)(p->ob_item[0]);
     918            PyObject_GC_Del(q);
     919        }
     920    }
     921#endif
     922    return freelist_size;
     923}
     924
    872925void
    873926PyTuple_Fini(void)
    874927{
    875928#if PyTuple_MAXSAVESIZE > 0
    876         /* empty tuples are used all over the place and applications may
    877          * rely on the fact that an empty tuple is a singleton. */
    878         Py_XDECREF(free_list[0]);
    879         free_list[0] = NULL;
    880 
    881         (void)PyTuple_ClearFreeList();
     929    /* empty tuples are used all over the place and applications may
     930     * rely on the fact that an empty tuple is a singleton. */
     931    Py_XDECREF(free_list[0]);
     932    free_list[0] = NULL;
     933
     934    (void)PyTuple_ClearFreeList();
     935#endif
     936#ifdef SHOW_TRACK_COUNT
     937    show_track();
    882938#endif
    883939}
    … …  
    886942
    887943typedef struct {
    888         PyObject_HEAD
    889         long it_index;
    890         PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
     944    PyObject_HEAD
     945    long it_index;
     946    PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
    891947} tupleiterobject;
    892948
    … …  
    894950tupleiter_dealloc(tupleiterobject *it)
    895951{
    896         _PyObject_GC_UNTRACK(it);
    897         Py_XDECREF(it->it_seq);
    898         PyObject_GC_Del(it);
     952    _PyObject_GC_UNTRACK(it);
     953    Py_XDECREF(it->it_seq);
     954    PyObject_GC_Del(it);
    899955}
    900956
    … …  
    902958tupleiter_traverse(tupleiterobject *it, visitproc visit, void *arg)
    903959{
    904         Py_VISIT(it->it_seq);
    905         return 0;
     960    Py_VISIT(it->it_seq);
     961    return 0;
    906962}
    907963
    … …  
    909965tupleiter_next(tupleiterobject *it)
    910966{
    911         PyTupleObject *seq;
    912         PyObject *item;
    913 
    914         assert(it != NULL);
    915         seq = it->it_seq;
    916         if (seq == NULL)
    917                 return NULL;
    918         assert(PyTuple_Check(seq));
    919 
    920         if (it->it_index < PyTuple_GET_SIZE(seq)) {
    921                 item = PyTuple_GET_ITEM(seq, it->it_index);
    922                 ++it->it_index;
    923                 Py_INCREF(item);
    924                 return item;
    925         }
    926 
    927         Py_DECREF(seq);
    928         it->it_seq = NULL;
    929         return NULL;
     967    PyTupleObject *seq;
     968    PyObject *item;
     969
     970    assert(it != NULL);
     971    seq = it->it_seq;
     972    if (seq == NULL)
     973        return NULL;
     974    assert(PyTuple_Check(seq));
     975
     976    if (it->it_index < PyTuple_GET_SIZE(seq)) {
     977        item = PyTuple_GET_ITEM(seq, it->it_index);
     978        ++it->it_index;
     979        Py_INCREF(item);
     980        return item;
     981    }
     982
     983    Py_DECREF(seq);
     984    it->it_seq = NULL;
     985    return NULL;
    930986}
    931987
    … …  
    933989tupleiter_len(tupleiterobject *it)
    934990{
    935         Py_ssize_t len = 0;
    936         if (it->it_seq)
    937                 len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
    938         return PyInt_FromSsize_t(len);
     991    Py_ssize_t len = 0;
     992    if (it->it_seq)
     993        len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
     994    return PyInt_FromSsize_t(len);
    939995}
    940996
    … …  
    942998
    943999static PyMethodDef tupleiter_methods[] = {
    944         {"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc},
    945         {NULL,          NULL}           /* sentinel */
     1000    {"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc},
     1001    {NULL,              NULL}           /* sentinel */
    9461002};
    9471003
    9481004PyTypeObject PyTupleIter_Type = {
    949         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    950         "tupleiterator",                        /* tp_name */
    951         sizeof(tupleiterobject),                /* tp_basicsize */
    952         0,                                      /* tp_itemsize */
    953         /* methods */
    954         (destructor)tupleiter_dealloc,          /* tp_dealloc */
    955         0,                                      /* tp_print */
    956         0,                                      /* tp_getattr */
    957         0,                                      /* tp_setattr */
    958         0,                                      /* tp_compare */
    959         0,                                      /* tp_repr */
    960         0,                                      /* tp_as_number */
    961         0,                                      /* tp_as_sequence */
    962         0,                                      /* tp_as_mapping */
    963         0,                                      /* tp_hash */
    964         0,                                      /* tp_call */
    965         0,                                      /* tp_str */
    966         PyObject_GenericGetAttr,                /* tp_getattro */
    967         0,                                      /* tp_setattro */
    968         0,                                      /* tp_as_buffer */
    969         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
    970         0,                                      /* tp_doc */
    971         (traverseproc)tupleiter_traverse,       /* tp_traverse */
    972         0,                                      /* tp_clear */
    973         0,                                      /* tp_richcompare */
    974         0,                                      /* tp_weaklistoffset */
    975         PyObject_SelfIter,                      /* tp_iter */
    976         (iternextfunc)tupleiter_next,           /* tp_iternext */
    977         tupleiter_methods,                      /* tp_methods */
    978         0,
     1005    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     1006    "tupleiterator",                            /* tp_name */
     1007    sizeof(tupleiterobject),                    /* tp_basicsize */
     1008    0,                                          /* tp_itemsize */
     1009    /* methods */
     1010    (destructor)tupleiter_dealloc,              /* tp_dealloc */
     1011    0,                                          /* tp_print */
     1012    0,                                          /* tp_getattr */
     1013    0,                                          /* tp_setattr */
     1014    0,                                          /* tp_compare */
     1015    0,                                          /* tp_repr */
     1016    0,                                          /* tp_as_number */
     1017    0,                                          /* tp_as_sequence */
     1018    0,                                          /* tp_as_mapping */
     1019    0,                                          /* tp_hash */
     1020    0,                                          /* tp_call */
     1021    0,                                          /* tp_str */
     1022    PyObject_GenericGetAttr,                    /* tp_getattro */
     1023    0,                                          /* tp_setattro */
     1024    0,                                          /* tp_as_buffer */
     1025    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     1026    0,                                          /* tp_doc */
     1027    (traverseproc)tupleiter_traverse,           /* tp_traverse */
     1028    0,                                          /* tp_clear */
     1029    0,                                          /* tp_richcompare */
     1030    0,                                          /* tp_weaklistoffset */
     1031    PyObject_SelfIter,                          /* tp_iter */
     1032    (iternextfunc)tupleiter_next,               /* tp_iternext */
     1033    tupleiter_methods,                          /* tp_methods */
     1034    0,
    9791035};
    9801036
    … …  
    9821038tuple_iter(PyObject *seq)
    9831039{
    984         tupleiterobject *it;
    985 
    986         if (!PyTuple_Check(seq)) {
    987                 PyErr_BadInternalCall();
    988                 return NULL;
    989         }
    990         it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
    991         if (it == NULL)
    992                 return NULL;
    993         it->it_index = 0;
    994         Py_INCREF(seq);
    995         it->it_seq = (PyTupleObject *)seq;
    996         _PyObject_GC_TRACK(it);
    997         return (PyObject *)it;
    998 }
     1040    tupleiterobject *it;
     1041
     1042    if (!PyTuple_Check(seq)) {
     1043        PyErr_BadInternalCall();
     1044        return NULL;
     1045    }
     1046    it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
     1047    if (it == NULL)
     1048        return NULL;
     1049    it->it_index = 0;
     1050    Py_INCREF(seq);
     1051    it->it_seq = (PyTupleObject *)seq;
     1052    _PyObject_GC_TRACK(it);
     1053    return (PyObject *)it;
     1054}
Note: See TracChangeset for help on using the changeset viewer.