marshal.c 18.2 KB
Newer Older
Guido van Rossum's avatar
Guido van Rossum committed
1 2 3 4 5 6

/* Write Python objects to files and read them back.
   This is intended for writing and reading compiled Python code only;
   a true persistent storage facility would be much harder, since
   it would have to take circular links and sharing into account. */

7
#include "Python.h"
Guido van Rossum's avatar
Guido van Rossum committed
8 9 10 11
#include "longintrepr.h"
#include "compile.h"
#include "marshal.h"

12 13 14 15 16 17
/* High water mark to determine when the marshalled object is dangerously deep
 * and risks coring the interpreter.  When the object stack gets this deep,
 * raise an exception instead of continuing.
 */
#define MAX_MARSHAL_STACK_DEPTH 5000

Guido van Rossum's avatar
Guido van Rossum committed
18 19
#define TYPE_NULL	'0'
#define TYPE_NONE	'N'
20 21
#define TYPE_FALSE	'F'
#define TYPE_TRUE	'T'
22
#define TYPE_STOPITER	'S'
23
#define TYPE_ELLIPSIS   '.'
Guido van Rossum's avatar
Guido van Rossum committed
24
#define TYPE_INT	'i'
25
#define TYPE_INT64	'I'
Guido van Rossum's avatar
Guido van Rossum committed
26
#define TYPE_FLOAT	'f'
27
#define TYPE_COMPLEX	'x'
Guido van Rossum's avatar
Guido van Rossum committed
28 29 30 31 32
#define TYPE_LONG	'l'
#define TYPE_STRING	's'
#define TYPE_TUPLE	'('
#define TYPE_LIST	'['
#define TYPE_DICT	'{'
33
#define TYPE_CODE	'c'
34
#define TYPE_UNICODE	'u'
Guido van Rossum's avatar
Guido van Rossum committed
35 36
#define TYPE_UNKNOWN	'?'

37 38
typedef struct {
	FILE *fp;
39
	int error;
40
	int depth;
41
	/* If fp == NULL, the following are valid: */
42
	PyObject *str;
43 44 45
	char *ptr;
	char *end;
} WFILE;
Guido van Rossum's avatar
Guido van Rossum committed
46

47 48 49 50 51
#define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \
		      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
			   else w_more(c, p)

static void
52
w_more(int c, WFILE *p)
53 54 55 56
{
	int size, newsize;
	if (p->str == NULL)
		return; /* An error already occurred */
57
	size = PyString_Size(p->str);
58
	newsize = size + 1024;
59
	if (_PyString_Resize(&p->str, newsize) != 0) {
60 61 62
		p->ptr = p->end = NULL;
	}
	else {
63 64 65
		p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
		p->end =
			PyString_AS_STRING((PyStringObject *)p->str) + newsize;
66
		*p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
67 68 69 70
	}
}

static void
71
w_string(char *s, int n, WFILE *p)
72 73 74 75 76 77 78 79 80 81 82 83 84
{
	if (p->fp != NULL) {
		fwrite(s, 1, n, p->fp);
	}
	else {
		while (--n >= 0) {
			w_byte(*s, p);
			s++;
		}
	}
}

