← Back to branch summary

~ubuntu-branches/ubuntu/natty/python3.1/natty-security

« back to all changes in this revision

Viewing changes to Python/marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2010-07-06 16:52:42 UTC
  • mfrom: (1.2.1 upstream) (2.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20100706165242-2xv4i019r3et6c0j
Tags: 3.1.2+20100706-1ubuntu1
* Merge with Debian; remaining changes:
  - Regenerate the control file.
  - Add debian/patches/overwrite-semaphore-check for Lucid buildds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Python/marshal.c
24
24
#define MAX_MARSHAL_STACK_DEPTH 2000
25
25
#endif
26
26
 
27
 
#define TYPE_NULL               '0'
28
 
#define TYPE_NONE               'N'
29
 
#define TYPE_FALSE              'F'
30
 
#define TYPE_TRUE               'T'
31
 
#define TYPE_STOPITER           'S'
32
 
#define TYPE_ELLIPSIS           '.'
33
 
#define TYPE_INT                'i'
34
 
#define TYPE_INT64              'I'
35
 
#define TYPE_FLOAT              'f'
36
 
#define TYPE_BINARY_FLOAT       'g'
37
 
#define TYPE_COMPLEX            'x'
38
 
#define TYPE_BINARY_COMPLEX     'y'
39
 
#define TYPE_LONG               'l'
40
 
#define TYPE_STRING             's'
41
 
#define TYPE_TUPLE              '('
42
 
#define TYPE_LIST               '['
43
 
#define TYPE_DICT               '{'
44
 
#define TYPE_CODE               'c'
45
 
#define TYPE_UNICODE            'u'
46
 
#define TYPE_UNKNOWN            '?'
47
 
#define TYPE_SET                '<'
48
 
#define TYPE_FROZENSET          '>'
 
27
#define TYPE_NULL               '0'
 
28
#define TYPE_NONE               'N'
 
29
#define TYPE_FALSE              'F'
 
30
#define TYPE_TRUE               'T'
 
31
#define TYPE_STOPITER           'S'
 
32
#define TYPE_ELLIPSIS           '.'
 
33
#define TYPE_INT                'i'
 
34
#define TYPE_INT64              'I'
 
35
#define TYPE_FLOAT              'f'
 
36
#define TYPE_BINARY_FLOAT       'g'
 
37
#define TYPE_COMPLEX            'x'
 
38
#define TYPE_BINARY_COMPLEX     'y'
 
39
#define TYPE_LONG               'l'
 
40
#define TYPE_STRING             's'
 
41
#define TYPE_TUPLE              '('
 
42
#define TYPE_LIST               '['
 
43
#define TYPE_DICT               '{'
 
44
#define TYPE_CODE               'c'
 
45
#define TYPE_UNICODE            'u'
 
46
#define TYPE_UNKNOWN            '?'
 
47
#define TYPE_SET                '<'
 
48
#define TYPE_FROZENSET          '>'
49
49
 
50
50
#define WFERR_OK 0
51
51
#define WFERR_UNMARSHALLABLE 1
53
53
#define WFERR_NOMEMORY 3
54
54
 
55
55
typedef struct {
56
 
        FILE *fp;
57
 
        int error;  /* see WFERR_* values */
58
 
        int depth;
59
 
        /* If fp == NULL, the following are valid: */
60
 
        PyObject *str;
61
 
        char *ptr;
62
 
        char *end;
63
 
        PyObject *strings; /* dict on marshal, list on unmarshal */
64
 
        int version;
 
56
    FILE *fp;
 
57
    int error;  /* see WFERR_* values */
 
58
    int depth;
 
59
    /* If fp == NULL, the following are valid: */
 
60
    PyObject *str;
 
61
    char *ptr;
 
62
    char *end;
 
63
    PyObject *strings; /* dict on marshal, list on unmarshal */
 
64
    int version;
65
65
} WFILE;
66
66
 
67
67
#define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \
68
 
                      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
69
 
                           else w_more(c, p)
 
68
                      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
 
69
                           else w_more(c, p)
70
70
 
71
71
static void
72
72
w_more(int c, WFILE *p)
73
73
{
74
 
        Py_ssize_t size, newsize;
75
 
        if (p->str == NULL)
76
 
                return; /* An error already occurred */
77
 
        size = PyBytes_Size(p->str);
78
 
        newsize = size + size + 1024;
79
 
        if (newsize > 32*1024*1024) {
80
 
                newsize = size + (size >> 3);   /* 12.5% overallocation */
81
 
        }
82
 
        if (_PyBytes_Resize(&p->str, newsize) != 0) {
83
 
                p->ptr = p->end = NULL;
84
 
        }
85
 
        else {
86
 
                p->ptr = PyBytes_AS_STRING((PyBytesObject *)p->str) + size;
87
 
                p->end =
88
 
                        PyBytes_AS_STRING((PyBytesObject *)p->str) + newsize;
89
 
                *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
90
 
        }
 
74
    Py_ssize_t size, newsize;
 
75
    if (p->str == NULL)
 
76
        return; /* An error already occurred */
 
77
    size = PyBytes_Size(p->str);
 
78
    newsize = size + size + 1024;
 
79
    if (newsize > 32*1024*1024) {
 
80
        newsize = size + (size >> 3);           /* 12.5% overallocation */
 
81
    }
 
82
    if (_PyBytes_Resize(&p->str, newsize) != 0) {
 
83
        p->ptr = p->end = NULL;
 
84
    }
 
85
    else {
 
86
        p->ptr = PyBytes_AS_STRING((PyBytesObject *)p->str) + size;
 
87
        p->end =
 
88
            PyBytes_AS_STRING((PyBytesObject *)p->str) + newsize;
 
89
        *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
 
90
    }
91
91
}
92
92
 
93
93
static void
94
94
w_string(char *s, int n, WFILE *p)
95
95
{
96
 
        if (p->fp != NULL) {
97
 
                fwrite(s, 1, n, p->fp);
98
 
        }
99
 
        else {
100
 
                while (--n >= 0) {
101
 
                        w_byte(*s, p);
102
 
                        s++;
103
 
                }
104
 
        }
 
96
    if (p->fp != NULL) {
 
97
        fwrite(s, 1, n, p->fp);
 
98
    }
 
99
    else {
 
100
        while (--n >= 0) {
 
101
            w_byte(*s, p);
 
102
            s++;
 
103
        }
 
104
    }
105
105
}
106
106
 
107
107
static void
108
108
w_short(int x, WFILE *p)
109
109
{
110
 
        w_byte((char)( x      & 0xff), p);
111
 
        w_byte((char)((x>> 8) & 0xff), p);
 
110
    w_byte((char)( x      & 0xff), p);
 
111
    w_byte((char)((x>> 8) & 0xff), p);
112
112
}
113
113
 
114
114
static void
115
115
w_long(long x, WFILE *p)
116
116
{
117
 
        w_byte((char)( x      & 0xff), p);
118
 
        w_byte((char)((x>> 8) & 0xff), p);
119
 
        w_byte((char)((x>>16) & 0xff), p);
120
 
        w_byte((char)((x>>24) & 0xff), p);
 
117
    w_byte((char)( x      & 0xff), p);
 
118
    w_byte((char)((x>> 8) & 0xff), p);
 
119
    w_byte((char)((x>>16) & 0xff), p);
 
120
    w_byte((char)((x>>24) & 0xff), p);
121
121
}
122
122
 
123
123
#if SIZEOF_LONG > 4
124
124
static void
125
125
w_long64(long x, WFILE *p)
126
126
{
127
 
        w_long(x, p);
128
 
        w_long(x>>32, p);
 
127
    w_long(x, p);
 
128
    w_long(x>>32, p);
129
129
}
130
130
#endif
131
131
 
144
144
static void
145
145
w_PyLong(const PyLongObject *ob, WFILE *p)
146
146
{
147
 
        Py_ssize_t i, j, n, l;
148
 
        digit d;
149
 
 
150
 
        w_byte(TYPE_LONG, p);
151
 
        if (Py_SIZE(ob) == 0) {
152
 
                w_long((long)0, p);
153
 
                return;
154
 
        }
155
 
 
156
 
        /* set l to number of base PyLong_MARSHAL_BASE digits */
157
 
        n = ABS(Py_SIZE(ob));
158
 
        l = (n-1) * PyLong_MARSHAL_RATIO;
159
 
        d = ob->ob_digit[n-1];
160
 
        assert(d != 0); /* a PyLong is always normalized */
161
 
        do {
162
 
                d >>= PyLong_MARSHAL_SHIFT;
163
 
                l++;
164
 
        } while (d != 0);
165
 
        w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
166
 
 
167
 
        for (i=0; i < n-1; i++) {
168
 
                d = ob->ob_digit[i];
169
 
                for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
170
 
                        w_short(d & PyLong_MARSHAL_MASK, p);
171
 
                        d >>= PyLong_MARSHAL_SHIFT;
172
 
                }
173
 
                assert (d == 0);
174
 
        }
175
 
        d = ob->ob_digit[n-1];
176
 
        do {
177
 
                w_short(d & PyLong_MARSHAL_MASK, p);
178
 
                d >>= PyLong_MARSHAL_SHIFT;
179
 
        } while (d != 0);
 
147
    Py_ssize_t i, j, n, l;
 
148
    digit d;
 
149
 
 
150
    w_byte(TYPE_LONG, p);
 
151
    if (Py_SIZE(ob) == 0) {
 
152
        w_long((long)0, p);
 
153
        return;
 
154
    }
 
155
 
 
156
    /* set l to number of base PyLong_MARSHAL_BASE digits */
 
157
    n = ABS(Py_SIZE(ob));
 
158
    l = (n-1) * PyLong_MARSHAL_RATIO;
 
159
    d = ob->ob_digit[n-1];
 
160
    assert(d != 0); /* a PyLong is always normalized */
 
161
    do {
 
162
        d >>= PyLong_MARSHAL_SHIFT;
 
163
        l++;
 
164
    } while (d != 0);
 
165
    w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
 
166
 
 
167
    for (i=0; i < n-1; i++) {
 
168
        d = ob->ob_digit[i];
 
169
        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
 
170
            w_short(d & PyLong_MARSHAL_MASK, p);
 
171
            d >>= PyLong_MARSHAL_SHIFT;
 
172
        }
 
173
        assert (d == 0);
 
174
    }
 
175
    d = ob->ob_digit[n-1];
 
176
    do {
 
177
        w_short(d & PyLong_MARSHAL_MASK, p);
 
178
        d >>= PyLong_MARSHAL_SHIFT;
 
179
    } while (d != 0);
180
180
}
181
181
 
182
182
static void
183
183
w_object(PyObject *v, WFILE *p)
184
184
{
185
 
        Py_ssize_t i, n;
186
 
 
187
 
        p->depth++;
188
 
 
189
 
        if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
190
 
                p->error = WFERR_NESTEDTOODEEP;
191
 
        }
192
 
        else if (v == NULL) {
193
 
                w_byte(TYPE_NULL, p);
194
 
        }
195
 
        else if (v == Py_None) {
196
 
                w_byte(TYPE_NONE, p);
197
 
        }
198
 
        else if (v == PyExc_StopIteration) {
199
 
                w_byte(TYPE_STOPITER, p);
200
 
        }
201
 
        else if (v == Py_Ellipsis) {
202
 
                w_byte(TYPE_ELLIPSIS, p);
203
 
        }
204
 
        else if (v == Py_False) {
205
 
                w_byte(TYPE_FALSE, p);
206
 
        }
207
 
        else if (v == Py_True) {
208
 
                w_byte(TYPE_TRUE, p);
209
 
        }
