use core::ptr; use libc::{c_void, c_int, c_uint, c_ulong, c_char}; use pyport::{Py_ssize_t, Py_hash_t}; #[repr(C)] #[derive(Copy, Clone)] pub struct PyObject { #[cfg(py_sys_config="Py_TRACE_REFS")] _ob_next: *mut PyObject, #[cfg(py_sys_config="Py_TRACE_REFS")] _ob_prev: *mut PyObject, pub ob_refcnt: Py_ssize_t, pub ob_type: *mut PyTypeObject, } #[cfg(py_sys_config="Py_TRACE_REFS")] pub const PyObject_HEAD_INIT: PyObject = PyObject { _ob_next: 0 as *mut PyObject, _ob_prev: 0 as *mut PyObject, ob_refcnt: 1, ob_type: 0 as *mut PyTypeObject }; #[cfg(not(py_sys_config="Py_TRACE_REFS"))] pub const PyObject_HEAD_INIT: PyObject = PyObject { ob_refcnt: 1, ob_type: 0 as *mut PyTypeObject }; #[repr(C)] #[derive(Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } #[inline(always)] pub unsafe fn Py_REFCNT(ob : *mut PyObject) -> Py_ssize_t { (*ob).ob_refcnt } #[inline(always)] pub unsafe fn Py_TYPE(ob : *mut PyObject) -> *mut PyTypeObject { (*ob).ob_type } #[inline(always)] pub unsafe fn Py_SIZE(ob : *mut PyObject) -> Py_ssize_t { (*(ob as *mut PyVarObject)).ob_size } pub type unaryfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject; pub type binaryfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject; pub type ternaryfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> *mut PyObject; pub type inquiry = unsafe extern "C" fn(arg1: *mut PyObject) -> c_int; pub type lenfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> Py_ssize_t; pub type ssizeargfunc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject; pub type ssizessizeargfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t) -> *mut PyObject; pub type ssizeobjargproc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int; pub type ssizessizeobjargproc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t, arg4: *mut PyObject) -> c_int; pub type objobjargproc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; #[cfg(not(Py_LIMITED_API))] mod bufferinfo { use libc::{c_void, c_int, c_char}; use pyport::Py_ssize_t; #[repr(C)] #[derive(Copy)] pub struct Py_buffer { pub buf: *mut c_void, pub obj: *mut ::object::PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: c_int, pub ndim: c_int, pub format: *mut c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut c_void, } impl Clone for Py_buffer { #[inline] fn clone(&self) -> Self { *self } } impl Default for Py_buffer { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } pub type getbufferproc = extern "C" fn(arg1: *mut ::object::PyObject, arg2: *mut Py_buffer, arg3: c_int) -> c_int; pub type releasebufferproc = extern "C" fn(arg1: *mut ::object::PyObject, arg2: *mut Py_buffer) -> (); /// Maximum number of dimensions pub const PyBUF_MAX_NDIM : c_int = 64; /* Flags for getting buffers */ pub const PyBUF_SIMPLE : c_int = 0; pub const PyBUF_WRITABLE : c_int = 0x0001; /* we used to include an E, backwards compatible alias */ pub const PyBUF_WRITEABLE : c_int = PyBUF_WRITABLE; pub const PyBUF_FORMAT : c_int = 0x0004; pub const PyBUF_ND : c_int = 0x0008; pub const PyBUF_STRIDES : c_int = (0x0010 | PyBUF_ND); pub const PyBUF_C_CONTIGUOUS : c_int = (0x0020 | PyBUF_STRIDES); pub const PyBUF_F_CONTIGUOUS : c_int = (0x0040 | PyBUF_STRIDES); pub const PyBUF_ANY_CONTIGUOUS : c_int = (0x0080 | PyBUF_STRIDES); pub const PyBUF_INDIRECT : c_int = (0x0100 | PyBUF_STRIDES); pub const PyBUF_CONTIG : c_int = (PyBUF_ND | PyBUF_WRITABLE); pub const PyBUF_CONTIG_RO : c_int = (PyBUF_ND); pub const PyBUF_STRIDED : c_int = (PyBUF_STRIDES | PyBUF_WRITABLE); pub const PyBUF_STRIDED_RO : c_int = (PyBUF_STRIDES); pub const PyBUF_RECORDS : c_int = (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT); pub const PyBUF_RECORDS_RO : c_int = (PyBUF_STRIDES | PyBUF_FORMAT); pub const PyBUF_FULL : c_int = (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT); pub const PyBUF_FULL_RO : c_int = (PyBUF_INDIRECT | PyBUF_FORMAT); pub const PyBUF_READ : c_int = 0x100; pub const PyBUF_WRITE : c_int = 0x200; } #[cfg(not(Py_LIMITED_API))] pub use self::bufferinfo::*; pub type objobjproc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> c_int; pub type visitproc = unsafe extern "C" fn (object: *mut PyObject, arg: *mut c_void) -> c_int; pub type traverseproc = unsafe extern "C" fn (slf: *mut PyObject, visit: visitproc, arg: *mut c_void) -> c_int; pub type freefunc = unsafe extern "C" fn(arg1: *mut c_void); pub type destructor = unsafe extern "C" fn(arg1: *mut PyObject); #[cfg(not(Py_LIMITED_API))] pub type printfunc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::libc::FILE, arg3: c_int) -> c_int; pub type getattrfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut c_char) -> *mut PyObject; pub type getattrofunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject; pub type setattrfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut c_char, arg3: *mut PyObject) -> c_int; pub type setattrofunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; pub type reprfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject; pub type hashfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> Py_hash_t; pub type richcmpfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> *mut PyObject; pub type getiterfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject; pub type iternextfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject; pub type descrgetfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> *mut PyObject; pub type descrsetfunc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; pub type initproc = unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; pub type newfunc = unsafe extern "C" fn (arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject) -> *mut PyObject; pub type allocfunc = unsafe extern "C" fn (arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject; #[cfg(Py_LIMITED_API)] pub enum PyTypeObject { } #[cfg(not(Py_LIMITED_API))] mod typeobject { use libc::{c_void, c_char, c_ulong, c_uint}; use pyport::Py_ssize_t; #[repr(C)] #[derive(Copy)] pub struct PyNumberMethods { pub nb_add: Option<::object::binaryfunc>, pub nb_subtract: Option<::object::binaryfunc>, pub nb_multiply: Option<::object::binaryfunc>, pub nb_remainder: Option<::object::binaryfunc>, pub nb_divmod: Option<::object::binaryfunc>, pub nb_power: Option<::object::ternaryfunc>, pub nb_negative: Option<::object::unaryfunc>, pub nb_positive: Option<::object::unaryfunc>, pub nb_absolute: Option<::object::unaryfunc>, pub nb_bool: Option<::object::inquiry>, pub nb_invert: Option<::object::unaryfunc>, pub nb_lshift: Option<::object::binaryfunc>, pub nb_rshift: Option<::object::binaryfunc>, pub nb_and: Option<::object::binaryfunc>, pub nb_xor: Option<::object::binaryfunc>, pub nb_or: Option<::object::binaryfunc>, pub nb_int: Option<::object::unaryfunc>, pub nb_reserved: *mut c_void, pub nb_float: Option<::object::unaryfunc>, pub nb_inplace_add: Option<::object::binaryfunc>, pub nb_inplace_subtract: Option<::object::binaryfunc>, pub nb_inplace_multiply: Option<::object::binaryfunc>, pub nb_inplace_remainder: Option<::object::binaryfunc>, pub nb_inplace_power: Option<::object::ternaryfunc>, pub nb_inplace_lshift: Option<::object::binaryfunc>, pub nb_inplace_rshift: Option<::object::binaryfunc>, pub nb_inplace_and: Option<::object::binaryfunc>, pub nb_inplace_xor: Option<::object::binaryfunc>, pub nb_inplace_or: Option<::object::binaryfunc>, pub nb_floor_divide: Option<::object::binaryfunc>, pub nb_true_divide: Option<::object::binaryfunc>, pub nb_inplace_floor_divide: Option<::object::binaryfunc>, pub nb_inplace_true_divide: Option<::object::binaryfunc>, pub nb_index: Option<::object::unaryfunc>, #[cfg(Py_3_5)] pub nb_matrix_multiply: Option<::object::binaryfunc>, #[cfg(Py_3_5)] pub nb_inplace_matrix_multiply: Option<::object::binaryfunc>, } impl Clone for PyNumberMethods { #[inline] fn clone(&self) -> Self { *self } } impl Default for PyNumberMethods { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PySequenceMethods { pub sq_length: Option<::object::lenfunc>, pub sq_concat: Option<::object::binaryfunc>, pub sq_repeat: Option<::object::ssizeargfunc>, pub sq_item: Option<::object::ssizeargfunc>, pub was_sq_slice: *mut c_void, pub sq_ass_item: Option<::object::ssizeobjargproc>, pub was_sq_ass_slice: *mut c_void, pub sq_contains: Option<::object::objobjproc>, pub sq_inplace_concat: Option<::object::binaryfunc>, pub sq_inplace_repeat: Option<::object::ssizeargfunc>, } impl Clone for PySequenceMethods { #[inline] fn clone(&self) -> Self { *self } } impl Default for PySequenceMethods { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PyMappingMethods { pub mp_length: Option<::object::lenfunc>, pub mp_subscript: Option<::object::binaryfunc>, pub mp_ass_subscript: Option<::object::objobjargproc>, } impl Clone for PyMappingMethods { #[inline] fn clone(&self) -> Self { *self } } impl Default for PyMappingMethods { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] #[cfg(Py_3_5)] pub struct PyAsyncMethods { pub am_await: Option<::object::unaryfunc>, pub am_aiter: Option<::object::unaryfunc>, pub am_anext: Option<::object::unaryfunc>, } #[cfg(Py_3_5)] impl Clone for PyAsyncMethods { #[inline] fn clone(&self) -> Self { *self } } #[cfg(Py_3_5)] impl Default for PyAsyncMethods { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PyBufferProcs { pub bf_getbuffer: Option<::object::getbufferproc>, pub bf_releasebuffer: Option<::object::releasebufferproc>, } impl Clone for PyBufferProcs { #[inline] fn clone(&self) -> Self { *self } } impl Default for PyBufferProcs { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PyTypeObject { pub ob_base: ::object::PyVarObject, pub tp_name: *const c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: Option<::object::destructor>, pub tp_print: Option<::object::printfunc>, pub tp_getattr: Option<::object::getattrfunc>, pub tp_setattr: Option<::object::setattrfunc>, #[cfg(Py_3_5)] pub tp_as_async: *mut PyAsyncMethods, #[cfg(not(Py_3_5))] pub tp_reserved: *mut c_void, pub tp_repr: Option<::object::reprfunc>, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: Option<::object::hashfunc>, pub tp_call: Option<::object::ternaryfunc>, pub tp_str: Option<::object::reprfunc>, pub tp_getattro: Option<::object::getattrofunc>, pub tp_setattro: Option<::object::setattrofunc>, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: c_ulong, pub tp_doc: *const c_char, pub tp_traverse: Option<::object::traverseproc>, pub tp_clear: Option<::object::inquiry>, pub tp_richcompare: Option<::object::richcmpfunc>, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: Option<::object::getiterfunc>, pub tp_iternext: Option<::object::iternextfunc>, pub tp_methods: *mut ::methodobject::PyMethodDef, pub tp_members: *mut ::structmember::PyMemberDef, pub tp_getset: *mut ::descrobject::PyGetSetDef, pub tp_base: *mut PyTypeObject, pub tp_dict: *mut ::object::PyObject, pub tp_descr_get: Option<::object::descrgetfunc>, pub tp_descr_set: Option<::object::descrsetfunc>, pub tp_dictoffset: Py_ssize_t, pub tp_init: Option<::object::initproc>, pub tp_alloc: Option<::object::allocfunc>, pub tp_new: Option<::object::newfunc>, pub tp_free: Option<::object::freefunc>, pub tp_is_gc: Option<::object::inquiry>, pub tp_bases: *mut ::object::PyObject, pub tp_mro: *mut ::object::PyObject, pub tp_cache: *mut ::object::PyObject, pub tp_subclasses: *mut ::object::PyObject, pub tp_weaklist: *mut ::object::PyObject, pub tp_del: Option<::object::destructor>, pub tp_version_tag: c_uint, #[cfg(Py_3_4)] pub tp_finalize: Option<::object::destructor>, #[cfg(py_sys_config="COUNT_ALLOCS")] pub tp_allocs: Py_ssize_t, #[cfg(py_sys_config="COUNT_ALLOCS")] pub tp_frees: Py_ssize_t, #[cfg(py_sys_config="COUNT_ALLOCS")] pub tp_maxalloc: Py_ssize_t, #[cfg(py_sys_config="COUNT_ALLOCS")] pub tp_prev: *mut PyTypeObject, #[cfg(py_sys_config="COUNT_ALLOCS")] pub tp_next: *mut PyTypeObject, } impl Clone for PyTypeObject { #[inline] fn clone(&self) -> Self { *self } } impl Default for PyTypeObject { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PyHeapTypeObject { pub ht_type: PyTypeObject, #[cfg(Py_3_5)] pub as_async: PyAsyncMethods, pub as_number: PyNumberMethods, pub as_mapping: PyMappingMethods, pub as_sequence: PySequenceMethods, pub as_buffer: PyBufferProcs, pub ht_name: *mut ::object::PyObject, pub ht_slots: *mut ::object::PyObject, pub ht_qualname: *mut ::object::PyObject, pub ht_cached_keys: *mut c_void, } impl Clone for PyHeapTypeObject { #[inline] fn clone(&self) -> Self { *self } } impl Default for PyHeapTypeObject { #[inline] fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[inline] pub unsafe fn PyHeapType_GET_MEMBERS(etype: *mut PyHeapTypeObject) -> *mut ::structmember::PyMemberDef { (etype as *mut c_char).offset( (*::object::Py_TYPE(etype as *mut ::object::PyObject)).tp_basicsize as isize ) as *mut ::structmember::PyMemberDef } } #[cfg(not(Py_LIMITED_API))] pub use self::typeobject::*; #[repr(C)] #[derive(Copy)] pub struct PyType_Slot { pub slot: c_int, pub pfunc: *mut c_void, } impl Clone for PyType_Slot { fn clone(&self) -> PyType_Slot { *self } } impl Default for PyType_Slot { fn default() -> PyType_Slot { unsafe { ::core::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct PyType_Spec { pub name: *const c_char, pub basicsize: c_int, pub itemsize: c_int, pub flags: c_uint, pub slots: *mut PyType_Slot, } impl Clone for PyType_Spec { fn clone(&self) -> PyType_Spec { *self } } impl Default for PyType_Spec { fn default() -> PyType_Spec { unsafe { ::core::mem::zeroed() } } } extern "C" { pub fn PyType_FromSpec(arg1: *mut PyType_Spec) -> *mut PyObject; //#[cfg(Py_3_3)] pub fn PyType_FromSpecWithBases(arg1: *mut PyType_Spec, arg2: *mut PyObject) -> *mut PyObject; #[cfg(Py_3_4)] pub fn PyType_GetSlot(arg1: *mut PyTypeObject, arg2: c_int) -> *mut c_void; } extern "C" { pub fn PyType_IsSubtype(a: *mut PyTypeObject, b: *mut PyTypeObject) -> c_int; } #[inline(always)] pub unsafe fn PyObject_TypeCheck(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_int { (Py_TYPE(ob) == tp || PyType_IsSubtype(Py_TYPE(ob), tp) != 0) as c_int } extern "C" { /// built-in 'type' pub static mut PyType_Type: PyTypeObject; /// built-in 'object' pub static mut PyBaseObject_Type: PyTypeObject; /// built-in 'super' pub static mut PySuper_Type: PyTypeObject; pub fn PyType_GetFlags(arg1: *mut PyTypeObject) -> c_ulong; } #[inline(always)] pub unsafe fn PyType_Check(op: *mut PyObject) -> c_int { PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS) } #[inline(always)] pub unsafe fn PyType_CheckExact(op: *mut PyObject) -> c_int { (Py_TYPE(op) == &mut PyType_Type) as c_int } extern "C" { pub fn PyType_Ready(t: *mut PyTypeObject) -> c_int; pub fn PyType_GenericAlloc(t: *mut PyTypeObject, nitems: Py_ssize_t) -> *mut PyObject; pub fn PyType_GenericNew(t: *mut PyTypeObject, args: *mut PyObject, kwds: *mut PyObject) -> *mut PyObject; pub fn PyType_ClearCache() -> c_uint; pub fn PyType_Modified(t: *mut PyTypeObject); #[cfg(not(Py_LIMITED_API))] pub fn PyObject_Print(o: *mut PyObject, fp: *mut ::libc::FILE, flags: c_int) -> c_int; pub fn PyObject_Repr(o: *mut PyObject) -> *mut PyObject; pub fn PyObject_Str(o: *mut PyObject) -> *mut PyObject; pub fn PyObject_ASCII(arg1: *mut PyObject) -> *mut PyObject; pub fn PyObject_Bytes(arg1: *mut PyObject) -> *mut PyObject; pub fn PyObject_RichCompare(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> *mut PyObject; pub fn PyObject_RichCompareBool(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> c_int; pub fn PyObject_GetAttrString(arg1: *mut PyObject, arg2: *const c_char) -> *mut PyObject; pub fn PyObject_SetAttrString(arg1: *mut PyObject, arg2: *const c_char, arg3: *mut PyObject) -> c_int; pub fn PyObject_HasAttrString(arg1: *mut PyObject, arg2: *const c_char) -> c_int; pub fn PyObject_GetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject; pub fn PyObject_SetAttr(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; pub fn PyObject_HasAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int; /*pub fn _PyObject_IsAbstract(arg1: *mut PyObject) -> c_int; pub fn _PyObject_GetAttrId(arg1: *mut PyObject, arg2: *mut Struct__Py_Identifier) -> *mut PyObject; pub fn _PyObject_SetAttrId(arg1: *mut PyObject, arg2: *mut Struct__Py_Identifier, arg3: *mut PyObject) -> c_int; pub fn _PyObject_HasAttrId(arg1: *mut PyObject, arg2: *mut Struct__Py_Identifier) -> c_int;*/ pub fn PyObject_SelfIter(arg1: *mut PyObject) -> *mut PyObject; #[cfg(not(Py_LIMITED_API))] pub fn _PyObject_NextNotImplemented(arg1: *mut PyObject) -> *mut PyObject; pub fn PyObject_GenericGetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject; pub fn PyObject_GenericSetAttr(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int; pub fn PyObject_GenericSetDict(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut c_void) -> c_int; pub fn PyObject_Hash(arg1: *mut PyObject) -> Py_hash_t; pub fn PyObject_HashNotImplemented(arg1: *mut PyObject) -> Py_hash_t; pub fn PyObject_IsTrue(arg1: *mut PyObject) -> c_int; pub fn PyObject_Not(arg1: *mut PyObject) -> c_int; pub fn PyCallable_Check(arg1: *mut PyObject) -> c_int; pub fn PyObject_ClearWeakRefs(arg1: *mut PyObject) -> (); #[cfg(Py_3_4)] #[cfg(not(Py_LIMITED_API))] pub fn PyObject_CallFinalizer(arg1: *mut PyObject) -> (); #[cfg(Py_3_4)] #[cfg(not(Py_LIMITED_API))] pub fn PyObject_CallFinalizerFromDealloc(arg1: *mut PyObject) -> c_int; pub fn PyObject_Dir(arg1: *mut PyObject) -> *mut PyObject; pub fn Py_ReprEnter(arg1: *mut PyObject) -> c_int; pub fn Py_ReprLeave(arg1: *mut PyObject) -> (); } // Flag bits for printing: pub const Py_PRINT_RAW : c_int = 1; // No string quotes etc. /// Set if the type object is dynamically allocated pub const Py_TPFLAGS_HEAPTYPE : c_ulong = (1<<9); /// Set if the type allows subclassing pub const Py_TPFLAGS_BASETYPE : c_ulong = (1<<10); /// Set if the type is 'ready' -- fully initialized pub const Py_TPFLAGS_READY : c_ulong = (1<<12); /// Set while the type is being 'readied', to prevent recursive ready calls pub const Py_TPFLAGS_READYING : c_ulong = (1<<13); /// Objects support garbage collection (see objimp.h) pub const Py_TPFLAGS_HAVE_GC : c_ulong = (1<<14); const Py_TPFLAGS_HAVE_STACKLESS_EXTENSION : c_ulong = 0; /// Objects support type attribute cache pub const Py_TPFLAGS_HAVE_VERSION_TAG : c_ulong = (1<<18); pub const Py_TPFLAGS_VALID_VERSION_TAG : c_ulong = (1<<19); /* Type is abstract and cannot be instantiated */ pub const Py_TPFLAGS_IS_ABSTRACT : c_ulong = (1<<20); /* These flags are used to determine if a type is a subclass. */ pub const Py_TPFLAGS_LONG_SUBCLASS : c_ulong = (1<<24); pub const Py_TPFLAGS_LIST_SUBCLASS : c_ulong = (1<<25); pub const Py_TPFLAGS_TUPLE_SUBCLASS : c_ulong = (1<<26); pub const Py_TPFLAGS_BYTES_SUBCLASS : c_ulong = (1<<27); pub const Py_TPFLAGS_UNICODE_SUBCLASS : c_ulong = (1<<28); pub const Py_TPFLAGS_DICT_SUBCLASS : c_ulong = (1<<29); pub const Py_TPFLAGS_BASE_EXC_SUBCLASS : c_ulong = (1<<30); pub const Py_TPFLAGS_TYPE_SUBCLASS : c_ulong = (1<<31); pub const Py_TPFLAGS_DEFAULT : c_ulong = ( Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | Py_TPFLAGS_HAVE_VERSION_TAG | 0); pub const Py_TPFLAGS_HAVE_FINALIZE : c_ulong = (1<<0); #[inline(always)] #[cfg(Py_LIMITED_API)] pub unsafe fn PyType_HasFeature(t : *mut PyTypeObject, f : c_ulong) -> c_int { ((PyType_GetFlags(t) & f) != 0) as c_int } #[inline(always)] #[cfg(not(Py_LIMITED_API))] pub unsafe fn PyType_HasFeature(t : *mut PyTypeObject, f : c_ulong) -> c_int { (((*t).tp_flags & f) != 0) as c_int } #[inline(always)] pub unsafe fn PyType_FastSubclass(t : *mut PyTypeObject, f : c_ulong) -> c_int { PyType_HasFeature(t, f) } extern "C" { pub fn _Py_Dealloc(arg1: *mut PyObject) -> (); } // Reference counting macros. #[inline(always)] pub unsafe fn Py_INCREF(op : *mut PyObject) { if cfg!(py_sys_config="Py_REF_DEBUG") { Py_IncRef(op) } else { (*op).ob_refcnt += 1 } } #[inline(always)] pub unsafe fn Py_DECREF(op: *mut PyObject) { if cfg!(py_sys_config="Py_REF_DEBUG") { Py_DecRef(op) } else { (*op).ob_refcnt -= 1; if (*op).ob_refcnt == 0 { _Py_Dealloc(op) } } } #[inline(always)] pub unsafe fn Py_CLEAR(op: &mut *mut PyObject) { let tmp = *op; if !tmp.is_null() { *op = ptr::null_mut(); Py_DECREF(tmp); } } #[inline(always)] pub unsafe fn Py_XINCREF(op : *mut PyObject) { if !op.is_null() { Py_INCREF(op) } } #[inline(always)] pub unsafe fn Py_XDECREF(op : *mut PyObject) { if !op.is_null() { Py_DECREF(op) } } extern "C" { pub fn Py_IncRef(o: *mut PyObject); pub fn Py_DecRef(o: *mut PyObject); static mut _Py_NoneStruct: PyObject; static mut _Py_NotImplementedStruct: PyObject; } #[inline(always)] pub unsafe fn Py_None() -> *mut PyObject { &mut _Py_NoneStruct } #[inline(always)] pub unsafe fn Py_NotImplemented() -> *mut PyObject { &mut _Py_NotImplementedStruct } /* Rich comparison opcodes */ pub const Py_LT : c_int = 0; pub const Py_LE : c_int = 1; pub const Py_EQ : c_int = 2; pub const Py_NE : c_int = 3; pub const Py_GT : c_int = 4; pub const Py_GE : c_int = 5;