1 /////////////// BufferStructDeclare.proto /////////////// 2 3 /* structs for buffer access */ 4 5 typedef struct { 6 Py_ssize_t shape, strides, suboffsets; 7 } __Pyx_Buf_DimInfo; 8 9 typedef struct { 10 size_t refcount; 11 Py_buffer pybuffer; 12 } __Pyx_Buffer; 13 14 typedef struct { 15 __Pyx_Buffer *rcbuffer; 16 char *data; 17 __Pyx_Buf_DimInfo diminfo[{{max_dims}}]; 18 } __Pyx_LocalBuf_ND; 19 20 /////////////// BufferIndexError.proto /////////////// 21 static void __Pyx_RaiseBufferIndexError(int axis); /*proto*/ 22 23 /////////////// BufferIndexError /////////////// 24 static void __Pyx_RaiseBufferIndexError(int axis) { 25 PyErr_Format(PyExc_IndexError, 26 "Out of bounds on buffer access (axis %d)", axis); 27 } 28 29 /////////////// BufferIndexErrorNogil.proto /////////////// 30 //@requires: BufferIndexError 31 32 static void __Pyx_RaiseBufferIndexErrorNogil(int axis); /*proto*/ 33 34 /////////////// BufferIndexErrorNogil /////////////// 35 static void __Pyx_RaiseBufferIndexErrorNogil(int axis) { 36 #ifdef WITH_THREAD 37 PyGILState_STATE gilstate = PyGILState_Ensure(); 38 #endif 39 __Pyx_RaiseBufferIndexError(axis); 40 #ifdef WITH_THREAD 41 PyGILState_Release(gilstate); 42 #endif 43 } 44 45 /////////////// BufferFallbackError.proto /////////////// 46 static void __Pyx_RaiseBufferFallbackError(void); /*proto*/ 47 48 /////////////// BufferFallbackError /////////////// 49 static void __Pyx_RaiseBufferFallbackError(void) { 50 PyErr_SetString(PyExc_ValueError, 51 "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); 52 } 53 54 /////////////// BufferFormatStructs.proto /////////////// 55 56 #define IS_UNSIGNED(type) (((type) -1) > 0) 57 58 /* Run-time type information about structs used with buffers */ 59 struct __Pyx_StructField_; 60 61 #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) 62 63 typedef struct { 64 const char* name; /* for error messages only */ 65 struct __Pyx_StructField_* fields; 66 size_t size; /* sizeof(type) */ 67 size_t arraysize[8]; /* length of array in each dimension */ 68 int ndim; 69 char typegroup; /* _R_eal, _C_omplex, Signed _I_nt, _U_nsigned int, _S_truct, _P_ointer, _O_bject, c_H_ar */ 70 char is_unsigned; 71 int flags; 72 } __Pyx_TypeInfo; 73 74 typedef struct __Pyx_StructField_ { 75 __Pyx_TypeInfo* type; 76 const char* name; 77 size_t offset; 78 } __Pyx_StructField; 79 80 typedef struct { 81 __Pyx_StructField* field; 82 size_t parent_offset; 83 } __Pyx_BufFmt_StackElem; 84 85 typedef struct { 86 __Pyx_StructField root; 87 __Pyx_BufFmt_StackElem* head; 88 size_t fmt_offset; 89 size_t new_count, enc_count; 90 size_t struct_alignment; 91 int is_complex; 92 char enc_type; 93 char new_packmode; 94 char enc_packmode; 95 char is_valid_array; 96 } __Pyx_BufFmt_Context; 97 98 /////////////// GetAndReleaseBuffer.proto /////////////// 99 #if PY_MAJOR_VERSION < 3 100 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); 101 static void __Pyx_ReleaseBuffer(Py_buffer *view); 102 #else 103 #define __Pyx_GetBuffer PyObject_GetBuffer 104 #define __Pyx_ReleaseBuffer PyBuffer_Release 105 #endif 106 107 /////////////// GetAndReleaseBuffer /////////////// 108 #if PY_MAJOR_VERSION < 3 109 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { 110 #if PY_VERSION_HEX >= 0x02060000 111 if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); 112 #endif 113 114 {{for type_ptr, getbuffer, releasebuffer in types}} 115 {{if getbuffer}} 116 if (PyObject_TypeCheck(obj, {{type_ptr}})) return {{getbuffer}}(obj, view, flags); 117 {{endif}} 118 {{endfor}} 119 120 #if PY_VERSION_HEX < 0x02060000 121 if (obj->ob_type->tp_dict) { 122 PyObject *getbuffer_cobj = PyObject_GetItem( 123 obj->ob_type->tp_dict, PYIDENT("__pyx_getbuffer")); 124 if (getbuffer_cobj) { 125 getbufferproc func = (getbufferproc) PyCObject_AsVoidPtr(getbuffer_cobj); 126 Py_DECREF(getbuffer_cobj); 127 if (!func) 128 goto fail; 129 130 return func(obj, view, flags); 131 } else { 132 PyErr_Clear(); 133 } 134 } 135 #endif 136 137 PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); 138 139 #if PY_VERSION_HEX < 0x02060000 140 fail: 141 #endif 142 143 return -1; 144 } 145 146 static void __Pyx_ReleaseBuffer(Py_buffer *view) { 147 PyObject *obj = view->obj; 148 if (!obj) return; 149 150 #if PY_VERSION_HEX >= 0x02060000 151 if (PyObject_CheckBuffer(obj)) { 152 PyBuffer_Release(view); 153 return; 154 } 155 #endif 156 157 {{for type_ptr, getbuffer, releasebuffer in types}} 158 {{if releasebuffer}} 159 if (PyObject_TypeCheck(obj, {{type_ptr}})) { {{releasebuffer}}(obj, view); return; } 160 {{endif}} 161 {{endfor}} 162 163 #if PY_VERSION_HEX < 0x02060000 164 if (obj->ob_type->tp_dict) { 165 PyObject *releasebuffer_cobj = PyObject_GetItem( 166 obj->ob_type->tp_dict, PYIDENT("__pyx_releasebuffer")); 167 if (releasebuffer_cobj) { 168 releasebufferproc func = (releasebufferproc) PyCObject_AsVoidPtr(releasebuffer_cobj); 169 Py_DECREF(releasebuffer_cobj); 170 if (!func) 171 goto fail; 172 func(obj, view); 173 return; 174 } else { 175 PyErr_Clear(); 176 } 177 } 178 #endif 179 180 goto nofail; 181 182 #if PY_VERSION_HEX < 0x02060000 183 fail: 184 #endif 185 PyErr_WriteUnraisable(obj); 186 187 nofail: 188 Py_DECREF(obj); 189 view->obj = NULL; 190 } 191 192 #endif /* PY_MAJOR_VERSION < 3 */ 193 194 /////////////// BufferFormatCheck.proto /////////////// 195 {{# 196 197 Buffer format string checking 198 199 Buffer type checking. Utility code for checking that acquired 200 buffers match our assumptions. We only need to check ndim and 201 the format string; the access mode/flags is checked by the 202 exporter. See: 203 204 http://docs.python.org/3/library/struct.html 205 http://legacy.python.org/dev/peps/pep-3118/#additions-to-the-struct-string-syntax 206 207 The alignment code is copied from _struct.c in Python. 208 }} 209 210 static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, 211 __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); 212 static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); 213 214 /////////////// BufferFormatCheck /////////////// 215 static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { 216 unsigned int n = 1; 217 return *(unsigned char*)(&n) != 0; 218 } 219 220 221 static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, 222 __Pyx_BufFmt_StackElem* stack, 223 __Pyx_TypeInfo* type) { 224 stack[0].field = &ctx->root; 225 stack[0].parent_offset = 0; 226 ctx->root.type = type; 227 ctx->root.name = "buffer dtype"; 228 ctx->root.offset = 0; 229 ctx->head = stack; 230 ctx->head->field = &ctx->root; 231 ctx->fmt_offset = 0; 232 ctx->head->parent_offset = 0; 233 ctx->new_packmode = '@'; 234 ctx->enc_packmode = '@'; 235 ctx->new_count = 1; 236 ctx->enc_count = 0; 237 ctx->enc_type = 0; 238 ctx->is_complex = 0; 239 ctx->is_valid_array = 0; 240 ctx->struct_alignment = 0; 241 while (type->typegroup == 'S') { 242 ++ctx->head; 243 ctx->head->field = type->fields; 244 ctx->head->parent_offset = 0; 245 type = type->fields->type; 246 } 247 } 248 249 static int __Pyx_BufFmt_ParseNumber(const char** ts) { 250 int count; 251 const char* t = *ts; 252 if (*t < '0' || *t > '9') { 253 return -1; 254 } else { 255 count = *t++ - '0'; 256 while (*t >= '0' && *t < '9') { 257 count *= 10; 258 count += *t++ - '0'; 259 } 260 } 261 *ts = t; 262 return count; 263 } 264 265 static int __Pyx_BufFmt_ExpectNumber(const char **ts) { 266 int number = __Pyx_BufFmt_ParseNumber(ts); 267 if (number == -1) /* First char was not a digit */ 268 PyErr_Format(PyExc_ValueError,\ 269 "Does not understand character buffer dtype format string ('%c')", **ts); 270 return number; 271 } 272 273 274 static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { 275 PyErr_Format(PyExc_ValueError, 276 "Unexpected format string character: '%c'", ch); 277 } 278 279 static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { 280 switch (ch) { 281 case 'c': return "'char'"; 282 case 'b': return "'signed char'"; 283 case 'B': return "'unsigned char'"; 284 case 'h': return "'short'"; 285 case 'H': return "'unsigned short'"; 286 case 'i': return "'int'"; 287 case 'I': return "'unsigned int'"; 288 case 'l': return "'long'"; 289 case 'L': return "'unsigned long'"; 290 case 'q': return "'long long'"; 291 case 'Q': return "'unsigned long long'"; 292 case 'f': return (is_complex ? "'complex float'" : "'float'"); 293 case 'd': return (is_complex ? "'complex double'" : "'double'"); 294 case 'g': return (is_complex ? "'complex long double'" : "'long double'"); 295 case 'T': return "a struct"; 296 case 'O': return "Python object"; 297 case 'P': return "a pointer"; 298 case 's': case 'p': return "a string"; 299 case 0: return "end"; 300 default: return "unparseable format string"; 301 } 302 } 303 304 static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { 305 switch (ch) { 306 case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; 307 case 'h': case 'H': return 2; 308 case 'i': case 'I': case 'l': case 'L': return 4; 309 case 'q': case 'Q': return 8; 310 case 'f': return (is_complex ? 8 : 4); 311 case 'd': return (is_complex ? 16 : 8); 312 case 'g': { 313 PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); 314 return 0; 315 } 316 case 'O': case 'P': return sizeof(void*); 317 default: 318 __Pyx_BufFmt_RaiseUnexpectedChar(ch); 319 return 0; 320 } 321 } 322 323 static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { 324 switch (ch) { 325 case 'c': case 'b': case 'B': case 's': case 'p': return 1; 326 case 'h': case 'H': return sizeof(short); 327 case 'i': case 'I': return sizeof(int); 328 case 'l': case 'L': return sizeof(long); 329 #ifdef HAVE_LONG_LONG 330 case 'q': case 'Q': return sizeof(PY_LONG_LONG); 331 #endif 332 case 'f': return sizeof(float) * (is_complex ? 2 : 1); 333 case 'd': return sizeof(double) * (is_complex ? 2 : 1); 334 case 'g': return sizeof(long double) * (is_complex ? 2 : 1); 335 case 'O': case 'P': return sizeof(void*); 336 default: { 337 __Pyx_BufFmt_RaiseUnexpectedChar(ch); 338 return 0; 339 } 340 } 341 } 342 343 typedef struct { char c; short x; } __Pyx_st_short; 344 typedef struct { char c; int x; } __Pyx_st_int; 345 typedef struct { char c; long x; } __Pyx_st_long; 346 typedef struct { char c; float x; } __Pyx_st_float; 347 typedef struct { char c; double x; } __Pyx_st_double; 348 typedef struct { char c; long double x; } __Pyx_st_longdouble; 349 typedef struct { char c; void *x; } __Pyx_st_void_p; 350 #ifdef HAVE_LONG_LONG 351 typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; 352 #endif 353 354 static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { 355 switch (ch) { 356 case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; 357 case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); 358 case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); 359 case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); 360 #ifdef HAVE_LONG_LONG 361 case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); 362 #endif 363 case 'f': return sizeof(__Pyx_st_float) - sizeof(float); 364 case 'd': return sizeof(__Pyx_st_double) - sizeof(double); 365 case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); 366 case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); 367 default: 368 __Pyx_BufFmt_RaiseUnexpectedChar(ch); 369 return 0; 370 } 371 } 372 373 /* These are for computing the padding at the end of the struct to align 374 on the first member of the struct. This will probably the same as above, 375 but we don't have any guarantees. 376 */ 377 typedef struct { short x; char c; } __Pyx_pad_short; 378 typedef struct { int x; char c; } __Pyx_pad_int; 379 typedef struct { long x; char c; } __Pyx_pad_long; 380 typedef struct { float x; char c; } __Pyx_pad_float; 381 typedef struct { double x; char c; } __Pyx_pad_double; 382 typedef struct { long double x; char c; } __Pyx_pad_longdouble; 383 typedef struct { void *x; char c; } __Pyx_pad_void_p; 384 #ifdef HAVE_LONG_LONG 385 typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; 386 #endif 387 388 static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { 389 switch (ch) { 390 case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; 391 case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); 392 case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); 393 case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); 394 #ifdef HAVE_LONG_LONG 395 case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); 396 #endif 397 case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); 398 case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); 399 case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); 400 case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); 401 default: 402 __Pyx_BufFmt_RaiseUnexpectedChar(ch); 403 return 0; 404 } 405 } 406 407 static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { 408 switch (ch) { 409 case 'c': 410 return 'H'; 411 case 'b': case 'h': case 'i': 412 case 'l': case 'q': case 's': case 'p': 413 return 'I'; 414 case 'B': case 'H': case 'I': case 'L': case 'Q': 415 return 'U'; 416 case 'f': case 'd': case 'g': 417 return (is_complex ? 'C' : 'R'); 418 case 'O': 419 return 'O'; 420 case 'P': 421 return 'P'; 422 default: { 423 __Pyx_BufFmt_RaiseUnexpectedChar(ch); 424 return 0; 425 } 426 } 427 } 428 429 430 static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { 431 if (ctx->head == NULL || ctx->head->field == &ctx->root) { 432 const char* expected; 433 const char* quote; 434 if (ctx->head == NULL) { 435 expected = "end"; 436 quote = ""; 437 } else { 438 expected = ctx->head->field->type->name; 439 quote = "'"; 440 } 441 PyErr_Format(PyExc_ValueError, 442 "Buffer dtype mismatch, expected %s%s%s but got %s", 443 quote, expected, quote, 444 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); 445 } else { 446 __Pyx_StructField* field = ctx->head->field; 447 __Pyx_StructField* parent = (ctx->head - 1)->field; 448 PyErr_Format(PyExc_ValueError, 449 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", 450 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), 451 parent->type->name, field->name); 452 } 453 } 454 455 static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { 456 char group; 457 size_t size, offset, arraysize = 1; 458 459 /* printf("processing... %s\n", ctx->head->field->type->name); */ 460 461 if (ctx->enc_type == 0) return 0; 462 463 /* Validate array size */ 464 if (ctx->head->field->type->arraysize[0]) { 465 int i, ndim = 0; 466 467 /* handle strings ('s' and 'p') */ 468 if (ctx->enc_type == 's' || ctx->enc_type == 'p') { 469 ctx->is_valid_array = ctx->head->field->type->ndim == 1; 470 ndim = 1; 471 if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { 472 PyErr_Format(PyExc_ValueError, 473 "Expected a dimension of size %zu, got %zu", 474 ctx->head->field->type->arraysize[0], ctx->enc_count); 475 return -1; 476 } 477 } 478 479 if (!ctx->is_valid_array) { 480 PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", 481 ctx->head->field->type->ndim, ndim); 482 return -1; 483 } 484 for (i = 0; i < ctx->head->field->type->ndim; i++) { 485 arraysize *= ctx->head->field->type->arraysize[i]; 486 } 487 ctx->is_valid_array = 0; 488 ctx->enc_count = 1; 489 } 490 491 group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); 492 do { 493 __Pyx_StructField* field = ctx->head->field; 494 __Pyx_TypeInfo* type = field->type; 495 496 if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { 497 size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); 498 } else { 499 size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); 500 } 501 502 if (ctx->enc_packmode == '@') { 503 size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); 504 size_t align_mod_offset; 505 if (align_at == 0) return -1; 506 align_mod_offset = ctx->fmt_offset % align_at; 507 if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; 508 509 if (ctx->struct_alignment == 0) 510 ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, 511 ctx->is_complex); 512 } 513 514 if (type->size != size || type->typegroup != group) { 515 if (type->typegroup == 'C' && type->fields != NULL) { 516 /* special case -- treat as struct rather than complex number */ 517 size_t parent_offset = ctx->head->parent_offset + field->offset; 518 ++ctx->head; 519 ctx->head->field = type->fields; 520 ctx->head->parent_offset = parent_offset; 521 continue; 522 } 523 524 if ((type->typegroup == 'H' || group == 'H') && type->size == size) { 525 /* special case -- chars don't care about sign */ 526 } else { 527 __Pyx_BufFmt_RaiseExpected(ctx); 528 return -1; 529 } 530 } 531 532 offset = ctx->head->parent_offset + field->offset; 533 if (ctx->fmt_offset != offset) { 534 PyErr_Format(PyExc_ValueError, 535 "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", 536 (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); 537 return -1; 538 } 539 540 ctx->fmt_offset += size; 541 if (arraysize) 542 ctx->fmt_offset += (arraysize - 1) * size; 543 544 --ctx->enc_count; /* Consume from buffer string */ 545 546 /* Done checking, move to next field, pushing or popping struct stack if needed */ 547 while (1) { 548 if (field == &ctx->root) { 549 ctx->head = NULL; 550 if (ctx->enc_count != 0) { 551 __Pyx_BufFmt_RaiseExpected(ctx); 552 return -1; 553 } 554 break; /* breaks both loops as ctx->enc_count == 0 */ 555 } 556 ctx->head->field = ++field; 557 if (field->type == NULL) { 558 --ctx->head; 559 field = ctx->head->field; 560 continue; 561 } else if (field->type->typegroup == 'S') { 562 size_t parent_offset = ctx->head->parent_offset + field->offset; 563 if (field->type->fields->type == NULL) continue; /* empty struct */ 564 field = field->type->fields; 565 ++ctx->head; 566 ctx->head->field = field; 567 ctx->head->parent_offset = parent_offset; 568 break; 569 } else { 570 break; 571 } 572 } 573 } while (ctx->enc_count); 574 ctx->enc_type = 0; 575 ctx->is_complex = 0; 576 return 0; 577 } 578 579 /* Parse an array in the format string (e.g. (1,2,3)) */ 580 static CYTHON_INLINE PyObject * 581 __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) 582 { 583 const char *ts = *tsp; 584 int i = 0, number; 585 int ndim = ctx->head->field->type->ndim; 586 ; 587 ++ts; 588 if (ctx->new_count != 1) { 589 PyErr_SetString(PyExc_ValueError, 590 "Cannot handle repeated arrays in format string"); 591 return NULL; 592 } 593 594 /* Process the previous element */ 595 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 596 597 /* Parse all numbers in the format string */ 598 while (*ts && *ts != ')') { 599 // ignore space characters (not using isspace() due to C/C++ problem on MacOS-X) 600 switch (*ts) { 601 case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; 602 default: break; /* not a 'break' in the loop */ 603 } 604 605 number = __Pyx_BufFmt_ExpectNumber(&ts); 606 if (number == -1) return NULL; 607 608 if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) 609 return PyErr_Format(PyExc_ValueError, 610 "Expected a dimension of size %zu, got %d", 611 ctx->head->field->type->arraysize[i], number); 612 613 if (*ts != ',' && *ts != ')') 614 return PyErr_Format(PyExc_ValueError, 615 "Expected a comma in format string, got '%c'", *ts); 616 617 if (*ts == ',') ts++; 618 i++; 619 } 620 621 if (i != ndim) 622 return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", 623 ctx->head->field->type->ndim, i); 624 625 if (!*ts) { 626 PyErr_SetString(PyExc_ValueError, 627 "Unexpected end of format string, expected ')'"); 628 return NULL; 629 } 630 631 ctx->is_valid_array = 1; 632 ctx->new_count = 1; 633 *tsp = ++ts; 634 return Py_None; 635 } 636 637 static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { 638 int got_Z = 0; 639 640 while (1) { 641 /* puts(ts); */ 642 switch(*ts) { 643 case 0: 644 if (ctx->enc_type != 0 && ctx->head == NULL) { 645 __Pyx_BufFmt_RaiseExpected(ctx); 646 return NULL; 647 } 648 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 649 if (ctx->head != NULL) { 650 __Pyx_BufFmt_RaiseExpected(ctx); 651 return NULL; 652 } 653 return ts; 654 case ' ': 655 case '\r': 656 case '\n': 657 ++ts; 658 break; 659 case '<': 660 if (!__Pyx_IsLittleEndian()) { 661 PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); 662 return NULL; 663 } 664 ctx->new_packmode = '='; 665 ++ts; 666 break; 667 case '>': 668 case '!': 669 if (__Pyx_IsLittleEndian()) { 670 PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); 671 return NULL; 672 } 673 ctx->new_packmode = '='; 674 ++ts; 675 break; 676 case '=': 677 case '@': 678 case '^': 679 ctx->new_packmode = *ts++; 680 break; 681 case 'T': /* substruct */ 682 { 683 const char* ts_after_sub; 684 size_t i, struct_count = ctx->new_count; 685 size_t struct_alignment = ctx->struct_alignment; 686 ctx->new_count = 1; 687 ++ts; 688 if (*ts != '{') { 689 PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); 690 return NULL; 691 } 692 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 693 ctx->enc_type = 0; /* Erase processed last struct element */ 694 ctx->enc_count = 0; 695 ctx->struct_alignment = 0; 696 ++ts; 697 ts_after_sub = ts; 698 for (i = 0; i != struct_count; ++i) { 699 ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); 700 if (!ts_after_sub) return NULL; 701 } 702 ts = ts_after_sub; 703 if (struct_alignment) ctx->struct_alignment = struct_alignment; 704 } 705 break; 706 case '}': /* end of substruct; either repeat or move on */ 707 { 708 size_t alignment = ctx->struct_alignment; 709 ++ts; 710 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 711 ctx->enc_type = 0; /* Erase processed last struct element */ 712 if (alignment && ctx->fmt_offset % alignment) { 713 /* Pad struct on size of the first member */ 714 ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); 715 } 716 } 717 return ts; 718 case 'x': 719 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 720 ctx->fmt_offset += ctx->new_count; 721 ctx->new_count = 1; 722 ctx->enc_count = 0; 723 ctx->enc_type = 0; 724 ctx->enc_packmode = ctx->new_packmode; 725 ++ts; 726 break; 727 case 'Z': 728 got_Z = 1; 729 ++ts; 730 if (*ts != 'f' && *ts != 'd' && *ts != 'g') { 731 __Pyx_BufFmt_RaiseUnexpectedChar('Z'); 732 return NULL; 733 } 734 /* fall through */ 735 case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': 736 case 'l': case 'L': case 'q': case 'Q': 737 case 'f': case 'd': case 'g': 738 case 'O': case 'p': 739 if (ctx->enc_type == *ts && got_Z == ctx->is_complex && 740 ctx->enc_packmode == ctx->new_packmode) { 741 /* Continue pooling same type */ 742 ctx->enc_count += ctx->new_count; 743 ctx->new_count = 1; 744 got_Z = 0; 745 ++ts; 746 break; 747 } 748 /* fall through */ 749 case 's': 750 /* 's' or new type (cannot be added to current pool) */ 751 if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; 752 ctx->enc_count = ctx->new_count; 753 ctx->enc_packmode = ctx->new_packmode; 754 ctx->enc_type = *ts; 755 ctx->is_complex = got_Z; 756 ++ts; 757 ctx->new_count = 1; 758 got_Z = 0; 759 break; 760 case ':': 761 ++ts; 762 while(*ts != ':') ++ts; 763 ++ts; 764 break; 765 case '(': 766 if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; 767 break; 768 default: 769 { 770 int number = __Pyx_BufFmt_ExpectNumber(&ts); 771 if (number == -1) return NULL; 772 ctx->new_count = (size_t)number; 773 } 774 } 775 } 776 } 777 778 static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { 779 buf->buf = NULL; 780 buf->obj = NULL; 781 buf->strides = __Pyx_zeros; 782 buf->shape = __Pyx_zeros; 783 buf->suboffsets = __Pyx_minusones; 784 } 785 786 static CYTHON_INLINE int __Pyx_GetBufferAndValidate( 787 Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, 788 int nd, int cast, __Pyx_BufFmt_StackElem* stack) 789 { 790 if (obj == Py_None || obj == NULL) { 791 __Pyx_ZeroBuffer(buf); 792 return 0; 793 } 794 buf->buf = NULL; 795 if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; 796 if (buf->ndim != nd) { 797 PyErr_Format(PyExc_ValueError, 798 "Buffer has wrong number of dimensions (expected %d, got %d)", 799 nd, buf->ndim); 800 goto fail; 801 } 802 if (!cast) { 803 __Pyx_BufFmt_Context ctx; 804 __Pyx_BufFmt_Init(&ctx, stack, dtype); 805 if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; 806 } 807 if ((unsigned)buf->itemsize != dtype->size) { 808 PyErr_Format(PyExc_ValueError, 809 "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", 810 buf->itemsize, (buf->itemsize > 1) ? "s" : "", 811 dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); 812 goto fail; 813 } 814 if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; 815 return 0; 816 fail:; 817 __Pyx_ZeroBuffer(buf); 818 return -1; 819 } 820 821 static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { 822 if (info->buf == NULL) return; 823 if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; 824 __Pyx_ReleaseBuffer(info); 825 } 826 827 /////////////// TypeInfoCompare.proto /////////////// 828 static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); 829 830 /////////////// TypeInfoCompare /////////////// 831 /* See if two dtypes are equal */ 832 static int 833 __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) 834 { 835 int i; 836 837 if (!a || !b) 838 return 0; 839 840 if (a == b) 841 return 1; 842 843 if (a->size != b->size || a->typegroup != b->typegroup || 844 a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { 845 if (a->typegroup == 'H' || b->typegroup == 'H') { 846 /* Special case for chars */ 847 return a->size == b->size; 848 } else { 849 return 0; 850 } 851 } 852 853 if (a->ndim) { 854 /* Verify multidimensional C arrays */ 855 for (i = 0; i < a->ndim; i++) 856 if (a->arraysize[i] != b->arraysize[i]) 857 return 0; 858 } 859 860 if (a->typegroup == 'S') { 861 /* Check for packed struct */ 862 if (a->flags != b->flags) 863 return 0; 864 865 /* compare all struct fields */ 866 if (a->fields || b->fields) { 867 /* Check if both have fields */ 868 if (!(a->fields && b->fields)) 869 return 0; 870 871 /* compare */ 872 for (i = 0; a->fields[i].type && b->fields[i].type; i++) { 873 __Pyx_StructField *field_a = a->fields + i; 874 __Pyx_StructField *field_b = b->fields + i; 875 876 if (field_a->offset != field_b->offset || 877 !__pyx_typeinfo_cmp(field_a->type, field_b->type)) 878 return 0; 879 } 880 881 /* If all fields are processed, we have a match */ 882 return !a->fields[i].type && !b->fields[i].type; 883 } 884 } 885 886 return 1; 887 } 888 889 890 891 /////////////// TypeInfoToFormat.proto /////////////// 892 struct __pyx_typeinfo_string { 893 char string[3]; 894 }; 895 static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *type); 896 897 /////////////// TypeInfoToFormat /////////////// 898 {{# See also MemoryView.pyx:BufferFormatFromTypeInfo }} 899 900 static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *type) { 901 struct __pyx_typeinfo_string result = { {0} }; 902 char *buf = (char *) result.string; 903 size_t size = type->size; 904 905 switch (type->typegroup) { 906 case 'H': 907 *buf = 'c'; 908 break; 909 case 'I': 910 case 'U': 911 if (size == 1) 912 *buf = 'b'; 913 else if (size == 2) 914 *buf = 'h'; 915 else if (size == 4) 916 *buf = 'i'; 917 else if (size == 8) 918 *buf = 'q'; 919 920 if (type->is_unsigned) 921 *buf = toupper(*buf); 922 break; 923 case 'P': 924 *buf = 'P'; 925 break; 926 case 'C': 927 { 928 __Pyx_TypeInfo complex_type = *type; 929 complex_type.typegroup = 'R'; 930 complex_type.size /= 2; 931 932 *buf++ = 'Z'; 933 *buf = __Pyx_TypeInfoToFormat(&complex_type).string[0]; 934 break; 935 } 936 case 'R': 937 if (size == 4) 938 *buf = 'f'; 939 else if (size == 8) 940 *buf = 'd'; 941 else 942 *buf = 'g'; 943 break; 944 } 945 946 return result; 947 } 948