210
 
        else if (PyLong_CheckExact(v)) {
211
 
                long x = PyLong_AsLong(v);
212
 
                if ((x == -1)  && PyErr_Occurred()) {
213
 
                        PyLongObject *ob = (PyLongObject *)v;
214
 
                        PyErr_Clear();
215
 
                        w_PyLong(ob, p);
216
 
                }
217
 
                else {
 
185
    Py_ssize_t i, n;
 
186
 
 
187
    p->depth++;
 
188
 
 
189
    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
 
190
        p->error = WFERR_NESTEDTOODEEP;
 
191
    }
 
192
    else if (v == NULL) {
 
193
        w_byte(TYPE_NULL, p);
 
194
    }
 
195
    else if (v == Py_None) {
 
196
        w_byte(TYPE_NONE, p);
 
197
    }
 
198
    else if (v == PyExc_StopIteration) {
 
199
        w_byte(TYPE_STOPITER, p);
 
200
    }
 
201
    else if (v == Py_Ellipsis) {
 
202
        w_byte(TYPE_ELLIPSIS, p);
 
203
    }
 
204
    else if (v == Py_False) {
 
205
        w_byte(TYPE_FALSE, p);
 
206
    }
 
207
    else if (v == Py_True) {
 
208
        w_byte(TYPE_TRUE, p);
 
209
    }
 
210
    else if (PyLong_CheckExact(v)) {
 
211
        long x = PyLong_AsLong(v);
 
212
        if ((x == -1)  && PyErr_Occurred()) {
 
213
            PyLongObject *ob = (PyLongObject *)v;
 
214
            PyErr_Clear();
 
215
            w_PyLong(ob, p);
 
216
        }
 
217
        else {
218
218
#if SIZEOF_LONG > 4
219
 
                        long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
220
 
                        if (y && y != -1) {
221
 
                                w_byte(TYPE_INT64, p);
222
 
                                w_long64(x, p);
223
 
                        }
224
 
                        else
 
219
            long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
 
220
            if (y && y != -1) {
 
221
                w_byte(TYPE_INT64, p);
 
222
                w_long64(x, p);
 
223
            }
 
224
            else
225
225
#endif
226
 
                        {
227
 
                                w_byte(TYPE_INT, p);
228
 
                                w_long(x, p);
229
 
                        }
230
 
                }
231
 
        }
232
 
        else if (PyFloat_CheckExact(v)) {
233
 
                if (p->version > 1) {
234
 
                        unsigned char buf[8];
235
 
                        if (_PyFloat_Pack8(PyFloat_AsDouble(v), 
236
 
                                           buf, 1) < 0) {
237
 
                                p->error = WFERR_UNMARSHALLABLE;
238
 
                                return;
239
 
                        }
240
 
                        w_byte(TYPE_BINARY_FLOAT, p);
241
 
                        w_string((char*)buf, 8, p);
242
 
                }
243
 
                else {
244
 
                        char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
245
 
                                                          'g', 17, 0, NULL);
246
 
                        if (!buf) {
247
 
                                p->error = WFERR_NOMEMORY;
248
 
                                return;
249
 
                        }
250
 
                        n = strlen(buf);
251
 
                        w_byte(TYPE_FLOAT, p);
252
 
                        w_byte((int)n, p);
253
 
                        w_string(buf, (int)n, p);
254
 
                        PyMem_Free(buf);
255
 
                }
256
 
        }
 
226
            {
 
227
                w_byte(TYPE_INT, p);
 
228
                w_long(x, p);
 
229
            }
 
230
        }
 
231
    }
 
232
    else if (PyFloat_CheckExact(v)) {
 
233
        if (p->version > 1) {
 
234
            unsigned char buf[8];
 
235
            if (_PyFloat_Pack8(PyFloat_AsDouble(v),
 
236
                               buf, 1) < 0) {
 
237
                p->error = WFERR_UNMARSHALLABLE;
 
238
                return;
 
239
            }
 
240
            w_byte(TYPE_BINARY_FLOAT, p);
 
241
            w_string((char*)buf, 8, p);
 
242
        }
 
243
        else {
 
244
            char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
 
245
                                              'g', 17, 0, NULL);
 
246
            if (!buf) {
 
247
                p->error = WFERR_NOMEMORY;
 
248
                return;
 
249
            }
 
250
            n = strlen(buf);
 
251
            w_byte(TYPE_FLOAT, p);
 
252
            w_byte((int)n, p);
 
253
            w_string(buf, (int)n, p);
 
254
            PyMem_Free(buf);
 
255
        }
 
256
    }
257
257
#ifndef WITHOUT_COMPLEX
258
 
        else if (PyComplex_CheckExact(v)) {
259
 
                if (p->version > 1) {
260
 
                        unsigned char buf[8];
261
 
                        if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
262
 
                                           buf, 1) < 0) {
263
 
                                p->error = WFERR_UNMARSHALLABLE;
264
 
                                return;
265
 
                        }
266
 
                        w_byte(TYPE_BINARY_COMPLEX, p);
267
 
                        w_string((char*)buf, 8, p);
268
 
                        if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v), 
269
 
                                           buf, 1) < 0) {
270
 
                                p->error = WFERR_UNMARSHALLABLE;
271
 
                                return;
272
 
                        }
273
 
                        w_string((char*)buf, 8, p);
274
 
                }
275
 
                else {
276
 
                        char *buf;
277
 
                        w_byte(TYPE_COMPLEX, p);
278
 
                        buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),
279
 
                                                    'g', 17, 0, NULL);
280
 
                        if (!buf) {
281
 
                                p->error = WFERR_NOMEMORY;
282
 
                                return;
283
 
                        }
284
 
                        n = strlen(buf);
285
 
                        w_byte((int)n, p);
286
 
                        w_string(buf, (int)n, p);
287
 
                        PyMem_Free(buf);
288
 
                        buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),
289
 
                                                    'g', 17, 0, NULL);
290
 
                        if (!buf) {
291
 
                                p->error = WFERR_NOMEMORY;
292
 
                                return;
293
 
                        }
294
 
                        n = strlen(buf);
295
 
                        w_byte((int)n, p);
296
 
                        w_string(buf, (int)n, p);
297
 
                        PyMem_Free(buf);
298
 
                }
299
 
        }
 
258
    else if (PyComplex_CheckExact(v)) {
 
259
        if (p->version > 1) {
 
260
            unsigned char buf[8];
 
261
            if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
 
262
                               buf, 1) < 0) {
 
263
                p->error = WFERR_UNMARSHALLABLE;
 
264
                return;
 
265
            }
 
266
            w_byte(TYPE_BINARY_COMPLEX, p);
 
267
            w_string((char*)buf, 8, p);
 
268
            if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),
 
269
                               buf, 1) < 0) {
 
270
                p->error = WFERR_UNMARSHALLABLE;
 
271
                return;
 
272
            }
 
273
            w_string((char*)buf, 8, p);
 
274
        }
 
275
        else {
 
276
            char *buf;
 
277
            w_byte(TYPE_COMPLEX, p);
 
278
            buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),
 
279
                                        'g', 17, 0, NULL);
 
280
            if (!buf) {
 
281
                p->error = WFERR_NOMEMORY;
 
282
                return;
 
283
            }
 
284
            n = strlen(buf);
 
285
            w_byte((int)n, p);
 
286
            w_string(buf, (int)n, p);
 
287
            PyMem_Free(buf);
 
288
            buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),
 
289
                                        'g', 17, 0, NULL);
 
290
            if (!buf) {
 
291
                p->error = WFERR_NOMEMORY;
 
292
                return;
 
293
            }
 
294
            n = strlen(buf);
 
295
            w_byte((int)n, p);
 
296
            w_string(buf, (int)n, p);
 
297
            PyMem_Free(buf);
 
298
        }
 
299
    }
300
300
#endif
301
 
        else if (PyBytes_CheckExact(v)) {
302
 
                w_byte(TYPE_STRING, p);
303
 
                n = PyBytes_GET_SIZE(v);
304
 
                if (n > INT_MAX) {
305
 
                        /* huge strings are not supported */
306
 
                        p->depth--;
307
 
                        p->error = WFERR_UNMARSHALLABLE;
308
 
                        return;
309
 
                }
310
 
                w_long((long)n, p);
311
 
                w_string(PyBytes_AS_STRING(v), (int)n, p);
312
 
        }
313
 
        else if (PyUnicode_CheckExact(v)) {
314
 
                PyObject *utf8;
315
 
                utf8 = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(v),
316
 
                                            PyUnicode_GET_SIZE(v),
317
 
                                            "surrogatepass");
318
 
                if (utf8 == NULL) {
319
 
                        p->depth--;
320
 
                        p->error = WFERR_UNMARSHALLABLE;
321
 
                        return;
322
 
                }
323
 
                w_byte(TYPE_UNICODE, p);
324
 
                n = PyBytes_GET_SIZE(utf8);
325
 
                if (n > INT_MAX) {
326
 
                        p->depth--;
327
 
                        p->error = WFERR_UNMARSHALLABLE;
328
 
                        return;
329
 
                }
330
 
                w_long((long)n, p);
331
 
                w_string(PyBytes_AS_STRING(utf8), (int)n, p);
332
 
                Py_DECREF(utf8);
333
 
        }
334
 
        else if (PyTuple_CheckExact(v)) {
335
 
                w_byte(TYPE_TUPLE, p);
336
 
                n = PyTuple_Size(v);
337
 
                w_long((long)n, p);
338
 
                for (i = 0; i < n; i++) {
339
 
                        w_object(PyTuple_GET_ITEM(v, i), p);
340
 
                }
341
 
        }
342
 
        else if (PyList_CheckExact(v)) {
343
 
                w_byte(TYPE_LIST, p);
344
 
                n = PyList_GET_SIZE(v);
345
 
                w_long((long)n, p);
346
 
                for (i = 0; i < n; i++) {
347
 
                        w_object(PyList_GET_ITEM(v, i), p);
348
 
                }
349
 
        }
350
 
        else if (PyDict_CheckExact(v)) {
351
 
                Py_ssize_t pos;
352
 
                PyObject *key, *value;
353
 
                w_byte(TYPE_DICT, p);
354
 
                /* This one is NULL object terminated! */
355
 
                pos = 0;
356
 
                while (PyDict_Next(v, &pos, &key, &value)) {
357
 
                        w_object(key, p);
358
 
                        w_object(value, p);
359
 
                }
360
 
                w_object((PyObject *)NULL, p);
361
 
        }
362
 
        else if (PyAnySet_CheckExact(v)) {
363
 
                PyObject *value, *it;
 
301
    else if (PyBytes_CheckExact(v)) {
 
302
        w_byte(TYPE_STRING, p);
 
303
        n = PyBytes_GET_SIZE(v);
 
304
        if (n > INT_MAX) {
 
305
            /* huge strings are not supported */
 
306
            p->depth--;
 
307
            p->error = WFERR_UNMARSHALLABLE;
 
308
            return;
 
309
        }
 
310
        w_long((long)n, p);
 
311
        w_string(PyBytes_AS_STRING(v), (int)n, p);
 
312
    }
 
313
    else if (PyUnicode_CheckExact(v)) {
 
314
        PyObject *utf8;
 
315
        utf8 = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(v),
 
316
                                    PyUnicode_GET_SIZE(v),
 
317
                                    "surrogatepass");
 
318
        if (utf8 == NULL) {
 
319
            p->depth--;
 
320
            p->error = WFERR_UNMARSHALLABLE;
 
321
            return;
 
322
        }
 
323
        w_byte(TYPE_UNICODE, p);
 
324
        n = PyBytes_GET_SIZE(utf8);
 
325
        if (n > INT_MAX) {
 
326
            p->depth--;
 
327
            p->error = WFERR_UNMARSHALLABLE;
 
328
            return;
 
329
        }
 
330
        w_long((long)n, p);
 
331
        w_string(PyBytes_AS_STRING(utf8), (int)n, p);
 
332
        Py_DECREF(utf8);
 
333
    }
 
