Exemple #1
0
def main(filename):
    ffi = FFI()

    ffi.set_source(
        "pylibsize",
        """
        # include "libsize.h"
        """,
        extra_objects=["libsize.so"],
        include_dirs=["."],
    )

    ffi.cdef(
        """\
struct Size_return {
	int r0; /* w */
	int r1; /* h */
};

extern struct Size_return Size(char* p0);
        """
    )
    ffi.compile(verbose=True, debug=True)

    from pylibsize import lib, ffi
    sizeinfo = lib.Size(filename.encode("utf-8"))
    print(sizeinfo, sizeinfo.r0, sizeinfo.r1)
Exemple #2
0
def build_ffi(include_recovery=False, include_schnorr=False, include_ecdh=False):
    ffi = FFI()

    source = "#include <secp256k1.h>"
    cdefs = definitions
    if include_recovery:
        cdefs += definitions_recovery
        source += "\n#include <secp256k1_recovery.h>"
    if include_schnorr:
        cdefs += definitions_schnorr
        source += "\n#include <secp256k1_schnorr.h>"
    if include_ecdh:
        cdefs += definitions_ecdh
        source += "\n#include <secp256k1_ecdh.h>"

    incpath = [os.environ['INCLUDE_DIR']] if 'INCLUDE_DIR' in os.environ else None
    libpath = [os.environ['LIB_DIR']] if 'LIB_DIR' in os.environ else None

    ffi.set_source(
        "_libsecp256k1",
        source,
        libraries=["secp256k1"],
        library_dirs=libpath,
        include_dirs=incpath)
    ffi.cdef(cdefs)

    return ffi
    def setup_class(cls):
        stack_ffi = FFI()
        stack_ffi.cdef("""
        typedef intptr_t ptr_t;
        int vmp_binary_search_ranges(ptr_t ip, ptr_t * l, int count);
        int vmp_ignore_ip(ptr_t ip);
        int vmp_ignore_symbol_count(void);
        ptr_t * vmp_ignore_symbols(void);
        void vmp_set_ignore_symbols(ptr_t * symbols, int count);
        int vmp_read_vmaps(const char * fname);
        void vmp_native_disable();
        """)
        with open("src/vmp_stack.c", "rb") as fd:
            source = fd.read().decode()
            libs = [] #['unwind', 'unwind-x86_64']
            if sys.platform.startswith('linux'):
                libs = ['unwind', 'unwind-x86_64']
            # trick: compile with _CFFI_USE_EMBEDDING=1 which will not define Py_LIMITED_API
            stack_ffi.set_source("vmprof.test._test_stack", source, include_dirs=['src'],
                                 define_macros=[('_CFFI_USE_EMBEDDING',1), ('PY_TEST',1),
                                                ('VMP_SUPPORTS_NATIVE_PROFILING',1)],
                                 libraries=libs, extra_compile_args=['-Werror', '-g'])

        stack_ffi.compile(verbose=True)
        from vmprof.test import _test_stack as clib
        cls.lib = clib.lib
        cls.ffi = clib.ffi
Exemple #4
0
def _ffi(
        module_name=MODULE_NAME, headers=HEADER_FILES, sources=SOURCE_FILES,
        libraries=LIBRARIES):
    """
    Returns an instance of :class:`FFI` without compiling
    the module.  This function is used internally but also
    as an entrypoint in the setup.py for `cffi_modules`.

    :keyword str module_name:
        Optional module name to use when setting the source.

    :keyword tuple headers:
        Optional path(s) to the header files.

    :keyword tuple sources:
        Optional path(s) to the source files.
    """
    logger.debug(
        "_ffi(module_name=%r, headers=%r, sources=%r)",
        module_name, headers, sources)

    header = _read(*headers)
    source = _read(*sources)

    ffi = FFI()
    ffi.set_unicode(True)
    ffi.set_source(module_name, source, libraries=libraries)

    # Windows uses SAL annotations which can provide some helpful information
    # about the inputs and outputs to a function.  Rather than require these
    # to be stripped out manually we should strip them out programmatically.
    ffi.cdef(REGEX_SAL_ANNOTATION.sub(" ", header))

    return ffi
def main(defs_file, parser_file, verbose):
    ffi = FFI()
    with open(defs_file) as f:
        ffi.embedding_api(f.read())
    ffi.set_source('parser_interface', '#include "%s"' % defs_file)
    with open(parser_file) as f:
        ffi.embedding_init_code(f.read())
    interpreter, _, _ = os.path.basename(sys.executable).partition('.')
    ffi.compile(target='libplease_parser_%s.*' % interpreter, verbose=verbose)
Exemple #6
0
def test_no_cross_include():
    baseffi = FFI()
    baseffi.set_source('test_no_cross_include_base', "..source..")
    #
    ffi = FFI()
    ffi.include(baseffi)
    target = udir.join('test_no_cross_include.py')
    py.test.raises(VerificationError, make_py_source,
                   ffi, 'test_no_cross_include', str(target))
Exemple #7
0
def _buildlib():
	cdef, src = _getcode()
	libname = _getlibname()
	from cffi import FFI
	ffibuilder = FFI()
	ffibuilder.cdef(cdef)
	ffibuilder.set_source(libname, src)
	dir = os.path.abspath(os.path.dirname(__file__))
	ffibuilder.compile(tmpdir=dir,verbose=True)
Exemple #8
0
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)
    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, ...);
    int globalvar42;
    const int globalconst42;
    const char *const globalconsthello = "hello";
    int no_such_function(int);
    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 *);
    """)
    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))
Exemple #9
0
def test_struct_included():
    baseffi = FFI()
    baseffi.cdef("struct foo_s { int x; };")
    baseffi.set_source('test_struct_included_base', None)
    #
    ffi = FFI()
    ffi.include(baseffi)
    target = udir.join('test_struct_included.py')
    make_py_source(ffi, 'test_struct_included', str(target))
    assert target.read() == r"""# auto-generated file
Exemple #10
0
def create_module():

    hfiles = header_files()
    # remove ws.h due to https://github.com/nanomsg/nanomsg/issues/467
    hfiles.pop('ws.h', None)

    ffi = FFI()
    ffi.cdef(functions(hfiles))
    ffi.set_source('_nnpy', '\n'.join('#include <%s>' % fn for fn in hfiles),
                   libraries=['nanomsg'], include_dirs=INCLUDE)
    return ffi
