← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Python/marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

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