334
    else if (PyTuple_CheckExact(v)) {
 
335
        w_byte(TYPE_TUPLE, p);
 
336
        n = PyTuple_Size(v);
 
337
        w_long((long)n, p);
 
338
        for (i = 0; i < n; i++) {
 
339
            w_object(PyTuple_GET_ITEM(v, i), p);
 
340
        }
 
341
    }
 
342
    else if (PyList_CheckExact(v)) {
 
343
        w_byte(TYPE_LIST, p);
 
344
        n = PyList_GET_SIZE(v);
 
345
        w_long((long)n, p);
 
346
        for (i = 0; i < n; i++) {
 
347
            w_object(PyList_GET_ITEM(v, i), p);
 
348
        }
 
349
    }
 
350
    else if (PyDict_CheckExact(v)) {
 
351
        Py_ssize_t pos;
 
352
        PyObject *key, *value;
 
353
        w_byte(TYPE_DICT, p);
 
354
        /* This one is NULL object terminated! */
 
355
        pos = 0;
 
356
        while (PyDict_Next(v, &pos, &key, &value)) {
 
357
            w_object(key, p);
 
358
            w_object(value, p);
 
359
        }
 
360
        w_object((PyObject *)NULL, p);
 
361
    }
 
362
    else if (PyAnySet_CheckExact(v)) {
 
363
        PyObject *value, *it;
364
364
 
365
 
                if (PyObject_TypeCheck(v, &PySet_Type))
366
 
                        w_byte(TYPE_SET, p);
367
 
                else
368
 
                        w_byte(TYPE_FROZENSET, p);
369
 
                n = PyObject_Size(v);
370
 
                if (n == -1) {
371
 
                        p->depth--;
372
 
                        p->error = WFERR_UNMARSHALLABLE;
373
 
                        return;
374
 
                }
375
 
                w_long((long)n, p);
376
 
                it = PyObject_GetIter(v);
377
 
                if (it == NULL) {
378
 
                        p->depth--;
379
 
                        p->error = WFERR_UNMARSHALLABLE;
380
 
                        return;
381
 
                }
382
 
                while ((value = PyIter_Next(it)) != NULL) {
383
 
                        w_object(value, p);
384
 
                        Py_DECREF(value);
385
 
                }
386
 
                Py_DECREF(it);
387
 
                if (PyErr_Occurred()) {
388
 
                        p->depth--;
389
 
                        p->error = WFERR_UNMARSHALLABLE;
390
 
                        return;
391
 
                }
392
 
        }
393
 
        else if (PyCode_Check(v)) {
394
 
                PyCodeObject *co = (PyCodeObject *)v;
395
 
                w_byte(TYPE_CODE, p);
396
 
                w_long(co->co_argcount, p);
397
 
                w_long(co->co_kwonlyargcount, p);
398
 
                w_long(co->co_nlocals, p);
399
 
                w_long(co->co_stacksize, p);
400
 
                w_long(co->co_flags, p);
401
 
                w_object(co->co_code, p);
402
 
                w_object(co->co_consts, p);
403
 
                w_object(co->co_names, p);
404
 
                w_object(co->co_varnames, p);
405
 
                w_object(co->co_freevars, p);
406
 
                w_object(co->co_cellvars, p);
407
 
                w_object(co->co_filename, p);
408
 
                w_object(co->co_name, p);
409
 
                w_long(co->co_firstlineno, p);
410
 
                w_object(co->co_lnotab, p);
411
 
        }
412
 
        else if (PyObject_CheckBuffer(v)) {
413
 
                /* Write unknown buffer-style objects as a string */
414
 
                char *s;
415
 
                PyBufferProcs *pb = v->ob_type->tp_as_buffer;
416
 
                Py_buffer view;
417
 
                if ((*pb->bf_getbuffer)(v, &view, PyBUF_SIMPLE) != 0) {
418
 
                        w_byte(TYPE_UNKNOWN, p);
419
 
                        p->error = WFERR_UNMARSHALLABLE;
420
 
                }
421
 
                w_byte(TYPE_STRING, p);
422
 
                n = view.len;
423
 
                s = view.buf;                        
424
 
                if (n > INT_MAX) {
425
 
                        p->depth--;
426
 
                        p->error = WFERR_UNMARSHALLABLE;
427
 
                        return;
428
 
                }
429
 
                w_long((long)n, p);
430
 
                w_string(s, (int)n, p);
431
 
                if (pb->bf_releasebuffer != NULL)
432
 
                        (*pb->bf_releasebuffer)(v, &view);
433
 
        }
434
 
        else {
435
 
                w_byte(TYPE_UNKNOWN, p);
436
 
                p->error = WFERR_UNMARSHALLABLE;
437
 
        }
438
 
        p->depth--;
 
365
        if (PyObject_TypeCheck(v, &PySet_Type))
 
366
            w_byte(TYPE_SET, p);
 
367
        else
 
368
            w_byte(TYPE_FROZENSET, p);
 
369
        n = PyObject_Size(v);
 
370
        if (n == -1) {
 
371
            p->depth--;
 
372
            p->error = WFERR_UNMARSHALLABLE;
 
373
            return;
 
374
        }
 
375
        w_long((long)n, p);
 
376
        it = PyObject_GetIter(v);
 
377
        if (it == NULL) {
 
378
            p->depth--;
 
379
            p->error = WFERR_UNMARSHALLABLE;
 
380
            return;
 
381
        }
 
382
        while ((value = PyIter_Next(it)) != NULL) {
 
383
            w_object(value, p);
 
384
            Py_DECREF(value);
 
385
        }
 
386
        Py_DECREF(it);
 
387
        if (PyErr_Occurred()) {
 
388
            p->depth--;
 
389
            p->error = WFERR_UNMARSHALLABLE;
 
390
            return;
 
391
        }
 
392
    }
 
393
    else if (PyCode_Check(v)) {
 
394
        PyCodeObject *co = (PyCodeObject *)v;
 
395
        w_byte(TYPE_CODE, p);
 
396
        w_long(co->co_argcount, p);
 
397
        w_long(co->co_kwonlyargcount, p);
 
398
        w_long(co->co_nlocals, p);
 
399
        w_long(co->co_stacksize, p);
 
400
        w_long(co->co_flags, p);
 
401
        w_object(co->co_code, p);
 
402
        w_object(co->co_consts, p);
 
403
        w_object(co->co_names, p);
 
404
        w_object(co->co_varnames, p);
 
405
        w_object(co->co_freevars, p);
 
406
        w_object(co->co_cellvars, p);
 
407
        w_object(co->co_filename, p);
 
408
        w_object(co->co_name, p);
 
409
        w_long(co->co_firstlineno, p);
 
410
        w_object(co->co_lnotab, p);
 
411
    }
 
412
    else if (PyObject_CheckBuffer(v)) {
 
413
        /* Write unknown buffer-style objects as a string */
 
414
        char *s;
 
415
        PyBufferProcs *pb = v->ob_type->tp_as_buffer;
 
416
        Py_buffer view;
 
417
        if ((*pb->bf_getbuffer)(v, &view, PyBUF_SIMPLE) != 0) {
 
418
            w_byte(TYPE_UNKNOWN, p);
 
419
            p->error = WFERR_UNMARSHALLABLE;
 
420
        }
 
421
        w_byte(TYPE_STRING, p);
 
422
        n = view.len;
 
423
        s = view.buf;
 
424
        if (n > INT_MAX) {
 
425
            p->depth--;
 
426
            p->error = WFERR_UNMARSHALLABLE;
 
427
            return;
 
428
        }
 
429
        w_long((long)n, p);
 
430
        w_string(s, (int)n, p);
 
431
        if (pb->bf_releasebuffer != NULL)
 
432
            (*pb->bf_releasebuffer)(v, &view);
 
433
    }
 
434
    else {
 
435
        w_byte(TYPE_UNKNOWN, p);
 
436
        p->error = WFERR_UNMARSHALLABLE;
 
437
    }
 
438
    p->depth--;
439
439
}
440
440
 
441
441
/* version currently has no effect for writing longs. */
442
442
void
443
443
PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
444
444
{
445
 
        WFILE wf;
446
 
        wf.fp = fp;
447
 
        wf.error = WFERR_OK;
448
 
        wf.depth = 0;
449
 
        wf.strings = NULL;
450
 
        wf.version = version;
451
 
        w_long(x, &wf);
 
445
    WFILE wf;
 
446
    wf.fp = fp;
 
447
    wf.error = WFERR_OK;
 
448
    wf.depth = 0;
 
449
    wf.strings = NULL;
 
450
    wf.version = version;
 
451
    w_long(x, &wf);
452
452
}
453
453
 
454
454
void
455
455
PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
456
456
{
457
 
        WFILE wf;
458
 
        wf.fp = fp;
459
 
        wf.error = WFERR_OK;
460
 
        wf.depth = 0;
461
 
        wf.strings = (version > 0) ? PyDict_New() : NULL;
462
 
        wf.version = version;
463
 
        w_object(x, &wf);
464
 
        Py_XDECREF(wf.strings);
 
457
    WFILE wf;
 
458
    wf.fp = fp;
 
459
    wf.error = WFERR_OK;
 
460
    wf.depth = 0;
 
461
    wf.strings = (version > 0) ? PyDict_New() : NULL;
 
462
    wf.version = version;
 
463
    w_object(x, &wf);
 
464
    Py_XDECREF(wf.strings);
465
465
}
466
466
 
467
467
typedef WFILE RFILE; /* Same struct with different invariants */
473
473
static int
474
474
r_string(char *s, int n, RFILE *p)
475
475
{
476
 
        if (p->fp != NULL)
477
 
                /* The result fits into int because it must be <=n. */
478
 
                return (int)fread(s, 1, n, p->fp);
479
 
        if (p->end - p->ptr < n)
480
 
                n = (int)(p->end - p->ptr);
481
 
        memcpy(s, p->ptr, n);
482
 
        p->ptr += n;
483
 
        return n;
 
476
    if (p->fp != NULL)
 
477
        /* The result fits into int because it must be <=n. */
 
478
        return (int)fread(s, 1, n, p->fp);
 
479
    if (p->end - p->ptr < n)
 
480
        n = (int)(p->end - p->ptr);
 
481
    memcpy(s, p->ptr, n);
 
482
    p->ptr += n;
 
483
    return n;
484
484
}
485
485
 
486
486
static int
487
487
r_short(RFILE *p)
488
488
{
489
 
        register short x;
490
 
        x = r_byte(p);
491
 
        x |= r_byte(p) << 8;
492
 
        /* Sign-extension, in case short greater than 16 bits */
493
 
        x |= -(x & 0x8000);
494
 
        return x;
 
489
    register short x;
 
490
    x = r_byte(p);
 
491
    x |= r_byte(p) << 8;
 
492
    /* Sign-extension, in case short greater than 16 bits */
 
493
    x |= -(x & 0x8000);
 
494
    return x;
495
495
}
496
496
 