Exemple #11
0
def build_ffi():
    ffi = FFI()
    source = []
    source.extend(raw_typedefs)
    source.extend(function_defs.values())
    source.extend(enum_defs)
    ffi.set_source('sdl2._gl', '\n'.join(source))
    ffi.cdef('\n'.join(typedefs.values()))
    ffi.cdef('\n'.join(function_defs.values()))
    ffi.cdef('\n'.join(enum_defs))
    return ffi
Exemple #12
0
def find_curses_library():
    for curses_library in ['ncursesw', 'ncurses']:
        ffi = FFI()
        ffi.set_source("_curses_cffi_check", "", libraries=[curses_library])
        try:
            ffi.compile()
        except VerificationError as e:
            e_last = e
            continue
        else:
            return curses_library

    # If none of the libraries is available, present the user a meaningful
    # error message
    raise e_last
Exemple #13
0
def _mk_ffi(sources, name="_libsecp256k1", bundled=True, **kwargs):
    ffi = FFI()
    code = []
    if "INCLUDE_DIR" in os.environ:
        kwargs["include_dirs"] = [absolute(os.environ["INCLUDE_DIR"])]
    if "LIB_DIR" in os.environ:
        kwargs["library_dirs"] = [absolute(os.environ["LIB_DIR"])]
    for source in sources:
        with open(source.h, "rt") as h:
            ffi.cdef(h.read())
        code.append(source.include)
    if bundled:
        code.append("#define PY_USE_BUNDLED")
    ffi.set_source(name, "\n".join(code), **kwargs)
    return ffi
Exemple #14
0
def create_module():

    # Set defaults

    set_source_args = {
        'include_dirs': DEFAULT_INCLUDE_DIRS
    }
    host_library = DEFAULT_HOST_LIBRARY

    # Read overrides for cross-compilation support from site.cfg

    if os.path.isfile(SITE_CFG):
        parser = cfgparser.ConfigParser()

        if parser.read(SITE_CFG):

            parsed_cfg = parser.defaults()
            for param in ['include_dirs', 'library_dirs']:
                if param in parsed_cfg:
                    set_source_args[param] = parsed_cfg[param].split(',')

            if 'host_library' in parsed_cfg:
                host_library = parsed_cfg['host_library']

    # Add some more directories from the environment

    if 'CPATH' in os.environ:
        cpaths = os.getenv('CPATH').split(os.pathsep)
        set_source_args['include_dirs'] += [os.path.join(p, 'nanomsg')
                                            for p in cpaths]

    hfiles = header_files(set_source_args['include_dirs'])
    # remove ws.h due to https://github.com/nanomsg/nanomsg/issues/467
    hfiles.pop('ws.h', None)

    # Build FFI module and write out the constants

    ffi = FFI()
    ffi.cdef(DEFINITIONS)
    ffi.cdef(functions(hfiles))
    ffi.set_source('_nnpy', '\n'.join('#include <%s>' % fn for fn in hfiles),
                   libraries=['nanomsg'], **set_source_args)

    with open('nnpy/constants.py', 'w') as f:
        f.write(symbols(ffi, host_library))

    return ffi
Exemple #15
0
def load_ool_module():
    """
    Compile an out-of-line module, return the corresponding ffi and
    module objects.
    """
    from cffi import FFI

    defs = """
    double sin(double x);
    double cos(double x);
    void vsSin(int n, float* x, float* y);
    void vdSin(int n, double* x, double* y);
    int foo(int a, int b, int c);
    """

    source = """
    static int foo(int a, int b, int c)
    {
        return a + b * c;
    }

    void vsSin(int n, float* x, float* y) {
        int i;
        for (i=0; i<n; i++)
            y[i] = sin(x[i]);
    }

    void vdSin(int n, double* x, double* y) {
        int i;
        for (i=0; i<n; i++)
            y[i] = sin(x[i]);
    }
    """

    ffi = FFI()
    ffi.set_source('cffi_usecases_ool', source)
    ffi.cdef(defs, override=True)
    tmpdir = static_temp_directory('test_cffi')
    ffi.compile(tmpdir=tmpdir)
    sys.path.append(tmpdir)
    try:
        import cffi_usecases_ool as mod
        cffi_support.register_module(mod)
        return mod.ffi, mod
    finally:
        sys.path.remove(tmpdir)
Exemple #16
0
def maker():
    """
    Generate the bindings module.  Invoked by cffi's setuptools
    integration.
    """
    _cffi_src = os.path.dirname(__file__)

    ffibuilder = FFI()

    with open(os.path.join(_cffi_src, "set_source.h")) as set_source:
        ffibuilder.set_source(
            "posix_spawn._bindings",
            set_source.read())

    with open(os.path.join(_cffi_src, "cdef.h")) as cdef:
        ffibuilder.cdef(cdef.read())

    return ffibuilder
Exemple #17
0
def build(**kwargs):
    """Build the C slitfunc library"""

    CWD = os.path.dirname(__file__)

    ffibuilder = FFI()
    with open(os.path.join(CWD, "slit_func_bd.h")) as f:
        ffibuilder.cdef(f.read(), override=True)
    with open(os.path.join(CWD, "slit_func_bd.c"), "r") as f:
        ffibuilder.set_source("clib._slitfunc_bd", f.read())
    ffibuilder.compile(**kwargs)

    ffibuilder = FFI()
    with open(os.path.join(CWD, "slit_func_2d_xi_zeta_bd.h")) as f:
        ffibuilder.cdef(f.read(), override=True)
    with open(os.path.join(CWD, "slit_func_2d_xi_zeta_bd.c"), "r") as f:
        ffibuilder.set_source("clib._slitfunc_2d", f.read())
    ffibuilder.compile(**kwargs)
Exemple #18
0
def build(**kwargs):
    """Build the cluster C library"""
    ffibuilder = FFI()

    CWD = os.path.dirname(__file__)

    with open(os.path.join(CWD, "cluster.h")) as f:
        ffibuilder.cdef(f.read(), override=True)

    with open(os.path.join(CWD, "cluster.c"), "r") as f:
        ffibuilder.set_source(
            "clib._cluster",
            f.read(),
            # libraries=["c"],
            # sources=[os.path.join(CWD, "cluster.c")],
            # library_dirs=["."]
            # include_dirs=[os.path.join()]
        )
    ffibuilder.compile(**kwargs)
