(**************************************************************************)

(* This unit is part of the Python for Delphi (P4D) library *)

(* Project home: https://github.com/pyscripter/python4delphi *)

(* *)

(* Project Maintainer: PyScripter (pyscripter@gmail.com) *)

(* Original Authors: Dr. Dietmar Budelsky (dbudelsky@web.de) *)

(* Morgan Martinet (https://github.com/mmm-experts) *)

(* Core developer: Lucas Belo (lucas.belo@live.com) *)

(* Contributors: See contributors.md at project home *)

(* *)

(* LICENCE and Copyright: MIT (see project home) *)

(**************************************************************************)

{$I Definition.Inc}

{$POINTERMATH ON}

unit PythonEngine;

{ TODO -oMMM : implement Attribute descriptor and subclassing stuff }

{$IFNDEF FPC}

{$IFNDEF DELPHIXE2_OR_HIGHER}

Error! Delphi XE2 or higher is required!

{$ENDIF}

{$ENDIF}

{$IF defined(LINUX) or (defined(BSD) and not defined(DARWIN)) or defined(SOLARIS) or defined(HAIKU)}

{$define _so_files}

{$IFEND}

interface

uses

Types,

{$IFDEF MSWINDOWS}

Windows,

{$ELSE}

{$IFDEF FPC}

Dl,

DynLibs,

{$ELSE}

Posix.DLfcn,

Posix.Pthread,

{$ENDIF}

{$ENDIF}

Classes,

SysUtils,

SyncObjs,

Variants,

MethodCallBack;

{$IF not Defined(FPC) and (CompilerVersion >= 23)}

const

{$IF CompilerVersion >= 33}

pidSupportedPlatforms = pidAllPlatforms;

{$ELSE}

pidSupportedPlatforms = pidWin32 or pidWin64 or pidOSX32;

{$IFEND}

{$IFEND}

//#######################################################

//## ##

//## PYTHON specific constants ##

//## ##

//#######################################################

type

TPythonVersionProp = record

DllName : string;

RegVersion : string;

APIVersion : Integer;

end;

const

{$IFDEF MSWINDOWS}

PYTHON_KNOWN_VERSIONS: array[1..7] of TPythonVersionProp =

(

(DllName: 'python38.dll'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'python39.dll'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'python310.dll'; RegVersion: '3.10'; APIVersion: 1013),

(DllName: 'python311.dll'; RegVersion: '3.11'; APIVersion: 1013),

(DllName: 'python312.dll'; RegVersion: '3.12'; APIVersion: 1013),

(DllName: 'python313.dll'; RegVersion: '3.13'; APIVersion: 1013),

(DllName: 'python314.dll'; RegVersion: '3.14'; APIVersion: 1013)

);

{$ENDIF}

{$IFDEF _so_files}

PYTHON_KNOWN_VERSIONS: array[1..7] of TPythonVersionProp =

(

(DllName: 'libpython3.8.so'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'libpython3.9.so'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'libpython3.10.so'; RegVersion: '3.10'; APIVersion: 1013),

(DllName: 'libpython3.11.so'; RegVersion: '3.11'; APIVersion: 1013),

(DllName: 'libpython3.12.so'; RegVersion: '3.12'; APIVersion: 1013),

(DllName: 'libpython3.13.so'; RegVersion: '3.13'; APIVersion: 1013),

(DllName: 'libpython3.14.so'; RegVersion: '3.14'; APIVersion: 1013)

);

{$ENDIF}

{$IFDEF DARWIN}

PYTHON_KNOWN_VERSIONS: array[1..7] of TPythonVersionProp =

(

(DllName: 'libpython3.8.dylib'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'libpython3.9.dylib'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'libpython3.10.dylib'; RegVersion: '3.10'; APIVersion: 1013),

(DllName: 'libpython3.11.dylib'; RegVersion: '3.11'; APIVersion: 1013),

(DllName: 'libpython3.12.dylib'; RegVersion: '3.12'; APIVersion: 1013),

(DllName: 'libpython3.13.dylib'; RegVersion: '3.13'; APIVersion: 1013),

(DllName: 'libpython3.14.dylib'; RegVersion: '3.14'; APIVersion: 1013)

);

{$ENDIF}

{$IFDEF ANDROID}

PYTHON_KNOWN_VERSIONS: array[1..7] of TPythonVersionProp =

(

(DllName: 'libpython3.8.so'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'libpython3.9.so'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'libpython3.10.so'; RegVersion: '3.10'; APIVersion: 1013),

(DllName: 'libpython3.11.so'; RegVersion: '3.11'; APIVersion: 1013),

(DllName: 'libpython3.12.so'; RegVersion: '3.12'; APIVersion: 1013),

(DllName: 'libpython3.13.so'; RegVersion: '3.13'; APIVersion: 1013),

(DllName: 'libpython3.14.so'; RegVersion: '3.14'; APIVersion: 1013)

);

{$ENDIF}

COMPILED_FOR_PYTHON_VERSION_INDEX = High(PYTHON_KNOWN_VERSIONS);

PYT_METHOD_BUFFER_INCREASE = 10;

PYT_MEMBER_BUFFER_INCREASE = 10;

PYT_GETSET_BUFFER_INCREASE = 10;

METH_VARARGS = $0001;

METH_KEYWORDS = $0002;

METH_CLASS = $0010;

METH_STATIC = $0020;

METH_COEXIST = $0040;

// Masks for the co_flags field of PyCodeObject

CO_OPTIMIZED = $0001;

CO_NEWLOCALS = $0002;

CO_VARARGS = $0004;

CO_VARKEYWORDS = $0008;

// Rich comparison opcodes introduced in version 2.1

Py_LT = 0;

Py_LE = 1;

Py_EQ = 2;

Py_NE = 3;

Py_GT = 4;

Py_GE = 5;

{$IFDEF CPUARM}

DEFAULT_CALLBACK_TYPE: TCallType = TCallType.ctARMSTD;

{$ELSE}

DEFAULT_CALLBACK_TYPE: TCallType = TCallType.ctCDECL;

{$ENDIF CPUARM}

type

// Delphi equivalent used by TPyObject

TRichComparisonOpcode = (pyLT, pyLE, pyEQ, pyNE, pyGT, pyGE);

// C long is 8 bytes in non-Windows 64-bit operating systems

// Same Delphi's LongInt but not fpc LongInt which is always 4 bytes

// Hence the following

{$IFDEF MSWINDOWS}

C_Long = Integer;

C_ULong = Cardinal;

{$ELSE}

C_Long = NativeInt;

C_ULong = NativeUInt;

{$ENDIF}

// wchar_t is 4 bytes on Linux/OS X/Android but 2 bytes on Windows

{$IFDEF POSIX}

PWCharT = PUCS4Char;

PPWCharT = ^PUCS4Char;

WCharTString = UCS4String;

{$ELSE}

PWCharT = PWideChar;

PPWCharT = PPWideChar;

WCharTString = UnicodeString;

{$ENDIF}

PPy_ssize_t = PNativeUInt;

Py_ssize_t = NativeUInt;

const

{

Type flags (tp_flags)

These flags are used to change expected features and behavior for a

particular type.

Arbitration of the flag bit positions will need to be coordinated among

all extension writers who publicly release their extensions (this will

be fewer than you might expect!).

Most flags were removed as of Python 3.0 to make room for new flags. (Some

flags are not for backwards compatibility but to indicate the presence of an

optional feature; these flags remain of course.)

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.

}

// Set if the type object is dynamically allocated

Py_TPFLAGS_HEAPTYPE = (C_ULong(1) shl 9);

// Set if the type allows subclassing

Py_TPFLAGS_BASETYPE = (C_ULong(1) shl 10);

// Set if the type is 'ready' -- fully initialized

Py_TPFLAGS_READY = (C_ULong(1) shl 12);

// Set while the type is being 'readied', to prevent recursive ready calls

Py_TPFLAGS_READYING = (C_ULong(1) shl 13);

// Objects support garbage collection (see objimp.h)

Py_TPFLAGS_HAVE_GC = (C_ULong(1) shl 14);

// Set if the type implements the vectorcall protocol (PEP 590) */

_Py_TPFLAGS_HAVE_VECTORCALL = (C_ULong(1) shl 11);

// Objects behave like an unbound method

Py_TPFLAGS_METHOD_DESCRIPTOR = (C_ULong(1) shl 17);

// Objects support type attribute cache

Py_TPFLAGS_HAVE_VERSION_TAG = (C_ULong(1) shl 18);

Py_TPFLAGS_VALID_VERSION_TAG = (C_ULong(1) shl 19);

// Type is abstract and cannot be instantiated

Py_TPFLAGS_IS_ABSTRACT = (C_ULong(1) shl 20);

// These flags are used to determine if a type is a subclass.

Py_TPFLAGS_LONG_SUBCLASS = (C_ULong(1) shl 24);

Py_TPFLAGS_LIST_SUBCLASS = (C_ULong(1) shl 25);

Py_TPFLAGS_TUPLE_SUBCLASS = (C_ULong(1) shl 26);

Py_TPFLAGS_BYTES_SUBCLASS = (C_ULong(1) shl 27);

Py_TPFLAGS_UNICODE_SUBCLASS = (C_ULong(1) shl 28);

Py_TPFLAGS_DICT_SUBCLASS = (C_ULong(1) shl 29);

Py_TPFLAGS_BASE_EXC_SUBCLASS = (C_ULong(1) shl 30);

Py_TPFLAGS_TYPE_SUBCLASS = (C_ULong(1) shl 31);

Py_TPFLAGS_DEFAULT = Py_TPFLAGS_BASETYPE or Py_TPFLAGS_HAVE_VERSION_TAG;

// See function PyType_HasFeature below for testing the flags.

// Delphi equivalent used by TPythonType

type

TPFlag = (tpfHeapType, tpfBaseType, tpfReady, tpfReadying, tpfHaveGC,

tpVectorCall, tpMethodDescriptor, tpHaveVersionTag,

tpValidVersionTag, tpIsAbstract, tpLongSubclass,

tpListSubClass, tpTupleSubclass, tpBytesSubclass,

tpBaseExcSubclass, tpTypeSubclass);

TPFlags = set of TPFlag;

const

TPFLAGS_DEFAULT = [tpfBaseType, tpHaveVersionTag];

//------- Python opcodes ----------//

const

single_input = 256;

file_input = 257;

eval_input = 258;

// UnicodeObject.h

const

// Return values of the PyUnicode_KIND() macro

{

PyUnicode_WCHAR_KIND is deprecated. Will be removed in Python 12.

String contains only wstr byte characters. This is only possible

when the string was created with a legacy API and _PyUnicode_Ready()

has not been called yet.

}

PyUnicode_WCHAR_KIND = 0;

PyUnicode_1BYTE_KIND = 1;

PyUnicode_2BYTE_KIND = 2;

PyUnicode_4BYTE_KIND = 4;

// structmember.h

const

//* Types */

T_SHORT = 0;

T_INT = 1;

T_LONG = 2;

T_FLOAT = 3;

T_DOUBLE = 4;

T_STRING = 5;

T_OBJECT = 6;

//* XXX the ordering here is weird for binary compatibility */

T_CHAR = 7; //* 1-character string */

T_BYTE = 8; //* 8-bit signed int */

//* unsigned variants: */

T_UBYTE = 9;

T_USHORT = 10;

T_UINT = 11;

T_ULONG = 12;

//* 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;

PY_WRITE_RESTRICTED = 4;

RESTRICTED = (READ_RESTRICTED or PY_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);

// Constants from pybuffer.h

const

PyBUF_MAX_NDIM = 64; // Maximum number of dimensions

// Flags for getting buffers. Keep these in sync with inspect.BufferFlags.

PyBUF_SIMPLE = 0;

PyBUF_WRITABLE = 1;

PyBUF_FORMAT = $0004;

PyBUF_ND = $0008;

PyBUF_STRIDES = $0010 or PyBUF_ND;

PyBUF_C_CONTIGUOUS = $0020 or PyBUF_STRIDES;

PyBUF_F_CONTIGUOUS = $0040 or PyBUF_STRIDES;

PyBUF_ANY_CONTIGUOUS = $0080 or PyBUF_STRIDES;

PyBUF_INDIRECT = $0100 or PyBUF_STRIDES;

PyBUF_CONTIG = PyBUF_ND or PyBUF_WRITABLE;

PyBUF_CONTIG_RO = PyBUF_ND;

PyBUF_STRIDED = PyBUF_STRIDES or PyBUF_WRITABLE;

PyBUF_STRIDED_RO = PyBUF_STRIDES;

PyBUF_RECORDS = PyBUF_STRIDES or PyBUF_WRITABLE or PyBUF_FORMAT;

PyBUF_RECORDS_RO = PyBUF_STRIDES or PyBUF_FORMAT;

PyBUF_FULL = PyBUF_INDIRECT or PyBUF_WRITABLE or PyBUF_FORMAT;

PyBUF_FULL_RO = PyBUF_INDIRECT or PyBUF_FORMAT;

PyBUF_READ = $100;

PyBUF_WRITE = $200;

//#######################################################

//## ##

//## Non-Python specific constants ##

//## ##

//#######################################################

const

CR = #13;

LF = #10;

TAB = #09;

CRLF = CR+LF;

//#######################################################

//## ##

//## Python specific interface ##

//## ##

//#######################################################

type

PP_frozen = ^P_frozen;

P_frozen = ^_frozen;

PPyObject = ^PyObject;

PPPyObject = ^PPyObject;

PPPPyObject = ^PPPyObject;

PPyTypeObject = ^PyTypeObject;

PPySliceObject = ^PySliceObject;

AtExitProc = procedure;

PyCFunction = function( self, args:PPyObject): PPyObject; cdecl;

PyCFunctionWithKW = function( self, args, keywords:PPyObject): PPyObject; cdecl;

unaryfunc = function( ob1 : PPyObject): PPyObject; cdecl;

binaryfunc = function( ob1,ob2 : PPyObject): PPyObject; cdecl;

ternaryfunc = function( ob1,ob2,ob3 : PPyObject): PPyObject; cdecl;

inquiry = function( ob1 : PPyObject): integer; cdecl;

lenfunc = function( ob1 : PPyObject): NativeInt; cdecl;

coercion = function( ob1,ob2 : PPPyObject): integer; cdecl;

ssizeargfunc = function( ob1 : PPyObject; i: NativeInt): PPyObject; cdecl;

ssizeobjargproc = function( ob1 : PPyObject; i: NativeInt; ob2 : PPyObject):

integer; cdecl;

objobjargproc = function( ob1,ob2,ob3 : PPyObject): integer; cdecl;

pydestructor = procedure(ob: PPyObject); cdecl;

getattrfunc = function( ob1: PPyObject; name: PAnsiChar): PPyObject; cdecl;

setattrfunc = function( ob1: PPyObject; name: PAnsiChar; ob2: PPyObject): integer; cdecl;

reprfunc = function( ob: PPyObject): PPyObject; cdecl;

hashfunc = function( ob: PPyObject): NativeInt; cdecl; // !! in 2.x it is still a LongInt

getattrofunc = function( ob1,ob2: PPyObject): PPyObject; cdecl;

setattrofunc = function( ob1,ob2,ob3: PPyObject): integer; cdecl;

objobjproc = function ( ob1, ob2: PPyObject): integer; cdecl;

visitproc = function ( ob1: PPyObject; ptr: Pointer): integer; cdecl;

traverseproc = function ( ob1: PPyObject; proc: visitproc; ptr: Pointer): integer; cdecl;

richcmpfunc = function ( ob1, ob2 : PPyObject; i : Integer) : PPyObject; cdecl;

getiterfunc = function ( ob1 : PPyObject) : PPyObject; cdecl;

iternextfunc = function ( ob1 : PPyObject) : PPyObject; cdecl;

descrgetfunc = function ( ob1, ob2, ob3 : PPyObject) : PPyObject; cdecl;

descrsetfunc = function ( ob1, ob2, ob3 : PPyObject) : Integer; cdecl;

initproc = function ( self, args, kwds : PPyObject) : Integer; cdecl;

newfunc = function ( subtype: PPyTypeObject; args, kwds : PPyObject) : PPyObject; cdecl;

allocfunc = function ( self: PPyTypeObject; nitems : NativeInt) : PPyObject; cdecl;

PyNumberMethods = {$IFDEF CPUX86}packed{$ENDIF} record

nb_add : binaryfunc;

nb_subtract : binaryfunc;

nb_multiply : binaryfunc;

nb_remainder : binaryfunc;

nb_divmod : binaryfunc;

nb_power : ternaryfunc;

nb_negative : unaryfunc;

nb_positive : unaryfunc;

nb_absolute : unaryfunc;

nb_bool : inquiry;

nb_invert : unaryfunc;

nb_lshift : binaryfunc;

nb_rshift : binaryfunc;

nb_and : binaryfunc;

nb_xor : binaryfunc;

nb_or : binaryfunc;

nb_int : unaryfunc;

nb_reserved : Pointer; // not used

nb_float : unaryfunc;

nb_inplace_add : binaryfunc;

nb_inplace_subtract : binaryfunc;

nb_inplace_multiply : binaryfunc;

nb_inplace_remainder : binaryfunc;

nb_inplace_power : ternaryfunc;

nb_inplace_lshift : binaryfunc;

nb_inplace_rshift : binaryfunc;

nb_inplace_and : binaryfunc;

nb_inplace_xor : binaryfunc;

nb_inplace_or : binaryfunc;

nb_floor_divide : binaryfunc;

nb_true_divide : binaryfunc;

nb_inplace_floor_divide : binaryfunc;

nb_inplace_true_divide : binaryfunc;

nb_index : unaryfunc;

nb_matrix_multiply : binaryfunc; // new in python 3.5

nb_inplace_matrix_multiply : binaryfunc; // new in python 3.5

end;

PPyNumberMethods = ^PyNumberMethods;

PySequenceMethods = {$IFDEF CPUX86}packed{$ENDIF} record

sq_length : lenfunc;

sq_concat : binaryfunc;

sq_repeat : ssizeargfunc;

sq_item : ssizeargfunc;

was_sq_slice : Pointer; // empty slot in python 3.x

sq_ass_item : ssizeobjargproc;

was_sq_ass_slice : Pointer; // empty slot in python 3.x

sq_contains : objobjproc;

sq_inplace_concat : binaryfunc;

sq_inplace_repeat : ssizeargfunc;

end;

PPySequenceMethods = ^PySequenceMethods;

PyMappingMethods = {$IFDEF CPUX86}packed{$ENDIF} record

mp_length : lenfunc;

mp_subscript : binaryfunc;

mp_ass_subscript : objobjargproc;

end;

PPyMappingMethods = ^PyMappingMethods;

Py_complex = {$IFDEF CPUX86}packed{$ENDIF} record

real : double;

imag : double;

end;

PyObject = {$IFDEF CPUX86}packed{$ENDIF} record

ob_refcnt: NativeUInt;

ob_type: PPyTypeObject;

end;

_frozen = {$IFDEF CPUX86}packed{$ENDIF} record

name : PAnsiChar;

code : PByte;

size : Integer;

end;

PySliceObject = {$IFDEF CPUX86}packed{$ENDIF} record

ob_refcnt: NativeUInt;

ob_type: PPyTypeObject;

start, stop, step: PPyObject;

end;

PPyMethodDef = ^PyMethodDef;

PyMethodDef = {$IFDEF CPUX86}packed{$ENDIF} record

ml_name: PAnsiChar;

ml_meth: PyCFunction;

ml_flags: Integer;

ml_doc: PAnsiChar;

end;

// structmember.h

PPyMemberDef = ^PyMemberDef;

PyMemberDef = {$IFDEF CPUX86}packed{$ENDIF} record

name : PAnsiChar;

_type : integer;

offset : NativeInt;

flags : Integer;

doc : PAnsiChar;

end;

// descrobject.h

// Descriptors

getter = function ( obj : PPyObject; context : Pointer) : PPyObject; cdecl;

setter = function ( obj, value : PPyObject; context : Pointer) : integer; cdecl;

PPyGetSetDef = ^PyGetSetDef;

PyGetSetDef = {$IFDEF CPUX86}packed{$ENDIF} record

name : PAnsiChar;

get : getter;

_set : setter;

doc : PAnsiChar;

closure : Pointer;

end;

wrapperfunc = function (self, args: PPyObject; wrapped : Pointer) : PPyObject; cdecl;

pwrapperbase = ^wrapperbase;

wrapperbase = {$IFDEF CPUX86}packed{$ENDIF} record

name : PAnsiChar;

wrapper : wrapperfunc;

doc : PAnsiChar;

end;

// Various kinds of descriptor objects

{#define PyDescr_COMMON \

PyObject_HEAD \

PyTypeObject *d_type; \

PyObject *d_name \

PyObject *d_qualname

}

PPyDescrObject = ^PyDescrObject;

PyDescrObject = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

d_qualname : PPyObject;

end;

PPyMethodDescrObject = ^PyMethodDescrObject;

PyMethodDescrObject = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

d_qualname : PPyObject;

// End of PyDescr_COMMON

d_method : PPyMethodDef;

end;

PPyMemberDescrObject = ^PyMemberDescrObject;

PyMemberDescrObject = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

d_qualname : PPyObject;

// End of PyDescr_COMMON

d_member : PPyMemberDef;

end;

PPyGetSetDescrObject = ^PyGetSetDescrObject;

PyGetSetDescrObject = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

d_qualname : PPyObject;

// End of PyDescr_COMMON

d_getset : PPyGetSetDef;

end;

PPyWrapperDescrObject = ^PyWrapperDescrObject;

PyWrapperDescrObject = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

d_qualname : PPyObject;

// End of PyDescr_COMMON

d_base : pwrapperbase;

d_wrapped : Pointer; // This can be any function pointer

end;

PPyModuleDef_Base = ^PyModuleDef_Base;

PyModuleDef_Base = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

m_init : function( ) : PPyObject; cdecl;

m_index : NativeInt;

m_copy : PPyObject;

end;

// Slots are used for two phase module initialization

// which is not yet implemented

PPyModuleDef_Slot = ^PyModuleDef_Slot;

PyModuleDef_Slot = {$IFDEF CPUX86}packed{$ENDIF} record

slot: integer;

value: Pointer;

end;

PPyModuleDef = ^PyModuleDef;

PyModuleDef = {$IFDEF CPUX86}packed{$ENDIF} record

m_base : PyModuleDef_Base;

m_name : PAnsiChar;

m_doc : PAnsiChar;

m_size : NativeInt;

m_methods : PPyMethodDef;

m_slots : PPyModuleDef_Slot;

m_traverse : traverseproc;

m_clear : inquiry;

m_free : inquiry;

end;

// pybuffer.h

PPy_buffer = ^Py_Buffer;

Py_buffer = record

buf: Pointer;

obj: PPyObject; (* owned reference *)

len: Py_ssize_t;

itemsize: Py_ssize_t; (* This is Py_ssize_t so it can be

pointed to by strides in simple case.*)

readonly: Integer;

ndim: Integer;

format: PAnsiChar;

shape: PPy_ssize_t ;

strides: PPy_ssize_t;

suboffsets: PPy_ssize_t;

internal: Pointer;

end;

getbufferproc = function(exporter: PPyObject; view: PPy_buffer; flags: Integer): Integer; cdecl;

releasebufferproc = procedure(exporter: PPyObject; view: PPy_buffer); cdecl;

PPyBufferProcs = ^PyBufferProcs;

PyBufferProcs = record

bf_getbuffer: getbufferproc;

bf_releasebuffer: releasebufferproc;

end;

// object.h

PyTypeObject = {$IFDEF CPUX86}packed{$ENDIF} record

ob_refcnt: NativeUInt;

ob_type: PPyTypeObject;

ob_size: NativeInt; // Number of items in variable part

tp_name: PAnsiChar; // For printing

tp_basicsize,

tp_itemsize: NativeInt; // For allocation

// Methods to implement standard operations

tp_dealloc: pydestructor;

tp_vectorcall_offset: NativeInt;

tp_getattr: getattrfunc;

tp_setattr: setattrfunc;

tp_as_async: Pointer; // not implemented

tp_repr: reprfunc;

// 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: hashfunc;

tp_call: ternaryfunc;

tp_str: reprfunc;

tp_getattro: getattrofunc;

tp_setattro: setattrofunc;

// Functions to access object as input/output buffer

tp_as_buffer: PPyBufferProcs;

// Flags to define presence of optional/expanded features

tp_flags: C_ULong;

tp_doc: PAnsiChar; // Documentation string

// call function for all accessible objects

tp_traverse: traverseproc;

// delete references to contained objects

tp_clear: inquiry;

// rich comparisons

tp_richcompare: richcmpfunc;

// weak reference enabler

tp_weaklistoffset: NativeInt;

// Iterators

tp_iter : getiterfunc;

tp_iternext : iternextfunc;

// Attribute descriptor and subclassing stuff

tp_methods : PPyMethodDef;

tp_members : PPyMemberDef;

tp_getset : PPyGetSetDef;

tp_base : PPyTypeObject;

tp_dict : PPyObject;

tp_descr_get : descrgetfunc;

tp_descr_set : descrsetfunc;

tp_dictoffset : NativeInt;

tp_init : initproc;

tp_alloc : allocfunc;

tp_new : newfunc;

tp_free : pydestructor; // Low-level free-memory routine

tp_is_gc : inquiry; // For PyObject_IS_GC

tp_bases : PPyObject;

tp_mro : PPyObject; // method resolution order

tp_cache : PPyObject;

tp_subclasses : PPyObject;

tp_weaklist : PPyObject;

tp_del : PyDestructor;

tp_version_tag : Cardinal; // Type attribute cache version tag. Added in version 2.6

tp_finalize : PyDestructor;

tp_vectorcall : Pointer; // not implemented

//More spares

tp_xxx1 : NativeInt;

tp_xxx2 : NativeInt;

tp_xxx3 : NativeInt;

tp_xxx4 : NativeInt;

tp_xxx5 : NativeInt;

tp_xxx6 : NativeInt;

tp_xxx7 : NativeInt;

tp_xxx8 : NativeInt;

tp_xxx9 : NativeInt;

tp_xxx10 : NativeInt;

tp_pythontype : Pointer; // Introduced for FindPythonType optimization

end;

// from pystate.h

// the structure of PyInterpreterState and PyThreadState is considered

// an implementation detail. It has been changing between python versions

// and there is no real use of accessing these structures directly.

PPyInterpreterState = Pointer;

PPyThreadState = Pointer;

// Parse tree node interface

PNode = ^node;

node = {$IFDEF CPUX86}packed{$ENDIF} record

n_type : smallint;

n_str : PAnsiChar;

n_lineno : integer;

n_col_offset: integer;

n_nchildren : integer;

n_child : PNode;

end;

PPyCompilerFlags = ^PyCompilerFlags;

PyCompilerFlags = {$IFDEF CPUX86}packed{$ENDIF} record

flags : integer;

cf_feature_version : integer; //added in Python 3.8

end;

const

PyCF_ONLY_AST = $0400;

// 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

PyDateTime_Delta = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : NativeInt; // -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 = ^PyDateTime_Delta;

PyDateTime_TZInfo = {$IFDEF CPUX86}packed{$ENDIF} record // a pure abstract base clase

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

end;

PPyDateTime_TZInfo = ^PyDateTime_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.

*}

_PyDateTime_BaseTZInfo = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

end;

_PPyDateTime_BaseTZInfo = ^_PyDateTime_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];

}