497
497
static long
498
498
r_long(RFILE *p)
499
499
{
500
 
        register long x;
501
 
        register FILE *fp = p->fp;
502
 
        if (fp) {
503
 
                x = getc(fp);
504
 
                x |= (long)getc(fp) << 8;
505
 
                x |= (long)getc(fp) << 16;
506
 
                x |= (long)getc(fp) << 24;
507
 
        }
508
 
        else {
509
 
                x = rs_byte(p);
510
 
                x |= (long)rs_byte(p) << 8;
511
 
                x |= (long)rs_byte(p) << 16;
512
 
                x |= (long)rs_byte(p) << 24;
513
 
        }
 
500
    register long x;
 
501
    register FILE *fp = p->fp;
 
502
    if (fp) {
 
503
        x = getc(fp);
 
504
        x |= (long)getc(fp) << 8;
 
505
        x |= (long)getc(fp) << 16;
 
506
        x |= (long)getc(fp) << 24;
 
507
    }
 
508
    else {
 
509
        x = rs_byte(p);
 
510
        x |= (long)rs_byte(p) << 8;
 
511
        x |= (long)rs_byte(p) << 16;
 
512
        x |= (long)rs_byte(p) << 24;
 
513
    }
514
514
#if SIZEOF_LONG > 4
515
 
        /* Sign extension for 64-bit machines */
516
 
        x |= -(x & 0x80000000L);
 
515
    /* Sign extension for 64-bit machines */
 
516
    x |= -(x & 0x80000000L);
517
517
#endif
518
 
        return x;
 
518
    return x;
519
519
}
520
520
 
521
521
/* r_long64 deals with the TYPE_INT64 code.  On a machine with
528
528
static PyObject *
529
529
r_long64(RFILE *p)
530
530
{
531
 
        long lo4 = r_long(p);
532
 
        long hi4 = r_long(p);
 
531
    long lo4 = r_long(p);
 
532
    long hi4 = r_long(p);
533
533
#if SIZEOF_LONG > 4
534
 
        long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
535
 
        return PyLong_FromLong(x);
 
534
    long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
 
535
    return PyLong_FromLong(x);
536
536
#else
537
 
        unsigned char buf[8];
538
 
        int one = 1;
539
 
        int is_little_endian = (int)*(char*)&one;
540
 
        if (is_little_endian) {
541
 
                memcpy(buf, &lo4, 4);
542
 
                memcpy(buf+4, &hi4, 4);
543
 
        }
544
 
        else {
545
 
                memcpy(buf, &hi4, 4);
546
 
                memcpy(buf+4, &lo4, 4);
547
 
        }
548
 
        return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
 
537
    unsigned char buf[8];
 
538
    int one = 1;
 
539
    int is_little_endian = (int)*(char*)&one;
 
540
    if (is_little_endian) {
 
541
        memcpy(buf, &lo4, 4);
 
542
        memcpy(buf+4, &hi4, 4);
 
543
    }
 
544
    else {
 
545
        memcpy(buf, &hi4, 4);
 
546
        memcpy(buf+4, &lo4, 4);
 
547
    }
 
548
    return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
549
549
#endif
550
550
}
551
551
 
552
552
static PyObject *
553
553
r_PyLong(RFILE *p)
554
554
{
555
 
        PyLongObject *ob;
556
 
        int size, i, j, md, shorts_in_top_digit;
557
 
        long n;
558
 
        digit d;
559
 
 
560
 
        n = r_long(p);
561
 
        if (n == 0)
562
 
                return (PyObject *)_PyLong_New(0);
563
 
        if (n < -INT_MAX || n > INT_MAX) {
564
 
                PyErr_SetString(PyExc_ValueError,
565
 
                               "bad marshal data (long size out of range)");
566
 
                return NULL;
567
 
        }
568
 
 
569
 
        size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
570
 
        shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
571
 
        ob = _PyLong_New(size);
572
 
        if (ob == NULL)
573
 
                return NULL;
574
 
        Py_SIZE(ob) = n > 0 ? size : -size;
575
 
 
576
 
        for (i = 0; i < size-1; i++) {
577
 
                d = 0;
578
 
                for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
579
 
                        md = r_short(p);
580
 
                        if (md < 0 || md > PyLong_MARSHAL_BASE)
581
 
                                goto bad_digit;
582
 
                        d += (digit)md << j*PyLong_MARSHAL_SHIFT;
583
 
                }
584
 
                ob->ob_digit[i] = d;
585
 
        }
586
 
        d = 0;
587
 
        for (j=0; j < shorts_in_top_digit; j++) {
588
 
                md = r_short(p);
589
 
                if (md < 0 || md > PyLong_MARSHAL_BASE)
590
 
                        goto bad_digit;
591
 
                /* topmost marshal digit should be nonzero */
592
 
                if (md == 0 && j == shorts_in_top_digit - 1) {
593
 
                        Py_DECREF(ob);
594
 
                        PyErr_SetString(PyExc_ValueError,
595
 
                                "bad marshal data (unnormalized long data)");
596
 
                        return NULL;
597
 
                }
598
 
                d += (digit)md << j*PyLong_MARSHAL_SHIFT;
599
 
        }
600
 
        /* top digit should be nonzero, else the resulting PyLong won't be
601
 
           normalized */
602
 
        ob->ob_digit[size-1] = d;
603
 
        return (PyObject *)ob;
 
555
    PyLongObject *ob;
 
556
    int size, i, j, md, shorts_in_top_digit;
 
557
    long n;
 
558
    digit d;
 
559
 
 
560
    n = r_long(p);
 
561
    if (n == 0)
 
562
        return (PyObject *)_PyLong_New(0);
 
563
    if (n < -INT_MAX || n > INT_MAX) {
 
564
        PyErr_SetString(PyExc_ValueError,
 
565
                       "bad marshal data (long size out of range)");
 
566
        return NULL;
 
567
    }
 
568
 
 
569
    size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
 
570
    shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
 
571
    ob = _PyLong_New(size);
 
572
    if (ob == NULL)
 
573
        return NULL;
 
574
    Py_SIZE(ob) = n > 0 ? size : -size;
 
575
 
 
576
    for (i = 0; i < size-1; i++) {
 
577
        d = 0;
 
578
        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
 
579
            md = r_short(p);
 
580
            if (md < 0 || md > PyLong_MARSHAL_BASE)
 
581
                goto bad_digit;
 
582
            d += (digit)md << j*PyLong_MARSHAL_SHIFT;
 
583
        }
 
584
        ob->ob_digit[i] = d;
 
585
    }
 
586
    d = 0;
 
587
    for (j=0; j < shorts_in_top_digit; j++) {
 
588
        md = r_short(p);
 
589
        if (md < 0 || md > PyLong_MARSHAL_BASE)
 
590
            goto bad_digit;
 
591
        /* topmost marshal digit should be nonzero */
 
592
        if (md == 0 && j == shorts_in_top_digit - 1) {
 
593
            Py_DECREF(ob);
 
594
            PyErr_SetString(PyExc_ValueError,
 
595
                "bad marshal data (unnormalized long data)");
 
596
            return NULL;
 
597
        }
 
598
        d += (digit)md << j*PyLong_MARSHAL_SHIFT;
 
599
    }
 
600
    /* top digit should be nonzero, else the resulting PyLong won't be
 
601
       normalized */
 
602
    ob->ob_digit[size-1] = d;
 
603
    return (PyObject *)ob;
604
604
  bad_digit:
605
 
        Py_DECREF(ob);
606
 
        PyErr_SetString(PyExc_ValueError,
607
 
                        "bad marshal data (digit out of range in long)");
608
 
        return NULL;
 
605
    Py_DECREF(ob);
 
606
    PyErr_SetString(PyExc_ValueError,
 
607
                    "bad marshal data (digit out of range in long)");
 
608
    return NULL;
609
609
}
610
610
 
611
611
 
612
612
static PyObject *
613
613
r_object(RFILE *p)
614
614
{
615
 
        /* NULL is a valid return value, it does not necessarily means that
616
 
           an exception is set. */
617
 
        PyObject *v, *v2;
618
 
        long i, n;
619
 
        int type = r_byte(p);
620
 
        PyObject *retval;
621
 
 
622
 
        p->depth++;
623
 
 
624
 
        if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
625
 
                p->depth--;
626
 
                PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
627
 
                return NULL;
628
 
        }
629
 
 
630
 
        switch (type) {
631
 
 
632
 
        case EOF:
633
 
                PyErr_SetString(PyExc_EOFError,
634
 
                                "EOF read where object expected");
635
 
                retval = NULL;
636
 
                break;
637
 
 
638
 
        case TYPE_NULL:
639
 
                retval = NULL;
640
 
                break;
641
 
 
642
 
        case TYPE_NONE:
643
 
                Py_INCREF(Py_None);
644
 
                retval = Py_None;
645
 
                break;
646
 
 
647
 
        case TYPE_STOPITER:
648
 
                Py_INCREF(PyExc_StopIteration);
649
 
                retval = PyExc_StopIteration;
650
 
                break;
651
 
 
652
 
        case TYPE_ELLIPSIS:
653
 
                Py_INCREF(Py_Ellipsis);
654
 
                retval = Py_Ellipsis;
655
 
                break;
656
 
 
657
 
        case TYPE_FALSE:
658
 
                Py_INCREF(Py_False);
659
 
                retval = Py_False;
660
 
                break;
661
 
 
662
 
        case TYPE_TRUE:
663
 
                Py_INCREF(Py_True);
664
 
                retval = Py_True;
665
 
                break;
666
 
 
667
 
        case TYPE_INT:
668
 
                retval = PyLong_FromLong(r_long(p));
669
 
                break;
670
 
 
671
 
        case TYPE_INT64:
672
 
                retval = r_long64(p);
673
 
                break;
674
 
 
675
 
        case TYPE_LONG:
676
 
                retval = r_PyLong(p);
677
 
                break;
678
 
 
679
 
        case TYPE_FLOAT:
680
 
                {
681
 
                        char buf[256];
682
 
                        double dx;
683
 
                        retval = NULL;
684
 
                        n = r_byte(p);
685
 
                        if (n == EOF || r_string(buf, (int)n, p) != n) {
686
 
                                PyErr_SetString(PyExc_EOFError,
687
 
                                        "EOF read where object expected");
688
 
                                break;
689
 
                        }
690
 
                        buf[n] = '\0';
691
 
                        dx = PyOS_string_to_double(buf, NULL, NULL);
692
 
                        if (dx == -1.0 && PyErr_Occurred())
693
 
                                break;
694
 
                        retval = PyFloat_FromDouble(dx);
695
 
                        break;
696
 
                }
697
 
 
698
 
        case TYPE_BINARY_FLOAT:
699
 
                {
700
 
                        unsigned char buf[8];
701
 
                        double x;
702
 
                        if (r_string((char*)buf, 8, p) != 8) {
703
 
                                PyErr_SetString(PyExc_EOFError,
704
 
                                        "EOF read where object expected");
705
 
                                retval = NULL;
706
 
                                break;
707
 
                        }
708
 
                        x = _PyFloat_Unpack8(buf, 1);
709
 
                        if (x == -1.0 && PyErr_Occurred()) {
710
 
                                retval = NULL;
711
 
                                break;
712
 
                        }
713
 
                        retval = PyFloat_FromDouble(x);
714
 
                        break;
715
 
                }
 
615
    /* NULL is a valid return value, it does not necessarily means that
 
616
       an exception is set. */
 
617
    PyObject *v, *v2;
 
618
    long i, n;
 
619
    int type = r_byte(p);
 
620
    PyObject *retval;
 
621
 
 
622
    p->depth++;
 
623
 
 
624
    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
 
625
        p->depth--;
 
626
        PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
 
627
        return NULL;
 
628
    }
 