Exemple #19
0
def test_include():
    ffi = FFI()
    ffi.cdef("#define ABC 123")
    ffi.set_source('test_include', None)
    target = udir.join('test_include.py')
    make_py_source(ffi, 'test_include', str(target))
    assert target.read() == r"""# auto-generated file
import _cffi_backend

ffi = _cffi_backend.FFI('test_include',
    _version = 0x2601,
    _types = b'',
    _globals = (b'\xFF\xFF\xFF\x1FABC',123,),
)
"""
    #
    ffi2 = FFI()
    ffi2.include(ffi)
    target2 = udir.join('test2_include.py')
    make_py_source(ffi2, 'test2_include', str(target2))
    assert target2.read() == r"""# auto-generated file
Exemple #20
0
    def setup_class(cls):
        ffi = FFI()
        ffi.cdef("""
        void native_gzipgzipgzip(void);
        """)
        source = """
        #include "zlib.h"
        unsigned char input[100];
        unsigned char output[100];
        void native_gzipgzipgzip(void) {
            z_stream defstream;
            defstream.zalloc = Z_NULL;
            defstream.zfree = Z_NULL;
            defstream.opaque = Z_NULL;
            defstream.next_in = input; // input char array
            defstream.next_out = output; // output char array

            deflateInit(&defstream, Z_DEFAULT_COMPRESSION);
            int i = 0;
            while (i < 10000) {
                defstream.avail_in = 100;
                defstream.avail_out = 100;
                deflate(&defstream, Z_FINISH);
                i++;
            }
            deflateEnd(&defstream);
        }
        """
        libs = []
        if sys.platform.startswith('linux'):
            libs.append('z')
        # trick: compile with _CFFI_USE_EMBEDDING=1 which will not define Py_LIMITED_API
        ffi.set_source("vmprof.test._test_native_gzip", source, include_dirs=['src'],
                       define_macros=[('_CFFI_USE_EMBEDDING',1),('_PY_TEST',1)], libraries=libs,
                       extra_compile_args=['-Werror', '-g', '-O0'])

        ffi.compile(verbose=True)
        from vmprof.test import _test_native_gzip as clib
        cls.lib = clib.lib
        cls.ffi = clib.ffi
Exemple #21
0
def _build_c_extension():
    ffi = FFI()

    ffi.cdef("""
    typedef int... off_t;
    #define PROT_READ ...
    #define PROT_WRITE ...
    #define PROT_EXEC ...
    #define PROT_NONE ...
    #define MAP_PRIVATE ...
    #define MAP_FIXED ...
    #define MAP_SHARED ...

    void mmap_init(off_t offset);
    uint16_t mmap_peek16(off_t offset);
    void mmap_poke16(off_t offset, uint16_t value);
    """)

    ffi.set_source("_cmmapwrapper", """
    #include<sys/mman.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    volatile uint16_t *map = 0;
    void mmap_init(off_t offset){
        int fd;
        fd = open("/dev/mem", O_RDWR|O_SYNC);
        map = mmap(0, getpagesize(), PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset);
    }
    uint16_t  mmap_peek16(off_t offset){
        uint16_t n;
        n = map[offset/2];
        return n;
    }
    void mmap_poke16(off_t offset, uint16_t value){
        map[offset/2] = value;
    }
    """)
    ffi.compile(tmpdir='build')
Exemple #22
0
def test_include_1():
    sub_ffi = FFI()
    sub_ffi.cdef("static const int k2 = 121212;")
    sub_ffi.include(original_ffi)
    assert 'macro FOOBAR' in original_ffi._parser._declarations
    assert 'macro FOOBAZ' in original_ffi._parser._declarations
    sub_ffi.set_source('re_python_pysrc', None)
    sub_ffi.emit_python_code(str(tmpdir.join('_re_include_1.py')))
    #
    if sys.version_info[:2] >= (3, 3):
        import importlib
        importlib.invalidate_caches()  # issue 197 (but can't reproduce myself)
    #
    from _re_include_1 import ffi
    assert ffi.integer_const('FOOBAR') == -42
    assert ffi.integer_const('FOOBAZ') == -43
    assert ffi.integer_const('k2') == 121212
    lib = ffi.dlopen(extmod)     # <- a random unrelated library would be fine
    assert lib.FOOBAR == -42
    assert lib.FOOBAZ == -43
    assert lib.k2 == 121212
    #
    p = ffi.new("bar_t *", [5, b"foobar"])
    assert p.a[4] == ord('a')
Exemple #23
0
    int nvx_utf8vld_validate (void* utf8vld, const uint8_t* data, size_t length);

    void nvx_utf8vld_free (void* utf8vld);

    int nvx_utf8vld_set_impl(void* utf8vld, int impl);

    int nvx_utf8vld_get_impl(void* utf8vld);
""")

with open(os.path.join(os.path.dirname(__file__), '_utf8validator.c')) as fd:
    c_source = fd.read()
    ffi.set_source("_nvx_utf8validator",
                   c_source,
                   libraries=[],
                   extra_compile_args=[
                       '-std=c99', '-Wall', '-Wno-strict-prototypes', '-O3',
                       '-march=native'
                   ])


class Utf8Validator:
    def __init__(self):
        self.ffi = ffi

        from _nvx_utf8validator import lib
        self.lib = lib

        self._vld = self.ffi.gc(self.lib.nvx_utf8vld_new(),
                                self.lib.nvx_utf8vld_free)
        print(self.lib.nvx_utf8vld_get_impl(self._vld))
Exemple #24
0
"""Build the _nvtx module."""

from cffi import FFI

ffibuilder = FFI()
ffibuilder.set_unicode(True)
ffibuilder.set_source("._nvtx",
                      "#include <nvtx3/nvToolsExt.h>\n",
                      include_dirs=['/usr/local/cuda/include'])
