struct ndpi_flow_struct *flow, const unsigned char *packet, const unsigned short packetlen, const u_int64_t packet_time_ms); ndpi_protocol ndpi_detection_giveup(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow, u_int8_t enable_guess, u_int8_t *protocol_was_guessed); void ndpi_py_setup_detection_module(struct ndpi_detection_module_struct *mod); struct ndpi_flow_struct * ndpi_py_initialize_flow(void); char* ndpi_protocol2name(struct ndpi_detection_module_struct *ndpi_mod, ndpi_protocol proto, char *buf, u_int buf_len); const char* ndpi_category_get_name(struct ndpi_detection_module_struct *ndpi_mod, ndpi_protocol_category_t category); const char* ndpi_confidence_get_name(ndpi_confidence_t confidence); """ ffi_builder = FFI() INCLUDE_DIR = pathlib.Path(__file__)\ .parent.resolve().parent.resolve().parent.resolve().\ joinpath("src").joinpath("include") LIBRARY_DIR = pathlib.Path(__file__)\ .parent.resolve().parent.resolve().parent.resolve().\ joinpath("src").joinpath("lib") NDPI_CDEF = subprocess.run(["gcc", "-DNDPI_LIB_COMPILATION", "-DNDPI_CFFI_PREPROCESSING", "-DNDPI_CFFI_PREPROCESSING_EXCLUDE_PACKED",
def test_struct_with_typedef(self): ffi = FFI() ffi.cdef("typedef struct { float x; } foo_t;") p = ffi.new("foo_t *", [5.2]) assert repr(p).startswith("<cdata 'foo_t *' ")
from os.path import dirname, join, realpath from cffi import FFI ffibuilder = FFI() ffibuilder.set_unicode(False) ffibuilder.cdef(r""" int read_bed_chunk(char*, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t*, uint64_t*); """) dirname(realpath(__file__)) ffibuilder.set_source( "pandas_plink.bed_reader", r""" int read_bed_chunk(char*, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t*, uint64_t*); """, sources=[join("pandas_plink", "_bed_reader.c")], ) if __name__ == "__main__": ffibuilder.compile(verbose=True)
"""FFI build script.""" from cffi import FFI FFI_BUILDER = FFI() HEADER = 'uint32_t murmurhash3_32_x86(const unsigned char* key, int len, int32_t seed);' FFI_BUILDER.cdef(HEADER) FFI_BUILDER.set_source( 'mmh3cffi._cimpl', '', sources=['csrc/mmh3.c'], include_dirs=['./csrc'] ) if __name__ == '__main__': FFI_BUILDER.compile()
################################################################################ # THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY # # Read the zproject/README.md for information about making permanent changes. # ################################################################################ from __future__ import print_function import os import re import sys from cffi import FFI ffi = FFI() try: # If LD_LIBRARY_PATH or your OSs equivalent is set, this is the only way to # load the library. If we use find_library below, we get the wrong result. if os.name == 'posix': if sys.platform == 'darwin': libpath = 'libzyre.2.dylib' else: libpath = 'libzyre.so.2' elif os.name == 'nt': libpath = 'libzyre.dll' lib = ffi.dlopen(libpath) except OSError: libpath = find_library("zyre") if not libpath: raise ImportError("Unable to find libzyre") lib = ffi.dlopen(libpath)
def setup_module(mod): SRC = """ #include <string.h> #define FOOBAR (-42) static const int FOOBAZ = -43; #define BIGPOS 420000000000L #define BIGNEG -420000000000L int add42(int x) { return x + 42; } int add43(int x, ...) { return x; } int globalvar42 = 1234; const int globalconst42 = 4321; const char *const globalconsthello = "hello"; struct foo_s; typedef struct bar_s { int x; signed char a[]; } bar_t; enum foo_e { AA, BB, CC }; void init_test_re_python(void) { } /* windows hack */ void PyInit__test_re_python(void) { } /* windows hack */ """ tmpdir = udir.join('test_re_python') tmpdir.ensure(dir=1) c_file = tmpdir.join('_test_re_python.c') c_file.write(SRC) ext = ffiplatform.get_extension(str(c_file), '_test_re_python', export_symbols=[ 'add42', 'add43', 'globalvar42', 'globalconst42', 'globalconsthello' ]) outputfilename = ffiplatform.compile(str(tmpdir), ext) # test with a non-ascii char ofn, oext = os.path.splitext(outputfilename) if sys.platform == "win32": unicode_name = ofn + (u + '\u03be') + oext else: unicode_name = ofn + (u + '\xe9') + oext try: unicode_name.encode(sys.getfilesystemencoding()) except UnicodeEncodeError: unicode_name = None if unicode_name is not None: print(repr(outputfilename) + ' ==> ' + repr(unicode_name)) os.rename(outputfilename, unicode_name) outputfilename = unicode_name mod.extmod = outputfilename mod.tmpdir = tmpdir # ffi = FFI() ffi.cdef(""" #define FOOBAR -42 static const int FOOBAZ = -43; #define BIGPOS 420000000000L #define BIGNEG -420000000000L int add42(int); int add43(int, ...); extern int globalvar42; const int globalconst42; const char *const globalconsthello; int no_such_function(int); extern int no_such_globalvar; struct foo_s; typedef struct bar_s { int x; signed char a[]; } bar_t; enum foo_e { AA, BB, CC }; int strlen(const char *); struct with_union { union { int a; char b; }; }; union with_struct { struct { int a; char b; }; }; struct NVGcolor { union { float rgba[4]; struct { float r,g,b,a; }; }; }; typedef struct selfref { struct selfref *next; } *selfref_ptr_t; """) ffi.set_source('re_python_pysrc', None) ffi.emit_python_code(str(tmpdir.join('re_python_pysrc.py'))) mod.original_ffi = ffi # sys.path.insert(0, str(tmpdir))
def check(self, source, expected_ofs_y, expected_align, expected_size): # NOTE: 'expected_*' is the numbers expected from GCC. # The numbers expected from MSVC are not explicitly written # in this file, and will just be taken from the compiler. ffi = FFI() ffi.cdef("struct s1 { %s };" % source) ctype = ffi.typeof("struct s1") # verify the information with gcc ffi1 = FFI() ffi1.cdef(""" static const int Gofs_y, Galign, Gsize; struct s1 *try_with_value(int fieldnum, long long value); """) fnames = [ name for name, cfield in ctype.fields if name and cfield.bitsize > 0 ] setters = [ 'case %d: s.%s = value; break;' % iname for iname in enumerate(fnames) ] lib = ffi1.verify(""" struct s1 { %s }; struct sa { char a; struct s1 b; }; #define Gofs_y offsetof(struct s1, y) #define Galign offsetof(struct sa, b) #define Gsize sizeof(struct s1) struct s1 *try_with_value(int fieldnum, long long value) { static struct s1 s; memset(&s, 0, sizeof(s)); switch (fieldnum) { %s } return &s; } """ % (source, ' '.join(setters))) if sys.platform == 'win32': expected_ofs_y = lib.Gofs_y expected_align = lib.Galign expected_size = lib.Gsize else: assert (lib.Gofs_y, lib.Galign, lib.Gsize) == (expected_ofs_y, expected_align, expected_size) # the real test follows assert ffi.offsetof("struct s1", "y") == expected_ofs_y assert ffi.alignof("struct s1") == expected_align assert ffi.sizeof("struct s1") == expected_size # compare the actual storage of the two for name, cfield in ctype.fields: if cfield.bitsize < 0 or not name: continue if int(ffi.cast(cfield.type, -1)) == -1: # signed min_value = -(1 << (cfield.bitsize - 1)) max_value = (1 << (cfield.bitsize - 1)) - 1 else: min_value = 0 max_value = (1 << cfield.bitsize) - 1 for t in [ 1, 2, 4, 8, 16, 128, 2813, 89728, 981729, -1, -2, -4, -8, -16, -128, -2813, -89728, -981729 ]: if min_value <= t <= max_value: self._fieldcheck(ffi, lib, fnames, name, t)
LOGISTIC = 0 RELU = 1 RELIE = 2 LINEAR = 3 RAMP = 4 TANH = 5 PLSE = 6 LEAKY = 7 ELU = 8 LOGGY = 9 STAIR = 10 HARDTAN = 11 LHTAN = 12 __darknetffi__ = FFI() __darknetffi__.cdef(""" typedef struct network network; typedef struct layer layer; typedef struct{ int *leaf; int n; int *parent; int *child; int *group; char **name; int groups; int *group_size;
def init_lib(): if LibEVT.lib is None: LibEVT.ffi = FFI() LibEVT.ffi.cdef(""" typedef struct { size_t sz; char buf[0]; } evt_data_t; #define EVT_OK 0 #define EVT_INTERNAL_ERROR -1 #define EVT_INVALID_ARGUMENT -2 #define EVT_INVALID_PRIVATE_KEY -3 #define EVT_INVALID_PUBLIC_KEY -4 #define EVT_INVALID_SIGNATURE -5 #define EVT_INVALID_HASH -6 #define EVT_INVALID_ACTION -7 #define EVT_INVALID_BINARY -8 #define EVT_SIZE_NOT_EQUALS -11 #define EVT_DATA_NOT_EQUALS -12 int evt_free(void*); int evt_equals(evt_data_t* rhs, evt_data_t* lhs); typedef evt_data_t evt_bin_t; typedef evt_data_t evt_chain_id_t; typedef evt_data_t evt_block_id_t; typedef evt_data_t evt_public_key_t; typedef evt_data_t evt_private_key_t; typedef evt_data_t evt_signature_t; typedef evt_data_t evt_checksum_t; void* evt_abi(); void evt_free_abi(void* abi); int evt_abi_json_to_bin(void* evt_abi, const char* action, const char* json, evt_bin_t** bin /* out */); int evt_abi_bin_to_json(void* evt_abi, const char* action, evt_bin_t* bin, char** json /* out */); int evt_trx_json_to_digest(void* evt_abi, const char* json, evt_chain_id_t* chain_id, evt_checksum_t** digest /* out */); int evt_chain_id_from_string(const char* str, evt_chain_id_t** chain_id /* out */); int evt_generate_new_pair(evt_public_key_t** pub_key /* out */, evt_private_key_t** priv_key /* out */); int evt_get_public_key(evt_private_key_t* priv_key, evt_public_key_t** pub_key /* out */); int evt_sign_hash(evt_private_key_t* priv_key, evt_checksum_t* hash, evt_signature_t** sign /* out */); int evt_recover(evt_signature_t* sign, evt_checksum_t* hash, evt_public_key_t** pub_key /* out */); int evt_hash(const char* buf, size_t sz, evt_checksum_t** hash /* out */); int evt_public_key_string(evt_public_key_t* pub_key, char** str /* out */); int evt_private_key_string(evt_private_key_t* priv_key, char** str /* out */); int evt_signature_string(evt_signature_t* sign, char** str /* out */); int evt_checksum_string(evt_checksum_t* hash, char** str /* out */); int evt_public_key_from_string(const char* str, evt_public_key_t** pub_key /* out */); int evt_private_key_from_string(const char* str, evt_private_key_t** priv_key /* out */); int evt_signature_from_string(const char* str, evt_signature_t** sign /* out */); int evt_checksum_from_string(const char* str, evt_checksum_t** hash /* out */); int evt_block_id_from_string(const char* str, evt_block_id_t** block_id /* out */); int evt_ref_block_num(evt_block_id_t* block_id, uint16_t* ref_block_num); int evt_ref_block_prefix(evt_block_id_t* block_id, uint32_t* ref_block_prefix); """) if "LIBEVT_PATH" in os.environ: LibEVT.lib = LibEVT.ffi.dlopen(os.environ["LIBEVT_PATH"] + '/libevt.so') else: LibEVT.lib = LibEVT.ffi.dlopen('libevt.so') LibEVT.abi = LibEVT.lib.evt_abi()
def generate_wrapper(): """Force the (re-)generation of the wrapper module for the current LLVM installation""" global ffi global cached_module output_path = cached_module ffi = FFI() libs, ffi_code, enums = parse_headers() if len(libs) == 0: raise ValueError("No valid LLVM libraries found' \ ', LLVM must be built with BUILD_SHARED_LIBS") classes = defaultdict(list) global_functions = [] constants = [] # Loop over all the LLVM libraries for _, library_name, library in libs: # Loop over all the methods we identified with cffi, not all of them # will actually be available for name in dir(library): # A library contains only some methods, find out which ones fail = False try: field = getattr(library, name) except AttributeError: fail = True if not fail and type(field) is int: constants.append((name, field)) # Is this a usable function? if not fail and isinstance(field, FFI.CData): # Is the first argument an LLVM object? Did we ever see it # before? prototype = ffi.typeof(field) args = prototype.args if len(args) > 0 and args[0].kind == "pointer": arg0_type = args[0].item if (arg0_type.kind == "struct" and is_llvm_type(arg0_type.cname)): if not [ 1 for x in classes[arg0_type.cname] if x[1] == name ]: # Associate to the name of the LLVM object a tuple # containing the library name, the method name and # the function prototype classes[arg0_type.cname].append( (library_name, name, prototype)) continue # It doesn't fit any class if not [1 for x in global_functions if x[1] == name]: global_functions.append((library_name, name, prototype)) with open(output_path, "w") as output_file: def write(string): output_file.write(string + "\n") # Print file header write(ffi_code) write("from cffi import FFI") write(""" class LLVMException(Exception): pass """) for library_path, library_name, library in libs: write("""{} = ffi.dlopen("{}")""".format(library_name, library_path)) # Create all the classes for key, value in classes.items(): class_name = remove_llvm_prefix(key) # Each class is a wrapper for a pointer to a pointer to an LLVM # object: when a pointer is passed to a function use `in_ptr` (which # dereferences it), when you want to use it as an out argument using # `out_ptr` instead (which returns a **) write(""" class {class_name}(object): def __new__(cls, value=None): if value == ffi.NULL: return None return super({class_name}, cls).__new__(cls) def __init__(self, value=None): self.ptr = ffi.new("{key} **") if value is not None: self.ptr[0] = value def __hash__(self): return hash(self.ptr[0]) def __eq__(self, other): return self.__hash__() == other.__hash__() def in_ptr(self): if self.ptr[0] == ffi.NULL: raise RuntimeError("in_ptr called on uninitialized object") return self.ptr[0] def out_ptr(self): if self.ptr[0] != ffi.NULL: raise RuntimeError(("Passing an already initialized object as an " + "out parameter")) return self.ptr""".format(class_name=class_name, key=key)) # Create a dictionary for properties create function will populate # it properties = defaultdict(lambda: (("", "None"), ("", "None"))) for library, name, prototype in value: write( create_function(library, name, prototype, class_name, properties, classes)) # Create the properties write("") for name, ((getter_llvm, getter), (setter_llvm, setter)) in properties.items(): if keyword.iskeyword(name): name += "_" docstring = "\"\"\"See " docstring += getter_llvm if getter_llvm and setter_llvm: docstring += " and " docstring += setter_llvm docstring += "\"\"\"" write(""" {} = property({}, {}, doc={})""".format( name, getter, setter, docstring)) # Print global functions write("\nif True:") for library, name, prototype in global_functions: write(create_function(library, name, prototype)) # Print numeric constants for name, value in constants: if name.startswith("LLVM") and not name.startswith("LLVM_"): name = name[4:] write("{} = {}".format(name, str(value))) # Print enum conversion methods for name, values in enums.items(): write(""" {} = {} """.format(name, values))
import os import platform import subprocess from cffi import FFI mpc_dir = os.path.join(os.path.dirname(os.path.abspath(__file__))) if platform.machine() == "x86_64": try: FFI().dlopen(os.path.join(mpc_dir, "libmpc1.so")) except OSError: # libmpc1.so is likely built for aarch64. cleaning... subprocess.check_call(["make", "clean"], cwd=mpc_dir) subprocess.check_call(["make", "-j4"], cwd=mpc_dir) def _get_libmpc(mpc_id): libmpc_fn = os.path.join(mpc_dir, "libmpc%d.so" % mpc_id) ffi = FFI() ffi.cdef(""" typedef struct { double x_ego, v_ego, a_ego, x_l, v_l, a_l; } state_t; typedef struct { double x_ego[21]; double v_ego[21];
def build_callback_fn(function_string, userdata_names=[]): ''' Builds a C callback function and returns a function pointer int. function_string : str This is a string of the C function to be compiled userdata_names : list or tuple This is an optional list to defince convenience names We compile and link and load the function, and return a function pointer. See `MjSim.set_substep_callback()` for an example use of these callbacks. The callback function should match the signature: void fun(const mjModel *m, mjData *d); Here's an example function_string: ``` """ #include <stdio.h> void fun(const mjModel* m, mjData* d) { printf("hello"); } """ ``` Input and output for the function pass through userdata in the data struct: ``` """ void fun(const mjModel* m, mjData* d) { d->userdata[0] += 1; } """ ``` `userdata_names` is expected to match the model where the callback is used. These can bet set on a model with: `model.set_userdata_names([...])` If `userdata_names` is supplied, convenience `#define`s are added for each. For example: `userdata_names = ['my_sum']` Will get gerenerated into the extra line: `#define my_sum d->userdata[0]` And prepended to the top of the function before compilation. Here's an example that takes advantage of this: ``` """ void fun(const mjModel* m, mjData* d) { for (int i = 0; i < m->nu; i++) { my_sum += d->ctrl[i]; } } """ ``` Note these are just C `#define`s and are limited in how they can be used. After compilation, the built library containing the function is loaded into memory and all of the files (including the library) are deleted. To retain these for debugging set the `MUJOCO_PY_DEBUG_FN_BUILDER` envvar. To save time compiling, these function pointers may be re-used by many different consumers. They are thread-safe and don't acquire the GIL. See the file `tests/test_substep.py` for additional examples, including an example which iterates over contacts to compute penetrations. ''' assert isinstance(userdata_names, (list, tuple)), \ 'invalid userdata_names: {}'.format(userdata_names) ffibuilder = FFI() ffibuilder.cdef('extern uintptr_t __fun;') name = '_fn_' + ''.join(choice(ascii_lowercase) for _ in range(15)) source_string = '#include <mujoco.h>\n' # Add defines for each userdata to make setting them easier for i, data_name in enumerate(userdata_names): source_string += '#define {} d->userdata[{}]\n'.format(data_name, i) source_string += function_string source_string += '\nuintptr_t __fun = (uintptr_t) fun;' # Link against mujoco so we can call mujoco functions from within callback ffibuilder.set_source(name, source_string, include_dirs=[join(mujoco_path, 'include')], library_dirs=[join(mujoco_path, 'bin')], libraries=['mujoco200']) # Catch compilation exceptions so we can cleanup partial files in that case try: library_path = ffibuilder.compile(verbose=True) except Exception as e: build_fn_cleanup(name) raise e # On Mac the MuJoCo library is linked strangely, so we have to fix it here if sys.platform == 'darwin': fixed_library_path = manually_link_libraries(mujoco_path, library_path) move(fixed_library_path, library_path) # Overwrite with fixed library module = load_dynamic_ext(name, library_path) # Now that the module is loaded into memory, we can actually delete it build_fn_cleanup(name) return module.lib.__fun
def test_typeof(): ffi = FFI(backend=FakeBackend()) clong = ffi.typeof("signed long int") assert isinstance(clong, FakeType) assert clong.cdecl == 'primitive long'
def test_inspecttype(self): ffi = FFI(backend=self.Backend()) assert ffi.typeof("long").kind == "primitive" assert ffi.typeof("long(*)(long, long**, ...)").cname == ( "long(*)(long, long * *, ...)") assert ffi.typeof("long(*)(long, long**, ...)").ellipsis is True
def xtest_cffi_assembly(): mesh = UnitSquareMesh(MPI.comm_world, 13, 13) V = FunctionSpace(mesh, ("Lagrange", 1)) if MPI.rank(mesh.mpi_comm()) == 0: from cffi import FFI ffibuilder = FFI() ffibuilder.set_source( "_cffi_kernelA", r""" #include <math.h> #include <stdalign.h> void tabulate_tensor_poissonA(double* restrict A, const double* w, const double* restrict coordinate_dofs, int cell_orientation) { // Precomputed values of basis functions and precomputations // FE* dimensions: [entities][points][dofs] // PI* dimensions: [entities][dofs][dofs] or [entities][dofs] // PM* dimensions: [entities][dofs][dofs] alignas(32) static const double FE3_C0_D01_Q1[1][1][2] = { { { -1.0, 1.0 } } }; // Unstructured piecewise computations const double J_c0 = coordinate_dofs[0] * FE3_C0_D01_Q1[0][0][0] + coordinate_dofs[2] * FE3_C0_D01_Q1[0][0][1]; const double J_c3 = coordinate_dofs[1] * FE3_C0_D01_Q1[0][0][0] + coordinate_dofs[5] * FE3_C0_D01_Q1[0][0][1]; const double J_c1 = coordinate_dofs[0] * FE3_C0_D01_Q1[0][0][0] + coordinate_dofs[4] * FE3_C0_D01_Q1[0][0][1]; const double J_c2 = coordinate_dofs[1] * FE3_C0_D01_Q1[0][0][0] + coordinate_dofs[3] * FE3_C0_D01_Q1[0][0][1]; alignas(32) double sp[20]; sp[0] = J_c0 * J_c3; sp[1] = J_c1 * J_c2; sp[2] = sp[0] + -1 * sp[1]; sp[3] = J_c0 / sp[2]; sp[4] = -1 * J_c1 / sp[2]; sp[5] = sp[3] * sp[3]; sp[6] = sp[3] * sp[4]; sp[7] = sp[4] * sp[4]; sp[8] = J_c3 / sp[2]; sp[9] = -1 * J_c2 / sp[2]; sp[10] = sp[9] * sp[9]; sp[11] = sp[8] * sp[9]; sp[12] = sp[8] * sp[8]; sp[13] = sp[5] + sp[10]; sp[14] = sp[6] + sp[11]; sp[15] = sp[12] + sp[7]; sp[16] = fabs(sp[2]); sp[17] = sp[13] * sp[16]; sp[18] = sp[14] * sp[16]; sp[19] = sp[15] * sp[16]; // UFLACS block mode: preintegrated A[0] = 0.5 * sp[19] + 0.5 * sp[18] + 0.5 * sp[18] + 0.5 * sp[17]; A[1] = -0.5 * sp[19] + -0.5 * sp[18]; A[2] = -0.5 * sp[18] + -0.5 * sp[17]; A[3] = -0.5 * sp[19] + -0.5 * sp[18]; A[4] = 0.5 * sp[19]; A[5] = 0.5 * sp[18]; A[6] = -0.5 * sp[18] + -0.5 * sp[17]; A[7] = 0.5 * sp[18]; A[8] = 0.5 * sp[17]; } void tabulate_tensor_poissonL(double* restrict A, const double* w, const double* restrict coordinate_dofs, int cell_orientation) { // Precomputed values of basis functions and precomputations // FE* dimensions: [entities][points][dofs] // PI* dimensions: [entities][dofs][dofs] or [entities][dofs] // PM* dimensions: [entities][dofs][dofs] alignas(32) static const double FE4_C0_D01_Q1[1][1][2] = { { { -1.0, 1.0 } } }; // Unstructured piecewise computations const double J_c0 = coordinate_dofs[0] * FE4_C0_D01_Q1[0][0][0] + coordinate_dofs[2] * FE4_C0_D01_Q1[0][0][1]; const double J_c3 = coordinate_dofs[1] * FE4_C0_D01_Q1[0][0][0] + coordinate_dofs[5] * FE4_C0_D01_Q1[0][0][1]; const double J_c1 = coordinate_dofs[0] * FE4_C0_D01_Q1[0][0][0] + coordinate_dofs[4] * FE4_C0_D01_Q1[0][0][1]; const double J_c2 = coordinate_dofs[1] * FE4_C0_D01_Q1[0][0][0] + coordinate_dofs[3] * FE4_C0_D01_Q1[0][0][1]; alignas(32) double sp[4]; sp[0] = J_c0 * J_c3; sp[1] = J_c1 * J_c2; sp[2] = sp[0] + -1 * sp[1]; sp[3] = fabs(sp[2]); // UFLACS block mode: preintegrated A[0] = 0.1666666666666667 * sp[3]; A[1] = 0.1666666666666667 * sp[3]; A[2] = 0.1666666666666667 * sp[3]; } """) ffibuilder.cdef(""" void tabulate_tensor_poissonA(double* restrict A, const double* w, const double* restrict coordinate_dofs, int cell_orientation); void tabulate_tensor_poissonL(double* restrict A, const double* w, const double* restrict coordinate_dofs, int cell_orientation); """) ffibuilder.compile(verbose=True) MPI.barrier(mesh.mpi_comm()) from _cffi_kernelA import ffi, lib a = cpp.fem.Form([V._cpp_object, V._cpp_object]) ptrA = ffi.cast("intptr_t", ffi.addressof(lib, "tabulate_tensor_poissonA")) a.set_cell_tabulate(0, ptrA) L = cpp.fem.Form([V._cpp_object]) ptrL = ffi.cast("intptr_t", ffi.addressof(lib, "tabulate_tensor_poissonL")) L.set_cell_tabulate(0, ptrL) assembler = cpp.fem.Assembler([[a]], [L], []) A = assembler.assemble_matrix(cpp.fem.Assembler.BlockType.monolithic) b = assembler.assemble_vector(cpp.fem.Assembler.BlockType.monolithic) Anorm = A.norm(cpp.la.Norm.frobenius) bnorm = b.norm(cpp.la.Norm.l2) assert (np.isclose(Anorm, 56.124860801609124)) assert (np.isclose(bnorm, 0.0739710713711999)) list_timings([TimingType.wall])
from pathlib import Path from cffi import FFI flex_motion_ffi = FFI() LIB_PATH = Path(__file__).parent.absolute() / 'lib' INC_PATH = LIB_PATH with open(str(INC_PATH / 'flexmotn_flat.h')) as f: flex_motion_ffi.cdef(f.read()) flex_motion_ffi.set_source('_flex_motion_cffi', f'#include "flexmotn_flat.h"', libraries=[str(INC_PATH / 'FlexMS32')], include_dirs=[str(INC_PATH)]) if __name__ == '__main__': flex_motion_ffi.compile(verbose=True)
def test_partial_enum(): ffi = FFI() ffi.cdef("enum foo { A, B, ... };") ffi.set_source('test_partial_enum', None) py.test.raises(VerificationMissing, ffi.emit_python_code, str(tmpdir.join('test_partial_enum.py')))
# You should have received a copy of the GNU General Public License # along with bedup. If not, see <http://www.gnu.org/licenses/>. from cffi import FFI import fcntl from . import cffi_support __all__ = ( 'getflags', 'editflags', 'FS_IMMUTABLE_FL', ) ffi = FFI() ffi.cdef(''' #define FS_IOC_GETFLAGS ... #define FS_IOC_SETFLAGS ... #define FS_SECRM_FL ... /* Secure deletion */ #define FS_UNRM_FL ... /* Undelete */ #define FS_COMPR_FL ... /* Compress file */ #define FS_SYNC_FL ... /* Synchronous updates */ #define FS_IMMUTABLE_FL ... /* Immutable file */ #define FS_APPEND_FL ... /* writes to file may only append */ #define FS_NODUMP_FL ... /* do not dump file */ #define FS_NOATIME_FL ... /* do not update atime */ /* Reserved for compression usage... */ #define FS_DIRTY_FL ... #define FS_COMPRBLK_FL ... /* One or more compressed clusters */
import os from types import TracebackType from typing import Optional, Type, Union from cffi import FFI from tartiflette.language.parsers.libgraphqlparser.transformers import ( document_from_ast_json, ) from tartiflette.types.exceptions.tartiflette import GraphQLSyntaxError __all__ = ("parse_to_document", ) # TODO: automatize read from headers files _FFI = FFI() _FFI.cdef(""" struct GraphQLAstNode *graphql_parse_string( const char *text, const char **error); void graphql_error_free(const char *error); void graphql_node_free(struct GraphQLAstNode *node); const char *graphql_ast_to_json(const struct GraphQLAstNode *node); """) # TODO: use importlib.resource in Python 3.7 _LIBGRAPHQLPARSER_DIR = os.path.join(os.path.dirname(__file__), "cffi") try: _LIB = _FFI.dlopen(f"{_LIBGRAPHQLPARSER_DIR}/libgraphqlparser.so") except OSError: