{	/* NULL is a valid return value, it does not necessarily means that	   an exception is set. */	PyObject *v, *v2, *v3;	long i, n;	int type = r_byte(p); 	switch (type) { 	case EOF:		PyErr_SetString(PyExc_EOFError,				"EOF read where object expected");		return NULL; 	case TYPE_NULL:		return NULL; 	case TYPE_NONE:		Py_INCREF(Py_None);		return Py_None; 	case TYPE_STOPITER:		Py_INCREF(PyExc_StopIteration);		return PyExc_StopIteration; 	case TYPE_ELLIPSIS:		Py_INCREF(Py_Ellipsis);		return Py_Ellipsis; 	case TYPE_FALSE:		Py_INCREF(Py_False);		return Py_False; 	case TYPE_TRUE:		Py_INCREF(Py_True);		return Py_True; 	case TYPE_INT:		return PyInt_FromLong(r_long(p)); 	case TYPE_INT64:		return r_long64(p); 	case TYPE_LONG:		{			int size;			PyLongObject *ob;			n = r_long(p);			if (n < -INT_MAX || n > INT_MAX) {				PyErr_SetString(PyExc_ValueError,						"bad marshal data");				return NULL;			}			size = n<0 ? -n : n;			ob = _PyLong_New(size);			if (ob == NULL)				return NULL;			ob->ob_size = n;			for (i = 0; i < size; i++) {				int digit = r_short(p);				if (digit < 0) {					Py_DECREF(ob);					PyErr_SetString(PyExc_ValueError,							"bad marshal data");					return NULL;				}				ob->ob_digit[i] = digit;			}			return (PyObject *)ob;		} 	case TYPE_FLOAT:		{			char buf[256];			double dx;			n = r_byte(p);			if (n == EOF || r_string(buf, (int)n, p) != n) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			buf[n] = '\0';			PyFPE_START_PROTECT("atof", return 0)			dx = PyOS_ascii_atof(buf);			PyFPE_END_PROTECT(dx)			return PyFloat_FromDouble(dx);		} 	case TYPE_BINARY_FLOAT:		{			unsigned char buf[8];			double x;			if (r_string((char*)buf, 8, p) != 8) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			x = _PyFloat_Unpack8(buf, 1);			if (x == -1.0 && PyErr_Occurred()) {				return NULL;			}			return PyFloat_FromDouble(x);		} #ifndef WITHOUT_COMPLEX	case TYPE_COMPLEX:		{			char buf[256];			Py_complex c;			n = r_byte(p);			if (n == EOF || r_string(buf, (int)n, p) != n) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			buf[n] = '\0';			PyFPE_START_PROTECT("atof", return 0)			c.real = PyOS_ascii_atof(buf);			PyFPE_END_PROTECT(c)			n = r_byte(p);			if (n == EOF || r_string(buf, (int)n, p) != n) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			buf[n] = '\0';			PyFPE_START_PROTECT("atof", return 0)			c.imag = PyOS_ascii_atof(buf);			PyFPE_END_PROTECT(c)			return PyComplex_FromCComplex(c);		} 	case TYPE_BINARY_COMPLEX:		{			unsigned char buf[8];			Py_complex c;			if (r_string((char*)buf, 8, p) != 8) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			c.real = _PyFloat_Unpack8(buf, 1);			if (c.real == -1.0 && PyErr_Occurred()) {				return NULL;			}			if (r_string((char*)buf, 8, p) != 8) {				PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");				return NULL;			}			c.imag = _PyFloat_Unpack8(buf, 1);			if (c.imag == -1.0 && PyErr_Occurred()) {				return NULL;			}			return PyComplex_FromCComplex(c);		}#endif 	case TYPE_INTERNED:	case TYPE_STRING:		n = r_long(p);		if (n < 0 || n > INT_MAX) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		v = PyString_FromStringAndSize((char *)NULL, n);		if (v == NULL)			return v;		if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {			Py_DECREF(v);			PyErr_SetString(PyExc_EOFError,					"EOF read where object expected");			return NULL;		}		if (type == TYPE_INTERNED) {			PyString_InternInPlace(&v);			PyList_Append(p->strings, v);		}		return v; 	case TYPE_STRINGREF:		n = r_long(p);		if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		v = PyList_GET_ITEM(p->strings, n);		Py_INCREF(v);		return v; #ifdef Py_USING_UNICODE	case TYPE_UNICODE:	    {		char *buffer; 		n = r_long(p);		if (n < 0 || n > INT_MAX) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		buffer = PyMem_NEW(char, n);		if (buffer == NULL)			return PyErr_NoMemory();		if (r_string(buffer, (int)n, p) != n) {			PyMem_DEL(buffer);			PyErr_SetString(PyExc_EOFError,				"EOF read where object expected");			return NULL;		}		v = PyUnicode_DecodeUTF8(buffer, n, NULL);		PyMem_DEL(buffer);		return v;	    }#endif 	case TYPE_TUPLE:		n = r_long(p);		if (n < 0 || n > INT_MAX) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		v = PyTuple_New((int)n);		if (v == NULL)			return v;		for (i = 0; i < n; i++) {			v2 = r_object(p);			if ( v2 == NULL ) {				if (!PyErr_Occurred())					PyErr_SetString(PyExc_TypeError,						"NULL object in marshal data");				Py_DECREF(v);				v = NULL;				break;			}			PyTuple_SET_ITEM(v, (int)i, v2);		}		return v; 	case TYPE_LIST:		n = r_long(p);		if (n < 0 || n > INT_MAX) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		v = PyList_New((int)n);		if (v == NULL)			return v;		for (i = 0; i < n; i++) {			v2 = r_object(p);			if ( v2 == NULL ) {				if (!PyErr_Occurred())					PyErr_SetString(PyExc_TypeError,						"NULL object in marshal data");				Py_DECREF(v);				v = NULL;				break;			}			PyList_SetItem(v, (int)i, v2);		}		return v; 	case TYPE_DICT:		v = PyDict_New();		if (v == NULL)			return NULL;		for (;;) {			PyObject *key, *val;			key = r_object(p);			if (key == NULL)				break;			val = r_object(p);			if (val != NULL)				PyDict_SetItem(v, key, val);			Py_DECREF(key);			Py_XDECREF(val);		}		if (PyErr_Occurred()) {			Py_DECREF(v);			v = NULL;		}		return v; 	case TYPE_SET:	case TYPE_FROZENSET:		n = r_long(p);		if (n < 0) {			PyErr_SetString(PyExc_ValueError, "bad marshal data");			return NULL;		}		v = PyTuple_New((int)n);		if (v == NULL)			return v;		for (i = 0; i < n; i++) {			v2 = r_object(p);			if ( v2 == NULL ) {				if (!PyErr_Occurred())					PyErr_SetString(PyExc_TypeError,						"NULL object in marshal data");				Py_DECREF(v);				v = NULL;				break;			}			PyTuple_SET_ITEM(v, (int)i, v2);		}		if (v == NULL)			return v;		if (type == TYPE_SET)			v3 = PySet_New(v);		else			v3 = PyFrozenSet_New(v);		Py_DECREF(v);		return v3; 	case TYPE_CODE:		if (PyEval_GetRestricted()) {			PyErr_SetString(PyExc_RuntimeError,				"cannot unmarshal code objects in "				"restricted execution mode");			return NULL;		}		else {			int argcount;			int nlocals;			int stacksize;			int flags;			PyObject *code = NULL;			PyObject *consts = NULL;			PyObject *names = NULL;			PyObject *varnames = NULL;			PyObject *freevars = NULL;			PyObject *cellvars = NULL;			PyObject *filename = NULL;			PyObject *name = NULL;			int firstlineno;			PyObject *lnotab = NULL;						v = NULL;                         /* XXX ignore long->int overflows for now */			argcount = (int)r_long(p);			nlocals = (int)r_long(p);			stacksize = (int)r_long(p);			flags = (int)r_long(p);			code = r_object(p);			if (code == NULL)				goto code_error;			consts = r_object(p);			if (consts == NULL)				goto code_error;			names = r_object(p);			if (names == NULL)				goto code_error;			varnames = r_object(p);			if (varnames == NULL)				goto code_error;			freevars = r_object(p);			if (freevars == NULL)				goto code_error;			cellvars = r_object(p);			if (cellvars == NULL)				goto code_error;			filename = r_object(p);			if (filename == NULL)				goto code_error;			name = r_object(p);			if (name == NULL)				goto code_error;			firstlineno = (int)r_long(p);			lnotab = r_object(p);			if (lnotab == NULL)				goto code_error; 			v = (PyObject *) PyCode_New(					argcount, nlocals, stacksize, flags,					code, consts, names, varnames,					freevars, cellvars, filename, name,					firstlineno, lnotab); 		  code_error:			Py_XDECREF(code);			Py_XDECREF(consts);			Py_XDECREF(names);			Py_XDECREF(varnames);			Py_XDECREF(freevars);			Py_XDECREF(cellvars);			Py_XDECREF(filename);			Py_XDECREF(name);			Py_XDECREF(lnotab); 		}		return v; 	default:		/* Bogus data got written, which isn't ideal.		   This will let you keep working and recover. */		PyErr_SetString(PyExc_ValueError, "bad marshal data");		return NULL; 	}} static PyObject *read_object(RFILE *p){	PyObject *v;	if (PyErr_Occurred()) {		fprintf(stderr, "XXX readobject called with exception set\n");		return NULL;	}	v = r_object(p);	if (v == NULL && !PyErr_Occurred())		PyErr_SetString(PyExc_TypeError, "NULL object in marshal data");	return v;} intPyMarshal_ReadShortFromFile(FILE *fp){	RFILE rf;	assert(fp);	rf.fp = fp;	rf.strings = NULL;	rf.end = rf.ptr = NULL;	return r_short(&rf);} longPyMarshal_ReadLongFromFile(FILE *fp){	RFILE rf;	rf.fp = fp;	rf.strings = NULL;	return r_long(&rf);} #ifdef HAVE_FSTAT/* Return size of file in bytes; < 0 if unknown. */static off_tgetfilesize(FILE *fp){	struct stat st;	if (fstat(fileno(fp), &st) != 0)		return -1;	else		return st.st_size;}#endif /* 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. * CAUTION:  since this may read the entire remainder of the file, don't * call it unless you know you're done with the file. */PyObject *PyMarshal_ReadLastObjectFromFile(FILE *fp){/* 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#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((int)filesize);		if (pBuf != NULL) {			PyObject* v;			size_t n;			/* filesize must fit into an int, because it			   is smaller than REASONABLE_FILE_LIMIT */			n = fread(pBuf, 1, (int)filesize, fp);			v = PyMarshal_ReadObjectFromString(pBuf, n);			if (pBuf != buf)				PyMem_FREE(pBuf);			return v;		} 	}#endif	/* 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); #undef SMALL_FILE_LIMIT#undef REASONABLE_FILE_LIMIT} PyObject *PyMarshal_ReadObjectFromFile(FILE *fp){

Lines 501–1000 of 1155. Previous lines Load more