ffibuilder.cdef(r"""
    typedef ...* nvtxDomainHandle_t;
    typedef ...* nvtxStringHandle_t;
    #define NVTX_VERSION ...
    #define NVTX_EVENT_ATTRIB_STRUCT_SIZE ...

    typedef union {
        const char *ascii;
        const wchar_t *unicode;
        nvtxStringHandle_t registered;
        ...;
    } nvtxMessageValue_t;

    typedef enum {
        NVTX_COLOR_UNKNOWN,
        NVTX_COLOR_ARGB,
        ...
    } nvtxColorType_t;

    typedef enum {
        NVTX_MESSAGE_UNKNOWN,
        NVTX_MESSAGE_TYPE_ASCII,
Exemple #25
0
from cffi import FFI

ffibuilder = FFI()

with open("lib/clips.c") as source_file:
    CLIPS_SOURCE = source_file.read()

with open("lib/clips.cdef") as cdef_file:
    CLIPS_CDEF = cdef_file.read()

ffibuilder.set_source("_clips", CLIPS_SOURCE, libraries=["clips"])

ffibuilder.cdef(CLIPS_CDEF)

if __name__ == "__main__":
    ffibuilder.compile(verbose=True)
Exemple #26
0
def build_quest_so():
    lib_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                            'pyquest_cffi/questlib/')
    quest_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                              "QuEST/QuEST")
    if platform.system() == 'Darwin':
        questlib = os.path.join(lib_path, "libQuEST.dylib")
    else:
        questlib = os.path.join(lib_path, "libQuEST.so")
    include = [os.path.join(quest_path, "include")]

    _questlib = ctypes.CDLL(questlib)
    QuESTPrecFunc = _questlib['getQuEST_PREC']
    QuESTPrecFunc.restype = ctypes.c_int
    QuESTPrec = QuESTPrecFunc()

    if QuESTPrec == 1:
        qreal = "float"
    elif QuESTPrec == 2:
        qreal = "double"
    elif QuESTPrec == 4:
        qreal = "longdouble"
    else:
        raise TypeError('Unable to determine precision of qreal')
    del (QuESTPrec)
    del (QuESTPrecFunc)

    with open(os.path.join(include[0], "QuEST.h"), "r") as f:
        lines = [line for line in f]

    lines += [
        "void statevec_setAmps(Qureg qureg, long long int startInd," +
        " qreal* reals, qreal* imags, long long int numAmps);"
    ]
    lines += [
        "qreal densmatr_calcProbOfOutcome(Qureg qureg, const int measureQubit, int outcome);"
    ]
    lines += [
        "qreal statevec_calcProbOfOutcome(Qureg qureg, const int measureQubit, int outcome);"
    ]
    lines += [
        "int generateMeasurementOutcome(qreal zeroProb, qreal *outcomeProb);"
    ]
    lines += ["int getQuEST_PREC(void);"]

    _lines = []
    no_def = True
    skip = False
    for line in lines:
        if not line.find("getEnvironmentString") >= 0:
            if skip:
                if line.startswith('#endif'):
                    skip = False
            elif line.startswith('#ifndef __cplusplus'):
                skip = True
            elif no_def and not line.startswith("#"):
                _lines.append(line)
            elif line.startswith("#ifdef"):
                no_def = False
            elif line.startswith("#endif"):
                no_def = True
    _lines = "".join(_lines).replace('qreal', qreal)

    ffibuilder = FFI()
    ffibuilder.cdef(_lines)
    ffibuilder.set_source(
        "_quest",
        r'''
            #include <QuEST.h>
        ''',
        libraries=["QuEST"],
        include_dirs=include,
        library_dirs=[lib_path],
        extra_link_args=['-Wl,-rpath,$ORIGIN'],
        # extra_link_args=['-Wl,-rpath={}'.format(lib_path)],
    )
    ffibuilder.compile(verbose=True)
def generateIntermediateApi():
    ffibuilder = FFI()
    ffibuilder.set_source("intermediateApi",
                          r"""#include "open62541.h"
		#define UA_STATUSCODE_GOOD 0x00 
		#define UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME 2258 
		#define UA_TYPES_COUNT 190
		#define UA_TYPES_DATETIME 12
		""",
                          include_dirs=[dirname + r"/open62541/build"],
                          library_dirs=[dirname + r"/open62541/build/bin"],
                          libraries=['open62541'])

    ffibuilder.cdef("""
		typedef struct UA_Client UA_Client;
		typedef uint32_t UA_StatusCode;
		typedef struct UA_ClientConfig UA_ClientConfig;
		UA_Client *UA_Client_new(void);
		UA_StatusCode UA_ClientConfig_setDefault(UA_ClientConfig *config);
		UA_ClientConfig *UA_Client_getConfig(UA_Client *client);
		UA_StatusCode UA_Client_connect(UA_Client *client, const char *endpointUrl);

		typedef uint16_t UA_UInt16;
		typedef uint32_t UA_UInt32;

		struct UA_DataType {...;};
		typedef struct UA_DataType UA_DataType;
		const UA_DataType UA_TYPES[190];
		#define UA_TYPES_DATETIME 12

		typedef bool UA_Boolean;
		typedef int64_t UA_DateTime;


		typedef struct { void *data;                   /* Points to the scalar or array data */
		...;} UA_Variant;
		void UA_Variant_init(UA_Variant *p);
		UA_Boolean UA_Variant_hasScalarType(const UA_Variant *v, const UA_DataType *type);

		typedef struct {...;} UA_NodeId;
		UA_NodeId UA_NODEID_NUMERIC(UA_UInt16 nsIndex, UA_UInt32 identifier);
		UA_StatusCode UA_Client_readValueAttribute(UA_Client *client, const UA_NodeId nodeId, UA_Variant *outValue);


		typedef enum {
    		UA_LOGCATEGORY_NETWORK = 0,
    		UA_LOGCATEGORY_SECURECHANNEL,
	    	UA_LOGCATEGORY_SESSION,
		    UA_LOGCATEGORY_SERVER,
		    UA_LOGCATEGORY_CLIENT,
		    UA_LOGCATEGORY_USERLAND,
		    UA_LOGCATEGORY_SECURITYPOLICY
		} UA_LogCategory;


		typedef struct {...;} UA_Logger;

		typedef struct UA_DateTimeStruct {
		    UA_UInt16 nanoSec;
		    UA_UInt16 microSec;
		    UA_UInt16 milliSec;
		    UA_UInt16 sec;
		    UA_UInt16 min;
		    UA_UInt16 hour;
		    UA_UInt16 day;   /* From 1 to 31 */
		    UA_UInt16 month; /* From 1 to 12 */
		    UA_UInt16 year;
		} UA_DateTimeStruct;


		UA_Logger *UA_Log_Stdout;
		UA_DateTimeStruct UA_DateTime_toStruct(UA_DateTime t);

		#define UA_STATUSCODE_GOOD 0x00
		#define UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME 2258

		void UA_LOG_INFO(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...);

		""")
    os.system("mkdir build")
    os.chdir(dirname + r"/build")
    ffibuilder.compile(verbose=True)
    print("finished building intermediateApi")
Exemple #28
0
import os

from cffi import FFI

siphash_source_file = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                   'siphash24.c')

ffibuilder = FFI()
ffibuilder.cdef(
    '''int siphash(const uint8_t *in, uint64_t inlen, const uint8_t *k, uint8_t *out, const size_t outlen);'''
)

with open(siphash_source_file) as siphash_source:
    ffibuilder.set_source('csiphash._siphash', siphash_source.read())

if __name__ == '__main__':
    ffibuilder.compile(verbose=True)
Exemple #29
0
from os import path

from cffi import FFI

ffibuilder = FFI()

base_path = path.abspath(path.dirname(__file__))
header_path = path.join(base_path, 'vendor/binaryen-c.h')

with open(header_path, 'r') as header_file:
    source = header_file.read()
    ffibuilder.set_source(
        '_binaryen_c',
        r"""
        #include <stddef.h>
        #include <stdint.h>
        {}""".format(source),
        libraries=['binaryen'],
        library_dirs=['vendor'],
    )
    ffibuilder.cdef(source)

if __name__ == '__main__':
    ffibuilder.compile(verbose=True)
Exemple #30
0
from cffi import FFI

ffi = FFI()

ffi.cdef("""
    int foo (int x);
""")

if __name__ == "__main__":
    ffi.set_source("_example",
                   """
        #include <x86intrin.h>

        const __m128i* ptr = 0;

        int foo (int x) {
            ptr += 1;
            return x + ((int) ptr);
        };
        """,
                   libraries=[])

    ffi.compile()
Exemple #31
0
#!/usr/bin/python

from cffi import FFI

ffibuilder = FFI()

ffibuilder.set_source("fnfqueue._fnfqueue",
                      """
    #include "fnfqueue.h"
    """,
                      sources=["src/fnfqueue.c"],
                      extra_compile_args=["-O3"],
                      include_dirs=["include"])

ffibuilder.cdef("""
#define NF_DROP           ...
#define NF_ACCEPT         ...
#define NF_STOLEN         ...
#define NF_QUEUE          ...
#define NF_REPEAT         ...
#define NF_STOP           ...

#define MANGLE_MARK       ...
#define MANGLE_PAYLOAD    ...
#define MANGLE_CT         ...
#define MANGLE_EXP        ...
#define MANGLE_VLAN       ...

#define NFQNL_COPY_NONE   ...
#define NFQNL_COPY_META   ...
#define NFQNL_COPY_PACKET ...
Exemple #32
0
    void free(void *ptr);
    """)

ffi.set_source(
    '_regex2dfa',
    """
    #include "%s"

    extern "C" {
        extern const char * cffi_regex2dfa(char *regex, uint32_t len) {
            const std::string input_regex = std::string(regex, len);

            std::string minimized_dfa;

            regex2dfa::Regex2Dfa(input_regex, &minimized_dfa);
            return strdup(minimized_dfa.c_str());
        }
    }
    """ % regex2dfa_header,
    source_extension='.cpp',
    library_dirs=['.libs'],
    libraries=['regex2dfa'],
    extra_compile_args=[
        '-O3',
        '-fstack-protector-all',
        '-D_FORTIFY_SOURCE',
        '-fPIC',
    ],
)

if __name__ == '__main__':
    ffi.compile()
Exemple #33
0
        lines = []
        src_lines = iter(headerfile_src)
        try:
            while True:
                line = next(src_lines).strip()
                if "deprecated" in line:
                    while ";" not in line:
                        line = next(src_lines).strip()
                else:
                    lines.append(line)
        except StopIteration:
            pass

        headerfile = "\n".join(lines)
        ffi_c_source = """
        #include <binaryen-c.h>
    """
    else:
        headerfile = open(header_location, "rt").read()
        ffi_c_source = headerfile
    return headerfile, ffi_c_source


headerfile, ffi_c_source = parse_header_file()
ffibuilder = FFI()
ffibuilder.cdef(headerfile)
ffibuilder.set_source("_binaryen", ffi_c_source, libraries=['binaryen'])

if __name__ == "__main__":
    ffibuilder.compile(verbose=True)
      float *transition_probs,
      float *states,
      float *initial_values,
      int n_generators,
      int n_simulations, 
      int n_transitions, 
      int n_states,
      int random_seed,
      int simulate_streaks);

	""")

