Include/abstract.h

   1 #ifndef Py_ABSTRACTOBJECT_H
   2 #define Py_ABSTRACTOBJECT_H
   3 #ifdef __cplusplus
   4 extern "C" {
   5 #endif
   6
   7 #ifdef PY_SSIZE_T_CLEAN
   8 #define PyObject_CallFunction _PyObject_CallFunction_SizeT
   9 #define PyObject_CallMethod _PyObject_CallMethod_SizeT
  10 #endif
  11
  12 /* Abstract Object Interface (many thanks to Jim Fulton) */
  13
  14 /*
  15    PROPOSAL: A Generic Python Object Interface for Python C Modules
  16
  17 Problem
  18
  19   Python modules written in C that must access Python objects must do
  20   so through routines whose interfaces are described by a set of
  21   include files.  Unfortunately, these routines vary according to the
  22   object accessed.  To use these routines, the C programmer must check
  23   the type of the object being used and must call a routine based on
  24   the object type.  For example, to access an element of a sequence,
  25   the programmer must determine whether the sequence is a list or a
  26   tuple:
  27
  28     if(is_tupleobject(o))
  29       e=gettupleitem(o,i)
  30     else if(is_listitem(o))
  31       e=getlistitem(o,i)
  32
  33   If the programmer wants to get an item from another type of object
  34   that provides sequence behavior, there is no clear way to do it
  35   correctly.
  36
  37   The persistent programmer may peruse object.h and find that the
  38   _typeobject structure provides a means of invoking up to (currently
  39   about) 41 special operators.  So, for example, a routine can get an
  40   item from any object that provides sequence behavior. However, to
  41   use this mechanism, the programmer must make their code dependent on
  42   the current Python implementation.
  43
  44   Also, certain semantics, especially memory management semantics, may
  45   differ by the type of object being used.  Unfortunately, these
  46   semantics are not clearly described in the current include files.
  47   An abstract interface providing more consistent semantics is needed.
  48
  49 Proposal
  50
  51   I propose the creation of a standard interface (with an associated
  52   library of routines and/or macros) for generically obtaining the
  53   services of Python objects.  This proposal can be viewed as one
  54   components of a Python C interface consisting of several components.
  55
  56   From the viewpoint of C access to Python services, we have (as
  57   suggested by Guido in off-line discussions):
  58
  59   - "Very high level layer": two or three functions that let you exec or
  60     eval arbitrary Python code given as a string in a module whose name is
  61     given, passing C values in and getting C values out using
  62     mkvalue/getargs style format strings.  This does not require the user
  63     to declare any variables of type "PyObject *".  This should be enough
  64     to write a simple application that gets Python code from the user,
  65     execs it, and returns the output or errors.  (Error handling must also
  66     be part of this API.)
  67
  68   - "Abstract objects layer": which is the subject of this proposal.
  69     It has many functions operating on objects, and lest you do many
  70     things from C that you can also write in Python, without going
  71     through the Python parser.
  72
  73   - "Concrete objects layer": This is the public type-dependent
  74     interface provided by the standard built-in types, such as floats,
  75     strings, and lists.  This interface exists and is currently
  76     documented by the collection of include files provided with the
  77     Python distributions.
  78
  79   From the point of view of Python accessing services provided by C
  80   modules:
  81
  82   - "Python module interface": this interface consist of the basic
  83     routines used to define modules and their members.  Most of the
  84     current extensions-writing guide deals with this interface.
  85
  86   - "Built-in object interface": this is the interface that a new
  87     built-in type must provide and the mechanisms and rules that a
  88     developer of a new built-in type must use and follow.
  89
  90   This proposal is a "first-cut" that is intended to spur
  91   discussion. See especially the lists of notes.
  92
  93   The Python C object interface will provide four protocols: object,
  94   numeric, sequence, and mapping.  Each protocol consists of a
  95   collection of related operations.  If an operation that is not
  96   provided by a particular type is invoked, then a standard exception,
  97   NotImplementedError is raised with a operation name as an argument.
  98   In addition, for convenience this interface defines a set of
  99   constructors for building objects of built-in types.  This is needed
 100   so new objects can be returned from C functions that otherwise treat
 101   objects generically.
 102
 103 Memory Management
 104
 105   For all of the functions described in this proposal, if a function
 106   retains a reference to a Python object passed as an argument, then the
 107   function will increase the reference count of the object.  It is
 108   unnecessary for the caller to increase the reference count of an
 109   argument in anticipation of the object's retention.
 110
 111   All Python objects returned from functions should be treated as new
 112   objects.  Functions that return objects assume that the caller will
 113   retain a reference and the reference count of the object has already
 114   been incremented to account for this fact.  A caller that does not
 115   retain a reference to an object that is returned from a function
 116   must decrement the reference count of the object (using
 117   DECREF(object)) to prevent memory leaks.
 118
 119   Note that the behavior mentioned here is different from the current
 120   behavior for some objects (e.g. lists and tuples) when certain
 121   type-specific routines are called directly (e.g. setlistitem).  The
 122   proposed abstraction layer will provide a consistent memory
 123   management interface, correcting for inconsistent behavior for some
 124   built-in types.
 125
 126 Protocols
 127
 128 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 129
 130 /*  Object Protocol: */
 131
 132      /* Implemented elsewhere:
 133
 134      int PyObject_Print(PyObject *o, FILE *fp, int flags);
 135
 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
 142        */
 143
 144      /* Implemented elsewhere:
 145
 146      int PyObject_HasAttrString(PyObject *o, char *attr_name);
 147
 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
 154        */
 155
 156      /* Implemented elsewhere:
 157
 158      PyObject* PyObject_GetAttrString(PyObject *o, char *attr_name);
 159
 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
 164        */
 165
 166      /* Implemented elsewhere:
 167
 168      int PyObject_HasAttr(PyObject *o, PyObject *attr_name);
 169
 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
 176        */
 177
 178      /* Implemented elsewhere:
 179
 180      PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
 181
 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
 186        */
 187
 188
 189      /* Implemented elsewhere:
 190
 191      int PyObject_SetAttrString(PyObject *o, char *attr_name, PyObject *v);
 192
 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
 197        */
 198
 199      /* Implemented elsewhere:
 200
 201      int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v);
 202
 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
 207        */
 208
 209      /* implemented as a macro:
 210
 211      int PyObject_DelAttrString(PyObject *o, char *attr_name);
 212
 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
 217        */
 218 #define  PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A),NULL)
 219
 220      /* implemented as a macro:
 221
 222      int PyObject_DelAttr(PyObject *o, PyObject *attr_name);
 223
 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
 228        */
 229 #define  PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL)
 230
 231      PyAPI_FUNC(int) PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);
 232
 233        /*
 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
 240        */
 241
 242      /* Implemented elsewhere:
 243
 244      int PyObject_Compare(PyObject *o1, PyObject *o2);
 245
 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
 252        */
 253
 254      /* Implemented elsewhere:
 255
 256      PyObject *PyObject_Repr(PyObject *o);
 257
 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
 264        */
 265
 266      /* Implemented elsewhere:
 267
 268      PyObject *PyObject_Str(PyObject *o);
 269
 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
 277        */
 278
 279      /* Implemented elsewhere:
 280
 281      PyObject *PyObject_Unicode(PyObject *o);
 282
 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
 289        */
 290
 291        /* Declared elsewhere
 292
 293      PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
 294
 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
 300        */
 301
 302
 303
 304      PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object,
 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      PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object,
 315                                                PyObject *args);
 316
 317        /*
 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
 324        */
 325
 326      PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable_object,
 327                                                  char *format, ...);
 328
 329        /*
 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
 337        */
 338
 339
 340      PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *o, char *m,
 341                                                char *format, ...);
 342
 343        /*
 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        */
 351
 352      PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
 353                                                          char *format, ...);
 354      PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o,
 355                                                        char *name,
 356                                                        char *format, ...);
 357
 358      PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
 359                                                         ...);
 360
 361        /*
 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        */
 368
 369
 370      PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *o,
 371                                                       PyObject *m, ...);
 372
 373        /*
 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        */
 380
 381
 382      /* Implemented elsewhere:
 383
 384      long PyObject_Hash(PyObject *o);
 385
 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
 390        */
 391
 392
 393      /* Implemented elsewhere:
 394
 395      int PyObject_IsTrue(PyObject *o);
 396
 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
 401        */
 402
 403      /* Implemented elsewhere:
 404
 405      int PyObject_Not(PyObject *o);
 406
 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
 411        */
 412
 413      PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o);
 414
 415        /*
 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        */
 420
 421      PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
 422
 423        /*
 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
 429        */
 430
 431        /* For DLL compatibility */
 432 #undef PyObject_Length
 433      PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o);
 434 #define PyObject_Length PyObject_Size
 435
 436      PyAPI_FUNC(Py_ssize_t) _PyObject_LengthHint(PyObject *o, Py_ssize_t);
 437
 438        /*
 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.  This function never fails. All exceptions are cleared.
 442        */
 443
 444      PyAPI_FUNC(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key);
 445
 446        /*
 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
 451        */
 452
 453      PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
 454
 455        /*
 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        */
 460
 461      PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, char *key);
 462
 463        /*
 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        */
 468
 469      PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key);
 470
 471        /*
 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        */
 475
 476      PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
 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
 490        */
 491
 492      PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj);
 493
 494       /*
 495           Checks whether an arbitrary object supports the (character,
 496           single segment) buffer interface.  Returns 1 on success, 0
 497           on failure.
 498
 499       */
 500
 501      PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
 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 occurrs.  Otherwise, -1 is returned and
 513           an exception set.
 514
 515        */
 516
 517      PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
 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 occurrs. Otherwise, -1 is returned and
 528           an exception set.
 529
 530        */
 531
 532         /* new buffer API */
 533
 534 #define PyObject_CheckBuffer(obj) \
 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
 551
 552      PyAPI_FUNC(void) PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view);
 553
 554
 555         /* C-API version of the releasebuffer function call.  It
 556            checks to make sure the object has the required function
 557            pointer and issues the call.  The obj must have the buffer
 558            interface or this function will cause a segfault (i.e. it
 559            is assumed to be called only after a corresponding
 560            getbuffer which already verified the existence of the
 561            tp_as_buffer pointer).
 562
 563            Returns 0 on success and -1 (with an error raised) on
 564            failure.  This function always succeeds (as a NO-OP) if
 565            there is no releasebuffer function for the object so that
 566            it can always be called when the consumer is done with the
 567            buffer
 568         */
 569
 570      PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
 571
 572         /* Get the memory area pointed to by the indices for the buffer given.
 573            Note that view->ndim is the assumed size of indices
 574         */
 575
 576      PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *);
 577
 578         /* Return the implied itemsize of the data-format area from a
 579            struct-style description */
 580
 581
 582
 583      PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
 584                                            Py_ssize_t len, char fort);
 585
 586      PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
 587                                              Py_ssize_t len, char fort);
 588
 589
 590         /* Copy len bytes of data from the contiguous chunk of memory
 591            pointed to by buf into the buffer exported by obj.  Return
 592            0 on success and return -1 and raise a PyBuffer_Error on
 593            error (i.e. the object does not have a buffer interface or
 594            it is not working).
 595
 596            If fort is 'F' and the object is multi-dimensional,
 597            then the data will be copied into the array in
 598            Fortran-style (first dimension varies the fastest).  If
 599            fort is 'C', then the data will be copied into the array
 600            in C-style (last dimension varies the fastest).  If fort
 601            is 'A', then it does not matter and the copy will be made
 602            in whatever way is more efficient.
 603
 604         */
 605
 606      PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
 607
 608         /* Copy the data from the src buffer to the buffer of destination
 609          */
 610
 611      PyAPI_FUNC(int) PyBuffer_IsContiguous(Py_buffer *view, char fort);
 612
 613
 614      PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
 615                                                     Py_ssize_t *shape,
 616                                                     Py_ssize_t *strides,
 617                                                     int itemsize,
 618                                                     char fort);
 619
 620         /*  Fill the strides array with byte-strides of a contiguous
 621             (Fortran-style if fort is 'F' or C-style otherwise)
 622             array of the given shape with the given number of bytes
 623             per element.
 624         */
 625
 626      PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, void *buf,
 627                                        Py_ssize_t len, int readonly,
 628                                        int flags);
 629
 630         /* Fills in a buffer-info structure correctly for an exporter
 631            that can only share a contiguous chunk of memory of
 632            "unsigned bytes" of the given length. Returns 0 on success
 633            and -1 (with raising an error) on error.
 634          */
 635
 636      PyAPI_FUNC(PyObject *) PyObject_Format(PyObject* obj,
 637                                             PyObject *format_spec);
 638        /*
 639          Takes an arbitrary object and returns the result of
 640          calling obj.__format__(format_spec).
 641        */
 642
 643 /* Iterators */
 644
 645      PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *);
 646      /* Takes an object and returns an iterator for it.
 647         This is typically a new iterator but if the argument
 648         is an iterator, this returns itself. */
 649
 650 #define PyIter_Check(obj) \
 651     (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_ITER) && \
 652      (obj)->ob_type->tp_iternext != NULL)
 653
 654      PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *);
 655      /* Takes an iterator object and calls its tp_iternext slot,
 656         returning the next value.  If the iterator is exhausted,
 657         this returns NULL without setting an exception.
 658         NULL with an exception means an error occurred. */
 659
 660 /*  Number Protocol:*/
 661
 662      PyAPI_FUNC(int) PyNumber_Check(PyObject *o);
 663
 664        /*
 665          Returns 1 if the object, o, provides numeric protocols, and
 666          false otherwise.
 667
 668          This function always succeeds.
 669
 670        */
 671
 672      PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2);
 673
 674        /*
 675          Returns the result of adding o1 and o2, or null on failure.
 676          This is the equivalent of the Python expression: o1+o2.
 677
 678
 679        */
 680
 681      PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2);
 682
 683        /*
 684          Returns the result of subtracting o2 from o1, or null on
 685          failure.  This is the equivalent of the Python expression:
 686          o1-o2.
 687
 688        */
 689
 690      PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2);
 691
 692        /*
 693          Returns the result of multiplying o1 and o2, or null on
 694          failure.  This is the equivalent of the Python expression:
 695          o1*o2.
 696
 697
 698        */
 699
 700      PyAPI_FUNC(PyObject *) PyNumber_Divide(PyObject *o1, PyObject *o2);
 701
 702        /*
 703          Returns the result of dividing o1 by o2, or null on failure.
 704          This is the equivalent of the Python expression: o1/o2.
 705
 706
 707        */
 708
 709      PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
 710
 711        /*
 712          Returns the result of dividing o1 by o2 giving an integral result,
 713          or null on failure.
 714          This is the equivalent of the Python expression: o1//o2.
 715
 716
 717        */
 718
 719      PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
 720
 721        /*
 722          Returns the result of dividing o1 by o2 giving a float result,
 723          or null on failure.
 724          This is the equivalent of the Python expression: o1/o2.
 725
 726
 727        */
 728
 729      PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2);
 730
 731        /*
 732          Returns the remainder of dividing o1 by o2, or null on
 733          failure.  This is the equivalent of the Python expression:
 734          o1%o2.
 735
 736
 737        */
 738
 739      PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2);
 740
 741        /*
 742          See the built-in function divmod.  Returns NULL on failure.
 743          This is the equivalent of the Python expression:
 744          divmod(o1,o2).
 745
 746
 747        */
 748
 749      PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2,
 750                                           PyObject *o3);
 751
 752        /*
 753          See the built-in function pow.  Returns NULL on failure.
 754          This is the equivalent of the Python expression:
 755          pow(o1,o2,o3), where o3 is optional.
 756
 757        */
 758
 759      PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o);
 760
 761        /*
 762          Returns the negation of o on success, or null on failure.
 763          This is the equivalent of the Python expression: -o.
 764
 765        */
 766
 767      PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o);
 768
 769        /*
 770          Returns the (what?) of o on success, or NULL on failure.
 771          This is the equivalent of the Python expression: +o.
 772
 773        */
 774
 775      PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o);
 776
 777        /*
 778          Returns the absolute value of o, or null on failure.  This is
 779          the equivalent of the Python expression: abs(o).
 780
 781        */
 782
 783      PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o);
 784
 785        /*
 786          Returns the bitwise negation of o on success, or NULL on
 787          failure.  This is the equivalent of the Python expression:
 788          ~o.
 789
 790
 791        */
 792
 793      PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2);
 794
 795        /*
 796          Returns the result of left shifting o1 by o2 on success, or
 797          NULL on failure.  This is the equivalent of the Python
 798          expression: o1 << o2.
 799
 800
 801        */
 802
 803      PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2);
 804
 805        /*
 806          Returns the result of right shifting o1 by o2 on success, or
 807          NULL on failure.  This is the equivalent of the Python
 808          expression: o1 >> o2.
 809
 810        */
 811
 812      PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2);
 813
 814        /*
 815          Returns the result of bitwise and of o1 and o2 on success, or
 816          NULL on failure. This is the equivalent of the Python
 817          expression: o1&o2.
 818
 819
 820        */
 821
 822      PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2);
 823
 824        /*
 825          Returns the bitwise exclusive or of o1 by o2 on success, or
 826          NULL on failure.  This is the equivalent of the Python
 827          expression: o1^o2.
 828
 829
 830        */
 831
 832      PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2);
 833
 834        /*
 835          Returns the result of bitwise or on o1 and o2 on success, or
 836          NULL on failure.  This is the equivalent of the Python
 837          expression: o1|o2.
 838
 839        */
 840
 841      /* Implemented elsewhere:
 842
 843      int PyNumber_Coerce(PyObject **p1, PyObject **p2);
 844
 845          This function takes the addresses of two variables of type
 846          PyObject*.
 847
 848          If the objects pointed to by *p1 and *p2 have the same type,
 849          increment their reference count and return 0 (success).
 850          If the objects can be converted to a common numeric type,
 851          replace *p1 and *p2 by their converted value (with 'new'
 852          reference counts), and return 0.
 853          If no conversion is possible, or if some other error occurs,
 854          return -1 (failure) and don't increment the reference counts.
 855          The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python
 856          statement o1, o2 = coerce(o1, o2).
 857
 858        */
 859
 860 #define PyIndex_Check(obj) \
 861    ((obj)->ob_type->tp_as_number != NULL && \
 862     PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_INDEX) && \
 863     (obj)->ob_type->tp_as_number->nb_index != NULL)
 864
 865      PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
 866
 867        /*
 868          Returns the object converted to a Python long or int
 869          or NULL with an error raised on failure.
 870        */
 871
 872      PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
 873
 874        /*
 875          Returns the Integral instance converted to an int. The
 876          instance is expected to be int or long or have an __int__
 877          method. Steals integral's reference. error_format will be
 878          used to create the TypeError if integral isn't actually an
 879          Integral instance. error_format should be a format string
 880          that can accept a char* naming integral's type.
 881        */
 882
 883      PyAPI_FUNC(PyObject *) _PyNumber_ConvertIntegralToInt(
 884              PyObject *integral,
 885              const char* error_format);
 886
 887        /*
 888         Returns the object converted to Py_ssize_t by going through
 889         PyNumber_Index first.  If an overflow error occurs while
 890         converting the int-or-long to Py_ssize_t, then the second argument
 891         is the error-type to return.  If it is NULL, then the overflow error
 892         is cleared and the value is clipped.
 893        */
 894
 895      PyAPI_FUNC(PyObject *) PyNumber_Int(PyObject *o);
 896
 897        /*
 898          Returns the o converted to an integer object on success, or
 899          NULL on failure.  This is the equivalent of the Python
 900          expression: int(o).
 901
 902        */
 903
 904      PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o);
 905
 906        /*
 907          Returns the o converted to a long integer object on success,
 908          or NULL on failure.  This is the equivalent of the Python
 909          expression: long(o).
 910
 911        */
 912
 913      PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o);
 914
 915        /*
 916          Returns the o converted to a float object on success, or NULL
 917          on failure.  This is the equivalent of the Python expression:
 918          float(o).
 919        */
 920
 921 /*  In-place variants of (some of) the above number protocol functions */
 922
 923      PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
 924
 925        /*
 926          Returns the result of adding o2 to o1, possibly in-place, or null
 927          on failure.  This is the equivalent of the Python expression:
 928          o1 += o2.
 929
 930        */
 931
 932      PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
 933
 934        /*
 935          Returns the result of subtracting o2 from o1, possibly in-place or
 936          null on failure.  This is the equivalent of the Python expression:
 937          o1 -= o2.
 938
 939        */
 940
 941      PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
 942
 943        /*
 944          Returns the result of multiplying o1 by o2, possibly in-place, or
 945          null on failure.  This is the equivalent of the Python expression:
 946          o1 *= o2.
 947
 948        */
 949
 950      PyAPI_FUNC(PyObject *) PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2);
 951
 952        /*
 953          Returns the result of dividing o1 by o2, possibly in-place, or null
 954          on failure.  This is the equivalent of the Python expression:
 955          o1 /= o2.
 956
 957        */
 958
 959      PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
 960                                                        PyObject *o2);
 961
 962        /*
 963          Returns the result of dividing o1 by o2 giving an integral result,
 964          possibly in-place, or null on failure.
 965          This is the equivalent of the Python expression:
 966          o1 /= o2.
 967
 968        */
 969
 970      PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1,
 971                                                       PyObject *o2);
 972
 973        /*
 974          Returns the result of dividing o1 by o2 giving a float result,
 975          possibly in-place, or null on failure.
 976          This is the equivalent of the Python expression:
 977          o1 /= o2.
 978
 979        */
 980
 981      PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
 982
 983        /*
 984          Returns the remainder of dividing o1 by o2, possibly in-place, or
 985          null on failure.  This is the equivalent of the Python expression:
 986          o1 %= o2.
 987
 988        */
 989
 990      PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
 991                                                  PyObject *o3);
 992
 993        /*
 994          Returns the result of raising o1 to the power of o2, possibly
 995          in-place, or null on failure.  This is the equivalent of the Python
 996          expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
 997
 998        */
 999
