# _cffi_backend - pydoc - phpman Help on module _cffi_backend: ## NAME _cffi_backend ## CLASSES builtins.object CField CLibrary CType FFI Lib buffer ### class CField | Methods defined here: | | __getattribute__(self, name, /) | Return getattr(self, name). | | ---------------------------------------------------------------------- | Data descriptors defined here: | | bitshift | | bitsize | | flags | | offset | | type ### class CLibrary | Methods defined here: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | close_lib(...) | | load_function(...) | | read_variable(...) | | write_variable(...) ### class CType | Methods defined here: | | __dir__(...) | Default dir() implementation. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | ---------------------------------------------------------------------- | Data descriptors defined here: | | abi | function ABI | | args | function argument types | | cname | C name | | elements | enum elements | | ellipsis | function has '...' | | fields | struct or union fields | | item | pointer to, or array of | | kind | kind | | length | array length or None | | relements | enum elements, reverse | | result | function result type ### class FFI | Methods defined here: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | addressof(...) | Limited equivalent to the '&' operator in C: | | 1. ffi.addressof() returns a cdata that is a | pointer to this struct or union. | | 2. ffi.addressof(, field-or-index...) returns the address of a | field or array item inside the given structure or array, recursively | in case of nested structures or arrays. | | 3. ffi.addressof(, "name") returns the address of the named | function or global variable. | | alignof(...) | Return the natural alignment size in bytes of the argument. | It can be a string naming a C type, or a 'cdata' instance. | | callback(...) | Return a callback object or a decorator making such a callback object. | 'cdecl' must name a C function pointer type. The callback invokes the | specified 'python_callable' (which may be provided either directly or | via a decorator). Important: the callback object must be manually | kept alive for as long as the callback may be invoked from the C code. | | cast(...) | Similar to a C cast: returns an instance of the named C | type initialized with the given 'source'. The source is | casted between integers or pointers of any type. | | def_extern(...) | A decorator. Attaches the decorated Python function to the C code | generated for the 'extern "Python"' function of the same name. | Calling the C function will then invoke the Python function. | | Optional arguments: 'name' is the name of the C function, if | different from the Python function; and 'error' and 'onerror' | handle what occurs if the Python function raises an exception | (see the docs for details). | | dlclose(...) | Close a library obtained with ffi.dlopen(). After this call, access to | functions or variables from the library will fail (possibly with a | segmentation fault). | | dlopen(...) | Load and return a dynamic library identified by 'name'. The standard | C library can be loaded by passing None. | | Note that functions and types declared with 'ffi.cdef()' are not | linked to a particular library, just like C headers. In the library | we only look for the actual (untyped) symbols at the time of their | first access. | | from_buffer(...) | Return a that points to the data of the given Python | object, which must support the buffer interface. Note that this is | not meant to be used on the built-in types str or unicode | (you can build 'char[]' arrays explicitly) but only on objects | containing large quantities of raw data in some other format, like | 'array.array' or numpy arrays. | | from_handle(...) | Cast a 'void *' back to a Python object. Must be used *only* on the | pointers returned by new_handle(), and *only* as long as the exact | cdata object returned by new_handle() is still alive (somewhere else | in the program). Failure to follow these rules will crash. | | gc(...) | Return a new cdata object that points to the same data. | Later, when this new cdata object is garbage-collected, | 'destructor(old_cdata_object)' will be called. | | The optional 'size' gives an estimate of the size, used to | trigger the garbage collection more eagerly. So far only used | on PyPy. It tells the GC that the returned object keeps alive | roughly 'size' bytes of external memory. | | getctype(...) | Return a string giving the C type 'cdecl', which may be itself a | string or a object. If 'replace_with' is given, it gives | extra text to append (or insert for more complicated C types), like a | variable name, or '*' to get actually the C type 'pointer-to-cdecl'. | | init_once(...) | init_once(function, tag): run function() once. More precisely, | 'function()' is called the first time we see a given 'tag'. | | The return value of function() is remembered and returned by the current | and all future init_once() with the same tag. If init_once() is called | from multiple threads in parallel, all calls block until the execution | of function() is done. If function() raises an exception, it is | propagated and nothing is cached. | | integer_const(...) | Get the value of an integer constant. | | 'ffi.integer_const("xxx")' is equivalent to 'lib.xxx' if xxx names an | integer constant. The point of this function is limited to use cases | where you have an 'ffi' object but not any associated 'lib' object. | | list_types(...) | Returns the user type names known to this FFI instance. | This returns a tuple containing three lists of names: | (typedef_names, names_of_structs, names_of_unions) | | memmove(...) | ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. | | Like the C function memmove(), the memory areas may overlap; | apart from that it behaves like the C function memcpy(). | | 'src' can be any cdata ptr or array, or any Python buffer object. | 'dest' can be any cdata ptr or array, or a writable Python buffer | object. The size to copy, 'n', is always measured in bytes. | | Unlike other methods, this one supports all Python buffer including | byte strings and bytearrays---but it still does not support | non-contiguous buffers. | | new(...) | Allocate an instance according to the specified C type and return a | pointer to it. The specified C type must be either a pointer or an | array: ``new('X *')`` allocates an X and returns a pointer to it, | whereas ``new('X[n]')`` allocates an array of n X'es and returns an | array referencing it (which works mostly like a pointer, like in C). | You can also use ``new('X[]', n)`` to allocate an array of a | non-constant length n. | | The memory is initialized following the rules of declaring a global | variable in C: by default it is zero-initialized, but an explicit | initializer can be given which can be used to fill all or part of the | memory. | | When the returned object goes out of scope, the memory is | freed. In other words the returned object has ownership of | the value of type 'cdecl' that it points to. This means that the raw | data can be used as long as this object is kept alive, but must not be | used for a longer time. Be careful about that when copying the | pointer to the memory somewhere else, e.g. into another structure. | | new_allocator(...) | Return a new allocator, i.e. a function that behaves like ffi.new() | but uses the provided low-level 'alloc' and 'free' functions. | | 'alloc' is called with the size as argument. If it returns NULL, a | MemoryError is raised. 'free' is called with the result of 'alloc' | as argument. Both can be either Python functions or directly C | functions. If 'free' is None, then no free function is called. | If both 'alloc' and 'free' are None, the default is used. | | If 'should_clear_after_alloc' is set to False, then the memory | returned by 'alloc' is assumed to be already cleared (or you are | fine with garbage); otherwise CFFI will clear it. | | new_handle(...) | Return a non-NULL cdata of type 'void *' that contains an opaque | reference to the argument, which can be any Python object. To cast it | back to the original object, use from_handle(). You must keep alive | the cdata object returned by new_handle()! | | offsetof(...) | Return the offset of the named field inside the given structure or | array, which must be given as a C type name. You can give several | field names in case of nested structures. You can also give numeric | values which correspond to array items, in case of an array type. | | release(...) | Release now the resources held by a 'cdata' object from ffi.new(), | ffi.gc() or ffi.from_buffer(). The cdata object must not be used | afterwards. | | 'ffi.release(cdata)' is equivalent to 'cdata.__exit__()'. | | Note that on CPython this method has no effect (so far) on objects | returned by ffi.new(), because the memory is allocated inline with the | cdata object and cannot be freed independently. It might be fixed in | future releases of cffi. | | sizeof(...) | Return the size in bytes of the argument. | It can be a string naming a C type, or a 'cdata' instance. | | string(...) | Return a Python string (or unicode string) from the 'cdata'. If | 'cdata' is a pointer or array of characters or bytes, returns the | null-terminated string. The returned string extends until the first | null character, or at most 'maxlen' characters. If 'cdata' is an | array then 'maxlen' defaults to its length. | | If 'cdata' is a pointer or array of wchar_t, returns a unicode string | following the same rules. | | If 'cdata' is a single character or byte or a wchar_t, returns it as a | string or unicode string. | | If 'cdata' is an enum, returns the value of the enumerator as a | string, or 'NUMBER' if the value is out of range. | | typeof(...) | Parse the C type given as a string and return the | corresponding object. | It can also be used on 'cdata' instance to get its C type. | | unpack(...) | Unpack an array of C data of the given length, | returning a Python string/unicode/list. | | If 'cdata' is a pointer to 'char', returns a byte string. | It does not stop at the first null. This is equivalent to: | ffi.buffer(cdata, length)[:] | | If 'cdata' is a pointer to 'wchar_t', returns a unicode string. | 'length' is measured in wchar_t's; it is not the size in bytes. | | If 'cdata' is a pointer to anything else, returns a list of | 'length' items. This is a faster equivalent to: | [cdata[i] for i in range(length)] | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | errno | the value of 'errno' from/to the C calls | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | CData = | The internal base type for CData objects. Use FFI.CData to access it. Always check with isinstance(): subtypes are sometimes returned on CPython, for performance reasons. | | | CType = | | NULL = | | RTLD_DEEPBIND = 8 | | RTLD_GLOBAL = 256 | | RTLD_LAZY = 1 | | RTLD_LOCAL = 0 | | RTLD_NODELETE = 4096 | | RTLD_NOLOAD = 4 | | RTLD_NOW = 2 | | buffer = | ffi.buffer(cdata[, byte_size]): | Return a read-write buffer object that references the raw C data | pointed to by the given 'cdata'. The 'cdata' must be a pointer or an | array. Can be passed to functions expecting a buffer, or directly | manipulated with: | | buf[:] get a copy of it in a regular string, or | buf[idx] as a single character | buf[:] = ... | buf[idx] = ... change the content | | | error = ### class Lib | Methods defined here: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __dir__(...) | Default dir() implementation. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). ### class buffer | ffi.buffer(cdata[, byte_size]): | Return a read-write buffer object that references the raw C data | pointed to by the given 'cdata'. The 'cdata' must be a pointer or an | array. Can be passed to functions expecting a buffer, or directly | manipulated with: | | buf[:] get a copy of it in a regular string, or | buf[idx] as a single character | buf[:] = ... | buf[idx] = ... change the content | | Methods defined here: | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self