# with open('psrmodels/_c/libtimedependence.h','r') as f:
# 	ffibuilder.cdef(f.read())

header = "#include \"" + os.path.dirname(
    os.path.abspath(__file__)) + "/../c/libtimedependence.h\""

ffibuilder.set_source(
    "_c_ext_timedependence",  # name of the output C extension
    # """
    # #include "../../psrmodels/_c/libtimedependence.h"
    # """,
    header,
    sources=[
        'psrmodels/c/libtimedependence.c', 'psrmodels/c/mtwist-1.5/mtwist.c'
    ],
    libraries=['m'])  # on Unix, link with the math library

if __name__ == "__main__":
    ffibuilder.compile(verbose=True)
Exemple #35
0
##########
# FFI Build
##########

_groove_source = r"""
#include <groove/groove.h>
#include <groove/queue.h>
#include <groove/encoder.h>
#include <groovefingerprinter/fingerprinter.h>
#include <grooveloudness/loudness.h>
#include <grooveplayer/player.h>
"""
# TODO: set these differently depending on platform/compiler
libs = [
    ':libgroove.so.4',
    ':libgroovefingerprinter.so.4',
    ':libgrooveloudness.so.4',
    ':libgrooveplayer.so.4',
]
ffi_groove = FFI()
ffi_groove.set_source('groove._groove', _groove_source, libraries=libs)
ffi_groove.cdef(_groove_header)
ffi_groove.cdef(_queue_header)
ffi_groove.cdef(_encoder_header)
ffi_groove.cdef(_fingerprinter_header)
ffi_groove.cdef(_loudness_header)
ffi_groove.cdef(_player_header)

if __name__ == '__main__':
    ffi_groove.compile()
Exemple #36
0
from cffi import FFI

ffi = FFI()