static void
85
w_short(int x, WFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
86
{
87 88
	w_byte( x      & 0xff, p);
	w_byte((x>> 8) & 0xff, p);
Guido van Rossum's avatar
Guido van Rossum committed
89 90
}

91
static void
92
w_long(long x, WFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
93
{
94 95 96 97
	w_byte((int)( x      & 0xff), p);
	w_byte((int)((x>> 8) & 0xff), p);
	w_byte((int)((x>>16) & 0xff), p);
	w_byte((int)((x>>24) & 0xff), p);
Guido van Rossum's avatar
Guido van Rossum committed
98 99
}

100
#if SIZEOF_LONG > 4
101
static void
102
w_long64(long x, WFILE *p)
103 104
{
	w_long(x, p);
105
	w_long(x>>32, p);
106
}
107
#endif
108

109
static void
110
w_object(PyObject *v, WFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
111
{
112
	int i, n;
113 114

	p->depth++;
115

116 117
	if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
		p->error = 2;
118
	}
119
	else if (v == NULL) {
120
		w_byte(TYPE_NULL, p);
121 122
	}
	else if (v == Py_None) {
123
		w_byte(TYPE_NONE, p);
124
	}
125 126 127
	else if (v == PyExc_StopIteration) {
		w_byte(TYPE_STOPITER, p);
	}
128 129 130
	else if (v == Py_Ellipsis) {
	        w_byte(TYPE_ELLIPSIS, p);
	}
131 132 133 134 135 136
	else if (v == Py_False) {
	        w_byte(TYPE_FALSE, p);
	}
	else if (v == Py_True) {
	        w_byte(TYPE_TRUE, p);
	}
137 138
	else if (PyInt_Check(v)) {
		long x = PyInt_AS_LONG((PyIntObject *)v);
139
#if SIZEOF_LONG > 4
140
		long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
141 142 143 144
		if (y && y != -1) {
			w_byte(TYPE_INT64, p);
			w_long64(x, p);
		}
145 146 147
		else
#endif
			{
148 149 150
			w_byte(TYPE_INT, p);
			w_long(x, p);
		}
Guido van Rossum's avatar
Guido van Rossum committed
151
	}
152 153
	else if (PyLong_Check(v)) {
		PyLongObject *ob = (PyLongObject *)v;
154
		w_byte(TYPE_LONG, p);
Guido van Rossum's avatar
Guido van Rossum committed
155
		n = ob->ob_size;
156
		w_long((long)n, p);
Guido van Rossum's avatar
Guido van Rossum committed
157 158 159
		if (n < 0)
			n = -n;
		for (i = 0; i < n; i++)
160
			w_short(ob->ob_digit[i], p);
Guido van Rossum's avatar
Guido van Rossum committed
161
	}
162
	else if (PyFloat_Check(v)) {
Guido van Rossum's avatar
Guido van Rossum committed
163
		char buf[256]; /* Plenty to format any double */
164
		PyFloat_AsReprString(buf, (PyFloatObject *)v);
Guido van Rossum's avatar
Guido van Rossum committed
165
		n = strlen(buf);
166
		w_byte(TYPE_FLOAT, p);
167 168
		w_byte(n, p);
		w_string(buf, n, p);
Guido van Rossum's avatar
Guido van Rossum committed
169
	}
170
#ifndef WITHOUT_COMPLEX
171
	else if (PyComplex_Check(v)) {
172
		char buf[256]; /* Plenty to format any double */
173
		PyFloatObject *temp;
174
		w_byte(TYPE_COMPLEX, p);
175 176
		temp = (PyFloatObject*)PyFloat_FromDouble(
			PyComplex_RealAsDouble(v));
177
		PyFloat_AsReprString(buf, temp);
178
		Py_DECREF(temp);
179 180 181
		n = strlen(buf);
		w_byte(n, p);
		w_string(buf, n, p);
182 183
		temp = (PyFloatObject*)PyFloat_FromDouble(
			PyComplex_ImagAsDouble(v));
184
		PyFloat_AsReprString(buf, temp);
185
		Py_DECREF(temp);
186 187 188 189 190
		n = strlen(buf);
		w_byte(n, p);
		w_string(buf, n, p);
	}
#endif
191
	else if (PyString_Check(v)) {
192
		w_byte(TYPE_STRING, p);
193
		n = PyString_GET_SIZE(v);
194
		w_long((long)n, p);
195 196
		w_string(PyString_AS_STRING(v), n, p);
	}
197
#ifdef Py_USING_UNICODE
198 199 200 201
	else if (PyUnicode_Check(v)) {
	        PyObject *utf8;
		utf8 = PyUnicode_AsUTF8String(v);
		if (utf8 == NULL) {
202 203 204
			p->depth--;
			p->error = 1;
			return;
205 206 207 208 209 210
		}
		w_byte(TYPE_UNICODE, p);
		n = PyString_GET_SIZE(utf8);
		w_long((long)n, p);
		w_string(PyString_AS_STRING(utf8), n, p);
		Py_DECREF(utf8);
Guido van Rossum's avatar
Guido van Rossum committed
211
	}
212
#endif
213
	else if (PyTuple_Check(v)) {
214
		w_byte(TYPE_TUPLE, p);
215
		n = PyTuple_Size(v);
216
		w_long((long)n, p);
Guido van Rossum's avatar
Guido van Rossum committed
217
		for (i = 0; i < n; i++) {
218
			w_object(PyTuple_GET_ITEM(v, i), p);
Guido van Rossum's avatar
Guido van Rossum committed
219 220
		}
	}
221
	else if (PyList_Check(v)) {
222
		w_byte(TYPE_LIST, p);
223
		n = PyList_GET_SIZE(v);
224
		w_long((long)n, p);
Guido van Rossum's avatar
Guido van Rossum committed
225
		for (i = 0; i < n; i++) {
226
			w_object(PyList_GET_ITEM(v, i), p);
Guido van Rossum's avatar
Guido van Rossum committed
227 228
		}
	}
229
	else if (PyDict_Check(v)) {
230
		int pos;
231
		PyObject *key, *value;
232
		w_byte(TYPE_DICT, p);
233
		/* This one is NULL object terminated! */
234
		pos = 0;
235
		while (PyDict_Next(v, &pos, &key, &value)) {
236 237
			w_object(key, p);
			w_object(value, p);
238
		}
239
		w_object((PyObject *)NULL, p);
240
	}
241 242
	else if (PyCode_Check(v)) {
		PyCodeObject *co = (PyCodeObject *)v;
243
		w_byte(TYPE_CODE, p);
244 245 246 247
		w_long(co->co_argcount, p);
		w_long(co->co_nlocals, p);
		w_long(co->co_stacksize, p);
		w_long(co->co_flags, p);
248
		w_object(co->co_code, p);
249 250
		w_object(co->co_consts, p);
		w_object(co->co_names, p);
251
		w_object(co->co_varnames, p);
Jeremy Hylton's avatar
Jeremy Hylton committed
252 253
		w_object(co->co_freevars, p);
		w_object(co->co_cellvars, p);
254
		w_object(co->co_filename, p);
255
		w_object(co->co_name, p);
256
		w_long(co->co_firstlineno, p);
257
		w_object(co->co_lnotab, p);
Guido van Rossum's avatar
Guido van Rossum committed
258
	}
259
	else if (PyObject_CheckReadBuffer(v)) {
260 261
		/* Write unknown buffer-style objects as a string */
		char *s;
262
		PyBufferProcs *pb = v->ob_type->tp_as_buffer;
263 264 265 266 267
		w_byte(TYPE_STRING, p);
		n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
		w_long((long)n, p);
		w_string(s, n, p);
	}
Guido van Rossum's avatar
Guido van Rossum committed
268
	else {
269
		w_byte(TYPE_UNKNOWN, p);
270
		p->error = 1;
Guido van Rossum's avatar
Guido van Rossum committed
271
	}
272 273

	p->depth--;
Guido van Rossum's avatar
Guido van Rossum committed
274 275
}

276
void
277
PyMarshal_WriteLongToFile(long x, FILE *fp)
278 279 280
{
	WFILE wf;
	wf.fp = fp;
281
	wf.error = 0;
282
	wf.depth = 0;
283 284
	w_long(x, &wf);
}
Guido van Rossum's avatar
Guido van Rossum committed
285

286
void
287
PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp)
288 289 290
{
	WFILE wf;
	wf.fp = fp;
291
	wf.error = 0;
292
	wf.depth = 0;
293 294 295 296 297
	w_object(x, &wf);
}

typedef WFILE RFILE; /* Same struct with different invariants */

298 299 300
#define rs_byte(p) (((p)->ptr != (p)->end) ? (unsigned char)*(p)->ptr++ : EOF)

#define r_byte(p) ((p)->fp ? getc((p)->fp) : rs_byte(p))
301 302

static int
303
r_string(char *s, int n, RFILE *p)
304 305 306 307 308 309 310 311 312 313 314
{
	if (p->fp != NULL)
		return fread(s, 1, n, p->fp);
	if (p->end - p->ptr < n)
		n = p->end - p->ptr;
	memcpy(s, p->ptr, n);
	p->ptr += n;
	return n;
}

static int
315
r_short(RFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
316 317
{
	register short x;
318 319
	x = r_byte(p);
	x |= r_byte(p) << 8;
Tim Peters's avatar
Tim Peters committed
320 321
	/* Sign-extension, in case short greater than 16 bits */
	x |= -(x & 0x8000);
Guido van Rossum's avatar
Guido van Rossum committed
322 323 324
	return x;
}

325
static long
326
r_long(RFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
327 328
{
	register long x;
329 330 331 332 333 334 335 336 337 338 339 340 341
	register FILE *fp = p->fp;
	if (fp) {
		x = getc(fp);
		x |= (long)getc(fp) << 8;
		x |= (long)getc(fp) << 16;
		x |= (long)getc(fp) << 24;
	}
	else {
		x = rs_byte(p);
		x |= (long)rs_byte(p) << 8;
		x |= (long)rs_byte(p) << 16;
		x |= (long)rs_byte(p) << 24;
	}
342
#if SIZEOF_LONG > 4
343
	/* Sign extension for 64-bit machines */
Tim Peters's avatar
Tim Peters committed
344
	x |= -(x & 0x80000000L);
345
#endif
346 347 348
	return x;
}

349 350 351 352 353 354 355 356
/* r_long64 deals with the TYPE_INT64 code.  On a machine with
   sizeof(long) > 4, it returns a Python int object, else a Python long
   object.  Note that w_long64 writes out TYPE_INT if 32 bits is enough,
   so there's no inefficiency here in returning a PyLong on 32-bit boxes
   for everything written via TYPE_INT64 (i.e., if an int is written via
   TYPE_INT64, it *needs* more than 32 bits).
*/
static PyObject *
357
r_long64(RFILE *p)
358
{
359 360
	long lo4 = r_long(p);
	long hi4 = r_long(p);
361
#if SIZEOF_LONG > 4
362 363
	long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
	return PyInt_FromLong(x);
364
#else
365 366 367 368 369 370
	unsigned char buf[8];
	int one = 1;
	int is_little_endian = (int)*(char*)&one;
	if (is_little_endian) {
		memcpy(buf, &lo4, 4);
		memcpy(buf+4, &hi4, 4);
371
	}
372 373 374 375 376
	else {
		memcpy(buf, &hi4, 4);
		memcpy(buf+4, &lo4, 4);
	}
	return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
377
#endif
Guido van Rossum's avatar
Guido van Rossum committed
378 379
}

380
static PyObject *
381
r_object(RFILE *p)
Guido van Rossum's avatar
Guido van Rossum committed
382
{
383
	PyObject *v, *v2;
Guido van Rossum's avatar
Guido van Rossum committed
384
	long i, n;
385
	int type = r_byte(p);
386

Guido van Rossum's avatar
Guido van Rossum committed
387
	switch (type) {
388

Guido van Rossum's avatar
Guido van Rossum committed
389
	case EOF:
390 391
		PyErr_SetString(PyExc_EOFError,
				"EOF read where object expected");
Guido van Rossum's avatar
Guido van Rossum committed
392
		return NULL;
393

Guido van Rossum's avatar
Guido van Rossum committed
394 395
	case TYPE_NULL:
		return NULL;
396

Guido van Rossum's avatar
Guido van Rossum committed
397
	case TYPE_NONE:
398 399
		Py_INCREF(Py_None);
		return Py_None;
400

401 402 403 404
	case TYPE_STOPITER:
		Py_INCREF(PyExc_StopIteration);
		return PyExc_StopIteration;

405
	case TYPE_ELLIPSIS:
406
		Py_INCREF(Py_Ellipsis);
407
		return Py_Ellipsis;
408

409 410 411 412 413 414 415 416
	case TYPE_FALSE:
		Py_INCREF(Py_False);
		return Py_False;

	case TYPE_TRUE:
		Py_INCREF(Py_True);
		return Py_True;

Guido van Rossum's avatar
Guido van Rossum committed
417
	case TYPE_INT:
418
		return PyInt_FromLong(r_long(p));
419

420
	case TYPE_INT64:
421
		return r_long64(p);
422

Guido van Rossum's avatar
Guido van Rossum committed
423 424 425
	case TYPE_LONG:
		{
			int size;
426
			PyLongObject *ob;
427
			n = r_long(p);
Guido van Rossum's avatar
Guido van Rossum committed
428
			size = n<0 ? -n : n;
429
			ob = _PyLong_New(size);
Guido van Rossum's avatar
Guido van Rossum committed
430 431 432 433
			if (ob == NULL)
				return NULL;
			ob->ob_size = n;
			for (i = 0; i < size; i++)
434
				ob->ob_digit[i] = r_short(p);
435
			return (PyObject *)ob;
Guido van Rossum's avatar
Guido van Rossum committed
436
		}
437

Guido van Rossum's avatar
Guido van Rossum committed
438 439 440
	case TYPE_FLOAT:
		{
			char buf[256];
441
			double dx;
442 443
			n = r_byte(p);
			if (r_string(buf, (int)n, p) != n) {
444
				PyErr_SetString(PyExc_EOFError,
Guido van Rossum's avatar
Guido van Rossum committed
445 446 447 448
					"EOF read where object expected");
				return NULL;
			}
			buf[n] = '\0';
449 450
			PyFPE_START_PROTECT("atof", return 0)
			dx = atof(buf);
451
			PyFPE_END_PROTECT(dx)
452
			return PyFloat_FromDouble(dx);
Guido van Rossum's avatar
Guido van Rossum committed
453
		}
454

455 456 457 458
#ifndef WITHOUT_COMPLEX
	case TYPE_COMPLEX:
		{
			char buf[256];
459
			Py_complex c;
460 461
			n = r_byte(p);
			if (r_string(buf, (int)n, p) != n) {
462
				PyErr_SetString(PyExc_EOFError,
463 464 465 466
					"EOF read where object expected");
				return NULL;
			}
			buf[n] = '\0';
467
			PyFPE_START_PROTECT("atof", return 0)
468
			c.real = atof(buf);
469
			PyFPE_END_PROTECT(c)
470 471
			n = r_byte(p);
			if (r_string(buf, (int)n, p) != n) {
472
				PyErr_SetString(PyExc_EOFError,
473 474 475 476
					"EOF read where object expected");
				return NULL;
			}
			buf[n] = '\0';
477
			PyFPE_START_PROTECT("atof", return 0)
478
			c.imag = atof(buf);
479
			PyFPE_END_PROTECT(c)
480
			return PyComplex_FromCComplex(c);
481 482
		}
#endif
483

Guido van Rossum's avatar
Guido van Rossum committed
484
	case TYPE_STRING:
485
		n = r_long(p);
486 487 488 489
		if (n < 0) {
			PyErr_SetString(PyExc_ValueError, "bad marshal data");
			return NULL;
		}
490
		v = PyString_FromStringAndSize((char *)NULL, n);
Guido van Rossum's avatar
Guido van Rossum committed
491
		if (v != NULL) {
492
			if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
493
				Py_DECREF(v);
Guido van Rossum's avatar
Guido van Rossum committed
494
				v = NULL;
495
				PyErr_SetString(PyExc_EOFError,
Guido van Rossum's avatar
Guido van Rossum committed
496 497 498 499
					"EOF read where object expected");
			}
		}
		return v;
500

501
#ifdef Py_USING_UNICODE
502 503 504 505 506 507 508 509 510
	case TYPE_UNICODE:
	    {
		char *buffer;

		n = r_long(p);
		if (n < 0) {
			PyErr_SetString(PyExc_ValueError, "bad marshal data");
			return NULL;
		}
511
		buffer = PyMem_NEW(char, n);
512
		if (buffer == NULL)
513
			return PyErr_NoMemory();
514
		if (r_string(buffer, (int)n, p) != n) {
515
			PyMem_DEL(buffer);
516 517 518 519 520
			PyErr_SetString(PyExc_EOFError,
				"EOF read where object expected");
			return NULL;
		}
		v = PyUnicode_DecodeUTF8(buffer, n, NULL);
521
		PyMem_DEL(buffer);
522 523
		return v;
	    }
524
#endif
525

Guido van Rossum's avatar
Guido van Rossum committed
526
	case TYPE_TUPLE:
527
		n = r_long(p);
528 529 530 531
		if (n < 0) {
			PyErr_SetString(PyExc_ValueError, "bad marshal data");
			return NULL;
		}
532
		v = PyTuple_New((int)n);
Guido van Rossum's avatar
Guido van Rossum committed
533 534
		if (v == NULL)
			return v;
535 536 537
		for (i = 0; i < n; i++) {
			v2 = r_object(p);
			if ( v2 == NULL ) {
538
				Py_DECREF(v);
539 540 541
				v = NULL;
				break;
			}
542
			PyTuple_SET_ITEM(v, (int)i, v2);
543
		}
Guido van Rossum's avatar
Guido van Rossum committed
544
		return v;
545

Guido van Rossum's avatar
Guido van Rossum committed
546
	case TYPE_LIST:
547
		n = r_long(p);
548 549 550 551
		if (n < 0) {
			PyErr_SetString(PyExc_ValueError, "bad marshal data");
			return NULL;
		}
552
		v = PyList_New((int)n);
Guido van Rossum's avatar
Guido van Rossum committed
553 554
		if (v == NULL)
			return v;
555 556 557
		for (i = 0; i < n; i++) {
			v2 = r_object(p);
			if ( v2 == NULL ) {
558
				Py_DECREF(v);
559 560 561
				v = NULL;
				break;
			}
562
			PyList_SetItem(v, (int)i, v2);
563
		}
Guido van Rossum's avatar
Guido van Rossum committed
564
		return v;
565

566
	case TYPE_DICT:
567
		v = PyDict_New();
568 569 570
		if (v == NULL)
			return NULL;
		for (;;) {
571
			PyObject *key, *val;
572
			key = r_object(p);
573
			if (key == NULL)
574
				break; /* XXX Assume TYPE_NULL, not an error */
575
			val = r_object(p);
576
			if (val != NULL)
577 578 579
				PyDict_SetItem(v, key, val);
			Py_DECREF(key);
			Py_XDECREF(val);
580 581
		}
		return v;
582

Guido van Rossum's avatar
Guido van Rossum committed
583
	case TYPE_CODE:
584 585 586 587 588 589 590
		if (PyEval_GetRestricted()) {
			PyErr_SetString(PyExc_RuntimeError,
				"cannot unmarshal code objects in "
				"restricted execution mode");
			return NULL;
		}
		else {
591 592 593 594
			int argcount = r_long(p);
			int nlocals = r_long(p);
			int stacksize = r_long(p);
			int flags = r_long(p);
595 596 597 598
			PyObject *code = NULL;
			PyObject *consts = NULL;
			PyObject *names = NULL;
			PyObject *varnames = NULL;
Jeremy Hylton's avatar
Jeremy Hylton committed
599 600
			PyObject *freevars = NULL;
			PyObject *cellvars = NULL;
601 602
			PyObject *filename = NULL;
			PyObject *name = NULL;
Guido van Rossum's avatar
Guido van Rossum committed
603
			int firstlineno = 0;
604
			PyObject *lnotab = NULL;
605

606 607 608 609
			code = r_object(p);
			if (code) consts = r_object(p);
			if (consts) names = r_object(p);
			if (names) varnames = r_object(p);
Jeremy Hylton's avatar
Jeremy Hylton committed
610 611 612
			if (varnames) freevars = r_object(p);
			if (freevars) cellvars = r_object(p);
			if (cellvars) filename = r_object(p);
613
			if (filename) name = r_object(p);
614
			if (name) {
615
				firstlineno = r_long(p);
616 617
				lnotab = r_object(p);
			}
618

619 620
			if (!PyErr_Occurred()) {
				v = (PyObject *) PyCode_New(
621
					argcount, nlocals, stacksize, flags,
622
					code, consts, names, varnames,
623 624
					freevars, cellvars, filename, name,
					firstlineno, lnotab);
Guido van Rossum's avatar
Guido van Rossum committed
625 626 627
			}
			else
				v = NULL;
628 629 630 631
			Py_XDECREF(code);
			Py_XDECREF(consts);
			Py_XDECREF(names);
			Py_XDECREF(varnames);
Jeremy Hylton's avatar
Jeremy Hylton committed
632 633
			Py_XDECREF(freevars);
			Py_XDECREF(cellvars);
634 635
			Py_XDECREF(filename);
			Py_XDECREF(name);
636
			Py_XDECREF(lnotab);
Guido van Rossum's avatar
Guido van Rossum committed
637 638 639

		}
		return v;
640

Guido van Rossum's avatar
Guido van Rossum committed
641
	default:
642 643
		/* Bogus data got written, which isn't ideal.
		   This will let you keep working and recover. */
644 645
		PyErr_SetString(PyExc_ValueError, "bad marshal data");
		return NULL;
646

Guido van Rossum's avatar
Guido van Rossum committed
647 648 649
	}
}

650 651 652 653 654 655 656 657
int
PyMarshal_ReadShortFromFile(FILE *fp)
{
	RFILE rf;
	rf.fp = fp;
	return r_short(&rf);
}

658
long
659
PyMarshal_ReadLongFromFile(FILE *fp)
660 661 662 663 664 665
{
	RFILE rf;
	rf.fp = fp;
	return r_long(&rf);
}

666 667 668 669 670 671 672 673 674 675 676 677
#ifdef HAVE_FSTAT
/* Return size of file in bytes; < 0 if unknown. */
static off_t
getfilesize(FILE *fp)
{
	struct stat st;
	if (fstat(fileno(fp), &st) != 0)
		return -1;
	else
		return st.st_size;
}
#endif
678

679 680 681
/* If we can get the size of the file up-front, and it's reasonably small,
 * read it in one gulp and delegate to ...FromString() instead.  Much quicker
 * than reading a byte at a time from file; speeds .pyc imports.
682 683
 * CAUTION:  since this may read the entire remainder of the file, don't
 * call it unless you know you're done with the file.
684
 */
685
PyObject *
686
PyMarshal_ReadLastObjectFromFile(FILE *fp)
687
{
688 689 690 691 692 693 694 695
/* 75% of 2.1's .pyc files can exploit SMALL_FILE_LIMIT.
 * REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc.
 */
#define SMALL_FILE_LIMIT (1L << 14)
#define REASONABLE_FILE_LIMIT (1L << 18)
#ifdef HAVE_FSTAT
	off_t filesize;
#endif
696
	if (PyErr_Occurred()) {
697 698 699
		fprintf(stderr, "XXX rd_object called with exception set\n");
		return NULL;
	}
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
#ifdef HAVE_FSTAT
	filesize = getfilesize(fp);
	if (filesize > 0) {
		char buf[SMALL_FILE_LIMIT];
		char* pBuf = NULL;
		if (filesize <= SMALL_FILE_LIMIT)
			pBuf = buf;
		else if (filesize <= REASONABLE_FILE_LIMIT)
			pBuf = (char *)PyMem_MALLOC(filesize);
		if (pBuf != NULL) {
			PyObject* v;
			size_t n = fread(pBuf, 1, filesize, fp);
			v = PyMarshal_ReadObjectFromString(pBuf, n);
			if (pBuf != buf)
				PyMem_FREE(pBuf);
			return v;
		}
717

718 719
	}
#endif
720 721 722 723 724
	/* We don't have fstat, or we do but the file is larger than
	 * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
	 */
	return PyMarshal_ReadObjectFromFile(fp);

725 726
#undef SMALL_FILE_LIMIT
#undef REASONABLE_FILE_LIMIT
727 728
}

729 730 731 732 733 734 735 736 737 738 739 740
PyObject *
PyMarshal_ReadObjectFromFile(FILE *fp)
{
	RFILE rf;
	if (PyErr_Occurred()) {
		fprintf(stderr, "XXX rd_object called with exception set\n");
		return NULL;
	}
	rf.fp = fp;
	return r_object(&rf);
}

741
PyObject *
742
PyMarshal_ReadObjectFromString(char *str, int len)
743 744
{
	RFILE rf;
745
	if (PyErr_Occurred()) {
746 747 748
		fprintf(stderr, "XXX rds_object called with exception set\n");
		return NULL;
	}
749 750 751 752 753 754 755
	rf.fp = NULL;
	rf.str = NULL;
	rf.ptr = str;
	rf.end = str + len;
	return r_object(&rf);
}

756
PyObject *
757
PyMarshal_WriteObjectToString(PyObject *x) /* wrs_object() */
758 759 760
{
	WFILE wf;
	wf.fp = NULL;
761
	wf.str = PyString_FromStringAndSize((char *)NULL, 50);
762 763
	if (wf.str == NULL)
		return NULL;
764 765
	wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
	wf.end = wf.ptr + PyString_Size(wf.str);
766
	wf.error = 0;
767
	wf.depth = 0;
768 769
	w_object(x, &wf);
	if (wf.str != NULL)
770 771 772
		_PyString_Resize(&wf.str,
		    (int) (wf.ptr -
			   PyString_AS_STRING((PyStringObject *)wf.str)));
773
	if (wf.error) {
774
		Py_XDECREF(wf.str);
775
		PyErr_SetString(PyExc_ValueError,
776 777
				(wf.error==1)?"unmarshallable object"
				:"object too deeply nested to marshal");
778 779 780 781 782
		return NULL;
	}
	return wf.str;
}

783
/* And an interface for Python programs... */
Guido van Rossum's avatar
Guido van Rossum committed
784

785
static PyObject *
786
marshal_dump(PyObject *self, PyObject *args)
Guido van Rossum's avatar
Guido van Rossum committed
787
{
788
	WFILE wf;
789 790
	PyObject *x;
	PyObject *f;
791
	if (!PyArg_ParseTuple(args, "OO:dump", &x, &f))
Guido van Rossum's avatar
Guido van Rossum committed
792
		return NULL;
793 794 795
	if (!PyFile_Check(f)) {
		PyErr_SetString(PyExc_TypeError,
				"marshal.dump() 2nd arg must be file");
Guido van Rossum's avatar
Guido van Rossum committed
796 797
		return NULL;
	}
798
	wf.fp = PyFile_AsFile(f);
799 800
	wf.str = NULL;
	wf.ptr = wf.end = NULL;
801
	wf.error = 0;
802
	wf.depth = 0;
803
	w_object(x, &wf);
804
	if (wf.error) {
805
		PyErr_SetString(PyExc_ValueError,
806 807
				(wf.error==1)?"unmarshallable object"
				:"object too deeply nested to marshal");
808 809
		return NULL;
	}
810 811
	Py_INCREF(Py_None);
	return Py_None;
Guido van Rossum's avatar
Guido van Rossum committed
812 813
}

814
static PyObject *
815
marshal_load(PyObject *self, PyObject *args)
Guido van Rossum's avatar
Guido van Rossum committed
816
{
817
	RFILE rf;
818 819
	PyObject *f;
	PyObject *v;
820
	if (!PyArg_ParseTuple(args, "O:load", &f))
821
		return NULL;
822 823 824
	if (!PyFile_Check(f)) {
		PyErr_SetString(PyExc_TypeError,
				"marshal.load() arg must be file");
Guido van Rossum's avatar
Guido van Rossum committed
825 826
		return NULL;
	}
827
	rf.fp = PyFile_AsFile(f);
828 829
	rf.str = NULL;
	rf.ptr = rf.end = NULL;
830
	PyErr_Clear();
831
	v = r_object(&rf);
832 833
	if (PyErr_Occurred()) {
		Py_XDECREF(v);
834 835 836 837 838
		v = NULL;
	}
	return v;
}

839
static PyObject *
840
marshal_dumps(PyObject *self, PyObject *args)
841
{
842
	PyObject *x;
843
	if (!PyArg_ParseTuple(args, "O:dumps", &x))
844
		return NULL;
845
	return PyMarshal_WriteObjectToString(x);
846 847
}

848
static PyObject *
849
marshal_loads(PyObject *self, PyObject *args)
850 851
{
	RFILE rf;
852
	PyObject *v;
853 854
	char *s;
	int n;
855
	if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
856 857 858 859 860
		return NULL;
	rf.fp = NULL;
	rf.str = args;
	rf.ptr = s;
	rf.end = s + n;
861
	PyErr_Clear();
862
	v = r_object(&rf);
863 864
	if (PyErr_Occurred()) {
		Py_XDECREF(v);
Guido van Rossum's avatar
Guido van Rossum committed
865 866 867 868 869
		v = NULL;
	}
	return v;
}

870
static PyMethodDef marshal_methods[] = {
871 872 873 874
	{"dump",	marshal_dump,	METH_VARARGS},
	{"load",	marshal_load,	METH_VARARGS},
	{"dumps",	marshal_dumps,	METH_VARARGS},
	{"loads",	marshal_loads,	METH_VARARGS},
Guido van Rossum's avatar
Guido van Rossum committed
875 876 877 878
	{NULL,		NULL}		/* sentinel */
};

void
879
PyMarshal_Init(void)
Guido van Rossum's avatar
Guido van Rossum committed
880
{
881
	(void) Py_InitModule("marshal", marshal_methods);
Guido van Rossum's avatar
Guido van Rossum committed
882
}