_PyDateTime_BaseTime = {$IFDEF CPUX86}packed{$ENDIF} record // hastzinfo false

// Start of _PyDateTime_TIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_TIME_DATASIZE)] of Byte;

// End of _PyDateTime_TIMEHEAD

end;

_PPyDateTime_BaseTime = ^_PyDateTime_BaseTime;

PyDateTime_Time = {$IFDEF CPUX86}packed{$ENDIF} record // hastzinfo true

// Start of _PyDateTime_TIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_TIME_DATASIZE)] of Byte;

// End of _PyDateTime_TIMEHEAD

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).

*}

PyDateTime_Date = {$IFDEF CPUX86}packed{$ENDIF} record

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATE_DATASIZE)] of Byte;

end;

PPyDateTime_Date = ^PyDateTime_Date;

{

#define _PyDateTime_DATETIMEHEAD \

_PyTZINFO_HEAD \

unsigned char data[_PyDateTime_DATETIME_DATASIZE];

}

_PyDateTime_BaseDateTime = {$IFDEF CPUX86}packed{$ENDIF} record // hastzinfo false

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATETIME_DATASIZE)] of Byte;

end;

_PPyDateTime_BaseDateTime = ^_PyDateTime_BaseDateTime;

PyDateTime_DateTime = {$IFDEF CPUX86}packed{$ENDIF} record // hastzinfo true