ffi.set_source(
    "pyhello",
    """
#include "hello.h"
""",
    extra_objects=["../hello.so"],
    include_dirs=["../"],
)

ffi.cdef("""
extern void Hello();
""")

if __name__ == "__main__":
    ffi.compile(verbose=True)
    from pyhello.lib import Hello
    Hello()
Exemple #37
0
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
Exemple #38
0
# file "simple_example_build.py"

# Note: this particular example fails before version 1.0.2
# because it combines variadic function and ABI level.

from cffi import FFI

ffi = FFI()
ffi.set_source("_simple_example", None)
ffi.cdef("""
    int printf(const char *format, ...);
""")

if __name__ == "__main__":
    ffi.compile()
Exemple #39
0
    'graph.h',
    'index.h',
    'merge.h',
    'net.h',
    'refspec.h',
    'repository.h',
    'revert.h',
    'stash.h',
    'submodule.h',
    'callbacks.h',  # Bridge from libgit2 to Python
]
h_source = []
for h_file in h_files:
    h_file = os.path.join(dir_path, 'decl', h_file)
    with codecs.open(h_file, 'r', 'utf-8') as f:
        h_source.append(f.read())

C_HEADER_SRC = '\n'.join(h_source)

# ffi
_, libgit2_kw = get_libgit2_paths()
ffi = FFI()
ffi.set_source(
    "pygit2._libgit2",
    "#include <git2.h>",  # preamble
    **libgit2_kw)
ffi.cdef(C_HEADER_SRC)

if __name__ == '__main__':
    ffi.compile()
Exemple #40
0
    sos_include_dir = ""
    sos_lib_dir = ""
    if len(sys.argv) > 1:
        sos_include_dir = sys.argv[1]
        sos_lib_dir = sys.argv[2]
    else:
        sos_build_dir = str(os.environ.get("SOS_BUILD_DIR"))
        sos_include_dir = str(sos_build_dir) + "/include"
        sos_lib_dir = str(sos_build_dir) + "/lib"

    ffibuilder.set_source("ssos_python",
                          """

    #include "ssos.h"
    #include "sosa.h"

    """,
                          sources=["../ssos.c"],
                          libraries=["sos"],
                          library_dirs=[sos_lib_dir],
                          include_dirs=[sos_include_dir])
    #extra_compile_args=["-Wno-unused-variable"])
    #extra_compile_args=["-Wno-unused-variable", "-DUSE_MUNGE=1"])

    ffibuilder.cdef("""

    typedef struct {
        void        *sos_context;
        char        *query_sql;
        uint64_t     query_guid;
        double       exec_duration;
# which depend on '_pypy_winbase_cffi' already.
#
# Note that if you need to regenerate _pypy_winbase_cffi and
# can't use a preexisting PyPy to do that, then running this
# file should work as long as 'subprocess' is not imported
# by cffi.  I had to hack in 'cffi._pycparser' to move an
#'import subprocess' to the inside of a function.  (Also,
# CPython+CFFI should work as well.)
#
# This module supports both msvcrt.py and _subprocess.py.

from cffi import FFI

ffi = FFI()

ffi.set_source("_pypy_winbase_cffi", None)

# ---------- MSVCRT ----------

ffi.cdef("""
typedef unsigned short wint_t;

int _open_osfhandle(intptr_t osfhandle, int flags);
intptr_t _get_osfhandle(int fd);
int _setmode(int fd, int mode);
int _locking(int fd, int mode, long nbytes);

int _kbhit(void);
int _getch(void);
wint_t _getwch(void);
int _getche(void);
Exemple #42
0
# -*- coding: utf-8 -*-

from cffi import FFI

try:
    system_types = open('inc/system_types.h', 'r').read()
    fuse_types = open('inc/fuse_types.h', 'r').read()
except Exception:
    print('missing types headers!')
else:
    ffibuilder = FFI()
    ffibuilder.set_source("_fuse",
                          r"""
                            #include <fuse3/fuse.h>
                          """,
                          libraries=['fuse3'],
                          define_macros=[
                              ("FUSE_USE_VERSION", "32"),
                          ],
                          extra_compile_args=[],
                          extra_link_args=[])
    ffibuilder.cdef(system_types + fuse_types)
    if __name__ == '__main__':
        ffibuilder.compile(verbose=True)
Exemple #43
0
import logging
import struct
from collections import defaultdict

import os
try:
    from cffi.backend_ctypes import long, unicode
except ImportError:
    pass

try:
    from ._ffi_moco_packet import ffi
except ImportError:
    from cffi import FFI
    ffi = FFI()
    ffi.set_source("moco._ffi_moco_packet", None, libraries=[])
    dpt_path = os.path.join(
        os.path.dirname(os.path.abspath(__file__)),
        '../../embedded/firmware/communication/data_packet_types.h')
    with open(dpt_path, 'r') as dpt_file:
        ffi_data = dpt_file.readlines()
    ffi.cdef(''.join(ffi_data[7:-2]))

import six
from .util.datatypes import update, set_values, AttributeDict

logger = logging.getLogger("Motive." + __name__)
MAX_DATA_SIZE = 512

ffi = ffi
PACKET_LEN = ffi.sizeof("GenericPacket")
Exemple #44
0
import os
from cffi import FFI
ffibuilder = FFI()

ffibuilder.set_source("grblas.backends.suitesparse._suitesparse_grblas",
                      r"""#include "GraphBLAS.h" """,
                      libraries=['graphblas'])

thisdir = os.path.dirname(__file__)

gb_cdef = open(os.path.join(thisdir, 'suitesparse_graphblas_3.1.1.h'))

ffibuilder.cdef(gb_cdef.read())

if __name__ == '__main__':
    ffibuilder.compile(verbose=True)
Exemple #45
0
# -*- coding: utf-8 -*-
"""
CFFI API for SecureTransport.
"""

from cffi import FFI
ffibuilder = FFI()

ffibuilder.set_source(
    "_securetransport",
    """
    #include <stdlib.h>
    #include <Security/SecCertificate.h>
    #include <Security/SecTrust.h>
    #include <Security/SecureTransport.h>
    """,
    extra_link_args=['-framework', 'Security', '-framework', 'CoreFoundation'],
)

ffibuilder.cdef("""
    typedef bool Boolean;
    typedef uint8_t UInt8;
    typedef uint32_t UInt32;
    typedef signed long OSStatus;
    typedef signed long long CFIndex;
    typedef ... *CFArrayRef;
    typedef ... *CFDataRef;
    typedef ... *CFAllocatorRef;
    typedef ... *SSLContextRef;
    typedef ... *SecCertificateRef;
    typedef ... *SecTrustRef;
Exemple #46
0
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, ...);
    int globalvar42;
    const int globalconst42;
    const char *const globalconsthello = "hello";
    int no_such_function(int);
    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; }; }; };
    """)
    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))
