U
|
L ±d¨ ã @ sº d dl Z d dlZddlmZ ddlmZ ddlmZ ze W n( e k
|
rd d dl
|
m Z dd ZY nX ze W n e k
|
r e Z Y nX e ZG d d
|
d
|
eZd d Zd d Zdd ZdS )é Né )Ú allocate_lock)Ú CDefError)Úmodel)ÚCallablec C s
|
t | tS ©N)Ú
|
isinstancer )Úx© r
|
ú?d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\cffi/api.pyÚ<lambda> ó r c @ sÀ e Zd ZdZdjddZdkddZdldd Zdmd
|
d Zdnd dZdd Z dd Z
|
doddZ dd Z dd Z dd Zdd Zdpd d Zdqd d!Zd"d# Zdrd%d&Zd'd( Zedfd)d*Zd+d, Zdsd-d.Zdtd0d1Zdud2d3Zd4d5 Zdvd6d7Z d8d9 Z d:d; Z e e e dd<Z dwd=d>Z!d?d@ Z"dAdB Z#dCdD Z$dEdF Z%dGdH Z&dIdJ Z'dKdL Z(dMdN Z)dOdP Z*dQdR Z+dxdTdUZ,dydVdWZ-dzdYdZZ.d[d\ Z/d]d^ Z0d{d`daZ1dbdc Z2ddde Z3dfdg Z4dhdi Z5dS )|ÚFFIa
|
The main top-level class that you instantiate once, or once per module.
|
|
Example usage:
|
|
ffi = FFI()
|
ffi.cdef("""
|
int printf(const char *, ...);
|
""")
|
|
C = ffi.dlopen(None) # standard library
|
-or-
|
C = ffi.verify() # use a C compiler: verify the decl above is right
|
|
C.printf("hello, %s!\n", ffi.new("char[]", "world"))
|
Nc C s¶ |dkr^ddl }ddlm} |j|kr^t|drJtd|t|j|jf ntd|t|jf ddlm} || _t | _ |
|
¡ | _ i | _ t d ¡j| _t d
|
¡j| _g | _g | _g | _g | _d| _i | _d| _d| _t |¡| _ t|d rô| | ¡ t |jD ] }| d ¡rþt | |t!|| qþ| j " | "tj#¡| _$| "tj%¡| _&W 5 Q R X t'|t jrtt(d sª| )| j$d¡t(_*| +¡ \t(_,t(_-n | )| j$d¡| _*| +¡ \| _,| _-|j.| _.dS )z{Create an FFI instance. The 'backend' argument is used to
|
select a non-default backend, mostly for tests.
|
Nr r )Ú __version__Ú__file__zåVersion mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation.zØVersion mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation.)ÚcparserZ parsed_typesZ new_typesÚset_ffiZRTLD_ÚNULL)/Z _cffi_backendÚ r ÚhasattrÚ Exceptionr r Ú_backendr Ú_lockÚParserÚ_parserÚ_cached_btypesÚtypesÚ
|
ModuleTypeÚ__dict__Ú _parsed_typesZ
|
_new_typesÚ_function_cachesÚ
|
_librariesÚ _cdefsourcesÚ_included_ffisÚ_windows_unicodeÚ_init_once_cacheÚ _cdef_versionÚ
|
_embeddingr Z get_typecacheZ
|
_typecacher ÚlistÚ
|
startswithÚsetattrÚgetattrÚ_get_cached_btypeZ
|
voidp_typeÚBVoidPZchar_array_typeÚBCharAr r Úcastr Z
|
_get_typesÚCDataZCTypeÚbuffer)ÚselfÚbackendr r Únamer
|
r
|
r Ú__init__) s^
|
|
þ
|
ÿ
|
|
|
|
z FFI.__init__Fc C s | j ||||d dS )a[ Parse the given C source. This registers all declared functions,
|
types, and global variables. The functions and global variables can
|
then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'.
|
The types can be used in 'ffi.new()' and other functions.
|
If 'packed' is specified as True, all structs declared inside this
|
cdef are packed, i.e. laid out without any field alignment at all.
|
Alternatively, 'pack' can be a small integer, and requests for
|
alignment greater than that are ignored (pack=1 is equivalent to
|
packed=True).
|
)ÚoverrideÚpackedÚpackN)Ú_cdef)r2 Úcsourcer6 r7 r8 r
|
r
|
r Úcdefe s zFFI.cdefc C s& | j |||dd | jd kr"d| _d S )NT)r7 r8 Z dllexportr )r9 r' )r2 r: r7 r8 r
|
r
|
r Ú embedding_apir s
|
zFFI.embedding_apic K sª t |ts&t |ts td| d¡}| jt t | _| jj |fd|i| | j
|
|¡ |rr| j D ] }| ¡ qd| jj}|rg | j_|D ]}| | |¡ qW 5 Q R X d S )Nz cdef() argument must be a stringÚasciir6 )r ÚstrÚ
|
basestringÚ TypeErrorÚencoder Úobjectr& r Úparser" Úappendr ÚclearZ _recompleteÚfinish_backend_type)r2 r: r6 ÚoptionsÚcacheÚ
|
finishlistÚtpr
|
r
|
r r9 w s
|
|
|
|
|
z FFI._cdefr c C sd t |ts&|dks&t || js&td| j. t| ||\}}| j |¡ | j |¡ W 5 Q R X |S )aH 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 by 'ffi.cdef()' are not
|
linked to a particular library, just like C headers; in the
|
library we only look for the actual (untyped) symbols.
|
NzRdlopen(name): name must be a file name, None, or an already-opened 'void *' handle) r r? r0 r@ r Ú_make_ffi_libraryr rD r! )r2 r4 ÚflagsÚlibZfunction_cacher
|
r
|
r Údlopen s
|
ÿ
|
þ z
|
FFI.dlopenc C s t | |¡ dS )z¸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).
|
N)ÚtypeÚ__cffi_close__)r2 rM r
|
r
|
r Údlclose s z FFI.dlclosec C sj |}|| j kr| j | S t|ts,| d¡}| j |¡}|j}|rJ| ¡ }| |¡}||f}|| j |< |S )Nr= ) r r r> rA r Z
|
parse_typeZis_raw_functionZas_function_pointerr, )r2 ÚcdeclÚkeyrO Úreally_a_function_typeÚbtypeÚresultr
|
r
|
r Ú_typeof_locked¢ s
|
|
|
|
|
|
zFFI._typeof_lockedc C sb z| j | }W n0 tk
|
r> | j | |¡}W 5 Q R X Y nX |\}}|r^|s^td|f |S )Nz>the type %r is a function type, not a pointer-to-function type)r ÚKeyErrorr rW r )r2 rR Ú consider_function_as_funcptrrV rU rT r
|
r
|
r Ú_typeof´ s ÿz FFI._typeofc
|
C s t |tr| |¡S t || jr,| j |¡S t |tjrLt|}|dk rL|S t |tj rt
|
|dr| j | |j ¡W 5 Q R £ S Q R X tt|dS )z£Parse the C type given as a string and return the
|
corresponding <ctype> object.
|
It can also be used on 'cdata' instance to get its C type.
|
NÚ_cffi_base_type)r r? rZ r0 r Útypeofr ÚBuiltinFunctionTypeÚ_builtin_function_typeÚ FunctionTyper r r, r[ r@ rO )r2 rR Úresr
|
r
|
r r\ Â s
|
|
ÿ z
|
FFI.typeofc C s0 t |tr | |¡}| j |¡S | j |¡S dS )zvReturn the size in bytes of the argument. It can be a
|
string naming a C type, or a 'cdata' instance.
|
N)r r? rZ r Úsizeof)r2 rR ÚBTyper
|
r
|
r ra Õ s
|
|
z
|
FFI.sizeofc C s t |tr| |¡}| j |¡S )z\Return the natural alignment size in bytes of the C type
|
given as a string.
|
)r r? rZ r Úalignof)r2 rR r
|
r
|
r rc ß s
|
|
z FFI.alignofc G s( t |tr| |¡}| j|f| d S )a3 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.
|
r )r r? rZ Ú _typeoffsetof)r2 rR Úfields_or_indexesr
|
r
|
r Úoffsetofç s
|
|
z FFI.offsetofc C s" t |tr| |¡}| j ||¡S )a¬ 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 <cdata> object goes out of scope, the memory
|
is freed. In other words the returned <cdata> 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.
|
)r r? rZ r Únewp)r2 rR Úinitr
|
r
|
r Únewò s
|
|
zFFI.newTc s, j ¡ }| |||¡ d fdd }|S )aÇ 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 function 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.
|
Nc s t | tr | ¡} | |S r ©r r? rZ )rR rh ©Z allocatorr2 r
|
r Úallocate s
|
|
z#FFI.new_allocator.<locals>.allocate)N)r r Ú new_allocator)r2 ZallocÚfreeZshould_clear_after_allocZ compiled_ffirl r
|
rk r rm s
|
ÿzFFI.new_allocatorc C s" t |tr| |¡}| j ||¡S )zº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.
|
)r r? rZ r r/ )r2 rR Úsourcer
|
r
|
r r/ % s
|
|
zFFI.castéÿÿÿÿc C s | j ||¡S )aà 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.
|
)r Ústring)r2 ÚcdataÚmaxlenr
|
r
|
r rq . s z
|
FFI.stringc C s | j ||¡S )aL 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)]
|
)r Úunpack)r2 rr Úlengthr
|
r
|
r rt @ s z
|
FFI.unpackc C s: |t kr| j| }}nt|tr*| |¡}| j |||¡S )aÙ Return a cdata of the given type pointing 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.
|
|
The first argument is optional and default to 'char[]'.
|
)Ú _unspecifiedr. r r? rZ r Ú from_buffer)r2 rR Z python_bufferZrequire_writabler
|
r
|
r rw ^ s
|
|
|
ÿzFFI.from_bufferc C s | j |||¡S )a_ 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.
|
)r Úmemmove)r2 ÚdestÚsrcÚnr
|
r
|
r rx p s z FFI.memmovec sB fdd}t tr*j dd |dkr6|S ||S dS )a 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 level.
|
c s" t | stdj | ¡S )Nz.the 'python_callable' argument is not callable)Úcallabler@ r Úcallback)Úpython_callable©rR ÚerrorÚonerrorr2 r
|
r Úcallback_decorator_wrap s
|
ÿz-FFI.callback.<locals>.callback_decorator_wrapT)rY Nrj )r2 rR r~ r r r r
|
r r r} s
|
z FFI.callbackr c C sh t |tr| |¡}| ¡ }| d¡rBd| j |d¡krBd| }n|rZ|d dkrZd| }| j ||¡S )a. Return a string giving the C type 'cdecl', which may be itself
|
a string or a <ctype> 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'.
|
Ú*z&[ú&z(%s)r z[(ú )r r? rZ Ústripr) r Zgetcname)r2 rR Z replace_withr
|
r
|
r Úgetctype s
|
|
|
ÿ
|
z FFI.getctypec C s | j |||¡S )a» 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.
|
)r Zgcp)r2 rr Z
|
destructorÚsizer
|
r
|
r Úgc¥ s
|
zFFI.gcc C sb | j d¡dkstz| j| }W n: tk
|
r\ g }| | |¡}|D ]}| | |¡ qFY nX |S )NF)r ÚacquireÚAssertionErrorr rX Zget_cached_btyperF )r2 rO rb rI r
|
r
|
r r, ± s zFFI._get_cached_btypec K sV ddl m}m} | jr | |¡ |p(| }|| ||f|| _ | j ¡ }| j |¡ |S )aÊ Verify that the current ffi signatures compile on this
|
machine, and return a dynamic library object. The dynamic
|
library can be used to call functions and access global
|
variables declared in this 'ffi'. The library is compiled
|
by the C compiler: it gives you C-level API compatibility
|
(including calling macros). This is unlike 'ffi.dlopen()',
|
which requires binary compatibility in the signatures.
|
r )ÚVerifierÚ_caller_dir_pycache)Úverifierr r r$ Ú_apply_windows_unicodeÚ load_libraryr! rD )r2 ro ÚtmpdirÚkwargsr r rM r
|
r
|
r Úverify½ s
|
|
|
z
|
FFI.verifyc C s
|
| j ¡ S r )r Ú get_errno©r2 r
|
r
|
r Ú
|
_get_errnoÛ s zFFI._get_errnoc C s | j |¡ d S r )r Ú set_errno)r2 Úerrnor
|
r
|
r Ú
|
_set_errnoÝ s zFFI._set_errnoz(the value of 'errno' from/to the C callsc C s | j |¡S r )r Ú getwinerror)r2 Úcoder
|
r
|
r r â s zFFI.getwinerrorc
|
C s* | j t | |¡W 5 Q R £ S Q R X d S r )r r Ú pointer_cache)r2 Úctyper
|
r
|
r Ú _pointer_toå s zFFI._pointer_toc G s z| j |¡}W n< tk
|
rL dt|jkrFt|j|f| Y S Y nX |rh| j|f| \}}n|jdkrztdd}| |¡}| j |||¡S )zêReturn the address of a <cdata 'struct-or-union'>.
|
If 'fields_or_indexes' are given, returns the address of that
|
field or array item in the structure or array, recursively in
|
case of nested structures.
|
Ú __addressof__Úpointerzaddressof(pointer)r )
|
r r\ r@ rO r r rd Úkindr Z rawaddressof)r2 rr re r ÚoffsetZctypeptrr
|
r
|
r Ú addressofé s
|
|
z FFI.addressofc G s@ | j ||¡\}}|D ] }| j ||d¡\}}||7 }q||fS )Nr )r Z typeoffsetof)r2 r Zfield_or_indexre r¢ Zfield1Zoffset1r
|
r
|
r rd þ s
|
|
zFFI._typeoffsetofc
|
C s t |ts tdt|jf || kr.td|jX | jF | j |j¡ | j
|
d¡ | j |j ¡ | j
|
d¡ | j
|
|¡ W 5 Q R X W 5 Q R X dS )aÉ Includes the typedefs, structs, unions and enums defined
|
in another FFI instance. Usage is similar to a #include in C,
|
where a part of the program might include types defined in
|
another part for its own usage. Note that the include()
|
method has no effect on functions, constants and global
|
variables, which must anyway be accessed directly from the
|
lib object returned by the original FFI instance.
|
zGffi.include() expects an argument that is also of type cffi.FFI, not %rzself.include(self)ú[ú]N) r r r@ rO Ú__name__Ú
|
ValueErrorr r Úincluder" rD Úextendr# )r2 Zffi_to_includer
|
r
|
r r¨ s
|
ÿÿ z FFI.includec C s | j | j|¡S r )r Z newp_handler- ©r2 r r
|
r
|
r Ú
|
new_handle s zFFI.new_handlec C s | j |¡S r )r Ú from_handlerª r
|
r
|
r r¬ s zFFI.from_handlec C s | j |¡ d S r )r Úreleaserª r
|
r
|
r r " s z FFI.releasec C s> | j dk rtdt|}|r*| d¡ n
|
| d¡ || _ dS )ac Windows: if 'enabled_flag' is True, enable the UNICODE and
|
_UNICODE defines in C, and declare the types like TCHAR and LPTCSTR
|
to be (pointers to) wchar_t. If 'enabled_flag' is False,
|
declare these types to be (pointers to) plain 8-bit characters.
|
This is mostly for backward compatibility; you usually want True.
|
Nz%set_unicode() can only be called oncezÄtypedef wchar_t TBYTE;typedef wchar_t TCHAR;typedef const wchar_t *LPCTSTR;typedef const wchar_t *PCTSTR;typedef wchar_t *LPTSTR;typedef wchar_t *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;z²typedef char TBYTE;typedef char TCHAR;typedef const char *LPCTSTR;typedef const char *PCTSTR;typedef char *LPTSTR;typedef char *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;)r$ r§ Úboolr; )r2 Z enabled_flagr
|
r
|
r Ú set_unicode% s
|
|
zFFI.set_unicodec C s> | dd¡}t|ttfs"tdt|ddg }||d< d S )NÚ define_macrosr
|
z''define_macros' must be a list or tuple)ÚUNICODEÚ1)Z_UNICODEr² )Úgetr r( Útupler@ )r2 ÚkwdsZ defmacrosr
|
r
|
r r C s ÿzFFI._apply_windows_unicodec sr fdd}dt jkr®dd l}t jdkrVd t j¡}tt dr|d|j t j d ¡ n4t jd
|
k rfd }nd }tt dr|d|j t j d ¡ tt dr¬|d|j t j dd¡ n t jdkrÐd}tt drÎ|d7 }nLz dd l
|
}W n t k
|
rü ddl m
|
} Y nX d}| d¡r || d¡7 }|t jd? t jd? d@ f }tt drN|t j7 }|d| t jdkrn|dd d S ) Nc s" | g ¡}||kr | |¡ d S r )Ú
|
setdefaultrD )rS ÚvalueÚlst©rµ r
|
r ÚensureM s z(FFI._apply_embedding_fix.<locals>.ensureZ__pypy__r Úwin32zpython{0[0]}{0[1]}ÚprefixÚ library_dirsZlibs©é zpypy-czpypy3-cÚbinÚpypyZgoalz
|
python%d%dÚgettotalrefcountZ_d)Ú sysconfigz python%d.%dZ DEBUG_EXTé é éÿ ÚabiflagsÚ librariesÚextra_link_argsz /MANIFEST)ÚsysÚbuiltin_module_namesÚosÚplatformÚformatÚ version_infor ÚpathÚjoinr¼ rÃ Ú ImportErrorÚ distutilsÚget_config_varÚ
|
hexversionrÇ )r2 rµ rº rÌ Z pythonlibÚtemplaterà r
|
r¹ r Ú_apply_embedding_fixK sB
|
|
|
|
|
|
|
|
|
ÿ
|
|
zFFI._apply_embedding_fixú.cc K sd dd l }t| drtdt|ts,td|j|ksF|jrN|j|krNtdt||||f| _ d S )Nr Ú_assigned_sourcez:set_source() cannot be called several times per ffi objectz 'module_name' must be a stringzY'module_name' must not contain '/': use a dotted name to make a 'package.module' location)
|
rÌ r r§ r r? r@ ÚsepÚaltsepr> rÙ )r2 Ú module_namero Úsource_extensionrµ rÌ r
|
r
|
r Ú
|
set_source} s
|
|
ÿzFFI.set_sourcec K sJ ddl m} t|ts td| |¡}| ||¡ | j|||f| d S )Nr )Ú pkgconfigz;the pkgconfig_libs argument must be a list of package names)r rß r r( r@ Zflags_from_pkgconfigZ merge_flagsrÞ )r2 rÜ Zpkgconfig_libsro rÝ rµ rß Zkwds2r
|
r
|
r Úset_source_pkgconfig s
|
|
zFFI.set_source_pkgconfigÚbuildc C sÄ ddl m} ddlm} t| ds>t| dr6| j ¡ S td| j\}}}}|d kr\t d|| || ||f|||d d
|
|\} }
|
|rÀ|
|
r¨t
|
j d | j d f ¡ nt
|
j d | j d f ¡ | S ) Nr )Úmkpathr ©Ú recompilerÙ r z8set_source() must be called before distutils_extension()zadistutils_extension() is only for C extension modules, not for dlopen()-style pure Python modulesF)r ZextradirrÝ Úcall_c_compilerzregenerated: %r
|
znot modified: %r
|
)Údistutils.dir_utilrâ Ú
|
recompilerrä r r Ú get_extensionr§ rÙ r@ rÊ ÚstderrÚwriteÚsources) r2 r Úverboserâ rä rÜ ro rÝ rµ ÚextÚupdatedr
|
r
|
r Údistutils_extension s2
|
|
|
ÿ ýý
|
zFFI.distutils_extensionc C sZ ddl m} t| ds td| j\}}}}|d kr<td|| ||f|dd| d S )Nr rã rÙ ú0set_source() must be called before emit_c_code()zYemit_c_code() is only for C extension modules, not for dlopen()-style pure Python modulesF©Zc_filerå ©rç rä r r§ rÙ r@ ©r2 Úfilenamerä rÜ ro rÝ rµ r
|
r
|
r Ú emit_c_code® s
|
|
ÿÿzFFI.emit_c_codec C sZ ddl m} t| ds td| j\}}}}|d k r<td|| ||f|dd| d S )Nr rã rÙ rð z^emit_python_code() is only for dlopen()-style pure Python modules, not for C extension modulesFrñ rò ró r
|
r
|
r Úemit_python_codeº s
|
|
ÿÿzFFI.emit_python_codeÚ.c
|
C sL ddl m} t| ds td| j\}}}} || ||f|||||d| S )a¿ The 'target' argument gives the final file name of the
|
compiled DLL. Use '*' to force distutils' choice, suitable for
|
regular CPython C API modules. Use a file name ending in '.*'
|
to ask for the system's default extension for dynamic libraries
|
(.so/.dll/.dylib).
|
|
The default is '*' when building a non-embedded C API extension,
|
and (module_name + '.*') when building an embedded library.
|
r rã rÙ z,set_source() must be called before compile())r ÚtargetrÝ Zcompiler_verboseÚdebug)rç rä r r§ rÙ )
|
r2 r rì rø rù rä rÜ ro rÝ rµ r
|
r
|
r ÚcompileÆ s
|
|
þþz FFI.compilec
|
C s z| j | }W n( tk
|
r6 | j |dt f¡}Y nX |d rH|d S |d @ | j | }|d rx|d W 5 Q R £ S | }d|f| j |< W 5 Q R X |S )NFr r T)r% rX r¶ r )r2 ÚfuncÚtagr rV r
|
r
|
r Ú init_onceÙ s
|
|
z FFI.init_oncec sÎ | j rtddd l}| d|¡}|r6|| ¡ d
}| ¡ pBdg}| d|d ¡ ¡ }tdt|D ], | }| ¡ rf|
|
|¡sf|d d
}qzqft| fdd |D }d |¡}t |d
|
d || _ d S ) Nz-embedding_init_code() can only be called oncer z\s*\nr z\s*r rp c s g | ]}| d
d qS )NÚ
|
r
|
)Ú.0Úline©Úir
|
r Ú
|
<listcomp> s z+FFI.embedding_init_code.<locals>.<listcomp>Z cffi_initÚexec) r' r§ ÚreÚmatchÚendÚ
|
splitlinesÚgroupÚrangeÚlenÚrstripr) rÑ rú )r2 Zpysourcer r Úlinesr¼ r r
|
r r Úembedding_init_codeñ s$
|
|
zFFI.embedding_init_codec O s t dd S )Nz:ffi.def_extern() is only available on API-mode FFI objects)r§ )r2 Úargsrµ r
|
r
|
r Ú
|
def_extern s zFFI.def_externc C s g }g }g }| j jD ]\}| d¡r6| |dd
¡ q| d¡rT| |dd
¡ q| d¡r| |dd
¡ q| ¡ | ¡ | ¡ |||fS )z¹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)
|
ztypedef é Nzstruct é zunion é )r Ú _declarationsr) rD Úsort)r2 ZtypedefsÚstructsZunionsrS r
|
r
|
r Ú
|
list_types s
|
|
|
zFFI.list_types)N)FFN)FN)F)r )F)N)NNT)rp )NNN)r )r )r N)rp )rØ )rØ )rá T)r÷ r NN)6r¦ Ú
|
__module__Ú __qualname__Ú__doc__r5 r; r< r9 rN rQ rW rZ r\ ra rc rf ri rm r/ rq rt rv rw rx r} r r r, r r r Úpropertyr r r r£ rd r¨ r« r¬ r r¯ r r× rÞ rà rï rõ rö rú rý r r r r
|
r
|
r
|
r r sp
|
<
|
|
|
|
|
|
|
ÿ
|
|
ÿ
|
|
|
|
|
ÿ
|
2
|
ÿ
|
|
|
|
r c
|
C sú dd l }t|ts4tjdks$|d k r0| ||¡S d}d }d|ksRd|ksR|j|krz| ||¡W S tk
|
r } z|}W 5 d }~X Y nX dd l}|j
|
|¡}|d krî|dkrÈtjdkrÈtj dkrÈtdd|f }|d k ræd ||f }t|| ||¡S )
|
Nr r» Úcr÷ ú/r¾ zXdlopen(None) cannot work on Windows for Python 3 (see http://bugs.python.org/issue23606)zGctypes.util.find_library() did not manage to locate a library called %rz%s. Additionally, %s) rÌ r r? rÊ rÍ r rÚ ÚOSErrorÚ ctypes.utilÚutilÚ find_libraryrÏ ) r3 r4 rL rÌ Z first_errorÚeÚctypesrÐ Úmsgr
|
r
|
r Ú_load_backend_lib$ s.
|
ÿ r% c s
|
j }t|||
|
fdd
|
fdd
|
fdddd
|
fd d
|
i d gi
|
fd d
|
fdd G
|
fdddt t|trøz"t|tsÖ| d¡}d| _W n tk
|
rö Y nX j fS )Nc s< d| }j j| \}} |¡} || ¡}|j| < d S )Nz function )r r r, Ú load_functionr )r4 rS rJ Ú_rb r· )Ú
|
backendlibÚffiÚlibraryr
|
r Úaccessor_functionB s
|
|
z,_make_ffi_library.<locals>.accessor_functionc s\ d }j j| \}} |¡ jjtt fdd fdd d S )Nú variable c s
|
S r r
|
r )rb r4 Ú read_variabler
|
r r P r z>_make_ffi_library.<locals>.accessor_variable.<locals>.<lambda>c s |S r r
|
)r2 r· )rb r4 Úwrite_variabler
|
r r Q r )r r r, r- r. r* r )r4 rS rJ r' )Ú
|
FFILibraryr( r) )rb r4 r- r. r Úaccessor_variableI s
|
þz,_make_ffi_library.<locals>.accessor_variablec s z
|
| W S t k
|
r jZ | krvd| }jj| \}} |¡}|jdkrbt |¡} || ¡}| | < W 5 Q R X | Y S X d S )Nr, Úarray) rX r r r r, r¡ r r r& )r4 rS rJ r' rb Úp)Úaddr_variablesr( r) r
|
r Ú addressof_varS s
|
|
|
z(_make_ffi_library.<locals>.addressof_varc S s t d| f d S )NzDnon-integer constant '%s' cannot be accessed from a dlopen() library)ÚNotImplementedError©r4 r
|
r
|
r Úaccessor_constantb s ÿz,_make_ffi_library.<locals>.accessor_constantc s j j| j| < d S r )r Ú_int_constantsr r6 )r) r* r
|
r Úaccessor_int_constantf s z0_make_ffi_library.<locals>.accessor_int_constantFc sÔ d j krd S jj ¡ D ]\} \}}t|tjs|| dd¡\}}|dkrX|< qª|dkrj|< qª|dkrª |< q t|j D ]"\}}||ffdd }||< qq jj
|
D ]} |¡ q´j d< d S ) Nr r
r ÚfunctionÚvariableZconstantc s | ¡ |j| j| < d S r )Zcheck_not_partialZ
|
enumvaluesr )r4 rJ r )r* r
|
r Ú accessor_enum| s zB_make_ffi_library.<locals>.update_accessors.<locals>.accessor_enum) r& r r Úitemsr r ZEnumTypeÚsplitÚ enumerateZ enumeratorsr8 r¶ )rS rJ r' rü r4 r Zenumnamer< )r7 r+ r9 r0 Ú accessorsÚaccessors_versionr) r* r
|
r Úupdate_accessorsm s"
|
|
|
z+_make_ffi_library.<locals>.update_accessorsc sb j R | jks | jkr*W 5 Q R £ d S | krH | krHt| | | W 5 Q R X d S r )r r ÚAttributeErrorr6 )r/ r@ r) r* rB r
|
r Ú make_accessor s z(_make_ffi_library.<locals>.make_accessorc sR e Zd ZfddZfddZfddZ fddZfd d
|
Zd S ) z%_make_ffi_library.<locals>.FFILibraryc s | t | |S r )r+ ©r2 r4 ©rD r
|
r Ú __getattr__ s z1_make_ffi_library.<locals>.FFILibrary.__getattr__c sJ zt | j|}W n( tk
|
r8 | t| || Y nX | | |¡ d S r )r+ Ú __class__rC r* Ú__set__)r2 r4 r· r rF r
|
r Ú __setattr__ s z1_make_ffi_library.<locals>.FFILibrary.__setattr__c
|
s, j ¡ W 5 Q R £ S Q R X d S r )r Úkeysr )r@ r) rB r
|
r Ú__dir__ s z-_make_ffi_library.<locals>.FFILibrary.__dir__c sf |j krj | S | j kr&|S | |j krBj | S | j krT|S td|f d S )Nz:cffi library has no function or global variable named '%s')r rC rE )r/ r4 r* rD r
|
r r s
|
|
|
|
|
|
ÿz3_make_ffi_library.<locals>.FFILibrary.__addressof__c s ¡ | j ¡ d S r )Z close_libr rE r )r( r
|
r rP ª s z4_make_ffi_library.<locals>.FFILibrary.__cffi_close__N)r¦ r r rG rJ rL r rP r
|
)r/ r@ r4 r( r) r* rD rB r
|
r r/ s
|
r/ zutf-8z FFILibrary_%s)
|
r r% rB r r? r> rA r¦ Ú UnicodeErrorr )r) ÚlibnamerL r3 r
|
)r/ r7 r+ r9 r0 r@ rA r3 r4 r( r) r* rD rB r rK > s,
|
|
"
|
|
|
rK c
|
C sr dd l }z$|j| j }|j}|j}|| }W n tttfk
|
rH Y d S X |j | |¡W 5 Q R £ S Q R X d S )Nr )
|
rÊ Úmodulesr Z_cffi_original_ffiZ _cffi_types_of_builtin_funcsrX rC r@ r r, )rû rÊ Úmoduler) Ztypes_of_builtin_funcsrJ r
|
r
|
r r^ ¸ s r^ )rÊ r Úlockr r r r r r| Ú NameErrorÚ collectionsr r? r> rB rv r r% rK r^ r
|
r
|
r
|
r Ú<module> s.
|
z
|
