1 /* Abstract Object Interface (many thanks to Jim Fulton) */

     2 

     3 #include "Python.h"

     4 #include <ctype.h>

     5 #include "structmember.h" /* we need the offsetof() macro from there */

     6 #include "longintrepr.h"

     7 

     8 #define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \

     9 				Py_TPFLAGS_CHECKTYPES)

    10 

    11 

    12 /* Shorthands to return certain errors */

    13 

    14 static PyObject *

    15 type_error(const char *msg, PyObject *obj)

    16 {

    17 	PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);

    18 	return NULL;

    19 }

    20 

    21 static PyObject *

    22 null_error(void)

    23 {

    24 	if (!PyErr_Occurred())

    25 		PyErr_SetString(PyExc_SystemError,

    26 				"null argument to internal routine");

    27 	return NULL;

    28 }

    29 

    30 /* Operations on any object */

    31 

    32 int

    33 PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)

    34 {

    35 	int r;

    36 

    37 	if (o1 == NULL || o2 == NULL) {

    38 		null_error();

    39 		return -1;

    40 	}

    41 	r = PyObject_Compare(o1, o2);

    42 	if (PyErr_Occurred())

    43 		return -1;

    44 	*result = r;

    45 	return 0;

    46 }

    47 

    48 PyObject *

    49 PyObject_Type(PyObject *o)

    50 {

    51 	PyObject *v;

    52 

    53 	if (o == NULL)

    54 		return null_error();

    55 	v = (PyObject *)o->ob_type;

    56 	Py_INCREF(v);

    57 	return v;

    58 }

    59 

    60 Py_ssize_t

    61 PyObject_Size(PyObject *o)

    62 {

    63 	PySequenceMethods *m;

    64 

    65 	if (o == NULL) {

    66 		null_error();

    67 		return -1;

    68 	}

    69 

    70 	m = o->ob_type->tp_as_sequence;

    71 	if (m && m->sq_length)

    72 		return m->sq_length(o);

    73 

    74 	return PyMapping_Size(o);

    75 }

    76 

    77 #undef PyObject_Length

    78 Py_ssize_t

    79 PyObject_Length(PyObject *o)

    80 {

    81 	return PyObject_Size(o);

    82 }

    83 #define PyObject_Length PyObject_Size

    84 

    85 

    86 /* The length hint function returns a non-negative value from o.__len__()

    87    or o.__length_hint__().  If those methods aren't found or return a negative

    88    value, then the defaultvalue is returned.  This function never fails. 

    89    Accordingly, it will mask exceptions raised in either method.

    90 */

    91 

    92 Py_ssize_t

    93 _PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)

    94 {

    95 	static PyObject *hintstrobj = NULL;

    96 	PyObject *ro;

    97 	Py_ssize_t rv;

    98 

    99 	/* try o.__len__() */

   100 	rv = PyObject_Size(o);

   101 	if (rv >= 0)

   102 		return rv;

   103 	if (PyErr_Occurred())

   104 		PyErr_Clear();

   105 

   106 	/* cache a hashed version of the attribute string */

   107 	if (hintstrobj == NULL) {

   108 		hintstrobj = PyString_InternFromString("__length_hint__");

   109 		if (hintstrobj == NULL)

   110 			goto defaultcase;

   111 	}

   112 

   113 	/* try o.__length_hint__() */

   114 	ro = PyObject_CallMethodObjArgs(o, hintstrobj, NULL);

   115 	if (ro == NULL)

   116 		goto defaultcase;

   117 	rv = PyInt_AsLong(ro);

   118 	Py_DECREF(ro);

   119 	if (rv >= 0)

   120 		return rv;

   121 

   122 defaultcase:

   123 	if (PyErr_Occurred())

   124 		PyErr_Clear();

   125 	return defaultvalue;

   126 }

   127 

   128 PyObject *

   129 PyObject_GetItem(PyObject *o, PyObject *key)

   130 {

   131 	PyMappingMethods *m;

   132 

   133 	if (o == NULL || key == NULL)

   134 		return null_error();

   135 

   136 	m = o->ob_type->tp_as_mapping;

   137 	if (m && m->mp_subscript)

   138 		return m->mp_subscript(o, key);

   139 

   140 	if (o->ob_type->tp_as_sequence) {

   141 		if (PyIndex_Check(key)) {

   142 			Py_ssize_t key_value;

   143 			key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

   144 			if (key_value == -1 && PyErr_Occurred())

   145 				return NULL;

   146 			return PySequence_GetItem(o, key_value);

   147 		}

   148 		else if (o->ob_type->tp_as_sequence->sq_item)

   149 			return type_error("sequence index must "

   150 					  "be integer, not '%.200s'", key);

   151 	}

   152 

   153 	return type_error("'%.200s' object is unsubscriptable", o);

   154 }

   155 

   156 int

   157 PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)

   158 {

   159 	PyMappingMethods *m;

   160 

   161 	if (o == NULL || key == NULL || value == NULL) {

   162 		null_error();

   163 		return -1;

   164 	}

   165 	m = o->ob_type->tp_as_mapping;

   166 	if (m && m->mp_ass_subscript)

   167 		return m->mp_ass_subscript(o, key, value);

   168 

   169 	if (o->ob_type->tp_as_sequence) {

   170 		if (PyIndex_Check(key)) {

   171 			Py_ssize_t key_value;

   172 			key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

   173 			if (key_value == -1 && PyErr_Occurred())

   174 				return -1;

   175 			return PySequence_SetItem(o, key_value, value);

   176 		}

   177 		else if (o->ob_type->tp_as_sequence->sq_ass_item) {

   178 			type_error("sequence index must be "

   179 				   "integer, not '%.200s'", key);

   180 			return -1;

   181 		}

   182 	}

   183 

   184 	type_error("'%.200s' object does not support item assignment", o);

   185 	return -1;

   186 }

   187 

   188 int

   189 PyObject_DelItem(PyObject *o, PyObject *key)

   190 {

   191 	PyMappingMethods *m;

   192 

   193 	if (o == NULL || key == NULL) {

   194 		null_error();

   195 		return -1;

   196 	}

   197 	m = o->ob_type->tp_as_mapping;

   198 	if (m && m->mp_ass_subscript)

   199 		return m->mp_ass_subscript(o, key, (PyObject*)NULL);

   200 

   201 	if (o->ob_type->tp_as_sequence) {

   202 		if (PyIndex_Check(key)) {

   203 			Py_ssize_t key_value;

   204 			key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

   205 			if (key_value == -1 && PyErr_Occurred())

   206 				return -1;

   207 			return PySequence_DelItem(o, key_value);

   208 		}

   209 		else if (o->ob_type->tp_as_sequence->sq_ass_item) {

   210 			type_error("sequence index must be "

   211 				   "integer, not '%.200s'", key);

   212 			return -1;

   213 		}

   214 	}

   215 

   216 	type_error("'%.200s' object does not support item deletion", o);

   217 	return -1;

   218 }

   219 

   220 int

   221 PyObject_DelItemString(PyObject *o, char *key)

   222 {

   223 	PyObject *okey;

   224 	int ret;

   225 

   226 	if (o == NULL || key == NULL) {

   227 		null_error();

   228 		return -1;

   229 	}

   230 	okey = PyString_FromString(key);

   231 	if (okey == NULL)

   232 		return -1;

   233 	ret = PyObject_DelItem(o, okey);

   234 	Py_DECREF(okey);

   235 	return ret;

   236 }

   237 

   238 int

   239 PyObject_AsCharBuffer(PyObject *obj,

   240 			  const char **buffer,

   241 			  Py_ssize_t *buffer_len)

   242 {

   243 	PyBufferProcs *pb;

   244 	char *pp;

   245 	Py_ssize_t len;

   246 

   247 	if (obj == NULL || buffer == NULL || buffer_len == NULL) {

   248 		null_error();

   249 		return -1;

   250 	}

   251 	pb = obj->ob_type->tp_as_buffer;

   252 	if (pb == NULL ||

   253 	     pb->bf_getcharbuffer == NULL ||

   254 	     pb->bf_getsegcount == NULL) {

   255 		PyErr_SetString(PyExc_TypeError,

   256 				"expected a character buffer object");

   257 		return -1;

   258 	}

   259 	if ((*pb->bf_getsegcount)(obj,NULL) != 1) {

   260 		PyErr_SetString(PyExc_TypeError,

   261 				"expected a single-segment buffer object");

   262 		return -1;

   263 	}

   264 	len = (*pb->bf_getcharbuffer)(obj, 0, &pp);

   265 	if (len < 0)

   266 		return -1;

   267 	*buffer = pp;

   268 	*buffer_len = len;

   269 	return 0;

   270 }

   271 

   272 int

   273 PyObject_CheckReadBuffer(PyObject *obj)

   274 {

   275 	PyBufferProcs *pb = obj->ob_type->tp_as_buffer;

   276 

   277 	if (pb == NULL ||

   278 	    pb->bf_getreadbuffer == NULL ||

   279 	    pb->bf_getsegcount == NULL ||

   280 	    (*pb->bf_getsegcount)(obj, NULL) != 1)

   281 		return 0;

   282 	return 1;

   283 }

   284 

   285 int PyObject_AsReadBuffer(PyObject *obj,

   286 			  const void **buffer,

   287 			  Py_ssize_t *buffer_len)

   288 {

   289 	PyBufferProcs *pb;

   290 	void *pp;

   291 	Py_ssize_t len;

   292 

   293 	if (obj == NULL || buffer == NULL || buffer_len == NULL) {

   294 		null_error();

   295 		return -1;

   296 	}

   297 	pb = obj->ob_type->tp_as_buffer;

   298 	if (pb == NULL ||

   299 	     pb->bf_getreadbuffer == NULL ||

   300 	     pb->bf_getsegcount == NULL) {

   301 		PyErr_SetString(PyExc_TypeError,

   302 				"expected a readable buffer object");

   303 		return -1;

   304 	}

   305 	if ((*pb->bf_getsegcount)(obj, NULL) != 1) {

   306 		PyErr_SetString(PyExc_TypeError,

   307 				"expected a single-segment buffer object");

   308 		return -1;

   309 	}

   310 	len = (*pb->bf_getreadbuffer)(obj, 0, &pp);

   311 	if (len < 0)

   312 		return -1;

   313 	*buffer = pp;

   314 	*buffer_len = len;

   315 	return 0;

   316 }

   317 

   318 int PyObject_AsWriteBuffer(PyObject *obj,

   319 			   void **buffer,

   320 			   Py_ssize_t *buffer_len)

   321 {

   322 	PyBufferProcs *pb;

   323 	void*pp;

   324 	Py_ssize_t len;

   325 

   326 	if (obj == NULL || buffer == NULL || buffer_len == NULL) {

   327 		null_error();

   328 		return -1;

   329 	}

   330 	pb = obj->ob_type->tp_as_buffer;

   331 	if (pb == NULL ||

   332 	     pb->bf_getwritebuffer == NULL ||

   333 	     pb->bf_getsegcount == NULL) {

   334 		PyErr_SetString(PyExc_TypeError,

   335 				"expected a writeable buffer object");

   336 		return -1;

   337 	}

   338 	if ((*pb->bf_getsegcount)(obj, NULL) != 1) {

   339 		PyErr_SetString(PyExc_TypeError,

   340 				"expected a single-segment buffer object");

   341 		return -1;

   342 	}

   343 	len = (*pb->bf_getwritebuffer)(obj,0,&pp);

   344 	if (len < 0)

   345 		return -1;

   346 	*buffer = pp;

   347 	*buffer_len = len;

   348 	return 0;

   349 }

   350 

   351 /* Buffer C-API for Python 3.0 */

   352 

   353 int

   354 PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)

   355 {

   356 	if (!PyObject_CheckBuffer(obj)) {

   357 		PyErr_Format(PyExc_TypeError,

   358                              "'%100s' does not have the buffer interface",

   359                              Py_TYPE(obj)->tp_name);

   360 		return -1;

   361 	}

   362 	return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);

   363 }

   364 

   365 static int

   366 _IsFortranContiguous(Py_buffer *view)

   367 {

   368 	Py_ssize_t sd, dim;

   369 	int i;

   370 

   371 	if (view->ndim == 0) return 1;

   372 	if (view->strides == NULL) return (view->ndim == 1);

   373 

   374 	sd = view->itemsize;

   375 	if (view->ndim == 1) return (view->shape[0] == 1 ||

   376 				   sd == view->strides[0]);

   377 	for (i=0; i<view->ndim; i++) {

   378 		dim = view->shape[i];

   379 		if (dim == 0) return 1;

   380 		if (view->strides[i] != sd) return 0;

   381 		sd *= dim;

   382 	}

   383 	return 1;

   384 }

   385 

   386 static int

   387 _IsCContiguous(Py_buffer *view)

   388 {

   389 	Py_ssize_t sd, dim;

   390 	int i;

   391 

   392 	if (view->ndim == 0) return 1;

   393 	if (view->strides == NULL) return 1;

   394 

   395 	sd = view->itemsize;

   396 	if (view->ndim == 1) return (view->shape[0] == 1 ||

   397 				   sd == view->strides[0]);

   398 	for (i=view->ndim-1; i>=0; i--) {

   399 		dim = view->shape[i];

   400 		if (dim == 0) return 1;

   401 		if (view->strides[i] != sd) return 0;

   402 		sd *= dim;

   403 	}

   404 	return 1;

   405 }

   406 

   407 int

   408 PyBuffer_IsContiguous(Py_buffer *view, char fort)

   409 {

   410 

   411 	if (view->suboffsets != NULL) return 0;

   412 

   413 	if (fort == 'C')

   414 		return _IsCContiguous(view);

   415 	else if (fort == 'F')

   416 		return _IsFortranContiguous(view);

   417 	else if (fort == 'A')

   418 		return (_IsCContiguous(view) || _IsFortranContiguous(view));

   419 	return 0;

   420 }

   421 

   422 

   423 void*

   424 PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)

   425 {

   426 	char* pointer;

   427 	int i;

   428 	pointer = (char *)view->buf;

   429 	for (i = 0; i < view->ndim; i++) {

   430 		pointer += view->strides[i]*indices[i];

   431 		if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {

   432 			pointer = *((char**)pointer) + view->suboffsets[i];

   433 		}

   434 	}

   435 	return (void*)pointer;

   436 }

   437 

   438 

   439 static void

   440 _add_one_to_index_F(int nd, Py_ssize_t *index, Py_ssize_t *shape)

   441 {

   442 	int k;

   443 

   444 	for (k=0; k<nd; k++) {

   445 		if (index[k] < shape[k]-1) {

   446 			index[k]++;

   447 			break;

   448 		}

   449 		else {

   450 			index[k] = 0;

   451 		}

   452 	}

   453 }

   454 

   455 static void

   456 _add_one_to_index_C(int nd, Py_ssize_t *index, Py_ssize_t *shape)

   457 {

   458 	int k;

   459 

   460 	for (k=nd-1; k>=0; k--) {

   461 		if (index[k] < shape[k]-1) {

   462 			index[k]++;

   463 			break;

   464 		}

   465 		else {

   466 			index[k] = 0;

   467 		}

   468 	}

   469 }

   470 

   471   /* view is not checked for consistency in either of these.  It is

   472      assumed that the size of the buffer is view->len in

   473      view->len / view->itemsize elements.

   474   */

   475 

   476 int

   477 PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)

   478 {

   479 	int k;

   480 	void (*addone)(int, Py_ssize_t *, Py_ssize_t *);

   481 	Py_ssize_t *indices, elements;

   482 	char *dest, *ptr;

   483 

   484 	if (len > view->len) {

   485 		len = view->len;

   486 	}

   487 

   488 	if (PyBuffer_IsContiguous(view, fort)) {

   489 		/* simplest copy is all that is needed */

   490 		memcpy(buf, view->buf, len);

   491 		return 0;

   492 	}

   493 

   494 	/* Otherwise a more elaborate scheme is needed */

   495 

   496 	/* XXX(nnorwitz): need to check for overflow! */

   497 	indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));

   498 	if (indices == NULL) {

   499 		PyErr_NoMemory();

   500 		return -1;

   501 	}

   502 	for (k=0; k<view->ndim;k++) {

   503 		indices[k] = 0;

   504 	}

   505 

   506 	if (fort == 'F') {

   507 		addone = _add_one_to_index_F;

   508 	}

   509 	else {

   510 		addone = _add_one_to_index_C;

   511 	}

   512 	dest = buf;

   513 	/* XXX : This is not going to be the fastest code in the world

   514 		 several optimizations are possible.

   515 	 */

   516 	elements = len / view->itemsize;

   517 	while (elements--) {

   518 		addone(view->ndim, indices, view->shape);

   519 		ptr = PyBuffer_GetPointer(view, indices);

   520 		memcpy(dest, ptr, view->itemsize);

   521 		dest += view->itemsize;

   522 	}

   523 	PyMem_Free(indices);

   524 	return 0;

   525 }

   526 

   527 int

   528 PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)

   529 {

   530 	int k;

   531 	void (*addone)(int, Py_ssize_t *, Py_ssize_t *);

   532 	Py_ssize_t *indices, elements;

   533 	char *src, *ptr;

   534 

   535 	if (len > view->len) {

   536 		len = view->len;

   537 	}

   538 

   539 	if (PyBuffer_IsContiguous(view, fort)) {

   540 		/* simplest copy is all that is needed */

   541 		memcpy(view->buf, buf, len);

   542 		return 0;

   543 	}

   544 

   545 	/* Otherwise a more elaborate scheme is needed */

   546 

   547 	/* XXX(nnorwitz): need to check for overflow! */

   548 	indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));

   549 	if (indices == NULL) {

   550 		PyErr_NoMemory();

   551 		return -1;

   552 	}

   553 	for (k=0; k<view->ndim;k++) {

   554 		indices[k] = 0;

   555 	}

   556 

   557 	if (fort == 'F') {

   558 		addone = _add_one_to_index_F;

   559 	}

   560 	else {

   561 		addone = _add_one_to_index_C;

   562 	}

   563 	src = buf;

   564 	/* XXX : This is not going to be the fastest code in the world

   565 		 several optimizations are possible.

   566 	 */

   567 	elements = len / view->itemsize;

   568 	while (elements--) {

   569 		addone(view->ndim, indices, view->shape);

   570 		ptr = PyBuffer_GetPointer(view, indices);

   571 		memcpy(ptr, src, view->itemsize);

   572 		src += view->itemsize;

   573 	}

   574 

   575 	PyMem_Free(indices);

   576 	return 0;

   577 }

   578 

   579 int PyObject_CopyData(PyObject *dest, PyObject *src)

   580 {

   581 	Py_buffer view_dest, view_src;

   582 	int k;

   583 	Py_ssize_t *indices, elements;

   584 	char *dptr, *sptr;

   585 

   586 	if (!PyObject_CheckBuffer(dest) ||

   587 	    !PyObject_CheckBuffer(src)) {

   588 		PyErr_SetString(PyExc_TypeError,

   589 				"both destination and source must have the "\

   590 				"buffer interface");

   591 		return -1;

   592 	}

   593 

   594 	if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;

   595 	if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {

   596 		PyBuffer_Release(&view_dest);

   597 		return -1;

   598 	}

   599 

   600 	if (view_dest.len < view_src.len) {

   601 		PyErr_SetString(PyExc_BufferError,

   602 				"destination is too small to receive data from source");

   603 		PyBuffer_Release(&view_dest);

   604 		PyBuffer_Release(&view_src);

   605 		return -1;

   606 	}

   607 

   608 	if ((PyBuffer_IsContiguous(&view_dest, 'C') &&

   609 	     PyBuffer_IsContiguous(&view_src, 'C')) ||

   610 	    (PyBuffer_IsContiguous(&view_dest, 'F') &&

   611 	     PyBuffer_IsContiguous(&view_src, 'F'))) {

   612 		/* simplest copy is all that is needed */

   613 		memcpy(view_dest.buf, view_src.buf, view_src.len);

   614 		PyBuffer_Release(&view_dest);

   615 		PyBuffer_Release(&view_src);

   616 		return 0;

   617 	}

   618 

   619 	/* Otherwise a more elaborate copy scheme is needed */

   620 

   621 	/* XXX(nnorwitz): need to check for overflow! */

   622 	indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);

   623 	if (indices == NULL) {

   624 		PyErr_NoMemory();

   625 		PyBuffer_Release(&view_dest);

   626 		PyBuffer_Release(&view_src);

   627 		return -1;

   628 	}

   629 	for (k=0; k<view_src.ndim;k++) {

   630 		indices[k] = 0;

   631 	}

   632 	elements = 1;

   633 	for (k=0; k<view_src.ndim; k++) {

   634 		/* XXX(nnorwitz): can this overflow? */

   635 		elements *= view_src.shape[k];

   636 	}

   637 	while (elements--) {

   638 		_add_one_to_index_C(view_src.ndim, indices, view_src.shape);

   639 		dptr = PyBuffer_GetPointer(&view_dest, indices);

   640 		sptr = PyBuffer_GetPointer(&view_src, indices);

   641 		memcpy(dptr, sptr, view_src.itemsize);

   642 	}

   643 	PyMem_Free(indices);

   644 	PyBuffer_Release(&view_dest);

   645 	PyBuffer_Release(&view_src);

   646 	return 0;

   647 }

   648 

   649 void

   650 PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,

   651 			       Py_ssize_t *strides, int itemsize,

   652 			       char fort)

   653 {

   654 	int k;

   655 	Py_ssize_t sd;

   656 

   657 	sd = itemsize;

   658 	if (fort == 'F') {

   659 		for (k=0; k<nd; k++) {

   660 			strides[k] = sd;

   661 			sd *= shape[k];

   662 		}

   663 	}

   664 	else {

   665 		for (k=nd-1; k>=0; k--) {

   666 			strides[k] = sd;

   667 			sd *= shape[k];

   668 		}

   669 	}

   670 	return;

   671 }

   672 

   673 int

   674 PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,

   675 	      int readonly, int flags)

   676 {

   677 	if (view == NULL) return 0;

   678 	if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&

   679 	    (readonly == 1)) {

   680 		PyErr_SetString(PyExc_BufferError,

   681 				"Object is not writable.");

   682 		return -1;

   683 	}

   684 

   685 	view->obj = obj;

   686 	if (obj)

   687 		Py_INCREF(obj);

   688 	view->buf = buf;

   689 	view->len = len;

   690 	view->readonly = readonly;

   691 	view->itemsize = 1;

   692 	view->format = NULL;

   693 	if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)

   694 		view->format = "B";

   695 	view->ndim = 1;

   696 	view->shape = NULL;

   697 	if ((flags & PyBUF_ND) == PyBUF_ND)

   698 		view->shape = &(view->len);

   699 	view->strides = NULL;

   700 	if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)

   701 		view->strides = &(view->itemsize);

   702 	view->suboffsets = NULL;

   703 	view->internal = NULL;

   704 	return 0;

   705 }

   706 

   707 void

   708 PyBuffer_Release(Py_buffer *view)

   709 {

   710 	PyObject *obj = view->obj;

   711 	if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer)

   712 		Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view);

   713 	Py_XDECREF(obj);

   714 	view->obj = NULL;

   715 }

   716 

   717 PyObject *

   718 PyObject_Format(PyObject* obj, PyObject *format_spec)

   719 {

   720 	static PyObject * str__format__ = NULL;

   721 	PyObject *empty = NULL;

   722 	PyObject *result = NULL;

   723 	int spec_is_unicode;

   724 	int result_is_unicode;

   725 

   726 	/* Initialize cached value */

   727 	if (str__format__ == NULL) {

   728 		/* Initialize static variable needed by _PyType_Lookup */

   729 		str__format__ = PyString_InternFromString("__format__");

   730 		if (str__format__ == NULL)

   731 			goto done;

   732 	}

   733 

   734 	/* If no format_spec is provided, use an empty string */

   735 	if (format_spec == NULL) {

   736 		empty = PyString_FromStringAndSize(NULL, 0);

   737 		format_spec = empty;

   738 	}

   739 

   740 	/* Check the format_spec type, and make sure it's str or unicode */

   741 	if (PyUnicode_Check(format_spec))

   742 		spec_is_unicode = 1;

   743 	else if (PyString_Check(format_spec))

   744 		spec_is_unicode = 0;

   745 	else {

   746 		PyErr_Format(PyExc_TypeError,

   747 			     "format expects arg 2 to be string "

   748 			     "or unicode, not %.100s", Py_TYPE(format_spec)->tp_name);

   749 		goto done;

   750 	}

   751 

   752 	/* Make sure the type is initialized.  float gets initialized late */

   753 	if (Py_TYPE(obj)->tp_dict == NULL)

   754 		if (PyType_Ready(Py_TYPE(obj)) < 0)

   755 			goto done;

   756 

   757 	/* Check for a __format__ method and call it. */

   758 	if (PyInstance_Check(obj)) {

   759 		/* We're an instance of a classic class */

   760 		PyObject *bound_method = PyObject_GetAttr(obj,

   761 							  str__format__);

   762 		if (bound_method != NULL) {

   763 			result = PyObject_CallFunctionObjArgs(bound_method,

   764 							      format_spec,

   765 							      NULL);

   766 			Py_DECREF(bound_method);

   767 		} else {

   768 			PyObject *self_as_str;

   769 			PyObject *format_method;

   770 

   771 			PyErr_Clear();

   772 			/* Per the PEP, convert to str (or unicode,

   773 			   depending on the type of the format

   774 			   specifier).  For new-style classes, this

   775 			   logic is done by object.__format__(). */

   776 			if (spec_is_unicode)

   777 				self_as_str = PyObject_Unicode(obj);

   778 			else

   779 				self_as_str = PyObject_Str(obj);

   780 			if (self_as_str == NULL)

   781 				goto done;

   782 

   783 			/* Then call str.__format__ on that result */

   784 			format_method = PyObject_GetAttr(self_as_str,

   785 							 str__format__);

   786 			if (format_method == NULL) {

   787 				Py_DECREF(self_as_str);

   788 				goto done;

   789 			}

   790                         result = PyObject_CallFunctionObjArgs(format_method,

   791 							      format_spec,

   792 							      NULL);

   793 			Py_DECREF(self_as_str);

   794 			Py_DECREF(format_method);

   795 			if (result == NULL)

   796 				goto done;

   797                 }

   798 	} else {

   799 		/* Not an instance of a classic class, use the code

   800 		   from py3k */

   801 

   802 		/* Find the (unbound!) __format__ method (a borrowed

   803 		   reference) */

   804 		PyObject *method = _PyType_Lookup(Py_TYPE(obj),

   805 						  str__format__);

   806 		if (method == NULL) {

   807 			PyErr_Format(PyExc_TypeError,

   808 				     "Type %.100s doesn't define __format__",

   809 				     Py_TYPE(obj)->tp_name);

   810 			goto done;

   811 		}

   812 		/* And call it, binding it to the value */

   813 		result = PyObject_CallFunctionObjArgs(method, obj,

   814 						      format_spec, NULL);

   815 	}

   816 

   817 	if (result == NULL)

   818 		goto done;

   819 

   820 	/* Check the result type, and make sure it's str or unicode */

   821 	if (PyUnicode_Check(result))

   822 		result_is_unicode = 1;

   823 	else if (PyString_Check(result))

   824 		result_is_unicode = 0;

   825 	else {

   826 		PyErr_Format(PyExc_TypeError,

   827 			     "%.100s.__format__ must return string or "

   828 			     "unicode, not %.100s", Py_TYPE(obj)->tp_name,

   829 			     Py_TYPE(result)->tp_name);

   830 		Py_DECREF(result);

   831 		result = NULL;

   832 		goto done;

   833 	}

   834 

   835 	/* Convert to unicode, if needed.  Required if spec is unicode

   836 	   and result is str */

   837 	if (spec_is_unicode && !result_is_unicode) {

   838 		PyObject *tmp = PyObject_Unicode(result);

   839 		/* This logic works whether or not tmp is NULL */

   840 		Py_DECREF(result);

   841 		result = tmp;

   842 	}

   843 

   844 done:

   845 	Py_XDECREF(empty);

   846 	return result;

   847 }

   848 

   849 /* Operations on numbers */

   850 

   851 int

   852 PyNumber_Check(PyObject *o)

   853 {

   854 	return o && o->ob_type->tp_as_number &&

   855 	       (o->ob_type->tp_as_number->nb_int ||

   856 		o->ob_type->tp_as_number->nb_float);

   857 }

   858 

   859 /* Binary operators */

   860 

   861 /* New style number protocol support */

   862 

   863 #define NB_SLOT(x) offsetof(PyNumberMethods, x)

   864 #define NB_BINOP(nb_methods, slot) \

   865 		(*(binaryfunc*)(& ((char*)nb_methods)[slot]))

   866 #define NB_TERNOP(nb_methods, slot) \

   867 		(*(ternaryfunc*)(& ((char*)nb_methods)[slot]))

   868 

   869 /*

   870   Calling scheme used for binary operations:

   871 

   872   v	w	Action

   873   -------------------------------------------------------------------

   874   new	new	w.op(v,w)[*], v.op(v,w), w.op(v,w)

   875   new	old	v.op(v,w), coerce(v,w), v.op(v,w)

   876   old	new	w.op(v,w), coerce(v,w), v.op(v,w)

   877   old	old	coerce(v,w), v.op(v,w)

   878 

   879   [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of

   880       v->ob_type

   881 

   882   Legend:

   883   -------

   884   * new == new style number

   885   * old == old style number

   886   * Action indicates the order in which operations are tried until either

   887     a valid result is produced or an error occurs.

   888 

   889  */

   890 

   891 static PyObject *

   892 binary_op1(PyObject *v, PyObject *w, const int op_slot)

   893 {

   894 	PyObject *x;

   895 	binaryfunc slotv = NULL;

   896 	binaryfunc slotw = NULL;

   897 

   898 	if (v->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(v))

   899 		slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);

   900 	if (w->ob_type != v->ob_type &&

   901 	    w->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(w)) {

   902 		slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);

   903 		if (slotw == slotv)

   904 			slotw = NULL;

   905 	}

   906 	if (slotv) {

   907 		if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

   908 			x = slotw(v, w);

   909 			if (x != Py_NotImplemented)

   910 				return x;

   911 			Py_DECREF(x); /* can't do it */

   912 			slotw = NULL;

   913 		}

   914 		x = slotv(v, w);

   915 		if (x != Py_NotImplemented)

   916 			return x;

   917 		Py_DECREF(x); /* can't do it */

   918 	}

   919 	if (slotw) {

   920 		x = slotw(v, w);

   921 		if (x != Py_NotImplemented)

   922 			return x;

   923 		Py_DECREF(x); /* can't do it */

   924 	}

   925 	if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) {

   926 		int err = PyNumber_CoerceEx(&v, &w);

   927 		if (err < 0) {

   928 			return NULL;

   929 		}

   930 		if (err == 0) {

   931 			PyNumberMethods *mv = v->ob_type->tp_as_number;

   932 			if (mv) {

   933 				binaryfunc slot;

   934 				slot = NB_BINOP(mv, op_slot);

   935 				if (slot) {

   936 					x = slot(v, w);

   937 					Py_DECREF(v);

   938 					Py_DECREF(w);

   939 					return x;

   940 				}

   941 			}

   942 			/* CoerceEx incremented the reference counts */

   943 			Py_DECREF(v);

   944 			Py_DECREF(w);

   945 		}

   946 	}

   947 	Py_INCREF(Py_NotImplemented);

   948 	return Py_NotImplemented;

   949 }

   950 

   951 static PyObject *

   952 binop_type_error(PyObject *v, PyObject *w, const char *op_name)

   953 {

   954 	PyErr_Format(PyExc_TypeError,

   955 		     "unsupported operand type(s) for %.100s: "

   956 		     "'%.100s' and '%.100s'",

   957 		     op_name,

   958 		     v->ob_type->tp_name,

   959 		     w->ob_type->tp_name);

   960 	return NULL;

   961 }

   962 

   963 static PyObject *

   964 binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)

   965 {

   966 	PyObject *result = binary_op1(v, w, op_slot);

   967 	if (result == Py_NotImplemented) {

   968 		Py_DECREF(result);

   969 		return binop_type_error(v, w, op_name);

   970 	}

   971 	return result;

   972 }

   973 

   974 

   975 /*

   976   Calling scheme used for ternary operations:

   977 

   978   *** In some cases, w.op is called before v.op; see binary_op1. ***

   979 

   980   v	w	z	Action

   981   -------------------------------------------------------------------

   982   new	new	new	v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)

   983   new	old	new	v.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   984   old	new	new	w.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   985   old	old	new	z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   986   new	new	old	v.op(v,w,z), w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   987   new	old	old	v.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   988   old	new	old	w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)

   989   old	old	old	coerce(v,w,z), v.op(v,w,z)

   990 

   991   Legend:

   992   -------

   993   * new == new style number

   994   * old == old style number

   995   * Action indicates the order in which operations are tried until either

   996     a valid result is produced or an error occurs.

   997   * coerce(v,w,z) actually does: coerce(v,w), coerce(v,z), coerce(w,z) and

   998     only if z != Py_None; if z == Py_None, then it is treated as absent

   999     variable and only coerce(v,w) is tried.

  1000 

  1001  */

  1002 

  1003 static PyObject *

  1004 ternary_op(PyObject *v,

  1005 	   PyObject *w,

  1006 	   PyObject *z,

  1007 	   const int op_slot,

  1008 	   const char *op_name)

  1009 {

  1010 	PyNumberMethods *mv, *mw, *mz;

  1011 	PyObject *x = NULL;

  1012 	ternaryfunc slotv = NULL;

  1013 	ternaryfunc slotw = NULL;

  1014 	ternaryfunc slotz = NULL;

  1015 

  1016 	mv = v->ob_type->tp_as_number;

  1017 	mw = w->ob_type->tp_as_number;

  1018 	if (mv != NULL && NEW_STYLE_NUMBER(v))

  1019 		slotv = NB_TERNOP(mv, op_slot);

  1020 	if (w->ob_type != v->ob_type &&

  1021 	    mw != NULL && NEW_STYLE_NUMBER(w)) {

  1022 		slotw = NB_TERNOP(mw, op_slot);

  1023 		if (slotw == slotv)

  1024 			slotw = NULL;

  1025 	}

  1026 	if (slotv) {

  1027 		if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

  1028 			x = slotw(v, w, z);

  1029 			if (x != Py_NotImplemented)

  1030 				return x;

  1031 			Py_DECREF(x); /* can't do it */

  1032 			slotw = NULL;

  1033 		}

  1034 		x = slotv(v, w, z);

  1035 		if (x != Py_NotImplemented)

  1036 			return x;

  1037 		Py_DECREF(x); /* can't do it */

  1038 	}

  1039 	if (slotw) {

  1040 		x = slotw(v, w, z);

  1041 		if (x != Py_NotImplemented)

  1042 			return x;

  1043 		Py_DECREF(x); /* can't do it */

  1044 	}

  1045 	mz = z->ob_type->tp_as_number;

  1046 	if (mz != NULL && NEW_STYLE_NUMBER(z)) {

  1047 		slotz = NB_TERNOP(mz, op_slot);

  1048 		if (slotz == slotv || slotz == slotw)

  1049 			slotz = NULL;

  1050 		if (slotz) {

  1051 			x = slotz(v, w, z);

  1052 			if (x != Py_NotImplemented)

  1053 				return x;

  1054 			Py_DECREF(x); /* can't do it */

  1055 		}

  1056 	}

  1057 

  1058 	if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w) ||

  1059 			(z != Py_None && !NEW_STYLE_NUMBER(z))) {

  1060 		/* we have an old style operand, coerce */

  1061 		PyObject *v1, *z1, *w2, *z2;

  1062 		int c;

  1063 

  1064 		c = PyNumber_Coerce(&v, &w);

  1065 		if (c != 0)

  1066 			goto error3;

  1067 

  1068 		/* Special case: if the third argument is None, it is

  1069 		   treated as absent argument and not coerced. */

  1070 		if (z == Py_None) {

  1071 			if (v->ob_type->tp_as_number) {

  1072 				slotz = NB_TERNOP(v->ob_type->tp_as_number,

  1073 						  op_slot);

  1074 				if (slotz)

  1075 					x = slotz(v, w, z);

  1076 				else

  1077 					c = -1;

  1078 			}

  1079 			else

  1080 				c = -1;

  1081 			goto error2;

  1082 		}

  1083 		v1 = v;

  1084 		z1 = z;

  1085 		c = PyNumber_Coerce(&v1, &z1);

  1086 		if (c != 0)

  1087 			goto error2;

  1088 		w2 = w;

  1089 		z2 = z1;

  1090 		c = PyNumber_Coerce(&w2, &z2);

  1091 		if (c != 0)

  1092 			goto error1;

  1093 

  1094 		if (v1->ob_type->tp_as_number != NULL) {

  1095 			slotv = NB_TERNOP(v1->ob_type->tp_as_number,

  1096 					  op_slot);

  1097 			if (slotv)

  1098 				x = slotv(v1, w2, z2);

  1099 			else

  1100 				c = -1;

  1101 		}

  1102 		else

  1103 			c = -1;

  1104 

  1105 		Py_DECREF(w2);

  1106 		Py_DECREF(z2);

  1107 	error1:

  1108 		Py_DECREF(v1);

  1109 		Py_DECREF(z1);

  1110 	error2:

  1111 		Py_DECREF(v);

  1112 		Py_DECREF(w);

  1113 	error3:

  1114 		if (c >= 0)

  1115 			return x;

  1116 	}

  1117 

  1118 	if (z == Py_None)

  1119 		PyErr_Format(

  1120 			PyExc_TypeError,

  1121 			"unsupported operand type(s) for ** or pow(): "

  1122 			"'%.100s' and '%.100s'",

  1123 			v->ob_type->tp_name,

  1124 			w->ob_type->tp_name);

  1125 	else

  1126 		PyErr_Format(

  1127 			PyExc_TypeError,

  1128 			"unsupported operand type(s) for pow(): "

  1129 			"'%.100s', '%.100s', '%.100s'",

  1130 			v->ob_type->tp_name,

  1131 			w->ob_type->tp_name,

  1132 			z->ob_type->tp_name);

  1133 	return NULL;

  1134 }

  1135