Exemple #47
0
int Tcl_GetBignumFromObj(Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value);
Tcl_Obj *Tcl_NewBignumObj(mp_int *value);

int mp_unsigned_bin_size(mp_int *a);
int mp_to_unsigned_bin_n(mp_int * a, unsigned char *b, unsigned long *outlen);
int mp_read_radix(mp_int *a, const char *str, int radix);
int mp_init(mp_int *a);
void mp_clear(mp_int *a);
""")

tkffi.set_source("_tkinter.tklib_cffi", """
#define HAVE_LIBTOMMATH %(HAVE_LIBTOMMATH)s
#define HAVE_WIDE_INT_TYPE %(HAVE_WIDE_INT_TYPE)s
#include <tcl.h>
#include <tk.h>

#if HAVE_LIBTOMMATH
#include <tclTomMath.h>
#endif 

char *get_tk_version(void) { return TK_VERSION; }
char *get_tcl_version(void) { return TCL_VERSION; }
""" % globals(),
include_dirs=incdirs,
libraries=linklibs,
library_dirs = libdirs
)

if __name__ == "__main__":
    tkffi.compile(os.path.join(os.path.dirname(sys.argv[0]), '..'))
Exemple #48
0
for l in cpropep_libs:
    prefix = 'pypropep/cpropep/' + l + '/src/'
    src_files += glob(prefix + '*.c')
    for ef in exclude_c_files:
        if (prefix + ef) in src_files:
            print('Excluding {} from source list'.format(prefix+ef))
            src_files.remove(prefix + ef)

inc_files = ''
for i in inc_dir:
    files = glob(i + '/*.h')
    for f in files:
        inc_files += '#include "%s"\n' % (os.path.basename(f))

ffibuilder.set_source("pypropep.cpropep._cpropep",
    inc_files,
    sources=src_files,
    include_dirs=inc_dir)

# TODO:Find a way to scrape #defines from headers rather than hard coding const
ffibuilder.cdef("""
//**** libcpropep/type.h ****//
typedef enum
{
  GAS,
  CONDENSED,
  STATE_LAST,
  ...
} state_t;

typedef enum
{
Exemple #49
0
  int count;
  float threshold;
  ccv_bbf_feature_t* feature;
  float* alpha;
} ccv_bbf_stage_classifier_t;

typedef struct {
  int count;
  ccv_size_t size;
  ccv_bbf_stage_classifier_t* stage_classifier;
} ccv_bbf_classifier_cascade_t;

ccv_bbf_classifier_cascade_t* ccv_bbf_read_classifier_cascade(const char*);
ccv_array_t* ccv_bbf_detect_objects(
    ccv_dense_matrix_t*, ccv_bbf_classifier_cascade_t**,
    int, ccv_bbf_param_t);
void ccv_bbf_classifier_cascade_free(ccv_bbf_classifier_cascade_t* cascade);

extern ccv_bbf_param_t ccv_bbf_default_params;
""")

ffi.set_source('_ccv',
               '#include <ccv.h>',
               include_dirs=[os.getenv('INCDIR') or '.'],
               library_dirs=[os.getenv('LIBDIR') or '.'],
               libraries=['ccv'])

if __name__ == "__main__":
    res = ffi.compile()
    print res
from cffi import FFI

ffibuilder = FFI()

_path = os.path.dirname(__file__)
sourcefile = os.path.join(_path, 'seclink.cc')

with open(sourcefile, 'r') as f:
    source = f.read()

ffibuilder.set_source(
    "_libseclink",
    source,
    source_extension='.cc',
    extra_compile_args=['-Wall', '-Wextra', '-std=gnu++17', '-O3'],
    include_dirs=["./", "_cffi_build/"],
    libraries=['seal'],
    sources=[
        '_cffi_build/encrypt.cc', '_cffi_build/decrypt.cc',
        '_cffi_build/multiply.cc', '_cffi_build/secure-linkage.cc'
    ])

ffibuilder.cdef("""
    typedef struct seclink_ctx *seclink_ctx_t;

void seclink_init_ctx(seclink_ctx_t *ctx,
        size_t polmod_deg, uint64_t plain_mod,
        uint64_t prng_seed[2]);

void seclink_clear_ctx(seclink_ctx_t ctx);
Exemple #51
0
import sys
import os.path
import setuptools  # Fix distutils issues
from cffi import FFI

ffi = FFI()
mod_name = 'instrumental.drivers.cameras._pixelfly.errortext'

if sys.platform.startswith('win'):
    ffi.set_source(mod_name,
                   """
        #define PCO_ERR_H_CREATE_OBJECT
        #define PCO_ERRT_H_CREATE_OBJECT
        #include <windows.h>
        #include "PCO_errt.h"
    """,
                   include_dirs=[os.path.dirname(__file__)])
    ffi.cdef("void PCO_GetErrorText(DWORD dwerr, char* pbuf, DWORD dwlen);")
else:
    ffi.set_source(mod_name, '')

if __name__ == '__main__':
    ffi.compile()
Exemple #52
0
# file "testCFFI_build.py"

# Note: this particular example fails before version 1.0.2
# because it combines variadic function and ABI level.

from cffi import FFI

ffi = FFI()
ffi.set_source("_testCFFI", None)
ffi.cdef("""
    void printHello();
    void printMessage(char *myMessage);
    double sumVector(int size, double* vec);
         """)

if __name__ == "__main__":
    ffi.compile()
Exemple #53
0
from cffi import FFI
ffi = FFI()
ffi.cdef("""

typedef ... Display;
typedef struct { ...; } Window;

typedef struct { int type; ...; } XEvent;

Display *XOpenDisplay(char *display_name);
Window DefaultRootWindow(Display *display);
int XMapRaised(Display *display, Window w);
Window XCreateSimpleWindow(Display *display, Window parent, int x, int y,
                           unsigned int width, unsigned int height,
                           unsigned int border_width, unsigned long border,
                           unsigned long background);
int XNextEvent(Display *display, XEvent *event_return);
""")