1000      PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
1001
1002        /*
1003          Returns the result of left shifting o1 by o2, possibly in-place, or
1004          null on failure.  This is the equivalent of the Python expression:
1005          o1 <<= o2.
1006
1007        */
1008
1009      PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
1010
1011        /*
1012          Returns the result of right shifting o1 by o2, possibly in-place or
1013          null on failure.  This is the equivalent of the Python expression:
1014          o1 >>= o2.
1015
1016        */
1017
1018      PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
1019
1020        /*
1021          Returns the result of bitwise and of o1 and o2, possibly in-place,
1022          or null on failure. This is the equivalent of the Python
1023          expression: o1 &= o2.
1024
1025        */
1026
1027      PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
1028
1029        /*
1030          Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
1031          null on failure.  This is the equivalent of the Python expression:
1032          o1 ^= o2.
1033
1034        */
1035
1036      PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
1037
1038        /*
1039          Returns the result of bitwise or of o1 and o2, possibly in-place,
1040          or null on failure.  This is the equivalent of the Python
1041          expression: o1 |= o2.
1042
1043        */
1044
1045
1046      PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base);
1047
1048        /*
1049          Returns the integer n converted to a string with a base, with a base
1050          marker of 0b, 0o or 0x prefixed if applicable.
1051          If n is not an int object, it is converted with PyNumber_Index first.
1052        */
1053
1054
1055 /*  Sequence protocol:*/
1056
1057      PyAPI_FUNC(int) PySequence_Check(PyObject *o);
1058
1059        /*
1060          Return 1 if the object provides sequence protocol, and zero
1061          otherwise.
1062
1063          This function always succeeds.
1064
1065        */
1066
1067      PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
1068
1069        /*
1070          Return the size of sequence object o, or -1 on failure.
1071
1072        */
1073
1074        /* For DLL compatibility */
1075 #undef PySequence_Length
1076      PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o);
1077 #define PySequence_Length PySequence_Size
1078
1079
1080      PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2);
1081
1082        /*
1083          Return the concatenation of o1 and o2 on success, and NULL on
1084          failure.   This is the equivalent of the Python
1085          expression: o1+o2.
1086
1087        */
1088
1089      PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count);
1090
1091        /*
1092          Return the result of repeating sequence object o count times,
1093          or NULL on failure.  This is the equivalent of the Python
1094          expression: o1*count.
1095
1096        */
1097
1098      PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i);
1099
1100        /*
1101          Return the ith element of o, or NULL on failure. This is the
1102          equivalent of the Python expression: o[i].
1103        */
1104
1105      PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
1106
1107        /*
1108          Return the slice of sequence object o between i1 and i2, or
1109          NULL on failure. This is the equivalent of the Python
1110          expression: o[i1:i2].
1111
1112        */
1113
1114      PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
1115
1116        /*
1117          Assign object v to the ith element of o.  Returns
1118          -1 on failure.  This is the equivalent of the Python
1119          statement: o[i]=v.
1120
1121        */
1122
1123      PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
1124
1125        /*
1126          Delete the ith element of object v.  Returns
1127          -1 on failure.  This is the equivalent of the Python
1128          statement: del o[i].
1129        */
1130
1131      PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
1132                                         PyObject *v);
1133
1134        /*
1135          Assign the sequence object, v, to the slice in sequence
1136          object, o, from i1 to i2.  Returns -1 on failure. This is the
1137          equivalent of the Python statement: o[i1:i2]=v.
1138        */
1139
1140      PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
1141
1142        /*
1143          Delete the slice in sequence object, o, from i1 to i2.
1144          Returns -1 on failure. This is the equivalent of the Python
1145          statement: del o[i1:i2].
1146        */
1147
1148      PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o);
1149
1150        /*
1151          Returns the sequence, o, as a tuple on success, and NULL on failure.
1152          This is equivalent to the Python expression: tuple(o)
1153        */
1154
1155
1156      PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o);
1157        /*
1158          Returns the sequence, o, as a list on success, and NULL on failure.
1159          This is equivalent to the Python expression: list(o)
1160        */
1161
1162      PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m);
1163        /*
1164          Returns the sequence, o, as a tuple, unless it's already a
1165          tuple or list.  Use PySequence_Fast_GET_ITEM to access the
1166          members of this list, and PySequence_Fast_GET_SIZE to get its length.
1167
1168          Returns NULL on failure.  If the object does not support iteration,
1169          raises a TypeError exception with m as the message text.
1170        */
1171
1172 #define PySequence_Fast_GET_SIZE(o) \
1173         (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
1174        /*
1175          Return the size of o, assuming that o was returned by
1176          PySequence_Fast and is not NULL.
1177        */
1178
1179 #define PySequence_Fast_GET_ITEM(o, i)\
1180      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
1181        /*
1182          Return the ith element of o, assuming that o was returned by
1183          PySequence_Fast, and that i is within bounds.
1184        */
1185
1186 #define PySequence_ITEM(o, i)\
1187         ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
1188        /* Assume tp_as_sequence and sq_item exist and that i does not
1189           need to be corrected for a negative index
1190        */
1191
1192 #define PySequence_Fast_ITEMS(sf) \
1193         (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
1194                           : ((PyTupleObject *)(sf))->ob_item)
1195         /* Return a pointer to the underlying item array for
1196            an object retured by PySequence_Fast */
1197
1198      PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value);
1199
1200        /*
1201          Return the number of occurrences on value on o, that is,
1202          return the number of keys for which o[key]==value.  On
1203          failure, return -1.  This is equivalent to the Python
1204          expression: o.count(value).
1205        */
1206
1207      PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob);
1208        /*
1209          Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
1210          Use __contains__ if possible, else _PySequence_IterSearch().
1211        */
1212
1213 #define PY_ITERSEARCH_COUNT    1
1214 #define PY_ITERSEARCH_INDEX    2
1215 #define PY_ITERSEARCH_CONTAINS 3
1216      PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
1217                                         PyObject *obj, int operation);
1218         /*
1219           Iterate over seq.  Result depends on the operation:
1220           PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if
1221                 error.
1222           PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of
1223                 obj in seq; set ValueError and return -1 if none found;
1224                 also return -1 on error.
1225           PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on
1226                 error.
1227         */
1228
1229 /* For DLL-level backwards compatibility */
1230 #undef PySequence_In
1231      PyAPI_FUNC(int) PySequence_In(PyObject *o, PyObject *value);
1232
1233 /* For source-level backwards compatibility */
1234 #define PySequence_In PySequence_Contains
1235
1236        /*
1237          Determine if o contains value.  If an item in o is equal to
1238          X, return 1, otherwise return 0.  On error, return -1.  This
1239          is equivalent to the Python expression: value in o.
1240        */
1241
1242      PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value);
1243
1244        /*
1245          Return the first index for which o[i]=value.  On error,
1246          return -1.    This is equivalent to the Python
1247          expression: o.index(value).
1248        */
1249
1250 /* In-place versions of some of the above Sequence functions. */
1251
1252      PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
1253
1254        /*
1255          Append o2 to o1, in-place when possible. Return the resulting
1256          object, which could be o1, or NULL on failure.  This is the
1257          equivalent of the Python expression: o1 += o2.
1258
1259        */
1260
1261      PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
1262
1263        /*
1264          Repeat o1 by count, in-place when possible. Return the resulting
1265          object, which could be o1, or NULL on failure.  This is the
1266          equivalent of the Python expression: o1 *= count.
1267
1268        */
1269
1270 /*  Mapping protocol:*/
1271
1272      PyAPI_FUNC(int) PyMapping_Check(PyObject *o);
1273
1274        /*
1275          Return 1 if the object provides mapping protocol, and zero
1276          otherwise.
1277
1278          This function always succeeds.
1279        */
1280
1281      PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
1282
1283        /*
1284          Returns the number of keys in object o on success, and -1 on
1285          failure.  For objects that do not provide sequence protocol,
1286          this is equivalent to the Python expression: len(o).
1287        */
1288
1289        /* For DLL compatibility */
1290 #undef PyMapping_Length
1291      PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o);
1292 #define PyMapping_Length PyMapping_Size
1293
1294
1295      /* implemented as a macro:
1296
1297      int PyMapping_DelItemString(PyObject *o, char *key);
1298
1299          Remove the mapping for object, key, from the object *o.
1300          Returns -1 on failure.  This is equivalent to
1301          the Python statement: del o[key].
1302        */
1303 #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
1304
1305      /* implemented as a macro:
1306
1307      int PyMapping_DelItem(PyObject *o, PyObject *key);
1308
1309          Remove the mapping for object, key, from the object *o.
1310          Returns -1 on failure.  This is equivalent to
1311          the Python statement: del o[key].
1312        */
1313 #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
1314
1315      PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, char *key);
1316
1317        /*
1318          On success, return 1 if the mapping object has the key, key,
1319          and 0 otherwise.  This is equivalent to the Python expression:
1320          o.has_key(key).
1321
1322          This function always succeeds.
1323        */
1324
1325      PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key);
1326
1327        /*
1328          Return 1 if the mapping object has the key, key,
1329          and 0 otherwise.  This is equivalent to the Python expression:
1330          o.has_key(key).
1331
1332          This function always succeeds.
1333
1334        */
1335
1336      /* Implemented as macro:
1337
1338      PyObject *PyMapping_Keys(PyObject *o);
1339
1340          On success, return a list of the keys in object o.  On
1341          failure, return NULL. This is equivalent to the Python
1342          expression: o.keys().
1343        */
1344 #define PyMapping_Keys(O) PyObject_CallMethod(O,"keys",NULL)
1345
1346      /* Implemented as macro:
1347
1348      PyObject *PyMapping_Values(PyObject *o);
1349
1350          On success, return a list of the values in object o.  On
1351          failure, return NULL. This is equivalent to the Python
1352          expression: o.values().
1353        */
1354 #define PyMapping_Values(O) PyObject_CallMethod(O,"values",NULL)
1355
1356      /* Implemented as macro:
1357
1358      PyObject *PyMapping_Items(PyObject *o);
1359
1360          On success, return a list of the items in object o, where
1361          each item is a tuple containing a key-value pair.  On
1362          failure, return NULL. This is equivalent to the Python
1363          expression: o.items().
1364
1365        */
1366 #define PyMapping_Items(O) PyObject_CallMethod(O,"items",NULL)
1367
1368      PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o, char *key);
1369
1370        /*
1371          Return element of o corresponding to the object, key, or NULL
1372          on failure. This is the equivalent of the Python expression:
1373          o[key].
1374        */
1375
1376      PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, char *key,
1377                                             PyObject *value);
1378
1379        /*
1380          Map the object, key, to the value, v.  Returns
1381          -1 on failure.  This is the equivalent of the Python
1382          statement: o[key]=v.
1383       */
1384
1385
1386 PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass);
1387       /* isinstance(object, typeorclass) */
1388
1389 PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);
1390       /* issubclass(object, typeorclass) */
1391
1392
1393 #ifdef __cplusplus
1394 }
1395 #endif
1396 #endif /* Py_ABSTRACTOBJECT_H */