Changeset 388 for python/vendor/current/Include/abstract.h
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
-
python/vendor/current/Include/abstract.h (modified) (101 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Include/abstract.h
r2 r388 33 33 If the programmer wants to get an item from another type of object 34 34 that provides sequence behavior, there is no clear way to do it 35 correctly. 35 correctly. 36 36 37 37 The persistent programmer may peruse object.h and find that the … … 45 45 differ by the type of object being used. Unfortunately, these 46 46 semantics are not clearly described in the current include files. 47 An abstract interface providing more consistent semantics is needed. 47 An abstract interface providing more consistent semantics is needed. 48 48 49 49 Proposal … … 78 78 79 79 From the point of view of Python accessing services provided by C 80 modules: 80 modules: 81 81 82 82 - "Python module interface": this interface consist of the basic … … 134 134 int PyObject_Print(PyObject *o, FILE *fp, int flags); 135 135 136 137 138 options. The only option currently supported is Py_Print_RAW. 139 140 (What should be said about Py_Print_RAW?)136 Print an object, o, on file, fp. Returns -1 on 137 error. The flags argument is used to enable certain printing 138 options. The only option currently supported is Py_Print_RAW. 139 140 (What should be said about Py_Print_RAW?) 141 141 142 142 */ … … 146 146 int PyObject_HasAttrString(PyObject *o, char *attr_name); 147 147 148 149 150 hasattr(o,attr_name). 151 152 148 Returns 1 if o has the attribute attr_name, and 0 otherwise. 149 This is equivalent to the Python expression: 150 hasattr(o,attr_name). 151 152 This function always succeeds. 153 153 154 154 */ … … 158 158 PyObject* PyObject_GetAttrString(PyObject *o, char *attr_name); 159 159 160 161 162 160 Retrieve an attributed named attr_name form object o. 161 Returns the attribute value on success, or NULL on failure. 162 This is the equivalent of the Python expression: o.attr_name. 163 163 164 164 */ … … 168 168 int PyObject_HasAttr(PyObject *o, PyObject *attr_name); 169 169 170 171 172 hasattr(o,attr_name). 173 174 170 Returns 1 if o has the attribute attr_name, and 0 otherwise. 171 This is equivalent to the Python expression: 172 hasattr(o,attr_name). 173 174 This function always succeeds. 175 175 176 176 */ … … 180 180 PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name); 181 181 182 183 184 182 Retrieve an attributed named attr_name form object o. 183 Returns the attribute value on success, or NULL on failure. 184 This is the equivalent of the Python expression: o.attr_name. 185 185 186 186 */ … … 191 191 int PyObject_SetAttrString(PyObject *o, char *attr_name, PyObject *v); 192 192 193 194 195 193 Set the value of the attribute named attr_name, for object o, 194 to the value, v. Returns -1 on failure. This is 195 the equivalent of the Python statement: o.attr_name=v. 196 196 197 197 */ … … 201 201 int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v); 202 202 203 204 205 203 Set the value of the attribute named attr_name, for object o, 204 to the value, v. Returns -1 on failure. This is 205 the equivalent of the Python statement: o.attr_name=v. 206 206 207 207 */ … … 211 211 int PyObject_DelAttrString(PyObject *o, char *attr_name); 212 212 213 214 215 213 Delete attribute named attr_name, for object o. Returns 214 -1 on failure. This is the equivalent of the Python 215 statement: del o.attr_name. 216 216 217 217 */ … … 222 222 int PyObject_DelAttr(PyObject *o, PyObject *attr_name); 223 223 224 225 226 224 Delete attribute named attr_name, for object o. Returns -1 225 on failure. This is the equivalent of the Python 226 statement: del o.attr_name. 227 227 228 228 */ … … 232 232 233 233 /* 234 235 236 237 238 234 Compare the values of o1 and o2 using a routine provided by 235 o1, if one exists, otherwise with a routine provided by o2. 236 The result of the comparison is returned in result. Returns 237 -1 on failure. This is the equivalent of the Python 238 statement: result=cmp(o1,o2). 239 239 240 240 */ … … 244 244 int PyObject_Compare(PyObject *o1, PyObject *o2); 245 245 246 247 248 249 250 246 Compare the values of o1 and o2 using a routine provided by 247 o1, if one exists, otherwise with a routine provided by o2. 248 Returns the result of the comparison on success. On error, 249 the value returned is undefined. This is equivalent to the 250 Python expression: cmp(o1,o2). 251 251 252 252 */ … … 256 256 PyObject *PyObject_Repr(PyObject *o); 257 257 258 259 260 261 262 258 Compute the string representation of object, o. Returns the 259 string representation on success, NULL on failure. This is 260 the equivalent of the Python expression: repr(o). 261 262 Called by the repr() built-in function and by reverse quotes. 263 263 264 264 */ … … 268 268 PyObject *PyObject_Str(PyObject *o); 269 269 270 271 272 273 274 275 270 Compute the string representation of object, o. Returns the 271 string representation on success, NULL on failure. This is 272 the equivalent of the Python expression: str(o).) 273 274 Called by the str() built-in function and by the print 275 statement. 276 276 277 277 */ … … 281 281 PyObject *PyObject_Unicode(PyObject *o); 282 282 283 284 285 286 287 283 Compute the unicode representation of object, o. Returns the 284 unicode representation on success, NULL on failure. This is 285 the equivalent of the Python expression: unistr(o).) 286 287 Called by the unistr() built-in function. 288 288 289 289 */ … … 293 293 PyAPI_FUNC(int) PyCallable_Check(PyObject *o); 294 294 295 296 297 298 295 Determine if the object, o, is callable. Return 1 if the 296 object is callable and 0 otherwise. 297 298 This function always succeeds. 299 299 300 300 */ … … 303 303 304 304 PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object, 305 306 307 /* 308 309 310 311 312 */ 313 305 PyObject *args, PyObject *kw); 306 307 /* 308 Call a callable Python object, callable_object, with 309 arguments and keywords arguments. The 'args' argument can not be 310 NULL, but the 'kw' argument can be NULL. 311 312 */ 313 314 314 PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object, 315 315 PyObject *args); 316 316 317 317 /* 318 319 320 321 322 318 Call a callable Python object, callable_object, with 319 arguments given by the tuple, args. If no arguments are 320 needed, then args may be NULL. Returns the result of the 321 call on success, or NULL on failure. This is the equivalent 322 of the Python expression: apply(o,args). 323 323 324 324 */ … … 328 328 329 329 /* 330 331 332 333 334 335 330 Call a callable Python object, callable_object, with a 331 variable number of C arguments. The C arguments are described 332 using a mkvalue-style format string. The format may be NULL, 333 indicating that no arguments are provided. Returns the 334 result of the call on success, or NULL on failure. This is 335 the equivalent of the Python expression: apply(o,args). 336 336 337 337 */ … … 342 342 343 343 /* 344 345 346 347 348 349 344 Call the method named m of object o with a variable number of 345 C arguments. The C arguments are described by a mkvalue 346 format string. The format may be NULL, indicating that no 347 arguments are provided. Returns the result of the call on 348 success, or NULL on failure. This is the equivalent of the 349 Python expression: o.method(args). 350 350 */ 351 351 352 352 PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable, 353 353 char *format, ...); 354 354 PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o, 355 356 355 char *name, 356 char *format, ...); 357 357 358 358 PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable, … … 360 360 361 361 /* 362 363 364 365 366 362 Call a callable Python object, callable_object, with a 363 variable number of C arguments. The C arguments are provided 364 as PyObject * values, terminated by a NULL. Returns the 365 result of the call on success, or NULL on failure. This is 366 the equivalent of the Python expression: apply(o,args). 367 367 */ 368 368 … … 372 372 373 373 /* 374 375 376 377 378 374 Call the method named m of object o with a variable number of 375 C arguments. The C arguments are provided as PyObject * 376 values, terminated by NULL. Returns the result of the call 377 on success, or NULL on failure. This is the equivalent of 378 the Python expression: o.method(args). 379 379 */ 380 380 … … 384 384 long PyObject_Hash(PyObject *o); 385 385 386 387 388 386 Compute and return the hash, hash_value, of an object, o. On 387 failure, return -1. This is the equivalent of the Python 388 expression: hash(o). 389 389 390 390 */ … … 395 395 int PyObject_IsTrue(PyObject *o); 396 396 397 398 399 397 Returns 1 if the object, o, is considered to be true, 0 if o is 398 considered to be false and -1 on failure. This is equivalent to the 399 Python expression: not not o 400 400 401 401 */ … … 405 405 int PyObject_Not(PyObject *o); 406 406 407 408 409 407 Returns 0 if the object, o, is considered to be true, 1 if o is 408 considered to be false and -1 on failure. This is equivalent to the 409 Python expression: not o 410 410 411 411 */ … … 414 414 415 415 /* 416 417 418 416 On success, returns a type object corresponding to the object 417 type of object o. On failure, returns NULL. This is 418 equivalent to the Python expression: type(o). 419 419 */ 420 420 … … 422 422 423 423 /* 424 425 426 427 424 Return the size of object o. If the object, o, provides 425 both sequence and mapping protocols, the sequence size is 426 returned. On error, -1 is returned. This is the equivalent 427 to the Python expression: len(o). 428 428 429 429 */ … … 437 437 438 438 /* 439 440 441 439 Guess the size of object o using len(o) or o.__length_hint__(). 440 If neither of those return a non-negative value, then return the 441 default value. If one of the calls fails, this function returns -1. 442 442 */ 443 443 … … 445 445 446 446 /* 447 448 449 447 Return element of o corresponding to the object, key, or NULL 448 on failure. This is the equivalent of the Python expression: 449 o[key]. 450 450 451 451 */ … … 454 454 455 455 /* 456 457 458 456 Map the object, key, to the value, v. Returns 457 -1 on failure. This is the equivalent of the Python 458 statement: o[key]=v. 459 459 */ 460 460 … … 462 462 463 463 /* 464 465 466 464 Remove the mapping for object, key, from the object *o. 465 Returns -1 on failure. This is equivalent to 466 the Python statement: del o[key]. 467 467 */ 468 468 … … 470 470 471 471 /* 472 473 472 Delete the mapping for key from *o. Returns -1 on failure. 473 This is the equivalent of the Python statement: del o[key]. 474 474 */ 475 475 476 476 PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, 477 478 479 480 /* 481 482 483 484 485 486 487 488 477 const char **buffer, 478 Py_ssize_t *buffer_len); 479 480 /* 481 Takes an arbitrary object which must support the (character, 482 single segment) buffer interface and returns a pointer to a 483 read-only memory location useable as character based input 484 for subsequent processing. 485 486 0 is returned on success. buffer and buffer_len are only 487 set in case no error occurs. Otherwise, -1 is returned and 488 an exception set. 489 489 490 490 */ … … 492 492 PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj); 493 493 494 /* 495 496 497 494 /* 495 Checks whether an arbitrary object supports the (character, 496 single segment) buffer interface. Returns 1 on success, 0 497 on failure. 498 498 499 499 */ 500 500 501 501 PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, 502 503 504 505 /* 506 507 508 509 510 511 512 set in case no error occurrs. Otherwise, -1 is returned and513 502 const void **buffer, 503 Py_ssize_t *buffer_len); 504 505 /* 506 Same as PyObject_AsCharBuffer() except that this API expects 507 (readable, single segment) buffer interface and returns a 508 pointer to a read-only memory location which can contain 509 arbitrary data. 510 511 0 is returned on success. buffer and buffer_len are only 512 set in case no error occurs. Otherwise, -1 is returned and 513 an exception set. 514 514 515 515 */ 516 516 517 517 PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, 518 519 520 521 /* 522 523 524 525 526 527 set in case no error occurrs. Otherwise, -1 is returned and528 529 530 */ 531 532 518 void **buffer, 519 Py_ssize_t *buffer_len); 520 521 /* 522 Takes an arbitrary object which must support the (writeable, 523 single segment) buffer interface and returns a pointer to a 524 writeable memory location in buffer of size buffer_len. 525 526 0 is returned on success. buffer and buffer_len are only 527 set in case no error occurs. Otherwise, -1 is returned and 528 an exception set. 529 530 */ 531 532 /* new buffer API */ 533 533 534 534 #define PyObject_CheckBuffer(obj) \ 535 (((obj)->ob_type->tp_as_buffer != NULL) &&\536 537 538 539 /* Return 1 if the getbuffer function is available, otherwise 540 541 542 PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, 543 544 545 546 547 call. Returns -1 and raises an error on failure and returns 0 on 548 549 535 (((obj)->ob_type->tp_as_buffer != NULL) && \ 536 (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_NEWBUFFER)) && \ 537 ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL)) 538 539 /* Return 1 if the getbuffer function is available, otherwise 540 return 0 */ 541 542 PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, 543 int flags); 544 545 /* This is a C-API version of the getbuffer function call. It checks 546 to make sure object has the required function pointer and issues the 547 call. Returns -1 and raises an error on failure and returns 0 on 548 success 549 */ 550 550 551 551 552 552 PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices); 553 554 /* Get the memory area pointed to by the indices for the buffer given.555 Note that view->ndim is the assumed size of indices556 553 554 /* Get the memory area pointed to by the indices for the buffer given. 555 Note that view->ndim is the assumed size of indices 556 */ 557 557 558 558 PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *); 559 560 /* Return the implied itemsize of the data-format area from a 561 562 563 564 559 560 /* Return the implied itemsize of the data-format area from a 561 struct-style description */ 562 563 564 565 565 PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view, 566 567 568 PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 566 Py_ssize_t len, char fort); 567 568 PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, 569 Py_ssize_t len, char fort); 570 571 572 /* Copy len bytes of data from the contiguous chunk of memory 573 pointed to by buf into the buffer exported by obj. Return 574 0 on success and return -1 and raise a PyBuffer_Error on 575 error (i.e. the object does not have a buffer interface or 576 it is not working). 577 578 If fort is 'F' and the object is multi-dimensional, 579 then the data will be copied into the array in 580 Fortran-style (first dimension varies the fastest). If 581 fort is 'C', then the data will be copied into the array 582 in C-style (last dimension varies the fastest). If fort 583 is 'A', then it does not matter and the copy will be made 584 in whatever way is more efficient. 585 586 */ 587 587 588 588 PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); 589 590 591 589 590 /* Copy the data from the src buffer to the buffer of destination 591 */ 592 592 593 593 PyAPI_FUNC(int) PyBuffer_IsContiguous(Py_buffer *view, char fort); 594 594 595 595 596 PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, 597 Py_ssize_t *shape, 598 599 600 601 602 603 604 605 606 596 PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, 597 Py_ssize_t *shape, 598 Py_ssize_t *strides, 599 int itemsize, 600 char fort); 601 602 /* Fill the strides array with byte-strides of a contiguous 603 (Fortran-style if fort is 'F' or C-style otherwise) 604 array of the given shape with the given number of bytes 605 per element. 606 */ 607 607 608 608 PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, 609 610 611 612 613 614 615 616 609 Py_ssize_t len, int readonly, 610 int flags); 611 612 /* Fills in a buffer-info structure correctly for an exporter 613 that can only share a contiguous chunk of memory of 614 "unsigned bytes" of the given length. Returns 0 on success 615 and -1 (with raising an error) on error. 616 */ 617 617 618 618 PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); 619 619 620 620 /* Releases a Py_buffer obtained from getbuffer ParseTuple's s*. 621 621 */ 622 622 623 623 PyAPI_FUNC(PyObject *) PyObject_Format(PyObject* obj, 624 625 /* 626 627 624 PyObject *format_spec); 625 /* 626 Takes an arbitrary object and returns the result of 627 calling obj.__format__(format_spec). 628 628 */ 629 629 … … 632 632 PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *); 633 633 /* Takes an object and returns an iterator for it. 634 635 634 This is typically a new iterator but if the argument 635 is an iterator, this returns itself. */ 636 636 637 637 #define PyIter_Check(obj) \ 638 638 (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_ITER) && \ 639 (obj)->ob_type->tp_iternext != NULL) 639 (obj)->ob_type->tp_iternext != NULL && \ 640 (obj)->ob_type->tp_iternext != &_PyObject_NextNotImplemented) 640 641 641 642 PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *); 642 643 /* Takes an iterator object and calls its tp_iternext slot, 643 644 645 644 returning the next value. If the iterator is exhausted, 645 this returns NULL without setting an exception. 646 NULL with an exception means an error occurred. */ 646 647 647 648 /* Number Protocol:*/ … … 650 651 651 652 /* 652 653 false otherwise. 654 655 653 Returns 1 if the object, o, provides numeric protocols, and 654 false otherwise. 655 656 This function always succeeds. 656 657 657 658 */ … … 660 661 661 662 /* 662 663 663 Returns the result of adding o1 and o2, or null on failure. 664 This is the equivalent of the Python expression: o1+o2. 664 665 665 666 … … 669 670 670 671 /* 671 672 673 672 Returns the result of subtracting o2 from o1, or null on 673 failure. This is the equivalent of the Python expression: 674 o1-o2. 674 675 675 676 */ … … 678 679 679 680 /* 680 681 682 681 Returns the result of multiplying o1 and o2, or null on 682 failure. This is the equivalent of the Python expression: 683 o1*o2. 683 684 684 685 … … 688 689 689 690 /* 690 691 691 Returns the result of dividing o1 by o2, or null on failure. 692 This is the equivalent of the Python expression: o1/o2. 692 693 693 694 … … 697 698 698 699 /* 699 700 701 700 Returns the result of dividing o1 by o2 giving an integral result, 701 or null on failure. 702 This is the equivalent of the Python expression: o1//o2. 702 703 703 704 … … 707 708 708 709 /* 709 710 711 710 Returns the result of dividing o1 by o2 giving a float result, 711 or null on failure. 712 This is the equivalent of the Python expression: o1/o2. 712 713 713 714 … … 717 718 718 719 /* 719 720 721 720 Returns the remainder of dividing o1 by o2, or null on 721 failure. This is the equivalent of the Python expression: 722 o1%o2. 722 723 723 724 … … 727 728 728 729 /* 729 730 731 730 See the built-in function divmod. Returns NULL on failure. 731 This is the equivalent of the Python expression: 732 divmod(o1,o2). 732 733 733 734 … … 738 739 739 740 /* 740 741 742 741 See the built-in function pow. Returns NULL on failure. 742 This is the equivalent of the Python expression: 743 pow(o1,o2,o3), where o3 is optional. 743 744 744 745 */ … … 747 748 748 749 /* 749 750 750 Returns the negation of o on success, or null on failure. 751 This is the equivalent of the Python expression: -o. 751 752 752 753 */ … … 755 756 756 757 /* 757 758 758 Returns the (what?) of o on success, or NULL on failure. 759 This is the equivalent of the Python expression: +o. 759 760 760 761 */ … … 763 764 764 765 /* 765 766 766 Returns the absolute value of o, or null on failure. This is 767 the equivalent of the Python expression: abs(o). 767 768 768 769 */ … … 771 772 772 773 /* 773 774 775 774 Returns the bitwise negation of o on success, or NULL on 775 failure. This is the equivalent of the Python expression: 776 ~o. 776 777 777 778 … … 781 782 782 783 /* 783 784 785 784 Returns the result of left shifting o1 by o2 on success, or 785 NULL on failure. This is the equivalent of the Python 786 expression: o1 << o2. 786 787 787 788 … … 791 792 792 793 /* 793 794 795 794 Returns the result of right shifting o1 by o2 on success, or 795 NULL on failure. This is the equivalent of the Python 796 expression: o1 >> o2. 796 797 797 798 */ … … 800 801 801 802 /* 802 803 804 803 Returns the result of bitwise and of o1 and o2 on success, or 804 NULL on failure. This is the equivalent of the Python 805 expression: o1&o2. 805 806 806 807 … … 810 811 811 812 /* 812 813 814 813 Returns the bitwise exclusive or of o1 by o2 on success, or 814 NULL on failure. This is the equivalent of the Python 815 expression: o1^o2. 815 816 816 817 … … 820 821 821 822 /* 822 823 824 823 Returns the result of bitwise or on o1 and o2 on success, or 824 NULL on failure. This is the equivalent of the Python 825 expression: o1|o2. 825 826 826 827 */ … … 830 831 int PyNumber_Coerce(PyObject **p1, PyObject **p2); 831 832 832 833 834 835 836 837 838 839 840 841 842 843 833 This function takes the addresses of two variables of type 834 PyObject*. 835 836 If the objects pointed to by *p1 and *p2 have the same type, 837 increment their reference count and return 0 (success). 838 If the objects can be converted to a common numeric type, 839 replace *p1 and *p2 by their converted value (with 'new' 840 reference counts), and return 0. 841 If no conversion is possible, or if some other error occurs, 842 return -1 (failure) and don't increment the reference counts. 843 The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python 844 statement o1, o2 = coerce(o1, o2). 844 845 845 846 */ … … 849 850 PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_INDEX) && \ 850 851 (obj)->ob_type->tp_as_number->nb_index != NULL) 851 852 852 853 PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o); 853 854 854 855 /* 855 856 856 Returns the object converted to a Python long or int 857 or NULL with an error raised on failure. 857 858 */ 858 859 … … 860 861 861 862 /* 862 863 864 865 866 867 863 Returns the Integral instance converted to an int. The 864 instance is expected to be int or long or have an __int__ 865 method. Steals integral's reference. error_format will be 866 used to create the TypeError if integral isn't actually an 867 Integral instance. error_format should be a format string 868 that can accept a char* naming integral's type. 868 869 */ 869 870 870 871 PyAPI_FUNC(PyObject *) _PyNumber_ConvertIntegralToInt( 871 872 873 874 /* 875 876 877 878 879 is cleared and the value is clipped.872 PyObject *integral, 873 const char* error_format); 874 875 /* 876 Returns the object converted to Py_ssize_t by going through 877 PyNumber_Index first. If an overflow error occurs while 878 converting the int-or-long to Py_ssize_t, then the second argument 879 is the error-type to return. If it is NULL, then the overflow error 880 is cleared and the value is clipped. 880 881 */ 881 882 … … 883 884 884 885 /* 885 886 887 886 Returns the o converted to an integer object on success, or 887 NULL on failure. This is the equivalent of the Python 888 expression: int(o). 888 889 889 890 */ … … 892 893 893 894 /* 894 895 896 895 Returns the o converted to a long integer object on success, 896 or NULL on failure. This is the equivalent of the Python 897 expression: long(o). 897 898 898 899 */ … … 901 902 902 903 /* 903 904 905 906 */ 907 904 Returns the o converted to a float object on success, or NULL 905 on failure. This is the equivalent of the Python expression: 906 float(o). 907 */ 908 908 909 /* In-place variants of (some of) the above number protocol functions */ 909 910 … … 911 912 912 913 /* 913 914 915 914 Returns the result of adding o2 to o1, possibly in-place, or null 915 on failure. This is the equivalent of the Python expression: 916 o1 += o2. 916 917 917 918 */ … … 920 921 921 922 /* 922 923 924 923 Returns the result of subtracting o2 from o1, possibly in-place or 924 null on failure. This is the equivalent of the Python expression: 925 o1 -= o2. 925 926 926 927 */ … … 929 930 930 931 /* 931 932 933 932 Returns the result of multiplying o1 by o2, possibly in-place, or 933 null on failure. This is the equivalent of the Python expression: 934 o1 *= o2. 934 935 935 936 */ … … 938 939 939 940 /* 940 941 942 941 Returns the result of dividing o1 by o2, possibly in-place, or null 942 on failure. This is the equivalent of the Python expression: 943 o1 /= o2. 943 944 944 945 */ 945 946 946 947 PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1, 947 948 949 /* 950 951 952 953 948 PyObject *o2); 949 950 /* 951 Returns the result of dividing o1 by o2 giving an integral result, 952 possibly in-place, or null on failure. 953 This is the equivalent of the Python expression: 954 o1 /= o2. 954 955 955 956 */ 956 957 957 958 PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1, 958 959 960 /* 961 962 963 964 959 PyObject *o2); 960 961 /* 962 Returns the result of dividing o1 by o2 giving a float result, 963 possibly in-place, or null on failure. 964 This is the equivalent of the Python expression: 965 o1 /= o2. 965 966 966 967 */ … … 969 970 970 971 /* 971 972 973 972 Returns the remainder of dividing o1 by o2, possibly in-place, or 973 null on failure. This is the equivalent of the Python expression: 974 o1 %= o2. 974 975 975 976 */ 976 977 977 978 PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2, 978 979 980 /* 981 982 983 979 PyObject *o3); 980 981 /* 982 Returns the result of raising o1 to the power of o2, possibly 983 in-place, or null on failure. This is the equivalent of the Python 984 expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present. 984 985 985 986 */ … … 988 989 989 990 /* 990 991 992 991 Returns the result of left shifting o1 by o2, possibly in-place, or 992 null on failure. This is the equivalent of the Python expression: 993 o1 <<= o2. 993 994 994 995 */ … … 997 998 998 999 /* 999 1000 1001 1000 Returns the result of right shifting o1 by o2, possibly in-place or 1001 null on failure. This is the equivalent of the Python expression: 1002 o1 >>= o2. 1002 1003 1003 1004 */ … … 1006 1007 1007 1008 /* 1008 1009 1010 1009 Returns the result of bitwise and of o1 and o2, possibly in-place, 1010 or null on failure. This is the equivalent of the Python 1011 expression: o1 &= o2. 1011 1012 1012 1013 */ … … 1015 1016 1016 1017 /* 1017 1018 1019 1018 Returns the bitwise exclusive or of o1 by o2, possibly in-place, or 1019 null on failure. This is the equivalent of the Python expression: 1020 o1 ^= o2. 1020 1021 1021 1022 */ … … 1024 1025 1025 1026 /* 1026 1027 1028 1027 Returns the result of bitwise or of o1 and o2, possibly in-place, 1028 or null on failure. This is the equivalent of the Python 1029 expression: o1 |= o2. 1029 1030 1030 1031 */ … … 1034 1035 1035 1036 /* 1036 1037 1038 1037 Returns the integer n converted to a string with a base, with a base 1038 marker of 0b, 0o or 0x prefixed if applicable. 1039 If n is not an int object, it is converted with PyNumber_Index first. 1039 1040 */ 1040 1041 … … 1045 1046 1046 1047 /* 1047 1048 otherwise. 1049 1050 1048 Return 1 if the object provides sequence protocol, and zero 1049 otherwise. 1050 1051 This function always succeeds. 1051 1052 1052 1053 */ … … 1055 1056 1056 1057 /* 1057 1058 Return the size of sequence object o, or -1 on failure. 1058 1059 1059 1060 */ … … 1068 1069 1069 1070 /* 1070 1071 1072 1071 Return the concatenation of o1 and o2 on success, and NULL on 1072 failure. This is the equivalent of the Python 1073 expression: o1+o2. 1073 1074 1074 1075 */ … … 1077 1078 1078 1079 /* 1079 1080 1081 1080 Return the result of repeating sequence object o count times, 1081 or NULL on failure. This is the equivalent of the Python 1082 expression: o1*count. 1082 1083 1083 1084 */ … … 1086 1087 1087 1088 /* 1088 1089 1089 Return the ith element of o, or NULL on failure. This is the 1090 equivalent of the Python expression: o[i]. 1090 1091 */ 1091 1092 … … 1093 1094 1094 1095 /* 1095 1096 1097 1096 Return the slice of sequence object o between i1 and i2, or 1097 NULL on failure. This is the equivalent of the Python 1098 expression: o[i1:i2]. 1098 1099 1099 1100 */ … … 1102 1103 1103 1104 /* 1104 1105 1106 1105 Assign object v to the ith element of o. Returns 1106 -1 on failure. This is the equivalent of the Python 1107 statement: o[i]=v. 1107 1108 1108 1109 */ … … 1111 1112 1112 1113 /* 1113 1114 1115 1114 Delete the ith element of object v. Returns 1115 -1 on failure. This is the equivalent of the Python 1116 statement: del o[i]. 1116 1117 */ 1117 1118 … … 1120 1121 1121 1122 /* 1122 1123 1124 1123 Assign the sequence object, v, to the slice in sequence 1124 object, o, from i1 to i2. Returns -1 on failure. This is the 1125 equivalent of the Python statement: o[i1:i2]=v. 1125 1126 */ 1126 1127 … … 1128 1129 1129 1130 /* 1130 1131 1132 1131 Delete the slice in sequence object, o, from i1 to i2. 1132 Returns -1 on failure. This is the equivalent of the Python 1133 statement: del o[i1:i2]. 1133 1134 */ 1134 1135 … … 1136 1137 1137 1138 /* 1138 1139 1139 Returns the sequence, o, as a tuple on success, and NULL on failure. 1140 This is equivalent to the Python expression: tuple(o) 1140 1141 */ 1141 1142 … … 1143 1144 PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o); 1144 1145 /* 1145 1146 1146 Returns the sequence, o, as a list on success, and NULL on failure. 1147 This is equivalent to the Python expression: list(o) 1147 1148 */ 1148 1149 1149 1150 PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m); 1150 1151 /* 1151 1152 1153 1154 1155 1156 1152 Returns the sequence, o, as a tuple, unless it's already a 1153 tuple or list. Use PySequence_Fast_GET_ITEM to access the 1154 members of this list, and PySequence_Fast_GET_SIZE to get its length. 1155 1156 Returns NULL on failure. If the object does not support iteration, 1157 raises a TypeError exception with m as the message text. 1157 1158 */ 1158 1159 1159 1160 #define PySequence_Fast_GET_SIZE(o) \ 1160 1161 /* 1162 1163 1161 (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o)) 1162 /* 1163 Return the size of o, assuming that o was returned by 1164 PySequence_Fast and is not NULL. 1164 1165 */ 1165 1166 … … 1167 1168 (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i)) 1168 1169 /* 1169 1170 1170 Return the ith element of o, assuming that o was returned by 1171 PySequence_Fast, and that i is within bounds. 1171 1172 */ 1172 1173 1173 1174 #define PySequence_ITEM(o, i)\ 1174 1175 ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) ) 1175 1176 /* Assume tp_as_sequence and sq_item exist and that i does not 1176 1177 */ 1177 need to be corrected for a negative index 1178 */ 1178 1179 1179 1180 #define PySequence_Fast_ITEMS(sf) \ 1180 1181 1182 1183 1181 (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \ 1182 : ((PyTupleObject *)(sf))->ob_item) 1183 /* Return a pointer to the underlying item array for 1184 an object retured by PySequence_Fast */ 1184 1185 1185 1186 PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value); 1186 1187 1187 1188 /* 1188 1189 1190 1191 1189 Return the number of occurrences on value on o, that is, 1190 return the number of keys for which o[key]==value. On 1191 failure, return -1. This is equivalent to the Python 1192 expression: o.count(value). 1192 1193 */ 1193 1194 1194 1195 PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob); 1195 1196 /* 1196 1197 1197 Return -1 if error; 1 if ob in seq; 0 if ob not in seq. 1198 Use __contains__ if possible, else _PySequence_IterSearch(). 1198 1199 */ 1199 1200 … … 1202 1203 #define PY_ITERSEARCH_CONTAINS 3 1203 1204 PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq, 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1205 PyObject *obj, int operation); 1206 /* 1207 Iterate over seq. Result depends on the operation: 1208 PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if 1209 error. 1210 PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of 1211 obj in seq; set ValueError and return -1 if none found; 1212 also return -1 on error. 1213 PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on 1214 error. 1215 */ 1215 1216 1216 1217 /* For DLL-level backwards compatibility */ … … 1222 1223 1223 1224 /* 1224 1225 1226 1225 Determine if o contains value. If an item in o is equal to 1226 X, return 1, otherwise return 0. On error, return -1. This 1227 is equivalent to the Python expression: value in o. 1227 1228 */ 1228 1229 … … 1230 1231 1231 1232 /* 1232 1233 1234 1233 Return the first index for which o[i]=value. On error, 1234 return -1. This is equivalent to the Python 1235 expression: o.index(value). 1235 1236 */ 1236 1237 … … 1240 1241 1241 1242 /* 1242 1243 1244 1243 Append o2 to o1, in-place when possible. Return the resulting 1244 object, which could be o1, or NULL on failure. This is the 1245 equivalent of the Python expression: o1 += o2. 1245 1246 1246 1247 */ … … 1249 1250 1250 1251 /* 1251 1252 1253 1252 Repeat o1 by count, in-place when possible. Return the resulting 1253 object, which could be o1, or NULL on failure. This is the 1254 equivalent of the Python expression: o1 *= count. 1254 1255 1255 1256 */ … … 1260 1261 1261 1262 /* 1262 1263 otherwise. 1264 1265 1263 Return 1 if the object provides mapping protocol, and zero 1264 otherwise. 1265 1266 This function always succeeds. 1266 1267 */ 1267 1268 … … 1269 1270 1270 1271 /* 1271 1272 1273 1272 Returns the number of keys in object o on success, and -1 on 1273 failure. For objects that do not provide sequence protocol, 1274 this is equivalent to the Python expression: len(o). 1274 1275 */ 1275 1276 … … 1284 1285 int PyMapping_DelItemString(PyObject *o, char *key); 1285 1286 1286 1287 1288 1287 Remove the mapping for object, key, from the object *o. 1288 Returns -1 on failure. This is equivalent to 1289 the Python statement: del o[key]. 1289 1290 */ 1290 1291 #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K)) … … 1294 1295 int PyMapping_DelItem(PyObject *o, PyObject *key); 1295 1296 1296 1297 1298 1297 Remove the mapping for object, key, from the object *o. 1298 Returns -1 on failure. This is equivalent to 1299 the Python statement: del o[key]. 1299 1300 */ 1300 1301 #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K)) … … 1303 1304 1304 1305 /* 1305 1306 1307 o.has_key(key). 1308 1309 1306 On success, return 1 if the mapping object has the key, key, 1307 and 0 otherwise. This is equivalent to the Python expression: 1308 o.has_key(key). 1309 1310 This function always succeeds. 1310 1311 */ 1311 1312 … … 1313 1314 1314 1315 /* 1315 1316 1317 o.has_key(key). 1318 1319 1316 Return 1 if the mapping object has the key, key, 1317 and 0 otherwise. This is equivalent to the Python expression: 1318 o.has_key(key). 1319 1320 This function always succeeds. 1320 1321 1321 1322 */ … … 1325 1326 PyObject *PyMapping_Keys(PyObject *o); 1326 1327 1327 1328 1329 1328 On success, return a list of the keys in object o. On 1329 failure, return NULL. This is equivalent to the Python 1330 expression: o.keys(). 1330 1331 */ 1331 1332 #define PyMapping_Keys(O) PyObject_CallMethod(O,"keys",NULL) … … 1335 1336 PyObject *PyMapping_Values(PyObject *o); 1336 1337 1337 1338 1339 1338 On success, return a list of the values in object o. On 1339 failure, return NULL. This is equivalent to the Python 1340 expression: o.values(). 1340 1341 */ 1341 1342 #define PyMapping_Values(O) PyObject_CallMethod(O,"values",NULL) … … 1345 1346 PyObject *PyMapping_Items(PyObject *o); 1346 1347 1347 1348 1349 1350 1348 On success, return a list of the items in object o, where 1349 each item is a tuple containing a key-value pair. On 1350 failure, return NULL. This is equivalent to the Python 1351 expression: o.items(). 1351 1352 1352 1353 */ … … 1356 1357 1357 1358 /* 1358 1359 1360 1359 Return element of o corresponding to the object, key, or NULL 1360 on failure. This is the equivalent of the Python expression: 1361 o[key]. 1361 1362 */ 1362 1363 … … 1365 1366 1366 1367 /* 1367 Map the object, key, to the value, v. Returns 1368 1369 1368 Map the object, key, to the value, v. Returns 1369 -1 on failure. This is the equivalent of the Python 1370 statement: o[key]=v. 1370 1371 */ 1371 1372 … … 1381 1382 1382 1383 PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); 1384 1385 1386 /* For internal use by buffer API functions */ 1387 PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index, 1388 const Py_ssize_t *shape); 1389 PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index, 1390 const Py_ssize_t *shape); 1383 1391 1384 1392
Note:
See TracChangeset
for help on using the changeset viewer.