629
 
 
630
    switch (type) {
 
631
 
 
632
    case EOF:
 
633
        PyErr_SetString(PyExc_EOFError,
 
634
                        "EOF read where object expected");
 
635
        retval = NULL;
 
636
        break;
 
637
 
 
638
    case TYPE_NULL:
 
639
        retval = NULL;
 
640
        break;
 
641
 
 
642
    case TYPE_NONE:
 
643
        Py_INCREF(Py_None);
 
644
        retval = Py_None;
 
645
        break;
 
646
 
 
647
    case TYPE_STOPITER:
 
648
        Py_INCREF(PyExc_StopIteration);
 
649
        retval = PyExc_StopIteration;
 
650
        break;
 
651
 
 
652
    case TYPE_ELLIPSIS:
 
653
        Py_INCREF(Py_Ellipsis);
 
654
        retval = Py_Ellipsis;
 
655
        break;
 
656
 
 
657
    case TYPE_FALSE:
 
658
        Py_INCREF(Py_False);
 
659
        retval = Py_False;
 
660
        break;
 
661
 
 
662
    case TYPE_TRUE:
 
663
        Py_INCREF(Py_True);
 
664
        retval = Py_True;
 
665
        break;
 
666
 
 
667
    case TYPE_INT:
 
668
        retval = PyLong_FromLong(r_long(p));
 
669
        break;
 
670
 
 
671
    case TYPE_INT64:
 
672
        retval = r_long64(p);
 
673
        break;
 
674
 
 
675
    case TYPE_LONG:
 
676
        retval = r_PyLong(p);
 
677
        break;
 
678
 
 
679
    case TYPE_FLOAT:
 
680
        {
 
681
            char buf[256];
 
682
            double dx;
 
683
            retval = NULL;
 
684
            n = r_byte(p);
 
685
            if (n == EOF || r_string(buf, (int)n, p) != n) {
 
686
                PyErr_SetString(PyExc_EOFError,
 
687
                    "EOF read where object expected");
 
688
                break;
 
689
            }
 
690
            buf[n] = '\0';
 
691
            dx = PyOS_string_to_double(buf, NULL, NULL);
 
692
            if (dx == -1.0 && PyErr_Occurred())
 
693
                break;
 
694
            retval = PyFloat_FromDouble(dx);
 
695
            break;
 
696
        }
 
697
 
 
698
    case TYPE_BINARY_FLOAT:
 
699
        {
 
700
            unsigned char buf[8];
 
701
            double x;
 
702
            if (r_string((char*)buf, 8, p) != 8) {
 
703
                PyErr_SetString(PyExc_EOFError,
 
704
                    "EOF read where object expected");
 
705
                retval = NULL;
 
706
                break;
 
707
            }
 
708
            x = _PyFloat_Unpack8(buf, 1);
 
709
            if (x == -1.0 && PyErr_Occurred()) {
 
710
                retval = NULL;
 
711
                break;
 
712
            }
 
713
            retval = PyFloat_FromDouble(x);
 
714
            break;
 
715
        }
716
716
 
717
717
#ifndef WITHOUT_COMPLEX
718
 
        case TYPE_COMPLEX:
719
 
                {
720
 
                        char buf[256];
721
 
                        Py_complex c;
722
 
                        retval = NULL;
723
 
                        n = r_byte(p);
724
 
                        if (n == EOF || r_string(buf, (int)n, p) != n) {
725
 
                                PyErr_SetString(PyExc_EOFError,
726
 
                                        "EOF read where object expected");
727
 
                                break;
728
 
                        }
729
 
                        buf[n] = '\0';
730
 
                        c.real = PyOS_string_to_double(buf, NULL, NULL);
731
 
                        if (c.real == -1.0 && PyErr_Occurred())
732
 
                                break;
733
 
                        n = r_byte(p);
734
 
                        if (n == EOF || r_string(buf, (int)n, p) != n) {
735
 
                                PyErr_SetString(PyExc_EOFError,
736
 
                                        "EOF read where object expected");
737
 
                                break;
738
 
                        }
739
 
                        buf[n] = '\0';
740
 
                        c.imag = PyOS_string_to_double(buf, NULL, NULL);
741
 
                        if (c.imag == -1.0 && PyErr_Occurred())
742
 
                                break;
743
 
                        retval = PyComplex_FromCComplex(c);
744
 
                        break;
745
 
                }
 
718
    case TYPE_COMPLEX:
 
719
        {
 
720
            char buf[256];
 
721
            Py_complex c;
 
722
            retval = NULL;
 
723
            n = r_byte(p);
 
724
            if (n == EOF || r_string(buf, (int)n, p) != n) {
 
725
                PyErr_SetString(PyExc_EOFError,
 
726
                    "EOF read where object expected");
 
727
                break;
 
728
            }
 
729
            buf[n] = '\0';
 
730
            c.real = PyOS_string_to_double(buf, NULL, NULL);
 
731
            if (c.real == -1.0 && PyErr_Occurred())
 
732
                break;
 
733
            n = r_byte(p);
 
734
            if (n == EOF || r_string(buf, (int)n, p) != n) {
 
735
                PyErr_SetString(PyExc_EOFError,
 
736
                    "EOF read where object expected");
 
737
                break;
 
738
            }
 
739
            buf[n] = '\0';
 
740
            c.imag = PyOS_string_to_double(buf, NULL, NULL);
 
741
            if (c.imag == -1.0 && PyErr_Occurred())
 
742
                break;
 
743
            retval = PyComplex_FromCComplex(c);
 
744
            break;
 
745
        }
746
746
 
747
 
        case TYPE_BINARY_COMPLEX:
748
 
                {
749
 
                        unsigned char buf[8];
750
 
                        Py_complex c;
751
 
                        if (r_string((char*)buf, 8, p) != 8) {
752
 
                                PyErr_SetString(PyExc_EOFError,
753
 
                                        "EOF read where object expected");
754
 
                                retval = NULL;
755
 
                                break;
756
 
                        }
757
 
                        c.real = _PyFloat_Unpack8(buf, 1);
758
 
                        if (c.real == -1.0 && PyErr_Occurred()) {
759
 
                                retval = NULL;
760
 
                                break;
761
 
                        }
762
 
                        if (r_string((char*)buf, 8, p) != 8) {
763
 
                                PyErr_SetString(PyExc_EOFError,
764
 
                                        "EOF read where object expected");
765
 
                                retval = NULL;
766
 
                                break;
767
 
                        }
768
 
                        c.imag = _PyFloat_Unpack8(buf, 1);
769
 
                        if (c.imag == -1.0 && PyErr_Occurred()) {
770
 
                                retval = NULL;
771
 
                                break;
772
 
                        }
773
 
                        retval = PyComplex_FromCComplex(c);
774
 
                        break;
775
 
                }
 
747
    case TYPE_BINARY_COMPLEX:
 
748
        {
 
749
            unsigned char buf[8];
 
750
            Py_complex c;
 
751
            if (r_string((char*)buf, 8, p) != 8) {
 
752
                PyErr_SetString(PyExc_EOFError,
 
753
                    "EOF read where object expected");
 
754
                retval = NULL;
 
755
                break;
 
756
            }
 
757
            c.real = _PyFloat_Unpack8(buf, 1);
 
758
            if (c.real == -1.0 && PyErr_Occurred()) {
 
759
                retval = NULL;
 
760
                break;
 
761
            }
 
762
            if (r_string((char*)buf, 8, p) != 8) {
 
763
                PyErr_SetString(PyExc_EOFError,
 
764
                    "EOF read where object expected");
 
765
                retval = NULL;
 
766
                break;
 
767
            }
 
768
            c.imag = _PyFloat_Unpack8(buf, 1);
 
769
            if (c.imag == -1.0 && PyErr_Occurred()) {
 
770
                retval = NULL;
 
771
                break;
 
772
            }
 
773
            retval = PyComplex_FromCComplex(c);
 
774
            break;
 
775
        }
776
776
#endif
777
777
 
778
 
        case TYPE_STRING:
779
 
                n = r_long(p);
780
 
                if (n < 0 || n > INT_MAX) {
781
 
                        PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
782
 
                        retval = NULL;
783
 
                        break;
784
 
                }
785
 
                v = PyBytes_FromStringAndSize((char *)NULL, n);
786
 
                if (v == NULL) {
787
 
                        retval = NULL;
788
 
                        break;
789
 
                }
790
 
                if (r_string(PyBytes_AS_STRING(v), (int)n, p) != n) {
791
 
                        Py_DECREF(v);
792
 
                        PyErr_SetString(PyExc_EOFError,
793
 
                                        "EOF read where object expected");
794
 
                        retval = NULL;
795
 
                        break;
796
 
                }
797
 
                retval = v;
798
 
                break;
799
 
 
800
 
        case TYPE_UNICODE:
801
 
            {
802
 
                char *buffer;
803
 
 
804
 
                n = r_long(p);
805
 
                if (n < 0 || n > INT_MAX) {
806
 
                        PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");
807
 
                        retval = NULL;
808
 
                        break;
809
 
                }
810
 
                buffer = PyMem_NEW(char, n);
811
 
                if (buffer == NULL) {
812
 
                        retval = PyErr_NoMemory();
813
 
                        break;
814
 
                }
815
 
                if (r_string(buffer, (int)n, p) != n) {
816
 
                        PyMem_DEL(buffer);
817
 
                        PyErr_SetString(PyExc_EOFError,
818
 
                                "EOF read where object expected");
819
 
                        retval = NULL;
820
 
                        break;
821
 
                }
822
 
                v = PyUnicode_DecodeUTF8(buffer, n, "surrogatepass");
823
 
                PyMem_DEL(buffer);
824
 
                retval = v;
825
 
                break;
826
 
            }
827
 
 
828
 
        case TYPE_TUPLE:
829
 
                n = r_long(p);
830
 
                if (n < 0 || n > INT_MAX) {
831
 
                        PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
832
 
                        retval = NULL;
833
 
                        break;
834
 
                }
835
 
                v = PyTuple_New((int)n);
836
 
                if (v == NULL) {
837
 
                        retval = NULL;
838
 
                        break;
839
 
                }
840
 
                for (i = 0; i < n; i++) {
841
 
                        v2 = r_object(p);
842
 
                        if ( v2 == NULL ) {
843
 
                                if (!PyErr_Occurred())
844
 
                                        PyErr_SetString(PyExc_TypeError,
845
 
                                                "NULL object in marshal data for tuple");
846
 
                                Py_DECREF(v);
847
 
                                v = NULL;
848
 
                                break;
849
 
                        }
850
 
                        PyTuple_SET_ITEM(v, (int)i, v2);
851
 
                }
852
 
                retval = v;
853
 
                break;
854
 
 
855
 
        case TYPE_LIST:
856
 
                n = r_long(p);
857
 
                if (n < 0 || n > INT_MAX) {
858
 
                        PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
859
 
                        retval = NULL;
860
 
                        break;
861
 
                }
862
 
                v = PyList_New((int)n);
863
 
                if (v == NULL) {
864
 
                        retval = NULL;
865
 
                        break;
866
 
                }
867
 
                for (i = 0; i < n; i++) {
868
 
                        v2 = r_object(p);
869
 
                        if ( v2 == NULL ) {
870
 
                                if (!PyErr_Occurred())
871
 
                                        PyErr_SetString(PyExc_TypeError,
872
 
                                                "NULL object in marshal data for list");
873
 
                                Py_DECREF(v);
874
 
                                v = NULL;
875
 
                                break;
876
 
                        }
877
 
                        PyList_SET_ITEM(v, (int)i, v2);
878
 
                }
879
 
                retval = v;
880
 
                break;
881
 
 
882
 
        case TYPE_DICT:
883
 
                v = PyDict_New();
884
 
                if (v == NULL) {
885
 
                        retval = NULL;
886
 
                        break;
887
 
                }
888
 
                for (;;) {
889
 
                        PyObject *key, *val;
890
 
                        key = r_object(p);
891
 
                        if (key == NULL)
892
 
                                break;
893
 
                        val = r_object(p);
894
 
                        if (val != NULL)
895
 
                                PyDict_SetItem(v, key, val);
896
 
                        Py_DECREF(key);
897
 
                        Py_XDECREF(val);
898
 
                }
899
 
                if (PyErr_Occurred()) {
900
 
                        Py_DECREF(v);
901
 
                        v = NULL;
902
 
                }
903
 
                retval = v;
904
 
                break;
905
 
 
906
 
        case TYPE_SET:
907
 
        case TYPE_FROZENSET:
908
 
                n = r_long(p);
909
 
                if (n < 0 || n > INT_MAX) {
910
 
                        PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
911
 
                        retval = NULL;
912
 
                        break;
913
 
                }
914
 
                v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
915
 
                if (v == NULL) {
916
 
                        retval = NULL;
917
 
                        break;
918
 
                }
919
 
                for (i = 0; i < n; i++) {
920
 
                        v2 = r_object(p);
921
 
                        if ( v2 == NULL ) {
922
 
                                if (!PyErr_Occurred())
923
 
                                        PyErr_SetString(PyExc_TypeError,
924
 
                                                "NULL object in marshal data for set");
925
 
                                Py_DECREF(v);
926
 
                                v = NULL;
927
 
                                break;
928
 
                        }
929
 
                        if (PySet_Add(v, v2) == -1) {
930
 
                                Py_DECREF(v);
931
 
                                Py_DECREF(v2);
932
 
                                v = NULL;
933
 
                                break;
934
 
                        }
935
 
                        Py_DECREF(v2);
936
 
                }
937
 
                retval = v;
938
 
                break;
939
 
 
940
 
        case TYPE_CODE:
941
 
                {
942
 
                        int argcount;
943
 
                        int kwonlyargcount;
944
 
                        int nlocals;
945
 
                        int stacksize;
946
 
                        int flags;
947
 
                        PyObject *code = NULL;
948
 
                        PyObject *consts = NULL;
949
 
                        PyObject *names = NULL;
950
 
                        PyObject *varnames = NULL;
951
 
                        PyObject *freevars = NULL;
952
 
                        PyObject *cellvars = NULL;
953
 
                        PyObject *filename = NULL;
954
 
                        PyObject *name = NULL;
955
 
                        int firstlineno;
956
 
                        PyObject *lnotab = NULL;
957
 
                        
958
 
                        v = NULL;
959
 
 
960
 
                        /* XXX ignore long->int overflows for now */
961
 
                        argcount = (int)r_long(p);
962
 
                        kwonlyargcount = (int)r_long(p);
963
 
                        nlocals = (int)r_long(p);
964
 
                        stacksize = (int)r_long(p);
965
 
                        flags = (int)r_long(p);
966
 
                        code = r_object(p);
967
 
                        if (code == NULL)
968
 
                                goto code_error;
969
 
                        consts = r_object(p);
970
 
                        if (consts == NULL)
971
 
                                goto code_error;
972
 
                        names = r_object(p);
973
 
                        if (names == NULL)
974
 
                                goto code_error;
975
 
                        varnames = r_object(p);
976
 
                        if (varnames == NULL)
977
 
                                goto code_error;
978
 
                        freevars = r_object(p);
979
 
                        if (freevars == NULL)
980
 
                                goto code_error;
981
 
                        cellvars = r_object(p);
982
 
                        if (cellvars == NULL)
983
 
                                goto code_error;
984
 
                        filename = r_object(p);
985
 
                        if (filename == NULL)
986
 
                                goto code_error;
987
 
                        name = r_object(p);
988
 
                        if (name == NULL)
989
 
                                goto code_error;
990
 
                        firstlineno = (int)r_long(p);
991
 
                        lnotab = r_object(p);
992
 
                        if (lnotab == NULL)
993
 
                                goto code_error;
994
 
 
995
 
                        v = (PyObject *) PyCode_New(
996
 
                                        argcount, kwonlyargcount,
997
 
                                        nlocals, stacksize, flags,
998
 
                                        code, consts, names, varnames,
999
 
                                        freevars, cellvars, filename, name,
1000
 
                                        firstlineno, lnotab);
1001
 
 
1002
 
                  code_error:
1003
 
                        Py_XDECREF(code);
1004
 
                        Py_XDECREF(consts);
1005
 
                        Py_XDECREF(names);
1006
 
                        Py_XDECREF(varnames);
1007
 
                        Py_XDECREF(freevars);
1008
 
                        Py_XDECREF(cellvars);
1009
 
                        Py_XDECREF(filename);
1010
 
                        Py_XDECREF(name);
1011
 
                        Py_XDECREF(lnotab);
1012
 
                }
1013
 
                retval = v;
1014
 
                break;
1015
 
 
1016
 
        default:
1017
 
                /* Bogus data got written, which isn't ideal.
1018
 
                   This will let you keep working and recover. */
1019
 
                PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
1020
 
                retval = NULL;
1021
 
                break;
1022
 
 
1023
 
        }
