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 _load_backend_lib(backend, name, flags): import os if name is None: if sys.platform != "win32": return backend.load_library(None, 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 main(): import os try: import _cffi_backend except ImportError: sys.stderr.write('SKIP: cannot import _cffi_backend\n') return 0 libc = _cffi_backend.load_library(None) BInt = _cffi_backend.new_primitive_type("int") BSizeT = _cffi_backend.new_primitive_type("size_t") BChar = _cffi_backend.new_primitive_type("char") BCharP = _cffi_backend.new_pointer_type(BChar) BWrite = _cffi_backend.new_function_type([BInt, BCharP, BSizeT], BSizeT) # not signed here! _write = libc.load_function(BWrite, 'write') i = 0 fd0, fd1 = os.pipe() buffer = _cffi_backend.newp(BCharP, 'A') while i < 300: tmp = _write(fd1, buffer, 1) # ID: cfficall assert tmp == 1 assert os.read(fd0, 2) == 'A' i += 1 os.close(fd0) os.close(fd1) return 42
def main(): import os try: import _cffi_backend except ImportError: sys.stderr.write('SKIP: cannot import _cffi_backend\n') return 0 libc = _cffi_backend.load_library(None) BInt = _cffi_backend.new_primitive_type("int") BSizeT = _cffi_backend.new_primitive_type("size_t") BChar = _cffi_backend.new_primitive_type("char") BCharP = _cffi_backend.new_pointer_type(BChar) BWrite = _cffi_backend.new_function_type( [BInt, BCharP, BSizeT], BSizeT) # not signed here! _write = libc.load_function(BWrite, 'write') i = 0 fd0, fd1 = os.pipe() buffer = _cffi_backend.newp(BCharP, 'A') while i < 300: tmp = _write(fd1, buffer, 1) # ID: cfficall assert tmp == 1 assert os.read(fd0, 2) == 'A' i += 1 os.close(fd0) os.close(fd1) return 42
def _load_backend_lib(backend, name, flags): if name is None: if sys.platform != "win32": return backend.load_library(None, flags) name = "c" # Windows: load_library(None) fails, but this works # (backward compatibility hack only) try: if '.' not in name and '/' not in name: raise OSError("library not found: %r" % (name,)) return backend.load_library(name, flags) except OSError: import ctypes.util path = ctypes.util.find_library(name) if path is None: raise # propagate the original OSError return backend.load_library(path, flags)
def find_and_load_library_for_test(name, is_global=False): if name is None: path = None else: import ctypes.util path = ctypes.util.find_library(name) import _cffi_backend return _cffi_backend.load_library(path, is_global)
def _load_backend_lib(backend, name, flags): import os if name is None: if sys.platform != "win32": return backend.load_library(None, flags) name = "c" # Windows: load_library(None) fails, but this works # (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: 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 _load_backend_lib(backend, name, flags): import os if name is None: if sys.platform != "win32": return backend.load_library(None, flags) name = "c" # Windows: load_library(None) fails, but this works # (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: 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 main(libm_name): try: import _cffi_backend except ImportError: sys.stderr.write('SKIP: cannot import _cffi_backend\n') return 0 libm = _cffi_backend.load_library(libm_name) BDouble = _cffi_backend.new_primitive_type("double") BSin = _cffi_backend.new_function_type([BDouble], BDouble) sin = libm.load_function(BSin, 'sin') def f(*args): for i in range(300): sin(*args) f(1.0) f(1)
def main(libm_name): try: import _cffi_backend except ImportError: sys.stderr.write('SKIP: cannot import _cffi_backend\n') return 0 libm = _cffi_backend.load_library(libm_name) BDouble = _cffi_backend.new_primitive_type("double") BInt = _cffi_backend.new_primitive_type("int") BPow = _cffi_backend.new_function_type([BDouble, BInt], BDouble) ldexp = libm.load_function(BPow, 'ldexp') i = 0 res = 0 while i < 300: tmp = ldexp(1, 3) # ID: cfficall res += tmp i += 1 BLong = _cffi_backend.new_primitive_type("long") ldexp_addr = int(_cffi_backend.cast(BLong, ldexp)) return ldexp_addr, res
def main(): import os try: import _cffi_backend except ImportError: sys.stderr.write('SKIP: cannot import _cffi_backend\n') return 0 libc = _cffi_backend.load_library(None) BInt = _cffi_backend.new_primitive_type("int") BClose = _cffi_backend.new_function_type([BInt], BInt) _dup = libc.load_function(BClose, 'dup') i = 0 fd0, fd1 = os.pipe() while i < 300: tmp = _dup(fd0) # ID: cfficall os.close(tmp) i += 1 os.close(fd0) os.close(fd1) BLong = _cffi_backend.new_primitive_type("long") return 42
def _make_ffi_library(ffi, libname, flags): import os name = libname if name is None: name = 'c' # on Posix only backend = ffi._backend try: if '.' not in name and '/' not in name: raise OSError backendlib = backend.load_library(name, flags) except OSError: import ctypes.util path = ctypes.util.find_library(name) if path is None: raise OSError("library not found: %r" % (name,)) backendlib = backend.load_library(path, flags) copied_enums = [] # def make_accessor(name): key = 'function ' + name if key in ffi._parser._declarations: tp = ffi._parser._declarations[key] BType = ffi._get_cached_btype(tp) try: value = backendlib.load_function(BType, name) except KeyError: raise AttributeError(name) library.__dict__[name] = value return # key = 'variable ' + name if key in ffi._parser._declarations: 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))) return # if not copied_enums: from . import model for key, tp in ffi._parser._declarations.items(): if not isinstance(tp, model.EnumType): continue for enumname, enumval in zip(tp.enumerators, tp.enumvalues): if enumname not in library.__dict__: library.__dict__[enumname] = enumval copied_enums.append(True) # if name in library.__dict__: # copied from an enum value just above, return # or multithread's race condition raise AttributeError(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) # if libname is not None: 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 _make_ffi_library(ffi, libname, flags): import os name = libname if name is None: name = 'c' # on Posix only backend = ffi._backend try: if '.' not in name and '/' not in name: raise OSError("library not found: %r" % (name, )) backendlib = backend.load_library(name, flags) except OSError: import ctypes.util path = ctypes.util.find_library(name) if path is None: raise # propagate the original OSError backendlib = backend.load_library(path, flags) copied_enums = [] # def make_accessor_locked(name): key = 'function ' + name if key in ffi._parser._declarations: tp = ffi._parser._declarations[key] BType = ffi._get_cached_btype(tp) try: value = backendlib.load_function(BType, name) except KeyError as e: raise AttributeError('%s: %s' % (name, e)) library.__dict__[name] = value return # key = 'variable ' + name if key in ffi._parser._declarations: 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))) return # if not copied_enums: from . import model for key, tp in ffi._parser._declarations.items(): if not isinstance(tp, model.EnumType): continue for enumname, enumval in zip(tp.enumerators, tp.enumvalues): if enumname not in library.__dict__: library.__dict__[enumname] = enumval copied_enums.append(True) if name in library.__dict__: return # raise AttributeError(name) # 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 make_accessor_locked(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) # if libname is not None: 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__