| import sys, types |
| from .lock import allocate_lock |
| from .error import CDefError |
| from . import model |
| |
| try: |
| callable |
| except NameError: |
| # Python 3.1 |
| from collections import Callable |
| callable = lambda x: isinstance(x, Callable) |
| |
| try: |
| basestring |
| except NameError: |
| # Python 3.x |
| basestring = str |
| |
| _unspecified = object() |
| |
| |
| |
| class FFI(object): |
| r''' |
| 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")) |
| ''' |
| |
| def __init__(self, backend=None): |
| """Create an FFI instance. The 'backend' argument is used to |
| select a non-default backend, mostly for tests. |
| """ |
| if backend is None: |
| # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with |
| # _cffi_backend.so compiled. |
| import _cffi_backend as backend |
| from . import __version__ |
| if backend.__version__ != __version__: |
| # bad version! Try to be as explicit as possible. |
| if hasattr(backend, '__file__'): |
| # CPython |
| raise Exception("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." % ( |
| __version__, __file__, |
| backend.__version__, backend.__file__)) |
| else: |
| # PyPy |
| raise Exception("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." % ( |
| __version__, __file__, backend.__version__)) |
| # (If you insist you can also try to pass the option |
| # 'backend=backend_ctypes.CTypesBackend()', but don't |
| # rely on it! It's probably not going to work well.) |
| |
| from . import cparser |
| self._backend = backend |
| self._lock = allocate_lock() |
| self._parser = cparser.Parser() |
| self._cached_btypes = {} |
| self._parsed_types = types.ModuleType('parsed_types').__dict__ |
| self._new_types = types.ModuleType('new_types').__dict__ |
| self._function_caches = [] |
| self._libraries = [] |
| self._cdefsources = [] |
| self._included_ffis = [] |
| self._windows_unicode = None |
| self._init_once_cache = {} |
| self._cdef_version = None |
| self._embedding = None |
| self._typecache = model.get_typecache(backend) |
| if hasattr(backend, 'set_ffi'): |
| backend.set_ffi(self) |
| for name in list(backend.__dict__): |
| if name.startswith('RTLD_'): |
| setattr(self, name, getattr(backend, name)) |
| # |
| with self._lock: |
| self.BVoidP = self._get_cached_btype(model.voidp_type) |
| self.BCharA = self._get_cached_btype(model.char_array_type) |
| if isinstance(backend, types.ModuleType): |
| # _cffi_backend: attach these constants to the class |
| if not hasattr(FFI, 'NULL'): |
| FFI.NULL = self.cast(self.BVoidP, 0) |
| FFI.CData, FFI.CType = backend._get_types() |
| else: |
| # ctypes backend: attach these constants to the instance |
| self.NULL = self.cast(self.BVoidP, 0) |
| self.CData, self.CType = backend._get_types() |
| self.buffer = backend.buffer |
| |
| def cdef(self, csource, override=False, packed=False, pack=None): |
| """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). |
| """ |
| self._cdef(csource, override=override, packed=packed, pack=pack) |
| |
| def embedding_api(self, csource, packed=False, pack=None): |
| self._cdef(csource, packed=packed, pack=pack, dllexport=True) |
| if self._embedding is None: |
| self._embedding = '' |
| |
| def _cdef(self, csource, override=False, **options): |
| if not isinstance(csource, str): # unicode, on Python 2 |
| if not isinstance(csource, basestring): |
| raise TypeError("cdef() argument must be a string") |
| csource = csource.encode('ascii') |
| with self._lock: |
| self._cdef_version = object() |
| self._parser.parse(csource, override=override, **options) |
| self._cdefsources.append(csource) |
| if override: |
| for cache in self._function_caches: |
| cache.clear() |
| finishlist = self._parser._recomplete |
| if finishlist: |
| self._parser._recomplete = [] |
| for tp in finishlist: |
| tp.finish_backend_type(self, finishlist) |
| |
| def dlopen(self, name, flags=0): |
| """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. |
| """ |
| if not (isinstance(name, basestring) or |
| name is None or |
| isinstance(name, self.CData)): |
| raise TypeError("dlopen(name): name must be a file name, None, " |
| "or an already-opened 'void *' handle") |
| with self._lock: |
| lib, function_cache = _make_ffi_library(self, name, flags) |
| self._function_caches.append(function_cache) |
| self._libraries.append(lib) |
| return lib |
| |
| def dlclose(self, lib): |
| """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). |
| """ |
| type(lib).__cffi_close__(lib) |
| |
| def _typeof_locked(self, cdecl): |
| # call me with the lock! |
| key = cdecl |
| if key in self._parsed_types: |
| return self._parsed_types[key] |
| # |
| if not isinstance(cdecl, str): # unicode, on Python 2 |
| cdecl = cdecl.encode('ascii') |
| # |
| type = self._parser.parse_type(cdecl) |
| really_a_function_type = type.is_raw_function |
| if really_a_function_type: |
| type = type.as_function_pointer() |
| btype = self._get_cached_btype(type) |
| result = btype, really_a_function_type |
| self._parsed_types[key] = result |
| return result |
| |
| def _typeof(self, cdecl, consider_function_as_funcptr=False): |
| # string -> ctype object |
| try: |
| result = self._parsed_types[cdecl] |
| except KeyError: |
| with self._lock: |
| result = self._typeof_locked(cdecl) |
| # |
| btype, really_a_function_type = result |
| if really_a_function_type and not consider_function_as_funcptr: |
| raise CDefError("the type %r is a function type, not a " |
| "pointer-to-function type" % (cdecl,)) |
| return btype |
| |
| def typeof(self, cdecl): |
| """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. |
| """ |
| if isinstance(cdecl, basestring): |
| return self._typeof(cdecl) |
| if isinstance(cdecl, self.CData): |
| return self._backend.typeof(cdecl) |
| if isinstance(cdecl, types.BuiltinFunctionType): |
| res = _builtin_function_type(cdecl) |
| if res is not None: |
| return res |
| if (isinstance(cdecl, types.FunctionType) |
| and hasattr(cdecl, '_cffi_base_type')): |
| with self._lock: |
| return self._get_cached_btype(cdecl._cffi_base_type) |
| raise TypeError(type(cdecl)) |
| |
| def sizeof(self, cdecl): |
| """Return the size in bytes of the argument. It can be a |
| string naming a C type, or a 'cdata' instance. |
| """ |
| if isinstance(cdecl, basestring): |
| BType = self._typeof(cdecl) |
| return self._backend.sizeof(BType) |
| else: |
| return self._backend.sizeof(cdecl) |
| |
| def alignof(self, cdecl): |
| """Return the natural alignment size in bytes of the C type |
| given as a string. |
| """ |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return self._backend.alignof(cdecl) |
| |
| def offsetof(self, cdecl, *fields_or_indexes): |
| """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. |
| """ |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return self._typeoffsetof(cdecl, *fields_or_indexes)[1] |
| |
| def new(self, cdecl, init=None): |
| """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. |
| """ |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return self._backend.newp(cdecl, init) |
| |
| def new_allocator(self, alloc=None, free=None, |
| should_clear_after_alloc=True): |
| """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. |
| """ |
| compiled_ffi = self._backend.FFI() |
| allocator = compiled_ffi.new_allocator(alloc, free, |
| should_clear_after_alloc) |
| def allocate(cdecl, init=None): |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return allocator(cdecl, init) |
| return allocate |
| |
| def cast(self, cdecl, source): |
| """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. |
| """ |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return self._backend.cast(cdecl, source) |
| |
| def string(self, cdata, maxlen=-1): |
| """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. |
| """ |
| return self._backend.string(cdata, maxlen) |
| |
| def unpack(self, cdata, length): |
| """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)] |
| """ |
| return self._backend.unpack(cdata, length) |
| |
| #def buffer(self, cdata, size=-1): |
| # """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 |
| # """ |
| # note that 'buffer' is a type, set on this instance by __init__ |
| |
| def from_buffer(self, cdecl, python_buffer=_unspecified, |
| require_writable=False): |
| """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[]'. |
| """ |
| if python_buffer is _unspecified: |
| cdecl, python_buffer = self.BCharA, cdecl |
| elif isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| return self._backend.from_buffer(cdecl, python_buffer, |
| require_writable) |
| |
| def memmove(self, dest, src, n): |
| """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. |
| """ |
| return self._backend.memmove(dest, src, n) |
| |
| def callback(self, cdecl, python_callable=None, error=None, onerror=None): |
| """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. |
| """ |
| def callback_decorator_wrap(python_callable): |
| if not callable(python_callable): |
| raise TypeError("the 'python_callable' argument " |
| "is not callable") |
| return self._backend.callback(cdecl, python_callable, |
| error, onerror) |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl, consider_function_as_funcptr=True) |
| if python_callable is None: |
| return callback_decorator_wrap # decorator mode |
| else: |
| return callback_decorator_wrap(python_callable) # direct mode |
| |
| def getctype(self, cdecl, replace_with=''): |
| """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'. |
| """ |
| if isinstance(cdecl, basestring): |
| cdecl = self._typeof(cdecl) |
| replace_with = replace_with.strip() |
| if (replace_with.startswith('*') |
| and '&[' in self._backend.getcname(cdecl, '&')): |
| replace_with = '(%s)' % replace_with |
| elif replace_with and not replace_with[0] in '[(': |
| replace_with = ' ' + replace_with |
| return self._backend.getcname(cdecl, replace_with) |
| |
| def gc(self, cdata, destructor, size=0): |
| """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. |
| """ |
| return self._backend.gcp(cdata, destructor, size) |
| |
| def _get_cached_btype(self, type): |
| assert self._lock.acquire(False) is False |
| # call me with the lock! |
| try: |
| BType = self._cached_btypes[type] |
| except KeyError: |
| finishlist = [] |
| BType = type.get_cached_btype(self, finishlist) |
| for type in finishlist: |
| type.finish_backend_type(self, finishlist) |
| return BType |
| |
| def verify(self, source='', tmpdir=None, **kwargs): |
| """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. |
| """ |
| from .verifier import Verifier, _caller_dir_pycache |
| # |
| # If set_unicode(True) was called, insert the UNICODE and |
| # _UNICODE macro declarations |
| if self._windows_unicode: |
| self._apply_windows_unicode(kwargs) |
| # |
| # Set the tmpdir here, and not in Verifier.__init__: it picks |
| # up the caller's directory, which we want to be the caller of |
| # ffi.verify(), as opposed to the caller of Veritier(). |
| tmpdir = tmpdir or _caller_dir_pycache() |
| # |
| # Make a Verifier() and use it to load the library. |
| self.verifier = Verifier(self, source, tmpdir, **kwargs) |
| lib = self.verifier.load_library() |
| # |
| # Save the loaded library for keep-alive purposes, even |
| # if the caller doesn't keep it alive itself (it should). |
| self._libraries.append(lib) |
| return lib |
| |
| def _get_errno(self): |
| return self._backend.get_errno() |
| def _set_errno(self, errno): |
| self._backend.set_errno(errno) |
| errno = property(_get_errno, _set_errno, None, |
| "the value of 'errno' from/to the C calls") |
| |
| def getwinerror(self, code=-1): |
| return self._backend.getwinerror(code) |
| |
| def _pointer_to(self, ctype): |
| with self._lock: |
| return model.pointer_cache(self, ctype) |
| |
| def addressof(self, cdata, *fields_or_indexes): |
| """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. |
| """ |
| try: |
| ctype = self._backend.typeof(cdata) |
| except TypeError: |
| if '__addressof__' in type(cdata).__dict__: |
| return type(cdata).__addressof__(cdata, *fields_or_indexes) |
| raise |
| if fields_or_indexes: |
| ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes) |
| else: |
| if ctype.kind == "pointer": |
| raise TypeError("addressof(pointer)") |
| offset = 0 |
| ctypeptr = self._pointer_to(ctype) |
| return self._backend.rawaddressof(ctypeptr, cdata, offset) |
| |
| def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes): |
| ctype, offset = self._backend.typeoffsetof(ctype, field_or_index) |
| for field1 in fields_or_indexes: |
| ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1) |
| offset += offset1 |
| return ctype, offset |
| |
| def include(self, ffi_to_include): |
| """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. |
| """ |
| if not isinstance(ffi_to_include, FFI): |
| raise TypeError("ffi.include() expects an argument that is also of" |
| " type cffi.FFI, not %r" % ( |
| type(ffi_to_include).__name__,)) |
| if ffi_to_include is self: |
| raise ValueError("self.include(self)") |
| with ffi_to_include._lock: |
| with self._lock: |
| self._parser.include(ffi_to_include._parser) |
| self._cdefsources.append('[') |
| self._cdefsources.extend(ffi_to_include._cdefsources) |
| self._cdefsources.append(']') |
| self._included_ffis.append(ffi_to_include) |
| |
| def new_handle(self, x): |
| return self._backend.newp_handle(self.BVoidP, x) |
| |
| def from_handle(self, x): |
| return self._backend.from_handle(x) |
| |
| def release(self, x): |
| self._backend.release(x) |
| |
| def set_unicode(self, enabled_flag): |
| """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. |
| """ |
| if self._windows_unicode is not None: |
| raise ValueError("set_unicode() can only be called once") |
| enabled_flag = bool(enabled_flag) |
| if enabled_flag: |
| self.cdef("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;") |
| else: |
| self.cdef("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;") |
| self._windows_unicode = enabled_flag |
| |
| def _apply_windows_unicode(self, kwds): |
| defmacros = kwds.get('define_macros', ()) |
| if not isinstance(defmacros, (list, tuple)): |
| raise TypeError("'define_macros' must be a list or tuple") |
| defmacros = list(defmacros) + [('UNICODE', '1'), |
| ('_UNICODE', '1')] |
| kwds['define_macros'] = defmacros |
| |
| def _apply_embedding_fix(self, kwds): |
| # must include an argument like "-lpython2.7" for the compiler |
| def ensure(key, value): |
| lst = kwds.setdefault(key, []) |
| if value not in lst: |
| lst.append(value) |
| # |
| if '__pypy__' in sys.builtin_module_names: |
| import os |
| if sys.platform == "win32": |
| # we need 'libpypy-c.lib'. Current distributions of |
| # pypy (>= 4.1) contain it as 'libs/python27.lib'. |
| pythonlib = "python{0[0]}{0[1]}".format(sys.version_info) |
| if hasattr(sys, 'prefix'): |
| ensure('library_dirs', os.path.join(sys.prefix, 'libs')) |
| else: |
| # we need 'libpypy-c.{so,dylib}', which should be by |
| # default located in 'sys.prefix/bin' for installed |
| # systems. |
| if sys.version_info < (3,): |
| pythonlib = "pypy-c" |
| else: |
| pythonlib = "pypy3-c" |
| if hasattr(sys, 'prefix'): |
| ensure('library_dirs', os.path.join(sys.prefix, 'bin')) |
| # On uninstalled pypy's, the libpypy-c is typically found in |
| # .../pypy/goal/. |
| if hasattr(sys, 'prefix'): |
| ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal')) |
| else: |
| if sys.platform == "win32": |
| template = "python%d%d" |
| if hasattr(sys, 'gettotalrefcount'): |
| template += '_d' |
| else: |
| try: |
| import sysconfig |
| except ImportError: # 2.6 |
| from distutils import sysconfig |
| template = "python%d.%d" |
| if sysconfig.get_config_var('DEBUG_EXT'): |
| template += sysconfig.get_config_var('DEBUG_EXT') |
| pythonlib = (template % |
| (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) |
| if hasattr(sys, 'abiflags'): |
| pythonlib += sys.abiflags |
| ensure('libraries', pythonlib) |
| if sys.platform == "win32": |
| ensure('extra_link_args', '/MANIFEST') |
| |
| def set_source(self, module_name, source, source_extension='.c', **kwds): |
| import os |
| if hasattr(self, '_assigned_source'): |
| raise ValueError("set_source() cannot be called several times " |
| "per ffi object") |
| if not isinstance(module_name, basestring): |
| raise TypeError("'module_name' must be a string") |
| if os.sep in module_name or (os.altsep and os.altsep in module_name): |
| raise ValueError("'module_name' must not contain '/': use a dotted " |
| "name to make a 'package.module' location") |
| self._assigned_source = (str(module_name), source, |
| source_extension, kwds) |
| |
| def set_source_pkgconfig(self, module_name, pkgconfig_libs, source, |
| source_extension='.c', **kwds): |
| from . import pkgconfig |
| if not isinstance(pkgconfig_libs, list): |
| raise TypeError("the pkgconfig_libs argument must be a list " |
| "of package names") |
| kwds2 = pkgconfig.flags_from_pkgconfig(pkgconfig_libs) |
| pkgconfig.merge_flags(kwds, kwds2) |
| self.set_source(module_name, source, source_extension, **kwds) |
| |
| def distutils_extension(self, tmpdir='build', verbose=True): |
| from distutils.dir_util import mkpath |
| from .recompiler import recompile |
| # |
| if not hasattr(self, '_assigned_source'): |
| if hasattr(self, 'verifier'): # fallback, 'tmpdir' ignored |
| return self.verifier.get_extension() |
| raise ValueError("set_source() must be called before" |
| " distutils_extension()") |
| module_name, source, source_extension, kwds = self._assigned_source |
| if source is None: |
| raise TypeError("distutils_extension() is only for C extension " |
| "modules, not for dlopen()-style pure Python " |
| "modules") |
| mkpath(tmpdir) |
| ext, updated = recompile(self, module_name, |
| source, tmpdir=tmpdir, extradir=tmpdir, |
| source_extension=source_extension, |
| call_c_compiler=False, **kwds) |
| if verbose: |
| if updated: |
| sys.stderr.write("regenerated: %r\n" % (ext.sources[0],)) |
| else: |
| sys.stderr.write("not modified: %r\n" % (ext.sources[0],)) |
| return ext |
| |
| def emit_c_code(self, filename): |
| from .recompiler import recompile |
| # |
| if not hasattr(self, '_assigned_source'): |
| raise ValueError("set_source() must be called before emit_c_code()") |
| module_name, source, source_extension, kwds = self._assigned_source |
| if source is None: |
| raise TypeError("emit_c_code() is only for C extension modules, " |
| "not for dlopen()-style pure Python modules") |
| recompile(self, module_name, source, |
| c_file=filename, call_c_compiler=False, **kwds) |
| |
| def emit_python_code(self, filename): |
| from .recompiler import recompile |
| # |
| if not hasattr(self, '_assigned_source'): |
| raise ValueError("set_source() must be called before emit_c_code()") |
| module_name, source, source_extension, kwds = self._assigned_source |
| if source is not None: |
| raise TypeError("emit_python_code() is only for dlopen()-style " |
| "pure Python modules, not for C extension modules") |
| recompile(self, module_name, source, |
| c_file=filename, call_c_compiler=False, **kwds) |
| |
| def compile(self, tmpdir='.', verbose=0, target=None, debug=None): |
| """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. |
| """ |
| from .recompiler import recompile |
| # |
| if not hasattr(self, '_assigned_source'): |
| raise ValueError("set_source() must be called before compile()") |
| module_name, source, source_extension, kwds = self._assigned_source |
| return recompile(self, module_name, source, tmpdir=tmpdir, |
| target=target, source_extension=source_extension, |
| compiler_verbose=verbose, debug=debug, **kwds) |
| |
| def init_once(self, func, tag): |
| # Read _init_once_cache[tag], which is either (False, lock) if |
| # we're calling the function now in some thread, or (True, result). |
| # Don't call setdefault() in most cases, to avoid allocating and |
| # immediately freeing a lock; but still use setdefaut() to avoid |
| # races. |
| try: |
| x = self._init_once_cache[tag] |
| except KeyError: |
| x = self._init_once_cache.setdefault(tag, (False, allocate_lock())) |
| # Common case: we got (True, result), so we return the result. |
| if x[0]: |
| return x[1] |
| # Else, it's a lock. Acquire it to serialize the following tests. |
| with x[1]: |
| # Read again from _init_once_cache the current status. |
| x = self._init_once_cache[tag] |
| if x[0]: |
| return x[1] |
| # Call the function and store the result back. |
| result = func() |
| self._init_once_cache[tag] = (True, result) |
| return result |
| |
| def embedding_init_code(self, pysource): |
| if self._embedding: |
| raise ValueError("embedding_init_code() can only be called once") |
| # fix 'pysource' before it gets dumped into the C file: |
| # - remove empty lines at the beginning, so it starts at "line 1" |
| # - dedent, if all non-empty lines are indented |
| # - check for SyntaxErrors |
| import re |
| match = re.match(r'\s*\n', pysource) |
| if match: |
| pysource = pysource[match.end():] |
| lines = pysource.splitlines() or [''] |
| prefix = re.match(r'\s*', lines[0]).group() |
| for i in range(1, len(lines)): |
| line = lines[i] |
| if line.rstrip(): |
| while not line.startswith(prefix): |
| prefix = prefix[:-1] |
| i = len(prefix) |
| lines = [line[i:]+'\n' for line in lines] |
| pysource = ''.join(lines) |
| # |
| compile(pysource, "cffi_init", "exec") |
| # |
| self._embedding = pysource |
| |
| def def_extern(self, *args, **kwds): |
| raise ValueError("ffi.def_extern() is only available on API-mode FFI " |
| "objects") |
| |
| def list_types(self): |
| """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) |
| """ |
| typedefs = [] |
| structs = [] |
| unions = [] |
| for key in self._parser._declarations: |
| if key.startswith('typedef '): |
| typedefs.append(key[8:]) |
| elif key.startswith('struct '): |
| structs.append(key[7:]) |
| elif key.startswith('union '): |
| unions.append(key[6:]) |
| typedefs.sort() |
| structs.sort() |
| unions.sort() |
| return (typedefs, structs, unions) |
| |
| |
| def _load_backend_lib(backend, name, flags): |
| import os |
| if not isinstance(name, basestring): |
| if sys.platform != "win32" or name is not None: |
| return backend.load_library(name, flags) |
| name = "c" # Windows: load_library(None) fails, but this works |
| # on Python 2 (backward compatibility hack only) |
| first_error = None |
| if '.' in name or '/' in name or os.sep in name: |
| try: |
| return backend.load_library(name, flags) |
| except OSError as e: |
| first_error = e |
| import ctypes.util |
| path = ctypes.util.find_library(name) |
| if path is None: |
| if name == "c" and sys.platform == "win32" and sys.version_info >= (3,): |
| raise OSError("dlopen(None) cannot work on Windows for Python 3 " |
| "(see http://bugs.python.org/issue23606)") |
| msg = ("ctypes.util.find_library() did not manage " |
| "to locate a library called %r" % (name,)) |
| if first_error is not None: |
| msg = "%s. Additionally, %s" % (first_error, msg) |
| raise OSError(msg) |
| return backend.load_library(path, flags) |
| |
| def _make_ffi_library(ffi, libname, flags): |
| backend = ffi._backend |
| backendlib = _load_backend_lib(backend, libname, flags) |
| # |
| def accessor_function(name): |
| key = 'function ' + name |
| tp, _ = ffi._parser._declarations[key] |
| BType = ffi._get_cached_btype(tp) |
| value = backendlib.load_function(BType, name) |
| library.__dict__[name] = value |
| # |
| def accessor_variable(name): |
| key = 'variable ' + name |
| tp, _ = ffi._parser._declarations[key] |
| BType = ffi._get_cached_btype(tp) |
| read_variable = backendlib.read_variable |
| write_variable = backendlib.write_variable |
| setattr(FFILibrary, name, property( |
| lambda self: read_variable(BType, name), |
| lambda self, value: write_variable(BType, name, value))) |
| # |
| def addressof_var(name): |
| try: |
| return addr_variables[name] |
| except KeyError: |
| with ffi._lock: |
| if name not in addr_variables: |
| key = 'variable ' + name |
| tp, _ = ffi._parser._declarations[key] |
| BType = ffi._get_cached_btype(tp) |
| if BType.kind != 'array': |
| BType = model.pointer_cache(ffi, BType) |
| p = backendlib.load_function(BType, name) |
| addr_variables[name] = p |
| return addr_variables[name] |
| # |
| def accessor_constant(name): |
| raise NotImplementedError("non-integer constant '%s' cannot be " |
| "accessed from a dlopen() library" % (name,)) |
| # |
| def accessor_int_constant(name): |
| library.__dict__[name] = ffi._parser._int_constants[name] |
| # |
| accessors = {} |
| accessors_version = [False] |
| addr_variables = {} |
| # |
| def update_accessors(): |
| if accessors_version[0] is ffi._cdef_version: |
| return |
| # |
| for key, (tp, _) in ffi._parser._declarations.items(): |
| if not isinstance(tp, model.EnumType): |
| tag, name = key.split(' ', 1) |
| if tag == 'function': |
| accessors[name] = accessor_function |
| elif tag == 'variable': |
| accessors[name] = accessor_variable |
| elif tag == 'constant': |
| accessors[name] = accessor_constant |
| else: |
| for i, enumname in enumerate(tp.enumerators): |
| def accessor_enum(name, tp=tp, i=i): |
| tp.check_not_partial() |
| library.__dict__[name] = tp.enumvalues[i] |
| accessors[enumname] = accessor_enum |
| for name in ffi._parser._int_constants: |
| accessors.setdefault(name, accessor_int_constant) |
| accessors_version[0] = ffi._cdef_version |
| # |
| def make_accessor(name): |
| with ffi._lock: |
| if name in library.__dict__ or name in FFILibrary.__dict__: |
| return # added by another thread while waiting for the lock |
| if name not in accessors: |
| update_accessors() |
| if name not in accessors: |
| raise AttributeError(name) |
| accessors[name](name) |
| # |
| class FFILibrary(object): |
| def __getattr__(self, name): |
| make_accessor(name) |
| return getattr(self, name) |
| def __setattr__(self, name, value): |
| try: |
| property = getattr(self.__class__, name) |
| except AttributeError: |
| make_accessor(name) |
| setattr(self, name, value) |
| else: |
| property.__set__(self, value) |
| def __dir__(self): |
| with ffi._lock: |
| update_accessors() |
| return accessors.keys() |
| def __addressof__(self, name): |
| if name in library.__dict__: |
| return library.__dict__[name] |
| if name in FFILibrary.__dict__: |
| return addressof_var(name) |
| make_accessor(name) |
| if name in library.__dict__: |
| return library.__dict__[name] |
| if name in FFILibrary.__dict__: |
| return addressof_var(name) |
| raise AttributeError("cffi library has no function or " |
| "global variable named '%s'" % (name,)) |
| def __cffi_close__(self): |
| backendlib.close_lib() |
| self.__dict__.clear() |
| # |
| if isinstance(libname, basestring): |
| try: |
| if not isinstance(libname, str): # unicode, on Python 2 |
| libname = libname.encode('utf-8') |
| FFILibrary.__name__ = 'FFILibrary_%s' % libname |
| except UnicodeError: |
| pass |
| library = FFILibrary() |
| return library, library.__dict__ |
| |
| def _builtin_function_type(func): |
| # a hack to make at least ffi.typeof(builtin_function) work, |
| # if the builtin function was obtained by 'vengine_cpy'. |
| import sys |
| try: |
| module = sys.modules[func.__module__] |
| ffi = module._cffi_original_ffi |
| types_of_builtin_funcs = module._cffi_types_of_builtin_funcs |
| tp = types_of_builtin_funcs[func] |
| except (KeyError, AttributeError, TypeError): |
| return None |
| else: |
| with ffi._lock: |
| return ffi._get_cached_btype(tp) |