1024
 
        p->depth--;
1025
 
        return retval;
 
778
    case TYPE_STRING:
 
779
        n = r_long(p);
 
780
        if (n < 0 || n > INT_MAX) {
 
781
            PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
 
782
            retval = NULL;
 
783
            break;
 
784
        }
 
785
        v = PyBytes_FromStringAndSize((char *)NULL, n);
 
786
        if (v == NULL) {
 
787
            retval = NULL;
 
788
            break;
 
789
        }
 
790
        if (r_string(PyBytes_AS_STRING(v), (int)n, p) != n) {
 
791
            Py_DECREF(v);
 
792
            PyErr_SetString(PyExc_EOFError,
 
793
                            "EOF read where object expected");
 
794
            retval = NULL;
 
795
            break;
 
796
        }
 
797
        retval = v;
 
798
        break;
 
799
 
 
800
    case TYPE_UNICODE:
 
801
        {
 
802
        char *buffer;
 
803
 
 
804
        n = r_long(p);
 
805
        if (n < 0 || n > INT_MAX) {
 
806
            PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");
 
807
            retval = NULL;
 
808
            break;
 
809
        }
 
810
        buffer = PyMem_NEW(char, n);
 
811
        if (buffer == NULL) {
 
812
            retval = PyErr_NoMemory();
 
813
            break;
 
814
        }
 
815
        if (r_string(buffer, (int)n, p) != n) {
 
816
            PyMem_DEL(buffer);
 
817
            PyErr_SetString(PyExc_EOFError,
 
818
                "EOF read where object expected");
 
819
            retval = NULL;
 
820
            break;
 
821
        }
 
822
        v = PyUnicode_DecodeUTF8(buffer, n, "surrogatepass");
 
823
        PyMem_DEL(buffer);
 
824
        retval = v;
 
825
        break;
 
826
        }
 
827
 
 
828
    case TYPE_TUPLE:
 
829
        n = r_long(p);
 
830
        if (n < 0 || n > INT_MAX) {
 
831
            PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
 
832
            retval = NULL;
 
833
            break;
 
834
        }
 
835
        v = PyTuple_New((int)n);
 
836
        if (v == NULL) {
 
837
            retval = NULL;
 
838
            break;
 
839
        }
 
840
        for (i = 0; i < n; i++) {
 
841
            v2 = r_object(p);
 
842
            if ( v2 == NULL ) {
 
843
                if (!PyErr_Occurred())
 
844
                    PyErr_SetString(PyExc_TypeError,
 
845
                        "NULL object in marshal data for tuple");
 
846
                Py_DECREF(v);
 
847
                v = NULL;
 
848
                break;
 
849
            }
 
850
            PyTuple_SET_ITEM(v, (int)i, v2);
 
851
        }
 
852
        retval = v;
 
853
        break;
 
854
 
 
855
    case TYPE_LIST:
 
856
        n = r_long(p);
 
857
        if (n < 0 || n > INT_MAX) {
 
858
            PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
 
859
            retval = NULL;
 
860
            break;
 
861
        }
 
862
        v = PyList_New((int)n);
 
863
        if (v == NULL) {
 
864
            retval = NULL;
 
865
            break;
 
866
        }
 
867
        for (i = 0; i < n; i++) {
 
868
            v2 = r_object(p);
 
869
            if ( v2 == NULL ) {
 
870
                if (!PyErr_Occurred())
 
871
                    PyErr_SetString(PyExc_TypeError,
 
872
                        "NULL object in marshal data for list");
 
873
                Py_DECREF(v);
 
874
                v = NULL;
 
875
                break;
 
876
            }
 
877
            PyList_SET_ITEM(v, (int)i, v2);
 
878
        }
 
879
        retval = v;
 
880
        break;
 
881
 
 
882
    case TYPE_DICT:
 
883
        v = PyDict_New();
 
884
        if (v == NULL) {
 
885
            retval = NULL;
 
886
            break;
 
887
        }
 
888
        for (;;) {
 
889
            PyObject *key, *val;
 
890
            key = r_object(p);
 
891
            if (key == NULL)
 
892
                break;
 
893
            val = r_object(p);
 
894
            if (val != NULL)
 
895
                PyDict_SetItem(v, key, val);
 
896
            Py_DECREF(key);
 
897
            Py_XDECREF(val);
 
898
        }
 
899
        if (PyErr_Occurred()) {
 
900
            Py_DECREF(v);
 
901
            v = NULL;
 
902
        }
 
903
        retval = v;
 
904
        break;
 
905
 
 
906
    case TYPE_SET:
 
907
    case TYPE_FROZENSET:
 
908
        n = r_long(p);
 
909
        if (n < 0 || n > INT_MAX) {
 
910
            PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
 
911
            retval = NULL;
 
912
            break;
 
913
        }
 
914
        v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
 
915
        if (v == NULL) {
 
916
            retval = NULL;
 
917
            break;
 
918
        }
 
919
        for (i = 0; i < n; i++) {
 
920
            v2 = r_object(p);
 
921
            if ( v2 == NULL ) {
 
922
                if (!PyErr_Occurred())
 
923
                    PyErr_SetString(PyExc_TypeError,
 
924
                        "NULL object in marshal data for set");
 
925
                Py_DECREF(v);
 
926
                v = NULL;
 
927
                break;
 
928
            }
 
929
            if (PySet_Add(v, v2) == -1) {
 
930
                Py_DECREF(v);
 
931
                Py_DECREF(v2);
 
932
                v = NULL;
 
933
                break;
 
934
            }
 
935
            Py_DECREF(v2);
 
936
        }
 
937
        retval = v;
 
938
        break;
 
939
 
 
940
    case TYPE_CODE:
 