ffi.set_source('_xclient_cffi', """
            #include <X11/Xlib.h>
""", libraries=['X11'])

if __name__ == '__main__':
    ffi.compile(verbose=True)
Exemple #54
0
#include <stdlib.h>
#define FNV1A_32_OFFSET   2166136261UL
#define FNV1A_32_PRIME    16777619
/**
 * 32-bits unsigned FNV1a returning into hash, using p to as variable to
 * walk over metric up to firstspace
 */
#define fnv1a_32(hash, p, metric, firstspace) \
	hash = FNV1A_32_OFFSET; \
	for (p = metric; p < firstspace; p++) \
		hash = (hash ^ (unsigned int)*p) * FNV1A_32_PRIME;

static unsigned short
fnv1a_hashpos(const char *key, int len)
{
	unsigned int hash;
    const char *end = key + len;
	fnv1a_32(hash, key, key, end);
	return (unsigned short)((hash >> 16) ^ (hash & (unsigned int)0xFFFF));
}
'''
ffi.set_source("_fnv1a", header+src)
ffi.cdef(header)
ffi.compile()

from _fnv1a import ffi
lib = ffi.dlopen(None)
fnv1a_hashpos = lib.fnv1a_hashpos

if __name__ == "__main__":
    print fnv1a_hashpos('test', 4)
Exemple #55
0
    void *src,
    int srclen,
    void *dst
);
int hypua_decoder_decode_ucs4(
    void *decoder,
    void *src,
    int srclen,
    void *dst
);
int hypua_decoder_decode_flush_ucs2(void *decoder, void *dst);
int hypua_decoder_decode_flush_ucs4(void *decoder, void *dst);

    '''  # noqa
)


if sys.platform == 'win32':
    library = 'build/hypua2jamo-c/HanyangPUA.lib'
else:
    library = 'build/hypua2jamo-c/libHanyangPUA.a'


ffi.set_source(
    'hypua2jamo._cffi',
    '',
    extra_objects=[
        library,
    ],
)
ffi.cdef("int ldns_ok(struct ldns_info *ldi);")

ffi.cdef("uint16_t get_short(uint8_t *bp, uint16_t x);")

ffi.set_source("cpldns",  # .so to be created
    """ // passed to the real C compiler
#include <ldns/ldns.h>

struct ldns_info {
   struct ldns_struct_pkt *ldpkt;  /* ldns_pkt typedef in ldns/packet.h */
   int status;  /* enum in ldns */
   };

int get_ldns_info(struct ldns_info *ldi, uint8_t *dns_msg, int dns_len) {
   ldi->status = ldns_wire2pkt(&ldi->ldpkt, dns_msg, dns_len);
   return ldi->ldpkt != NULL;  /* True if all's well */
   }

int ldns_ok(struct ldns_info *ldi) {
   return ldi->status == LDNS_STATUS_OK;
   }

uint16_t get_short(uint8_t *bp, uint16_t x) {
   uint16_t v = *(uint16_t *)&bp[x];
   return ntohs(v);
   }
    """,
    libraries=["ldns", "c"])   # list of libraries to link with

ffi.cdef(
    """
struct ldns_info {
Exemple #57
0
from cffi import FFI
ffi = FFI()
ffi.cdef("""

typedef ... Display;
typedef struct { ...; } Window;

typedef struct { int type; ...; } XEvent;

Display *XOpenDisplay(char *display_name);
Window DefaultRootWindow(Display *display);
int XMapRaised(Display *display, Window w);
Window XCreateSimpleWindow(Display *display, Window parent, int x, int y,
                           unsigned int width, unsigned int height,
                           unsigned int border_width, unsigned long border,
                           unsigned long background);
int XNextEvent(Display *display, XEvent *event_return);
""")

ffi.set_source('_xclient_cffi', """
            #include <X11/Xlib.h>
""", libraries=['X11'])

if __name__ == '__main__':
    ffi.compile()
Exemple #58
0
from cffi import FFI

ffibuilder = FFI()

source = """
typedef unsigned char   MP_U8;
typedef unsigned int    MP_U32;
int lzmat_encode(MP_U8 *pbOut, MP_U32 *pcbOut, MP_U8 *pbIn, MP_U32 cbIn);
int lzmat_decode(MP_U8 *pbOut, MP_U32 *pcbOut, MP_U8 *pbIn, MP_U32 cbIn);
"""
ffibuilder.set_source(
    "_pylzmat",  # name of the output C extension
    """#include "lzmat.h" """,
    sources=['src/lzmat/lzmat_enc.c', 'src/lzmat/lzmat_dec.c'],   # includes pi.c as additional sources
    include_dirs=['src/lzmat']

)

# ffibuilder.cdef("int lzmat_encode(char *pbOut, int *pcbOut, char *pbIn, int cbIn);")
# ffibuilder.cdef("int lzmat_decode(char *pbOut, int *pcbOut, char *pbIn, int cbIn);")

ffibuilder.cdef(source)

if __name__ == "__main__":
    ffibuilder.compile(verbose=True)
Exemple #59
0
    'repository.h',
    'revert.h',
    'stash.h',
    'submodule.h',
]
h_source = []
for h_file in h_files:
    h_file = os.path.join(dir_path, 'decl', h_file)
    with codecs.open(h_file, 'r', 'utf-8') as f:
        h_source.append(f.read())

C_HEADER_SRC = '\n'.join(h_source)

# Preamble
preamble = "#include <git2.h>"

# C_KEYWORDS
libgit2_bin, libgit2_include, libgit2_lib = get_libgit2_paths()
C_KEYWORDS = dict(libraries=['git2'],
                  library_dirs=[libgit2_lib],
                  include_dirs=[libgit2_include])

# ffi
ffi = FFI()
ffi.set_source("pygit2._libgit2", preamble, **C_KEYWORDS)
ffi.cdef(C_HEADER_SRC)


if __name__ == '__main__':
    ffi.compile()
Exemple #60
-1
def build_ffi(module_name, cdef_source, verify_source, libraries=[],
              extra_compile_args=[], extra_link_args=[]):
    ffi = FFI()
    ffi.cdef(cdef_source)
    ffi.set_source(
        module_name,
        verify_source,
        libraries=libraries,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args,
    )
    return ffi