version 0.7.0

author: Andreas Rumpf <rumpf_a@web.de> 2008-11-16 22:11:53 +0100
committer: Andreas Rumpf <rumpf_a@web.de> 2008-11-16 22:11:53 +0100
commit: 985113a88fe07fa18f0a34ceaa9e8c1c1e04a79b (patch)
tree: 6a2e56078dd24d29d9031a784917ed94696d24a8 /lib/base/devel/python.pas
parent: 8b2a9401a147bd0b26cd2976ae71a1022fbde8cc (diff)
download: Nim-985113a88fe07fa18f0a34ceaa9e8c1c1e04a79b.tar.gz
1 files changed, 2205 insertions, 0 deletions
diff --git a/lib/base/devel/python.pas b/lib/base/devel/python.pas
new file mode 100644
index 000000000..587ec6dc9
--- /dev/null
+++ b/lib/base/devel/python.pas
@@ -0,0 +1,2205 @@
+{
+    Light-weight binding for the Python interpreter
+       (c) 2008 Andreas Rumpf 
+    Based on 'PythonEngine' module by Dr. Dietmar Budelsky
+
+}
+
+(**************************************************************************)
+(*                                                                        *)
+(* Module:  Unit 'PythonEngine'     Copyright (c) 1997                    *)
+(*                                                                        *)
+(* Version: 3.0                     Dr. Dietmar Budelsky                  *)
+(* Sub-Version: 0.25                dbudelsky@web.de                      *)
+(*                                  Germany                               *)
+(*                                                                        *)
+(*                                  Morgan Martinet                       *)
+(*                                  4721 rue Brebeuf                      *)
+(*                                  H2J 3L2 MONTREAL (QC)                 *)
+(*                                  CANADA                                *)
+(*                                  e-mail: mmm@free.fr                   *)
+(*                                                                        *)
+(*  look our page at: http://www.multimania.com/marat                     *)
+(**************************************************************************)
+(*  Functionality:  Delphi Components that provide an interface to the    *)
+(*                  Python language (see python.txt for more infos on     *)
+(*                  Python itself).                                       *)
+(*                                                                        *)
+(**************************************************************************)
+(*  Contributors:                                                         *)
+(*      Grzegorz Makarewicz (mak@mikroplan.com.pl)                        *)
+(*      Andrew Robinson (andy@hps1.demon.co.uk)                           *)
+(*      Mark Watts(mark_watts@hotmail.com)                                *)
+(*      Olivier Deckmyn (olivier.deckmyn@mail.dotcom.fr)                  *)
+(*      Sigve Tjora (public@tjora.no)                                     *)
+(*      Mark Derricutt (mark@talios.com)                                  *)
+(*      Igor E. Poteryaev (jah@mail.ru)                                   *)
+(*      Yuri Filimonov (fil65@mail.ru)                                    *)
+(*      Stefan Hoffmeister (Stefan.Hoffmeister@Econos.de)                 *)
+(**************************************************************************)
+(* This source code is distributed with no WARRANTY, for no reason or use.*)
+(* Everyone is allowed to use and change this code free for his own tasks *)
+(* and projects, as long as this header and its copyright text is intact. *)
+(* For changed versions of this code, which are public distributed the    *)
+(* following additional conditions have to be fullfilled:                 *)
+(* 1) The header has to contain a comment on the change and the author of *)
+(*    it.                                                                 *)
+(* 2) A copy of the changed source has to be sent to the above E-Mail     *)
+(*    address or my then valid address, if this is possible to the        *)
+(*    author.                                                             *)
+(* The second condition has the target to maintain an up to date central  *)
+(* version of the component. If this condition is not acceptable for      *)
+(* confidential or legal reasons, everyone is free to derive a component  *)
+(* or to generate a diff file to my or other original sources.            *)
+(* Dr. Dietmar Budelsky, 1997-11-17                                       *)
+(**************************************************************************)
+unit python;
+
+interface
+
+uses
+  dyncalls;
+
+{$ifdef windows}
+const
+  DllName = 'python24.dll';
+{$else}
+const
+  DllName = 'libpython2.4.so'; // for UNIX systems
+{$endif}
+
+const
+  PYT_METHOD_BUFFER_INCREASE = 10;
+  PYT_MEMBER_BUFFER_INCREASE = 10;
+  PYT_GETSET_BUFFER_INCREASE = 10;
+
+  METH_VARARGS  = $0001;
+  METH_KEYWORDS = $0002;
+
+  // Masks for the co_flags field of PyCodeObject
+  CO_OPTIMIZED   = $0001;
+  CO_NEWLOCALS   = $0002;
+  CO_VARARGS     = $0004;
+  CO_VARKEYWORDS = $0008;
+
+type
+  // Rich comparison opcodes introduced in version 2.1
+  TRichComparisonOpcode = (pyLT, pyLE, pyEQ, pyNE, pyGT, pyGE);
+const
+{Type flags (tp_flags) introduced in version 2.0
+
+These flags are used to extend the type structure in a backwards-compatible
+fashion. Extensions can use the flags to indicate (and test) when a given
+type structure contains a new feature. The Python core will use these when
+introducing new functionality between major revisions (to avoid mid-version
+changes in the PYTHON_API_VERSION).
+
+Arbitration of the flag bit positions will need to be coordinated among
+all extension writers who publically release their extensions (this will
+be fewer than you might expect!)..
+
+Python 1.5.2 introduced the bf_getcharbuffer slot into PyBufferProcs.
+
+Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.
+
+Code can use PyType_HasFeature(type_ob, flag_value) to test whether the
+given type object has a specified feature.
+}
+
+// PyBufferProcs contains bf_getcharbuffer
+  Py_TPFLAGS_HAVE_GETCHARBUFFER = (1 shl 0);
+
+// PySequenceMethods contains sq_contains
+  Py_TPFLAGS_HAVE_SEQUENCE_IN = (1 shl 1);
+
+// Objects which participate in garbage collection (see objimp.h)
+  Py_TPFLAGS_GC = (1 shl 2);
+
+// PySequenceMethods and PyNumberMethods contain in-place operators
+  Py_TPFLAGS_HAVE_INPLACEOPS = (1 shl 3);
+
+// PyNumberMethods do their own coercion */
+  Py_TPFLAGS_CHECKTYPES = (1 shl 4);
+
+  Py_TPFLAGS_HAVE_RICHCOMPARE = (1 shl 5);
+
+// Objects which are weakly referencable if their tp_weaklistoffset is >0
+// XXX Should this have the same value as Py_TPFLAGS_HAVE_RICHCOMPARE?
+// These both indicate a feature that appeared in the same alpha release.
+
+  Py_TPFLAGS_HAVE_WEAKREFS = (1 shl 6);
+
+// tp_iter is defined
+  Py_TPFLAGS_HAVE_ITER = (1 shl 7);
+
+// New members introduced by Python 2.2 exist
+  Py_TPFLAGS_HAVE_CLASS = (1 shl 8);
+
+// Set if the type object is dynamically allocated
+  Py_TPFLAGS_HEAPTYPE = (1 shl 9);
+
+// Set if the type allows subclassing
+  Py_TPFLAGS_BASETYPE = (1 shl 10);
+
+// Set if the type is 'ready' -- fully initialized
+  Py_TPFLAGS_READY = (1 shl 12);
+
+// Set while the type is being 'readied', to prevent recursive ready calls
+  Py_TPFLAGS_READYING = (1 shl 13);
+
+// Objects support garbage collection (see objimp.h)
+  Py_TPFLAGS_HAVE_GC = (1 shl 14);
+
+  Py_TPFLAGS_DEFAULT  =      Py_TPFLAGS_HAVE_GETCHARBUFFER
+                             or Py_TPFLAGS_HAVE_SEQUENCE_IN
+                             or Py_TPFLAGS_HAVE_INPLACEOPS
+                             or Py_TPFLAGS_HAVE_RICHCOMPARE
+                             or Py_TPFLAGS_HAVE_WEAKREFS
+                             or Py_TPFLAGS_HAVE_ITER
+                             or Py_TPFLAGS_HAVE_CLASS;
+
+// See function PyType_HasFeature below for testing the flags.
+
+// Delphi equivalent used by TPythonType
+type
+  TPFlag = (tpfHaveGetCharBuffer, tpfHaveSequenceIn, tpfGC, tpfHaveInplaceOps,
+            tpfCheckTypes, tpfHaveRichCompare, tpfHaveWeakRefs,
+            tpfHaveIter, tpfHaveClass, tpfHeapType, tpfBaseType, tpfReady, 
+            tpfReadying, tpfHaveGC
+           );
+  TPFlags = set of TPFlag;
+const
+  TPFLAGS_DEFAULT = [tpfHaveGetCharBuffer, tpfHaveSequenceIn, tpfHaveInplaceOps,
+                     tpfHaveRichCompare, tpfHaveWeakRefs, tpfHaveIter, 
+                     tpfHaveClass];
+//-------  Python opcodes  ----------//
+Const
+   single_input                 = 256;
+   file_input                   = 257;
+   eval_input                   = 258;
+   funcdef                      = 259;
+   parameters                   = 260;
+   varargslist                  = 261;
+   fpdef                        = 262;
+   fplist                       = 263;
+   stmt                         = 264;
+   simple_stmt                  = 265;
+   small_stmt                   = 266;
+   expr_stmt                    = 267;
+   augassign                    = 268;
+   print_stmt                   = 269;
+   del_stmt                     = 270;
+   pass_stmt                    = 271;
+   flow_stmt                    = 272;
+   break_stmt                   = 273;
+   continue_stmt                = 274;
+   return_stmt                  = 275;
+   raise_stmt                   = 276;
+   import_stmt                  = 277;
+   import_as_name               = 278;
+   dotted_as_name               = 279;
+   dotted_name                  = 280;
+   global_stmt                  = 281;
+   exec_stmt                    = 282;
+   assert_stmt                  = 283;
+   compound_stmt                = 284;
+   if_stmt                      = 285;
+   while_stmt                   = 286;
+   for_stmt                     = 287;
+   try_stmt                     = 288;
+   except_clause                = 289;
+   suite                        = 290;
+   test                         = 291;
+   and_test                     = 291;
+   not_test                     = 293;
+   comparison                   = 294;
+   comp_op                      = 295;
+   expr                         = 296;
+   xor_expr                     = 297;
+   and_expr                     = 298;
+   shift_expr                   = 299;
+   arith_expr                   = 300;
+   term                         = 301;
+   factor                       = 302;
+   power                        = 303;
+   atom                         = 304;
+   listmaker                    = 305;
+   lambdef                      = 306;
+   trailer                      = 307;
+   subscriptlist                = 308;
+   subscript                    = 309;
+   sliceop                      = 310;
+   exprlist                     = 311;
+   testlist                     = 312;
+   dictmaker                    = 313;
+   classdef                     = 314;
+   arglist                      = 315;
+   argument                     = 316;
+   list_iter                    = 317;
+   list_for                     = 318;
+   list_if                      = 319;
+
+const
+  T_SHORT                       = 0;
+  T_INT                         = 1;
+  T_LONG                        = 2;
+  T_FLOAT                       = 3;
+  T_DOUBLE                      = 4;
+  T_STRING                      = 5;
+  T_OBJECT                      = 6;
+  T_CHAR                        = 7;	// 1-character string
+  T_BYTE                        = 8;	// 8-bit signed int
+  T_UBYTE                       = 9;
+  T_USHORT                      = 10;
+  T_UINT                        = 11;
+  T_ULONG                       = 12;
+
+// Added by Jack: strings contained in the structure
+  T_STRING_INPLACE= 13;
+
+  T_OBJECT_EX                   = 16;{ Like T_OBJECT, but raises AttributeError
+                                        when the value is NULL, instead of
+                                        converting to None. }
+
+// Flags
+  READONLY                      = 1;
+  RO                            = READONLY;		// Shorthand 
+  READ_RESTRICTED               = 2;
+  WRITE_RESTRICTED              = 4;
+  RESTRICTED                    = (READ_RESTRICTED or WRITE_RESTRICTED);
+type
+  TPyMemberType = (mtShort, mtInt, mtLong, mtFloat, mtDouble, mtString, 
+                   mtObject, mtChar, mtByte, mtUByte, mtUShort, mtUInt, 
+                   mtULong, mtStringInplace, mtObjectEx);
+  TPyMemberFlag = (mfDefault, mfReadOnly, mfReadRestricted, mfWriteRestricted, mfRestricted);
+
+//#######################################################
+//##                                                   ##
+//##    Global declarations, nothing Python specific   ##
+//##                                                   ##
+//#######################################################
+
+type
+  TPChar  = array[0..16000] of PChar;
+  PPChar  = ^TPChar;
+  PInt	   = ^Integer;
+  PDouble = ^Double;
+  PFloat  = ^Real;
+  PLong   = ^LongInt;
+  PShort  = ^ShortInt;
+  PString = ^PChar;
+
+//#######################################################
+//##                                                   ##
+//##            Python specific interface              ##
+//##                                                   ##
+//#######################################################
+
+type
+  PP_frozen	    = ^Pfrozen;
+  P_frozen	    = ^Tfrozen;
+  PPyObject	    = ^PyObject;
+  PPPyObject	    = ^PPyObject;
+  PPPPyObject	    = ^PPPyObject;
+  PPyIntObject	    = ^PyIntObject;
+  PPyTypeObject     = ^PyTypeObject;
+  PPySliceObject    = ^PySliceObject;
+
+  TPyCFunction       = function (self, args: PPyObject): PPyObject; cdecl;
+
+  Tunaryfunc         = function (ob1: PPyObject): PPyObject; cdecl;
+  Tbinaryfunc        = function (ob1,ob2: PPyObject): PPyObject; cdecl;
+  Tternaryfunc       = function (ob1,ob2,ob3: PPyObject): PPyObject; cdecl;
+  Tinquiry           = function (ob1: PPyObject): integer; cdecl;
+  Tcoercion          = function (ob1,ob2: PPPyObject): integer; cdecl;
+  Tintargfunc        = function (ob1: PPyObject; i: integer): PPyObject; cdecl;
+  Tintintargfunc     = function (ob1: PPyObject; i1, i2: integer):
+                                PPyObject; cdecl;
+  Tintobjargproc     = function (ob1: PPyObject; i: integer; ob2: PPyObject):
+                                integer; cdecl;
+  Tintintobjargproc  = function (ob1: PPyObject; i1, i2: integer;
+                                ob2: PPyObject): integer; cdecl;
+  Tobjobjargproc     = function (ob1,ob2,ob3: PPyObject): integer; cdecl;
+
+  Tpydestructor      = procedure (ob: PPyObject); cdecl;
+  Tprintfunc         = function (ob: PPyObject; var f: file; i: integer): integer; cdecl;
+  Tgetattrfunc       = function (ob1: PPyObject; name: PChar): PPyObject; cdecl;
+  Tsetattrfunc       = function (ob1: PPyObject; name: PChar; ob2: PPyObject): integer; cdecl;
+  Tcmpfunc           = function (ob1, ob2: PPyObject): integer; cdecl;
+  Treprfunc          = function (ob: PPyObject): PPyObject; cdecl;
+  Thashfunc          = function (ob: PPyObject): LongInt; cdecl;
+  Tgetattrofunc      = function (ob1, ob2: PPyObject): PPyObject; cdecl;
+  Tsetattrofunc      = function (ob1, ob2, ob3: PPyObject): integer; cdecl;
+
+/// jah 29-sep-2000: updated for python 2.0
+///                   added from object.h
+  Tgetreadbufferproc = function (ob1: PPyObject; i: integer; ptr: Pointer): integer; cdecl;
+  Tgetwritebufferproc= function (ob1: PPyObject; i: integer; ptr: Pointer): integer; cdecl;
+  Tgetsegcountproc   = function (ob1: PPyObject; i: integer): integer; cdecl;
+  Tgetcharbufferproc = function (ob1: PPyObject; i: integer; const pstr: PChar): integer; cdecl;
+  Tobjobjproc        = function (ob1, ob2: PPyObject): integer; cdecl;
+  Tvisitproc         = function (ob1: PPyObject; ptr: Pointer): integer; cdecl;
+  Ttraverseproc      = function (ob1: PPyObject; proc: visitproc; ptr: Pointer): integer; cdecl;
+
+  Trichcmpfunc       = function (ob1, ob2: PPyObject; i: Integer): PPyObject; cdecl;
+  Tgetiterfunc       = function (ob1: PPyObject): PPyObject; cdecl;
+  Titernextfunc      = function (ob1: PPyObject): PPyObject; cdecl;
+  Tdescrgetfunc      = function (ob1, ob2, ob3: PPyObject): PPyObject; cdecl;
+  Tdescrsetfunc      = function (ob1, ob2, ob3: PPyObject): Integer; cdecl;
+  Tinitproc          = function (self, args, kwds: PPyObject): Integer; cdecl;
+  Tnewfunc           = function (subtype: PPyTypeObject; args, kwds: PPyObject): PPyObject; cdecl;
+  Tallocfunc         = function (self: PPyTypeObject; nitems: integer): PPyObject; cdecl;
+
+  TPyNumberMethods = record
+     nb_add: Tbinaryfunc;
+     nb_substract: Tbinaryfunc;
+     nb_multiply: Tbinaryfunc;
+     nb_divide: Tbinaryfunc;
+     nb_remainder: Tbinaryfunc;
+     nb_divmod: Tbinaryfunc;
+     nb_power: Tternaryfunc;
+     nb_negative: Tunaryfunc;
+     nb_positive: Tunaryfunc;
+     nb_absolute: Tunaryfunc;
+     nb_nonzero: Tinquiry;
+     nb_invert: Tunaryfunc;
+     nb_lshift: Tbinaryfunc;
+     nb_rshift: Tbinaryfunc;
+     nb_and: Tbinaryfunc;
+     nb_xor: Tbinaryfunc;
+     nb_or: Tbinaryfunc;
+     nb_coerce: Tcoercion;
+     nb_int: Tunaryfunc;
+     nb_long: Tunaryfunc;
+     nb_float: Tunaryfunc;
+     nb_oct: Tunaryfunc;
+     nb_hex: Tunaryfunc;
+/// jah 29-sep-2000: updated for python 2.0
+///                   added from .h
+     nb_inplace_add: Tbinaryfunc;
+     nb_inplace_subtract: Tbinaryfunc;
+     nb_inplace_multiply: Tbinaryfunc;
+     nb_inplace_divide: Tbinaryfunc;
+     nb_inplace_remainder: Tbinaryfunc;
+     nb_inplace_power: Tternaryfunc;
+     nb_inplace_lshift: Tbinaryfunc;
+     nb_inplace_rshift: Tbinaryfunc;
+     nb_inplace_and: Tbinaryfunc;
+     nb_inplace_xor: Tbinaryfunc;
+     nb_inplace_or: Tbinaryfunc;
+     // Added in release 2.2
+     // The following require the Py_TPFLAGS_HAVE_CLASS flag
+     nb_floor_divide:         Tbinaryfunc;
+     nb_true_divide:          Tbinaryfunc;
+     nb_inplace_floor_divide: Tbinaryfunc;
+     nb_inplace_true_divide:  Tbinaryfunc;
+  end;
+  PPyNumberMethods = ^TPyNumberMethods;
+
+  TPySequenceMethods = record
+     sq_length: Tinquiry;
+     sq_concat: Tbinaryfunc;
+     sq_repeat: Tintargfunc;
+     sq_item: Tintargfunc;
+     sq_slice: Tintintargfunc;
+     sq_ass_item: Tintobjargproc;
+     sq_ass_slice: Tintintobjargproc;
+/// jah 29-sep-2000: updated for python 2.0
+///                   added from .h
+     sq_contains: Tobjobjproc;
+     sq_inplace_concat: Tbinaryfunc;
+     sq_inplace_repeat: Tintargfunc;
+  end;
+  PPySequenceMethods = ^TPySequenceMethods;
+
+  TPyMappingMethods = record
+     mp_length	: Tinquiry;
+     mp_subscript: Tbinaryfunc;
+     mp_ass_subscript: Tobjobjargproc;
+  end;
+  PPyMappingMethods = ^PyMappingMethods;
+
+/// jah 29-sep-2000: updated for python 2.0
+///                   added from .h
+  TPyBufferProcs = record
+     bf_getreadbuffer: Tgetreadbufferproc;
+     bf_getwritebuffer: Tgetwritebufferproc;
+     bf_getsegcount: Tgetsegcountproc;
+     bf_getcharbuffer: Tgetcharbufferproc;
+  end;
+  PPyBufferProcs = ^TPyBufferProcs;
+
+  TPy_complex =  record
+     real: double;
+     imag: double;
+  end;
+
+  TPyObject = record
+    ob_refcnt: Integer;
+    ob_type:   PPyTypeObject;
+  end;
+
+  TPyIntObject = object(TPyObject)
+    ob_ival: LongInt;
+  end;
+
+  PByte = ^Byte;
+  Tfrozen = packed record
+     name: PChar;
+     code: PByte;
+     size: Integer;
+  end;
+
+  TPySliceObject = object(TPyObject)
+    start, stop, step:  PPyObject;
+  end;
+
+  PPyMethodDef = ^TPyMethodDef;
+  TPyMethodDef  = record
+     ml_name:  PChar;
+     ml_meth:  TPyCFunction;
+     ml_flags: Integer;
+     ml_doc:   PChar;
+  end;
+
+  // structmember.h
+  PPyMemberDef = ^TPyMemberDef;
+  TPyMemberDef = record
+    name: PChar;
+    theType: integer;
+    offset: integer;
+    flags: integer;
+    doc: PChar;
+  end;
+
+  // descrobject.h
+
+  // Descriptors
+
+  Tgetter = function (obj: PPyObject; context: Pointer): PPyObject; cdecl;
+  Tsetter = function (obj, value: PPyObject; context: Pointer): integer; cdecl;
+
+  PPyGetSetDef = ^TPyGetSetDef;
+  TPyGetSetDef = record
+    name: PChar;
+    get: Tgetter;
+    set_: Tsetter;
+    doc: PChar;
+    closure: Pointer;
+  end;
+
+  Twrapperfunc = function (self, args: PPyObject; wrapped: Pointer): PPyObject; cdecl;
+
+  pwrapperbase = ^Twrapperbase;
+  Twrapperbase = record
+    name: PChar;
+    wrapper: Twrapperfunc;
+    doc: PChar;
+  end;
+
+  // Various kinds of descriptor objects
+
+  {#define PyDescr_COMMON \
+          PyObject_HEAD \
+          PyTypeObject *d_type; \
+          PyObject *d_name
+  }
+
+  PPyDescrObject = ^TPyDescrObject;
+  TPyDescrObject = object(TPyObject)
+    d_type: PPyTypeObject;
+    d_name: PPyObject;
+  end;
+
+  PPyMethodDescrObject = ^TPyMethodDescrObject;
+  TPyMethodDescrObject = object(TPyDescrObject)
+    d_method: PPyMethodDef;
+  end;
+
+  PPyMemberDescrObject = ^TPyMemberDescrObject;
+  TPyMemberDescrObject = object(TPyDescrObject)
+    d_member: PPyMemberDef;
+  end;
+
+  PPyGetSetDescrObject = ^TPyGetSetDescrObject;
+  TPyGetSetDescrObject = object(TPyDescrObject)
+    d_getset: PPyGetSetDef;
+  end;
+
+  PPyWrapperDescrObject = ^TPyWrapperDescrObject;
+  TPyWrapperDescrObject = object(TPyDescrObject)
+    d_base: pwrapperbase;
+    d_wrapped: Pointer; // This can be any function pointer
+  end;
+
+  // object.h
+  TPyTypeObject = object(TPyObject)
+    ob_size:        Integer; // Number of items in variable part
+    tp_name:        PChar;   // For printing
+    tp_basicsize, tp_itemsize: Integer; // For allocation
+
+    // Methods to implement standard operations
+
+    tp_dealloc:     Tpydestructor;
+    tp_print:       Tprintfunc;
+    tp_getattr:     Tgetattrfunc;
+    tp_setattr:     Tsetattrfunc;
+    tp_compare:     Tcmpfunc;
+    tp_repr:        Treprfunc;
+
+    // Method suites for standard classes
+
+    tp_as_number:   PPyNumberMethods;
+    tp_as_sequence: PPySequenceMethods;
+    tp_as_mapping:  PPyMappingMethods;
+
+    // More standard operations (here for binary compatibility)
+
+    tp_hash:        Thashfunc;
+    tp_call:        Tternaryfunc;
+    tp_str:         Treprfunc;
+    tp_getattro:    Tgetattrofunc;
+    tp_setattro:    Tsetattrofunc;
+
+/// jah 29-sep-2000: updated for python 2.0
+
+    // Functions to access object as input/output buffer
+    tp_as_buffer:   PPyBufferProcs;
+    // Flags to define presence of optional/expanded features
+    tp_flags:       LongInt;
+
+    tp_doc:         PChar; // Documentation string
+
+    // call function for all accessible objects
+    tp_traverse:    Ttraverseproc;
+
+    // delete references to contained objects
+    tp_clear:       Tinquiry;
+    // rich comparisons
+    tp_richcompare: Trichcmpfunc;
+
+    // weak reference enabler
+    tp_weaklistoffset: Longint;
+    // Iterators
+    tp_iter: Tgetiterfunc;
+    tp_iternext: Titernextfunc;
+
+    // Attribute descriptor and subclassing stuff
+    tp_methods: PPyMethodDef;
+    tp_members: PPyMemberDef;
+    tp_getset: PPyGetSetDef;
+    tp_base: PPyTypeObject;
+    tp_dict: PPyObject;
+    tp_descr_get: Tdescrgetfunc;
+    tp_descr_set: Tdescrsetfunc;
+    tp_dictoffset: longint;
+    tp_init: Tinitproc;
+    tp_alloc: Tallocfunc;
+    tp_new: Tnewfunc;
+    tp_free: Tpydestructor; // Low-level free-memory routine
+    tp_is_gc: Tinquiry; // For PyObject_IS_GC
+    tp_bases: PPyObject;
+    tp_mro: PPyObject; // method resolution order
+    tp_cache: PPyObject;
+    tp_subclasses: PPyObject;
+    tp_weaklist: PPyObject;
+    //More spares
+    tp_xxx7:        pointer;
+    tp_xxx8:        pointer;
+  end;
+
+  PPyMethodChain = ^TPyMethodChain;
+  TPyMethodChain = record
+    methods: PPyMethodDef;
+    link:    PPyMethodChain;
+  end;
+
+  PPyClassObject = ^TPyClassObject;
+  TPyClassObject = object(TPyObject)
+    cl_bases: PPyObject;      // A tuple of class objects
+    cl_dict: PPyObject;       // A dictionary
+    cl_name: PPyObject;       // A string
+    // The following three are functions or NULL
+    cl_getattr: PPyObject;
+    cl_setattr: PPyObject;
+    cl_delattr: PPyObject;
+  end;
+
+  PPyInstanceObject = ^TPyInstanceObject;
+  TPyInstanceObject = object(TPyObject)
+    in_class: PPyClassObject;      // The class object
+    in_dict: PPyObject;           // A dictionary
+  end;
+
+{ Instance method objects are used for two purposes:
+   (a) as bound instance methods (returned by instancename.methodname)
+   (b) as unbound methods (returned by ClassName.methodname)
+   In case (b), im_self is NULL
+}
+
+  PPyMethodObject = ^TPyMethodObject;
+  TPyMethodObject = object(TPyObject)
+    im_func: PPyObject;      // The function implementing the method
+    im_self: PPyObject;      // The instance it is bound to, or NULL
+    im_class: PPyObject;      // The class that defined the method
+  end;
+
+  // Bytecode object, compile.h
+  PPyCodeObject = ^TPyCodeObject;
+  TPyCodeObject = object(TPyObject)
+    co_argcount: Integer;         // #arguments, except *args
+    co_nlocals: Integer;         // #local variables
+    co_stacksize: Integer;          // #entries needed for evaluation stack
+    co_flags: Integer;         // CO_..., see below
+    co_code: PPyObject;       // instruction opcodes (it hides a PyStringObject)
+    co_consts: PPyObject;       // list (constants used)
+    co_names: PPyObject;       // list of strings (names used)
+    co_varnames: PPyObject;       // tuple of strings (local variable names)
+    co_freevars: PPyObject;	      // tuple of strings (free variable names)
+    co_cellvars: PPyObject;       // tuple of strings (cell variable names)
+    // The rest doesn't count for hash/cmp
+    co_filename: PPyObject;       // string (where it was loaded from)
+    co_name: PPyObject;       // string (name, for reference)
+    co_firstlineno: Integer;         // first source line number
+    co_lnotab: PPyObject;       // string (encoding addr<->lineno mapping)
+  end;
+
+  // from pystate.h
+  PPyInterpreterState = ^TPyInterpreterState;
+  PPyThreadState = ^TPyThreadState;
+  PPyFrameObject = ^TPyFrameObject;
+
+  // Interpreter environments
+  TPyInterpreterState = record
+    next: PPyInterpreterState;
+    tstate_head: PPyThreadState;
+
+    modules: PPyObject;
+    sysdict: PPyObject;
+    builtins: PPyObject;
+
+    checkinterval: integer;
+  end;
+
+  // Thread specific information
+  TPyThreadState = record
+    next: PPyThreadState;
+    interp: PPyInterpreterState;
+
+    frame: PPyFrameObject;
+    recursion_depth: integer;
+    ticker: integer;
+    tracing: integer;
+
+    sys_profilefunc: PPyObject;
+    sys_tracefunc: PPyObject;
+
+    curexc_type: PPyObject;
+    curexc_value: PPyObject;
+    curexc_traceback: PPyObject;
+
+    exc_type: PPyObject;
+    exc_value: PPyObject;
+    exc_traceback: PPyObject;
+
+    dict: PPyObject;
+  end;
+
+  // from frameobject.h
+
+  PPyTryBlock = ^TPyTryBlock;
+  TPyTryBlock = record
+    b_type: Integer;       // what kind of block this is
+    b_handler: Integer;       // where to jump to find handler
+    b_level: Integer;       // value stack level to pop to
+  end;
+
+  CO_MAXBLOCKS  = 0..19;
+  TPyFrameObject = object(TPyObject)
+    // start of the VAR_HEAD of an object
+    ob_size: Integer;           // Number of items in variable part
+    // End of the Head of an object
+    f_back: PPyFrameObject;    // previous frame, or NULL
+    f_code: PPyCodeObject;     // code segment
+    f_builtins: PPyObject;         // builtin symbol table (PyDictObject)
+    f_globals: PPyObject;         // global symbol table (PyDictObject)
+    f_locals: PPyObject;         // local symbol table (PyDictObject)
+    f_valuestack: PPPyObject;        // points after the last local
+    (* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
+       Frame evaluation usually NULLs it, but a frame that yields sets it
+       to the current stack top. *)
+    f_stacktop: PPPyObject;
+    f_trace: PPyObject;         // Trace function
+    f_exc_type, f_exc_value, f_exc_traceback: PPyObject;
+    f_tstate: PPyThreadState;
+    f_lasti: Integer;           // Last instruction if called
+    f_lineno: Integer;           // Current line number
+    f_restricted: Integer;           // Flag set if restricted operations
+                                      // in this scope
+    f_iblock: Integer;           // index in f_blockstack
+    f_blockstack: array[CO_MAXBLOCKS] of PyTryBlock; // for try and loop blocks
+    f_nlocals: Integer;           // number of locals
+    f_ncells: Integer;
+    f_nfreevars: Integer;
+    f_stacksize: Integer;           // size of value stack
+    f_localsplus: array[0..0] of PPyObject; // locals+stack, dynamically sized
+  end;
+
+  // From traceback.c
+  PPyTraceBackObject = ^TPyTraceBackObject;
+  TPyTraceBackObject = object(TPyObject)
+    tb_next: PPyTraceBackObject;
+    tb_frame: PPyFrameObject;
+    tb_lasti: Integer;
+    tb_lineno: Integer;
+  end;
+
+  // Parse tree node interface
+
+  PNode = ^Tnode;
+  Tnode = record
+    n_type: smallint;
+    n_str: PChar;
+    n_lineno: smallint;
+    n_nchildren: smallint;
+    n_child: PNode;
+  end;
+
+  // From weakrefobject.h
+
+  PPyWeakReference = ^TPyWeakReference;
+  TPyWeakReference = object(TPyObject)
+    wr_object: PPyObject;
+    wr_callback: PPyObject;
+    hash: longint;
+    wr_prev: PPyWeakReference;
+    wr_next: PPyWeakReference;
+  end;
+
+  // from datetime.h
+
+
+{* Fields are packed into successive bytes, each viewed as unsigned and
+ * big-endian, unless otherwise noted:
+ *
+ * byte offset
+ *  0 		year     2 bytes, 1-9999
+ *  2	  	month    1 byte,  1-12
+ *  3 		day      1 byte,  1-31
+ *  4     hour     1 byte,  0-23
+ *  5 		minute   1 byte,  0-59
+ *  6 		second   1 byte,  0-59
+ *  7 		usecond  3 bytes, 0-999999
+ * 10
+ *}
+
+const
+  { # of bytes for year, month, and day. }
+  PyDateTime_DATE_DATASIZE = 4;
+
+  { # of bytes for hour, minute, second, and usecond. }
+  PyDateTime_TIME_DATASIZE = 6;
+
+  { # of bytes for year, month, day, hour, minute, second, and usecond. }
+  PyDateTime_DATETIME_DATASIZE = 10;
+type
+  TPyDateTime_Delta = object(TPyObject)
+    hashcode: Integer;  // -1 when unknown
+    days: Integer;  // -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS
+    seconds: Integer;  // 0 <= seconds < 24*3600 is invariant
+    microseconds: Integer;  // 0 <= microseconds < 1000000 is invariant
+  end;
+  PPyDateTime_Delta = ^TPyDateTime_Delta;
+
+  TPyDateTime_TZInfo = object(TPyObject) // a pure abstract base clase
+  end;
+  PPyDateTime_TZInfo = ^TPyDateTime_TZInfo;
+
+{
+/* The datetime and time types have hashcodes, and an optional tzinfo member,
+ * present if and only if hastzinfo is true.
+ */
+#define _PyTZINFO_HEAD		\
+	PyObject_HEAD		\
+	long hashcode;		\
+	char hastzinfo;		/* boolean flag */
+}
+
+{* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
+ * convenient to cast to, when getting at the hastzinfo member of objects
+ * starting with _PyTZINFO_HEAD.
+ *}
+  TPyDateTime_BaseTZInfo = object(TPyObject)
+    hashcode: Integer;
+    hastzinfo: bool;  // boolean flag
+  end;
+  PPyDateTime_BaseTZInfo = ^TPyDateTime_BaseTZInfo;
+
+{* All time objects are of PyDateTime_TimeType, but that can be allocated
+ * in two ways, with or without a tzinfo member.  Without is the same as
+ * tzinfo == None, but consumes less memory.  _PyDateTime_BaseTime is an
+ * internal struct used to allocate the right amount of space for the
+ * "without" case.
+ *}
+{#define _PyDateTime_TIMEHEAD	\
+	_PyTZINFO_HEAD		\
+	unsigned char data[_PyDateTime_TIME_DATASIZE];
+}
+
+  TPyDateTime_BaseTime = object(TPyDateTime_BaseTZInfo) 
+    data: array[0..Pred(PyDateTime_TIME_DATASIZE)] of Byte;
+  end;
+  PPyDateTime_BaseTime = ^TPyDateTime_BaseTime;
+
+  TPyDateTime_Time = object(TPyDateTime_BaseTime) // hastzinfo true
+    tzinfo: PPyObject;
+  end;
+  PPyDateTime_Time = ^PyDateTime_Time;
+
+{* All datetime objects are of PyDateTime_DateTimeType, but that can be
+ * allocated in two ways too, just like for time objects above.  In addition,
+ * the plain date type is a base class for datetime, so it must also have
+ * a hastzinfo member (although it's unused there).
+ *}
+  TPyDateTime_Date = object(TPyDateTime_BaseTZInfo) 
+    data: array [0..Pred(PyDateTime_DATE_DATASIZE)] of Byte;
+  end;
+  PPyDateTime_Date = ^TPyDateTime_Date;
+
+ {
+#define _PyDateTime_DATETIMEHEAD	\
+	_PyTZINFO_HEAD			\
+	unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+}
+
+  TPyDateTime_BaseDateTime = object(TPyDateTime_BaseTZInfo) // hastzinfo false
+    data: array[0..Pred(PyDateTime_DATETIME_DATASIZE)] of Byte;
+  end;
+  PPyDateTime_BaseDateTime = ^TPyDateTime_BaseDateTime;
+
+  TPyDateTime_DateTime = object(TPyDateTime_BaseTZInfo) // hastzinfo true
+    data: array[0..Pred(PyDateTime_DATETIME_DATASIZE)] of Byte;
+    tzinfo: PPyObject;
+  end;
+  PPyDateTime_DateTime = ^TPyDateTime_DateTime;
+
+
+//#######################################################
+//##                                                   ##
+//##         New exception classes                     ##
+//##                                                   ##
+//#######################################################
+(*
+  // Python's exceptions
+  EPythonError   = object(Exception)
+      EName: String;
+      EValue: String;
+  end;
+  EPyExecError   = object(EPythonError)
+  end;
+
+  // Standard exception classes of Python
+
+/// jah 29-sep-2000: updated for python 2.0
+///                   base classes updated according python documentation
+
+{ Hierarchy of Python exceptions, Python 2.3, copied from <INSTALL>\Python\exceptions.c
+
+Exception\n\
+ |\n\
+ +-- SystemExit\n\
+ +-- StopIteration\n\
+ +-- StandardError\n\
+ |    |\n\
+ |    +-- KeyboardInterrupt\n\
+ |    +-- ImportError\n\
+ |    +-- EnvironmentError\n\
+ |    |    |\n\
+ |    |    +-- IOError\n\
+ |    |    +-- OSError\n\
+ |    |         |\n\
+ |    |         +-- WindowsError\n\
+ |    |         +-- VMSError\n\
+ |    |\n\
+ |    +-- EOFError\n\
+ |    +-- RuntimeError\n\
+ |    |    |\n\
+ |    |    +-- NotImplementedError\n\
+ |    |\n\
+ |    +-- NameError\n\
+ |    |    |\n\
+ |    |    +-- UnboundLocalError\n\
+ |    |\n\
+ |    +-- AttributeError\n\
+ |    +-- SyntaxError\n\
+ |    |    |\n\
+ |    |    +-- IndentationError\n\
+ |    |         |\n\
+ |    |         +-- TabError\n\
+ |    |\n\
+ |    +-- TypeError\n\
+ |    +-- AssertionError\n\
+ |    +-- LookupError\n\
+ |    |    |\n\
+ |    |    +-- IndexError\n\
+ |    |    +-- KeyError\n\
+ |    |\n\
+ |    +-- ArithmeticError\n\
+ |    |    |\n\
+ |    |    +-- OverflowError\n\
+ |    |    +-- ZeroDivisionError\n\
+ |    |    +-- FloatingPointError\n\
+ |    |\n\
+ |    +-- ValueError\n\
+ |    |    |\n\
+ |    |    +-- UnicodeError\n\
+ |    |        |\n\
+ |    |        +-- UnicodeEncodeError\n\
+ |    |        +-- UnicodeDecodeError\n\
+ |    |        +-- UnicodeTranslateError\n\
+ |    |\n\
+ |    +-- ReferenceError\n\
+ |    +-- SystemError\n\
+ |    +-- MemoryError\n\
+ |\n\
+ +---Warning\n\
+      |\n\
+      +-- UserWarning\n\
+      +-- DeprecationWarning\n\
+      +-- PendingDeprecationWarning\n\
+      +-- SyntaxWarning\n\
+      +-- OverflowWarning\n\
+      +-- RuntimeWarning\n\
+      +-- FutureWarning"
+}
+   EPyException = class (EPythonError);
+   EPyStandardError = class (EPyException);
+   EPyArithmeticError = class (EPyStandardError);
+   EPyLookupError = class (EPyStandardError);
+   EPyAssertionError = class (EPyStandardError);
+   EPyAttributeError = class (EPyStandardError);
+   EPyEOFError = class (EPyStandardError);
+   EPyFloatingPointError = class (EPyArithmeticError);
+   EPyEnvironmentError = class (EPyStandardError);
+   EPyIOError = class (EPyEnvironmentError);
+   EPyOSError = class (EPyEnvironmentError);
+   EPyImportError = class (EPyStandardError);
+   EPyIndexError = class (EPyLookupError);
+   EPyKeyError = class (EPyLookupError);
+   EPyKeyboardInterrupt = class (EPyStandardError);
+   EPyMemoryError = class (EPyStandardError);
+   EPyNameError = class (EPyStandardError);
+   EPyOverflowError = class (EPyArithmeticError);
+   EPyRuntimeError = class (EPyStandardError);
+   EPyNotImplementedError = class (EPyRuntimeError);
+   EPySyntaxError = class (EPyStandardError)
+   public
+      EFileName: string;
+      ELineStr: string;
+      ELineNumber: Integer;
+      EOffset: Integer;
+   end;
+   EPyIndentationError = class (EPySyntaxError);
+   EPyTabError = class (EPyIndentationError);
+   EPySystemError = class (EPyStandardError);
+   EPySystemExit = class (EPyException);
+   EPyTypeError = class (EPyStandardError);
+   EPyUnboundLocalError = class (EPyNameError);
+   EPyValueError = class (EPyStandardError);
+   EPyUnicodeError = class (EPyValueError);
+   UnicodeEncodeError = class (EPyUnicodeError);
+   UnicodeDecodeError = class (EPyUnicodeError);
+   UnicodeTranslateError = class (EPyUnicodeError);
+   EPyZeroDivisionError = class (EPyArithmeticError);
+   EPyStopIteration = class(EPyException);
+   EPyWarning = class (EPyException);
+   EPyUserWarning = class (EPyWarning);
+   EPyDeprecationWarning = class (EPyWarning);
+   PendingDeprecationWarning = class (EPyWarning);
+   FutureWarning = class (EPyWarning);
+   EPySyntaxWarning = class (EPyWarning);
+   EPyOverflowWarning = class (EPyWarning);
+   EPyRuntimeWarning = class (EPyWarning);
+   EPyReferenceError = class (EPyStandardError);
+*)
+
+var
+    PyArg_Parse: function(args: PPyObject; format: PChar):
+                     Integer; cdecl;// varargs; 
+    PyArg_ParseTuple: function(args: PPyObject; format: PChar;
+                              x1: Pointer = nil;
+                              x2: Pointer = nil;
+                              x3: Pointer = nil):
+                     Integer; cdecl;// varargs
+    Py_BuildValue: function(format: PChar): PPyObject; cdecl; // varargs
+    PyCode_Addr2Line: function (co: PPyCodeObject; addrq: Integer): Integer; cdecl;
+    DLL_Py_GetBuildInfo: function: PChar; cdecl;
+
+    // define Python flags. See file pyDebug.h
+    Py_DebugFlag: PInt;
+    Py_VerboseFlag: PInt;
+    Py_InteractiveFlag: PInt;
+    Py_OptimizeFlag: PInt;
+    Py_NoSiteFlag: PInt;
+    Py_UseClassExceptionsFlag: PInt;
+    Py_FrozenFlag: PInt;
+    Py_TabcheckFlag: PInt;
+    Py_UnicodeFlag: PInt;
+    Py_IgnoreEnvironmentFlag: PInt;
+    Py_DivisionWarningFlag: PInt;
+    //_PySys_TraceFunc:    PPPyObject;
+    //_PySys_ProfileFunc: PPPPyObject;
+
+    PyImport_FrozenModules: PP_frozen;
+
+    Py_None:            PPyObject;
+    Py_Ellipsis:        PPyObject;
+    Py_False:           PPyIntObject;
+    Py_True:            PPyIntObject;
+    Py_NotImplemented:  PPyObject;
+
+    PyExc_AttributeError: PPPyObject;
+    PyExc_EOFError: PPPyObject;
+    PyExc_IOError: PPPyObject;
+    PyExc_ImportError: PPPyObject;
+    PyExc_IndexError: PPPyObject;
+    PyExc_KeyError: PPPyObject;
+    PyExc_KeyboardInterrupt: PPPyObject;
+    PyExc_MemoryError: PPPyObject;
+    PyExc_NameError: PPPyObject;
+    PyExc_OverflowError: PPPyObject;
+    PyExc_RuntimeError: PPPyObject;
+    PyExc_SyntaxError: PPPyObject;
+    PyExc_SystemError: PPPyObject;
+    PyExc_SystemExit: PPPyObject;
+    PyExc_TypeError: PPPyObject;
+    PyExc_ValueError: PPPyObject;
+    PyExc_ZeroDivisionError: PPPyObject;
+    PyExc_ArithmeticError: PPPyObject;
+    PyExc_Exception: PPPyObject;
+    PyExc_FloatingPointError: PPPyObject;
+    PyExc_LookupError: PPPyObject;
+    PyExc_StandardError: PPPyObject;
+    PyExc_AssertionError: PPPyObject;
+    PyExc_EnvironmentError: PPPyObject;
+    PyExc_IndentationError: PPPyObject;
+    PyExc_MemoryErrorInst: PPPyObject;
+    PyExc_NotImplementedError: PPPyObject;
+    PyExc_OSError: PPPyObject;
+    PyExc_TabError: PPPyObject;
+    PyExc_UnboundLocalError: PPPyObject;
+    PyExc_UnicodeError: PPPyObject;
+
+    PyExc_Warning: PPPyObject;
+    PyExc_DeprecationWarning: PPPyObject;
+    PyExc_RuntimeWarning: PPPyObject;
+    PyExc_SyntaxWarning: PPPyObject;
+    PyExc_UserWarning: PPPyObject;
+    PyExc_OverflowWarning: PPPyObject;
+    PyExc_ReferenceError: PPPyObject;
+    PyExc_StopIteration: PPPyObject;
+    PyExc_FutureWarning: PPPyObject;
+    PyExc_PendingDeprecationWarning: PPPyObject;
+    PyExc_UnicodeDecodeError: PPPyObject;
+    PyExc_UnicodeEncodeError: PPPyObject;
+    PyExc_UnicodeTranslateError: PPPyObject;
+
+    PyType_Type: PPyTypeObject;
+    PyCFunction_Type: PPyTypeObject;
+    PyCObject_Type: PPyTypeObject;
+    PyClass_Type: PPyTypeObject;
+    PyCode_Type: PPyTypeObject;
+    PyComplex_Type: PPyTypeObject;
+    PyDict_Type: PPyTypeObject;
+    PyFile_Type: PPyTypeObject;
+    PyFloat_Type: PPyTypeObject;
+    PyFrame_Type: PPyTypeObject;
+    PyFunction_Type: PPyTypeObject;
+    PyInstance_Type: PPyTypeObject;
+    PyInt_Type: PPyTypeObject;
+    PyList_Type: PPyTypeObject;
+    PyLong_Type: PPyTypeObject;
+    PyMethod_Type: PPyTypeObject;
+    PyModule_Type: PPyTypeObject;
+    PyObject_Type: PPyTypeObject;
+    PyRange_Type: PPyTypeObject;
+    PySlice_Type: PPyTypeObject;
+    PyString_Type: PPyTypeObject;
+    PyTuple_Type: PPyTypeObject;
+
+    PyBaseObject_Type: PPyTypeObject;
+    PyBuffer_Type: PPyTypeObject;
+    PyCallIter_Type: PPyTypeObject;
+    PyCell_Type: PPyTypeObject;
+    PyClassMethod_Type: PPyTypeObject;
+    PyProperty_Type: PPyTypeObject;
+    PySeqIter_Type: PPyTypeObject;
+    PyStaticMethod_Type: PPyTypeObject;
+    PySuper_Type: PPyTypeObject;
+    PySymtableEntry_Type: PPyTypeObject;
+    PyTraceBack_Type: PPyTypeObject;
+    PyUnicode_Type: PPyTypeObject;
+    PyWrapperDescr_Type: PPyTypeObject;
+
+    PyBaseString_Type: PPyTypeObject;
+    PyBool_Type: PPyTypeObject;
+    PyEnum_Type: PPyTypeObject;
+
+    //PyArg_GetObject: function(args: PPyObject; nargs, i: integer; p_a: PPPyObject): integer; cdecl;
+    //PyArg_GetLong:   function(args: PPyObject; nargs, i: integer; p_a: PLong): integer; cdecl;
+    //PyArg_GetShort:  function(args: PPyObject; nargs, i: integer; p_a: PShort): integer; cdecl;
+    //PyArg_GetFloat:  function(args: PPyObject; nargs, i: integer; p_a: PFloat): integer; cdecl;
+    //PyArg_GetString: function(args: PPyObject; nargs, i: integer; p_a: PString): integer; cdecl;
+    //PyArgs_VaParse:  function (args: PPyObject; format: PChar; va_list: array of const): integer; cdecl;
+    // Does not work!
+    // Py_VaBuildValue: function (format: PChar; va_list: array of const): PPyObject; cdecl;
+    //PyBuiltin_Init:     procedure; cdecl;
+
+    PyComplex_FromCComplex: function(c: TPy_complex):PPyObject; cdecl;
+    PyComplex_FromDoubles: function(realv,imag: double):PPyObject; cdecl;
+    PyComplex_RealAsDouble: function(op: PPyObject): double; cdecl;
+    PyComplex_ImagAsDouble: function(op: PPyObject): double; cdecl;
+    PyComplex_AsCComplex: function(op: PPyObject): TPy_complex; cdecl;
+    PyCFunction_GetFunction: function(ob: PPyObject): Pointer; cdecl;
+    PyCFunction_GetSelf: function(ob: PPyObject): PPyObject; cdecl;
+    PyCallable_Check: function(ob	: PPyObject): integer; cdecl;
+    PyCObject_FromVoidPtr: function(cobj, destruct: Pointer): PPyObject; cdecl;
+    PyCObject_AsVoidPtr: function(ob: PPyObject): Pointer; cdecl;
+    PyClass_New: function (ob1,ob2,ob3:  PPyObject): PPyObject; cdecl;
+    PyClass_IsSubclass: function (ob1, ob2: PPyObject): integer cdecl;
+
+    Py_InitModule4: function(name: PChar; methods: PPyMethodDef; doc: PChar;
+                              passthrough: PPyObject; Api_Version: Integer):PPyObject; cdecl;
+    PyErr_BadArgument:  function: integer; cdecl;
+    PyErr_BadInternalCall: procedure; cdecl;
+    PyErr_CheckSignals: function: integer; cdecl;
+    PyErr_Clear:        procedure; cdecl;
+    PyErr_Fetch:        procedure(errtype, errvalue, errtraceback: PPPyObject); cdecl;
+    PyErr_NoMemory: function: PPyObject; cdecl;
+    PyErr_Occurred:     function: PPyObject; cdecl;
+    PyErr_Print:        procedure; cdecl;
+    PyErr_Restore:      procedure  (errtype, errvalue, errtraceback: PPyObject); cdecl;
+    PyErr_SetFromErrno: function (ob:  PPyObject):PPyObject; cdecl;
+    PyErr_SetNone:      procedure(value: PPyObject); cdecl;
+    PyErr_SetObject:    procedure  (ob1, ob2	: PPyObject); cdecl;
+    PyErr_SetString:    procedure(ErrorObject: PPyObject; text: PChar); cdecl;
+    PyImport_GetModuleDict: function: PPyObject; cdecl;
+    PyInt_FromLong:     function(x: LongInt):PPyObject; cdecl;
+    Py_Initialize:      procedure; cdecl;
+    Py_Exit:            procedure(RetVal: Integer); cdecl;
+    PyEval_GetBuiltins: function: PPyObject; cdecl;
+    PyDict_GetItem: function(mp, key: PPyObject):PPyObject; cdecl;
+    PyDict_SetItem: function(mp, key, item:PPyObject):integer; cdecl;
+    PyDict_DelItem: function(mp, key: PPyObject):integer; cdecl;
+    PyDict_Clear: procedure(mp: PPyObject); cdecl;
+    PyDict_Next: function(mp: PPyObject; pos: PInt; key, value: PPPyObject):integer; cdecl;
+    PyDict_Keys: function(mp: PPyObject):PPyObject; cdecl;
+    PyDict_Values: function(mp: PPyObject):PPyObject; cdecl;
+    PyDict_Items: function(mp: PPyObject):PPyObject; cdecl;
+    PyDict_Size: function(mp: PPyObject):integer; cdecl;
+    PyDict_DelItemString: function(dp: PPyObject;key: PChar):integer; cdecl;
+    PyDict_New: function: PPyObject; cdecl;
+    PyDict_GetItemString: function(dp: PPyObject; key: PChar): PPyObject; cdecl;
+    PyDict_SetItemString: function(dp: PPyObject; key: PChar; item: PPyObject):
+                          Integer; cdecl;
+    PyDictProxy_New: function (obj: PPyObject): PPyObject; cdecl;
+    PyModule_GetDict:     function(module:PPyObject): PPyObject; cdecl;
+    PyObject_Str:         function(v: PPyObject): PPyObject; cdecl;
+    PyRun_String:         function(str: PChar; start: Integer; globals: PPyObject;
+                                    locals: PPyObject): PPyObject; cdecl;
+    PyRun_SimpleString:   function(str: PChar): Integer; cdecl;
+    PyString_AsString:    function(ob: PPyObject): PChar; cdecl;
+    PyString_FromString:  function(str: PChar): PPyObject; cdecl;
+    PySys_SetArgv:        procedure(argc: Integer; argv: PPChar); cdecl;
+
+{+ means, Grzegorz or me has tested his non object version of this function}
+{+} PyCFunction_New: function(md:PPyMethodDef;ob:PPyObject):PPyObject; cdecl;
+{+} PyEval_CallObject: function(ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyEval_CallObjectWithKeywords:function (ob1,ob2,ob3:PPyObject):PPyObject; cdecl;
+{-} PyEval_GetFrame:function:PPyObject; cdecl;
+{-} PyEval_GetGlobals:function:PPyObject; cdecl;
+{-} PyEval_GetLocals:function:PPyObject; cdecl;
+{-} //PyEval_GetOwner:function:PPyObject; cdecl;
+{-} PyEval_GetRestricted:function:integer; cdecl;
+
+{-} PyEval_InitThreads:procedure; cdecl;
+{-} PyEval_RestoreThread:procedure(tstate: PPyThreadState); cdecl;
+{-} PyEval_SaveThread:function:PPyThreadState; cdecl;
+
+{-} PyFile_FromString:function (pc1,pc2:PChar):PPyObject; cdecl;
+{-} PyFile_GetLine:function (ob:PPyObject;i:integer):PPyObject; cdecl;
+{-} PyFile_Name:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyFile_SetBufSize:procedure(ob:PPyObject;i:integer); cdecl;
+{-} PyFile_SoftSpace:function (ob:PPyObject;i:integer):integer; cdecl;
+{-} PyFile_WriteObject:function (ob1,ob2:PPyObject;i:integer):integer; cdecl;
+{-} PyFile_WriteString:procedure(s:PChar;ob:PPyObject); cdecl;
+{+} PyFloat_AsDouble:function (ob:PPyObject):DOUBLE; cdecl;
+{+} PyFloat_FromDouble:function (db:double):PPyObject; cdecl;
+{-} PyFunction_GetCode:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyFunction_GetGlobals:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyFunction_New:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyImport_AddModule:function (name:PChar):PPyObject; cdecl;
+{-} PyImport_Cleanup:procedure; cdecl;
+{-} PyImport_GetMagicNumber:function:LONGINT; cdecl;
+{+} PyImport_ImportFrozenModule:function (key:PChar):integer; cdecl;
+{+} PyImport_ImportModule:function (name:PChar):PPyObject; cdecl;
+{+} PyImport_Import:function (name:PPyObject):PPyObject; cdecl;
+{-} //PyImport_Init:procedure; cdecl;
+{-} PyImport_ReloadModule:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyInstance_New:function (obClass, obArg, obKW:PPyObject):PPyObject; cdecl;
+{+} PyInt_AsLong:function (ob:PPyObject):LONGINT; cdecl;
+{-} PyList_Append:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} PyList_AsTuple:function (ob:PPyObject):PPyObject; cdecl;
+{+} PyList_GetItem:function (ob:PPyObject;i:integer):PPyObject; cdecl;
+{-} PyList_GetSlice:function (ob:PPyObject;i1,i2:integer):PPyObject; cdecl;
+{-} PyList_Insert:function (dp:PPyObject;idx:Integer;item:PPyObject):integer; cdecl;
+{-} PyList_New:function (size:integer):PPyObject; cdecl;
+{-} PyList_Reverse:function (ob:PPyObject):integer; cdecl;
+{-} PyList_SetItem:function (dp:PPyObject;idx:Integer;item:PPyObject):integer; cdecl;
+{-} PyList_SetSlice:function (ob:PPyObject;i1,i2:integer;ob2:PPyObject):integer; cdecl;
+{+} PyList_Size:function (ob:PPyObject):integer; cdecl;
+{-} PyList_Sort:function (ob:PPyObject):integer; cdecl;
+{-} PyLong_AsDouble:function (ob:PPyObject):DOUBLE; cdecl;
+{+} PyLong_AsLong:function (ob:PPyObject):LONGINT; cdecl;
+{+} PyLong_FromDouble:function (db:double):PPyObject; cdecl;
+{+} PyLong_FromLong:function (l:longint):PPyObject; cdecl;
+{-} PyLong_FromString:function (pc:PChar;var ppc:PChar;i:integer):PPyObject; cdecl;
+{-} PyLong_FromUnsignedLong:function(val:cardinal): PPyObject; cdecl;
+{-} PyLong_AsUnsignedLong:function(ob:PPyObject): Cardinal; cdecl;
+{-} PyLong_FromUnicode:function(ob:PPyObject; a, b: integer): PPyObject; cdecl;
+{-} PyLong_FromLongLong:function(val:Int64): PPyObject; cdecl;
+{-} PyLong_AsLongLong:function(ob:PPyObject): Int64; cdecl;
+{-} PyMapping_Check:function (ob:PPyObject):integer; cdecl;
+{-} PyMapping_GetItemString:function (ob:PPyObject;key:PChar):PPyObject; cdecl;
+{-} PyMapping_HasKey:function (ob,key:PPyObject):integer; cdecl;
+{-} PyMapping_HasKeyString:function (ob:PPyObject;key:PChar):integer; cdecl;
+{-} PyMapping_Length:function (ob:PPyObject):integer; cdecl;
+{-} PyMapping_SetItemString:function (ob:PPyObject; key:PChar; value:PPyObject):integer; cdecl;
+{-} PyMethod_Class:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyMethod_Function:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyMethod_New:function (ob1,ob2,ob3:PPyObject):PPyObject; cdecl;
+{-} PyMethod_Self:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyModule_GetName:function (ob:PPyObject):PChar; cdecl;
+{-} PyModule_New:function (key:PChar):PPyObject; cdecl;
+{-} PyNumber_Absolute:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Add:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_And:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Check:function (ob:PPyObject):integer; cdecl;
+{-} PyNumber_Coerce:function (var ob1,ob2:PPyObject):integer; cdecl;
+{-} PyNumber_Divide:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_FloorDivide:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_TrueDivide:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Divmod:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Float:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Int:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Invert:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Long:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Lshift:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Multiply:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Negative:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Or:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Positive:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Power:function (ob1,ob2,ob3:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Remainder:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Rshift:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Subtract:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyNumber_Xor:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyOS_InitInterrupts:procedure; cdecl;
+{-} PyOS_InterruptOccurred:function:integer; cdecl;
+{-} PyObject_CallObject:function (ob,args:PPyObject):PPyObject; cdecl;
+{-} PyObject_Compare:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} PyObject_GetAttr:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{+} PyObject_GetAttrString:function (ob:PPyObject;c:PChar):PPyObject; cdecl;
+{-} PyObject_GetItem:function (ob,key:PPyObject):PPyObject; cdecl;
+{-} PyObject_DelItem:function (ob,key:PPyObject):PPyObject; cdecl;
+{-} PyObject_HasAttrString:function (ob:PPyObject;key:PChar):integer; cdecl;
+{-} PyObject_Hash:function (ob:PPyObject):LONGINT; cdecl;
+{-} PyObject_IsTrue:function (ob:PPyObject):integer; cdecl;
+{-} PyObject_Length:function (ob:PPyObject):integer; cdecl;
+{-} PyObject_Repr:function (ob:PPyObject):PPyObject; cdecl;
+{-} PyObject_SetAttr:function (ob1,ob2,ob3:PPyObject):integer; cdecl;
+{-} PyObject_SetAttrString:function (ob:PPyObject;key:Pchar;value:PPyObject):integer; cdecl;
+{-} PyObject_SetItem:function (ob1,ob2,ob3:PPyObject):integer; cdecl;
+{-} PyObject_Init:function (ob:PPyObject; t:PPyTypeObject):PPyObject; cdecl;
+{-} PyObject_InitVar:function (ob:PPyObject; t:PPyTypeObject; size:integer):PPyObject; cdecl;
+{-} PyObject_New:function (t:PPyTypeObject):PPyObject; cdecl;
+{-} PyObject_NewVar:function (t:PPyTypeObject; size:integer):PPyObject; cdecl;
+    PyObject_Free:procedure (ob:PPyObject); cdecl;
+{-} PyObject_IsInstance:function (inst, cls:PPyObject):integer; cdecl;
+{-} PyObject_IsSubclass:function (derived, cls:PPyObject):integer; cdecl;
+    PyObject_GenericGetAttr:function (obj, name: PPyObject): PPyObject; cdecl;
+    PyObject_GenericSetAttr:function (obj, name, value: PPyObject): Integer; cdecl;
+{-} PyObject_GC_Malloc:function (size:integer):PPyObject; cdecl;
+{-} PyObject_GC_New:function (t:PPyTypeObject):PPyObject; cdecl;
+{-} PyObject_GC_NewVar:function (t:PPyTypeObject; size:integer):PPyObject; cdecl;
+{-} PyObject_GC_Resize:function (t:PPyObject; newsize:integer):PPyObject; cdecl;
+{-} PyObject_GC_Del:procedure (ob:PPyObject); cdecl;
+{-} PyObject_GC_Track:procedure (ob:PPyObject); cdecl;
+{-} PyObject_GC_UnTrack:procedure (ob:PPyObject); cdecl;
+{-} PyRange_New:function (l1,l2,l3:longint;i:integer):PPyObject; cdecl;
+{-} PySequence_Check:function (ob:PPyObject):integer; cdecl;
+{-} PySequence_Concat:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PySequence_Count:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} PySequence_GetItem:function (ob:PPyObject;i:integer):PPyObject; cdecl;
+{-} PySequence_GetSlice:function (ob:PPyObject;i1,i2:integer):PPyObject; cdecl;
+{-} PySequence_In:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} PySequence_Index:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} PySequence_Length:function (ob:PPyObject):integer; cdecl;
+{-} PySequence_Repeat:function (ob:PPyObject;count:integer):PPyObject; cdecl;
+{-} PySequence_SetItem:function (ob:PPyObject;i:integer;value:PPyObject):integer; cdecl;
+{-} PySequence_SetSlice:function (ob:PPyObject;i1,i2:integer;value:PPyObject):integer; cdecl;
+{-} PySequence_DelSlice:function (ob:PPyObject;i1,i2:integer):integer; cdecl;
+{-} PySequence_Tuple:function (ob:PPyObject):PPyObject; cdecl;
+{-} PySequence_Contains:function (ob, value:PPyObject):integer; cdecl;
+{-} PySlice_GetIndices:function (ob:PPySliceObject;length:integer;var start,stop,step:integer):integer; cdecl;
+{-} PySlice_GetIndicesEx:function (ob:PPySliceObject;length:integer;var start,stop,step,slicelength:integer):integer; cdecl;
+{-} PySlice_New:function (start,stop,step:PPyObject):PPyObject; cdecl;
+{-} PyString_Concat:procedure(var ob1:PPyObject;ob2:PPyObject); cdecl;
+{-} PyString_ConcatAndDel:procedure(var ob1:PPyObject;ob2:PPyObject); cdecl;
+{-} PyString_Format:function (ob1,ob2:PPyObject):PPyObject; cdecl;
+{-} PyString_FromStringAndSize:function (s:PChar;i:integer):PPyObject; cdecl;
+{-} PyString_Size:function (ob:PPyObject):integer; cdecl;
+{-} PyString_DecodeEscape:function(s:PChar; len:integer; errors:PChar; unicode:integer; recode_encoding:PChar):PPyObject; cdecl;
+{-} PyString_Repr:function(ob:PPyObject; smartquotes:integer):PPyObject; cdecl;
+{+} PySys_GetObject:function (s:PChar):PPyObject; cdecl;
+{-} //PySys_Init:procedure; cdecl;
+{-} PySys_SetObject:function (s:PChar;ob:PPyObject):integer; cdecl;
+{-} PySys_SetPath:procedure(path:PChar); cdecl;
+{-} //PyTraceBack_Fetch:function:PPyObject; cdecl;
+{-} PyTraceBack_Here:function (p:pointer):integer; cdecl;
+{-} PyTraceBack_Print:function (ob1,ob2:PPyObject):integer; cdecl;
+{-} //PyTraceBack_Store:function (ob:PPyObject):integer; cdecl;
+{+} PyTuple_GetItem:function (ob:PPyObject;i:integer):PPyObject; cdecl;
+{-} PyTuple_GetSlice:function (ob:PPyObject;i1,i2:integer):PPyObject; cdecl;
+{+} PyTuple_New:function (size:Integer):PPyObject; cdecl;
+{+} PyTuple_SetItem:function (ob:PPyObject;key:integer;value:PPyObject):integer; cdecl;
+{+} PyTuple_Size:function (ob:PPyObject):integer; cdecl;
+{+} PyType_IsSubtype:function (a, b: PPyTypeObject):integer; cdecl;
+    PyType_GenericAlloc:function(atype: PPyTypeObject; nitems:Integer): PPyObject; cdecl;
+    PyType_GenericNew:function(atype: PPyTypeObject; args, kwds: PPyObject): PPyObject; cdecl;
+    PyType_Ready:function(atype: PPyTypeObject): integer; cdecl;
+{+} PyUnicode_FromWideChar:function (const w:PWideChar; size:integer):PPyObject; cdecl;
+{+} PyUnicode_AsWideChar:function (unicode: PPyObject; w:PWideChar; size:integer):integer; cdecl;
+{-} PyUnicode_FromOrdinal:function (ordinal:integer):PPyObject; cdecl;
+    PyWeakref_GetObject: function (ref: PPyObject): PPyObject; cdecl;
+    PyWeakref_NewProxy: function (ob, callback: PPyObject): PPyObject; cdecl;
+    PyWeakref_NewRef: function (ob, callback: PPyObject): PPyObject; cdecl;
+    PyWrapper_New: function (ob1, ob2: PPyObject): PPyObject; cdecl;
+    PyBool_FromLong: function (ok: Integer): PPyObject; cdecl;
+{-} Py_AtExit:function (proc: procedure):integer; cdecl;
+{-} //Py_Cleanup:procedure; cdecl;
+{-} Py_CompileString:function (s1,s2:PChar;i:integer):PPyObject; cdecl;
+{-} Py_FatalError:procedure(s:PChar); cdecl;
+{-} Py_FindMethod:function (md:PPyMethodDef;ob:PPyObject;key:PChar):PPyObject; cdecl;
+{-} Py_FindMethodInChain:function (mc:PPyMethodChain;ob:PPyObject;key:PChar):PPyObject; cdecl;
+{-} Py_FlushLine:procedure; cdecl;
+{+} Py_Finalize: procedure; cdecl;
+{-} PyErr_ExceptionMatches: function (exc: PPyObject): Integer; cdecl;
+{-} PyErr_GivenExceptionMatches: function (raised_exc, exc: PPyObject): Integer; cdecl;
+{-} PyEval_EvalCode: function (co: PPyCodeObject; globals, locals: PPyObject): PPyObject; cdecl;
+{+} Py_GetVersion: function: PChar; cdecl;
+{+} Py_GetCopyright: function: PChar; cdecl;
+{+} Py_GetExecPrefix: function: PChar; cdecl;
+{+} Py_GetPath: function: PChar; cdecl;
+{+} Py_GetPrefix: function: PChar; cdecl;
+{+} Py_GetProgramName: function: PChar; cdecl;
+
+{-} PyParser_SimpleParseString: function (str: PChar; start: Integer): PNode; cdecl;
+{-} PyNode_Free: procedure(n: PNode); cdecl;
+{-} PyErr_NewException: function (name: PChar; base, dict: PPyObject): PPyObject; cdecl;
+{-} Py_Malloc: function (size: Integer): Pointer;
+{-} PyMem_Malloc: function (size: Integer): Pointer;
+{-} PyObject_CallMethod: function (obj: PPyObject; method, format: PChar): PPyObject; cdecl;
+
+{New exported Objects in Python 1.5}
+    Py_SetProgramName: procedure(name: PChar); cdecl;
+    Py_IsInitialized: function: integer; cdecl;
+    Py_GetProgramFullPath: function: PChar; cdecl;
+    Py_NewInterpreter: function: PPyThreadState; cdecl;
+    Py_EndInterpreter: procedure(tstate: PPyThreadState); cdecl;
+    PyEval_AcquireLock: procedure; cdecl;
+    PyEval_ReleaseLock: procedure; cdecl;
+    PyEval_AcquireThread: procedure(tstate: PPyThreadState); cdecl;
+    PyEval_ReleaseThread: procedure(tstate: PPyThreadState); cdecl;
+    PyInterpreterState_New: function: PPyInterpreterState; cdecl;
+    PyInterpreterState_Clear: procedure(interp: PPyInterpreterState); cdecl;
+    PyInterpreterState_Delete: procedure(interp: PPyInterpreterState); cdecl;
+    PyThreadState_New: function (interp: PPyInterpreterState): PPyThreadState; cdecl;
+    PyThreadState_Clear: procedure(tstate: PPyThreadState); cdecl;
+    PyThreadState_Delete: procedure(tstate: PPyThreadState); cdecl;
+    PyThreadState_Get: function: PPyThreadState; cdecl;
+    PyThreadState_Swap: function (tstate: PPyThreadState): PPyThreadState; cdecl;
+
+{Further exported Objects, may be implemented later}
+{
+    PyCode_New: Pointer;
+    PyErr_SetInterrupt: Pointer;
+    PyFile_AsFile: Pointer;
+    PyFile_FromFile: Pointer;
+    PyFloat_AsString: Pointer;
+    PyFrame_BlockPop: Pointer;
+    PyFrame_BlockSetup: Pointer;
+    PyFrame_ExtendStack: Pointer;
+    PyFrame_FastToLocals: Pointer;
+    PyFrame_LocalsToFast: Pointer;
+    PyFrame_New: Pointer;
+    PyGrammar_AddAccelerators: Pointer;
+    PyGrammar_FindDFA: Pointer;
+    PyGrammar_LabelRepr: Pointer;
+    PyInstance_DoBinOp: Pointer;
+    PyInt_GetMax: Pointer;
+    PyMarshal_Init: Pointer;
+    PyMarshal_ReadLongFromFile: Pointer;
+    PyMarshal_ReadObjectFromFile: Pointer;
+    PyMarshal_ReadObjectFromString: Pointer;
+    PyMarshal_WriteLongToFile: Pointer;
+    PyMarshal_WriteObjectToFile: Pointer;
+    PyMember_Get: Pointer;
+    PyMember_Set: Pointer;
+    PyNode_AddChild: Pointer;
+    PyNode_Compile: Pointer;
+    PyNode_New: Pointer;
+    PyOS_GetLastModificationTime: Pointer;
+    PyOS_Readline: Pointer;
+    PyOS_strtol: Pointer;
+    PyOS_strtoul: Pointer;
+    PyObject_CallFunction: Pointer;
+    PyObject_CallMethod: Pointer;
+    PyObject_Print: Pointer;
+    PyParser_AddToken: Pointer;
+    PyParser_Delete: Pointer;
+    PyParser_New: Pointer;
+    PyParser_ParseFile: Pointer;
+    PyParser_ParseString: Pointer;
+    PyParser_SimpleParseFile: Pointer;
+    PyRun_AnyFile: Pointer;
+    PyRun_File: Pointer;
+    PyRun_InteractiveLoop: Pointer;
+    PyRun_InteractiveOne: Pointer;
+    PyRun_SimpleFile: Pointer;
+    PySys_GetFile: Pointer;
+    PyToken_OneChar: Pointer;
+    PyToken_TwoChars: Pointer;
+    PyTokenizer_Free: Pointer;
+    PyTokenizer_FromFile: Pointer;
+    PyTokenizer_FromString: Pointer;
+    PyTokenizer_Get: Pointer;
+    Py_Main: Pointer;
+    _PyObject_NewVar: Pointer;
+    _PyParser_Grammar: Pointer;
+    _PyParser_TokenNames: Pointer;
+    _PyThread_Started: Pointer;
+    _Py_c_diff: Pointer;
+    _Py_c_neg: Pointer;
+    _Py_c_pow: Pointer;
+    _Py_c_prod: Pointer;
+    _Py_c_quot: Pointer;
+    _Py_c_sum: Pointer;
+}
+// functions redefined in Delphi
+procedure Py_INCREF(op: PPyObject);
+procedure Py_DECREF(op: PPyObject);
+procedure Py_XINCREF(op: PPyObject);
+procedure Py_XDECREF(op: PPyObject);
+
+// This function handles all cardinals, pointer types (with no adjustment of pointers!)
+// (Extended) floats, which are handled as Python doubles and currencies, handled
+// as (normalized) Python doubles.
+function PyImport_ExecCodeModule(const name: String; codeobject: PPyObject): PPyObject;
+function PyString_Check(obj: PPyObject): Boolean;
+function PyString_CheckExact(obj: PPyObject): Boolean;
+function PyFloat_Check(obj: PPyObject): Boolean;
+function PyFloat_CheckExact(obj: PPyObject): Boolean;
+function PyInt_Check(obj: PPyObject): Boolean;
+function PyInt_CheckExact(obj: PPyObject): Boolean;
+function PyLong_Check(obj: PPyObject): Boolean;
+function PyLong_CheckExact(obj: PPyObject): Boolean;
+function PyTuple_Check(obj: PPyObject): Boolean;
+function PyTuple_CheckExact(obj: PPyObject): Boolean;
+function PyInstance_Check(obj: PPyObject): Boolean;
+function PyClass_Check(obj: PPyObject): Boolean;
+function PyMethod_Check(obj: PPyObject): Boolean;
+function PyList_Check(obj: PPyObject): Boolean;
+function PyList_CheckExact(obj: PPyObject): Boolean;
+function PyDict_Check(obj: PPyObject): Boolean;
+function PyDict_CheckExact(obj: PPyObject): Boolean;
+function PyModule_Check(obj: PPyObject): Boolean;
+function PyModule_CheckExact(obj: PPyObject): Boolean;
+function PySlice_Check(obj: PPyObject): Boolean;
+function PyFunction_Check(obj: PPyObject): Boolean;
+function PyUnicode_Check(obj: PPyObject): Boolean;
+function PyUnicode_CheckExact(obj: PPyObject): Boolean;
+function PyType_IS_GC(t: PPyTypeObject): Boolean;
+function PyObject_IS_GC(obj: PPyObject): Boolean;
+function PyWeakref_Check(obj: PPyObject): Boolean;
+function PyWeakref_CheckRef(obj: PPyObject): Boolean;
+function PyWeakref_CheckProxy(obj: PPyObject): Boolean;
+function PyBool_Check(obj: PPyObject): Boolean;
+function PyBaseString_Check(obj: PPyObject): Boolean;
+function PyEnum_Check(obj: PPyObject): Boolean;
+function PyObject_TypeCheck(obj:PPyObject; t:PPyTypeObject): Boolean;
+function Py_InitModule(const name: PChar; md: PPyMethodDef): PPyObject;
+
+function  PyType_HasFeature(AType: PPyTypeObject; AFlag: Integer): Boolean;
+
+implementation
+
+procedure Py_INCREF(op: PPyObject);
+begin
+  Inc(op.ob_refcnt);
+end;
+
+procedure Py_DECREF(op: PPyObject);
+begin
+  Dec(op.ob_refcnt);
+  if op.ob_refcnt = 0 then begin
+    op.ob_type.tp_dealloc(op);
+  end;
+end;
+
+procedure Py_XINCREF(op: PPyObject);
+begin
+  if op <> nil then Py_INCREF(op);
+end;
+
+procedure Py_XDECREF(op: PPyObject);
+begin
+  if op <> nil then Py_DECREF(op);
+end;
+
+function PyImport_ExecCodeModule(const name: String; 
+             codeobject: PPyObject): PPyObject;
+var
+  m, d, v, modules: PPyObject;
+begin
+  m:= PyImport_AddModule(PChar(name));
+  if m = nil then
+    begin
+      Result:= nil;
+      Exit;
+    end;
+  d:= PyModule_GetDict(m);
+  if PyDict_GetItemString(d, '__builtins__') = nil then
+    begin
+      if PyDict_SetItemString(d, '__builtins__', PyEval_GetBuiltins) <> 0 then
+        begin
+          Result:= nil;
+          Exit;
+        end;
+    end;
+  // Remember the fielname as the __file__ attribute
+  if PyDict_SetItemString(d, '__file__', PPyCodeObject(codeobject).co_filename) <> 0 then
+    PyErr_Clear(); // Not important enough to report
+  v:= PyEval_EvalCode(PPyCodeObject(codeobject), d, d); // XXX owner ?
+  if v = nil then
+    begin
+      Result:= nil;
+      Exit;
+    end;
+  Py_XDECREF(v);
+  modules:= PyImport_GetModuleDict();
+  if PyDict_GetItemString(modules, PChar(name)) = nil then
+    begin
+      PyErr_SetString(PyExc_ImportError^, PChar(Format('Loaded module %.200s not found in sys.modules', [name])));
+      Result:= nil;
+      Exit;
+    end;
+  Py_XINCREF(m);
+  Result:= m;
+end;
+
+function PyString_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyString_Type);
+end;
+
+function PyString_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj.ob_type = PPyTypeObject(PyString_Type));
+end;
+
+function PyFloat_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyFloat_Type);
+end;
+
+function PyFloat_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj.ob_type = PPyTypeObject(PyFloat_Type));
+end;
+
+function PyInt_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyInt_Type);
+end;
+
+function PyInt_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj.ob_type = PPyTypeObject(PyInt_Type));
+end;
+
+function PyLong_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyLong_Type);
+end;
+
+function PyLong_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj.ob_type = PPyTypeObject(PyLong_Type));
+end;
+
+function PyTuple_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyTuple_Type);
+end;
+
+function PyTuple_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= ( obj<> nil) and (obj^.ob_type = PPyTypeObject(PyTuple_Type));
+end;
+
+function PyInstance_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj^.ob_type = PPyTypeObject(PyInstance_Type));
+end;
+
+function PyClass_Check(obj: PPyObject): Boolean;
+begin
+  Result:= ( obj<> nil) and (obj^.ob_type = PPyTypeObject(PyClass_Type));
+end;
+
+function PyMethod_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj <> nil) and (obj^.ob_type = PPyTypeObject(PyMethod_Type));
+end;
+
+function PyList_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyList_Type);
+end;
+
+function PyList_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj^.ob_type = PPyTypeObject(PyList_Type));
+end;
+
+function PyDict_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyDict_Type);
+end;
+
+function PyDict_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj^.ob_type = PPyTypeObject(PyDict_Type));
+end;
+
+function PyModule_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyModule_Type);
+end;
+
+function PyModule_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj^.ob_type = PPyTypeObject(PyModule_Type));
+end;
+
+function PySlice_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj^.ob_type = PPyTypeObject(PySlice_Type));
+end;
+
+function PyFunction_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and
+    ((obj.ob_type = PPyTypeObject(PyCFunction_Type)) or
+     (obj.ob_type = PPyTypeObject(PyFunction_Type)));
+end;
+
+function PyUnicode_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyUnicode_Type);
+end;
+
+function PyUnicode_CheckExact(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj^.ob_type = PPyTypeObject(PyUnicode_Type));
+end;
+
+function PyType_IS_GC(t: PPyTypeObject): Boolean;
+begin
+  Result:= PyType_HasFeature(t, Py_TPFLAGS_HAVE_GC);
+end;
+
+function PyObject_IS_GC(obj: PPyObject): Boolean;
+begin
+  Result:= PyType_IS_GC(obj.ob_type) and
+            ((obj.ob_type.tp_is_gc = nil) or (obj.ob_type.tp_is_gc(obj) = 1));
+end;
+
+function PyWeakref_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (PyWeakref_CheckRef(obj) or PyWeakref_CheckProxy(obj));
+end;
+
+function PyWeakref_CheckRef(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj.ob_type = PPyTypeObject(PyWeakref_RefType));
+end;
+
+function PyWeakref_CheckProxy(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and
+            ((obj.ob_type = PPyTypeObject(PyWeakref_ProxyType)) or
+              (obj.ob_type = PPyTypeObject(PyWeakref_CallableProxyType)));
+end;
+
+function PyBool_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj.ob_type = PPyTypeObject(PyBool_Type));
+end;
+
+function PyBaseString_Check(obj: PPyObject): Boolean;
+begin
+  Result:= PyObject_TypeCheck(obj, PyBaseString_Type);
+end;
+
+function PyEnum_Check(obj: PPyObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj.ob_type = PPyTypeObject(PyEnum_Type));
+end;
+
+function PyObject_TypeCheck(obj: PPyObject; t: PPyTypeObject): Boolean;
+begin
+  Result:= (obj<>nil) and (obj.ob_type = t);
+  if not Result and (obj<>nil) and (t<>nil) then
+    Result:= PyType_IsSubtype(obj.ob_type, t) = 1;
+end;
+
+function Py_InitModule(const name: PChar; md: PPyMethodDef): PPyObject;
+begin
+  result:= Py_InitModule4(name, md, nil, nil, 1012);
+end;
+
+function PyType_HasFeature(AType: PPyTypeObject; AFlag: Integer): Boolean;
+begin
+  //(((t)->tp_flags & (f)) != 0)
+  Result:= (AType.tp_flags and AFlag) <> 0;
+end;
+
+procedure init(lib: TLibHandle);
+begin
+  Py_DebugFlag               := getProcAddr(lib, 'Py_DebugFlag');
+  Py_VerboseFlag             := getProcAddr(lib, 'Py_VerboseFlag');
+  Py_InteractiveFlag         := getProcAddr(lib, 'Py_InteractiveFlag');
+  Py_OptimizeFlag            := getProcAddr(lib, 'Py_OptimizeFlag');
+  Py_NoSiteFlag              := getProcAddr(lib, 'Py_NoSiteFlag');
+  Py_UseClassExceptionsFlag  := getProcAddr(lib, 'Py_UseClassExceptionsFlag');
+  Py_FrozenFlag              := getProcAddr(lib, 'Py_FrozenFlag');
+  Py_TabcheckFlag            := getProcAddr(lib, 'Py_TabcheckFlag');
+  Py_UnicodeFlag             := getProcAddr(lib, 'Py_UnicodeFlag');
+
+  Py_IgnoreEnvironmentFlag   := getProcAddr(lib, 'Py_IgnoreEnvironmentFlag');
+  Py_DivisionWarningFlag     := getProcAddr(lib, 'Py_DivisionWarningFlag');
+  Py_None                    := getProcAddr(lib, '_Py_NoneStruct');
+  Py_Ellipsis                := getProcAddr(lib, '_Py_EllipsisObject');
+  Py_False                   := getProcAddr(lib, '_Py_ZeroStruct');
+  Py_True                    := getProcAddr(lib, '_Py_TrueStruct');
+  Py_NotImplemented          := getProcAddr(lib, '_Py_NotImplementedStruct');
+
+  PyImport_FrozenModules     := getProcAddr(lib, 'PyImport_FrozenModules');
+
+  PyExc_AttributeError       := getProcAddr(lib, 'PyExc_AttributeError');
+  PyExc_EOFError             := getProcAddr(lib, 'PyExc_EOFError');
+  PyExc_IOError              := getProcAddr(lib, 'PyExc_IOError');
+  PyExc_ImportError          := getProcAddr(lib, 'PyExc_ImportError');
+  PyExc_IndexError           := getProcAddr(lib, 'PyExc_IndexError');
+  PyExc_KeyError             := getProcAddr(lib, 'PyExc_KeyError');
+  PyExc_KeyboardInterrupt    := getProcAddr(lib, 'PyExc_KeyboardInterrupt');
+  PyExc_MemoryError          := getProcAddr(lib, 'PyExc_MemoryError');
+  PyExc_NameError            := getProcAddr(lib, 'PyExc_NameError');
+  PyExc_OverflowError        := getProcAddr(lib, 'PyExc_OverflowError');
+  PyExc_RuntimeError         := getProcAddr(lib, 'PyExc_RuntimeError');
+  PyExc_SyntaxError          := getProcAddr(lib, 'PyExc_SyntaxError');
+  PyExc_SystemError          := getProcAddr(lib, 'PyExc_SystemError');
+  PyExc_SystemExit           := getProcAddr(lib, 'PyExc_SystemExit');
+  PyExc_TypeError            := getProcAddr(lib, 'PyExc_TypeError');
+  PyExc_ValueError           := getProcAddr(lib, 'PyExc_ValueError');
+  PyExc_ZeroDivisionError    := getProcAddr(lib, 'PyExc_ZeroDivisionError');
+  PyExc_ArithmeticError      := getProcAddr(lib, 'PyExc_ArithmeticError');
+  PyExc_Exception            := getProcAddr(lib, 'PyExc_Exception');
+  PyExc_FloatingPointError   := getProcAddr(lib, 'PyExc_FloatingPointError');
+  PyExc_LookupError          := getProcAddr(lib, 'PyExc_LookupError');
+  PyExc_StandardError        := getProcAddr(lib, 'PyExc_StandardError');
+
+  PyExc_AssertionError       := getProcAddr(lib, 'PyExc_AssertionError');
+  PyExc_EnvironmentError     := getProcAddr(lib, 'PyExc_EnvironmentError');
+  PyExc_IndentationError     := getProcAddr(lib, 'PyExc_IndentationError');
+  PyExc_MemoryErrorInst      := getProcAddr(lib, 'PyExc_MemoryErrorInst');
+  PyExc_NotImplementedError  := getProcAddr(lib, 'PyExc_NotImplementedError');
+  PyExc_OSError              := getProcAddr(lib, 'PyExc_OSError');
+  PyExc_TabError             := getProcAddr(lib, 'PyExc_TabError');
+  PyExc_UnboundLocalError    := getProcAddr(lib, 'PyExc_UnboundLocalError');
+  PyExc_UnicodeError         := getProcAddr(lib, 'PyExc_UnicodeError');
+
+  PyExc_Warning              := getProcAddr(lib, 'PyExc_Warning');
+  PyExc_DeprecationWarning   := getProcAddr(lib, 'PyExc_DeprecationWarning');
+  PyExc_RuntimeWarning       := getProcAddr(lib, 'PyExc_RuntimeWarning');
+  PyExc_SyntaxWarning        := getProcAddr(lib, 'PyExc_SyntaxWarning');
+  PyExc_UserWarning          := getProcAddr(lib, 'PyExc_UserWarning');
+
+  PyExc_OverflowWarning      := getProcAddr(lib, 'PyExc_OverflowWarning');
+  PyExc_ReferenceError       := getProcAddr(lib, 'PyExc_ReferenceError');
+  PyExc_StopIteration        := getProcAddr(lib, 'PyExc_StopIteration');
+
+  PyExc_FutureWarning        := getProcAddr(lib, 'PyExc_FutureWarning');
+  PyExc_PendingDeprecationWarning:= getProcAddr(lib, 'PyExc_PendingDeprecationWarning');
+  PyExc_UnicodeDecodeError   := getProcAddr(lib, 'PyExc_UnicodeDecodeError');
+  PyExc_UnicodeEncodeError   := getProcAddr(lib, 'PyExc_UnicodeEncodeError');
+  PyExc_UnicodeTranslateError:= getProcAddr(lib, 'PyExc_UnicodeTranslateError');
+
+  PyType_Type                := getProcAddr(lib, 'PyType_Type');
+  PyCFunction_Type           := getProcAddr(lib, 'PyCFunction_Type');
+  PyCObject_Type             := getProcAddr(lib, 'PyCObject_Type');
+  PyClass_Type               := getProcAddr(lib, 'PyClass_Type');
+  PyCode_Type                := getProcAddr(lib, 'PyCode_Type');
+  PyComplex_Type             := getProcAddr(lib, 'PyComplex_Type');
+  PyDict_Type                := getProcAddr(lib, 'PyDict_Type');
+  PyFile_Type                := getProcAddr(lib, 'PyFile_Type');
+  PyFloat_Type               := getProcAddr(lib, 'PyFloat_Type');
+  PyFrame_Type               := getProcAddr(lib, 'PyFrame_Type');
+  PyFunction_Type            := getProcAddr(lib, 'PyFunction_Type');
+  PyInstance_Type            := getProcAddr(lib, 'PyInstance_Type');
+  PyInt_Type                 := getProcAddr(lib, 'PyInt_Type');
+  PyList_Type                := getProcAddr(lib, 'PyList_Type');
+  PyLong_Type                := getProcAddr(lib, 'PyLong_Type');
+  PyMethod_Type              := getProcAddr(lib, 'PyMethod_Type');
+  PyModule_Type              := getProcAddr(lib, 'PyModule_Type');
+  PyObject_Type              := getProcAddr(lib, 'PyObject_Type');
+  PyRange_Type               := getProcAddr(lib, 'PyRange_Type');
+  PySlice_Type               := getProcAddr(lib, 'PySlice_Type');
+  PyString_Type              := getProcAddr(lib, 'PyString_Type');
+  PyTuple_Type               := getProcAddr(lib, 'PyTuple_Type');
+
+  PyUnicode_Type             := getProcAddr(lib, 'PyUnicode_Type');
+
+  PyBaseObject_Type          := getProcAddr(lib, 'PyBaseObject_Type');
+  PyBuffer_Type              := getProcAddr(lib, 'PyBuffer_Type');
+  PyCallIter_Type            := getProcAddr(lib, 'PyCallIter_Type');
+  PyCell_Type                := getProcAddr(lib, 'PyCell_Type');
+  PyClassMethod_Type         := getProcAddr(lib, 'PyClassMethod_Type');
+  PyProperty_Type            := getProcAddr(lib, 'PyProperty_Type');
+  PySeqIter_Type             := getProcAddr(lib, 'PySeqIter_Type');
+  PyStaticMethod_Type        := getProcAddr(lib, 'PyStaticMethod_Type');
+  PySuper_Type               := getProcAddr(lib, 'PySuper_Type');
+  PySymtableEntry_Type       := getProcAddr(lib, 'PySymtableEntry_Type');
+  PyTraceBack_Type           := getProcAddr(lib, 'PyTraceBack_Type');
+  PyWrapperDescr_Type        := getProcAddr(lib, 'PyWrapperDescr_Type');
+
+  PyBaseString_Type          := getProcAddr(lib, 'PyBaseString_Type');
+  PyBool_Type                := getProcAddr(lib, 'PyBool_Type');
+  PyEnum_Type                := getProcAddr(lib, 'PyEnum_Type');
+
+
+  //PyArg_GetObject           := getProcAddr(lib, 'PyArg_GetObject');
+  //PyArg_GetLong             := getProcAddr(lib, 'PyArg_GetLong');
+  //PyArg_GetShort            := getProcAddr(lib, 'PyArg_GetShort');
+  //PyArg_GetFloat            := getProcAddr(lib, 'PyArg_GetFloat');
+  //PyArg_GetString           := getProcAddr(lib, 'PyArg_GetString');
+  //PyArgs_VaParse            := getProcAddr(lib, 'PyArgs_VaParse');
+  //Py_VaBuildValue           := getProcAddr(lib, 'Py_VaBuildValue');
+  //PyBuiltin_Init            := getProcAddr(lib, 'PyBuiltin_Init');
+  PyComplex_FromCComplex    := getProcAddr(lib, 'PyComplex_FromCComplex');
+  PyComplex_FromDoubles     := getProcAddr(lib, 'PyComplex_FromDoubles');
+  PyComplex_RealAsDouble    := getProcAddr(lib, 'PyComplex_RealAsDouble');
+  PyComplex_ImagAsDouble    := getProcAddr(lib, 'PyComplex_ImagAsDouble');
+  PyComplex_AsCComplex      := getProcAddr(lib, 'PyComplex_AsCComplex');
+  PyCFunction_GetFunction   := getProcAddr(lib, 'PyCFunction_GetFunction');
+  PyCFunction_GetSelf       := getProcAddr(lib, 'PyCFunction_GetSelf');
+  PyCallable_Check          := getProcAddr(lib, 'PyCallable_Check');
+  PyCObject_FromVoidPtr     := getProcAddr(lib, 'PyCObject_FromVoidPtr');
+  PyCObject_AsVoidPtr       := getProcAddr(lib, 'PyCObject_AsVoidPtr');
+  PyClass_New               := getProcAddr(lib, 'PyClass_New');
+  PyClass_IsSubclass        := getProcAddr(lib, 'PyClass_IsSubclass');
+  PyDict_GetItem            := getProcAddr(lib, 'PyDict_GetItem');
+  PyDict_SetItem            := getProcAddr(lib, 'PyDict_SetItem');
+  PyDict_DelItem            := getProcAddr(lib, 'PyDict_DelItem');
+  PyDict_Clear              := getProcAddr(lib, 'PyDict_Clear');
+  PyDict_Next               := getProcAddr(lib, 'PyDict_Next');
+  PyDict_Keys               := getProcAddr(lib, 'PyDict_Keys');
+  PyDict_Values             := getProcAddr(lib, 'PyDict_Values');
+  PyDict_Items              := getProcAddr(lib, 'PyDict_Items');
+  PyDict_Size               := getProcAddr(lib, 'PyDict_Size');
+  PyDict_DelItemString      := getProcAddr(lib, 'PyDict_DelItemString');
+  PyDictProxy_New           := getProcAddr(lib, 'PyDictProxy_New');
+  Py_InitModule4            := getProcAddr(lib, 'Py_InitModule4');
+  PyErr_Print               := getProcAddr(lib, 'PyErr_Print');
+  PyErr_SetNone             := getProcAddr(lib, 'PyErr_SetNone');
+  PyErr_SetObject           := getProcAddr(lib, 'PyErr_SetObject');
+  PyErr_Restore             := getProcAddr(lib, 'PyErr_Restore');
+  PyErr_BadArgument         := getProcAddr(lib, 'PyErr_BadArgument');
+  PyErr_NoMemory            := getProcAddr(lib, 'PyErr_NoMemory');
+  PyErr_SetFromErrno        := getProcAddr(lib, 'PyErr_SetFromErrno');
+  PyErr_BadInternalCall     := getProcAddr(lib, 'PyErr_BadInternalCall');
+  PyErr_CheckSignals        := getProcAddr(lib, 'PyErr_CheckSignals');
+  PyErr_Occurred            := getProcAddr(lib, 'PyErr_Occurred');
+  PyErr_Clear               := getProcAddr(lib, 'PyErr_Clear');
+  PyErr_Fetch               := getProcAddr(lib, 'PyErr_Fetch');
+  PyErr_SetString           := getProcAddr(lib, 'PyErr_SetString');
+  PyEval_GetBuiltins        := getProcAddr(lib, 'PyEval_GetBuiltins');
+  PyImport_GetModuleDict    := getProcAddr(lib, 'PyImport_GetModuleDict');
+  PyInt_FromLong            := getProcAddr(lib, 'PyInt_FromLong');
+  PyArg_ParseTuple      := getProcAddr(lib, 'PyArg_ParseTuple');
+  PyArg_Parse           := getProcAddr(lib, 'PyArg_Parse');
+  Py_BuildValue         := getProcAddr(lib, 'Py_BuildValue');
+  Py_Initialize             := getProcAddr(lib, 'Py_Initialize');
+  PyDict_New                := getProcAddr(lib, 'PyDict_New');
+  PyDict_SetItemString      := getProcAddr(lib, 'PyDict_SetItemString');
+  PyModule_GetDict          := getProcAddr(lib, 'PyModule_GetDict');
+  PyObject_Str              := getProcAddr(lib, 'PyObject_Str');
+  PyRun_String              := getProcAddr(lib, 'PyRun_String');
+  PyRun_SimpleString        := getProcAddr(lib, 'PyRun_SimpleString');
+  PyDict_GetItemString      := getProcAddr(lib, 'PyDict_GetItemString');
+  PyString_AsString         := getProcAddr(lib, 'PyString_AsString');
+  PyString_FromString       := getProcAddr(lib, 'PyString_FromString');
+  PySys_SetArgv             := getProcAddr(lib, 'PySys_SetArgv');
+  Py_Exit                   := getProcAddr(lib, 'Py_Exit');
+
+  PyCFunction_New           :=getProcAddr(lib, 'PyCFunction_New');
+  PyEval_CallObject         :=getProcAddr(lib, 'PyEval_CallObject');
+  PyEval_CallObjectWithKeywords:=getProcAddr(lib, 'PyEval_CallObjectWithKeywords');
+  PyEval_GetFrame           :=getProcAddr(lib, 'PyEval_GetFrame');
+  PyEval_GetGlobals         :=getProcAddr(lib, 'PyEval_GetGlobals');
+  PyEval_GetLocals          :=getProcAddr(lib, 'PyEval_GetLocals');
+  //PyEval_GetOwner           :=getProcAddr(lib, 'PyEval_GetOwner');
+  PyEval_GetRestricted      :=getProcAddr(lib, 'PyEval_GetRestricted');
+  PyEval_InitThreads        :=getProcAddr(lib, 'PyEval_InitThreads');
+  PyEval_RestoreThread      :=getProcAddr(lib, 'PyEval_RestoreThread');
+  PyEval_SaveThread         :=getProcAddr(lib, 'PyEval_SaveThread');
+  PyFile_FromString         :=getProcAddr(lib, 'PyFile_FromString');
+  PyFile_GetLine            :=getProcAddr(lib, 'PyFile_GetLine');
+  PyFile_Name               :=getProcAddr(lib, 'PyFile_Name');
+  PyFile_SetBufSize         :=getProcAddr(lib, 'PyFile_SetBufSize');
+  PyFile_SoftSpace          :=getProcAddr(lib, 'PyFile_SoftSpace');
+  PyFile_WriteObject        :=getProcAddr(lib, 'PyFile_WriteObject');
+  PyFile_WriteString        :=getProcAddr(lib, 'PyFile_WriteString');
+  PyFloat_AsDouble          :=getProcAddr(lib, 'PyFloat_AsDouble');
+  PyFloat_FromDouble        :=getProcAddr(lib, 'PyFloat_FromDouble');
+  PyFunction_GetCode        :=getProcAddr(lib, 'PyFunction_GetCode');
+  PyFunction_GetGlobals     :=getProcAddr(lib, 'PyFunction_GetGlobals');
+  PyFunction_New            :=getProcAddr(lib, 'PyFunction_New');
+  PyImport_AddModule        :=getProcAddr(lib, 'PyImport_AddModule');
+  PyImport_Cleanup          :=getProcAddr(lib, 'PyImport_Cleanup');
+  PyImport_GetMagicNumber   :=getProcAddr(lib, 'PyImport_GetMagicNumber');
+  PyImport_ImportFrozenModule:=getProcAddr(lib, 'PyImport_ImportFrozenModule');
+  PyImport_ImportModule     :=getProcAddr(lib, 'PyImport_ImportModule');
+  PyImport_Import           :=getProcAddr(lib, 'PyImport_Import');
+  //@PyImport_Init             :=getProcAddr(lib, 'PyImport_Init');
+  PyImport_ReloadModule     :=getProcAddr(lib, 'PyImport_ReloadModule');
+  PyInstance_New            :=getProcAddr(lib, 'PyInstance_New');
+  PyInt_AsLong              :=getProcAddr(lib, 'PyInt_AsLong');
+  PyList_Append             :=getProcAddr(lib, 'PyList_Append');
+  PyList_AsTuple            :=getProcAddr(lib, 'PyList_AsTuple');
+  PyList_GetItem            :=getProcAddr(lib, 'PyList_GetItem');
+  PyList_GetSlice           :=getProcAddr(lib, 'PyList_GetSlice');
+  PyList_Insert             :=getProcAddr(lib, 'PyList_Insert');
+  PyList_New                :=getProcAddr(lib, 'PyList_New');
+  PyList_Reverse            :=getProcAddr(lib, 'PyList_Reverse');
+  PyList_SetItem            :=getProcAddr(lib, 'PyList_SetItem');
+  PyList_SetSlice           :=getProcAddr(lib, 'PyList_SetSlice');
+  PyList_Size               :=getProcAddr(lib, 'PyList_Size');
+  PyList_Sort               :=getProcAddr(lib, 'PyList_Sort');
+  PyLong_AsDouble           :=getProcAddr(lib, 'PyLong_AsDouble');
+  PyLong_AsLong             :=getProcAddr(lib, 'PyLong_AsLong');
+  PyLong_FromDouble         :=getProcAddr(lib, 'PyLong_FromDouble');
+  PyLong_FromLong           :=getProcAddr(lib, 'PyLong_FromLong');
+  PyLong_FromString         :=getProcAddr(lib, 'PyLong_FromString');
+  PyLong_FromString         :=getProcAddr(lib, 'PyLong_FromString');
+  PyLong_FromUnsignedLong   :=getProcAddr(lib, 'PyLong_FromUnsignedLong');
+  PyLong_AsUnsignedLong     :=getProcAddr(lib, 'PyLong_AsUnsignedLong');
+  PyLong_FromUnicode        :=getProcAddr(lib, 'PyLong_FromUnicode');
+  PyLong_FromLongLong       :=getProcAddr(lib, 'PyLong_FromLongLong');
+  PyLong_AsLongLong         :=getProcAddr(lib, 'PyLong_AsLongLong');
+
+  PyMapping_Check           :=getProcAddr(lib, 'PyMapping_Check');
+  PyMapping_GetItemString   :=getProcAddr(lib, 'PyMapping_GetItemString');
+  PyMapping_HasKey          :=getProcAddr(lib, 'PyMapping_HasKey');
+  PyMapping_HasKeyString    :=getProcAddr(lib, 'PyMapping_HasKeyString');
+  PyMapping_Length          :=getProcAddr(lib, 'PyMapping_Length');
+  PyMapping_SetItemString   :=getProcAddr(lib, 'PyMapping_SetItemString');
+  PyMethod_Class            :=getProcAddr(lib, 'PyMethod_Class');
+  PyMethod_Function         :=getProcAddr(lib, 'PyMethod_Function');
+  PyMethod_New              :=getProcAddr(lib, 'PyMethod_New');
+  PyMethod_Self             :=getProcAddr(lib, 'PyMethod_Self');
+  PyModule_GetName          :=getProcAddr(lib, 'PyModule_GetName');
+  PyModule_New              :=getProcAddr(lib, 'PyModule_New');
+  PyNumber_Absolute         :=getProcAddr(lib, 'PyNumber_Absolute');
+  PyNumber_Add              :=getProcAddr(lib, 'PyNumber_Add');
+  PyNumber_And              :=getProcAddr(lib, 'PyNumber_And');
+  PyNumber_Check            :=getProcAddr(lib, 'PyNumber_Check');
+  PyNumber_Coerce           :=getProcAddr(lib, 'PyNumber_Coerce');
+  PyNumber_Divide           :=getProcAddr(lib, 'PyNumber_Divide');
+
+  PyNumber_FloorDivide      :=getProcAddr(lib, 'PyNumber_FloorDivide');
+  PyNumber_TrueDivide       :=getProcAddr(lib, 'PyNumber_TrueDivide');
+  PyNumber_Divmod           :=getProcAddr(lib, 'PyNumber_Divmod');
+  PyNumber_Float            :=getProcAddr(lib, 'PyNumber_Float');
+  PyNumber_Int              :=getProcAddr(lib, 'PyNumber_Int');
+  PyNumber_Invert           :=getProcAddr(lib, 'PyNumber_Invert');
+  PyNumber_Long             :=getProcAddr(lib, 'PyNumber_Long');
+  PyNumber_Lshift           :=getProcAddr(lib, 'PyNumber_Lshift');
+  PyNumber_Multiply         :=getProcAddr(lib, 'PyNumber_Multiply');
+  PyNumber_Negative         :=getProcAddr(lib, 'PyNumber_Negative');
+  PyNumber_Or               :=getProcAddr(lib, 'PyNumber_Or');
+  PyNumber_Positive         :=getProcAddr(lib, 'PyNumber_Positive');
+  PyNumber_Power            :=getProcAddr(lib, 'PyNumber_Power');
+  PyNumber_Remainder        :=getProcAddr(lib, 'PyNumber_Remainder');
+  PyNumber_Rshift           :=getProcAddr(lib, 'PyNumber_Rshift');
+  PyNumber_Subtract         :=getProcAddr(lib, 'PyNumber_Subtract');
+  PyNumber_Xor              :=getProcAddr(lib, 'PyNumber_Xor');
+  PyOS_InitInterrupts       :=getProcAddr(lib, 'PyOS_InitInterrupts');
+  PyOS_InterruptOccurred    :=getProcAddr(lib, 'PyOS_InterruptOccurred');
+  PyObject_CallObject       :=getProcAddr(lib, 'PyObject_CallObject');
+  PyObject_Compare          :=getProcAddr(lib, 'PyObject_Compare');
+  PyObject_GetAttr          :=getProcAddr(lib, 'PyObject_GetAttr');
+  PyObject_GetAttrString    :=getProcAddr(lib, 'PyObject_GetAttrString');
+  PyObject_GetItem          :=getProcAddr(lib, 'PyObject_GetItem');
+  PyObject_DelItem          :=getProcAddr(lib, 'PyObject_DelItem');
+  PyObject_HasAttrString    :=getProcAddr(lib, 'PyObject_HasAttrString');
+  PyObject_Hash             :=getProcAddr(lib, 'PyObject_Hash');
+  PyObject_IsTrue           :=getProcAddr(lib, 'PyObject_IsTrue');
+  PyObject_Length           :=getProcAddr(lib, 'PyObject_Length');
+  PyObject_Repr             :=getProcAddr(lib, 'PyObject_Repr');
+  PyObject_SetAttr          :=getProcAddr(lib, 'PyObject_SetAttr');
+  PyObject_SetAttrString    :=getProcAddr(lib, 'PyObject_SetAttrString');
+  PyObject_SetItem          :=getProcAddr(lib, 'PyObject_SetItem');
+
+  PyObject_Init             :=getProcAddr(lib, 'PyObject_Init');
+  PyObject_InitVar          :=getProcAddr(lib, 'PyObject_InitVar');
+  PyObject_New              :=getProcAddr(lib, '_PyObject_New');
+  PyObject_NewVar           :=getProcAddr(lib, '_PyObject_NewVar');
+  PyObject_Free             :=getProcAddr(lib, 'PyObject_Free');
+
+  PyObject_IsInstance       :=getProcAddr(lib, 'PyObject_IsInstance');
+  PyObject_IsSubclass       :=getProcAddr(lib, 'PyObject_IsSubclass');
+
+  PyObject_GenericGetAttr   :=getProcAddr(lib, 'PyObject_GenericGetAttr');
+  PyObject_GenericSetAttr   :=getProcAddr(lib, 'PyObject_GenericSetAttr');
+
+  PyObject_GC_Malloc         :=getProcAddr(lib, '_PyObject_GC_Malloc');
+  PyObject_GC_New            :=getProcAddr(lib, '_PyObject_GC_New');
+  PyObject_GC_NewVar         :=getProcAddr(lib, '_PyObject_GC_NewVar');
+  PyObject_GC_Resize         :=getProcAddr(lib, '_PyObject_GC_Resize');
+  PyObject_GC_Del            :=getProcAddr(lib, 'PyObject_GC_Del');
+  PyObject_GC_Track          :=getProcAddr(lib, 'PyObject_GC_Track');
+  PyObject_GC_UnTrack        :=getProcAddr(lib, 'PyObject_GC_UnTrack');
+
+  PyRange_New               :=getProcAddr(lib, 'PyRange_New');
+  PySequence_Check          :=getProcAddr(lib, 'PySequence_Check');
+  PySequence_Concat         :=getProcAddr(lib, 'PySequence_Concat');
+  PySequence_Count          :=getProcAddr(lib, 'PySequence_Count');
+  PySequence_GetItem        :=getProcAddr(lib, 'PySequence_GetItem');
+  PySequence_GetSlice       :=getProcAddr(lib, 'PySequence_GetSlice');
+  PySequence_In             :=getProcAddr(lib, 'PySequence_In');
+  PySequence_Index          :=getProcAddr(lib, 'PySequence_Index');
+  PySequence_Length         :=getProcAddr(lib, 'PySequence_Length');
+  PySequence_Repeat         :=getProcAddr(lib, 'PySequence_Repeat');
+  PySequence_SetItem        :=getProcAddr(lib, 'PySequence_SetItem');
+  PySequence_SetSlice       :=getProcAddr(lib, 'PySequence_SetSlice');
+  PySequence_DelSlice       :=getProcAddr(lib, 'PySequence_DelSlice');
+  PySequence_Tuple          :=getProcAddr(lib, 'PySequence_Tuple');
+  PySequence_Contains       :=getProcAddr(lib, 'PySequence_Contains');
+  PySlice_GetIndices        :=getProcAddr(lib, 'PySlice_GetIndices');
+  PySlice_GetIndicesEx      :=getProcAddr(lib, 'PySlice_GetIndicesEx');
+  PySlice_New               :=getProcAddr(lib, 'PySlice_New');
+  PyString_Concat           :=getProcAddr(lib, 'PyString_Concat');
+  PyString_ConcatAndDel     :=getProcAddr(lib, 'PyString_ConcatAndDel');
+  PyString_Format           :=getProcAddr(lib, 'PyString_Format');
+  PyString_FromStringAndSize:=getProcAddr(lib, 'PyString_FromStringAndSize');
+  PyString_Size             :=getProcAddr(lib, 'PyString_Size');
+  PyString_DecodeEscape     :=getProcAddr(lib, 'PyString_DecodeEscape');
+  PyString_Repr             :=getProcAddr(lib, 'PyString_Repr');
+  PySys_GetObject           :=getProcAddr(lib, 'PySys_GetObject');
+  //PySys_Init                :=getProcAddr(lib, 'PySys_Init');
+  PySys_SetObject           :=getProcAddr(lib, 'PySys_SetObject');
+  PySys_SetPath             :=getProcAddr(lib, 'PySys_SetPath');
+  //PyTraceBack_Fetch         :=getProcAddr(lib, 'PyTraceBack_Fetch');
+  PyTraceBack_Here          :=getProcAddr(lib, 'PyTraceBack_Here');
+  PyTraceBack_Print         :=getProcAddr(lib, 'PyTraceBack_Print');
+  //PyTraceBack_Store         :=getProcAddr(lib, 'PyTraceBack_Store');
+  PyTuple_GetItem           :=getProcAddr(lib, 'PyTuple_GetItem');
+  PyTuple_GetSlice          :=getProcAddr(lib, 'PyTuple_GetSlice');
+  PyTuple_New               :=getProcAddr(lib, 'PyTuple_New');
+  PyTuple_SetItem           :=getProcAddr(lib, 'PyTuple_SetItem');
+  PyTuple_Size              :=getProcAddr(lib, 'PyTuple_Size');
+
+  PyType_IsSubtype          :=getProcAddr(lib, 'PyType_IsSubtype');
+  PyType_GenericAlloc       :=getProcAddr(lib, 'PyType_GenericAlloc');
+  PyType_GenericNew         :=getProcAddr(lib, 'PyType_GenericNew');
+  PyType_Ready              :=getProcAddr(lib, 'PyType_Ready');
+
+  PyUnicode_FromWideChar    :=getProcAddr(lib, 'PyUnicodeUCS2_FromWideChar');
+  PyUnicode_AsWideChar      :=getProcAddr(lib, 'PyUnicodeUCS2_AsWideChar');
+  PyUnicode_FromOrdinal     :=getProcAddr(lib, 'PyUnicodeUCS2_FromOrdinal');
+
+  PyWeakref_GetObject       :=getProcAddr(lib, 'PyWeakref_GetObject');
+  PyWeakref_NewProxy        :=getProcAddr(lib, 'PyWeakref_NewProxy');
+  PyWeakref_NewRef          :=getProcAddr(lib, 'PyWeakref_NewRef');
+  PyWrapper_New             :=getProcAddr(lib, 'PyWrapper_New');
+
+  PyBool_FromLong           :=getProcAddr(lib, 'PyBool_FromLong'); 
+
+  Py_AtExit                 :=getProcAddr(lib, 'Py_AtExit');
+  //Py_Cleanup                :=getProcAddr(lib, 'Py_Cleanup');
+  Py_CompileString          :=getProcAddr(lib, 'Py_CompileString');
+  Py_FatalError             :=getProcAddr(lib, 'Py_FatalError');
+  Py_FindMethod             :=getProcAddr(lib, 'Py_FindMethod');
+  Py_FindMethodInChain      :=getProcAddr(lib, 'Py_FindMethodInChain');
+  Py_FlushLine              :=getProcAddr(lib, 'Py_FlushLine');
+  Py_Finalize                :=getProcAddr(lib, 'Py_Finalize');
+  PyCode_Addr2Line     := getProcAddr(lib, 'PyCode_Addr2Line');
+  PyClass_IsSubclass         :=getProcAddr(lib, 'PyClass_IsSubclass');
+  PyErr_ExceptionMatches     :=getProcAddr(lib, 'PyErr_ExceptionMatches');
+  PyErr_GivenExceptionMatches:=getProcAddr(lib, 'PyErr_GivenExceptionMatches');
+  PyEval_EvalCode            :=getProcAddr(lib, 'PyEval_EvalCode');
+  Py_GetVersion              :=getProcAddr(lib, 'Py_GetVersion');
+  Py_GetCopyright            :=getProcAddr(lib, 'Py_GetCopyright');
+  Py_GetExecPrefix           :=getProcAddr(lib, 'Py_GetExecPrefix');
+  Py_GetPath                 :=getProcAddr(lib, 'Py_GetPath');
+  Py_GetPrefix               :=getProcAddr(lib, 'Py_GetPrefix');
+  Py_GetProgramName          :=getProcAddr(lib, 'Py_GetProgramName');
+  PyParser_SimpleParseString :=getProcAddr(lib, 'PyParser_SimpleParseString');
+  PyNode_Free                :=getProcAddr(lib, 'PyNode_Free');
+  PyErr_NewException         :=getProcAddr(lib, 'PyErr_NewException');
+/// jah 29-sep-2000 : updated for python 2.0
+///                   replaced Py_Malloc with PyMem_Malloc
+///---   @Py_Malloc := Import ('Py_Malloc');
+///+++   @Py_Malloc := Import ('PyMem_Malloc');
+  Py_Malloc := getProcAddr(lib, 'PyMem_Malloc');
+  PyMem_Malloc := getProcAddr(lib, 'PyMem_Malloc');
+  PyObject_CallMethod        := getProcAddr(lib, 'PyObject_CallMethod');
+  Py_SetProgramName        := getProcAddr(lib, 'Py_SetProgramName');
+  Py_IsInitialized         := getProcAddr(lib, 'Py_IsInitialized');
+  Py_GetProgramFullPath    := getProcAddr(lib, 'Py_GetProgramFullPath');
+  DLL_Py_GetBuildInfo    := getProcAddr(lib, 'Py_GetBuildInfo');
+  Py_NewInterpreter        := getProcAddr(lib, 'Py_NewInterpreter');
+  Py_EndInterpreter        := getProcAddr(lib, 'Py_EndInterpreter');
+  PyEval_AcquireLock       := getProcAddr(lib, 'PyEval_AcquireLock');
+  PyEval_ReleaseLock       := getProcAddr(lib, 'PyEval_ReleaseLock');
+  PyEval_AcquireThread     := getProcAddr(lib, 'PyEval_AcquireThread');
+  PyEval_ReleaseThread     := getProcAddr(lib, 'PyEval_ReleaseThread');
+  PyInterpreterState_New   := getProcAddr(lib, 'PyInterpreterState_New');
+  PyInterpreterState_Clear := getProcAddr(lib, 'PyInterpreterState_Clear');
+  PyInterpreterState_Delete:= getProcAddr(lib, 'PyInterpreterState_Delete');
+  PyThreadState_New        := getProcAddr(lib, 'PyThreadState_New');
+  PyThreadState_Clear      := getProcAddr(lib, 'PyThreadState_Clear');
+  PyThreadState_Delete     := getProcAddr(lib, 'PyThreadState_Delete');
+  PyThreadState_Get        := getProcAddr(lib, 'PyThreadState_Get');
+  PyThreadState_Swap       := getProcAddr(lib, 'PyThreadState_Swap');
+end;
+
+var
+  lib: TLibHandle;
+initialization
+  lib := loadLibrary(dllName);
+  if lib <> NilLibHandle then init(lib);
+end.
author	Andreas Rumpf <rumpf_a@web.de>	2008-11-16 22:11:53 +0100
committer	Andreas Rumpf <rumpf_a@web.de>	2008-11-16 22:11:53 +0100
commit	985113a88fe07fa18f0a34ceaa9e8c1c1e04a79b (patch)
tree	6a2e56078dd24d29d9031a784917ed94696d24a8 /lib/base/devel/python.pas
parent	8b2a9401a147bd0b26cd2976ae71a1022fbde8cc (diff)
download	Nim-985113a88fe07fa18f0a34ceaa9e8c1c1e04a79b.tar.gz