941
        {
 
942
            int argcount;
 
943
            int kwonlyargcount;
 
944
            int nlocals;
 
945
            int stacksize;
 
946
            int flags;
 
947
            PyObject *code = NULL;
 
948
            PyObject *consts = NULL;
 
949
            PyObject *names = NULL;
 
950
            PyObject *varnames = NULL;
 
951
            PyObject *freevars = NULL;
 
952
            PyObject *cellvars = NULL;
 
953
            PyObject *filename = NULL;
 
954
            PyObject *name = NULL;
 
955
            int firstlineno;
 
956
            PyObject *lnotab = NULL;
 
957
 
 
958
            v = NULL;
 
959
 
 
960
            /* XXX ignore long->int overflows for now */
 
961
            argcount = (int)r_long(p);
 
962
            kwonlyargcount = (int)r_long(p);
 
963
            nlocals = (int)r_long(p);
 
964
            stacksize = (int)r_long(p);
 
965
            flags = (int)r_long(p);
 
966
            code = r_object(p);
 
967
            if (code == NULL)
 
968
                goto code_error;
 
969
            consts = r_object(p);
 
970
            if (consts == NULL)
 
971
                goto code_error;
 
972
            names = r_object(p);
 
973
            if (names == NULL)
 
974
                goto code_error;
 
975
            varnames = r_object(p);
 
976
            if (varnames == NULL)
 
977
                goto code_error;
 
978
            freevars = r_object(p);
 
979
            if (freevars == NULL)
 
980
                goto code_error;
 
981
            cellvars = r_object(p);
 
982
            if (cellvars == NULL)
 
983
                goto code_error;
 
984
            filename = r_object(p);
 
985
            if (filename == NULL)
 
986
                goto code_error;
 
987
            name = r_object(p);
 
988
            if (name == NULL)
 
989
                goto code_error;
 
990
            firstlineno = (int)r_long(p);
 
991
            lnotab = r_object(p);
 
992
            if (lnotab == NULL)
 
993
                goto code_error;
 
994
 
 
995
            v = (PyObject *) PyCode_New(
 
996
                            argcount, kwonlyargcount,
 
997
                            nlocals, stacksize, flags,
 
998
                            code, consts, names, varnames,
 
999
                            freevars, cellvars, filename, name,
 
1000
                            firstlineno, lnotab);
 
1001
 
 
1002
          code_error:
 
1003
            Py_XDECREF(code);
 
1004
            Py_XDECREF(consts);
 
1005
            Py_XDECREF(names);
 
1006
            Py_XDECREF(varnames);
 
1007
            Py_XDECREF(freevars);
 
1008
            Py_XDECREF(cellvars);
 
1009
            Py_XDECREF(filename);
 
1010
            Py_XDECREF(name);
 
1011
            Py_XDECREF(lnotab);
 
1012
        }
 
1013
        retval = v;
 
1014
        break;
 
1015
 
 
1016
    default:
 
1017
        /* Bogus data got written, which isn't ideal.
 
1018
           This will let you keep working and recover. */
 
1019
        PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
 
1020
        retval = NULL;
 
1021
        break;
 
1022
 
 
1023
    }
 
1024
    p->depth--;
 
1025
    return retval;
1026
1026
}
1027
1027
 
1028
1028
static PyObject *
1029
1029
read_object(RFILE *p)
1030
1030
{
1031
 
        PyObject *v;
1032
 
        if (PyErr_Occurred()) {
1033
 
                fprintf(stderr, "XXX readobject called with exception set\n");
1034
 
                return NULL;
1035
 
        }
1036
 
        v = r_object(p);
1037
 
        if (v == NULL && !PyErr_Occurred())
1038
 
                PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
1039
 
        return v;
 
1031
    PyObject *v;
 
1032
    if (PyErr_Occurred()) {
 
1033
        fprintf(stderr, "XXX readobject called with exception set\n");
 
1034
        return NULL;
 
1035
    }
 
1036
    v = r_object(p);
 
1037
    if (v == NULL && !PyErr_Occurred())
 
1038
        PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
 
1039
    return v;
1040
1040
}
1041
1041
 
1042
1042
int
1043
1043
PyMarshal_ReadShortFromFile(FILE *fp)
1044
1044
{
1045
 
        RFILE rf;
1046
 
        assert(fp);
1047
 
        rf.fp = fp;
1048
 
        rf.strings = NULL;
1049
 
        rf.end = rf.ptr = NULL;
1050
 
        return r_short(&rf);
 
1045
    RFILE rf;
 
1046
    assert(fp);
 
1047
    rf.fp = fp;
 
1048
    rf.strings = NULL;
 
1049
    rf.end = rf.ptr = NULL;
 
1050
    return r_short(&rf);
1051
1051
}
1052
1052
 
1053
1053
long
1054
1054
PyMarshal_ReadLongFromFile(FILE *fp)
1055
1055
{
1056
 
        RFILE rf;
1057
 
        rf.fp = fp;
1058
 
        rf.strings = NULL;
1059
 
        rf.ptr = rf.end = NULL;
1060
 
        return r_long(&rf);
 
1056
    RFILE rf;
 
1057
    rf.fp = fp;
 
1058
    rf.strings = NULL;
 
1059
    rf.ptr = rf.end = NULL;
 
1060
    return r_long(&rf);
1061
1061
}
1062
1062
 
1063
1063
#ifdef HAVE_FSTAT
1065
1065
static off_t
1066
1066
getfilesize(FILE *fp)
1067
1067
{
1068
 
        struct stat st;
1069
 
        if (fstat(fileno(fp), &st) != 0)
1070
 
                return -1;
1071
 
        else
1072
 
                return st.st_size;
 
1068
    struct stat st;
 
1069
    if (fstat(fileno(fp), &st) != 0)
 
1070
        return -1;
 
1071
    else
 
1072
        return st.st_size;
1073
1073
}
1074
1074
#endif
1075
1075
 
1088
1088
#define SMALL_FILE_LIMIT (1L << 14)
1089
1089
#define REASONABLE_FILE_LIMIT (1L << 18)
1090
1090
#ifdef HAVE_FSTAT
1091
 
        off_t filesize;
 
1091
    off_t filesize;
1092
1092
#endif
1093
1093
#ifdef HAVE_FSTAT
1094
 
        filesize = getfilesize(fp);
1095
 
        if (filesize > 0) {
1096
 
                char buf[SMALL_FILE_LIMIT];
1097
 
                char* pBuf = NULL;
1098
 
                if (filesize <= SMALL_FILE_LIMIT)
1099
 
                        pBuf = buf;
1100
 
                else if (filesize <= REASONABLE_FILE_LIMIT)
1101
 
                        pBuf = (char *)PyMem_MALLOC(filesize);
1102
 
                if (pBuf != NULL) {
1103
 
                        PyObject* v;
1104
 
                        size_t n;
1105
 
                        /* filesize must fit into an int, because it
1106
 
                           is smaller than REASONABLE_FILE_LIMIT */
1107
 
                        n = fread(pBuf, 1, (int)filesize, fp);
1108
 
                        v = PyMarshal_ReadObjectFromString(pBuf, n);
1109
 
                        if (pBuf != buf)
1110
 
                                PyMem_FREE(pBuf);
1111
 
                        return v;
1112
 
                }
 
1094
    filesize = getfilesize(fp);
 
1095
    if (filesize > 0) {
 
1096
        char buf[SMALL_FILE_LIMIT];
 
1097
        char* pBuf = NULL;
 
1098
        if (filesize <= SMALL_FILE_LIMIT)
 
1099
            pBuf = buf;
 
1100
        else if (filesize <= REASONABLE_FILE_LIMIT)
 
1101
            pBuf = (char *)PyMem_MALLOC(filesize);
 
1102
        if (pBuf != NULL) {
 
1103
            PyObject* v;
 
1104
            size_t n;
 
1105
            /* filesize must fit into an int, because it
 
1106
               is smaller than REASONABLE_FILE_LIMIT */
 
1107
            n = fread(pBuf, 1, (int)filesize, fp);
 
1108
            v = PyMarshal_ReadObjectFromString(pBuf, n);
 
1109
            if (pBuf != buf)
 
1110
                PyMem_FREE(pBuf);
 
1111
            return v;
 
1112
        }
1113
1113
 
1114
 
        }
 
1114
    }
1115
1115
#endif
1116
 
        /* We don't have fstat, or we do but the file is larger than
1117
 
         * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
1118
 
         */
1119
 
        return PyMarshal_ReadObjectFromFile(fp);
 
1116
    /* We don't have fstat, or we do but the file is larger than
 
1117
     * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
 
1118
     */
 
1119
    return PyMarshal_ReadObjectFromFile(fp);
1120
1120
 
1121
1121
#undef SMALL_FILE_LIMIT
1122
1122
#undef REASONABLE_FILE_LIMIT
1125
1125
PyObject *
1126
1126
PyMarshal_ReadObjectFromFile(FILE *fp)
1127
1127
{
1128
 
        RFILE rf;
1129
 
        PyObject *result;
1130
 
        rf.fp = fp;
1131
 
        rf.strings = PyList_New(0);
1132
 
        rf.depth = 0;
1133
 
        rf.ptr = rf.end = NULL;
1134
 
        result = r_object(&rf);
1135
 
        Py_DECREF(rf.strings);
1136
 
        return result;
 
1128
    RFILE rf;
 
1129
    PyObject *result;
 
1130
    rf.fp = fp;
 
1131
    rf.strings = PyList_New(0);
 
1132
    rf.depth = 0;
 
1133
    rf.ptr = rf.end = NULL;
 
1134
    result = r_object(&rf);
 
1135
    Py_DECREF(rf.strings);
 
1136
    return result;
1137
1137
}
1138
1138
 
1139
1139
PyObject *
1140
1140
PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len)
1141
1141
{
1142
 
        RFILE rf;
1143
 
        PyObject *result;
1144
 
        rf.fp = NULL;
1145
 
        rf.ptr = str;
1146
 
        rf.end = str + len;
1147
 
        rf.strings = PyList_New(0);
1148
 
        rf.depth = 0;
1149
 
        result = r_object(&rf);
1150
 
        Py_DECREF(rf.strings);
1151
 
        return result;
 
1142
    RFILE rf;
 
1143
    PyObject *result;
 
1144
    rf.fp = NULL;
 
1145
    rf.ptr = str;
 
1146
    rf.end = str + len;
 
1147
    rf.strings = PyList_New(0);
 
1148
    rf.depth = 0;
 
1149
    result = r_object(&rf);
 
1150
    Py_DECREF(rf.strings);
 
1151
    return result;
1152
1152
}
1153
1153
 
