1991-06-04 16:42:30 -03:00
|
|
|
/***********************************************************
|
1995-01-04 15:12:13 -04:00
|
|
|
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
|
|
The Netherlands.
|
1991-06-04 16:42:30 -03:00
|
|
|
|
|
|
|
All Rights Reserved
|
|
|
|
|
1996-10-25 11:44:06 -03:00
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
|
|
documentation for any purpose and without fee is hereby granted,
|
1991-06-04 16:42:30 -03:00
|
|
|
provided that the above copyright notice appear in all copies and that
|
1996-10-25 11:44:06 -03:00
|
|
|
both that copyright notice and this permission notice appear in
|
1991-06-04 16:42:30 -03:00
|
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
1996-10-25 11:44:06 -03:00
|
|
|
Centrum or CWI or Corporation for National Research Initiatives or
|
|
|
|
CNRI not be used in advertising or publicity pertaining to
|
|
|
|
distribution of the software without specific, written prior
|
|
|
|
permission.
|
|
|
|
|
|
|
|
While CWI is the initial source for this software, a modified version
|
|
|
|
is made available by the Corporation for National Research Initiatives
|
|
|
|
(CNRI) at the Internet address ftp://ftp.python.org.
|
|
|
|
|
|
|
|
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
|
|
|
|
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
|
|
|
|
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
|
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
|
PERFORMANCE OF THIS SOFTWARE.
|
1991-06-04 16:42:30 -03:00
|
|
|
|
|
|
|
******************************************************************/
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
#include "Python.h"
|
1991-06-04 16:42:30 -03:00
|
|
|
#include "longintrepr.h"
|
|
|
|
#include "compile.h"
|
|
|
|
#include "marshal.h"
|
|
|
|
|
|
|
|
#define TYPE_NULL '0'
|
|
|
|
#define TYPE_NONE 'N'
|
1996-10-11 13:25:41 -03:00
|
|
|
#define TYPE_ELLIPSIS '.'
|
1991-06-04 16:42:30 -03:00
|
|
|
#define TYPE_INT 'i'
|
1996-12-05 19:15:02 -04:00
|
|
|
#define TYPE_INT64 'I'
|
1991-06-04 16:42:30 -03:00
|
|
|
#define TYPE_FLOAT 'f'
|
1996-01-11 21:09:56 -04:00
|
|
|
#define TYPE_COMPLEX 'x'
|
1991-06-04 16:42:30 -03:00
|
|
|
#define TYPE_LONG 'l'
|
|
|
|
#define TYPE_STRING 's'
|
|
|
|
#define TYPE_TUPLE '('
|
|
|
|
#define TYPE_LIST '['
|
|
|
|
#define TYPE_DICT '{'
|
1995-07-18 11:51:37 -03:00
|
|
|
#define TYPE_CODE 'c'
|
2000-03-10 19:03:02 -04:00
|
|
|
#define TYPE_UNICODE 'u'
|
1991-06-04 16:42:30 -03:00
|
|
|
#define TYPE_UNKNOWN '?'
|
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
typedef struct {
|
|
|
|
FILE *fp;
|
1996-06-26 17:41:23 -03:00
|
|
|
int error;
|
1993-01-21 12:07:51 -04:00
|
|
|
/* If fp == NULL, the following are valid: */
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *str;
|
1993-01-21 12:07:51 -04:00
|
|
|
char *ptr;
|
|
|
|
char *end;
|
|
|
|
} WFILE;
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
#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
|
|
|
|
w_more(c, p)
|
|
|
|
char c;
|
|
|
|
WFILE *p;
|
|
|
|
{
|
|
|
|
int size, newsize;
|
|
|
|
if (p->str == NULL)
|
|
|
|
return; /* An error already occurred */
|
1997-04-29 17:08:16 -03:00
|
|
|
size = PyString_Size(p->str);
|
1993-01-21 12:07:51 -04:00
|
|
|
newsize = size + 1024;
|
1997-04-29 17:08:16 -03:00
|
|
|
if (_PyString_Resize(&p->str, newsize) != 0) {
|
1993-01-21 12:07:51 -04:00
|
|
|
p->ptr = p->end = NULL;
|
|
|
|
}
|
|
|
|
else {
|
1997-04-29 17:08:16 -03:00
|
|
|
p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
|
|
|
|
p->end =
|
|
|
|
PyString_AS_STRING((PyStringObject *)p->str) + newsize;
|
1993-01-21 12:07:51 -04:00
|
|
|
*p->ptr++ = c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_string(s, n, p)
|
|
|
|
char *s;
|
|
|
|
int n;
|
|
|
|
WFILE *p;
|
|
|
|
{
|
|
|
|
if (p->fp != NULL) {
|
|
|
|
fwrite(s, 1, n, p->fp);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
while (--n >= 0) {
|
|
|
|
w_byte(*s, p);
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_short(x, p)
|
1991-06-04 16:42:30 -03:00
|
|
|
int x;
|
1993-01-21 12:07:51 -04:00
|
|
|
WFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte( x & 0xff, p);
|
|
|
|
w_byte((x>> 8) & 0xff, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
static void
|
|
|
|
w_long(x, p)
|
1991-06-04 16:42:30 -03:00
|
|
|
long x;
|
1993-01-21 12:07:51 -04:00
|
|
|
WFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1993-01-21 12:07:51 -04:00
|
|
|
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);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
|
1996-12-10 11:39:04 -04:00
|
|
|
#if SIZEOF_LONG > 4
|
1996-12-05 19:15:02 -04:00
|
|
|
static void
|
|
|
|
w_long64(x, p)
|
|
|
|
long x;
|
|
|
|
WFILE *p;
|
|
|
|
{
|
|
|
|
w_long(x, p);
|
1996-12-10 11:39:04 -04:00
|
|
|
w_long(x>>32, p);
|
1996-12-05 19:15:02 -04:00
|
|
|
}
|
1996-12-10 11:39:04 -04:00
|
|
|
#endif
|
1996-12-05 19:15:02 -04:00
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
static void
|
|
|
|
w_object(v, p)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *v;
|
1993-01-21 12:07:51 -04:00
|
|
|
WFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1995-02-17 11:10:07 -04:00
|
|
|
int i, n;
|
1998-10-07 16:42:25 -03:00
|
|
|
PyBufferProcs *pb;
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1998-04-10 19:27:42 -03:00
|
|
|
if (v == NULL) {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_NULL, p);
|
1998-04-10 19:27:42 -03:00
|
|
|
}
|
|
|
|
else if (v == Py_None) {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_NONE, p);
|
1998-04-10 19:27:42 -03:00
|
|
|
}
|
|
|
|
else if (v == Py_Ellipsis) {
|
|
|
|
w_byte(TYPE_ELLIPSIS, p);
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyInt_Check(v)) {
|
|
|
|
long x = PyInt_AS_LONG((PyIntObject *)v);
|
1996-12-10 11:39:04 -04:00
|
|
|
#if SIZEOF_LONG > 4
|
1996-12-05 19:15:02 -04:00
|
|
|
long y = x>>31;
|
|
|
|
if (y && y != -1) {
|
|
|
|
w_byte(TYPE_INT64, p);
|
|
|
|
w_long64(x, p);
|
|
|
|
}
|
1996-12-10 11:39:04 -04:00
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
1996-12-05 19:15:02 -04:00
|
|
|
w_byte(TYPE_INT, p);
|
|
|
|
w_long(x, p);
|
|
|
|
}
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyLong_Check(v)) {
|
|
|
|
PyLongObject *ob = (PyLongObject *)v;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_LONG, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
n = ob->ob_size;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_long((long)n, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
if (n < 0)
|
|
|
|
n = -n;
|
|
|
|
for (i = 0; i < n; i++)
|
1993-01-21 12:07:51 -04:00
|
|
|
w_short(ob->ob_digit[i], p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyFloat_Check(v)) {
|
|
|
|
extern void PyFloat_AsString
|
|
|
|
Py_PROTO((char *, PyFloatObject *));
|
1991-06-04 16:42:30 -03:00
|
|
|
char buf[256]; /* Plenty to format any double */
|
1997-04-29 17:08:16 -03:00
|
|
|
PyFloat_AsString(buf, (PyFloatObject *)v);
|
1991-06-04 16:42:30 -03:00
|
|
|
n = strlen(buf);
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_FLOAT, p);
|
1995-02-17 11:10:07 -04:00
|
|
|
w_byte(n, p);
|
|
|
|
w_string(buf, n, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
1996-01-11 21:09:56 -04:00
|
|
|
#ifndef WITHOUT_COMPLEX
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyComplex_Check(v)) {
|
|
|
|
extern void PyFloat_AsString
|
|
|
|
Py_PROTO((char *, PyFloatObject *));
|
1996-01-11 21:09:56 -04:00
|
|
|
char buf[256]; /* Plenty to format any double */
|
1997-04-29 17:08:16 -03:00
|
|
|
PyFloatObject *temp;
|
1996-01-11 21:09:56 -04:00
|
|
|
w_byte(TYPE_COMPLEX, p);
|
1997-04-29 17:08:16 -03:00
|
|
|
temp = (PyFloatObject*)PyFloat_FromDouble(
|
|
|
|
PyComplex_RealAsDouble(v));
|
|
|
|
PyFloat_AsString(buf, temp);
|
|
|
|
Py_DECREF(temp);
|
1996-01-11 21:09:56 -04:00
|
|
|
n = strlen(buf);
|
|
|
|
w_byte(n, p);
|
|
|
|
w_string(buf, n, p);
|
1997-04-29 17:08:16 -03:00
|
|
|
temp = (PyFloatObject*)PyFloat_FromDouble(
|
|
|
|
PyComplex_ImagAsDouble(v));
|
|
|
|
PyFloat_AsString(buf, temp);
|
|
|
|
Py_DECREF(temp);
|
1996-01-11 21:09:56 -04:00
|
|
|
n = strlen(buf);
|
|
|
|
w_byte(n, p);
|
|
|
|
w_string(buf, n, p);
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyString_Check(v)) {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_STRING, p);
|
2000-03-10 19:03:02 -04:00
|
|
|
n = PyString_GET_SIZE(v);
|
1995-02-17 11:10:07 -04:00
|
|
|
w_long((long)n, p);
|
2000-03-10 19:03:02 -04:00
|
|
|
w_string(PyString_AS_STRING(v), n, p);
|
|
|
|
}
|
|
|
|
else if (PyUnicode_Check(v)) {
|
|
|
|
PyObject *utf8;
|
|
|
|
utf8 = PyUnicode_AsUTF8String(v);
|
|
|
|
if (utf8 == NULL) {
|
|
|
|
p->error = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
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);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyTuple_Check(v)) {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_TUPLE, p);
|
1997-04-29 17:08:16 -03:00
|
|
|
n = PyTuple_Size(v);
|
1995-02-17 11:10:07 -04:00
|
|
|
w_long((long)n, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
1997-04-29 17:08:16 -03:00
|
|
|
w_object(PyTuple_GET_ITEM(v, i), p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyList_Check(v)) {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_LIST, p);
|
2000-03-10 19:03:02 -04:00
|
|
|
n = PyList_GET_SIZE(v);
|
1995-02-17 11:10:07 -04:00
|
|
|
w_long((long)n, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
2000-03-10 19:03:02 -04:00
|
|
|
w_object(PyList_GET_ITEM(v, i), p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyDict_Check(v)) {
|
1993-05-19 11:50:45 -03:00
|
|
|
int pos;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *key, *value;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_DICT, p);
|
1991-06-07 10:58:22 -03:00
|
|
|
/* This one is NULL object terminated! */
|
1993-05-19 11:50:45 -03:00
|
|
|
pos = 0;
|
1997-04-29 17:08:16 -03:00
|
|
|
while (PyDict_Next(v, &pos, &key, &value)) {
|
1993-05-19 11:50:45 -03:00
|
|
|
w_object(key, p);
|
|
|
|
w_object(value, p);
|
1991-06-07 10:58:22 -03:00
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
w_object((PyObject *)NULL, p);
|
1991-06-07 10:58:22 -03:00
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
else if (PyCode_Check(v)) {
|
|
|
|
PyCodeObject *co = (PyCodeObject *)v;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_CODE, p);
|
1995-07-18 11:51:37 -03:00
|
|
|
w_short(co->co_argcount, p);
|
|
|
|
w_short(co->co_nlocals, p);
|
1997-01-17 17:07:08 -04:00
|
|
|
w_short(co->co_stacksize, p);
|
1995-07-18 11:51:37 -03:00
|
|
|
w_short(co->co_flags, p);
|
1998-10-07 16:42:25 -03:00
|
|
|
w_object(co->co_code, p);
|
1993-01-21 12:07:51 -04:00
|
|
|
w_object(co->co_consts, p);
|
|
|
|
w_object(co->co_names, p);
|
1995-07-18 11:51:37 -03:00
|
|
|
w_object(co->co_varnames, p);
|
1993-01-21 12:07:51 -04:00
|
|
|
w_object(co->co_filename, p);
|
1993-03-29 06:43:31 -04:00
|
|
|
w_object(co->co_name, p);
|
1997-01-23 23:44:17 -04:00
|
|
|
w_short(co->co_firstlineno, p);
|
|
|
|
w_object(co->co_lnotab, p);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
1998-10-07 16:42:25 -03:00
|
|
|
else if ((pb = v->ob_type->tp_as_buffer) != NULL &&
|
|
|
|
pb->bf_getsegcount != NULL &&
|
|
|
|
pb->bf_getreadbuffer != NULL &&
|
|
|
|
(*pb->bf_getsegcount)(v, NULL) == 1)
|
|
|
|
{
|
|
|
|
/* Write unknown buffer-style objects as a string */
|
|
|
|
char *s;
|
|
|
|
w_byte(TYPE_STRING, p);
|
|
|
|
n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
|
|
|
|
w_long((long)n, p);
|
|
|
|
w_string(s, n, p);
|
|
|
|
}
|
1991-06-04 16:42:30 -03:00
|
|
|
else {
|
1993-01-21 12:07:51 -04:00
|
|
|
w_byte(TYPE_UNKNOWN, p);
|
1996-06-26 17:41:23 -03:00
|
|
|
p->error = 1;
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
void
|
1997-04-29 17:08:16 -03:00
|
|
|
PyMarshal_WriteLongToFile(x, fp)
|
1993-01-21 12:07:51 -04:00
|
|
|
long x;
|
|
|
|
FILE *fp;
|
|
|
|
{
|
|
|
|
WFILE wf;
|
|
|
|
wf.fp = fp;
|
1996-06-26 17:41:23 -03:00
|
|
|
wf.error = 0;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_long(x, &wf);
|
|
|
|
}
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
void
|
1997-04-29 17:08:16 -03:00
|
|
|
PyMarshal_WriteObjectToFile(x, fp)
|
|
|
|
PyObject *x;
|
1991-06-04 16:42:30 -03:00
|
|
|
FILE *fp;
|
1993-01-21 12:07:51 -04:00
|
|
|
{
|
|
|
|
WFILE wf;
|
|
|
|
wf.fp = fp;
|
1996-06-26 17:41:23 -03:00
|
|
|
wf.error = 0;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_object(x, &wf);
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef WFILE RFILE; /* Same struct with different invariants */
|
|
|
|
|
1995-03-09 08:12:11 -04:00
|
|
|
#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))
|
1993-01-21 12:07:51 -04:00
|
|
|
|
|
|
|
static int
|
|
|
|
r_string(s, n, p)
|
|
|
|
char *s;
|
|
|
|
int n;
|
|
|
|
RFILE *p;
|
|
|
|
{
|
|
|
|
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
|
|
|
|
r_short(p)
|
|
|
|
RFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
|
|
|
register short x;
|
1993-01-21 12:07:51 -04:00
|
|
|
x = r_byte(p);
|
|
|
|
x |= r_byte(p) << 8;
|
1991-06-04 16:42:30 -03:00
|
|
|
/* XXX If your short is > 16 bits, add sign-extension here!!! */
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
static long
|
|
|
|
r_long(p)
|
|
|
|
RFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
|
|
|
register long x;
|
1995-03-09 08:12:11 -04:00
|
|
|
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;
|
|
|
|
}
|
1996-12-10 11:39:04 -04:00
|
|
|
#if SIZEOF_LONG > 4
|
1996-12-05 19:15:02 -04:00
|
|
|
/* Sign extension for 64-bit machines */
|
|
|
|
x <<= (8*sizeof(long) - 32);
|
|
|
|
x >>= (8*sizeof(long) - 32);
|
1996-12-10 11:39:04 -04:00
|
|
|
#endif
|
1996-12-05 19:15:02 -04:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long
|
|
|
|
r_long64(p)
|
|
|
|
RFILE *p;
|
|
|
|
{
|
|
|
|
register long x;
|
1996-12-10 11:39:04 -04:00
|
|
|
x = r_long(p);
|
|
|
|
#if SIZEOF_LONG > 4
|
|
|
|
x = (x & 0xFFFFFFFF) | (r_long(p) << 32);
|
|
|
|
#else
|
|
|
|
if (r_long(p) != 0) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *f = PySys_GetObject("stderr");
|
1996-12-10 11:39:04 -04:00
|
|
|
if (f != NULL)
|
1997-05-22 19:35:47 -03:00
|
|
|
(void) PyFile_WriteString(
|
1996-12-10 11:39:04 -04:00
|
|
|
"Warning: un-marshal 64-bit int in 32-bit mode\n",
|
|
|
|
f);
|
1996-12-05 19:15:02 -04:00
|
|
|
}
|
1996-12-10 11:39:04 -04:00
|
|
|
#endif
|
1991-06-04 16:42:30 -03:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
1993-01-21 12:07:51 -04:00
|
|
|
r_object(p)
|
|
|
|
RFILE *p;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *v, *v2;
|
1991-06-04 16:42:30 -03:00
|
|
|
long i, n;
|
1993-01-21 12:07:51 -04:00
|
|
|
int type = r_byte(p);
|
1991-06-04 16:42:30 -03:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case EOF:
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"EOF read where object expected");
|
1991-06-04 16:42:30 -03:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
case TYPE_NULL:
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
case TYPE_NONE:
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1996-10-11 13:25:41 -03:00
|
|
|
case TYPE_ELLIPSIS:
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_INCREF(Py_Ellipsis);
|
1996-10-11 13:25:41 -03:00
|
|
|
return Py_Ellipsis;
|
1996-07-30 13:49:37 -03:00
|
|
|
|
1991-06-04 16:42:30 -03:00
|
|
|
case TYPE_INT:
|
1997-04-29 17:08:16 -03:00
|
|
|
return PyInt_FromLong(r_long(p));
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1996-12-05 19:15:02 -04:00
|
|
|
case TYPE_INT64:
|
1997-04-29 17:08:16 -03:00
|
|
|
return PyInt_FromLong(r_long64(p));
|
1996-12-05 19:15:02 -04:00
|
|
|
|
1991-06-04 16:42:30 -03:00
|
|
|
case TYPE_LONG:
|
|
|
|
{
|
|
|
|
int size;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyLongObject *ob;
|
1993-01-21 12:07:51 -04:00
|
|
|
n = r_long(p);
|
1991-06-04 16:42:30 -03:00
|
|
|
size = n<0 ? -n : n;
|
1997-04-29 17:08:16 -03:00
|
|
|
ob = _PyLong_New(size);
|
1991-06-04 16:42:30 -03:00
|
|
|
if (ob == NULL)
|
|
|
|
return NULL;
|
|
|
|
ob->ob_size = n;
|
|
|
|
for (i = 0; i < size; i++)
|
1993-01-21 12:07:51 -04:00
|
|
|
ob->ob_digit[i] = r_short(p);
|
1997-04-29 17:08:16 -03:00
|
|
|
return (PyObject *)ob;
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_FLOAT:
|
|
|
|
{
|
1997-04-29 17:08:16 -03:00
|
|
|
extern double atof Py_PROTO((const char *));
|
1991-06-04 16:42:30 -03:00
|
|
|
char buf[256];
|
1997-02-14 18:58:07 -04:00
|
|
|
double dx;
|
1993-01-21 12:07:51 -04:00
|
|
|
n = r_byte(p);
|
|
|
|
if (r_string(buf, (int)n, p) != n) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
1991-06-04 16:42:30 -03:00
|
|
|
"EOF read where object expected");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
buf[n] = '\0';
|
1997-02-14 18:58:07 -04:00
|
|
|
PyFPE_START_PROTECT("atof", return 0)
|
|
|
|
dx = atof(buf);
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(dx)
|
1997-04-29 17:08:16 -03:00
|
|
|
return PyFloat_FromDouble(dx);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
|
1996-01-11 21:09:56 -04:00
|
|
|
#ifndef WITHOUT_COMPLEX
|
|
|
|
case TYPE_COMPLEX:
|
|
|
|
{
|
1997-04-29 17:08:16 -03:00
|
|
|
extern double atof Py_PROTO((const char *));
|
1996-01-11 21:09:56 -04:00
|
|
|
char buf[256];
|
1996-07-20 23:27:43 -03:00
|
|
|
Py_complex c;
|
1996-01-11 21:09:56 -04:00
|
|
|
n = r_byte(p);
|
|
|
|
if (r_string(buf, (int)n, p) != n) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
1996-01-11 21:09:56 -04:00
|
|
|
"EOF read where object expected");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
buf[n] = '\0';
|
1997-02-14 18:58:07 -04:00
|
|
|
PyFPE_START_PROTECT("atof", return 0)
|
1996-01-11 21:09:56 -04:00
|
|
|
c.real = atof(buf);
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(c)
|
1996-01-11 21:09:56 -04:00
|
|
|
n = r_byte(p);
|
|
|
|
if (r_string(buf, (int)n, p) != n) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
1996-01-11 21:09:56 -04:00
|
|
|
"EOF read where object expected");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
buf[n] = '\0';
|
1997-02-14 18:58:07 -04:00
|
|
|
PyFPE_START_PROTECT("atof", return 0)
|
1996-01-11 21:09:56 -04:00
|
|
|
c.imag = atof(buf);
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(c)
|
1997-04-29 17:08:16 -03:00
|
|
|
return PyComplex_FromCComplex(c);
|
1996-01-11 21:09:56 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1991-06-04 16:42:30 -03:00
|
|
|
case TYPE_STRING:
|
1993-01-21 12:07:51 -04:00
|
|
|
n = r_long(p);
|
1998-06-08 17:27:29 -03:00
|
|
|
if (n < 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data");
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
v = PyString_FromStringAndSize((char *)NULL, n);
|
1991-06-04 16:42:30 -03:00
|
|
|
if (v != NULL) {
|
2000-03-10 19:03:02 -04:00
|
|
|
if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_DECREF(v);
|
1991-06-04 16:42:30 -03:00
|
|
|
v = NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
1991-06-04 16:42:30 -03:00
|
|
|
"EOF read where object expected");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
|
2000-03-10 19:03:02 -04:00
|
|
|
case TYPE_UNICODE:
|
|
|
|
{
|
|
|
|
char *buffer;
|
|
|
|
|
|
|
|
n = r_long(p);
|
|
|
|
if (n < 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
buffer = (char *)Py_Malloc(n);
|
|
|
|
if (buffer == NULL)
|
|
|
|
return NULL;
|
|
|
|
if (r_string(buffer, (int)n, p) != n) {
|
|
|
|
free(buffer);
|
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"EOF read where object expected");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
v = PyUnicode_DecodeUTF8(buffer, n, NULL);
|
|
|
|
free(buffer);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
1991-06-04 16:42:30 -03:00
|
|
|
case TYPE_TUPLE:
|
1993-01-21 12:07:51 -04:00
|
|
|
n = r_long(p);
|
1998-06-08 17:27:29 -03:00
|
|
|
if (n < 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data");
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
v = PyTuple_New((int)n);
|
1991-06-04 16:42:30 -03:00
|
|
|
if (v == NULL)
|
|
|
|
return v;
|
1995-10-27 10:21:28 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
v2 = r_object(p);
|
|
|
|
if ( v2 == NULL ) {
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_DECREF(v);
|
1995-10-27 10:21:28 -03:00
|
|
|
v = NULL;
|
|
|
|
break;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
PyTuple_SET_ITEM(v, (int)i, v2);
|
1995-10-27 10:21:28 -03:00
|
|
|
}
|
1991-06-04 16:42:30 -03:00
|
|
|
return v;
|
|
|
|
|
|
|
|
case TYPE_LIST:
|
1993-01-21 12:07:51 -04:00
|
|
|
n = r_long(p);
|
1998-06-08 17:27:29 -03:00
|
|
|
if (n < 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data");
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
v = PyList_New((int)n);
|
1991-06-04 16:42:30 -03:00
|
|
|
if (v == NULL)
|
|
|
|
return v;
|
1995-10-27 10:21:28 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
v2 = r_object(p);
|
|
|
|
if ( v2 == NULL ) {
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_DECREF(v);
|
1995-10-27 10:21:28 -03:00
|
|
|
v = NULL;
|
|
|
|
break;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
PyList_SetItem(v, (int)i, v2);
|
1995-10-27 10:21:28 -03:00
|
|
|
}
|
1991-06-04 16:42:30 -03:00
|
|
|
return v;
|
|
|
|
|
1991-06-07 10:58:22 -03:00
|
|
|
case TYPE_DICT:
|
1997-04-29 17:08:16 -03:00
|
|
|
v = PyDict_New();
|
1991-06-07 10:58:22 -03:00
|
|
|
if (v == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (;;) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *key, *val;
|
1993-01-21 12:07:51 -04:00
|
|
|
key = r_object(p);
|
1991-06-07 10:58:22 -03:00
|
|
|
if (key == NULL)
|
1996-06-26 17:41:23 -03:00
|
|
|
break; /* XXX Assume TYPE_NULL, not an error */
|
1993-01-21 12:07:51 -04:00
|
|
|
val = r_object(p);
|
1996-06-26 17:41:23 -03:00
|
|
|
if (val != NULL)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyDict_SetItem(v, key, val);
|
|
|
|
Py_DECREF(key);
|
|
|
|
Py_XDECREF(val);
|
1991-06-07 10:58:22 -03:00
|
|
|
}
|
|
|
|
return v;
|
|
|
|
|
1991-06-04 16:42:30 -03:00
|
|
|
case TYPE_CODE:
|
|
|
|
{
|
1995-07-18 11:51:37 -03:00
|
|
|
int argcount = r_short(p);
|
|
|
|
int nlocals = r_short(p);
|
1997-01-17 17:07:08 -04:00
|
|
|
int stacksize = r_short(p);
|
1995-07-18 11:51:37 -03:00
|
|
|
int flags = r_short(p);
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *code = NULL;
|
|
|
|
PyObject *consts = NULL;
|
|
|
|
PyObject *names = NULL;
|
|
|
|
PyObject *varnames = NULL;
|
|
|
|
PyObject *filename = NULL;
|
|
|
|
PyObject *name = NULL;
|
1997-02-14 17:12:56 -04:00
|
|
|
int firstlineno = 0;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *lnotab = NULL;
|
1995-10-27 10:21:28 -03:00
|
|
|
|
|
|
|
code = r_object(p);
|
|
|
|
if (code) consts = r_object(p);
|
|
|
|
if (consts) names = r_object(p);
|
|
|
|
if (names) varnames = r_object(p);
|
|
|
|
if (varnames) filename = r_object(p);
|
|
|
|
if (filename) name = r_object(p);
|
1997-01-23 23:44:17 -04:00
|
|
|
if (name) {
|
|
|
|
firstlineno = r_short(p);
|
|
|
|
lnotab = r_object(p);
|
|
|
|
}
|
1995-10-27 10:21:28 -03:00
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
v = (PyObject *) PyCode_New(
|
1997-01-17 17:07:08 -04:00
|
|
|
argcount, nlocals, stacksize, flags,
|
1995-07-18 11:51:37 -03:00
|
|
|
code, consts, names, varnames,
|
1997-01-23 23:44:17 -04:00
|
|
|
filename, name, firstlineno, lnotab);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
v = NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_XDECREF(code);
|
|
|
|
Py_XDECREF(consts);
|
|
|
|
Py_XDECREF(names);
|
|
|
|
Py_XDECREF(varnames);
|
|
|
|
Py_XDECREF(filename);
|
|
|
|
Py_XDECREF(name);
|
1997-07-26 20:30:18 -03:00
|
|
|
Py_XDECREF(lnotab);
|
1991-06-04 16:42:30 -03:00
|
|
|
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
|
|
|
|
default:
|
1996-06-26 17:41:23 -03:00
|
|
|
/* Bogus data got written, which isn't ideal.
|
|
|
|
This will let you keep working and recover. */
|
1998-06-08 17:27:29 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data");
|
|
|
|
return NULL;
|
1991-06-04 16:42:30 -03:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1993-01-21 12:07:51 -04:00
|
|
|
long
|
1997-04-29 17:08:16 -03:00
|
|
|
PyMarshal_ReadLongFromFile(fp)
|
1993-01-21 12:07:51 -04:00
|
|
|
FILE *fp;
|
|
|
|
{
|
|
|
|
RFILE rf;
|
|
|
|
rf.fp = fp;
|
|
|
|
return r_long(&rf);
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
|
|
|
PyMarshal_ReadObjectFromFile(fp)
|
1993-01-21 12:07:51 -04:00
|
|
|
FILE *fp;
|
|
|
|
{
|
|
|
|
RFILE rf;
|
1997-04-29 17:08:16 -03:00
|
|
|
if (PyErr_Occurred()) {
|
1995-01-02 15:04:15 -04:00
|
|
|
fprintf(stderr, "XXX rd_object called with exception set\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
1993-01-21 12:07:51 -04:00
|
|
|
rf.fp = fp;
|
|
|
|
return r_object(&rf);
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
|
|
|
PyMarshal_ReadObjectFromString(str, len)
|
1993-04-01 16:59:32 -04:00
|
|
|
char *str;
|
|
|
|
int len;
|
|
|
|
{
|
|
|
|
RFILE rf;
|
1997-04-29 17:08:16 -03:00
|
|
|
if (PyErr_Occurred()) {
|
1995-01-02 15:04:15 -04:00
|
|
|
fprintf(stderr, "XXX rds_object called with exception set\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
1993-04-01 16:59:32 -04:00
|
|
|
rf.fp = NULL;
|
|
|
|
rf.str = NULL;
|
|
|
|
rf.ptr = str;
|
|
|
|
rf.end = str + len;
|
|
|
|
return r_object(&rf);
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
1996-08-19 19:07:17 -03:00
|
|
|
PyMarshal_WriteObjectToString(x) /* wrs_object() */
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *x;
|
1996-08-19 19:07:17 -03:00
|
|
|
{
|
|
|
|
WFILE wf;
|
|
|
|
wf.fp = NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
wf.str = PyString_FromStringAndSize((char *)NULL, 50);
|
1996-08-19 19:07:17 -03:00
|
|
|
if (wf.str == NULL)
|
|
|
|
return NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
|
|
|
|
wf.end = wf.ptr + PyString_Size(wf.str);
|
1996-08-19 19:07:17 -03:00
|
|
|
wf.error = 0;
|
|
|
|
w_object(x, &wf);
|
|
|
|
if (wf.str != NULL)
|
1997-04-29 17:08:16 -03:00
|
|
|
_PyString_Resize(&wf.str,
|
|
|
|
(int) (wf.ptr -
|
|
|
|
PyString_AS_STRING((PyStringObject *)wf.str)));
|
1996-08-19 19:07:17 -03:00
|
|
|
if (wf.error) {
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_XDECREF(wf.str);
|
|
|
|
PyErr_SetString(PyExc_ValueError, "unmarshallable object");
|
1996-08-19 19:07:17 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return wf.str;
|
|
|
|
}
|
|
|
|
|
1991-06-07 10:58:22 -03:00
|
|
|
/* And an interface for Python programs... */
|
1991-06-04 16:42:30 -03:00
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
1993-01-21 12:07:51 -04:00
|
|
|
marshal_dump(self, args)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1993-01-21 12:07:51 -04:00
|
|
|
WFILE wf;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *x;
|
|
|
|
PyObject *f;
|
2000-03-30 20:37:41 -04:00
|
|
|
if (!PyArg_ParseTuple(args, "OO:dump", &x, &f))
|
1991-06-04 16:42:30 -03:00
|
|
|
return NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
if (!PyFile_Check(f)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"marshal.dump() 2nd arg must be file");
|
1991-06-04 16:42:30 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
wf.fp = PyFile_AsFile(f);
|
1993-01-21 12:07:51 -04:00
|
|
|
wf.str = NULL;
|
|
|
|
wf.ptr = wf.end = NULL;
|
1996-06-26 17:41:23 -03:00
|
|
|
wf.error = 0;
|
1993-01-21 12:07:51 -04:00
|
|
|
w_object(x, &wf);
|
1996-06-26 17:41:23 -03:00
|
|
|
if (wf.error) {
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError, "unmarshallable object");
|
1996-06-26 17:41:23 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
1993-01-21 12:07:51 -04:00
|
|
|
marshal_load(self, args)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1993-01-21 12:07:51 -04:00
|
|
|
RFILE rf;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *f;
|
|
|
|
PyObject *v;
|
2000-03-30 20:37:41 -04:00
|
|
|
if (!PyArg_ParseTuple(args, "O:load", &f))
|
1993-01-21 12:07:51 -04:00
|
|
|
return NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
if (!PyFile_Check(f)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"marshal.load() arg must be file");
|
1991-06-04 16:42:30 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-04-29 17:08:16 -03:00
|
|
|
rf.fp = PyFile_AsFile(f);
|
1993-01-21 12:07:51 -04:00
|
|
|
rf.str = NULL;
|
|
|
|
rf.ptr = rf.end = NULL;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_Clear();
|
1993-01-21 12:07:51 -04:00
|
|
|
v = r_object(&rf);
|
1997-04-29 17:08:16 -03:00
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
Py_XDECREF(v);
|
1993-01-21 12:07:51 -04:00
|
|
|
v = NULL;
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
1993-01-21 12:07:51 -04:00
|
|
|
marshal_dumps(self, args)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1993-01-21 12:07:51 -04:00
|
|
|
{
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *x;
|
2000-03-30 20:37:41 -04:00
|
|
|
if (!PyArg_ParseTuple(args, "O:dumps", &x))
|
1993-01-21 12:07:51 -04:00
|
|
|
return NULL;
|
1996-08-19 19:07:17 -03:00
|
|
|
return PyMarshal_WriteObjectToString(x);
|
1993-01-21 12:07:51 -04:00
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
1993-01-21 12:07:51 -04:00
|
|
|
marshal_loads(self, args)
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1993-01-21 12:07:51 -04:00
|
|
|
{
|
|
|
|
RFILE rf;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *v;
|
1993-01-21 12:07:51 -04:00
|
|
|
char *s;
|
|
|
|
int n;
|
2000-03-30 20:37:41 -04:00
|
|
|
if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
|
1993-01-21 12:07:51 -04:00
|
|
|
return NULL;
|
|
|
|
rf.fp = NULL;
|
|
|
|
rf.str = args;
|
|
|
|
rf.ptr = s;
|
|
|
|
rf.end = s + n;
|
1997-04-29 17:08:16 -03:00
|
|
|
PyErr_Clear();
|
1993-01-21 12:07:51 -04:00
|
|
|
v = r_object(&rf);
|
1997-04-29 17:08:16 -03:00
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
Py_XDECREF(v);
|
1991-06-04 16:42:30 -03:00
|
|
|
v = NULL;
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyMethodDef marshal_methods[] = {
|
2000-03-30 20:37:41 -04:00
|
|
|
{"dump", marshal_dump, 1},
|
|
|
|
{"load", marshal_load, 1},
|
|
|
|
{"dumps", marshal_dumps, 1},
|
|
|
|
{"loads", marshal_loads, 1},
|
1991-06-04 16:42:30 -03:00
|
|
|
{NULL, NULL} /* sentinel */
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
1997-04-29 17:08:16 -03:00
|
|
|
PyMarshal_Init()
|
1991-06-04 16:42:30 -03:00
|
|
|
{
|
1997-04-29 17:08:16 -03:00
|
|
|
(void) Py_InitModule("marshal", marshal_methods);
|
1991-06-04 16:42:30 -03:00
|
|
|
}
|