root/trunk/infrastructure/python/python.d

Revision 121, 139.3 kB (checked in by KirkMcDonald, 5 years ago)

Since the D 2.0 series has been found lacking at the moment, Pyd once again compiles under the 1.0 series. (Specifically 1.016 or later; tested with 1.020.)

Line 
1 /* DSR:2005.10.26.16.28:
2 // Updated to Python 2.5 by Kirk McDonald
3
4 XXX:
5
6 - In a build process controlled by Python distutils, need to detect whether the
7   Python interpreter was built in debug build mode, and if so, make the
8   appropriate adjustments to the header mixins.
9
10 */
11
12 module python;
13
14 version (build) {
15     version (DigitalMars) {
16         version (Windows) {
17             version (Python_2_5_Or_Later) {
18                 pragma(link, "python25_digitalmars");
19             } else {
20                 pragma(link, "python24_digitalmars");
21             }
22         }
23     } else {
24         version (Python_2_5_Or_Later) {
25             pragma(link, "python2.5");
26         } else {
27             pragma(link, "python2.4");
28         }
29     }
30 }
31
32 version (Tango) {
33     import tango.stdc.stdio;
34     import tango.stdc.time;
35     import tango.stdc.string;
36 } else {
37     import std.c.stdio;
38     import std.c.time;
39     import std.c.string;
40 }
41
42 /* D long is always 64 bits, but when the Python/C API mentions long, it is of
43  * course referring to the C type long, the size of which is 32 bits on both
44  * X86 and X86_64 under Windows, but 32 bits on X86 and 64 bits on X86_64 under
45  * most other operating systems. */
46
47 alias long C_longlong;
48 alias ulong C_ulonglong;
49
50 version(Windows) {
51   alias int C_long;
52   alias uint C_ulong;
53 } else {
54   version (X86) {
55     alias int C_long;
56     alias uint C_ulong;
57   } else {
58     alias long C_long;
59     alias ulong C_ulong;
60   }
61 }
62
63 version (D_Version2) {
64     // Need to define const(char)* in a way which is syntactically valid in a
65     // D 1.0 compiler.
66     mixin("alias const(char)* c_str;");
67 } else {
68     alias char* c_str;
69 }
70
71 /*
72  * Py_ssize_t is defined as a signed type which is 8 bytes on X86_64 and 4
73  * bytes on X86.
74  */
75 version (Python_2_5_Or_Later) {
76     version (X86_64) {
77         alias long Py_ssize_t;
78     } else {
79         alias int Py_ssize_t;
80     }
81 } else {
82     alias C_long Py_ssize_t;
83 }
84
85 extern (C) {
86 ///////////////////////////////////////////////////////////////////////////////
87 // PYTHON DATA STRUCTURES AND ALIASES
88 ///////////////////////////////////////////////////////////////////////////////
89   // Python-header-file: Include/Python.h:
90   const int Py_single_input = 256;
91   const int Py_file_input = 257;
92   const int Py_eval_input = 258;
93
94   // Python-header-file: Include/object.h:
95
96   // XXX:Conditionalize in if running debug build of Python interpreter:
97   /*
98   version (Python_Debug_Build) {
99     template _PyObject_HEAD_EXTRA() {
100       PyObject *_ob_next;
101       PyObject *_ob_prev;
102     }
103   } else {
104   */
105     template _PyObject_HEAD_EXTRA() {}
106   /*}*/
107
108   template PyObject_HEAD() {
109     mixin _PyObject_HEAD_EXTRA;
110     Py_ssize_t ob_refcnt;
111     PyTypeObject *ob_type;
112   }
113
114   struct PyObject {
115     mixin PyObject_HEAD;
116   }
117
118   template PyObject_VAR_HEAD() {
119     mixin PyObject_HEAD;
120     Py_ssize_t ob_size; /* Number of items in variable part */
121   }
122
123   struct PyVarObject {
124     mixin PyObject_VAR_HEAD;
125   }
126
127   alias PyObject * (*unaryfunc)(PyObject *);
128   alias PyObject * (*binaryfunc)(PyObject *, PyObject *);
129   alias PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
130   alias int (*inquiry)(PyObject *);
131   alias Py_ssize_t (*lenfunc)(PyObject *);
132   alias int (*coercion)(PyObject **, PyObject **);
133   alias PyObject *(*intargfunc)(PyObject *, int);
134   alias PyObject *(*intintargfunc)(PyObject *, int, int);
135   alias PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
136   alias PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
137   alias int(*intobjargproc)(PyObject *, int, PyObject *);
138   alias int(*intintobjargproc)(PyObject *, int, int, PyObject *);
139   alias int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
140   alias int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
141   alias int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
142
143   // int-based buffer interface
144   alias int (*getreadbufferproc)(PyObject *, int, void **);
145   alias int (*getwritebufferproc)(PyObject *, int, void **);
146   alias int (*getsegcountproc)(PyObject *, int *);
147   alias int (*getcharbufferproc)(PyObject *, int, c_str*);
148   // ssize_t-based buffer interface
149   alias Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **);
150   alias Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **);
151   alias Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *);
152   alias Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, c_str*);
153
154   alias int (*objobjproc)(PyObject *, PyObject *);
155   alias int (*visitproc)(PyObject *, void *);
156   alias int (*traverseproc)(PyObject *, visitproc, void *);
157
158   // Python-header-file: Include/object.h:
159   struct PyNumberMethods {
160     binaryfunc nb_add;
161     binaryfunc nb_subtract;
162     binaryfunc nb_multiply;
163     binaryfunc nb_divide;
164     binaryfunc nb_remainder;
165     binaryfunc nb_divmod;
166     ternaryfunc nb_power;
167     unaryfunc nb_negative;
168     unaryfunc nb_positive;
169     unaryfunc nb_absolute;
170     inquiry nb_nonzero;
171     unaryfunc nb_invert;
172     binaryfunc nb_lshift;
173     binaryfunc nb_rshift;
174     binaryfunc nb_and;
175     binaryfunc nb_xor;
176     binaryfunc nb_or;
177     coercion nb_coerce;
178     unaryfunc nb_int;
179     unaryfunc nb_long;
180     unaryfunc nb_float;
181     unaryfunc nb_oct;
182     unaryfunc nb_hex;
183
184     binaryfunc nb_inplace_add;
185     binaryfunc nb_inplace_subtract;
186     binaryfunc nb_inplace_multiply;
187     binaryfunc nb_inplace_divide;
188     binaryfunc nb_inplace_remainder;
189     ternaryfunc nb_inplace_power;
190     binaryfunc nb_inplace_lshift;
191     binaryfunc nb_inplace_rshift;
192     binaryfunc nb_inplace_and;
193     binaryfunc nb_inplace_xor;
194     binaryfunc nb_inplace_or;
195
196     binaryfunc nb_floor_divide;
197     binaryfunc nb_true_divide;
198     binaryfunc nb_inplace_floor_divide;
199     binaryfunc nb_inplace_true_divide;
200
201     version (Python_2_5_Or_Later) {
202         unaryfunc nb_index;
203     }
204   }
205
206   struct PySequenceMethods {
207     lenfunc sq_length;
208     binaryfunc sq_concat;
209     ssizeargfunc sq_repeat;
210     ssizeargfunc sq_item;
211     ssizessizeargfunc sq_slice;
212     ssizeobjargproc sq_ass_item;
213     ssizessizeobjargproc sq_ass_slice;
214     objobjproc sq_contains;
215     binaryfunc sq_inplace_concat;
216     ssizeargfunc sq_inplace_repeat;
217   }
218
219   struct PyMappingMethods {
220     lenfunc mp_length;
221     binaryfunc mp_subscript;
222     objobjargproc mp_ass_subscript;
223   }
224
225   struct PyBufferProcs {
226     readbufferproc bf_getreadbuffer;
227     writebufferproc bf_getwritebuffer;
228     segcountproc bf_getsegcount;
229     charbufferproc bf_getcharbuffer;
230   }
231
232
233   alias void (*freefunc)(void *);
234   alias void (*destructor)(PyObject *);
235   alias int (*printfunc)(PyObject *, FILE *, int);
236   alias PyObject *(*getattrfunc)(PyObject *, c_str);
237   alias PyObject *(*getattrofunc)(PyObject *, PyObject *);
238   alias int (*setattrfunc)(PyObject *, c_str, PyObject *);
239   alias int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
240   alias int (*cmpfunc)(PyObject *, PyObject *);
241   alias PyObject *(*reprfunc)(PyObject *);
242   alias C_long (*hashfunc)(PyObject *);
243   alias PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
244   alias PyObject *(*getiterfunc) (PyObject *);
245   alias PyObject *(*iternextfunc) (PyObject *);
246   alias PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
247   alias int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
248   alias int (*initproc)(PyObject *, PyObject *, PyObject *);
249   alias PyObject *(*newfunc)(PyTypeObject *, PyObject *, PyObject *);
250   alias PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t);
251
252   struct PyTypeObject {
253     mixin PyObject_VAR_HEAD;
254
255     c_str tp_name;
256     Py_ssize_t tp_basicsize, tp_itemsize;
257
258     destructor tp_dealloc;
259     printfunc tp_print;
260     getattrfunc tp_getattr;
261     setattrfunc tp_setattr;
262     cmpfunc tp_compare;
263     reprfunc tp_repr;
264
265     PyNumberMethods *tp_as_number;
266     PySequenceMethods *tp_as_sequence;
267     PyMappingMethods *tp_as_mapping;
268
269     hashfunc tp_hash;
270     ternaryfunc tp_call;
271     reprfunc tp_str;
272     getattrofunc tp_getattro;
273     setattrofunc tp_setattro;
274
275     PyBufferProcs *tp_as_buffer;
276
277     C_long tp_flags;
278
279     c_str tp_doc;
280
281     traverseproc tp_traverse;
282
283     inquiry tp_clear;
284
285     richcmpfunc tp_richcompare;
286
287     Py_ssize_t tp_weaklistoffset;
288
289     getiterfunc tp_iter;
290     iternextfunc tp_iternext;
291
292     PyMethodDef *tp_methods;
293     PyMemberDef *tp_members;
294     PyGetSetDef *tp_getset;
295     PyTypeObject *tp_base;
296     PyObject *tp_dict;
297     descrgetfunc tp_descr_get;
298     descrsetfunc tp_descr_set;
299     Py_ssize_t tp_dictoffset;
300     initproc tp_init;
301     allocfunc tp_alloc;
302     newfunc tp_new;
303     freefunc tp_free;
304     inquiry tp_is_gc;
305     PyObject *tp_bases;
306     PyObject *tp_mro;
307     PyObject *tp_cache;
308     PyObject *tp_subclasses;
309     PyObject *tp_weaklist;
310     destructor tp_del;
311   }
312
313   //alias _typeobject PyTypeObject;
314
315   struct _heaptypeobject {
316     // Some of these names changed between 2.4 and 2.5; not a serious issue.
317     PyTypeObject ht_type;
318     PyNumberMethods as_number;
319     PyMappingMethods as_mapping;
320     PySequenceMethods as_sequence;
321     PyBufferProcs as_buffer;
322     PyObject *ht_name;
323     PyObject *ht_slots;
324   }
325   alias _heaptypeobject PyHeapTypeObject;
326
327
328   // Python-header-file: Include/pymem.h:
329   void * PyMem_Malloc(size_t);
330   void * PyMem_Realloc(void *, size_t);
331   void PyMem_Free(void *);
332
333
334 ///////////////////////////////////////////////////////////////////////////////
335 // GENERIC TYPE CHECKING
336 ///////////////////////////////////////////////////////////////////////////////
337
338   int PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
339
340   // D translation of C macro:
341   int PyObject_TypeCheck(PyObject *ob, PyTypeObject *tp) {
342     return (ob.ob_type == tp || PyType_IsSubtype(ob.ob_type, tp));
343   }
344
345   /* Note that this Python support module makes pointers to PyType_Type and
346    * other global variables exposed by the Python API available to D
347    * programmers indirectly (see this module's static initializer). */
348
349   // D translation of C macro:
350   int PyType_Check(PyObject *op) {
351     return PyObject_TypeCheck(op, PyType_Type_p);
352   }
353   // D translation of C macro:
354   int PyType_CheckExact(PyObject *op) {
355     return op.ob_type == PyType_Type_p;
356   }
357
358   int PyType_Ready(PyTypeObject *);
359   PyObject * PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
360   PyObject * PyType_GenericNew(PyTypeObject *, PyObject *, PyObject *);
361
362
363   int PyObject_Print(PyObject *, FILE *, int);
364   PyObject * PyObject_Repr(PyObject *);
365   PyObject * PyObject_Str(PyObject *);
366
367   PyObject * PyObject_Unicode(PyObject *);
368
369   int PyObject_Compare(PyObject *, PyObject *);
370   PyObject * PyObject_RichCompare(PyObject *, PyObject *, int);
371   int PyObject_RichCompareBool(PyObject *, PyObject *, int);
372   PyObject * PyObject_GetAttrString(PyObject *, c_str);
373   int PyObject_SetAttrString(PyObject *, c_str, PyObject *);
374   int PyObject_HasAttrString(PyObject *, c_str);
375   PyObject * PyObject_GetAttr(PyObject *, PyObject *);
376   int PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
377   int PyObject_HasAttr(PyObject *, PyObject *);
378   PyObject * PyObject_SelfIter(PyObject *);
379   PyObject * PyObject_GenericGetAttr(PyObject *, PyObject *);
380   int PyObject_GenericSetAttr(PyObject *,
381                 PyObject *, PyObject *);
382   C_long PyObject_Hash(PyObject *);
383   int PyObject_IsTrue(PyObject *);
384   int PyObject_Not(PyObject *);
385   //int PyCallable_Check(PyObject *);
386   int PyNumber_Coerce(PyObject **, PyObject **);
387   int PyNumber_CoerceEx(PyObject **, PyObject **);
388
389   void PyObject_ClearWeakRefs(PyObject *);
390
391   PyObject * PyObject_Dir(PyObject *);
392
393   int Py_ReprEnter(PyObject *);
394   void Py_ReprLeave(PyObject *);
395
396   const int Py_PRINT_RAW = 1;
397
398
399   const int Py_TPFLAGS_HAVE_GETCHARBUFFER       = 1L<<0;
400   const int Py_TPFLAGS_HAVE_SEQUENCE_IN         = 1L<<1;
401   const int Py_TPFLAGS_GC                       = 0;
402   const int Py_TPFLAGS_HAVE_INPLACEOPS          = 1L<<3;
403   const int Py_TPFLAGS_CHECKTYPES               = 1L<<4;
404   const int Py_TPFLAGS_HAVE_RICHCOMPARE         = 1L<<5;
405   const int Py_TPFLAGS_HAVE_WEAKREFS            = 1L<<6;
406   const int Py_TPFLAGS_HAVE_ITER                = 1L<<7;
407   const int Py_TPFLAGS_HAVE_CLASS               = 1L<<8;
408   const int Py_TPFLAGS_HEAPTYPE                 = 1L<<9;
409   const int Py_TPFLAGS_BASETYPE                 = 1L<<10;
410   const int Py_TPFLAGS_READY                    = 1L<<12;
411   const int Py_TPFLAGS_READYING                 = 1L<<13;
412   const int Py_TPFLAGS_HAVE_GC                  = 1L<<14;
413
414   // YYY: Should conditionalize for stackless:
415   //#ifdef STACKLESS
416   //#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3L<<15)
417   //#else
418   const int Py_TPFLAGS_HAVE_STACKLESS_EXTENSION = 0;
419   //#endif
420   version (Python_2_5_Or_Later) {
421       const int Py_TPFLAGS_HAVE_INDEX = 1L<<17;
422   } else {
423       const int Py_TPFLAGS_HAVE_INDEX = 0;
424   }
425
426   const int Py_TPFLAGS_DEFAULT =
427       Py_TPFLAGS_HAVE_GETCHARBUFFER |
428       Py_TPFLAGS_HAVE_SEQUENCE_IN |
429       Py_TPFLAGS_HAVE_INPLACEOPS |
430       Py_TPFLAGS_HAVE_RICHCOMPARE |
431       Py_TPFLAGS_HAVE_WEAKREFS |
432       Py_TPFLAGS_HAVE_ITER |
433       Py_TPFLAGS_HAVE_CLASS |
434       Py_TPFLAGS_HAVE_STACKLESS_EXTENSION |
435       Py_TPFLAGS_HAVE_INDEX |
436       0
437     ;
438
439   // D translation of C macro:
440   int PyType_HasFeature(PyTypeObject *t, int f) {
441     return (t.tp_flags & f) != 0;
442   }
443
444
445 ///////////////////////////////////////////////////////////////////////////////
446 // REFERENCE COUNTING
447 ///////////////////////////////////////////////////////////////////////////////
448   // Python-header-file: Include/object.h:
449
450   void Py_INCREF(PyObject *op) {
451     ++op.ob_refcnt;
452   }
453
454   void Py_XINCREF(PyObject *op) {
455     if (op == null) {
456       return;
457     }
458     Py_INCREF(op);
459   }
460
461   void Py_DECREF(PyObject *op) {
462     --op.ob_refcnt;
463     assert (op.ob_refcnt >= 0);
464     if (op.ob_refcnt == 0) {
465       op.ob_type.tp_dealloc(op);
466     }
467   }
468
469   void Py_XDECREF(PyObject* op)
470   {
471     if(op == null) {
472       return;
473     }
474
475     Py_DECREF(op);
476   }
477
478   void Py_IncRef(PyObject *);
479   void Py_DecRef(PyObject *);
480
481   /* Rich comparison opcodes */
482   const int Py_LT = 0;
483   const int Py_LE = 1;
484   const int Py_EQ = 2;
485   const int Py_NE = 3;
486   const int Py_GT = 4;
487   const int Py_GE = 5;
488
489
490 ///////////////////////////////////////////////////////////////////////////////////////////////
491 // UNICODE
492 ///////////////////////////////////////////////////////////////////////////////////////////////
493   // Python-header-file: Include/unicodeobject.h:
494   /* The Python header explains:
495    *   Unicode API names are mangled to assure that UCS-2 and UCS-4 builds
496    *   produce different external names and thus cause import errors in
497    *   case Python interpreters and extensions with mixed compiled in
498    *   Unicode width assumptions are combined. */
499
500   version (Python_Unicode_UCS2) {
501     version (Windows) {
502       alias wchar Py_UNICODE;
503     } else {
504       alias ushort Py_UNICODE;
505     }
506   } else {
507     alias uint Py_UNICODE;
508   }
509
510   struct PyUnicodeObject {
511     mixin PyObject_HEAD;
512
513     Py_ssize_t length;
514     Py_UNICODE *str;
515     C_long hash;
516     PyObject *defenc;
517   }
518
519   // &PyUnicode_Type is accessible via PyUnicode_Type_p.
520   // D translations of C macros:
521   int PyUnicode_Check(PyObject *op) {
522     return PyObject_TypeCheck(op, PyUnicode_Type_p);
523   }
524   int PyUnicode_CheckExact(PyObject *op) {
525     return op.ob_type == PyUnicode_Type_p;
526   }
527
528   int PyUnicode_GET_SIZE(PyUnicodeObject *op) {
529     return op.length;
530   }
531   int PyUnicode_GET_DATA_SIZE(PyUnicodeObject *op) {
532     return op.length * Py_UNICODE.sizeof;
533   }
534   Py_UNICODE *PyUnicode_AS_UNICODE(PyUnicodeObject *op) {
535     return op.str;
536   }
537   char *PyUnicode_AS_DATA(PyUnicodeObject *op) {
538     return cast(char *) op.str;
539   }
540
541   Py_UNICODE Py_UNICODE_REPLACEMENT_CHARACTER = 0xFFFD;
542
543   // YYY: Unfortunately, we have to do it the tedious way since there's no
544   // preprocessor in D:
545   version (Python_Unicode_UCS2) {
546     PyObject *PyUnicodeUCS2_FromUnicode(Py_UNICODE *u, Py_ssize_t size);
547     Py_UNICODE *PyUnicodeUCS2_AsUnicode(PyObject *unicode);
548     Py_ssize_t PyUnicodeUCS2_GetSize(PyObject *unicode);
549     Py_UNICODE PyUnicodeUCS2_GetMax();
550
551     int PyUnicodeUCS2_Resize(PyObject **unicode, Py_ssize_t length);
552     PyObject *PyUnicodeUCS2_FromEncodedObject(PyObject *obj, c_str encoding, c_str errors);
553     PyObject *PyUnicodeUCS2_FromObject(PyObject *obj);
554
555     PyObject *PyUnicodeUCS2_FromWideChar(wchar *w, Py_ssize_t size);
556     Py_ssize_t PyUnicodeUCS2_AsWideChar(PyUnicodeObject *unicode, wchar *w, Py_ssize_t size);
557
558     PyObject *PyUnicodeUCS2_FromOrdinal(int ordinal);
559
560     PyObject *_PyUnicodeUCS2_AsDefaultEncodedString(PyObject *, c_str);
561
562     c_str PyUnicodeUCS2_GetDefaultEncoding();
563     int PyUnicodeUCS2_SetDefaultEncoding(c_str encoding);
564
565     PyObject *PyUnicodeUCS2_Decode(c_str s, Py_ssize_t size, c_str encoding, c_str errors);
566     PyObject *PyUnicodeUCS2_Encode(Py_UNICODE *s, Py_ssize_t size, c_str encoding, c_str errors);
567     PyObject *PyUnicodeUCS2_AsEncodedObject(PyObject *unicode, c_str encoding, c_str errors);
568     PyObject *PyUnicodeUCS2_AsEncodedString(PyObject *unicode, c_str encoding, c_str errors);
569
570     PyObject *PyUnicodeUCS2_DecodeUTF7(c_str s, Py_ssize_t length, c_str errors);
571     PyObject *PyUnicodeUCS2_EncodeUTF7(Py_UNICODE *data, Py_ssize_t length,
572         int encodeSetO, int encodeWhiteSpace, c_str errors
573       );
574
575     PyObject *PyUnicodeUCS2_DecodeUTF8(c_str s, Py_ssize_t length, c_str errors);
576     PyObject *PyUnicodeUCS2_DecodeUTF8Stateful(c_str s, Py_ssize_t length,
577         c_str errors, Py_ssize_t *consumed
578       );
579     PyObject *PyUnicodeUCS2_AsUTF8String(PyObject *unicode);
580     PyObject *PyUnicodeUCS2_EncodeUTF8(Py_UNICODE *data, Py_ssize_t length, c_str errors);
581
582     PyObject *PyUnicodeUCS2_DecodeUTF16(c_str s, Py_ssize_t length, c_str errors, int *byteorder);
583     PyObject *PyUnicodeUCS2_DecodeUTF16Stateful(c_str s, Py_ssize_t length,
584         c_str errors, int *byteorder, Py_ssize_t *consumed
585       );
586     PyObject *PyUnicodeUCS2_AsUTF16String(PyObject *unicode);
587     PyObject *PyUnicodeUCS2_EncodeUTF16(Py_UNICODE *data, Py_ssize_t length,
588         c_str errors, int byteorder
589       );
590
591     PyObject *PyUnicodeUCS2_DecodeUnicodeEscape(c_str s, Py_ssize_t length, c_str errors);
592     PyObject *PyUnicodeUCS2_AsUnicodeEscapeString(PyObject *unicode);
593     PyObject *PyUnicodeUCS2_EncodeUnicodeEscape(Py_UNICODE *data, Py_ssize_t length);
594     PyObject *PyUnicodeUCS2_DecodeRawUnicodeEscape(c_str s, Py_ssize_t length, c_str errors);
595     PyObject *PyUnicodeUCS2_AsRawUnicodeEscapeString(PyObject *unicode);
596     PyObject *PyUnicodeUCS2_EncodeRawUnicodeEscape(Py_UNICODE *data, Py_ssize_t length);
597
598     PyObject *_PyUnicodeUCS2_DecodeUnicodeInternal(c_str s, Py_ssize_t length, c_str errors);
599
600     PyObject *PyUnicodeUCS2_DecodeLatin1(c_str s, Py_ssize_t length, c_str errors);
601     PyObject *PyUnicodeUCS2_AsLatin1String(PyObject *unicode);
602     PyObject *PyUnicodeUCS2_EncodeLatin1(Py_UNICODE *data, Py_ssize_t length, c_str errors);
603
604     PyObject *PyUnicodeUCS2_DecodeASCII(c_str s, Py_ssize_t length, c_str errors);
605     PyObject *PyUnicodeUCS2_AsASCIIString(PyObject *unicode);
606     PyObject *PyUnicodeUCS2_EncodeASCII(Py_UNICODE *data, Py_ssize_t length, c_str errors);
607
608     PyObject *PyUnicodeUCS2_DecodeCharmap(c_str s, Py_ssize_t length,
609         PyObject *mapping, c_str errors
610       );
611     PyObject *PyUnicodeUCS2_AsCharmapString(PyObject *unicode, PyObject *mapping);
612     PyObject *PyUnicodeUCS2_EncodeCharmap(Py_UNICODE *data, Py_ssize_t length,
613         PyObject *mapping, c_str errors
614       );
615     PyObject *PyUnicodeUCS2_TranslateCharmap(Py_UNICODE *data, Py_ssize_t length,
616         PyObject *table, c_str errors
617       );
618
619     version (Windows) {
620       PyObject *PyUnicodeUCS2_DecodeMBCS(c_str s, Py_ssize_t length, c_str errors);
621       PyObject *PyUnicodeUCS2_AsMBCSString(PyObject *unicode);
622       PyObject *PyUnicodeUCS2_EncodeMBCS(Py_UNICODE *data, Py_ssize_t length, c_str errors);
623     }
624
625     int PyUnicodeUCS2_EncodeDecimal(Py_UNICODE *s, Py_ssize_t length, c_str output, c_str errors);
626
627     PyObject *PyUnicodeUCS2_Concat(PyObject *left, PyObject *right);
628     PyObject *PyUnicodeUCS2_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit);
629     PyObject *PyUnicodeUCS2_Splitlines(PyObject *s, int keepends);
630     version (Python_2_5_Or_Later) {
631         PyObject *PyUnicodeUCS2_Partition(PyObject* s, PyObject* sep);
632         PyObject *PyUnicodeUCS2_RPartition(PyObject* s, PyObject* sep);
633     }
634     PyObject *PyUnicodeUCS2_RSplit(PyObject *s, PyObject *sep, Py_ssize_t maxsplit);
635     PyObject *PyUnicodeUCS2_Translate(PyObject *str, PyObject *table, c_str errors);
636     PyObject *PyUnicodeUCS2_Join(PyObject *separator, PyObject *seq);
637     Py_ssize_t PyUnicodeUCS2_Tailmatch(PyObject *str, PyObject *substr,
638         Py_ssize_t start, Py_ssize_t end, int direction
639       );
640     Py_ssize_t PyUnicodeUCS2_Find(PyObject *str, PyObject *substr,
641         Py_ssize_t start, Py_ssize_t end, int direction
642       );
643     Py_ssize_t PyUnicodeUCS2_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end);
644     PyObject *PyUnicodeUCS2_Replace(PyObject *str, PyObject *substr,
645         PyObject *replstr, Py_ssize_t maxcount
646       );
647     int PyUnicodeUCS2_Compare(PyObject *left, PyObject *right);
648     PyObject *PyUnicodeUCS2_Format(PyObject *format, PyObject *args);
649     int PyUnicodeUCS2_Contains(PyObject *container, PyObject *element);
650     PyObject *_PyUnicodeUCS2_XStrip(PyUnicodeObject *self, int striptype,
651         PyObject *sepobj
652       );
653
654     int _PyUnicodeUCS2_IsLowercase(Py_UNICODE ch);
655     int _PyUnicodeUCS2_IsUppercase(Py_UNICODE ch);
656     int _PyUnicodeUCS2_IsTitlecase(Py_UNICODE ch);
657     int _PyUnicodeUCS2_IsWhitespace(Py_UNICODE ch);
658     int _PyUnicodeUCS2_IsLinebreak(Py_UNICODE ch);
659     Py_UNICODE _PyUnicodeUCS2_ToLowercase(Py_UNICODE ch);
660     Py_UNICODE _PyUnicodeUCS2_ToUppercase(Py_UNICODE ch);
661     Py_UNICODE _PyUnicodeUCS2_ToTitlecase(Py_UNICODE ch);
662     int _PyUnicodeUCS2_ToDecimalDigit(Py_UNICODE ch);
663     int _PyUnicodeUCS2_ToDigit(Py_UNICODE ch);
664     double _PyUnicodeUCS2_ToNumeric(Py_UNICODE ch);
665     int _PyUnicodeUCS2_IsDecimalDigit(Py_UNICODE ch);
666     int _PyUnicodeUCS2_IsDigit(Py_UNICODE ch);
667     int _PyUnicodeUCS2_IsNumeric(Py_UNICODE ch);
668     int _PyUnicodeUCS2_IsAlpha(Py_UNICODE ch);
669
670   } else { /* not Python_Unicode_UCS2: */
671
672     PyObject *PyUnicodeUCS4_FromUnicode(Py_UNICODE *u, Py_ssize_t size);
673     Py_UNICODE *PyUnicodeUCS4_AsUnicode(PyObject *unicode);
674     Py_ssize_t PyUnicodeUCS4_GetSize(PyObject *unicode);
675     Py_UNICODE PyUnicodeUCS4_GetMax();
676
677     int PyUnicodeUCS4_Resize(PyObject **unicode, Py_ssize_t length);
678     PyObject *PyUnicodeUCS4_FromEncodedObject(PyObject *obj, c_str encoding, c_str errors);
679     PyObject *PyUnicodeUCS4_FromObject(PyObject *obj);
680
681     PyObject *PyUnicodeUCS4_FromWideChar(wchar *w, Py_ssize_t size);
682     Py_ssize_t PyUnicodeUCS4_AsWideChar(PyUnicodeObject *unicode, wchar *w, Py_ssize_t size);
683
684     PyObject *PyUnicodeUCS4_FromOrdinal(int ordinal);
685
686     PyObject *_PyUnicodeUCS4_AsDefaultEncodedString(PyObject *, c_str);
687
688     c_str PyUnicodeUCS4_GetDefaultEncoding();
689     int PyUnicodeUCS4_SetDefaultEncoding(c_str encoding);
690
691     PyObject *PyUnicodeUCS4_Decode(c_str s, Py_ssize_t size, c_str encoding, c_str errors);
692     PyObject *PyUnicodeUCS4_Encode(Py_UNICODE *s, Py_ssize_t size, c_str encoding, c_str errors);
693     PyObject *PyUnicodeUCS4_AsEncodedObject(PyObject *unicode, c_str encoding, c_str errors);
694     PyObject *PyUnicodeUCS4_AsEncodedString(PyObject *unicode, c_str encoding, c_str errors);
695
696     PyObject *PyUnicodeUCS4_DecodeUTF7(c_str s, Py_ssize_t length, c_str errors);
697     PyObject *PyUnicodeUCS4_EncodeUTF7(Py_UNICODE *data, Py_ssize_t length,
698         int encodeSetO, int encodeWhiteSpace, c_str errors
699       );
700
701     PyObject *PyUnicodeUCS4_DecodeUTF8(c_str s, Py_ssize_t length, c_str errors);
702     PyObject *PyUnicodeUCS4_DecodeUTF8Stateful(c_str string, Py_ssize_t length,
703         c_str errors, Py_ssize_t *consumed
704       );
705     PyObject *PyUnicodeUCS4_AsUTF8String(PyObject *unicode);
706     PyObject *PyUnicodeUCS4_EncodeUTF8(Py_UNICODE *data, Py_ssize_t length, c_str errors);
707
708     PyObject *PyUnicodeUCS4_DecodeUTF16(c_str s, Py_ssize_t length, c_str errors, int *byteorder);
709     PyObject *PyUnicodeUCS4_DecodeUTF16Stateful(c_str s, Py_ssize_t length,
710         c_str errors, int *byteorder, Py_ssize_t *consumed
711       );
712     PyObject *PyUnicodeUCS4_AsUTF16String(PyObject *unicode);
713     PyObject *PyUnicodeUCS4_EncodeUTF16(Py_UNICODE *data, Py_ssize_t length,
714         c_str errors, int byteorder
715       );
716
717     PyObject *PyUnicodeUCS4_DecodeUnicodeEscape(c_str s, Py_ssize_t length, c_str errors);
718     PyObject *PyUnicodeUCS4_AsUnicodeEscapeString(PyObject *unicode);
719     PyObject *PyUnicodeUCS4_EncodeUnicodeEscape(Py_UNICODE *data, Py_ssize_t length);
720     PyObject *PyUnicodeUCS4_DecodeRawUnicodeEscape(c_str s, Py_ssize_t length, c_str errors);
721     PyObject *PyUnicodeUCS4_AsRawUnicodeEscapeString(PyObject *unicode);
722     PyObject *PyUnicodeUCS4_EncodeRawUnicodeEscape(Py_UNICODE *data, Py_ssize_t length);
723
724     PyObject *_PyUnicodeUCS4_DecodeUnicodeInternal(c_str s, Py_ssize_t length, c_str errors);
725
726     PyObject *PyUnicodeUCS4_DecodeLatin1(c_str s, Py_ssize_t length, c_str errors);
727     PyObject *PyUnicodeUCS4_AsLatin1String(PyObject *unicode);
728     PyObject *PyUnicodeUCS4_EncodeLatin1(Py_UNICODE *data, Py_ssize_t length, c_str errors);
729
730     PyObject *PyUnicodeUCS4_DecodeASCII(c_str s, Py_ssize_t length, c_str errors);
731     PyObject *PyUnicodeUCS4_AsASCIIString(PyObject *unicode);
732     PyObject *PyUnicodeUCS4_EncodeASCII(Py_UNICODE *data, Py_ssize_t length, c_str errors);
733
734     PyObject *PyUnicodeUCS4_DecodeCharmap(c_str s, Py_ssize_t length,
735         PyObject *mapping, c_str errors
736       );
737     PyObject *PyUnicodeUCS4_AsCharmapString(PyObject *unicode, PyObject *mapping);
738     PyObject *PyUnicodeUCS4_EncodeCharmap(Py_UNICODE *data, Py_ssize_t length,
739         PyObject *mapping, c_str errors
740       );
741     PyObject *PyUnicodeUCS4_TranslateCharmap(Py_UNICODE *data, Py_ssize_t length,
742         PyObject *table, c_str errors
743       );
744
745     version (Windows) {
746       PyObject *PyUnicodeUCS4_DecodeMBCS(c_str s, Py_ssize_t length, c_str errors);
747       PyObject *PyUnicodeUCS4_AsMBCSString(PyObject *unicode);
748       PyObject *PyUnicodeUCS4_EncodeMBCS(Py_UNICODE *data, Py_ssize_t length, c_str errors);
749     }
750
751     int PyUnicodeUCS4_EncodeDecimal(Py_UNICODE *s, Py_ssize_t length, c_str output, c_str errors);
752
753     PyObject *PyUnicodeUCS4_Concat(PyObject *left, PyObject *right);
754     PyObject *PyUnicodeUCS4_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit);
755     PyObject *PyUnicodeUCS4_Splitlines(PyObject *s, int keepends);
756     version (Python_2_5_Or_Later) {
757         PyObject *PyUnicodeUCS4_Partition(PyObject* s, PyObject* sep);
758         PyObject *PyUnicodeUCS4_RPartition(PyObject* s, PyObject* sep);
759     }
760     PyObject *PyUnicodeUCS4_RSplit(PyObject *s, PyObject *sep, Py_ssize_t maxsplit);
761     PyObject *PyUnicodeUCS4_Translate(PyObject *str, PyObject *table, c_str errors);
762     PyObject *PyUnicodeUCS4_Join(PyObject *separator, PyObject *seq);
763     Py_ssize_t PyUnicodeUCS4_Tailmatch(PyObject *str, PyObject *substr,
764         Py_ssize_t start, Py_ssize_t end, int direction
765       );
766     Py_ssize_t PyUnicodeUCS4_Find(PyObject *str, PyObject *substr,
767         Py_ssize_t start, Py_ssize_t end, int direction
768       );
769     Py_ssize_t PyUnicodeUCS4_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end);
770     PyObject *PyUnicodeUCS4_Replace(PyObject *str, PyObject *substr,
771         PyObject *replstr, Py_ssize_t maxcount
772       );
773     int PyUnicodeUCS4_Compare(PyObject *left, PyObject *right);
774     PyObject *PyUnicodeUCS4_Format(PyObject *format, PyObject *args);
775     int PyUnicodeUCS4_Contains(PyObject *container, PyObject *element);
776     PyObject *_PyUnicodeUCS4_XStrip(PyUnicodeObject *self, int striptype,
777         PyObject *sepobj
778       );
779
780     int _PyUnicodeUCS4_IsLowercase(Py_UNICODE ch);
781     int _PyUnicodeUCS4_IsUppercase(Py_UNICODE ch);
782     int _PyUnicodeUCS4_IsTitlecase(Py_UNICODE ch);
783     int _PyUnicodeUCS4_IsWhitespace(Py_UNICODE ch);
784     int _PyUnicodeUCS4_IsLinebreak(Py_UNICODE ch);
785     Py_UNICODE _PyUnicodeUCS4_ToLowercase(Py_UNICODE ch);
786     Py_UNICODE _PyUnicodeUCS4_ToUppercase(Py_UNICODE ch);
787     Py_UNICODE _PyUnicodeUCS4_ToTitlecase(Py_UNICODE ch);
788     int _PyUnicodeUCS4_ToDecimalDigit(Py_UNICODE ch);
789     int _PyUnicodeUCS4_ToDigit(Py_UNICODE ch);
790     double _PyUnicodeUCS4_ToNumeric(Py_UNICODE ch);
791     int _PyUnicodeUCS4_IsDecimalDigit(Py_UNICODE ch);
792     int _PyUnicodeUCS4_IsDigit(Py_UNICODE ch);
793     int _PyUnicodeUCS4_IsNumeric(Py_UNICODE ch);
794     int _PyUnicodeUCS4_IsAlpha(Py_UNICODE ch);
795   }
796
797
798   /* The client programmer should call PyUnicode_XYZ, but linkage should be
799    * done via either PyUnicodeUCS2_XYZ or PyUnicodeUCS4_XYZ. */
800   version (Python_Unicode_UCS2) {
801     alias PyUnicodeUCS2_AsASCIIString PyUnicode_AsASCIIString;
802     alias PyUnicodeUCS2_AsCharmapString PyUnicode_AsCharmapString;
803     alias PyUnicodeUCS2_AsEncodedObject PyUnicode_AsEncodedObject;
804     alias PyUnicodeUCS2_AsEncodedString PyUnicode_AsEncodedString;
805     alias PyUnicodeUCS2_AsLatin1String PyUnicode_AsLatin1String;
806     alias PyUnicodeUCS2_AsRawUnicodeEscapeString PyUnicode_AsRawUnicodeEscapeString;
807     alias PyUnicodeUCS2_AsUTF16String PyUnicode_AsUTF16String;
808     alias PyUnicodeUCS2_AsUTF8String PyUnicode_AsUTF8String;
809     alias PyUnicodeUCS2_AsUnicode PyUnicode_AsUnicode;
810     alias PyUnicodeUCS2_AsUnicodeEscapeString PyUnicode_AsUnicodeEscapeString;
811     alias PyUnicodeUCS2_AsWideChar PyUnicode_AsWideChar;
812     alias PyUnicodeUCS2_Compare PyUnicode_Compare;
813     alias PyUnicodeUCS2_Concat PyUnicode_Concat;
814     alias PyUnicodeUCS2_Contains PyUnicode_Contains;
815     alias PyUnicodeUCS2_Count PyUnicode_Count;
816     alias PyUnicodeUCS2_Decode PyUnicode_Decode;
817     alias PyUnicodeUCS2_DecodeASCII PyUnicode_DecodeASCII;
818     alias PyUnicodeUCS2_DecodeCharmap PyUnicode_DecodeCharmap;
819     alias PyUnicodeUCS2_DecodeLatin1 PyUnicode_DecodeLatin1;
820     alias PyUnicodeUCS2_DecodeRawUnicodeEscape PyUnicode_DecodeRawUnicodeEscape;
821     alias PyUnicodeUCS2_DecodeUTF16 PyUnicode_DecodeUTF16;
822     alias PyUnicodeUCS2_DecodeUTF16Stateful PyUnicode_DecodeUTF16Stateful;
823     alias PyUnicodeUCS2_DecodeUTF8 PyUnicode_DecodeUTF8;
824     alias PyUnicodeUCS2_DecodeUTF8Stateful PyUnicode_DecodeUTF8Stateful;
825     alias PyUnicodeUCS2_DecodeUnicodeEscape PyUnicode_DecodeUnicodeEscape;
826     alias PyUnicodeUCS2_Encode PyUnicode_Encode;
827     alias PyUnicodeUCS2_EncodeASCII PyUnicode_EncodeASCII;
828     alias PyUnicodeUCS2_EncodeCharmap PyUnicode_EncodeCharmap;
829     alias PyUnicodeUCS2_EncodeDecimal PyUnicode_EncodeDecimal;
830     alias PyUnicodeUCS2_EncodeLatin1 PyUnicode_EncodeLatin1;
831     alias PyUnicodeUCS2_EncodeRawUnicodeEscape PyUnicode_EncodeRawUnicodeEscape;
832     alias PyUnicodeUCS2_EncodeUTF16 PyUnicode_EncodeUTF16;
833     alias PyUnicodeUCS2_EncodeUTF8 PyUnicode_EncodeUTF8;
834     alias PyUnicodeUCS2_EncodeUnicodeEscape PyUnicode_EncodeUnicodeEscape;
835     alias PyUnicodeUCS2_Find PyUnicode_Find;
836     alias PyUnicodeUCS2_Format PyUnicode_Format;
837     alias PyUnicodeUCS2_FromEncodedObject PyUnicode_FromEncodedObject;
838     alias PyUnicodeUCS2_FromObject PyUnicode_FromObject;
839     alias PyUnicodeUCS2_FromOrdinal PyUnicode_FromOrdinal;
840     alias PyUnicodeUCS2_FromUnicode PyUnicode_FromUnicode;
841     alias PyUnicodeUCS2_FromWideChar PyUnicode_FromWideChar;
842     alias PyUnicodeUCS2_GetDefaultEncoding PyUnicode_GetDefaultEncoding;
843     alias PyUnicodeUCS2_GetMax PyUnicode_GetMax;
844     alias PyUnicodeUCS2_GetSize PyUnicode_GetSize;
845     alias PyUnicodeUCS2_Join PyUnicode_Join;
846     version (Python_2_5_Or_Later) {
847         alias PyUnicodeUCS2_Partition PyUnicode_Partition;
848         alias PyUnicodeUCS2_RPartition PyUnicode_RPartition;
849     }
850     alias PyUnicodeUCS2_Replace PyUnicode_Replace;
851     alias PyUnicodeUCS2_Resize PyUnicode_Resize;
852     alias PyUnicodeUCS2_SetDefaultEncoding PyUnicode_SetDefaultEncoding;
853     alias PyUnicodeUCS2_Split PyUnicode_Split;
854     alias PyUnicodeUCS2_RSplit PyUnicode_RSplit;
855     alias PyUnicodeUCS2_Splitlines PyUnicode_Splitlines;
856     alias PyUnicodeUCS2_Tailmatch PyUnicode_Tailmatch;
857     alias PyUnicodeUCS2_Translate PyUnicode_Translate;
858     alias PyUnicodeUCS2_TranslateCharmap PyUnicode_TranslateCharmap;
859     alias _PyUnicodeUCS2_AsDefaultEncodedString _PyUnicode_AsDefaultEncodedString;
860     // omitted _PyUnicode_Fini
861     // omitted _PyUnicode_Init
862     alias _PyUnicodeUCS2_IsAlpha _PyUnicode_IsAlpha;
863     alias _PyUnicodeUCS2_IsDecimalDigit _PyUnicode_IsDecimalDigit;
864     alias _PyUnicodeUCS2_IsDigit _PyUnicode_IsDigit;
865     alias _PyUnicodeUCS2_IsLinebreak _PyUnicode_IsLinebreak;
866     alias _PyUnicodeUCS2_IsLowercase _PyUnicode_IsLowercase;
867     alias _PyUnicodeUCS2_IsNumeric _PyUnicode_IsNumeric;
868     alias _PyUnicodeUCS2_IsTitlecase _PyUnicode_IsTitlecase;
869     alias _PyUnicodeUCS2_IsUppercase _PyUnicode_IsUppercase;
870     alias _PyUnicodeUCS2_IsWhitespace _PyUnicode_IsWhitespace;
871     alias _PyUnicodeUCS2_ToDecimalDigit _PyUnicode_ToDecimalDigit;
872     alias _PyUnicodeUCS2_ToDigit _PyUnicode_ToDigit;
873     alias _PyUnicodeUCS2_ToLowercase _PyUnicode_ToLowercase;
874     alias _PyUnicodeUCS2_ToNumeric _PyUnicode_ToNumeric;
875     alias _PyUnicodeUCS2_ToTitlecase _PyUnicode_ToTitlecase;
876     alias _PyUnicodeUCS2_ToUppercase _PyUnicode_ToUppercase;
877   } else {
878     alias PyUnicodeUCS4_AsASCIIString PyUnicode_AsASCIIString;
879     alias PyUnicodeUCS4_AsCharmapString PyUnicode_AsCharmapString;
880     alias PyUnicodeUCS4_AsEncodedObject PyUnicode_AsEncodedObject;
881     alias PyUnicodeUCS4_AsEncodedString PyUnicode_AsEncodedString;
882     alias PyUnicodeUCS4_AsLatin1String PyUnicode_AsLatin1String;
883     alias PyUnicodeUCS4_AsRawUnicodeEscapeString PyUnicode_AsRawUnicodeEscapeString;
884     alias PyUnicodeUCS4_AsUTF16String PyUnicode_AsUTF16String;
885     alias PyUnicodeUCS4_AsUTF8String PyUnicode_AsUTF8String;
886     alias PyUnicodeUCS4_AsUnicode PyUnicode_AsUnicode;
887     alias PyUnicodeUCS4_AsUnicodeEscapeString PyUnicode_AsUnicodeEscapeString;
888     alias PyUnicodeUCS4_AsWideChar PyUnicode_AsWideChar;
889     alias PyUnicodeUCS4_Compare PyUnicode_Compare;
890     alias PyUnicodeUCS4_Concat PyUnicode_Concat;
891     alias PyUnicodeUCS4_Contains PyUnicode_Contains;
892     alias PyUnicodeUCS4_Count PyUnicode_Count;
893     alias PyUnicodeUCS4_Decode PyUnicode_Decode;
894     alias PyUnicodeUCS4_DecodeASCII PyUnicode_DecodeASCII;
895     alias PyUnicodeUCS4_DecodeCharmap PyUnicode_DecodeCharmap;
896     alias PyUnicodeUCS4_DecodeLatin1 PyUnicode_DecodeLatin1;
897     alias PyUnicodeUCS4_DecodeRawUnicodeEscape PyUnicode_DecodeRawUnicodeEscape;
898     alias PyUnicodeUCS4_DecodeUTF16 PyUnicode_DecodeUTF16;
899     alias PyUnicodeUCS4_DecodeUTF16Stateful PyUnicode_DecodeUTF16Stateful;
900     alias PyUnicodeUCS4_DecodeUTF8 PyUnicode_DecodeUTF8;
901     alias PyUnicodeUCS4_DecodeUTF8Stateful PyUnicode_DecodeUTF8Stateful;
902     alias PyUnicodeUCS4_DecodeUnicodeEscape PyUnicode_DecodeUnicodeEscape;
903     alias PyUnicodeUCS4_Encode PyUnicode_Encode;
904     alias PyUnicodeUCS4_EncodeASCII PyUnicode_EncodeASCII;
905     alias PyUnicodeUCS4_EncodeCharmap PyUnicode_EncodeCharmap;
906     alias PyUnicodeUCS4_EncodeDecimal PyUnicode_EncodeDecimal;
907     alias PyUnicodeUCS4_EncodeLatin1 PyUnicode_EncodeLatin1;
908     alias PyUnicodeUCS4_EncodeRawUnicodeEscape PyUnicode_EncodeRawUnicodeEscape;
909     alias PyUnicodeUCS4_EncodeUTF16 PyUnicode_EncodeUTF16;
910     alias PyUnicodeUCS4_EncodeUTF8 PyUnicode_EncodeUTF8;
911     alias PyUnicodeUCS4_EncodeUnicodeEscape PyUnicode_EncodeUnicodeEscape;
912     alias PyUnicodeUCS4_Find PyUnicode_Find;
913     alias PyUnicodeUCS4_Format PyUnicode_Format;
914     alias PyUnicodeUCS4_FromEncodedObject PyUnicode_FromEncodedObject;
915     alias PyUnicodeUCS4_FromObject PyUnicode_FromObject;
916     alias PyUnicodeUCS4_FromOrdinal PyUnicode_FromOrdinal;
917     alias PyUnicodeUCS4_FromUnicode PyUnicode_FromUnicode;
918     alias PyUnicodeUCS4_FromWideChar PyUnicode_FromWideChar;
919     alias PyUnicodeUCS4_GetDefaultEncoding PyUnicode_GetDefaultEncoding;
920     alias PyUnicodeUCS4_GetMax PyUnicode_GetMax;
921     alias PyUnicodeUCS4_GetSize PyUnicode_GetSize;
922     alias PyUnicodeUCS4_Join PyUnicode_Join;
923     alias PyUnicodeUCS4_Replace PyUnicode_Replace;
924     alias PyUnicodeUCS4_Resize PyUnicode_Resize;
925     version (Python_2_5_Or_Later) {
926         alias PyUnicodeUCS4_Partition PyUnicode_Partition;
927         alias PyUnicodeUCS4_RPartition PyUnicode_RPartition;
928     }
929     alias PyUnicodeUCS4_RSplit PyUnicode_RSplit;
930     alias PyUnicodeUCS4_SetDefaultEncoding PyUnicode_SetDefaultEncoding;
931     alias PyUnicodeUCS4_Split PyUnicode_Split;
932     alias PyUnicodeUCS4_Splitlines PyUnicode_Splitlines;
933     alias PyUnicodeUCS4_Tailmatch PyUnicode_Tailmatch;
934     alias PyUnicodeUCS4_Translate PyUnicode_Translate;
935     alias PyUnicodeUCS4_TranslateCharmap PyUnicode_TranslateCharmap;
936     alias _PyUnicodeUCS4_AsDefaultEncodedString _PyUnicode_AsDefaultEncodedString;
937     // omitted _PyUnicode_Fini
938     // omitted _PyUnicode_Init
939     alias _PyUnicodeUCS4_IsAlpha _PyUnicode_IsAlpha;
940     alias _PyUnicodeUCS4_IsDecimalDigit _PyUnicode_IsDecimalDigit;
941     alias _PyUnicodeUCS4_IsDigit _PyUnicode_IsDigit;
942     alias _PyUnicodeUCS4_IsLinebreak _PyUnicode_IsLinebreak;
943     alias _PyUnicodeUCS4_IsLowercase _PyUnicode_IsLowercase;
944     alias _PyUnicodeUCS4_IsNumeric _PyUnicode_IsNumeric;
945     alias _PyUnicodeUCS4_IsTitlecase _PyUnicode_IsTitlecase;
946     alias _PyUnicodeUCS4_IsUppercase _PyUnicode_IsUppercase;
947     alias _PyUnicodeUCS4_IsWhitespace _PyUnicode_IsWhitespace;
948     alias _PyUnicodeUCS4_ToDecimalDigit _PyUnicode_ToDecimalDigit;
949     alias _PyUnicodeUCS4_ToDigit _PyUnicode_ToDigit;
950     alias _PyUnicodeUCS4_ToLowercase _PyUnicode_ToLowercase;
951     alias _PyUnicodeUCS4_ToNumeric _PyUnicode_ToNumeric;
952     alias _PyUnicodeUCS4_ToTitlecase _PyUnicode_ToTitlecase;
953     alias _PyUnicodeUCS4_ToUppercase _PyUnicode_ToUppercase;
954   }
955
956   alias _PyUnicode_IsWhitespace Py_UNICODE_ISSPACE;
957   alias _PyUnicode_IsLowercase Py_UNICODE_ISLOWER;
958   alias _PyUnicode_IsUppercase Py_UNICODE_ISUPPER;
959   alias _PyUnicode_IsTitlecase Py_UNICODE_ISTITLE;
960   alias _PyUnicode_IsLinebreak Py_UNICODE_ISLINEBREAK;
961   alias _PyUnicode_ToLowercase Py_UNICODE_TOLOWER;
962   alias _PyUnicode_ToUppercase Py_UNICODE_TOUPPER;
963   alias _PyUnicode_ToTitlecase Py_UNICODE_TOTITLE;
964   alias _PyUnicode_IsDecimalDigit Py_UNICODE_ISDECIMAL;
965   alias _PyUnicode_IsDigit Py_UNICODE_ISDIGIT;
966   alias _PyUnicode_IsNumeric Py_UNICODE_ISNUMERIC;
967   alias _PyUnicode_ToDecimalDigit Py_UNICODE_TODECIMAL;
968   alias _PyUnicode_ToDigit Py_UNICODE_TODIGIT;
969   alias _PyUnicode_ToNumeric Py_UNICODE_TONUMERIC;
970   alias _PyUnicode_IsAlpha Py_UNICODE_ISALPHA;
971
972   int Py_UNICODE_ISALNUM(Py_UNICODE ch) {
973     return (
974            Py_UNICODE_ISALPHA(ch)
975         || Py_UNICODE_ISDECIMAL(ch)
976         || Py_UNICODE_ISDIGIT(ch)
977         || Py_UNICODE_ISNUMERIC(ch)
978       );
979   }
980
981   void Py_UNICODE_COPY(void *target, void *source, size_t length) {
982     memcpy(target, source, cast(uint)(length * Py_UNICODE.sizeof));
983   }
984
985   void Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, size_t length) {
986     for (size_t i = 0; i < length; i++) {
987       target[i] = value;
988     }
989   }
990
991   int Py_UNICODE_MATCH(PyUnicodeObject *string, size_t offset,
992       PyUnicodeObject *substring
993     )
994   {
995     return (
996          (*(string.str + offset) == *(substring.str))
997       && !memcmp(string.str + offset, substring.str,
998              substring.length * Py_UNICODE.sizeof
999           )
1000       );
1001   }
1002
1003
1004 ///////////////////////////////////////////////////////////////////////////////
1005 // INT INTERFACE
1006 ///////////////////////////////////////////////////////////////////////////////
1007   // Python-header-file: Include/intobject.h:
1008
1009   struct PyIntObject {
1010     mixin PyObject_HEAD;
1011
1012     C_long ob_ival;
1013   }
1014
1015   // &PyInt_Type is accessible via PyInt_Type_p.
1016
1017   // D translation of C macro:
1018   int PyInt_Check(PyObject *op) {
1019     return PyObject_TypeCheck(op, PyInt_Type_p);
1020   }
1021   // D translation of C macro:
1022   int PyInt_CheckExact(PyObject *op) {
1023     return op.ob_type == PyInt_Type_p;
1024   }
1025
1026   PyObject *PyInt_FromString(char *, char **, int);
1027   PyObject *PyInt_FromUnicode(Py_UNICODE *, Py_ssize_t, int);
1028   PyObject *PyInt_FromLong(C_long);
1029   version (Python_2_5_Or_Later) {
1030       PyObject *PyInt_FromSize_t(size_t);
1031       PyObject *PyInt_FromSsize_t(Py_ssize_t);
1032   }
1033
1034   C_long PyInt_AsLong(PyObject *);
1035   C_ulong PyInt_AsUnsignedLongMask(PyObject *);
1036   C_ulonglong PyInt_AsUnsignedLongLongMask(PyObject *);
1037
1038   C_long PyInt_GetMax(); /* Accessible at the Python level as sys.maxint */
1039
1040   C_ulong PyOS_strtoul(char *, char **, int);
1041   C_long PyOS_strtol(char *, char **, int);
1042
1043
1044 ///////////////////////////////////////////////////////////////////////////////
1045 // BOOL INTERFACE
1046 ///////////////////////////////////////////////////////////////////////////////
1047   // Python-header-file: Include/boolobject.h:
1048
1049   alias PyIntObject PyBoolObject;
1050
1051   // &PyBool_Type is accessible via PyBool_Type_p.
1052
1053   // D translation of C macro:
1054   int PyBool_Check(PyObject *x) {
1055     return x.ob_type == PyBool_Type_p;
1056   }
1057
1058   // Py_False and Py_True are actually macros in the Python/C API, so they're
1059   // loaded as PyObject pointers in this module static initializer.
1060
1061   PyObject * PyBool_FromLong(C_long);
1062
1063
1064 ///////////////////////////////////////////////////////////////////////////////
1065 // LONG INTERFACE
1066 ///////////////////////////////////////////////////////////////////////////////
1067   // Python-header-file: Include/longobject.h:
1068
1069   // &PyLong_Type is accessible via PyLong_Type_p.
1070
1071   // D translation of C macro:
1072   int PyLong_Check(PyObject *op) {
1073     return PyObject_TypeCheck(op, PyLong_Type_p);
1074   }
1075   // D translation of C macro:
1076   int PyLong_CheckExact(PyObject *op) {
1077     return op.ob_type == PyLong_Type_p;
1078   }
1079
1080   PyObject * PyLong_FromLong(C_long);
1081   PyObject * PyLong_FromUnsignedLong(C_ulong);
1082
1083   PyObject * PyLong_FromLongLong(C_longlong);
1084   PyObject * PyLong_FromUnsignedLongLong(C_ulonglong);
1085
1086   PyObject * PyLong_FromDouble(double);
1087
1088   C_long PyLong_AsLong(PyObject *);
1089   C_ulong PyLong_AsUnsignedLong(PyObject *);
1090   C_ulong PyLong_AsUnsignedLongMask(PyObject *);
1091
1092   C_longlong PyLong_AsLongLong(PyObject *);
1093   C_ulonglong PyLong_AsUnsignedLongLong(PyObject *);
1094   C_ulonglong PyLong_AsUnsignedLongLongMask(PyObject *);
1095
1096   double PyLong_AsDouble(PyObject *);
1097   PyObject * PyLong_FromVoidPtr(void *);
1098   void * PyLong_AsVoidPtr(PyObject *);
1099
1100   PyObject * PyLong_FromString(char *, char **, int);
1101   PyObject * PyLong_FromUnicode(Py_UNICODE *, int, int);
1102
1103
1104 ///////////////////////////////////////////////////////////////////////////////
1105 // FLOAT INTERFACE
1106 ///////////////////////////////////////////////////////////////////////////////
1107   // Python-header-file: Include/floatobject.h:
1108
1109   struct PyFloatObject {
1110     mixin PyObject_HEAD;
1111
1112     double ob_fval;
1113   }
1114
1115   // &PyFloat_Type is accessible via PyFloat_Type_p.
1116
1117   // D translation of C macro:
1118   int PyFloat_Check(PyObject *op) {
1119     return PyObject_TypeCheck(op, PyFloat_Type_p);
1120   }
1121   // D translation of C macro:
1122   int PyFloat_CheckExact(PyObject *op) {
1123     return op.ob_type == PyFloat_Type_p;
1124   }
1125
1126   PyObject * PyFloat_FromString(PyObject *, char** junk);
1127   PyObject * PyFloat_FromDouble(double);
1128
1129   double PyFloat_AsDouble(PyObject *);
1130   void PyFloat_AsReprString(char *, PyFloatObject *v);
1131   void PyFloat_AsString(char *, PyFloatObject *v);
1132
1133
1134 ///////////////////////////////////////////////////////////////////////////////
1135 // COMPLEX INTERFACE
1136 ///////////////////////////////////////////////////////////////////////////////
1137   // Python-header-file: Include/complexobject.h:
1138
1139   struct Py_complex {
1140     double real_; // real is the name of a D type, so must rename
1141     double imag;
1142   }
1143
1144   struct PyComplexObject {
1145     mixin PyObject_HEAD;
1146
1147     Py_complex cval;
1148   }
1149
1150   Py_complex c_sum(Py_complex, Py_complex);
1151   Py_complex c_diff(Py_complex, Py_complex);
1152   Py_complex c_neg(Py_complex);
1153   Py_complex c_prod(Py_complex, Py_complex);
1154   Py_complex c_quot(Py_complex, Py_complex);
1155   Py_complex c_pow(Py_complex, Py_complex);
1156
1157   // &PyComplex_Type is accessible via PyComplex_Type_p.
1158
1159   // D translation of C macro:
1160   int PyComplex_Check(PyObject *op) {
1161     return PyObject_TypeCheck(op, PyComplex_Type_p);
1162   }
1163   // D translation of C macro:
1164   int PyComplex_CheckExact(PyObject *op) {
1165     return op.ob_type == PyComplex_Type_p;
1166   }
1167
1168   PyObject * PyComplex_FromCComplex(Py_complex);
1169   PyObject * PyComplex_FromDoubles(double real_, double imag);
1170
1171   double PyComplex_RealAsDouble(PyObject *op);
1172   double PyComplex_ImagAsDouble(PyObject *op);
1173   Py_complex PyComplex_AsCComplex(PyObject *op);
1174
1175
1176 ///////////////////////////////////////////////////////////////////////////////
1177 // RANGE INTERFACE
1178 ///////////////////////////////////////////////////////////////////////////////
1179   // Python-header-file: Include/rangeobject.h:
1180
1181   // &PyRange_Type is accessible via PyRange_Type_p.
1182
1183   // D translation of C macro:
1184   int PyRange_Check(PyObject *op) {
1185     return op.ob_type == PyRange_Type_p;
1186   }
1187
1188   // Removed in 2.5
1189   version (Python_2_5_Or_Later) {
1190   } else {
1191     PyObject * PyRange_New(C_long, C_long, C_long, int);
1192   }
1193
1194
1195 ///////////////////////////////////////////////////////////////////////////////
1196 // STRING INTERFACE
1197 ///////////////////////////////////////////////////////////////////////////////
1198   // Python-header-file: Include/stringobject.h:
1199
1200   struct PyStringObject {
1201     mixin PyObject_VAR_HEAD;
1202
1203     C_long ob_shash;
1204     int ob_sstate;
1205     // DSR:XXX:LAYOUT:
1206     // Will the D layout for a 1-char array be the same as the C layout?  I
1207     // think the D array will be larger.
1208     char _ob_sval[1];
1209     char* ob_sval() {
1210         return _ob_sval.ptr;
1211     }
1212   }
1213
1214   // &PyBaseString_Type is accessible via PyBaseString_Type_p.
1215   // &PyString_Type is accessible via PyString_Type_p.
1216
1217   // D translation of C macro:
1218   int PyString_Check(PyObject *op) {
1219     return PyObject_TypeCheck(op, PyString_Type_p);
1220   }
1221   // D translation of C macro:
1222   int PyString_CheckExact(PyObject *op) {
1223     return op.ob_type == PyString_Type_p;
1224   }
1225
1226   PyObject * PyString_FromStringAndSize(c_str, Py_ssize_t);
1227   PyObject * PyString_FromString(c_str);
1228   // PyString_FromFormatV omitted
1229   PyObject * PyString_FromFormat(c_str, ...);
1230   Py_ssize_t PyString_Size(PyObject *);
1231   c_str PyString_AsString(PyObject *);
1232   /* Use only if you know it's a string */
1233   int PyString_CHECK_INTERNED(PyObject* op) {
1234     return (cast(PyStringObject*)op).ob_sstate;
1235   }
1236   /* Macro, trading safety for speed */
1237   c_str PyString_AS_STRING(PyObject* op) {
1238     return (cast(PyStringObject*)op).ob_sval;
1239   }
1240   Py_ssize_t PyString_GET_SIZE(PyObject* op) {
1241     return (cast(PyStringObject*)op).ob_size;
1242   }
1243   PyObject * PyString_Repr(PyObject *, int);
1244   void PyString_Concat(PyObject **, PyObject *);
1245   void PyString_ConcatAndDel(PyObject **, PyObject *);
1246   PyObject * PyString_Format(PyObject *, PyObject *);
1247   PyObject * PyString_DecodeEscape(char *, Py_ssize_t, char *, Py_ssize_t, char *);
1248
1249   void PyString_InternInPlace(PyObject **);
1250   void PyString_InternImmortal(PyObject **);
1251   PyObject * PyString_InternFromString(char *);
1252
1253   PyObject * _PyString_Join(PyObject *sep, PyObject *x);
1254
1255
1256   PyObject* PyString_Decode(c_str s, Py_ssize_t size, c_str encoding, c_str errors);
1257   PyObject* PyString_Encode(c_str s, Py_ssize_t size, c_str encoding, c_str errors);
1258
1259   PyObject* PyString_AsEncodedObject(PyObject *str, c_str encoding, c_str errors);
1260   PyObject* PyString_AsDecodedObject(PyObject *str, c_str encoding, c_str errors);
1261
1262   // Since no one has legacy Python extensions written in D, the deprecated
1263   // functions PyString_AsDecodedString and PyString_AsEncodedString were
1264   // omitted.
1265
1266   int PyString_AsStringAndSize(PyObject *obj, char **s, int *len);
1267
1268
1269 ///////////////////////////////////////////////////////////////////////////////
1270 // BUFFER INTERFACE
1271 ///////////////////////////////////////////////////////////////////////////////
1272   // Python-header-file: Include/bufferobject.h:
1273
1274   // &PyBuffer_Type is accessible via PyBuffer_Type_p.
1275
1276   // D translation of C macro:
1277   int PyBuffer_Check(PyObject *op) {
1278     return op.ob_type == PyBuffer_Type_p;
1279   }
1280
1281   const int Py_END_OF_BUFFER = -1;
1282
1283   PyObject * PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size);
1284   PyObject * PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size);
1285
1286   PyObject * PyBuffer_FromMemory(void *ptr, Py_ssize_t size);
1287   PyObject * PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size);
1288
1289   PyObject * PyBuffer_New(Py_ssize_t size);
1290
1291
1292 ///////////////////////////////////////////////////////////////////////////////
1293 // TUPLE INTERFACE
1294 ///////////////////////////////////////////////////////////////////////////////
1295   // Python-header-file: Include/tupleobject.h:
1296
1297   struct PyTupleObject {
1298     mixin PyObject_VAR_HEAD;
1299
1300     // DSR:XXX:LAYOUT:
1301     // Will the D layout for a 1-PyObject* array be the same as the C layout?
1302     // I think the D array will be larger.
1303     PyObject *_ob_item[1];
1304     PyObject** ob_item() {
1305       return _ob_item.ptr;
1306     }
1307   }
1308
1309   // &PyTuple_Type is accessible via PyTuple_Type_p.
1310
1311   // D translation of C macro:
1312   int PyTuple_Check(PyObject *op) {
1313     return PyObject_TypeCheck(op, PyTuple_Type_p);
1314   }
1315   // D translation of C macro:
1316   int PyTuple_CheckExact(PyObject *op) {
1317     return op.ob_type == PyTuple_Type_p;
1318   }
1319
1320   PyObject * PyTuple_New(Py_ssize_t size);
1321   Py_ssize_t PyTuple_Size(PyObject *);
1322   PyObject * PyTuple_GetItem(PyObject *, Py_ssize_t);
1323   int PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
1324   PyObject * PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
1325   int _PyTuple_Resize(PyObject **, Py_ssize_t);
1326   PyObject * PyTuple_Pack(Py_ssize_t, ...);
1327
1328   // D translations of C macros:
1329   // XXX: These do not work.
1330   PyObject *PyTuple_GET_ITEM(PyObject *op, Py_ssize_t i) {
1331     return (cast(PyTupleObject *) op).ob_item[i];
1332   }
1333   int PyTuple_GET_SIZE(PyObject *op) {
1334     return (cast(PyTupleObject *) op).ob_size;
1335   }
1336   PyObject *PyTuple_SET_ITEM(PyObject *op, Py_ssize_t i, PyObject *v) {
1337     PyTupleObject *opAsTuple = cast(PyTupleObject *) op;
1338     opAsTuple.ob_item[i] = v;
1339     return v;
1340   }
1341
1342
1343 ///////////////////////////////////////////////////////////////////////////////
1344 // LIST INTERFACE
1345 ///////////////////////////////////////////////////////////////////////////////
1346   // Python-header-file: Include/listobject.h:
1347
1348   struct PyListObject {
1349     mixin PyObject_VAR_HEAD;
1350
1351     PyObject **ob_item;
1352     Py_ssize_t allocated;
1353   }
1354
1355   // &PyList_Type is accessible via PyList_Type_p.
1356
1357   // D translation of C macro:
1358   int PyList_Check(PyObject *op) {
1359     return PyObject_TypeCheck(op, PyList_Type_p);
1360   }
1361   // D translation of C macro:
1362   int PyList_CheckExact(PyObject *op) {
1363     return op.ob_type == PyList_Type_p;
1364   }
1365
1366   PyObject * PyList_New(int size);
1367   Py_ssize_t PyList_Size(PyObject *);
1368
1369   PyObject * PyList_GetItem(PyObject *, Py_ssize_t);
1370   int PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
1371   int PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
1372   int PyList_Append(PyObject *, PyObject *);
1373   PyObject * PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
1374   int PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
1375   int PyList_Sort(PyObject *);
1376   int PyList_Reverse(PyObject *);
1377   PyObject * PyList_AsTuple(PyObject *);
1378
1379   // D translations of C macros:
1380   PyObject *PyList_GET_ITEM(PyObject *op, Py_ssize_t i) {
1381     return (cast(PyListObject *) op).ob_item[i];
1382   }
1383   void PyList_SET_ITEM(PyObject *op, Py_ssize_t i, PyObject *v) {
1384     (cast(PyListObject*)op).ob_item[i] = v;
1385   }
1386   int PyList_GET_SIZE(PyObject *op) {
1387     return (cast(PyListObject *) op).ob_size;
1388   }
1389
1390
1391 ///////////////////////////////////////////////////////////////////////////////
1392 // DICTIONARY OBJECT TYPE
1393 ///////////////////////////////////////////////////////////////////////////////
1394   // Python-header-file: Include/dictobject.h:
1395
1396   const int PyDict_MINSIZE = 8;
1397
1398   struct PyDictEntry {
1399     Py_ssize_t me_hash;
1400     PyObject *me_key;
1401     PyObject *me_value;
1402   }
1403
1404   struct _dictobject {
1405     mixin PyObject_HEAD;
1406
1407     Py_ssize_t ma_fill;
1408     Py_ssize_t ma_used;
1409     Py_ssize_t ma_mask;
1410     PyDictEntry *ma_table;
1411     PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, C_long hash);
1412     PyDictEntry ma_smalltable[PyDict_MINSIZE];
1413   }
1414   alias _dictobject PyDictObject;
1415
1416   // &PyDict_Type is accessible via PyDict_Type_p.
1417
1418   // D translation of C macro:
1419   int PyDict_Check(PyObject *op) {
1420     return PyObject_TypeCheck(op, PyDict_Type_p);
1421   }
1422   // D translation of C macro:
1423   int PyDict_CheckExact(PyObject *op) {
1424     return op.ob_type == PyDict_Type_p;
1425   }
1426
1427   PyObject * PyDict_New();
1428   PyObject * PyDict_GetItem(PyObject *mp, PyObject *key);
1429   int PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
1430   int PyDict_DelItem(PyObject *mp, PyObject *key);
1431   void PyDict_Clear(PyObject *mp);
1432   int PyDict_Next(PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
1433   PyObject * PyDict_Keys(PyObject *mp);
1434   PyObject * PyDict_Values(PyObject *mp);
1435   PyObject * PyDict_Items(PyObject *mp);
1436   Py_ssize_t PyDict_Size(PyObject *mp);
1437   PyObject * PyDict_Copy(PyObject *mp);
1438   int PyDict_Contains(PyObject *mp, PyObject *key);
1439
1440   int PyDict_Update(PyObject *mp, PyObject *other);
1441   int PyDict_Merge(PyObject *mp, PyObject *other, int override_);
1442   int PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override_);
1443
1444   PyObject * PyDict_GetItemString(PyObject *dp, c_str key);
1445   int PyDict_SetItemString(PyObject *dp, c_str key, PyObject *item);
1446   int PyDict_DelItemString(PyObject *dp, c_str key);
1447
1448
1449 ///////////////////////////////////////////////////////////////////////////////
1450 // PYTHON EXTENSION FUNCTION INTERFACE
1451 ///////////////////////////////////////////////////////////////////////////////
1452   // Python-header-file: Include/methodobject.h:
1453
1454   // &PyCFunction_Type is accessible via PyCFunction_Type_p.
1455
1456   // D translation of C macro:
1457   int PyCFunction_Check(PyObject *op) {
1458     return op.ob_type == PyCFunction_Type_p;
1459   }
1460
1461   alias PyObject *(*PyCFunction)(PyObject *, PyObject *);
1462   alias PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,PyObject *);
1463   alias PyObject *(*PyNoArgsFunction)(PyObject *);
1464
1465   PyCFunction PyCFunction_GetFunction(PyObject *);
1466   PyObject * PyCFunction_GetSelf(PyObject *);
1467   int PyCFunction_GetFlags(PyObject *);
1468
1469   PyObject * PyCFunction_Call(PyObject *, PyObject *, PyObject *);
1470
1471   struct PyMethodDef {
1472     c_str    ml_name;
1473     PyCFunction  ml_meth;
1474     int      ml_flags;
1475     c_str    ml_doc;
1476   }
1477
1478   PyObject * Py_FindMethod(PyMethodDef[], PyObject *, c_str);
1479   PyObject * PyCFunction_NewEx(PyMethodDef *, PyObject *,PyObject *);
1480   PyObject * PyCFunction_New(PyMethodDef* ml, PyObject* self) {
1481     return PyCFunction_NewEx(ml, self, null);
1482   }
1483
1484   const int METH_OLDARGS = 0x0000;
1485   const int METH_VARARGS = 0x0001;
1486   const int METH_KEYWORDS= 0x0002;
1487   const int METH_NOARGS  = 0x0004;
1488   const int METH_O       = 0x0008;
1489   const int METH_CLASS   = 0x0010;
1490   const int METH_STATIC  = 0x0020;
1491   const int METH_COEXIST = 0x0040;
1492
1493   struct PyMethodChain {
1494     PyMethodDef *methods;
1495     PyMethodChain *link;
1496   }
1497
1498   PyObject * Py_FindMethodInChain(PyMethodChain *, PyObject *, c_str);
1499
1500   struct PyCFunctionObject {
1501     mixin PyObject_HEAD;
1502
1503     PyMethodDef *m_ml;
1504     PyObject    *m_self;
1505     PyObject    *m_module;
1506   }
1507
1508
1509 ///////////////////////////////////////////////////////////////////////////////
1510 // MODULE INTERFACE
1511 ///////////////////////////////////////////////////////////////////////////////
1512   // Python-header-file: Include/moduleobject.h:
1513
1514   // &PyModule_Type is accessible via PyModule_Type_p.
1515
1516   // D translation of C macro:
1517   int PyModule_Check(PyObject *op) {
1518     return PyObject_TypeCheck(op, PyModule_Type_p);
1519   }
1520   // D translation of C macro:
1521   int PyModule_CheckExact(PyObject *op) {
1522     return op.ob_type == PyModule_Type_p;
1523   }
1524
1525   PyObject * PyModule_New(c_str);
1526   PyObject * PyModule_GetDict(PyObject *);
1527   c_str PyModule_GetName(PyObject *);
1528   c_str PyModule_GetFilename(PyObject *);
1529   version (Python_2_5_Or_Later) {
1530       void _PyModule_Clear(PyObject *);
1531   }
1532
1533   // Python-header-file: Include/modsupport.h:
1534
1535   version (Python_2_5_Or_Later) {
1536     const int PYTHON_API_VERSION = 1013;
1537     const char[] PYTHON_API_STRING = "1013";
1538   } else {
1539     const int PYTHON_API_VERSION = 1012;
1540     const char[] PYTHON_API_STRING = "1012";
1541   }
1542
1543   int PyArg_Parse(PyObject *, c_str, ...);
1544   int PyArg_ParseTuple(PyObject *, c_str, ...);
1545   int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
1546                             c_str, char **, ...);
1547   int PyArg_UnpackTuple(PyObject *, c_str, Py_ssize_t, Py_ssize_t, ...);
1548   PyObject * Py_BuildValue(c_str, ...);
1549
1550   int PyModule_AddObject(PyObject *, c_str, PyObject *);
1551   int PyModule_AddIntConstant(PyObject *, c_str, C_long);
1552   int PyModule_AddStringConstant(PyObject *, c_str, c_str);
1553
1554   PyObject * Py_InitModule4(c_str name, PyMethodDef *methods, c_str doc,
1555                             PyObject *self, int apiver);
1556
1557   PyObject * Py_InitModule(c_str name, PyMethodDef *methods)
1558   {
1559     return Py_InitModule4(name, methods, cast(c_str)(null),
1560       cast(PyObject *)(null), PYTHON_API_VERSION);
1561   }
1562
1563   PyObject * Py_InitModule3(c_str name, PyMethodDef *methods, c_str doc) {
1564     return Py_InitModule4(name, methods, doc, cast(PyObject *)null,
1565       PYTHON_API_VERSION);
1566   }
1567
1568
1569 ///////////////////////////////////////////////////////////////////////////////
1570 // PYTHON FUNCTION INTERFACE (to functions created by the 'def' statement)
1571 ///////////////////////////////////////////////////////////////////////////////
1572   // Python-header-file: Include/funcobject.h:
1573
1574   struct PyFunctionObject {
1575     mixin PyObject_HEAD;
1576
1577     PyObject *func_code;
1578     PyObject *func_globals;
1579     PyObject *func_defaults;
1580     PyObject *func_closure;
1581     PyObject *func_doc;
1582     PyObject *func_name;
1583     PyObject *func_dict;
1584     PyObject *func_weakreflist;
1585     PyObject *func_module;
1586   }
1587
1588   // &PyFunction_Type is accessible via PyFunction_Type_p.
1589
1590   // D translation of C macro:
1591   int PyFunction_Check(PyObject *op) {
1592     return op.ob_type == PyFunction_Type_p;
1593   }
1594
1595   PyObject * PyFunction_New(PyObject *, PyObject *);
1596   PyObject * PyFunction_GetCode(PyObject *);
1597   PyObject * PyFunction_GetGlobals(PyObject *);
1598   PyObject * PyFunction_GetModule(PyObject *);
1599   PyObject * PyFunction_GetDefaults(PyObject *);
1600   int PyFunction_SetDefaults(PyObject *, PyObject *);
1601   PyObject * PyFunction_GetClosure(PyObject *);
1602   int PyFunction_SetClosure(PyObject *, PyObject *);
1603
1604   // These are not present in the 2.4 API, but do no harm in it, either.
1605   PyObject* PyFunction_GET_CODE(PyObject* func) {
1606     return (cast(PyFunctionObject*)func).func_code;
1607   }
1608   PyObject* PyFunction_GET_GLOBALS(PyObject* func) {
1609     return (cast(PyFunctionObject*)func).func_globals;
1610   }
1611   PyObject* PyFunction_GET_MODULE(PyObject* func) {
1612     return (cast(PyFunctionObject*)func).func_module;
1613   }
1614   PyObject* PyFunction_GET_DEFAULTS(PyObject* func) {
1615     return (cast(PyFunctionObject*)func).func_defaults;
1616   }
1617   PyObject* PyFunction_GET_CLOSURE(PyObject* func) {
1618     return (cast(PyFunctionObject*)func).func_closure;
1619   }
1620
1621   // &PyClassMethod_Type is accessible via PyClassMethod_Type_p.
1622   // &PyStaticMethod_Type is accessible via PyStaticMethod_Type_p.
1623
1624   PyObject * PyClassMethod_New(PyObject *);
1625   PyObject * PyStaticMethod_New(PyObject *);
1626
1627
1628 ///////////////////////////////////////////////////////////////////////////////
1629 // PYTHON CLASS INTERFACE
1630 ///////////////////////////////////////////////////////////////////////////////
1631   // Python-header-file: Include/classobject.h:
1632
1633   struct PyClassObject {
1634     mixin PyObject_HEAD;
1635
1636     PyObject    *cl_bases;  /* A tuple of class objects */
1637     PyObject    *cl_dict;   /* A dictionary */
1638     PyObject    *cl_name;   /* A string */
1639     /* The following three are functions or null */
1640     PyObject    *cl_getattr;
1641     PyObject    *cl_setattr;
1642     PyObject    *cl_delattr;
1643   }
1644
1645   struct PyInstanceObject {
1646     mixin PyObject_HEAD;
1647
1648     PyClassObject *in_class;
1649     PyObject      *in_dict;
1650     PyObject      *in_weakreflist;
1651   }
1652
1653   struct PyMethodObject {
1654     mixin PyObject_HEAD;
1655
1656     PyObject *im_func;
1657     PyObject *im_self;
1658     PyObject *im_class;
1659     PyObject *im_weakreflist;
1660   }
1661
1662   // &PyClass_Type is accessible via PyClass_Type_p.
1663   // D translation of C macro:
1664   int PyClass_Check(PyObject *op) {
1665     return op.ob_type == PyClass_Type_p;
1666   }
1667
1668   // &PyInstance_Type is accessible via PyInstance_Type_p.
1669   // D translation of C macro:
1670   int PyInstance_Check(PyObject *op) {
1671     return op.ob_type == PyInstance_Type_p;
1672   }
1673
1674   // &PyMethod_Type is accessible via PyMethod_Type_p.
1675   // D translation of C macro:
1676   int PyMethod_Check(PyObject *op) {
1677     return op.ob_type == PyMethod_Type_p;
1678   }
1679
1680   PyObject * PyClass_New(PyObject *, PyObject *, PyObject *);
1681   PyObject * PyInstance_New(PyObject *, PyObject *,
1682                         PyObject *);
1683   PyObject * PyInstance_NewRaw(PyObject *, PyObject *);
1684   PyObject * PyMethod_New(PyObject *, PyObject *, PyObject *);
1685
1686   PyObject * PyMethod_Function(PyObject *);
1687   PyObject * PyMethod_Self(PyObject *);
1688   PyObject * PyMethod_Class(PyObject *);
1689
1690   PyObject * _PyInstance_Lookup(PyObject *pinst, PyObject *name);
1691
1692   // These are not present in the 2.4 API, but do no harm in it, either.
1693   PyObject * PyMethod_GET_FUNCTION(PyObject* meth) {
1694     return (cast(PyMethodObject*)meth).im_func;
1695   }
1696   PyObject * PyMethod_GET_SELF(PyObject* meth) {
1697     return (cast(PyMethodObject*)meth).im_self;
1698   }
1699   PyObject * PyMethod_GET_CLASS(PyObject* meth) {
1700     return (cast(PyMethodObject*)meth).im_class;
1701   }
1702
1703   int PyClass_IsSubclass(PyObject *, PyObject *);
1704
1705
1706 ///////////////////////////////////////////////////////////////////////////////
1707 // FILE INTERFACE
1708 ///////////////////////////////////////////////////////////////////////////////
1709   // Python-header-file: Include/fileobject.h:
1710
1711   struct PyFileObject {
1712     mixin PyObject_HEAD;
1713
1714     FILE *f_fp;
1715     PyObject *f_name;
1716     PyObject *f_mode;
1717     int (*f_close)(FILE *);
1718     int f_softspace;
1719     int f_binary;
1720     char* f_buf;
1721     char* f_bufend;
1722     char* f_bufptr;
1723     char *f_setbuf;
1724     int f_univ_newline;
1725     int f_newlinetypes;
1726     int f_skipnextlf;
1727     PyObject *f_encoding;
1728     PyObject *weakreflist;
1729   }
1730
1731   // &PyFile_Type is accessible via PyFile_Type_p.
1732   // D translation of C macro:
1733   int PyFile_Check(PyObject *op) {
1734     return PyObject_TypeCheck(op, PyFile_Type_p);
1735   }
1736   // D translation of C macro:
1737   int PyFile_CheckExact(PyObject *op) {
1738     return op.ob_type == PyFile_Type_p;
1739   }
1740
1741   PyObject * PyFile_FromString(char *, char *);
1742   void PyFile_SetBufSize(PyObject *, int);
1743   int PyFile_SetEncoding(PyObject *,  c_str);
1744   PyObject * PyFile_FromFile(FILE *, char *, char *,
1745                          int (*)(FILE *));
1746   FILE * PyFile_AsFile(PyObject *);
1747   PyObject * PyFile_Name(PyObject *);
1748   PyObject * PyFile_GetLine(PyObject *, int);
1749   int PyFile_WriteObject(PyObject *, PyObject *, int);
1750   int PyFile_SoftSpace(PyObject *, int);
1751   int PyFile_WriteString(c_str, PyObject *);
1752   int PyObject_AsFileDescriptor(PyObject *);
1753
1754   // We deal with char *Py_FileSystemDefaultEncoding in the global variables
1755   // section toward the bottom of this file.
1756
1757   const char[] PY_STDIOTEXTMODE = "b";
1758
1759   char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
1760   size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);
1761
1762
1763 ///////////////////////////////////////////////////////////////////////////////
1764 // COBJECT INTERFACE
1765 ///////////////////////////////////////////////////////////////////////////////
1766   // Python-header-file: Include/cobject.h:
1767
1768   // PyCObject_Type is a Python type for transporting an arbitrary C pointer
1769   // from the C level to Python and back (in essence, an opaque handle).
1770
1771   // &PyCObject_Type is accessible via PyCObject_Type_p.
1772   // D translation of C macro:
1773   int PyCObject_Check(PyObject *op) {
1774     return op.ob_type == PyCObject_Type_p;
1775   }
1776
1777   PyObject * PyCObject_FromVoidPtr(void *cobj, void (*destruct)(void*));
1778   PyObject * PyCObject_FromVoidPtrAndDesc(void *cobj, void *desc,
1779     void (*destruct)(void*,void*));
1780   void * PyCObject_AsVoidPtr(PyObject *);
1781   void * PyCObject_GetDesc(PyObject *);
1782   void * PyCObject_Import(c_str module_name, c_str cobject_name);
1783   int PyCObject_SetVoidPtr(PyObject *self, void *cobj);
1784
1785
1786 ///////////////////////////////////////////////////////////////////////////////////////////////
1787 // TRACEBACK INTERFACE
1788 ///////////////////////////////////////////////////////////////////////////////////////////////
1789   // Python-header-file: Include/traceback.h:
1790
1791   struct PyTracebackObject {
1792     mixin PyObject_HEAD;
1793
1794     PyTracebackObject *tb_next;
1795     PyFrameObject *tb_frame;
1796     int tb_lasti;
1797     int tb_lineno;
1798   }
1799
1800   int PyTraceBack_Here(PyFrameObject *);
1801   int PyTraceBack_Print(PyObject *, PyObject *);
1802
1803   // &PyTraceBack_Type is accessible via PyTraceBack_Type_p.
1804   // D translation of C macro:
1805   int PyTraceBack_Check(PyObject *v) {
1806     return v.ob_type == PyTraceBack_Type_p;
1807   }
1808
1809
1810 ///////////////////////////////////////////////////////////////////////////////
1811 // SLICE INTERFACE
1812 ///////////////////////////////////////////////////////////////////////////////
1813   // Python-header-file: Include/sliceobject.h:
1814
1815   // We deal with Py_Ellipsis in the global variables section toward the bottom
1816   // of this file.
1817
1818   struct PySliceObject {
1819     mixin PyObject_HEAD;
1820
1821     PyObject *start;
1822     PyObject *stop;
1823     PyObject *step;
1824   }
1825
1826   // &PySlice_Type is accessible via PySlice_Type_p.
1827   // D translation of C macro:
1828   int PySlice_Check(PyObject *op) {
1829     return op.ob_type == PySlice_Type_p;
1830   }
1831
1832   PyObject * PySlice_New(PyObject *start, PyObject *stop, PyObject *step);
1833   int PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
1834                 Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
1835   int PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
1836                 Py_ssize_t *start, Py_ssize_t *stop,
1837                 Py_ssize_t *step, Py_ssize_t *slicelength);
1838
1839
1840 ///////////////////////////////////////////////////////////////////////////////
1841 // CELL INTERFACE
1842 ///////////////////////////////////////////////////////////////////////////////
1843   // Python-header-file: Include/cellobject.h:
1844
1845   struct PyCellObject {
1846     mixin PyObject_HEAD;
1847
1848     PyObject *ob_ref;
1849   }
1850
1851   // &PyCell_Type is accessible via PyCell_Type_p.
1852   // D translation of C macro:
1853   int PyCell_Check(PyObject *op) {
1854     return op.ob_type == PyCell_Type_p;
1855   }
1856
1857   PyObject * PyCell_New(PyObject *);
1858   PyObject * PyCell_Get(PyObject *);
1859   int PyCell_Set(PyObject *, PyObject *);
1860
1861
1862 ///////////////////////////////////////////////////////////////////////////////
1863 // ITERATOR INTERFACE
1864 ///////////////////////////////////////////////////////////////////////////////
1865   // Python-header-file: Include/iterobject.h:
1866
1867   // &PySeqIter_Type is accessible via PySeqIter_Type_p.
1868   // D translation of C macro:
1869   int PySeqIter_Check(PyObject *op) {
1870     return op.ob_type == PySeqIter_Type_p;
1871   }
1872
1873   PyObject * PySeqIter_New(PyObject *);
1874
1875   // &PyCallIter_Type is accessible via PyCallIter_Type_p.
1876   // D translation of C macro:
1877   int PyCallIter_Check(PyObject *op) {
1878     return op.ob_type == PyCallIter_Type_p;
1879   }
1880
1881   PyObject * PyCallIter_New(PyObject *, PyObject *);
1882
1883
1884 ///////////////////////////////////////////////////////////////////////////////
1885 // DESCRIPTOR INTERFACE
1886 ///////////////////////////////////////////////////////////////////////////////
1887   // Python-header-file: Include/descrobject.h:
1888
1889   alias PyObject *(*getter)(PyObject *, void *);
1890   alias int (*setter)(PyObject *, PyObject *, void *);
1891
1892   struct PyGetSetDef {
1893     char *name;
1894     getter get;
1895     setter set;
1896     char *doc;
1897     void *closure;
1898   }
1899
1900   alias PyObject *(*wrapperfunc)(PyObject *, PyObject *, void *);
1901   alias PyObject *(*wrapperfunc_kwds)(PyObject *, PyObject *, void *, PyObject *);
1902
1903   struct wrapperbase {
1904     char *name;
1905     int offset;
1906     void *function_;
1907     wrapperfunc wrapper;
1908     char *doc;
1909     int flags;
1910     PyObject *name_strobj;
1911   }
1912
1913   const int PyWrapperFlag_KEYWORDS = 1;
1914
1915   template PyDescr_COMMON() {
1916     mixin PyObject_HEAD;
1917     PyTypeObject *d_type;
1918     PyObject *d_name;
1919   }
1920
1921   struct PyDescrObject {
1922     mixin PyDescr_COMMON;
1923   }
1924
1925   struct PyMethodDescrObject {
1926     mixin PyDescr_COMMON;
1927     PyMethodDef *d_method;
1928   }
1929
1930   struct PyMemberDescrObject {
1931     mixin PyDescr_COMMON;
1932     PyMemberDef *d_member;
1933   }
1934
1935   struct PyGetSetDescrObject {
1936     mixin PyDescr_COMMON;
1937     PyGetSetDef *d_getset;
1938   }
1939
1940   struct PyWrapperDescrObject {
1941     mixin PyDescr_COMMON;
1942     wrapperbase *d_base;
1943     void *d_wrapped;
1944   }
1945
1946   // PyWrapperDescr_Type is currently not accessible from D.
1947
1948   PyObject * PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
1949   PyObject * PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
1950   PyObject * PyDescr_NewMember(PyTypeObject *, PyMemberDef *);
1951   PyObject * PyDescr_NewGetSet(PyTypeObject *, PyGetSetDef *);
1952   PyObject * PyDescr_NewWrapper(PyTypeObject *, wrapperbase *, void *);
1953   PyObject * PyDictProxy_New(PyObject *);
1954   PyObject * PyWrapper_New(PyObject *, PyObject *);
1955
1956   // &PyProperty_Type is accessible via PyProperty_Type_p.
1957
1958
1959 ///////////////////////////////////////////////////////////////////////////////
1960 // WEAK REFERENCE INTERFACE
1961 ///////////////////////////////////////////////////////////////////////////////
1962   // Python-header-file: Include/weakrefobject.h:
1963
1964   struct PyWeakReference {
1965     mixin PyObject_HEAD;
1966
1967     PyObject *wr_object;
1968     PyObject *wr_callback;
1969     C_long hash;
1970     PyWeakReference *wr_prev;
1971     PyWeakReference *wr_next;
1972   }
1973
1974   // &_PyWeakref_RefType is accessible via _PyWeakref_RefType_p.
1975   // &_PyWeakref_ProxyType is accessible via _PyWeakref_ProxyType_p.
1976   // &_PyWeakref_CallableProxyType is accessible via _PyWeakref_CallableProxyType_p.
1977
1978   // D translations of C macros:
1979   int PyWeakref_CheckRef(PyObject *op) {
1980     return PyObject_TypeCheck(op, _PyWeakref_RefType_p);
1981   }
1982   int PyWeakref_CheckRefExact(PyObject *op) {
1983     return op.ob_type == _PyWeakref_RefType_p;
1984   }
1985   int PyWeakref_CheckProxy(PyObject *op) {
1986     return op.ob_type == _PyWeakref_ProxyType_p
1987         || op.ob_type == _PyWeakref_CallableProxyType_p;
1988   }
1989   int PyWeakref_Check(PyObject *op) {
1990     return PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op);
1991   }
1992
1993   PyObject * PyWeakref_NewRef(PyObject *ob, PyObject *callback);
1994   PyObject * PyWeakref_NewProxy(PyObject *ob, PyObject *callback);
1995   PyObject * PyWeakref_GetObject(PyObject *ref_);
1996
1997   Py_ssize_t _PyWeakref_GetWeakrefCount(PyWeakReference *head);
1998   void _PyWeakref_ClearRef(PyWeakReference *self);
1999
2000   PyObject *PyWeakref_GET_OBJECT(PyObject *ref_) {
2001     return (cast(PyWeakReference *) ref_).wr_object;
2002   }
2003
2004
2005 ///////////////////////////////////////////////////////////////////////////////
2006 // CODEC REGISTRY AND SUPPORT INTERFACE
2007 ///////////////////////////////////////////////////////////////////////////////
2008   // Python-header-file: Include/codecs.h:
2009
2010   int PyCodec_Register(PyObject *search_function);
2011   PyObject * _PyCodec_Lookup(c_str encoding);
2012   PyObject * PyCodec_Encode(PyObject *object, c_str encoding, c_str errors);
2013   PyObject * PyCodec_Decode(PyObject *object, c_str encoding, c_str errors);
2014   PyObject * PyCodec_Encoder(c_str encoding);
2015   PyObject * PyCodec_Decoder(c_str encoding);
2016   PyObject * PyCodec_StreamReader(c_str encoding, PyObject *stream, c_str errors);
2017   PyObject * PyCodec_StreamWriter(c_str encoding, PyObject *stream, c_str errors);
2018
2019   /////////////////////////////////////////////////////////////////////////////
2020   // UNICODE ENCODING INTERFACE
2021   /////////////////////////////////////////////////////////////////////////////
2022
2023   int PyCodec_RegisterError(c_str name, PyObject *error);
2024   PyObject * PyCodec_LookupError(c_str name);
2025   PyObject * PyCodec_StrictErrors(PyObject *exc);
2026   PyObject * PyCodec_IgnoreErrors(PyObject *exc);
2027   PyObject * PyCodec_ReplaceErrors(PyObject *exc);
2028   PyObject * PyCodec_XMLCharRefReplaceErrors(PyObject *exc);
2029   PyObject * PyCodec_BackslashReplaceErrors(PyObject *exc);
2030
2031
2032 ///////////////////////////////////////////////////////////////////////////////
2033 // ERROR HANDLING INTERFACE
2034 ///////////////////////////////////////////////////////////////////////////////
2035   // Python-header-file: Include/pyerrors.h:
2036
2037   /* Error objects */
2038   version (Python_2_5_Or_Later) {
2039   struct PyBaseExceptionObject {
2040       mixin PyObject_HEAD;
2041       PyObject *dict;
2042       PyObject *args;
2043       PyObject *message;
2044   }
2045
2046   struct PySyntaxErrorObject {
2047       mixin PyObject_HEAD;
2048       PyObject *dict;
2049       PyObject *args;
2050       PyObject *message;
2051       PyObject *msg;
2052       PyObject *filename;
2053       PyObject *lineno;
2054       PyObject *offset;
2055       PyObject *text;
2056       PyObject *print_file_and_line;
2057   }
2058
2059   struct PyUnicodeErrorObject {
2060       mixin PyObject_HEAD;
2061       PyObject *dict;
2062       PyObject *args;
2063       PyObject *message;
2064       PyObject *encoding;
2065       PyObject *object;
2066       PyObject *start;
2067       PyObject *end;
2068       PyObject *reason;
2069   }
2070
2071   struct PySystemExitObject {
2072       mixin PyObject_HEAD;
2073       PyObject *dict;
2074       PyObject *args;
2075       PyObject *message;
2076       PyObject *code;
2077   }
2078
2079   struct PyEnvironmentErrorObject {
2080       mixin PyObject_HEAD;
2081       PyObject *dict;
2082       PyObject *args;
2083       PyObject *message;
2084       PyObject *myerrno;
2085       PyObject *strerror;
2086       PyObject *filename;
2087   }
2088
2089   version(Windows) {
2090     struct PyWindowsErrorObject {
2091         mixin PyObject_HEAD;
2092         PyObject *dict;
2093         PyObject *args;
2094         PyObject *message;
2095         PyObject *myerrno;
2096         PyObject *strerror;
2097         PyObject *filename;
2098         PyObject *winerror;
2099     }
2100   }
2101   } /*Python_2_5_Or_Later*/
2102
2103   void PyErr_SetNone(PyObject *);
2104   void PyErr_SetObject(PyObject *, PyObject *);
2105   void PyErr_SetString(PyObject *, c_str);
2106   PyObject * PyErr_Occurred();
2107   void PyErr_Clear();
2108   void PyErr_Fetch(PyObject **, PyObject **, PyObject **);
2109   void PyErr_Restore(PyObject *, PyObject *, PyObject *);
2110
2111   int PyErr_GivenExceptionMatches(PyObject *, PyObject *);
2112   int PyErr_ExceptionMatches(PyObject *);
2113   void PyErr_NormalizeException(PyObject **, PyObject **, PyObject **);
2114
2115   // All predefined Python exception types are dealt with in the global
2116   // variables section toward the end of this file.
2117
2118   int PyErr_BadArgument();
2119   PyObject * PyErr_NoMemory();
2120   PyObject * PyErr_SetFromErrno(PyObject *);
2121   PyObject * PyErr_SetFromErrnoWithFilenameObject(PyObject *, PyObject *);
2122   PyObject * PyErr_SetFromErrnoWithFilename(PyObject *, char *);
2123   PyObject * PyErr_SetFromErrnoWithUnicodeFilename(PyObject *, Py_UNICODE *);
2124
2125   PyObject * PyErr_Format(PyObject *, c_str, ...);
2126
2127   version (Windows) {
2128     PyObject * PyErr_SetFromWindowsErrWithFilenameObject(int,  c_str);
2129     PyObject * PyErr_SetFromWindowsErrWithFilename(int, c_str);
2130     PyObject * PyErr_SetFromWindowsErrWithUnicodeFilename(int, Py_UNICODE *);
2131     PyObject * PyErr_SetFromWindowsErr(int);
2132     PyObject * PyErr_SetExcFromWindowsErrWithFilenameObject(PyObject *, int, PyObject *);
2133     PyObject * PyErr_SetExcFromWindowsErrWithFilename(PyObject *, int,  c_str);
2134     PyObject * PyErr_SetExcFromWindowsErrWithUnicodeFilename(PyObject *, int, Py_UNICODE *);
2135     PyObject * PyErr_SetExcFromWindowsErr(PyObject *, int);
2136   }
2137
2138   // PyErr_BadInternalCall and friends purposely omitted.
2139
2140   PyObject * PyErr_NewException(char *name, PyObject *base, PyObject *dict);
2141   void PyErr_WriteUnraisable(PyObject *);
2142
2143   version (Python_2_5_Or_Later) {
2144       int PyErr_WarnEx(PyObject*, c_str, Py_ssize_t);
2145   } else {
2146       int PyErr_Warn(PyObject *, char *);
2147   }
2148   int PyErr_WarnExplicit(PyObject *, c_str, c_str, int, c_str, PyObject *);
2149
2150   int PyErr_CheckSignals();
2151   void PyErr_SetInterrupt();
2152
2153   void PyErr_SyntaxLocation(c_str, int);
2154   PyObject * PyErr_ProgramText(c_str, int);
2155
2156   /////////////////////////////////////////////////////////////////////////////
2157   // UNICODE ENCODING ERROR HANDLING INTERFACE
2158   /////////////////////////////////////////////////////////////////////////////
2159   PyObject *PyUnicodeDecodeError_Create(c_str, c_str, Py_ssize_t, Py_ssize_t, Py_ssize_t, c_str);
2160
2161   PyObject *PyUnicodeEncodeError_Create(c_str, Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, c_str);
2162
2163   PyObject *PyUnicodeTranslateError_Create(Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, c_str);
2164
2165   PyObject *PyUnicodeEncodeError_GetEncoding(PyObject *);
2166   PyObject *PyUnicodeDecodeError_GetEncoding(PyObject *);
2167
2168   PyObject *PyUnicodeEncodeError_GetObject(PyObject *);
2169   PyObject *PyUnicodeDecodeError_GetObject(PyObject *);
2170   PyObject *PyUnicodeTranslateError_GetObject(PyObject *);
2171
2172   int PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
2173   int PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
2174   int PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
2175
2176   int PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
2177   int PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
2178   int PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
2179
2180   int PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
2181   int PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
2182   int PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
2183
2184   int PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
2185   int PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
2186   int PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
2187
2188   PyObject *PyUnicodeEncodeError_GetReason(PyObject *);
2189   PyObject *PyUnicodeDecodeError_GetReason(PyObject *);
2190   PyObject *PyUnicodeTranslateError_GetReason(PyObject *);
2191
2192   int PyUnicodeEncodeError_SetReason(PyObject *, c_str);
2193   int PyUnicodeDecodeError_SetReason(PyObject *, c_str);
2194   int PyUnicodeTranslateError_SetReason(PyObject *, c_str);
2195
2196   int PyOS_snprintf(char *str, size_t size, c_str format, ...);
2197
2198
2199 ///////////////////////////////////////////////////////////////////////////////
2200 // BYTECODE INTERFACE
2201 ///////////////////////////////////////////////////////////////////////////////
2202   // Python-header-file: Include/code.h:
2203
2204   struct PyCodeObject { /* Bytecode object */
2205     mixin PyObject_HEAD;
2206
2207     int co_argcount;
2208     int co_nlocals;
2209     int co_stacksize;
2210     int co_flags;
2211     PyObject *co_code;
2212     PyObject *co_consts;
2213     PyObject *co_names;
2214     PyObject *co_varnames;
2215     PyObject *co_freevars;
2216     PyObject *co_cellvars;
2217
2218     PyObject *co_filename;
2219     PyObject *co_name;
2220     int co_firstlineno;
2221     PyObject *co_lnotab;
2222     version (Python_2_5_Or_Later) {
2223         void *co_zombieframe;
2224     }
2225   }
2226
2227   /* Masks for co_flags above */
2228   const int CO_OPTIMIZED   = 0x0001;
2229   const int CO_NEWLOCALS   = 0x0002;
2230   const int CO_VARARGS     = 0x0004;
2231   const int CO_VARKEYWORDS = 0x0008;
2232   const int CO_NESTED      = 0x0010;
2233   const int CO_GENERATOR   = 0x0020;
2234   const int CO_NOFREE      = 0x0040;
2235
2236   const int CO_FUTURE_DIVISION        = 0x2000;
2237   version (Python_2_5_Or_Later) {
2238       const int CO_FUTURE_ABSOLUTE_IMPORT = 0x4000;
2239       const int CO_FUTURE_WITH_STATEMENT  = 0x8000;
2240   } else {
2241       const int CO_GENERATOR_ALLOWED      = 0x1000;
2242   }
2243
2244   const int CO_MAXBLOCKS = 20;
2245
2246   // &PyCode_Type is accessible via PyCode_Type_p.
2247   // D translations of C macros:
2248   int PyCode_Check(PyObject *op) {
2249     return op.ob_type == PyCode_Type_p;
2250   }
2251   int PyCode_GetNumFree(PyObject *op) {
2252     return PyObject_Length((cast(PyCodeObject *) op).co_freevars);
2253   }
2254
2255   version (Python_2_5_Or_Later) {
2256       struct PyAddrPair {
2257         int ap_lower;
2258         int ap_upper;
2259       }
2260
2261       int PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds);
2262
2263       // Python-header-file: Include/pyarena.h:
2264       struct PyArena;
2265
2266       PyArena* PyArena_New();
2267       void PyArena_Free(PyArena*);
2268
2269       void* PyArena_Malloc(PyArena*, size_t);
2270       int PyArena_AddPyObject(PyArena*, PyObject*);
2271   }
2272
2273 ///////////////////////////////////////////////////////////////////////////////
2274 // COMPILATION INTERFACE
2275 ///////////////////////////////////////////////////////////////////////////////
2276   // Python-header-file: Include/node.h
2277   struct node {
2278     short   n_type;
2279     char    *n_str;
2280     int     n_lineno;
2281     version (Python_2_5_Or_Later) {
2282         int n_col_offset;
2283     }
2284     int     n_nchildren;
2285     node    *n_child;
2286   }
2287   version (Python_2_5_Or_Later) {
2288       node * PyNode_New(int type);
2289       int PyNode_AddChild(node *n, int type,
2290             char *str, int lineno, int col_offset);
2291       void PyNode_Free(node *n);
2292       void PyNode_ListTree(node *);
2293   }
2294
2295   // Python-header-file: Include/compile.h:
2296   PyCodeObject *PyNode_Compile(node *, c_str);
2297   PyCodeObject *PyCode_New(
2298     int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
2299     PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *);
2300   int PyCode_Addr2Line(PyCodeObject *, int);
2301
2302
2303   struct PyFutureFeatures {
2304     version (Python_2_5_Or_Later) {} else {
2305         int ff_found_docstring;
2306         int ff_last_lineno;
2307     }
2308     int ff_features;
2309     version (Python_2_5_Or_Later) {
2310         int ff_lineno;
2311     }
2312   }
2313
2314   version (Python_2_5_Or_Later) {} else {
2315       PyFutureFeatures *PyNode_Future(node *, c_str);
2316       PyCodeObject *PyNode_CompileFlags(node *, c_str, PyCompilerFlags *);
2317   }
2318
2319   const char[] FUTURE_NESTED_SCOPES = "nested_scopes";
2320   const char[] FUTURE_GENERATORS = "generators";
2321   const char[] FUTURE_DIVISION = "division";
2322   version (Python_2_5_Or_Later) {
2323       const char[] FUTURE_ABSOLUTE_IMPORT = "absolute_import";
2324       const char[] FUTURE_WITH_STATEMENT = "with_statement";
2325
2326       struct _mod; /* Declare the existence of this type */
2327       PyCodeObject * PyAST_Compile(_mod *, c_str, PyCompilerFlags *, PyArena *);
2328       PyFutureFeatures * PyFuture_FromAST(_mod *, c_str);
2329
2330       // Python-header-file: Include/ast.h
2331       _mod* PyAST_FromNode(node*, PyCompilerFlags*, c_str, PyArena*);
2332   }
2333
2334 ///////////////////////////////////////////////////////////////////////////////
2335 // CODE EXECUTION INTERFACE
2336 ///////////////////////////////////////////////////////////////////////////////
2337   // Python-header-file: Include/pythonrun.h:
2338
2339   struct PyCompilerFlags {
2340     int cf_flags;
2341   }
2342
2343   void Py_SetProgramName(char *);
2344   char *Py_GetProgramName();
2345
2346   void Py_SetPythonHome(char *);
2347   char *Py_GetPythonHome();
2348
2349   void Py_Initialize();
2350   void Py_InitializeEx(int);
2351   void Py_Finalize();
2352   int Py_IsInitialized();
2353   PyThreadState *Py_NewInterpreter();
2354   void Py_EndInterpreter(PyThreadState *);
2355
2356   // These are slightly different in 2.4, but the 2.5 form should still work.
2357   int PyRun_AnyFileExFlags(FILE *, c_str, int, PyCompilerFlags *);
2358
2359   int PyRun_AnyFile(FILE *fp, c_str name) {
2360     return PyRun_AnyFileExFlags(fp, name, 0, null);
2361   }
2362   int PyRun_AnyFileEx(FILE *fp, c_str name, int closeit) {
2363     return PyRun_AnyFileExFlags(fp, name, closeit, null);
2364   }
2365   int PyRun_AnyFileFlags(FILE *fp, c_str name, PyCompilerFlags *flags) {
2366     return PyRun_AnyFileExFlags(fp, name, 0, flags);
2367   }
2368
2369   int PyRun_SimpleStringFlags(c_str, PyCompilerFlags *);
2370   int PyRun_SimpleString(c_str s) {
2371     return PyRun_SimpleStringFlags(s, null);
2372   }
2373
2374   int PyRun_SimpleFileExFlags(FILE *,  c_str, int, PyCompilerFlags *);
2375   int PyRun_SimpleFile(FILE *f, c_str p) {
2376     return PyRun_SimpleFileExFlags(f, p, 0, null);
2377   }
2378   int PyRun_SimpleFileEx(FILE *f, c_str p, int c) {
2379     return PyRun_SimpleFileExFlags(f, p, c, null);
2380   }
2381
2382   int PyRun_InteractiveOneFlags(FILE *, c_str, PyCompilerFlags *);
2383   int PyRun_InteractiveOne(FILE *f, c_str p) {
2384     return PyRun_InteractiveOneFlags(f, p, null);
2385   }
2386   int PyRun_InteractiveLoopFlags(FILE *, c_str, PyCompilerFlags *);
2387   int PyRun_InteractiveLoop(FILE *f, c_str p) {
2388     return PyRun_InteractiveLoopFlags(f, p, null);
2389   }
2390
2391   version (Python_2_5_Or_Later) {
2392     _mod* PyParser_ASTFromString(c_str, c_str,
2393                         int, PyCompilerFlags *, PyArena *);
2394     _mod* PyParser_ASTFromFile(FILE *, c_str, int,
2395                         char *, char *, PyCompilerFlags *, int *, PyArena *);
2396   }
2397
2398   node *PyParser_SimpleParseStringFlags(c_str, int, int);
2399   node *PyParser_SimpleParseString(c_str s, int b) {
2400     return PyParser_SimpleParseStringFlags(s, b, 0);
2401   }
2402   node *PyParser_SimpleParseFileFlags(FILE *, c_str, int, int);
2403   node *PyParser_SimpleParseFile(FILE *f, c_str s, int b) {
2404     return PyParser_SimpleParseFileFlags(f, s, b, 0);
2405   }
2406 //  node *PyParser_SimpleParseStringFlagsFilename(char *, char *, int, int);
2407
2408   PyObject *PyRun_StringFlags(c_str, int, PyObject *, PyObject *, PyCompilerFlags *);
2409   PyObject *PyRun_String(c_str str, int s, PyObject *g, PyObject *l) {
2410     return PyRun_StringFlags(str, s, g, l, null);
2411   }
2412   PyObject *PyRun_FileExFlags(FILE *, c_str, int, PyObject *, PyObject *, int, PyCompilerFlags *);
2413   PyObject *PyRun_File(FILE *fp, c_str p, int s, PyObject *g, PyObject *l) {
2414     return PyRun_FileExFlags(fp, p, s, g, l, 0, null);
2415   }
2416   PyObject *PyRun_FileEx(FILE *fp, c_str p, int s, PyObject *g, PyObject *l, int c) {
2417     return PyRun_FileExFlags(fp, p, s, g, l, c, null);
2418   }
2419   PyObject *PyRun_FileFlags(FILE *fp, c_str p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags) {
2420     return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
2421   }
2422
2423   PyObject *Py_CompileStringFlags(c_str, c_str, int, PyCompilerFlags *);
2424   PyObject *Py_CompileString(c_str str, c_str p, int s) {
2425     return Py_CompileStringFlags(str, p, s, null);
2426   }
2427   // Py_SymtableString is undocumented, so it's omitted here.
2428
2429   void PyErr_Print();
2430   void PyErr_PrintEx(int);
2431   void PyErr_Display(PyObject *, PyObject *, PyObject *);
2432
2433   int Py_AtExit(void (*func)());
2434
2435   void Py_Exit(int);
2436
2437   int Py_FdIsInteractive(FILE *, c_str);
2438
2439 ///////////////////////////////////////////////////////////////////////////////
2440 // BOOTSTRAPPING INTERFACE (for embedding Python in D)
2441 ///////////////////////////////////////////////////////////////////////////////
2442   // Python-header-file: Include/pythonrun.h:
2443
2444   int Py_Main(int argc, char **argv);
2445
2446   char *Py_GetProgramFullPath();
2447   char *Py_GetPrefix();
2448   char *Py_GetExecPrefix();
2449   char *Py_GetPath();
2450
2451   c_str Py_GetVersion();
2452   c_str Py_GetPlatform();
2453   c_str Py_GetCopyright();
2454   c_str Py_GetCompiler();
2455   c_str Py_GetBuildInfo();
2456   version (Python_2_5_Or_Later) {
2457       c_str  _Py_svnversion();
2458       c_str  Py_SubversionRevision();
2459       c_str  Py_SubversionShortBranch();
2460   }
2461
2462   /////////////////////////////////////////////////////////////////////////////
2463   // ONE-TIME INITIALIZERS
2464   /////////////////////////////////////////////////////////////////////////////
2465
2466   PyObject *_PyBuiltin_Init();
2467   PyObject *_PySys_Init();
2468   void _PyImport_Init();
2469   void _PyExc_Init();
2470   void _PyImportHooks_Init();
2471   int _PyFrame_Init();
2472   int _PyInt_Init();
2473
2474   /////////////////////////////////////////////////////////////////////////////
2475   // FINALIZERS
2476   /////////////////////////////////////////////////////////////////////////////
2477
2478   void _PyExc_Fini();
2479   void _PyImport_Fini();
2480   void PyMethod_Fini();
2481   void PyFrame_Fini();
2482   void PyCFunction_Fini();
2483   void PyTuple_Fini();
2484   void PyString_Fini();
2485   void PyInt_Fini();
2486   void PyFloat_Fini();
2487   void PyOS_FiniInterrupts();
2488
2489   /////////////////////////////////////////////////////////////////////////////
2490   // VARIOUS (API members documented as having "no proper home")
2491   /////////////////////////////////////////////////////////////////////////////
2492   char *PyOS_Readline(FILE *, FILE *, char *);
2493   int (*PyOS_InputHook)();
2494   char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
2495   // _PyOS_ReadlineTState omitted.
2496   const int PYOS_STACK_MARGIN = 2048;
2497   // PyOS_CheckStack omitted.
2498
2499   /////////////////////////////////////////////////////////////////////////////
2500   // SIGNALS
2501   /////////////////////////////////////////////////////////////////////////////
2502
2503   alias void (*PyOS_sighandler_t)(int);
2504   PyOS_sighandler_t PyOS_getsig(int);
2505   PyOS_sighandler_t PyOS_setsig(int, PyOS_sighandler_t);
2506
2507
2508 ///////////////////////////////////////////////////////////////////////////////
2509 // EVAL CALLS (documented as "Interface to random parts in ceval.c")
2510 ///////////////////////////////////////////////////////////////////////////////
2511   // Python-header-file: Include/ceval.h:
2512   PyObject *PyEval_CallObjectWithKeywords(PyObject *, PyObject *, PyObject *);
2513   PyObject *PyEval_CallObject(PyObject *func, PyObject *arg) {
2514     return PyEval_CallObjectWithKeywords(func, arg, null);
2515   }
2516   PyObject *PyEval_CallFunction(PyObject *obj, c_str format, ...);
2517   PyObject *PyEval_CallMethod(PyObject *obj, c_str methodname, c_str format, ...);
2518
2519   void PyEval_SetProfile(Py_tracefunc, PyObject *);
2520   void PyEval_SetTrace(Py_tracefunc, PyObject *);
2521
2522   PyObject *PyEval_GetBuiltins();
2523   PyObject *PyEval_GetGlobals();
2524   PyObject *PyEval_GetLocals();
2525   PyFrameObject *PyEval_GetFrame();
2526   int PyEval_GetRestricted();
2527
2528   int PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
2529   int Py_FlushLine();
2530   int Py_AddPendingCall(int (*func)(void *), void *arg);
2531   int Py_MakePendingCalls();
2532
2533   void Py_SetRecursionLimit(int);
2534   int Py_GetRecursionLimit();
2535
2536   // The following API members are undocumented, so they're omitted here:
2537     // Py_EnterRecursiveCall
2538     // Py_LeaveRecursiveCall
2539     // _Py_CheckRecursiveCall
2540     // _Py_CheckRecursionLimit
2541     // _Py_MakeRecCheck
2542
2543   c_str PyEval_GetFuncName(PyObject *);
2544   c_str PyEval_GetFuncDesc(PyObject *);
2545
2546   PyObject *PyEval_GetCallStats(PyObject *);
2547   PyObject *PyEval_EvalFrame(PyFrameObject *);
2548   version (Python_2_5_Or_Later) {
2549       PyObject *PyEval_EvalFrameEx(PyFrameObject *, int);
2550   }
2551
2552 ///////////////////////////////////////////////////////////////////////////////
2553 // SYSTEM MODULE INTERFACE
2554 ///////////////////////////////////////////////////////////////////////////////
2555   // Python-header-file: Include/sysmodule.h:
2556
2557   PyObject *PySys_GetObject(char *);
2558   int PySys_SetObject(char *, PyObject *);
2559   FILE *PySys_GetFile(char *, FILE *);
2560   void PySys_SetArgv(int, char **);
2561   void PySys_SetPath(char *);
2562
2563   void PySys_WriteStdout(c_str format, ...);
2564   void PySys_WriteStderr(c_str format, ...);
2565
2566   void PySys_ResetWarnOptions();
2567   void PySys_AddWarnOption(char *);
2568
2569
2570 ///////////////////////////////////////////////////////////////////////////////
2571 // INTERRUPT INTERFACE
2572 ///////////////////////////////////////////////////////////////////////////////
2573   // Python-header-file: Include/intrcheck.h:
2574
2575   int PyOS_InterruptOccurred();
2576   void PyOS_InitInterrupts();
2577   void PyOS_AfterFork();
2578
2579
2580 ///////////////////////////////////////////////////////////////////////////////
2581 // FRAME INTERFACE
2582 ///////////////////////////////////////////////////////////////////////////////
2583   // Python-header-file: Include/frameobject.h:
2584
2585   struct PyTryBlock {
2586     int b_type;
2587     int b_handler;
2588     int b_level;
2589   }
2590
2591   struct PyFrameObject {
2592     mixin PyObject_VAR_HEAD;