1154
1154
PyObject *
1155
1155
PyMarshal_WriteObjectToString(PyObject *x, int version)
1156
1156
{
1157
 
        WFILE wf;
1158
 
        PyObject *res = NULL;
 
1157
    WFILE wf;
 
1158
    PyObject *res = NULL;
1159
1159
 
1160
 
        wf.fp = NULL;
1161
 
        wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
1162
 
        if (wf.str == NULL)
1163
 
                return NULL;
1164
 
        wf.ptr = PyBytes_AS_STRING((PyBytesObject *)wf.str);
1165
 
        wf.end = wf.ptr + PyBytes_Size(wf.str);
1166
 
        wf.error = WFERR_OK;
1167
 
        wf.depth = 0;
1168
 
        wf.version = version;
1169
 
        wf.strings = (version > 0) ? PyDict_New() : NULL;
1170
 
        w_object(x, &wf);
1171
 
        Py_XDECREF(wf.strings);
1172
 
        if (wf.str != NULL) {
1173
 
                char *base = PyBytes_AS_STRING((PyBytesObject *)wf.str);
1174
 
                if (wf.ptr - base > PY_SSIZE_T_MAX) {
1175
 
                        Py_DECREF(wf.str);
1176
 
                        PyErr_SetString(PyExc_OverflowError,
1177
 
                                        "too much marshal data for a string");
1178
 
                        return NULL;
1179
 
                }
1180
 
                if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
1181
 
                        return NULL;
1182
 
        }
1183
 
        if (wf.error != WFERR_OK) {
1184
 
                Py_XDECREF(wf.str);
1185
 
                if (wf.error == WFERR_NOMEMORY)
1186
 
                    PyErr_NoMemory();
1187
 
                else
1188
 
                    PyErr_SetString(PyExc_ValueError,
1189
 
                      (wf.error==WFERR_UNMARSHALLABLE)?"unmarshallable object"
1190
 
                       :"object too deeply nested to marshal");
1191
 
                return NULL;
1192
 
        }
1193
 
        if (wf.str != NULL) {
1194
 
                /* XXX Quick hack -- need to do this differently */
1195
 
                res = PyBytes_FromObject(wf.str);
1196
 
                Py_DECREF(wf.str);
1197
 
        }
1198
 
        return res;
 
1160
    wf.fp = NULL;
 
1161
    wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
 
1162
    if (wf.str == NULL)
 
1163
        return NULL;
 
1164
    wf.ptr = PyBytes_AS_STRING((PyBytesObject *)wf.str);
 
1165
    wf.end = wf.ptr + PyBytes_Size(wf.str);
 
1166
    wf.error = WFERR_OK;
 
1167
    wf.depth = 0;
 
1168
    wf.version = version;
 
1169
    wf.strings = (version > 0) ? PyDict_New() : NULL;
 
1170
    w_object(x, &wf);
 
1171
    Py_XDECREF(wf.strings);
 
1172
    if (wf.str != NULL) {
 
1173
        char *base = PyBytes_AS_STRING((PyBytesObject *)wf.str);
 
1174
        if (wf.ptr - base > PY_SSIZE_T_MAX) {
 
1175
            Py_DECREF(wf.str);
 
1176
            PyErr_SetString(PyExc_OverflowError,
 
1177
                            "too much marshal data for a string");
 
1178
            return NULL;
 
1179
        }
 
1180
        if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
 
1181
            return NULL;
 
1182
    }
 
1183
    if (wf.error != WFERR_OK) {
 
1184
        Py_XDECREF(wf.str);
 
1185
        if (wf.error == WFERR_NOMEMORY)
 
1186
            PyErr_NoMemory();
 
1187
        else
 
1188
            PyErr_SetString(PyExc_ValueError,
 
1189
              (wf.error==WFERR_UNMARSHALLABLE)?"unmarshallable object"
 
1190
               :"object too deeply nested to marshal");
 
1191
        return NULL;
 
1192
    }
 
1193
    if (wf.str != NULL) {
 
1194
        /* XXX Quick hack -- need to do this differently */
 
1195
        res = PyBytes_FromObject(wf.str);
 
1196
        Py_DECREF(wf.str);
 
1197
    }
 
1198
    return res;
1199
1199
}
1200
1200
 
1201
1201
/* And an interface for Python programs... */
1203
1203
static PyObject *
1204
1204
marshal_dump(PyObject *self, PyObject *args)
1205
1205
{
1206
 
        /* XXX Quick hack -- need to do this differently */
1207
 
        PyObject *x;
1208
 
        PyObject *f;
1209
 
        int version = Py_MARSHAL_VERSION;
1210
 
        PyObject *s;
1211
 
        PyObject *res;
1212
 
        if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
1213
 
                return NULL;
1214
 
        s = PyMarshal_WriteObjectToString(x, version);
1215
 
        if (s == NULL)
1216
 
                return NULL;
1217
 
        res = PyObject_CallMethod(f, "write", "O", s);
1218
 
        Py_DECREF(s);
1219
 
        return res;
 
1206
    /* XXX Quick hack -- need to do this differently */
 
1207
    PyObject *x;
 
1208
    PyObject *f;
 
1209
    int version = Py_MARSHAL_VERSION;
 
1210
    PyObject *s;
 
1211
    PyObject *res;
 
1212
    if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
 
1213
        return NULL;
 
1214
    s = PyMarshal_WriteObjectToString(x, version);
 
1215
    if (s == NULL)
 
1216
        return NULL;
 
1217
    res = PyObject_CallMethod(f, "write", "O", s);
 
1218
    Py_DECREF(s);
 
1219
    return res;
1220
1220
}
1221
1221
 
1222
1222
PyDoc_STRVAR(dump_doc,
1235
1235
static PyObject *
1236
1236
marshal_load(PyObject *self, PyObject *f)
1237
1237
{
1238
 
        /* XXX Quick hack -- need to do this differently */
1239
 
        PyObject *data, *result;
1240
 
        RFILE rf;
1241
 
        data = PyObject_CallMethod(f, "read", "");
1242
 
        if (data == NULL)
1243
 
                return NULL;
1244
 
        rf.fp = NULL;
1245
 
        if (PyBytes_Check(data)) {
1246
 
                rf.ptr = PyBytes_AS_STRING(data);
1247
 
                rf.end = rf.ptr + PyBytes_GET_SIZE(data);
1248
 
        }
1249
 
        else if (PyBytes_Check(data)) {
1250
 
                rf.ptr = PyBytes_AS_STRING(data);
1251
 
                rf.end = rf.ptr + PyBytes_GET_SIZE(data);
1252
 
        }
1253
 
        else {
1254
 
                PyErr_Format(PyExc_TypeError,
1255
 
                             "f.read() returned neither string "
1256
 
                             "nor bytes but %.100s",
1257
 
                             data->ob_type->tp_name);
1258
 
                Py_DECREF(data);
1259
 
                return NULL;
1260
 
        }
1261
 
        rf.strings = PyList_New(0);
1262
 
        rf.depth = 0;
1263
 
        result = read_object(&rf);
1264
 
        Py_DECREF(rf.strings);
1265
 
        Py_DECREF(data);
1266
 
        return result;
 
1238
    /* XXX Quick hack -- need to do this differently */
 
1239
    PyObject *data, *result;
 
1240
    RFILE rf;
 
1241
    data = PyObject_CallMethod(f, "read", "");
 
1242
    if (data == NULL)
 
1243
        return NULL;
 
1244
    rf.fp = NULL;
 
1245
    if (PyBytes_Check(data)) {
 
1246
        rf.ptr = PyBytes_AS_STRING(data);
 
1247
        rf.end = rf.ptr + PyBytes_GET_SIZE(data);
 
1248
    }
 
1249
    else if (PyBytes_Check(data)) {
 
1250
        rf.ptr = PyBytes_AS_STRING(data);
 
1251
        rf.end = rf.ptr + PyBytes_GET_SIZE(data);
 
1252
    }
 
1253
    else {
 
1254
        PyErr_Format(PyExc_TypeError,
 
1255
                     "f.read() returned neither string "
 
1256
                     "nor bytes but %.100s",
 
1257
                     data->ob_type->tp_name);
 
1258
        Py_DECREF(data);
 
1259
        return NULL;
 
1260
    }
 
1261
    rf.strings = PyList_New(0);
 
1262
    rf.depth = 0;
 
1263
    result = read_object(&rf);
 
1264
    Py_DECREF(rf.strings);
 
1265
    Py_DECREF(data);
 
1266
    return result;
1267
1267
}
1268
1268
 
1269
1269
PyDoc_STRVAR(load_doc,
1282
1282
static PyObject *
1283
1283
marshal_dumps(PyObject *self, PyObject *args)
1284
1284
{
1285
 
        PyObject *x;
1286
 
        int version = Py_MARSHAL_VERSION;
1287
 
        if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
1288
 
                return NULL;
1289
 
        return PyMarshal_WriteObjectToString(x, version);
 
1285
    PyObject *x;
 
1286
    int version = Py_MARSHAL_VERSION;
 
1287
    if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
 
1288
        return NULL;
 
1289
    return PyMarshal_WriteObjectToString(x, version);
1290
1290
}
1291
1291
 
1292
1292
PyDoc_STRVAR(dumps_doc,
1302
1302
static PyObject *
1303
1303
marshal_loads(PyObject *self, PyObject *args)
1304
1304
{
1305
 
        RFILE rf;
1306
 
        Py_buffer p;
1307
 
        char *s;
1308
 
        Py_ssize_t n;
1309
 
        PyObject* result;
1310
 
        if (!PyArg_ParseTuple(args, "s*:loads", &p))
1311
 
                return NULL;
1312
 
        s = p.buf;
1313
 
        n = p.len;
1314
 
        rf.fp = NULL;
1315
 
        rf.ptr = s;
1316
 
        rf.end = s + n;
1317
 
        rf.strings = PyList_New(0);
1318
 
        rf.depth = 0;
1319
 
        result = read_object(&rf);
1320
 
        Py_DECREF(rf.strings);
1321
 
        PyBuffer_Release(&p);
1322
 
        return result;
 
1305
    RFILE rf;
 
1306
    Py_buffer p;
 
1307
    char *s;
 
1308
    Py_ssize_t n;
 
1309
    PyObject* result;
 
1310
    if (!PyArg_ParseTuple(args, "s*:loads", &p))
 
1311
        return NULL;
 
1312
    s = p.buf;
 
1313
    n = p.len;
 
1314
    rf.fp = NULL;
 
1315
    rf.ptr = s;
 
1316
    rf.end = s + n;
 
1317
    rf.strings = PyList_New(0);
 
1318
    rf.depth = 0;
 
1319
    result = read_object(&rf);
 
1320
    Py_DECREF(rf.strings);
 
1321
    PyBuffer_Release(&p);
 
1322
    return result;
1323
1323
}
1324
1324
 
1325
1325
PyDoc_STRVAR(loads_doc,
1330
1330
ignored.");
1331
1331
 
1332
1332
static PyMethodDef marshal_methods[] = {
1333
 
        {"dump",        marshal_dump,   METH_VARARGS,   dump_doc},
1334
 
        {"load",        marshal_load,   METH_O,         load_doc},
1335
 
        {"dumps",       marshal_dumps,  METH_VARARGS,   dumps_doc},
1336
 
        {"loads",       marshal_loads,  METH_VARARGS,   loads_doc},
1337
 
        {NULL,          NULL}           /* sentinel */
 
1333
    {"dump",            marshal_dump,   METH_VARARGS,   dump_doc},
 
1334
    {"load",            marshal_load,   METH_O,         load_doc},
 
1335
    {"dumps",           marshal_dumps,  METH_VARARGS,   dumps_doc},
 
1336
    {"loads",           marshal_loads,  METH_VARARGS,   loads_doc},
 
1337
    {NULL,              NULL}           /* sentinel */
1338
1338
};
1339
1339
 
1340
1340
 
1369
1369
 
1370
1370
 
1371
1371
static struct PyModuleDef marshalmodule = {
1372
 
        PyModuleDef_HEAD_INIT,
1373
 
        "marshal",
1374
 
        module_doc,
1375
 
        0,
1376
 
        marshal_methods,
1377
 
        NULL,
1378
 
        NULL,
1379
 
        NULL,
1380
 
        NULL
 
1372
    PyModuleDef_HEAD_INIT,
 
1373
    "marshal",
 
1374
    module_doc,
 
1375
    0,
 
1376
    marshal_methods,
 
1377
    NULL,
 
1378
    NULL,
 
1379
    NULL,
 
1380
    NULL
1381
1381
};
1382
1382
 
1383
1383
PyMODINIT_FUNC
1384
1384
PyMarshal_Init(void)
1385
1385
{
1386
 
        PyObject *mod = PyModule_Create(&marshalmodule);
1387
 
        if (mod == NULL)
1388
 
                return NULL;
1389
 
        PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
1390
 
        return mod;
 
1386
    PyObject *mod = PyModule_Create(&marshalmodule);
 
1387
    if (mod == NULL)
 
1388
        return NULL;
 
1389
    PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
 
1390
    return mod;
1391
1391
}