Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Python/marshal.c

    r2 r388  
    1111#include "code.h"
    1212#include "marshal.h"
     13
     14#define ABS(x) ((x) < 0 ? -(x) : (x))
    1315
    1416/* High water mark to determine when the marshalled object is dangerously deep
    … …  
    1820#define MAX_MARSHAL_STACK_DEPTH 2000
    1921
    20 #define TYPE_NULL               '0'
    21 #define TYPE_NONE               'N'
    22 #define TYPE_FALSE              'F'
    23 #define TYPE_TRUE               'T'
    24 #define TYPE_STOPITER           'S'
    25 #define TYPE_ELLIPSIS           '.'
    26 #define TYPE_INT                'i'
    27 #define TYPE_INT64              'I'
    28 #define TYPE_FLOAT              'f'
    29 #define TYPE_BINARY_FLOAT       'g'
    30 #define TYPE_COMPLEX            'x'
    31 #define TYPE_BINARY_COMPLEX     'y'
    32 #define TYPE_LONG               'l'
    33 #define TYPE_STRING             's'
    34 #define TYPE_INTERNED           't'
    35 #define TYPE_STRINGREF          'R'
    36 #define TYPE_TUPLE              '('
    37 #define TYPE_LIST               '['
    38 #define TYPE_DICT               '{'
    39 #define TYPE_CODE               'c'
    40 #define TYPE_UNICODE            'u'
    41 #define TYPE_UNKNOWN            '?'
    42 #define TYPE_SET                '<'
    43 #define TYPE_FROZENSET          '>'
     22#define TYPE_NULL               '0'
     23#define TYPE_NONE               'N'
     24#define TYPE_FALSE              'F'
     25#define TYPE_TRUE               'T'
     26#define TYPE_STOPITER           'S'
     27#define TYPE_ELLIPSIS           '.'
     28#define TYPE_INT                'i'
     29#define TYPE_INT64              'I'
     30#define TYPE_FLOAT              'f'
     31#define TYPE_BINARY_FLOAT       'g'
     32#define TYPE_COMPLEX            'x'
     33#define TYPE_BINARY_COMPLEX     'y'
     34#define TYPE_LONG               'l'
     35#define TYPE_STRING             's'
     36#define TYPE_INTERNED           't'
     37#define TYPE_STRINGREF          'R'
     38#define TYPE_TUPLE              '('
     39#define TYPE_LIST               '['
     40#define TYPE_DICT               '{'
     41#define TYPE_CODE               'c'
     42#define TYPE_UNICODE            'u'
     43#define TYPE_UNKNOWN            '?'
     44#define TYPE_SET                '<'
     45#define TYPE_FROZENSET          '>'
     46
     47#define WFERR_OK 0
     48#define WFERR_UNMARSHALLABLE 1
     49#define WFERR_NESTEDTOODEEP 2
     50#define WFERR_NOMEMORY 3
    4451
    4552typedef struct {
    46         FILE *fp;
    47         int error;
    48         int depth;
    49         /* If fp == NULL, the following are valid: */
    50         PyObject *str;
    51         char *ptr;
    52         char *end;
    53         PyObject *strings; /* dict on marshal, list on unmarshal */
    54         int version;
     53    FILE *fp;
     54    int error;  /* see WFERR_* values */
     55    int depth;
     56    /* If fp == NULL, the following are valid: */
     57    PyObject *str;
     58    char *ptr;
     59    char *end;
     60    PyObject *strings; /* dict on marshal, list on unmarshal */
     61    int version;
    5562} WFILE;
    5663
    5764#define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \
    58                       else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
    59                            else w_more(c, p)
     65                      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
     66                           else w_more(c, p)
    6067
    6168static void
    6269w_more(int c, WFILE *p)
    6370{
    64         Py_ssize_t size, newsize;
    65         if (p->str == NULL)
    66                 return; /* An error already occurred */
    67         size = PyString_Size(p->str);
    68         newsize = size + size + 1024;
    69         if (newsize > 32*1024*1024) {
    70                 newsize = size + (size >> 3);   /* 12.5% overallocation */
    71         }
    72         if (_PyString_Resize(&p->str, newsize) != 0) {
    73                 p->ptr = p->end = NULL;
    74         }
    75         else {
    76                 p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
    77                 p->end =
    78                         PyString_AS_STRING((PyStringObject *)p->str) + newsize;
    79                 *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
    80         }
     71    Py_ssize_t size, newsize;
     72    if (p->str == NULL)
     73        return; /* An error already occurred */
     74    size = PyString_Size(p->str);
     75    newsize = size + size + 1024;
     76    if (newsize > 32*1024*1024) {
     77        newsize = size + (size >> 3);           /* 12.5% overallocation */
     78    }
     79    if (_PyString_Resize(&p->str, newsize) != 0) {
     80        p->ptr = p->end = NULL;
     81    }
     82    else {
     83        p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
     84        p->end =
     85            PyString_AS_STRING((PyStringObject *)p->str) + newsize;
     86        *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
     87    }
    8188}
    8289
    8390static void
    84 w_string(char *s, int n, WFILE *p)
    85 {
    86         if (p->fp != NULL) {
    87                 fwrite(s, 1, n, p->fp);
    88         }
    89         else {
    90                 while (--n >= 0) {
    91                         w_byte(*s, p);
    92                         s++;
    93                 }
    94         }
     91w_string(const char *s, Py_ssize_t n, WFILE *p)
     92{
     93    if (p->fp != NULL) {
     94        fwrite(s, 1, n, p->fp);
     95    }
     96    else {
     97        while (--n >= 0) {
     98            w_byte(*s, p);
     99            s++;
     100        }
     101    }
    95102}
    96103
    … …  
    98105w_short(int x, WFILE *p)
    99106{
    100         w_byte((char)( x      & 0xff), p);
    101         w_byte((char)((x>> 8) & 0xff), p);
     107    w_byte((char)( x      & 0xff), p);
     108    w_byte((char)((x>> 8) & 0xff), p);
    102109}
    103110
    … …  
    105112w_long(long x, WFILE *p)
    106113{
    107         w_byte((char)( x      & 0xff), p);
    108         w_byte((char)((x>> 8) & 0xff), p);
    109         w_byte((char)((x>>16) & 0xff), p);
    110         w_byte((char)((x>>24) & 0xff), p);
     114    w_byte((char)( x      & 0xff), p);
     115    w_byte((char)((x>> 8) & 0xff), p);
     116    w_byte((char)((x>>16) & 0xff), p);
     117    w_byte((char)((x>>24) & 0xff), p);
    111118}
    112119
    … …  
    115122w_long64(long x, WFILE *p)
    116123{
    117         w_long(x, p);
    118         w_long(x>>32, p);
     124    w_long(x, p);
     125    w_long(x>>32, p);
    119126}
    120127#endif
     128
     129#define SIZE32_MAX  0x7FFFFFFF
     130
     131#if SIZEOF_SIZE_T > 4
     132# define W_SIZE(n, p)  do {                     \
     133        if ((n) > SIZE32_MAX) {                 \
     134            (p)->depth--;                       \
     135            (p)->error = WFERR_UNMARSHALLABLE;  \
     136            return;                             \
     137        }                                       \
     138        w_long((long)(n), p);                   \
     139    } while(0)
     140#else
     141# define W_SIZE  w_long
     142#endif
     143
     144static void
     145w_pstring(const char *s, Py_ssize_t n, WFILE *p)
     146{
     147        W_SIZE(n, p);
     148        w_string(s, n, p);
     149}
     150
     151/* We assume that Python longs are stored internally in base some power of
     152   2**15; for the sake of portability we'll always read and write them in base
     153   exactly 2**15. */
     154
     155#define PyLong_MARSHAL_SHIFT 15
     156#define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)
     157#define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)
     158#if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0
     159#error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"
     160#endif
     161#define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)
     162
     163static void
     164w_PyLong(const PyLongObject *ob, WFILE *p)
     165{
     166    Py_ssize_t i, j, n, l;
     167    digit d;
     168
     169    w_byte(TYPE_LONG, p);
     170    if (Py_SIZE(ob) == 0) {
     171        w_long((long)0, p);
     172        return;
     173    }
     174
     175    /* set l to number of base PyLong_MARSHAL_BASE digits */
     176    n = ABS(Py_SIZE(ob));
     177    l = (n-1) * PyLong_MARSHAL_RATIO;
     178    d = ob->ob_digit[n-1];
     179    assert(d != 0); /* a PyLong is always normalized */
     180    do {
     181        d >>= PyLong_MARSHAL_SHIFT;
     182        l++;
     183    } while (d != 0);
     184    if (l > SIZE32_MAX) {
     185        p->depth--;
     186        p->error = WFERR_UNMARSHALLABLE;
     187        return;
     188    }
     189    w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
     190
     191    for (i=0; i < n-1; i++) {
     192        d = ob->ob_digit[i];
     193        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
     194            w_short(d & PyLong_MARSHAL_MASK, p);
     195            d >>= PyLong_MARSHAL_SHIFT;
     196        }
     197        assert (d == 0);
     198    }
     199    d = ob->ob_digit[n-1];
     200    do {
     201        w_short(d & PyLong_MARSHAL_MASK, p);
     202        d >>= PyLong_MARSHAL_SHIFT;
     203    } while (d != 0);
     204}
    121205
    122206static void
    123207w_object(PyObject *v, WFILE *p)
    124208{
    125         Py_ssize_t i, n;
    126 
    127         p->depth++;
    128 
    129         if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
    130                 p->error = 2;
    131         }
    132         else if (v == NULL) {
    133                 w_byte(TYPE_NULL, p);
    134         }
    135         else if (v == Py_None) {
    136                 w_byte(TYPE_NONE, p);
    137         }
    138         else if (v == PyExc_StopIteration) {
    139                 w_byte(TYPE_STOPITER, p);
    140         }
    141         else if (v == Py_Ellipsis) {
    142                 w_byte(TYPE_ELLIPSIS, p);
    143         }
    144         else if (v == Py_False) {
    145                 w_byte(TYPE_FALSE, p);
    146         }
    147         else if (v == Py_True) {
    148                 w_byte(TYPE_TRUE, p);
    149         }
    150         else if (PyInt_CheckExact(v)) {
    151                 long x = PyInt_AS_LONG((PyIntObject *)v);
     209    Py_ssize_t i, n;
     210
     211    p->depth++;
     212
     213    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
     214        p->error = WFERR_NESTEDTOODEEP;
     215    }
     216    else if (v == NULL) {
     217        w_byte(TYPE_NULL, p);
     218    }
     219    else if (v == Py_None) {
     220        w_byte(TYPE_NONE, p);
     221    }
     222    else if (v == PyExc_StopIteration) {
     223        w_byte(TYPE_STOPITER, p);
     224    }
     225    else if (v == Py_Ellipsis) {
     226        w_byte(TYPE_ELLIPSIS, p);
     227    }
     228    else if (v == Py_False) {
     229        w_byte(TYPE_FALSE, p);
     230    }
     231    else if (v == Py_True) {
     232        w_byte(TYPE_TRUE, p);
     233    }
     234    else if (PyInt_CheckExact(v)) {
     235        long x = PyInt_AS_LONG((PyIntObject *)v);
    152236#if SIZEOF_LONG > 4
    153                 long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
    154                 if (y && y != -1) {
    155                         w_byte(TYPE_INT64, p);
    156                         w_long64(x, p);
    157                 }
    158                 else
     237        long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
     238        if (y && y != -1) {
     239            w_byte(TYPE_INT64, p);
     240            w_long64(x, p);
     241        }
     242        else
    159243#endif
    160                         {
    161                         w_byte(TYPE_INT, p);
    162                         w_long(x, p);
    163                 }
    164         }
    165         else if (PyLong_CheckExact(v)) {
    166                 PyLongObject *ob = (PyLongObject *)v;
    167                 w_byte(TYPE_LONG, p);
    168                 n = ob->ob_size;
    169                 w_long((long)n, p);
    170                 if (n < 0)
    171                         n = -n;
    172                 for (i = 0; i < n; i++)
    173                         w_short(ob->ob_digit[i], p);
    174         }
    175         else if (PyFloat_CheckExact(v)) {
    176                 if (p->version > 1) {
    177                         unsigned char buf[8];
    178                         if (_PyFloat_Pack8(PyFloat_AsDouble(v),
    179                                            buf, 1) < 0) {
    180                                 p->error = 1;
    181                                 return;
    182                         }
    183                         w_byte(TYPE_BINARY_FLOAT, p);
    184                         w_string((char*)buf, 8, p);
    185                 }
    186                 else {
    187                         char buf[256]; /* Plenty to format any double */
    188                         PyFloat_AsReprString(buf, (PyFloatObject *)v);
    189                         n = strlen(buf);
    190                         w_byte(TYPE_FLOAT, p);
    191                         w_byte((int)n, p);
    192                         w_string(buf, (int)n, p);
    193                 }
    194         }
     244            {
     245            w_byte(TYPE_INT, p);
     246            w_long(x, p);
     247        }
     248    }
     249    else if (PyLong_CheckExact(v)) {
     250        PyLongObject *ob = (PyLongObject *)v;
     251        w_PyLong(ob, p);
     252    }
     253    else if (PyFloat_CheckExact(v)) {
     254        if (p->version > 1) {
     255            unsigned char buf[8];
     256            if (_PyFloat_Pack8(PyFloat_AsDouble(v),
     257                               buf, 1) < 0) {
     258                p->error = WFERR_UNMARSHALLABLE;
     259                return;
     260            }
     261            w_byte(TYPE_BINARY_FLOAT, p);
     262            w_string((char*)buf, 8, p);
     263        }
     264        else {
     265            char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
     266                                              'g', 17, 0, NULL);
     267            if (!buf) {
     268                p->error = WFERR_NOMEMORY;
     269                return;
     270            }
     271            n = strlen(buf);
     272            w_byte(TYPE_FLOAT, p);
     273            w_byte((int)n, p);
     274            w_string(buf, n, p);
     275            PyMem_Free(buf);
     276        }
     277    }
    195278#ifndef WITHOUT_COMPLEX
    196         else if (PyComplex_CheckExact(v)) {
    197                 if (p->version > 1) {
    198                         unsigned char buf[8];
    199                         if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
    200                                            buf, 1) < 0) {
    201                                 p->error = 1;
    202                                 return;
    203                         }
    204                         w_byte(TYPE_BINARY_COMPLEX, p);
    205                         w_string((char*)buf, 8, p);
    206                         if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),
    207                                            buf, 1) < 0) {
    208                                 p->error = 1;
    209                                 return;
    210                         }
    211                         w_string((char*)buf, 8, p);
    212                 }
    213                 else {
    214                         char buf[256]; /* Plenty to format any double */
    215                         PyFloatObject *temp;
    216                         w_byte(TYPE_COMPLEX, p);
    217                         temp = (PyFloatObject*)PyFloat_FromDouble(
    218                                 PyComplex_RealAsDouble(v));
    219                         if (!temp) {
    220                                 p->error = 1;
    221                                 return;
    222                         }
    223                         PyFloat_AsReprString(buf, temp);
    224                         Py_DECREF(temp);
    225                         n = strlen(buf);
    226                         w_byte((int)n, p);
    227                         w_string(buf, (int)n, p);
    228                         temp = (PyFloatObject*)PyFloat_FromDouble(
    229                                 PyComplex_ImagAsDouble(v));
    230                         if (!temp) {
    231                                 p->error = 1;
    232                                 return;
    233                         }
    234                         PyFloat_AsReprString(buf, temp);
    235                         Py_DECREF(temp);
    236                         n = strlen(buf);
    237                         w_byte((int)n, p);
    238                         w_string(buf, (int)n, p);
    239                 }
    240         }
     279    else if (PyComplex_CheckExact(v)) {
     280        if (p->version > 1) {
     281            unsigned char buf[8];
     282            if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
     283                               buf, 1) < 0) {
     284                p->error = WFERR_UNMARSHALLABLE;
     285                return;
     286            }
     287            w_byte(TYPE_BINARY_COMPLEX, p);
     288            w_string((char*)buf, 8, p);
     289            if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),
     290                               buf, 1) < 0) {
     291                p->error = WFERR_UNMARSHALLABLE;
     292                return;
     293            }
     294            w_string((char*)buf, 8, p);
     295        }
     296        else {
     297            char *buf;
     298            w_byte(TYPE_COMPLEX, p);
     299            buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),
     300                                        'g', 17, 0, NULL);
     301            if (!buf) {
     302                p->error = WFERR_NOMEMORY;
     303                return;
     304            }
     305            n = strlen(buf);
     306            w_byte((int)n, p);
     307            w_string(buf, n, p);
     308            PyMem_Free(buf);
     309            buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),
     310                                        'g', 17, 0, NULL);
     311            if (!buf) {
     312                p->error = WFERR_NOMEMORY;
     313                return;
     314            }
     315            n = strlen(buf);
     316            w_byte((int)n, p);
     317            w_string(buf, n, p);
     318            PyMem_Free(buf);
     319        }
     320    }
    241321#endif
    242         else if (PyString_CheckExact(v)) {
    243                 if (p->strings && PyString_CHECK_INTERNED(v)) {
    244                         PyObject *o = PyDict_GetItem(p->strings, v);
    245                         if (o) {
    246                                 long w = PyInt_AsLong(o);
    247                                 w_byte(TYPE_STRINGREF, p);
    248                                 w_long(w, p);
    249                                 goto exit;
    250                         }
    251                         else {
    252                                 int ok;
    253                                 o = PyInt_FromSsize_t(PyDict_Size(p->strings));
    254                                 ok = o &&
    255                                      PyDict_SetItem(p->strings, v, o) >= 0;
    256                                 Py_XDECREF(o);
    257                                 if (!ok) {
    258                                         p->depth--;
    259                                         p->error = 1;
    260                                         return;
    261                                 }
    262                                 w_byte(TYPE_INTERNED, p);
    263                         }
    264                 }
    265                 else {
    266                         w_byte(TYPE_STRING, p);
    267                 }
    268                 n = PyString_GET_SIZE(v);
    269                 if (n > INT_MAX) {
    270                         /* huge strings are not supported */
    271                         p->depth--;
    272                         p->error = 1;
    273                         return;
    274                 }
    275                 w_long((long)n, p);
    276                 w_string(PyString_AS_STRING(v), (int)n, p);
    277         }
     322    else if (PyString_CheckExact(v)) {
     323        if (p->strings && PyString_CHECK_INTERNED(v)) {
     324            PyObject *o = PyDict_GetItem(p->strings, v);
     325            if (o) {
     326                long w = PyInt_AsLong(o);
     327                w_byte(TYPE_STRINGREF, p);
     328                w_long(w, p);
     329                goto exit;
     330            }
     331            else {
     332                int ok;
     333                o = PyInt_FromSsize_t(PyDict_Size(p->strings));
     334                ok = o &&
     335                     PyDict_SetItem(p->strings, v, o) >= 0;
     336                Py_XDECREF(o);
     337                if (!ok) {
     338                    p->depth--;
     339                    p->error = WFERR_UNMARSHALLABLE;
     340                    return;
     341                }
     342                w_byte(TYPE_INTERNED, p);
     343            }
     344        }
     345        else {
     346            w_byte(TYPE_STRING, p);
     347        }
     348        w_pstring(PyBytes_AS_STRING(v), PyString_GET_SIZE(v), p);
     349    }
    278350#ifdef Py_USING_UNICODE
    279         else if (PyUnicode_CheckExact(v)) {
    280                 PyObject *utf8;
    281                 utf8 = PyUnicode_AsUTF8String(v);
    282                 if (utf8 == NULL) {
    283                         p->depth--;
    284                         p->error = 1;
    285                         return;
    286                 }
    287                 w_byte(TYPE_UNICODE, p);
    288                 n = PyString_GET_SIZE(utf8);
    289                 if (n > INT_MAX) {
    290                         p->depth--;
    291                         p->error = 1;
    292                         return;
    293                 }
    294                 w_long((long)n, p);
    295                 w_string(PyString_AS_STRING(utf8), (int)n, p);
    296                 Py_DECREF(utf8);
    297         }
     351    else if (PyUnicode_CheckExact(v)) {
     352        PyObject *utf8;
     353        utf8 = PyUnicode_AsUTF8String(v);
     354        if (utf8 == NULL) {
     355            p->depth--;
     356            p->error = WFERR_UNMARSHALLABLE;
     357            return;
     358        }
     359        w_byte(TYPE_UNICODE, p);
     360        w_pstring(PyString_AS_STRING(utf8), PyString_GET_SIZE(utf8), p);
     361        Py_DECREF(utf8);
     362    }
    298363#endif
    299         else if (PyTuple_CheckExact(v)) {
    300                 w_byte(TYPE_TUPLE, p);
    301                 n = PyTuple_Size(v);
    302                 w_long((long)n, p);
    303                 for (i = 0; i < n; i++) {
    304                         w_object(PyTuple_GET_ITEM(v, i), p);
    305                 }
    306         }
    307         else if (PyList_CheckExact(v)) {
    308                 w_byte(TYPE_LIST, p);
    309                 n = PyList_GET_SIZE(v);
    310                 w_long((long)n, p);
    311                 for (i = 0; i < n; i++) {
    312                         w_object(PyList_GET_ITEM(v, i), p);
    313                 }
    314         }
    315         else if (PyDict_CheckExact(v)) {
    316                 Py_ssize_t pos;
    317                 PyObject *key, *value;
    318                 w_byte(TYPE_DICT, p);
    319                 /* This one is NULL object terminated! */
    320                 pos = 0;
    321                 while (PyDict_Next(v, &pos, &key, &value)) {
    322                         w_object(key, p);
    323                         w_object(value, p);
    324                 }
    325                 w_object((PyObject *)NULL, p);
    326         }
    327         else if (PyAnySet_CheckExact(v)) {
    328                 PyObject *value, *it;
    329 
    330                 if (PyObject_TypeCheck(v, &PySet_Type))
    331                         w_byte(TYPE_SET, p);
    332                 else
    333                         w_byte(TYPE_FROZENSET, p);
    334                 n = PyObject_Size(v);
    335                 if (n == -1) {
    336                         p->depth--;
    337                         p->error = 1;
    338                         return;
    339                 }
    340                 w_long((long)n, p);
    341                 it = PyObject_GetIter(v);
    342                 if (it == NULL) {
    343                         p->depth--;
    344                         p->error = 1;
    345                         return;
    346                 }
    347                 while ((value = PyIter_Next(it)) != NULL) {
    348                         w_object(value, p);
    349                         Py_DECREF(value);
    350                 }
    351                 Py_DECREF(it);
    352                 if (PyErr_Occurred()) {
    353                         p->depth--;
    354                         p->error = 1;
    355                         return;
    356                 }
    357         }
    358         else if (PyCode_Check(v)) {
    359                 PyCodeObject *co = (PyCodeObject *)v;
    360                 w_byte(TYPE_CODE, p);
    361                 w_long(co->co_argcount, p);
    362                 w_long(co->co_nlocals, p);
    363                 w_long(co->co_stacksize, p);
    364                 w_long(co->co_flags, p);
    365                 w_object(co->co_code, p);
    366                 w_object(co->co_consts, p);
    367                 w_object(co->co_names, p);
    368                 w_object(co->co_varnames, p);
    369                 w_object(co->co_freevars, p);
    370                 w_object(co->co_cellvars, p);
    371                 w_object(co->co_filename, p);
    372                 w_object(co->co_name, p);
    373                 w_long(co->co_firstlineno, p);
    374                 w_object(co->co_lnotab, p);
    375         }
    376         else if (PyObject_CheckReadBuffer(v)) {
    377                 /* Write unknown buffer-style objects as a string */
    378                 char *s;
    379                 PyBufferProcs *pb = v->ob_type->tp_as_buffer;
    380                 w_byte(TYPE_STRING, p);
    381                 n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
    382                 if (n > INT_MAX) {
    383                         p->depth--;
    384                         p->error = 1;
    385                         return;
    386                 }
    387                 w_long((long)n, p);
    388                 w_string(s, (int)n, p);
    389         }
    390         else {
    391                 w_byte(TYPE_UNKNOWN, p);
    392                 p->error = 1;
    393         }
     364    else if (PyTuple_CheckExact(v)) {
     365        w_byte(TYPE_TUPLE, p);
     366        n = PyTuple_Size(v);
     367        W_SIZE(n, p);
     368        for (i = 0; i < n; i++) {
     369            w_object(PyTuple_GET_ITEM(v, i), p);
     370        }
     371    }
     372    else if (PyList_CheckExact(v)) {
     373        w_byte(TYPE_LIST, p);
     374        n = PyList_GET_SIZE(v);
     375        W_SIZE(n, p);
     376        for (i = 0; i < n; i++) {
     377            w_object(PyList_GET_ITEM(v, i), p);
     378        }
     379    }
     380    else if (PyDict_CheckExact(v)) {
     381        Py_ssize_t pos;
     382        PyObject *key, *value;
     383        w_byte(TYPE_DICT, p);
     384        /* This one is NULL object terminated! */
     385        pos = 0;
     386        while (PyDict_Next(v, &pos, &key, &value)) {
     387            w_object(key, p);
     388            w_object(value, p);
     389        }
     390        w_object((PyObject *)NULL, p);
     391    }
     392    else if (PyAnySet_CheckExact(v)) {
     393        PyObject *value, *it;
     394
     395        if (PyObject_TypeCheck(v, &PySet_Type))
     396            w_byte(TYPE_SET, p);
     397        else
     398            w_byte(TYPE_FROZENSET, p);
     399        n = PyObject_Size(v);
     400        if (n == -1) {
     401            p->depth--;
     402            p->error = WFERR_UNMARSHALLABLE;
     403            return;
     404        }
     405        W_SIZE(n, p);
     406        it = PyObject_GetIter(v);
     407        if (it == NULL) {
     408            p->depth--;
     409            p->error = WFERR_UNMARSHALLABLE;
     410            return;
     411        }
     412        while ((value = PyIter_Next(it)) != NULL) {
     413            w_object(value, p);
     414            Py_DECREF(value);
     415        }
     416        Py_DECREF(it);
     417        if (PyErr_Occurred()) {
     418            p->depth--;
     419            p->error = WFERR_UNMARSHALLABLE;
     420            return;
     421        }
     422    }
     423    else if (PyCode_Check(v)) {
     424        PyCodeObject *co = (PyCodeObject *)v;
     425        w_byte(TYPE_CODE, p);
     426        w_long(co->co_argcount, p);
     427        w_long(co->co_nlocals, p);
     428        w_long(co->co_stacksize, p);
     429        w_long(co->co_flags, p);
     430        w_object(co->co_code, p);
     431        w_object(co->co_consts, p);
     432        w_object(co->co_names, p);
     433        w_object(co->co_varnames, p);
     434        w_object(co->co_freevars, p);
     435        w_object(co->co_cellvars, p);
     436        w_object(co->co_filename, p);
     437        w_object(co->co_name, p);
     438        w_long(co->co_firstlineno, p);
     439        w_object(co->co_lnotab, p);
     440    }
     441    else if (PyObject_CheckReadBuffer(v)) {
     442        /* Write unknown buffer-style objects as a string */
     443        char *s;
     444        PyBufferProcs *pb = v->ob_type->tp_as_buffer;
     445        w_byte(TYPE_STRING, p);
     446        n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
     447        w_pstring(s, n, p);
     448    }
     449    else {
     450        w_byte(TYPE_UNKNOWN, p);
     451        p->error = WFERR_UNMARSHALLABLE;
     452    }
    394453   exit:
    395         p->depth--;
     454    p->depth--;
    396455}
    397456
    … …  
    400459PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
    401460{
    402         WFILE wf;
    403         wf.fp = fp;
    404         wf.error = 0;
    405         wf.depth = 0;
    406         wf.strings = NULL;
    407         wf.version = version;
    408         w_long(x, &wf);
     461    WFILE wf;
     462    wf.fp = fp;
     463    wf.error = WFERR_OK;
     464    wf.depth = 0;
     465    wf.strings = NULL;
     466    wf.version = version;
     467    w_long(x, &wf);
    409468}
    410469
    … …  
    412471PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
    413472{
    414         WFILE wf;
    415         wf.fp = fp;
    416         wf.error = 0;
    417         wf.depth = 0;
    418         wf.strings = (version > 0) ? PyDict_New() : NULL;
    419         wf.version = version;
    420         w_object(x, &wf);
    421         Py_XDECREF(wf.strings);
     473    WFILE wf;
     474    wf.fp = fp;
     475    wf.error = WFERR_OK;
     476    wf.depth = 0;
     477    wf.strings = (version > 0) ? PyDict_New() : NULL;
     478    wf.version = version;
     479    w_object(x, &wf);
     480    Py_XDECREF(wf.strings);
    422481}
    423482
    … …  
    428487#define r_byte(p) ((p)->fp ? getc((p)->fp) : rs_byte(p))
    429488
    430 static int
    431 r_string(char *s, int n, RFILE *p)
    432 {
    433         if (p->fp != NULL)
    434                 /* The result fits into int because it must be <=n. */
    435                 return (int)fread(s, 1, n, p->fp);
    436         if (p->end - p->ptr < n)
    437                 n = (int)(p->end - p->ptr);
    438         memcpy(s, p->ptr, n);
    439         p->ptr += n;
    440         return n;
     489static Py_ssize_t
     490r_string(char *s, Py_ssize_t n, RFILE *p)
     491{
     492    if (p->fp != NULL)
     493        /* The result fits into int because it must be <=n. */
     494        return fread(s, 1, n, p->fp);
     495    if (p->end - p->ptr < n)
     496        n = p->end - p->ptr;
     497    memcpy(s, p->ptr, n);
     498    p->ptr += n;
     499    return n;
    441500}
    442501
    … …  
    444503r_short(RFILE *p)
    445504{
    446         register short x;
    447         x = r_byte(p);
    448         x |= r_byte(p) << 8;
    449         /* Sign-extension, in case short greater than 16 bits */
    450         x |= -(x & 0x8000);
    451         return x;
     505    register short x;
     506    x = r_byte(p);
     507    x |= r_byte(p) << 8;
     508    /* Sign-extension, in case short greater than 16 bits */
     509    x |= -(x & 0x8000);
     510    return x;
    452511}
    453512
    … …  
    455514r_long(RFILE *p)
    456515{
    457         register long x;
    458         register FILE *fp = p->fp;
    459         if (fp) {
    460                 x = getc(fp);
    461                 x |= (long)getc(fp) << 8;
    462                 x |= (long)getc(fp) << 16;
    463                 x |= (long)getc(fp) << 24;
    464         }
    465         else {
    466                 x = rs_byte(p);
    467                 x |= (long)rs_byte(p) << 8;
    468                 x |= (long)rs_byte(p) << 16;
    469                 x |= (long)rs_byte(p) << 24;
    470         }
     516    register long x;
     517    register FILE *fp = p->fp;
     518    if (fp) {
     519        x = getc(fp);
     520        x |= (long)getc(fp) << 8;
     521        x |= (long)getc(fp) << 16;
     522        x |= (long)getc(fp) << 24;
     523    }
     524    else {
     525        x = rs_byte(p);
     526        x |= (long)rs_byte(p) << 8;
     527        x |= (long)rs_byte(p) << 16;
     528        x |= (long)rs_byte(p) << 24;
     529    }
    471530#if SIZEOF_LONG > 4
    472         /* Sign extension for 64-bit machines */
    473         x |= -(x & 0x80000000L);
     531    /* Sign extension for 64-bit machines */
     532    x |= -(x & 0x80000000L);
    474533#endif
    475         return x;
     534    return x;
    476535}
    477536
    … …  
    486545r_long64(RFILE *p)
    487546{
    488         long lo4 = r_long(p);
    489         long hi4 = r_long(p);
     547    long lo4 = r_long(p);
     548    long hi4 = r_long(p);
    490549#if SIZEOF_LONG > 4
    491         long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
    492         return PyInt_FromLong(x);
     550    long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
     551    return PyInt_FromLong(x);
    493552#else
    494         unsigned char buf[8];
    495         int one = 1;
    496         int is_little_endian = (int)*(char*)&one;
    497         if (is_little_endian) {
    498                 memcpy(buf, &lo4, 4);
    499                 memcpy(buf+4, &hi4, 4);
    500         }
    501         else {
    502                 memcpy(buf, &hi4, 4);
    503                 memcpy(buf+4, &lo4, 4);
    504         }
    505         return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
     553    unsigned char buf[8];
     554    int one = 1;
     555    int is_little_endian = (int)*(char*)&one;
     556    if (is_little_endian) {
     557        memcpy(buf, &lo4, 4);
     558        memcpy(buf+4, &hi4, 4);
     559    }
     560    else {
     561        memcpy(buf, &hi4, 4);
     562        memcpy(buf+4, &lo4, 4);
     563    }
     564    return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
    506565#endif
    507566}
     567
     568static PyObject *
     569r_PyLong(RFILE *p)
     570{
     571    PyLongObject *ob;
     572    long n, size, i;
     573    int j, md, shorts_in_top_digit;
     574    digit d;
     575
     576    n = r_long(p);
     577    if (n == 0)
     578        return (PyObject *)_PyLong_New(0);
     579    if (n < -SIZE32_MAX || n > SIZE32_MAX) {
     580        PyErr_SetString(PyExc_ValueError,
     581                       "bad marshal data (long size out of range)");
     582        return NULL;
     583    }
     584
     585    size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
     586    shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
     587    ob = _PyLong_New(size);
     588    if (ob == NULL)
     589        return NULL;
     590    Py_SIZE(ob) = n > 0 ? size : -size;
     591
     592    for (i = 0; i < size-1; i++) {
     593        d = 0;
     594        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
     595            md = r_short(p);
     596            if (md < 0 || md > PyLong_MARSHAL_BASE)
     597                goto bad_digit;
     598            d += (digit)md << j*PyLong_MARSHAL_SHIFT;
     599        }
     600        ob->ob_digit[i] = d;
     601    }
     602    d = 0;
     603    for (j=0; j < shorts_in_top_digit; j++) {
     604        md = r_short(p);
     605        if (md < 0 || md > PyLong_MARSHAL_BASE)
     606            goto bad_digit;
     607        /* topmost marshal digit should be nonzero */
     608        if (md == 0 && j == shorts_in_top_digit - 1) {
     609            Py_DECREF(ob);
     610            PyErr_SetString(PyExc_ValueError,
     611                "bad marshal data (unnormalized long data)");
     612            return NULL;
     613        }
     614        d += (digit)md << j*PyLong_MARSHAL_SHIFT;
     615    }
     616    /* top digit should be nonzero, else the resulting PyLong won't be
     617       normalized */
     618    ob->ob_digit[size-1] = d;
     619    return (PyObject *)ob;
     620  bad_digit:
     621    Py_DECREF(ob);
     622    PyErr_SetString(PyExc_ValueError,
     623                    "bad marshal data (digit out of range in long)");
     624    return NULL;
     625}
     626
    508627
    509628static PyObject *
    510629r_object(RFILE *p)
    511630{
    512         /* NULL is a valid return value, it does not necessarily means that
    513            an exception is set. */
    514         PyObject *v, *v2;
    515         long i, n;
    516         int type = r_byte(p);
    517         PyObject *retval;
    518 
    519         p->depth++;
    520 
    521         if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
    522                 p->depth--;
    523                 PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
    524                 return NULL;
    525         }
    526 
    527         switch (type) {
    528 
    529         case EOF:
    530                 PyErr_SetString(PyExc_EOFError,
    531                                 "EOF read where object expected");
    532                 retval = NULL;
    533                 break;
    534 
    535         case TYPE_NULL:
    536                 retval = NULL;
    537                 break;
    538 
    539         case TYPE_NONE:
    540                 Py_INCREF(Py_None);
    541                 retval = Py_None;
    542                 break;
    543 
    544         case TYPE_STOPITER:
    545                 Py_INCREF(PyExc_StopIteration);
    546                 retval = PyExc_StopIteration;
    547                 break;
    548 
    549         case TYPE_ELLIPSIS:
    550                 Py_INCREF(Py_Ellipsis);
    551                 retval = Py_Ellipsis;
    552                 break;
    553 
    554         case TYPE_FALSE:
    555                 Py_INCREF(Py_False);
    556                 retval = Py_False;
    557                 break;
    558 
    559         case TYPE_TRUE:
    560                 Py_INCREF(Py_True);
    561                 retval = Py_True;
    562                 break;
    563 
    564         case TYPE_INT:
    565                 retval = PyInt_FromLong(r_long(p));
    566                 break;
    567 
    568         case TYPE_INT64:
    569                 retval = r_long64(p);
    570                 break;
    571 
    572         case TYPE_LONG:
    573                 {
    574                         int size;
    575                         PyLongObject *ob;
    576                         n = r_long(p);
    577                         if (n < -INT_MAX || n > INT_MAX) {
    578                                 PyErr_SetString(PyExc_ValueError,
    579                                                 "bad marshal data");
    580                                 retval = NULL;
    581                                 break;
    582                         }
    583                         size = n<0 ? -n : n;
    584                         ob = _PyLong_New(size);
    585                         if (ob == NULL) {
    586                                 retval = NULL;
    587                                 break;
    588                         }
    589                         ob->ob_size = n;
    590                         for (i = 0; i < size; i++) {
    591                                 int digit = r_short(p);
    592                                 if (digit < 0 ||
    593                                     (digit == 0 && i == size-1)) {
    594                                         Py_DECREF(ob);
    595                                         PyErr_SetString(PyExc_ValueError,
    596                                                         "bad marshal data");
    597                                         ob = NULL;
    598                                         break;
    599                                 }
    600                                 if (ob != NULL)
    601                                         ob->ob_digit[i] = digit;
    602                         }
    603                         retval = (PyObject *)ob;
    604                         break;
    605                 }
    606 
    607         case TYPE_FLOAT:
    608                 {
    609                         char buf[256];
    610                         double dx;
    611                         n = r_byte(p);
    612                         if (n == EOF || r_string(buf, (int)n, p) != n) {
    613                                 PyErr_SetString(PyExc_EOFError,
    614                                         "EOF read where object expected");
    615                                 retval = NULL;
    616                                 break;
    617                         }
    618                         buf[n] = '\0';
    619                         retval = NULL;
    620                         PyFPE_START_PROTECT("atof", break)
    621                         dx = PyOS_ascii_atof(buf);
    622                         PyFPE_END_PROTECT(dx)
    623                         retval = PyFloat_FromDouble(dx);
    624                         break;
    625                 }
    626 
    627         case TYPE_BINARY_FLOAT:
    628                 {
    629                         unsigned char buf[8];
    630                         double x;
    631                         if (r_string((char*)buf, 8, p) != 8) {
    632                                 PyErr_SetString(PyExc_EOFError,
    633                                         "EOF read where object expected");
    634                                 retval = NULL;
    635                                 break;
    636                         }
    637                         x = _PyFloat_Unpack8(buf, 1);
    638                         if (x == -1.0 && PyErr_Occurred()) {
    639                                 retval = NULL;
    640                                 break;
    641                         }
    642                         retval = PyFloat_FromDouble(x);
    643                         break;
    644                 }
     631    /* NULL is a valid return value, it does not necessarily means that
     632       an exception is set. */
     633    PyObject *v, *v2;
     634    long i, n;
     635    int type = r_byte(p);
     636    PyObject *retval;
     637
     638    p->depth++;
     639
     640    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
     641        p->depth--;
     642        PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
     643        return NULL;
     644    }
     645
     646    switch (type) {
     647
     648    case EOF:
     649        PyErr_SetString(PyExc_EOFError,
     650                        "EOF read where object expected");
     651        retval = NULL;
     652        break;
     653
     654    case TYPE_NULL:
     655        retval = NULL;
     656        break;
     657
     658    case TYPE_NONE:
     659        Py_INCREF(Py_None);
     660        retval = Py_None;
     661        break;
     662
     663    case TYPE_STOPITER:
     664        Py_INCREF(PyExc_StopIteration);
     665        retval = PyExc_StopIteration;
     666        break;
     667
     668    case TYPE_ELLIPSIS:
     669        Py_INCREF(Py_Ellipsis);
     670        retval = Py_Ellipsis;
     671        break;
     672
     673    case TYPE_FALSE:
     674        Py_INCREF(Py_False);
     675        retval = Py_False;
     676        break;
     677
     678    case TYPE_TRUE:
     679        Py_INCREF(Py_True);
     680        retval = Py_True;
     681        break;
     682
     683    case TYPE_INT:
     684        retval = PyInt_FromLong(r_long(p));
     685        break;
     686
     687    case TYPE_INT64:
     688        retval = r_long64(p);
     689        break;
     690
     691    case TYPE_LONG:
     692        retval = r_PyLong(p);
     693        break;
     694
     695    case TYPE_FLOAT:
     696        {
     697            char buf[256];
     698            double dx;
     699            n = r_byte(p);
     700            if (n == EOF || r_string(buf, n, p) != n) {
     701                PyErr_SetString(PyExc_EOFError,
     702                    "EOF read where object expected");
     703                retval = NULL;
     704                break;
     705            }
     706            buf[n] = '\0';
     707            dx = PyOS_string_to_double(buf, NULL, NULL);
     708            if (dx == -1.0 && PyErr_Occurred()) {
     709                retval = NULL;
     710                break;
     711            }
     712            retval = PyFloat_FromDouble(dx);
     713            break;
     714        }
     715
     716    case TYPE_BINARY_FLOAT:
     717        {
     718            unsigned char buf[8];
     719            double x;
     720            if (r_string((char*)buf, 8, p) != 8) {
     721                PyErr_SetString(PyExc_EOFError,
     722                    "EOF read where object expected");
     723                retval = NULL;
     724                break;
     725            }
     726            x = _PyFloat_Unpack8(buf, 1);
     727            if (x == -1.0 && PyErr_Occurred()) {
     728                retval = NULL;
     729                break;
     730            }
     731            retval = PyFloat_FromDouble(x);
     732            break;
     733        }
    645734
    646735#ifndef WITHOUT_COMPLEX
    647         case TYPE_COMPLEX:
    648                 {
    649                         char buf[256];
    650                         Py_complex c;
    651                         n = r_byte(p);
    652                         if (n == EOF || r_string(buf, (int)n, p) != n) {
    653                                 PyErr_SetString(PyExc_EOFError,
    654                                         "EOF read where object expected");
    655                                 retval = NULL;
    656                                 break;
    657                         }
    658                         buf[n] = '\0';
    659                         retval = NULL;
    660                         PyFPE_START_PROTECT("atof", break;)
    661                         c.real = PyOS_ascii_atof(buf);
    662                         PyFPE_END_PROTECT(c)
    663                         n = r_byte(p);
    664                         if (n == EOF || r_string(buf, (int)n, p) != n) {
    665                                 PyErr_SetString(PyExc_EOFError,
    666                                         "EOF read where object expected");
    667                                 retval = NULL;
    668                                 break;
    669                         }
    670                         buf[n] = '\0';
    671                         PyFPE_START_PROTECT("atof", break)
    672                         c.imag = PyOS_ascii_atof(buf);
    673                         PyFPE_END_PROTECT(c)
    674                         retval = PyComplex_FromCComplex(c);
    675                         break;
    676                 }
    677 
    678         case TYPE_BINARY_COMPLEX:
    679                 {
    680                         unsigned char buf[8];
    681                         Py_complex c;
    682                         if (r_string((char*)buf, 8, p) != 8) {
    683                                 PyErr_SetString(PyExc_EOFError,
    684                                         "EOF read where object expected");
    685                                 retval = NULL;
    686                                 break;
    687                         }
    688                         c.real = _PyFloat_Unpack8(buf, 1);
    689                         if (c.real == -1.0 && PyErr_Occurred()) {
    690                                 retval = NULL;
    691                                 break;
    692                         }
    693                         if (r_string((char*)buf, 8, p) != 8) {
    694                                 PyErr_SetString(PyExc_EOFError,
    695                                         "EOF read where object expected");
    696                                 retval = NULL;
    697                                 break;
    698                         }
    699                         c.imag = _PyFloat_Unpack8(buf, 1);
    700                         if (c.imag == -1.0 && PyErr_Occurred()) {
    701                                 retval = NULL;
    702                                 break;
    703                         }
    704                         retval = PyComplex_FromCComplex(c);
    705                         break;
    706                 }
     736    case TYPE_COMPLEX:
     737        {
     738            char buf[256];
     739            Py_complex c;
     740            n = r_byte(p);
     741            if (n == EOF || r_string(buf, n, p) != n) {
     742                PyErr_SetString(PyExc_EOFError,
     743                    "EOF read where object expected");
     744                retval = NULL;
     745                break;
     746            }
     747            buf[n] = '\0';
     748            c.real = PyOS_string_to_double(buf, NULL, NULL);
     749            if (c.real == -1.0 && PyErr_Occurred()) {
     750                retval = NULL;
     751                break;
     752            }
     753            n = r_byte(p);
     754            if (n == EOF || r_string(buf, n, p) != n) {
     755                PyErr_SetString(PyExc_EOFError,
     756                    "EOF read where object expected");
     757                retval = NULL;
     758                break;
     759            }
     760            buf[n] = '\0';
     761            c.imag = PyOS_string_to_double(buf, NULL, NULL);
     762            if (c.imag == -1.0 && PyErr_Occurred()) {
     763                retval = NULL;
     764                break;
     765            }
     766            retval = PyComplex_FromCComplex(c);
     767            break;
     768        }
     769
     770    case TYPE_BINARY_COMPLEX:
     771        {
     772            unsigned char buf[8];
     773            Py_complex c;
     774            if (r_string((char*)buf, 8, p) != 8) {
     775                PyErr_SetString(PyExc_EOFError,
     776                    "EOF read where object expected");
     777                retval = NULL;
     778                break;
     779            }
     780            c.real = _PyFloat_Unpack8(buf, 1);
     781            if (c.real == -1.0 && PyErr_Occurred()) {
     782                retval = NULL;
     783                break;
     784            }
     785            if (r_string((char*)buf, 8, p) != 8) {
     786                PyErr_SetString(PyExc_EOFError,
     787                    "EOF read where object expected");
     788                retval = NULL;
     789                break;
     790            }
     791            c.imag = _PyFloat_Unpack8(buf, 1);
     792            if (c.imag == -1.0 && PyErr_Occurred()) {
     793                retval = NULL;
     794                break;
     795            }
     796            retval = PyComplex_FromCComplex(c);
     797            break;
     798        }
    707799#endif
    708800
    709         case TYPE_INTERNED:
    710         case TYPE_STRING:
    711                 n = r_long(p);
    712                 if (n < 0 || n > INT_MAX) {
    713                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    714                         retval = NULL;
    715                         break;
    716                 }
    717                 v = PyString_FromStringAndSize((char *)NULL, n);
    718                 if (v == NULL) {
    719                         retval = NULL;
    720                         break;
    721                 }
    722                 if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
    723                         Py_DECREF(v);
    724                         PyErr_SetString(PyExc_EOFError,
    725                                         "EOF read where object expected");
    726                         retval = NULL;
    727                         break;
    728                 }
    729                 if (type == TYPE_INTERNED) {
    730                         PyString_InternInPlace(&v);
    731                         if (PyList_Append(p->strings, v) < 0) {
    732                                 retval = NULL;
    733                                 break;
    734                         }
    735                 }
    736                 retval = v;
    737                 break;
    738 
    739         case TYPE_STRINGREF:
    740                 n = r_long(p);
    741                 if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {
    742                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    743                         retval = NULL;
    744                         break;
    745                 }
    746                 v = PyList_GET_ITEM(p->strings, n);
    747                 Py_INCREF(v);
    748                 retval = v;
    749                 break;
     801    case TYPE_INTERNED:
     802    case TYPE_STRING:
     803        n = r_long(p);
     804        if (n < 0 || n > SIZE32_MAX) {
     805            PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
     806            retval = NULL;
     807            break;
     808        }
     809        v = PyString_FromStringAndSize((char *)NULL, n);
     810        if (v == NULL) {
     811            retval = NULL;
     812            break;
     813        }
     814        if (r_string(PyString_AS_STRING(v), n, p) != n) {
     815            Py_DECREF(v);
     816            PyErr_SetString(PyExc_EOFError,
     817                            "EOF read where object expected");
     818            retval = NULL;
     819            break;
     820        }
     821        if (type == TYPE_INTERNED) {
     822            PyString_InternInPlace(&v);
     823            if (PyList_Append(p->strings, v) < 0) {
     824                retval = NULL;
     825                break;
     826            }
     827        }
     828        retval = v;
     829        break;
     830
     831    case TYPE_STRINGREF:
     832        n = r_long(p);
     833        if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {
     834            PyErr_SetString(PyExc_ValueError, "bad marshal data (string ref out of range)");
     835            retval = NULL;
     836            break;
     837        }
     838        v = PyList_GET_ITEM(p->strings, n);
     839        Py_INCREF(v);
     840        retval = v;
     841        break;
    750842
    751843#ifdef Py_USING_UNICODE
    752         case TYPE_UNICODE:
    753             {
    754                 char *buffer;
    755 
    756                 n = r_long(p);
    757                 if (n < 0 || n > INT_MAX) {
    758                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    759                         retval = NULL;
    760                         break;
    761                 }
    762                 buffer = PyMem_NEW(char, n);
    763                 if (buffer == NULL) {
    764                         retval = PyErr_NoMemory();
    765                         break;
    766                 }
    767                 if (r_string(buffer, (int)n, p) != n) {
    768                         PyMem_DEL(buffer);
    769                         PyErr_SetString(PyExc_EOFError,
    770                                 "EOF read where object expected");
    771                         retval = NULL;
    772                         break;
    773                 }
    774                 v = PyUnicode_DecodeUTF8(buffer, n, NULL);
    775                 PyMem_DEL(buffer);
    776                 retval = v;
    777                 break;
    778             }
     844    case TYPE_UNICODE:
     845        {
     846        char *buffer;
     847
     848        n = r_long(p);
     849        if (n < 0 || n > SIZE32_MAX) {
     850            PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");
     851            retval = NULL;
     852            break;
     853        }
     854        buffer = PyMem_NEW(char, n);
     855        if (buffer == NULL) {
     856            retval = PyErr_NoMemory();
     857            break;
     858        }
     859        if (r_string(buffer, n, p) != n) {
     860            PyMem_DEL(buffer);
     861            PyErr_SetString(PyExc_EOFError,
     862                "EOF read where object expected");
     863            retval = NULL;
     864            break;
     865        }
     866        v = PyUnicode_DecodeUTF8(buffer, n, NULL);
     867        PyMem_DEL(buffer);
     868        retval = v;
     869        break;
     870        }
    779871#endif
    780872
    781         case TYPE_TUPLE:
    782                 n = r_long(p);
    783                 if (n < 0 || n > INT_MAX) {
    784                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    785                         retval = NULL;
    786                         break;
    787                 }
    788                 v = PyTuple_New((int)n);
    789                 if (v == NULL) {
    790                         retval = NULL;
    791                         break;
    792                 }
    793                 for (i = 0; i < n; i++) {
    794                         v2 = r_object(p);
    795                         if ( v2 == NULL ) {
    796                                 if (!PyErr_Occurred())
    797                                         PyErr_SetString(PyExc_TypeError,
    798                                                 "NULL object in marshal data");
    799                                 Py_DECREF(v);
    800                                 v = NULL;
    801                                 break;
    802                         }
    803                         PyTuple_SET_ITEM(v, (int)i, v2);
    804                 }
    805                 retval = v;
    806                 break;
    807 
    808         case TYPE_LIST:
    809                 n = r_long(p);
    810                 if (n < 0 || n > INT_MAX) {
    811                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    812                         retval = NULL;
    813                         break;
    814                 }
    815                 v = PyList_New((int)n);
    816                 if (v == NULL) {
    817                         retval = NULL;
    818                         break;
    819                 }
    820                 for (i = 0; i < n; i++) {
    821                         v2 = r_object(p);
    822                         if ( v2 == NULL ) {
    823                                 if (!PyErr_Occurred())
    824                                         PyErr_SetString(PyExc_TypeError,
    825                                                 "NULL object in marshal data");
    826                                 Py_DECREF(v);
    827                                 v = NULL;
    828                                 break;
    829                         }
    830                         PyList_SET_ITEM(v, (int)i, v2);
    831                 }
    832                 retval = v;
    833                 break;
    834 
    835         case TYPE_DICT:
    836                 v = PyDict_New();
    837                 if (v == NULL) {
    838                         retval = NULL;
    839                         break;
    840                 }
    841                 for (;;) {
    842                         PyObject *key, *val;
    843                         key = r_object(p);
    844                         if (key == NULL)
    845                                 break;
    846                         val = r_object(p);
    847                         if (val != NULL)
    848                                 PyDict_SetItem(v, key, val);
    849                         Py_DECREF(key);
    850                         Py_XDECREF(val);
    851                 }
    852                 if (PyErr_Occurred()) {
    853                         Py_DECREF(v);
    854                         v = NULL;
    855                 }
    856                 retval = v;
    857                 break;
    858 
    859         case TYPE_SET:
    860         case TYPE_FROZENSET:
    861                 n = r_long(p);
    862                 if (n < 0 || n > INT_MAX) {
    863                         PyErr_SetString(PyExc_ValueError, "bad marshal data");
    864                         retval = NULL;
    865                         break;
    866                 }
    867                 v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
    868                 if (v == NULL) {
    869                         retval = NULL;
    870                         break;
    871                 }
    872                 for (i = 0; i < n; i++) {
    873                         v2 = r_object(p);
    874                         if ( v2 == NULL ) {
    875                                 if (!PyErr_Occurred())
    876                                         PyErr_SetString(PyExc_TypeError,
    877                                                 "NULL object in marshal data");
    878                                 Py_DECREF(v);
    879                                 v = NULL;
    880                                 break;
    881                         }
    882                         if (PySet_Add(v, v2) == -1) {
    883                                 Py_DECREF(v);
    884                                 Py_DECREF(v2);
    885                                 v = NULL;
    886                                 break;
    887                         }
    888                         Py_DECREF(v2);
    889                 }
    890                 retval = v;
    891                 break;
    892 
    893         case TYPE_CODE:
    894                 if (PyEval_GetRestricted()) {
    895                         PyErr_SetString(PyExc_RuntimeError,
    896                                 "cannot unmarshal code objects in "
    897                                 "restricted execution mode");
    898                         retval = NULL;
    899                         break;
    900                 }
    901                 else {
    902                         int argcount;
    903                         int nlocals;
    904                         int stacksize;
    905                         int flags;
    906                         PyObject *code = NULL;
    907                         PyObject *consts = NULL;
    908                         PyObject *names = NULL;
    909                         PyObject *varnames = NULL;
    910                         PyObject *freevars = NULL;
    911                         PyObject *cellvars = NULL;
    912                         PyObject *filename = NULL;
    913                         PyObject *name = NULL;
    914                         int firstlineno;
    915                         PyObject *lnotab = NULL;
    916                        
    917                         v = NULL;
    918 
    919                         /* XXX ignore long->int overflows for now */
    920                         argcount = (int)r_long(p);
    921                         nlocals = (int)r_long(p);
    922                         stacksize = (int)r_long(p);
    923                         flags = (int)r_long(p);
    924                         code = r_object(p);
    925                         if (code == NULL)
    926                                 goto code_error;
    927                         consts = r_object(p);
    928                         if (consts == NULL)
    929                                 goto code_error;
    930                         names = r_object(p);
    931                         if (names == NULL)
    932                                 goto code_error;
    933                         varnames = r_object(p);
    934                         if (varnames == NULL)
    935                                 goto code_error;
    936                         freevars = r_object(p);
    937                         if (freevars == NULL)
    938                                 goto code_error;
    939                         cellvars = r_object(p);
    940                         if (cellvars == NULL)
    941                                 goto code_error;
    942                         filename = r_object(p);
    943                         if (filename == NULL)
    944                                 goto code_error;
    945                         name = r_object(p);
    946                         if (name == NULL)
    947                                 goto code_error;
    948                         firstlineno = (int)r_long(p);
    949                         lnotab = r_object(p);
    950                         if (lnotab == NULL)
    951                                 goto code_error;
    952 
    953                         v = (PyObject *) PyCode_New(
    954                                         argcount, nlocals, stacksize, flags,
    955                                         code, consts, names, varnames,
    956                                         freevars, cellvars, filename, name,
    957                                         firstlineno, lnotab);
    958 
    959                   code_error:
    960                         Py_XDECREF(code);
    961                         Py_XDECREF(consts);
    962                         Py_XDECREF(names);
    963                         Py_XDECREF(varnames);
    964                         Py_XDECREF(freevars);
    965                         Py_XDECREF(cellvars);
    966                         Py_XDECREF(filename);
    967                         Py_XDECREF(name);
    968                         Py_XDECREF(lnotab);
    969 
    970                 }
    971                 retval = v;
    972                 break;
    973 
    974         default:
    975                 /* Bogus data got written, which isn't ideal.
    976                    This will let you keep working and recover. */
    977                 PyErr_SetString(PyExc_ValueError, "bad marshal data");
    978                 retval = NULL;
    979                 break;
    980 
    981         }
    982         p->depth--;
    983         return retval;
     873    case TYPE_TUPLE:
     874        n = r_long(p);
     875        if (n < 0 || n > SIZE32_MAX) {
     876            PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
     877            retval = NULL;
     878            break;
     879        }
     880        v = PyTuple_New(n);
     881        if (v == NULL) {
     882            retval = NULL;
     883            break;
     884        }
     885        for (i = 0; i < n; i++) {
     886            v2 = r_object(p);
     887            if ( v2 == NULL ) {
     888                if (!PyErr_Occurred())
     889                    PyErr_SetString(PyExc_TypeError,
     890                        "NULL object in marshal data for tuple");
     891                Py_DECREF(v);
     892                v = NULL;
     893                break;
     894            }
     895            PyTuple_SET_ITEM(v, i, v2);
     896        }
     897        retval = v;
     898        break;
     899
     900    case TYPE_LIST:
     901        n = r_long(p);
     902        if (n < 0 || n > SIZE32_MAX) {
     903            PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
     904            retval = NULL;
     905            break;
     906        }
     907        v = PyList_New(n);
     908        if (v == NULL) {
     909            retval = NULL;
     910            break;
     911        }
     912        for (i = 0; i < n; i++) {
     913            v2 = r_object(p);
     914            if ( v2 == NULL ) {
     915                if (!PyErr_Occurred())
     916                    PyErr_SetString(PyExc_TypeError,
     917                        "NULL object in marshal data for list");
     918                Py_DECREF(v);
     919                v = NULL;
     920                break;
     921            }
     922            PyList_SET_ITEM(v, i, v2);
     923        }
     924        retval = v;
     925        break;
     926
     927    case TYPE_DICT:
     928        v = PyDict_New();
     929        if (v == NULL) {
     930            retval = NULL;
     931            break;
     932        }
     933        for (;;) {
     934            PyObject *key, *val;
     935            key = r_object(p);
     936            if (key == NULL)
     937                break;
     938            val = r_object(p);
     939            if (val != NULL)
     940                PyDict_SetItem(v, key, val);
     941            Py_DECREF(key);
     942            Py_XDECREF(val);
     943        }
     944        if (PyErr_Occurred()) {
     945            Py_DECREF(v);
     946            v = NULL;
     947        }
     948        retval = v;
     949        break;
     950
     951    case TYPE_SET:
     952    case TYPE_FROZENSET:
     953        n = r_long(p);
     954        if (n < 0 || n > SIZE32_MAX) {
     955            PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
     956            retval = NULL;
     957            break;
     958        }
     959        v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
     960        if (v == NULL) {
     961            retval = NULL;
     962            break;
     963        }
     964        for (i = 0; i < n; i++) {
     965            v2 = r_object(p);
     966            if ( v2 == NULL ) {
     967                if (!PyErr_Occurred())
     968                    PyErr_SetString(PyExc_TypeError,
     969                        "NULL object in marshal data for set");
     970                Py_DECREF(v);
     971                v = NULL;
     972                break;
     973            }
     974            if (PySet_Add(v, v2) == -1) {
     975                Py_DECREF(v);
     976                Py_DECREF(v2);
     977                v = NULL;
     978                break;
     979            }
     980            Py_DECREF(v2);
     981        }
     982        retval = v;
     983        break;
     984
     985    case TYPE_CODE:
     986        if (PyEval_GetRestricted()) {
     987            PyErr_SetString(PyExc_RuntimeError,
     988                "cannot unmarshal code objects in "
     989                "restricted execution mode");
     990            retval = NULL;
     991            break;
     992        }
     993        else {
     994            int argcount;
     995            int nlocals;
     996            int stacksize;
     997            int flags;
     998            PyObject *code = NULL;
     999            PyObject *consts = NULL;
     1000            PyObject *names = NULL;
     1001            PyObject *varnames = NULL;
     1002            PyObject *freevars = NULL;
     1003            PyObject *cellvars = NULL;
     1004            PyObject *filename = NULL;
     1005            PyObject *name = NULL;
     1006            int firstlineno;
     1007            PyObject *lnotab = NULL;
     1008
     1009            v = NULL;
     1010
     1011            /* XXX ignore long->int overflows for now */
     1012            argcount = (int)r_long(p);
     1013            nlocals = (int)r_long(p);
     1014            stacksize = (int)r_long(p);
     1015            flags = (int)r_long(p);
     1016            code = r_object(p);
     1017            if (code == NULL)
     1018                goto code_error;
     1019            consts = r_object(p);
     1020            if (consts == NULL)
     1021                goto code_error;
     1022            names = r_object(p);
     1023            if (names == NULL)
     1024                goto code_error;
     1025            varnames = r_object(p);
     1026            if (varnames == NULL)
     1027                goto code_error;
     1028            freevars = r_object(p);
     1029            if (freevars == NULL)
     1030                goto code_error;
     1031            cellvars = r_object(p);
     1032            if (cellvars == NULL)
     1033                goto code_error;
     1034            filename = r_object(p);
     1035            if (filename == NULL)
     1036                goto code_error;
     1037            name = r_object(p);
     1038            if (name == NULL)
     1039                goto code_error;
     1040            firstlineno = (int)r_long(p);
     1041            lnotab = r_object(p);
     1042            if (lnotab == NULL)
     1043                goto code_error;
     1044
     1045            v = (PyObject *) PyCode_New(
     1046                            argcount, nlocals, stacksize, flags,
     1047                            code, consts, names, varnames,
     1048                            freevars, cellvars, filename, name,
     1049                            firstlineno, lnotab);
     1050
     1051          code_error:
     1052            Py_XDECREF(code);
     1053            Py_XDECREF(consts);
     1054            Py_XDECREF(names);
     1055            Py_XDECREF(varnames);
     1056            Py_XDECREF(freevars);
     1057            Py_XDECREF(cellvars);
     1058            Py_XDECREF(filename);
     1059            Py_XDECREF(name);
     1060            Py_XDECREF(lnotab);
     1061
     1062        }
     1063        retval = v;
     1064        break;
     1065
     1066    default:
     1067        /* Bogus data got written, which isn't ideal.
     1068           This will let you keep working and recover. */
     1069        PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
     1070        retval = NULL;
     1071        break;
     1072
     1073    }
     1074    p->depth--;
     1075    return retval;
    9841076}
    9851077
    … …  
    9871079read_object(RFILE *p)
    9881080{
    989         PyObject *v;
    990         if (PyErr_Occurred()) {
    991                 fprintf(stderr, "XXX readobject called with exception set\n");
    992                 return NULL;
    993         }
    994         v = r_object(p);
    995         if (v == NULL && !PyErr_Occurred())
    996                 PyErr_SetString(PyExc_TypeError, "NULL object in marshal data");
    997         return v;
     1081    PyObject *v;
     1082    if (PyErr_Occurred()) {
     1083        fprintf(stderr, "XXX readobject called with exception set\n");
     1084        return NULL;
     1085    }
     1086    v = r_object(p);
     1087    if (v == NULL && !PyErr_Occurred())
     1088        PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
     1089    return v;
    9981090}
    9991091
    … …  
    10011093PyMarshal_ReadShortFromFile(FILE *fp)
    10021094{
    1003         RFILE rf;
    1004         assert(fp);
    1005         rf.fp = fp;
    1006         rf.strings = NULL;
    1007         rf.end = rf.ptr = NULL;
    1008         return r_short(&rf);
     1095    RFILE rf;
     1096    assert(fp);
     1097    rf.fp = fp;
     1098    rf.strings = NULL;
     1099    rf.end = rf.ptr = NULL;
     1100    return r_short(&rf);
    10091101}
    10101102
    … …  
    10121104PyMarshal_ReadLongFromFile(FILE *fp)
    10131105{
    1014         RFILE rf;
    1015         rf.fp = fp;
    1016         rf.strings = NULL;
    1017         rf.ptr = rf.end = NULL;
    1018         return r_long(&rf);
     1106    RFILE rf;
     1107    rf.fp = fp;
     1108    rf.strings = NULL;
     1109    rf.ptr = rf.end = NULL;
     1110    return r_long(&rf);
    10191111}
    10201112
    … …  
    10241116getfilesize(FILE *fp)
    10251117{
    1026         struct stat st;
    1027         if (fstat(fileno(fp), &st) != 0)
    1028                 return -1;
    1029         else
    1030                 return st.st_size;
     1118    struct stat st;
     1119    if (fstat(fileno(fp), &st) != 0)
     1120        return -1;
     1121    else
     1122        return st.st_size;
    10311123}
    10321124#endif
    … …  
    10411133PyMarshal_ReadLastObjectFromFile(FILE *fp)
    10421134{
    1043 /* 75% of 2.1's .pyc files can exploit SMALL_FILE_LIMIT.
    1044  * REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc.
    1045  */
    1046 #define SMALL_FILE_LIMIT (1L << 14)
     1135/* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */
    10471136#define REASONABLE_FILE_LIMIT (1L << 18)
    10481137#ifdef HAVE_FSTAT
    1049         off_t filesize;
     1138    off_t filesize;
     1139    filesize = getfilesize(fp);
     1140    if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
     1141        char* pBuf = (char *)PyMem_MALLOC(filesize);
     1142        if (pBuf != NULL) {
     1143            size_t n = fread(pBuf, 1, (size_t)filesize, fp);
     1144            PyObject* v = PyMarshal_ReadObjectFromString(pBuf, n);
     1145            PyMem_FREE(pBuf);
     1146            return v;
     1147        }
     1148
     1149    }
    10501150#endif
    1051 #ifdef HAVE_FSTAT
    1052         filesize = getfilesize(fp);
    1053         if (filesize > 0) {
    1054                 char buf[SMALL_FILE_LIMIT];
    1055                 char* pBuf = NULL;
    1056                 if (filesize <= SMALL_FILE_LIMIT)
    1057                         pBuf = buf;
    1058                 else if (filesize <= REASONABLE_FILE_LIMIT)
    1059                         pBuf = (char *)PyMem_MALLOC(filesize);
    1060                 if (pBuf != NULL) {
    1061                         PyObject* v;
    1062                         size_t n;
    1063                         /* filesize must fit into an int, because it
    1064                            is smaller than REASONABLE_FILE_LIMIT */
    1065                         n = fread(pBuf, 1, (int)filesize, fp);
    1066                         v = PyMarshal_ReadObjectFromString(pBuf, n);
    1067                         if (pBuf != buf)
    1068                                 PyMem_FREE(pBuf);
    1069                         return v;
    1070                 }
    1071 
    1072         }
    1073 #endif
    1074         /* We don't have fstat, or we do but the file is larger than
    1075          * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
    1076          */
    1077         return PyMarshal_ReadObjectFromFile(fp);
    1078 
    1079 #undef SMALL_FILE_LIMIT
     1151    /* We don't have fstat, or we do but the file is larger than
     1152     * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
     1153     */
     1154    return PyMarshal_ReadObjectFromFile(fp);
     1155
    10801156#undef REASONABLE_FILE_LIMIT
    10811157}
    … …  
    10841160PyMarshal_ReadObjectFromFile(FILE *fp)
    10851161{
    1086         RFILE rf;
    1087         PyObject *result;
    1088         rf.fp = fp;
    1089         rf.strings = PyList_New(0);
    1090         rf.depth = 0;
    1091         rf.ptr = rf.end = NULL;
    1092         result = r_object(&rf);
    1093         Py_DECREF(rf.strings);
    1094         return result;
     1162    RFILE rf;
     1163    PyObject *result;
     1164    rf.fp = fp;
     1165    rf.strings = PyList_New(0);
     1166    rf.depth = 0;
     1167    rf.ptr = rf.end = NULL;
     1168    result = r_object(&rf);
     1169    Py_DECREF(rf.strings);
     1170    return result;
    10951171}
    10961172
    … …  
    10981174PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len)
    10991175{
    1100         RFILE rf;
    1101         PyObject *result;
    1102         rf.fp = NULL;
    1103         rf.ptr = str;
    1104         rf.end = str + len;
    1105         rf.strings = PyList_New(0);
    1106         rf.depth = 0;
    1107         result = r_object(&rf);
    1108         Py_DECREF(rf.strings);
    1109         return result;
     1176    RFILE rf;
     1177    PyObject *result;
     1178    rf.fp = NULL;
     1179    rf.ptr = str;
     1180    rf.end = str + len;
     1181    rf.strings = PyList_New(0);
     1182    rf.depth = 0;
     1183    result = r_object(&rf);
     1184    Py_DECREF(rf.strings);
     1185    return result;
     1186}
     1187
     1188static void
     1189set_error(int error)
     1190{
     1191    switch (error) {
     1192    case WFERR_NOMEMORY:
     1193        PyErr_NoMemory();
     1194        break;
     1195    case WFERR_UNMARSHALLABLE:
     1196        PyErr_SetString(PyExc_ValueError, "unmarshallable object");
     1197        break;
     1198    case WFERR_NESTEDTOODEEP:
     1199    default:
     1200        PyErr_SetString(PyExc_ValueError,
     1201            "object too deeply nested to marshal");
     1202        break;
     1203    }
    11101204}
    11111205
    … …  
    11131207PyMarshal_WriteObjectToString(PyObject *x, int version)
    11141208{
    1115         WFILE wf;
    1116         wf.fp = NULL;
    1117         wf.str = PyString_FromStringAndSize((char *)NULL, 50);
    1118         if (wf.str == NULL)
    1119                 return NULL;
    1120         wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
    1121         wf.end = wf.ptr + PyString_Size(wf.str);
    1122         wf.error = 0;
    1123         wf.depth = 0;
    1124         wf.version = version;
    1125         wf.strings = (version > 0) ? PyDict_New() : NULL;
    1126         w_object(x, &wf);
    1127         Py_XDECREF(wf.strings);
    1128         if (wf.str != NULL) {
    1129                 char *base = PyString_AS_STRING((PyStringObject *)wf.str);
    1130                 if (wf.ptr - base > PY_SSIZE_T_MAX) {
    1131                         Py_DECREF(wf.str);
    1132                         PyErr_SetString(PyExc_OverflowError,
    1133                                         "too much marshall data for a string");
    1134                         return NULL;
    1135                 }
    1136                 _PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base));
    1137         }
    1138         if (wf.error) {
    1139                 Py_XDECREF(wf.str);
    1140                 PyErr_SetString(PyExc_ValueError,
    1141                                 (wf.error==1)?"unmarshallable object"
    1142                                 :"object too deeply nested to marshal");
    1143                 return NULL;
    1144         }
    1145         return wf.str;
     1209    WFILE wf;
     1210    wf.fp = NULL;
     1211    wf.str = PyString_FromStringAndSize((char *)NULL, 50);
     1212    if (wf.str == NULL)
     1213        return NULL;
     1214    wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
     1215    wf.end = wf.ptr + PyString_Size(wf.str);
     1216    wf.error = WFERR_OK;
     1217    wf.depth = 0;
     1218    wf.version = version;
     1219    wf.strings = (version > 0) ? PyDict_New() : NULL;
     1220    w_object(x, &wf);
     1221    Py_XDECREF(wf.strings);
     1222    if (wf.str != NULL) {
     1223        char *base = PyString_AS_STRING((PyStringObject *)wf.str);
     1224        if (wf.ptr - base > PY_SSIZE_T_MAX) {
     1225            Py_DECREF(wf.str);
     1226            PyErr_SetString(PyExc_OverflowError,
     1227                            "too much marshall data for a string");
     1228            return NULL;
     1229        }
     1230        if (_PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)))
     1231            return NULL;
     1232    }
     1233    if (wf.error != WFERR_OK) {
     1234        Py_XDECREF(wf.str);
     1235        set_error(wf.error);
     1236        return NULL;
     1237    }
     1238    return wf.str;
    11461239}
    11471240
    … …  
    11511244marshal_dump(PyObject *self, PyObject *args)
    11521245{
    1153         WFILE wf;
    1154         PyObject *x;
    1155         PyObject *f;
    1156         int version = Py_MARSHAL_VERSION;
    1157         if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
    1158                 return NULL;
    1159         if (!PyFile_Check(f)) {
    1160                 PyErr_SetString(PyExc_TypeError,
    1161                                 "marshal.dump() 2nd arg must be file");
    1162                 return NULL;
    1163         }
    1164         wf.fp = PyFile_AsFile(f);
    1165         wf.str = NULL;
    1166         wf.ptr = wf.end = NULL;
    1167         wf.error = 0;
    1168         wf.depth = 0;
    1169         wf.strings = (version > 0) ? PyDict_New() : 0;
    1170         wf.version = version;
    1171         w_object(x, &wf);
    1172         Py_XDECREF(wf.strings);
    1173         if (wf.error) {
    1174                 PyErr_SetString(PyExc_ValueError,
    1175                                 (wf.error==1)?"unmarshallable object"
    1176                                 :"object too deeply nested to marshal");
    1177                 return NULL;
    1178         }
    1179         Py_INCREF(Py_None);
    1180         return Py_None;
     1246    WFILE wf;
     1247    PyObject *x;
     1248    PyObject *f;
     1249    int version = Py_MARSHAL_VERSION;
     1250    if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
     1251        return NULL;
     1252    if (!PyFile_Check(f)) {
     1253        PyErr_SetString(PyExc_TypeError,
     1254                        "marshal.dump() 2nd arg must be file");
     1255        return NULL;
     1256    }
     1257    wf.fp = PyFile_AsFile(f);
     1258    wf.str = NULL;
     1259    wf.ptr = wf.end = NULL;
     1260    wf.error = WFERR_OK;
     1261    wf.depth = 0;
     1262    wf.strings = (version > 0) ? PyDict_New() : 0;
     1263    wf.version = version;
     1264    w_object(x, &wf);
     1265    Py_XDECREF(wf.strings);
     1266    if (wf.error != WFERR_OK) {
     1267        set_error(wf.error);
     1268        return NULL;
     1269    }
     1270    Py_INCREF(Py_None);
     1271    return Py_None;
    11811272}
    11821273
    … …  
    11981289marshal_load(PyObject *self, PyObject *f)
    11991290{
    1200         RFILE rf;
    1201         PyObject *result;
    1202         if (!PyFile_Check(f)) {
    1203                 PyErr_SetString(PyExc_TypeError,
    1204                                 "marshal.load() arg must be file");
    1205                 return NULL;
    1206         }
    1207         rf.fp = PyFile_AsFile(f);
    1208         rf.strings = PyList_New(0);
    1209         rf.depth = 0;
    1210         result = read_object(&rf);
    1211         Py_DECREF(rf.strings);
    1212         return result;
     1291    RFILE rf;
     1292    PyObject *result;
     1293    if (!PyFile_Check(f)) {
     1294        PyErr_SetString(PyExc_TypeError,
     1295                        "marshal.load() arg must be file");
     1296        return NULL;
     1297    }
     1298    rf.fp = PyFile_AsFile(f);
     1299    rf.strings = PyList_New(0);
     1300    rf.depth = 0;
     1301    result = read_object(&rf);
     1302    Py_DECREF(rf.strings);
     1303    return result;
    12131304}
    12141305
    … …  
    12291320marshal_dumps(PyObject *self, PyObject *args)
    12301321{
    1231         PyObject *x;
    1232         int version = Py_MARSHAL_VERSION;
    1233         if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
    1234                 return NULL;
    1235         return PyMarshal_WriteObjectToString(x, version);
     1322    PyObject *x;
     1323    int version = Py_MARSHAL_VERSION;
     1324    if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
     1325        return NULL;
     1326    return PyMarshal_WriteObjectToString(x, version);
    12361327}
    12371328
    … …  
    12501341marshal_loads(PyObject *self, PyObject *args)
    12511342{
    1252         RFILE rf;
    1253         char *s;
    1254         Py_ssize_t n;
    1255         PyObject* result;
    1256         if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
    1257                 return NULL;
    1258         rf.fp = NULL;
    1259         rf.ptr = s;
    1260         rf.end = s + n;
    1261         rf.strings = PyList_New(0);
    1262         rf.depth = 0;
    1263         result = read_object(&rf);
    1264         Py_DECREF(rf.strings);
    1265         return result;
     1343    RFILE rf;
     1344    char *s;
     1345    Py_ssize_t n;
     1346    PyObject* result;
     1347    if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
     1348        return NULL;
     1349    rf.fp = NULL;
     1350    rf.ptr = s;
     1351    rf.end = s + n;
     1352    rf.strings = PyList_New(0);
     1353    rf.depth = 0;
     1354    result = read_object(&rf);
     1355    Py_DECREF(rf.strings);
     1356    return result;
    12661357}
    12671358
    … …  
    12741365
    12751366static PyMethodDef marshal_methods[] = {
    1276         {"dump",        marshal_dump,   METH_VARARGS,   dump_doc},
    1277         {"load",        marshal_load,   METH_O,         load_doc},
    1278         {"dumps",       marshal_dumps,  METH_VARARGS,   dumps_doc},
    1279         {"loads",       marshal_loads,  METH_VARARGS,   loads_doc},
    1280         {NULL,          NULL}           /* sentinel */
     1367    {"dump",            marshal_dump,   METH_VARARGS,   dump_doc},
     1368    {"load",            marshal_load,   METH_O,         load_doc},
     1369    {"dumps",           marshal_dumps,  METH_VARARGS,   dumps_doc},
     1370    {"loads",           marshal_loads,  METH_VARARGS,   loads_doc},
     1371    {NULL,              NULL}           /* sentinel */
    12811372};
    12821373
    … …  
    13141405PyMarshal_Init(void)
    13151406{
    1316         PyObject *mod = Py_InitModule3("marshal", marshal_methods,
    1317                 marshal_doc);
    1318         if (mod == NULL)
    1319                 return;
    1320         PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
    1321 }
     1407    PyObject *mod = Py_InitModule3("marshal", marshal_methods,
     1408        marshal_doc);
     1409    if (mod == NULL)
     1410        return;
     1411    PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
     1412}
Note: See TracChangeset for help on using the changeset viewer.