Lines Matching +full:pypy +full:- +full:c
31 * `Direct support for pkg-config`__.
35 ``require_writable`` to refuse read-only Python buffers.
48 * CPython 2.x: ``ffi.dlopen()`` failed with non-ascii file names on Posix
50 * CPython: if a thread is started from C and then runs Python code (with
71 -------
75 field or vice-versa.
79 * ABI mode: implemented ``ffi.dlclose()`` for the in-line case (it used
80 to be present only in the out-of-line case).
82 * Fixed a corner case for ``setup.py install --record=xx --root=yy``
83 with an out-of-line ABI module. Also fixed `Issue #345`_.
89 a spin-lock. On CPython 3 it is worse because it might spin-lock for
106 -------
110 for now. See `Issue #355`_. On Windows only, the C extension
112 ``foo.cp36-win32.pyd``, to make it clear that they are regular
119 -------
122 ``__spec__`` from the cffi-generated lib modules gave a buggy
127 literal strings in C code (from
136 -------
138 * Fix Windows issue with managing the thread-state on CPython 3.0 to 3.5
142 -------
144 * Fix tests, remove deprecated C API usage
155 -----
164 actually defined by the C source you provide (if used in ``cdef()``).
168 mode you still cannot call C functions that take complex numbers
175 out-of-line mode you don't instantiate ``FFI`` explicitly at all.)
178 messages show up to stderr---but stderr goes nowhere in many
184 open a non-modal MessageBox (in addition to sending raw messages to
196 used by PyPy, to make the next GC occur more quickly (`issue #320`__).
204 .. __: https://bitbucket.org/cffi/cffi/issues/321/cffi-191-segmentation-fault-during-self
205 .. __: ref.html#ffi-gc
206 .. __: https://bitbucket.org/cffi/cffi/issues/320/improve-memory_pressure-management
211 -------
213 (only released inside PyPy 5.8.0)
222 -----
226 allocator. Speeds up ``ffi.new(large-array)`` where most of the time
236 * Add support for some unusual compilers (non-msvc, non-gcc, non-icc,
237 non-clang)
247 * The C type ``_Bool`` or ``bool`` now converts to a Python boolean
252 case means "undefined behavior" in C; if you really have to interface
262 * ``ffi.addressof(lib, "name")`` now works also in in-line mode, not
263 only in out-of-line mode. This is useful for taking the address of
269 compares equal to ``b'A'``. Unlike C, ``<cdata 'int' -1>`` does not
270 compare equal to ``ffi.cast("unsigned int", -1)``: it compares
271 smaller, because ``-1 < 4294967295``.
273 * PyPy: ``ffi.new()`` and ``ffi.new_allocator()()`` did not record
275 ``ffi.new()`` very often and/or with large arrays. Fixed in PyPy 5.7.
278 ``-``. Assumes that there is no overflow; it should be fixed first
284 ----
286 * Structs with variable-sized arrays as their last field: now we track
289 detect out-of-range accesses to array items. This also lets us
296 * Add support in ``cdef()/set_source()`` for unspecified-length arrays
304 enum has size ``int`` is a 99%-safe bet. (But not 100%, so it stays
311 file object---and not at the earlier time when you call ``close()``,
315 from C (...via cffi).
319 ------
322 pointer type, or vice-versa, the cast occurs automatically, like in C.
325 property---but I was mistaken. In C you get the usual warning if you
332 ------
341 ------
343 * CPython 3.x: experimental: the generated C extension modules now use
346 distutils is still version-specific. To get the version-independent
351 --debug`` but defaulting to True if we are running a debugging
356 ----
364 * PyPy 5.4 can now pass a byte string directly to a ``char *``
366 a CPython-only optimization.
370 ----
376 value is zero (including ``-0.0``), and True otherwise. Previously
380 * bytearrays: ``ffi.from_buffer(bytearray-object)`` is now supported.
381 (The reason it was not supported was that it was hard to do in PyPy,
382 but it works since PyPy 5.3.) To call a C function with a ``char *``
383 argument from a buffer object---now including bytearrays---you write
385 ``p[0:length] = bytearray-object``. The problem with this was that a
390 * C++: compiling the generated C code with C++ was supposed to work,
392 as the C ``_Bool`` type, which doesn't exist in C++).
395 as well as ``dir(p)`` where ``p`` is a struct or pointer-to-struct.
399 ----
405 * `extern "Python+C"`_
407 * in API mode, ``lib.foo.__doc__`` contains the C signature now. On
409 ``help(lib)`` (or ``help(lib.foo)`` on PyPy) is still useless; I
416 .. _`ffi.list_types()`: ref.html#ffi-list-types
417 .. _`ffi.unpack()`: ref.html#ffi-unpack
418 .. _`extern "Python+C"`: using.html#extern-python-c
422 ------
428 ------
430 * A few installation-time tweaks (thanks Stefano!)
440 ------
448 ------
454 ------
457 some detail changed that makes some underscore-starting macros
459 thinking it changed in all 3.5 versions---but no: it was only in
464 ------
468 out-of-line API mode that replaces the dynamic creation of callback
469 objects (i.e. C functions that invoke Python) with the static
471 more C-like, in that you have to structure your code around the idea
473 creating them on-the-fly.
493 It already used to work like that on PyPy.
499 .. __: using.html#extern-python
500 .. __: ref.html#ffi-init-once
501 .. __: ref.html#ffi-new-handle
505 ------
508 not always available from out-of-line FFI objects.
516 mis-parse some pointer-to-pointer types like ``char * const *``: the
521 ------
525 * Pull request #64: out-of-line API mode: we can now declare
526 floating-point types with ``typedef float... foo_t;``. This only
530 on some architectures (64-bit, non-x86).
534 to the generated C code; this fixes warnings by the C compiler.
540 pointers; regular C functions still don't need to have their `calling
546 which had unwanted side-effects. Try saying ``import setuptools``
549 .. _`ffi.memmove()`: ref.html#ffi-memmove
551 .. __: https://bitbucket.org/cffi/cffi/pull-requests/65/remove-_hack_at_distutils-which-imports/diff
552 .. _`calling convention`: using.html#windows-calling-conventions
556 ------
562 ------
564 * Out-of-line mode: ``int a[][...];`` can be used to declare a structure
566 unknown to the C compiler (the ``a[]`` part) and each element is
568 C compiler (the ``int`` and ``[...]`` parts around it). Similarly,
570 that in C it means ``int (a[5])[...];``).
572 * PyPy: the ``lib.some_function`` objects were missing the attributes
574 some decorators-management functions from ``functools``.
576 * Out-of-line API mode: you can now do ``from _example.lib import x``
585 dict---assuming that ``lib`` has got no symbol called precisely
588 * Out-of-line API mode: global variables are now fetched on demand at
591 or ``__thread`` -local variables. (This change might also tighten
592 the C compiler's check on the variables' type.)
605 function---before it had time to enter the ``try: except:`` block.
611 .. __: ref.html#ffi-new-allocator
615 ------
622 ------
624 * Out-of-line mode: ``ffi.string()``, ``ffi.buffer()`` and
626 arguments, unlike their in-line mode equivalent. (It worked in PyPy.)
628 * Out-of-line ABI mode: documented a restriction__ of ``ffi.dlopen()``
629 when compared to the in-line mode.
634 only in PyPy, and only with the out-of-line FFIs.)
636 .. __: cdef.html#dlopen-note
640 ------
642 * Out-of-line API mode: we can now declare integer types with
646 * Out-of-line API mode: we can now declare multidimensional arrays
650 * Out-of-line ABI mode: we now support any constant declaration,
652 constants, i.e. either non-integers or without a value given in the
668 of ``package/_ffi.py``. Also fixed: in some cases, if the C file was
669 in ``build/foo.c``, the .o file would be put in ``build/build/foo.o``.
673 ------
679 ------
681 * Variadic C functions (ending in a "..." argument) were not supported
682 in the out-of-line ABI mode. This was a bug---there was even a
683 (non-working) example__ doing exactly that!
685 .. __: overview.html#out-of-line-abi-level
689 ------
702 ------
704 * The main news item is out-of-line module generation:
713 .. _`for ABI level`: overview.html#out-of-line-abi-level
714 .. _`for API level`: overview.html#out-of-line-api-level