// Start of _PyDateTime_DATETIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeUInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATETIME_DATASIZE)] of Byte;

// End of _PyDateTime_DATETIMEHEAD

tzinfo : PPyObject;

end;

PPyDateTime_DateTime = ^PyDateTime_DateTime;

//bytearrayobject.h

PyByteArrayObject = {$IFDEF CPUX86}packed{$ENDIF} record

ob_refcnt: NativeUInt;

ob_type: PPyTypeObject;

ob_alloc: Py_ssize_t;

ob_bytes: PAnsiChar;

ob_start: PAnsiChar;

ob_exports: Py_ssize_t;

end;

//initconfig.h

//See https://docs.python.org/3/c-api/init_config.html

const

_PyStatus_TYPE_OK = 0;

_PyStatus_TYPE_ERROR = 1;

_PyStatus_TYPE_EXIT = 2;

type

TPyStatus_Type = Integer;

PyStatus = {$IFDEF CPUX86}packed{$ENDIF} record

_type: TPyStatus_Type;

func: PAnsiChar;

err_msg: PAnsiChar;

exitcode: Integer;

end;

PPyWideStringList = ^PyWideStringList;

PyWideStringList = {$IFDEF CPUX86}packed{$ENDIF} record

length: Py_ssize_t;

items: PPWCharT;

end;

PPyConfig = ^PyConfig;

PyConfig = record