Cython 3.3.0a1__cp315-cp315-win_amd64.whl

Cython/Includes/libc/stdint.pxd

@@ -0,0 +1,105 @@
+# Longness only used for type promotion.
+# Actual compile time size used for conversions.
+
+# 7.18 Integer types <stdint.h>
+cdef extern from "<stdint.h>" nogil:
+
+    # 7.18.1 Integer types
+    # 7.18.1.1 Exact-width integer types
+    ctypedef   signed char  int8_t
+    ctypedef   signed short int16_t
+    ctypedef   signed int   int32_t
+    ctypedef   signed long  int64_t
+    ctypedef unsigned char  uint8_t
+    ctypedef unsigned short uint16_t
+    ctypedef unsigned int   uint32_t
+    ctypedef unsigned long long uint64_t
+    # 7.18.1.2 Minimum-width integer types
+    ctypedef   signed char  int_least8_t
+    ctypedef   signed short int_least16_t
+    ctypedef   signed int   int_least32_t
+    ctypedef   signed long  int_least64_t
+    ctypedef unsigned char  uint_least8_t
+    ctypedef unsigned short uint_least16_t
+    ctypedef unsigned int   uint_least32_t
+    ctypedef unsigned long long uint_least64_t
+    # 7.18.1.3 Fastest minimum-width integer types
+    ctypedef   signed char  int_fast8_t
+    ctypedef   signed short int_fast16_t
+    ctypedef   signed int   int_fast32_t
+    ctypedef   signed long  int_fast64_t
+    ctypedef unsigned char  uint_fast8_t
+    ctypedef unsigned short uint_fast16_t
+    ctypedef unsigned int   uint_fast32_t
+    ctypedef unsigned long long uint_fast64_t
+    # 7.18.1.4 Integer types capable of holding object pointers
+    ctypedef ssize_t intptr_t
+    ctypedef  size_t uintptr_t
+    # 7.18.1.5 Greatest-width integer types
+    ctypedef signed   long long intmax_t
+    ctypedef unsigned long long uintmax_t
+
+    # 7.18.2 Limits of specified-width integer types
+    # 7.18.2.1 Limits of exact-width integer types
+    int8_t   INT8_MIN
+    int16_t  INT16_MIN
+    int32_t  INT32_MIN
+    int64_t  INT64_MIN
+    int8_t   INT8_MAX
+    int16_t  INT16_MAX
+    int32_t  INT32_MAX
+    int64_t  INT64_MAX
+    uint8_t  UINT8_MAX
+    uint16_t UINT16_MAX
+    uint32_t UINT32_MAX
+    uint64_t UINT64_MAX
+    #7.18.2.2 Limits of minimum-width integer types
+    int_least8_t     INT_LEAST8_MIN
+    int_least16_t   INT_LEAST16_MIN
+    int_least32_t   INT_LEAST32_MIN
+    int_least64_t   INT_LEAST64_MIN
+    int_least8_t     INT_LEAST8_MAX
+    int_least16_t   INT_LEAST16_MAX
+    int_least32_t   INT_LEAST32_MAX
+    int_least64_t   INT_LEAST64_MAX
+    uint_least8_t   UINT_LEAST8_MAX
+    uint_least16_t UINT_LEAST16_MAX
+    uint_least32_t UINT_LEAST32_MAX
+    uint_least64_t UINT_LEAST64_MAX
+    #7.18.2.3 Limits of fastest minimum-width integer types
+    int_fast8_t     INT_FAST8_MIN
+    int_fast16_t   INT_FAST16_MIN
+    int_fast32_t   INT_FAST32_MIN
+    int_fast64_t   INT_FAST64_MIN
+    int_fast8_t     INT_FAST8_MAX
+    int_fast16_t   INT_FAST16_MAX
+    int_fast32_t   INT_FAST32_MAX
+    int_fast64_t   INT_FAST64_MAX
+    uint_fast8_t   UINT_FAST8_MAX
+    uint_fast16_t UINT_FAST16_MAX
+    uint_fast32_t UINT_FAST32_MAX
+    uint_fast64_t UINT_FAST64_MAX
+    #7.18.2.4 Limits of integer types capable of holding object pointers
+    enum:  INTPTR_MIN
+    enum:  INTPTR_MAX
+    enum: UINTPTR_MAX
+    # 7.18.2.5 Limits of greatest-width integer types
+    enum:  INTMAX_MAX
+    enum:  INTMAX_MIN
+    enum: UINTMAX_MAX
+
+    # 7.18.3 Limits of other integer types
+    # ptrdiff_t
+    enum: PTRDIFF_MIN
+    enum: PTRDIFF_MAX
+    # sig_atomic_t
+    enum: SIG_ATOMIC_MIN
+    enum: SIG_ATOMIC_MAX
+    # size_t
+    size_t SIZE_MAX
+    # wchar_t
+    enum: WCHAR_MIN
+    enum: WCHAR_MAX
+    # wint_t
+    enum: WINT_MIN
+    enum: WINT_MAX

Cython/Includes/libc/stdio.pxd

@@ -0,0 +1,80 @@
+# 7.19 Input/output <stdio.h>
+
+
+# deprecated cimports for backwards compatibility:
+from libc.string cimport const_char, const_void
+
+
+cdef extern from "<stdio.h>" nogil:
+
+    ctypedef struct FILE
+    cdef FILE *stdin
+    cdef FILE *stdout
+    cdef FILE *stderr
+
+    enum: FOPEN_MAX
+    enum: FILENAME_MAX
+    FILE *fopen   (const char *filename, const char  *opentype)
+    FILE *freopen (const char *filename, const char *opentype, FILE *stream)
+    FILE *fdopen  (int fdescriptor, const char *opentype)
+    int  fclose   (FILE *stream)
+    int  remove   (const char *filename)
+    int  rename   (const char *oldname, const char *newname)
+    FILE *tmpfile ()
+
+    int remove (const char *pathname)
+    int rename (const char *oldpath, const char *newpath)
+
+    enum: _IOFBF
+    enum: _IOLBF
+    enum: _IONBF
+    int setvbuf (FILE *stream, char *buf, int mode, size_t size)
+    enum: BUFSIZ
+    void setbuf (FILE *stream, char *buf)
+
+    size_t fread  (void *data, size_t size, size_t count, FILE *stream)
+    size_t fwrite (const void *data, size_t size, size_t count, FILE *stream)
+    int    fflush (FILE *stream)
+
+    enum: EOF
+    void clearerr (FILE *stream)
+    int feof      (FILE *stream)
+    int ferror    (FILE *stream)
+
+    enum: SEEK_SET
+    enum: SEEK_CUR
+    enum: SEEK_END
+    int      fseek  (FILE *stream, long int offset, int whence)
+    void     rewind (FILE *stream)
+    long int ftell  (FILE *stream)
+
+    ctypedef struct fpos_t
+    ctypedef const fpos_t const_fpos_t "const fpos_t"
+    int fgetpos (FILE *stream, fpos_t *position)
+    int fsetpos (FILE *stream, const fpos_t *position)
+
+    int scanf    (const char *template, ...)
+    int sscanf   (const char *s, const char *template, ...)
+    int fscanf   (FILE *stream, const char *template, ...)
+
+    int printf   (const char *template, ...)
+    int sprintf  (char *s, const char *template, ...)
+    int snprintf (char *s, size_t size, const char *template, ...)
+    int fprintf  (FILE *stream, const char *template, ...)
+
+    void perror  (const char *message)
+
+    char *gets  (char *s)
+    char *fgets (char *s, int count, FILE *stream)
+    int getchar ()
+    int fgetc   (FILE *stream)
+    int getc    (FILE *stream)
+    int ungetc  (int c, FILE *stream)
+
+    int puts    (const char *s)
+    int fputs   (const char *s, FILE *stream)
+    int putchar (int c)
+    int fputc   (int c, FILE *stream)
+    int putc    (int c, FILE *stream)
+
+    size_t getline(char **lineptr, size_t *n, FILE *stream)

Cython/Includes/libc/stdlib.pxd

@@ -0,0 +1,72 @@
+# 7.20 General utilities <stdlib.h>
+
+# deprecated cimports for backwards compatibility:
+from libc.string cimport const_char, const_void
+
+
+cdef extern from "<stdlib.h>" nogil:
+
+    # 7.20.1 Numeric conversion functions
+    int atoi (const char *string)
+    long atol (const char *string)
+    long long atoll (const char *string)
+    double atof (const char *string)
+    long strtol (const char *string, char **tailptr, int base)
+    unsigned long int strtoul (const char *string, char **tailptr, int base)
+    long long int strtoll (const char *string, char **tailptr, int base)
+    unsigned long long int strtoull (const char *string, char **tailptr, int base)
+    float strtof (const char *string, char **tailptr)
+    double strtod (const char *string, char **tailptr)
+    long double strtold (const char *string, char **tailptr)
+
+    # 7.20.2 Pseudo-random sequence generation functions
+    enum: RAND_MAX
+    int rand ()
+    void srand (unsigned int seed)
+
+    # 7.20.3 Memory management functions
+    void *calloc (size_t count, size_t eltsize)
+    void free (void *ptr)
+    void *malloc (size_t size)
+    void *realloc (void *ptr, size_t newsize)
+
+    # 7.20.4 Communication with the environment
+    enum: EXIT_FAILURE
+    enum: EXIT_SUCCESS
+    void exit (int status)
+    void _exit (int status)
+    int atexit (void (*function) ())
+    void abort ()
+    char *getenv (const char *name)
+    int system (const char *command)
+
+    #7.20.5 Searching and sorting utilities
+    void *bsearch (const void *key, const void *array,
+                   size_t count, size_t size,
+                   int (*compare)(const void *, const void *))
+    void qsort (void *array, size_t count, size_t size,
+                int (*compare)(const void *, const void *))
+
+    # 7.20.6 Integer arithmetic functions
+    int abs (int number)
+    long int labs (long int number)
+    long long int llabs (long long int number)
+    ctypedef struct div_t:
+        int quot
+        int rem
+    div_t div (int numerator, int denominator)
+    ctypedef struct ldiv_t:
+        long int quot
+        long int rem
+    ldiv_t ldiv (long int numerator, long int denominator)
+    ctypedef struct lldiv_t:
+        long long int quot
+        long long int rem
+    lldiv_t lldiv (long long int numerator, long long int denominator)
+
+
+    # 7.20.7 Multibyte/wide character conversion functions
+    # XXX TODO
+
+    # 7.20.8 Multibyte/wide string conversion functions
+    # XXX TODO

Cython/Includes/libc/string.pxd

@@ -0,0 +1,50 @@
+# 7.21 String handling <string.h>
+
+cdef extern from *:
+    # deprecated backwards compatibility declarations
+    ctypedef const char const_char "const char"
+    ctypedef const signed char const_schar "const signed char"
+    ctypedef const unsigned char const_uchar "const unsigned char"
+    ctypedef const void const_void "const void"
+
+cdef extern from "<string.h>" nogil:
+
+    void *memcpy  (void *pto, const void *pfrom, size_t size)
+    void *memmove (void *pto, const void *pfrom, size_t size)
+    void *memset  (void *block, int c, size_t size)
+    int  memcmp   (const void *a1, const void *a2, size_t size)
+    void *memchr  (const void *block, int c, size_t size)
+
+    void *memchr  (const void *block, int c, size_t size)
+    void *memrchr (const void *block, int c, size_t size)
+
+    size_t strlen   (const char *s)
+    char   *strcpy  (char *pto, const char *pfrom)
+    char   *strncpy (char *pto, const char *pfrom, size_t size)
+    char   *strdup  (const char *s)
+    char   *strndup (const char *s, size_t size)
+    char   *strcat  (char *pto, const char *pfrom)
+    char   *strncat (char *pto, const char *pfrom, size_t size)
+
+    int strcmp (const char *s1, const char *s2)
+    int strcasecmp (const char *s1, const char *s2)
+    int strncmp (const char *s1, const char *s2, size_t size)
+    int strncasecmp (const char *s1, const char *s2, size_t n)
+
+    int    strcoll (const char *s1, const char *s2)
+    size_t strxfrm (char *pto, const char *pfrom, size_t size)
+
+    char *strerror (int errnum)
+
+    char *strchr  (const char *string, int c)
+    char *strrchr (const char *string, int c)
+
+    char *strstr     (const char *haystack, const char *needle)
+    char *strcasestr (const char *haystack, const char *needle)
+
+    size_t strcspn (const char *string, const char *stopset)
+    size_t strspn  (const char *string, const char *set)
+    char * strpbrk (const char *string, const char *stopset)
+
+    char *strtok (char *newstring, const char *delimiters)
+    char *strsep (char **string_ptr, const char *delimiter)

Cython/Includes/libc/threads.pxd

@@ -0,0 +1,234 @@
+# cython: preliminary_late_includes_cy28=True
+
+from libc.time cimport timespec
+
+cdef extern from *:
+    """
+    #include <string.h>
+    #include <threads.h>
+    static void __Pyx_once_flag_init(once_flag* flag) {
+        once_flag other = ONCE_FLAG_INIT;
+        memcpy(flag, &other, sizeof(once_flag));
+    }
+    """
+    void once_flag_init "__Pyx_once_flag_init"(once_flag*)
+
+cdef extern from "<threads.h>" nogil:
+    ctypedef void (*_once_func_type)() noexcept nogil
+
+    # Threads
+    ctypedef struct thrd_t:
+        pass
+    # Declare as noexcept because you'll regret trying to throw a Python exception from it
+    # and nogil because it's a new thread, so you definitely don't have a Python threadstate yet.
+    ctypedef int (*thrd_start_t)(void*) noexcept nogil
+
+    int thrd_create(thrd_t*, thrd_start_t, void*)
+    int thrd_equal(thrd_t lhs, thrd_t rhs)
+    thrd_t thrd_current()
+    int thrd_sleep(const timespec* duration, timespec* remaining)
+    void thrd_yield()
+    void thrd_exit(int res)
+    void thrd_detach(thrd_t thr)
+    # Be very wary of deadlocks if calling thrd_join with the GIL.
+    int thrd_join(thrd_t, int *res)
+    enum:
+        thrd_success
+        thrd_nomem
+        thrd_timedout
+        thrd_busy
+        thrd_error
+
+    # Mutexes.
+    # We strongly recommend not calling mtx_lock with the GIL held and being
+    # very wary of calling mtx_timed_lock with the GIL (because it will block the GIL until the timeout).
+    ctypedef struct mtx_t:
+        pass
+    int mtx_init(mtx_t* mtx, int type)
+    int mtx_lock(mtx_t* mtx)  # see py_safe_mutex_lock for GIL-safe version
+    int mtx_timed_lock(mtx_t* mtx, const timespec* timepoint)
+    int mtx_trylock(mtx_t* mtx)
+    int mtx_unlock(mtx_t* mtx)
+    void mtx_destroy(mtx_t* mtx)
+    enum:
+        mtx_plain
+        mtx_recursive
+        mtx_timed
+
+    # call once. Potentially this may be hard to use with Cython's code generation
+    # (depending on the exact definition of "ONCE_FLAG_INIT").
+    # Use the helper function "once_flag_init" to do it non-statically.
+    ctypedef struct once_flag:
+        pass
+    once_flag ONCE_FLAG_INIT
+
+    # We strongly recommend not calling this with the GIL held.
+    # We define some GIL-friendly wrappers for C++ call-once which you can use
+    # in these circumstances.
+    # py_safe_call_once in this file avoids blocking, but the function
+    # must still be nogil.
+    void call_once(once_flag* flag, _once_func_type func) noexcept
+
+    # condition variables
+    ctypedef struct cnd_t:
+        pass
+    int cnd_init(cnd_t*)
+    int cnd_signal(cnd_t*)
+    int cnd_broadcast(cnd_t*)
+    # Be very wary of calling wait/timedwait with the GIL held. Two py_safe_ versions exist.
+    int cnd_wait(cnd_t*, mtx_t*)
+    int cnd_timedwait(cnd_t*, mtx_t*, const timespec*)
+    void cnd_destroy(cnd_t*)
+
+    # Thread-local storage
+    ctypedef struct tss_t:
+        pass
+    enum:
+        TSS_DTOR_ITERATIONS
+    ctypedef void (*tss_dtor_t)(void*) noexcept nogil
+    int tss_create(tss_t* key, tss_dtor_t destructor)
+    void *tss_get(tss_t key)
+    int tss_set(tss_t key, void* val)
+    void tss_delete(tss_t key)
+
+
+cdef inline void _dummy_force_utility_code_inclusion() nogil:
+    with nogil:
+        pass
+
+cdef extern from *:
+    ctypedef struct py_safe_once_flag "once_flag":
+        pass
+    py_safe_once_flag PY_SAFE_ONCE_FLAG_INIT "ONCE_FLAG_INIT"
+
+cdef extern from *:
+    """
+    static PyGILState_STATE __pyx_libc_threads_limited_api_ensure_gil() {
+        #if CYTHON_COMPILING_IN_LIMITED_API
+        if ((__PYX_LIMITED_VERSION_HEX < 0x030d0000) && __Pyx_get_runtime_version() < 0x030d0000) {
+            return PyGILState_Ensure();
+        }
+        #endif
+        return PyGILState_LOCKED;  // Unused
+    }
+
+    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
+    static void __pyx_libc_threads_limited_api_release_gil(PyGILState_STATE gil_state) {
+        if (__Pyx_get_runtime_version() < 0x030d0000)
+            PyGILState_Release(gil_state);
+    }
+    #else
+    #define __pyx_libc_threads_limited_api_release_gil(ignore) (void)ignore
+    #endif
+
+    static int __pyx_libc_threads_has_gil() {
+        #if CYTHON_COMPILING_IN_LIMITED_API
+            if ((__PYX_LIMITED_VERSION_HEX >= 0x030d0000) || __Pyx_get_runtime_version() >= 0x030d0000) {
+                // In 3.13+ we can temporarily give up the GIL to find out what the thread state was.
+                PyThreadState *ts = PyThreadState_Swap(NULL);
+                if (ts) {
+                    PyThreadState_Swap(ts);
+                    return 1;
+                }
+                return 0;
+            }
+            /* There is no way to know if we have the GIL. Therefore the only
+             * thing we can safely do is make absolutely sure that we have it
+             * (in __pyx_libc_threads_limited_api_ensure_gil).
+             */
+            return 1;
+        #elif PY_VERSION_HEX >= 0x030d0000
+            return PyThreadState_GetUnchecked() != NULL;
+        #elif PY_VERSION_HEX >= 0x030C0000
+            return _PyThreadState_UncheckedGet() != NULL;
+        #else
+            return PyGILState_Check();
+        #endif
+    }
+
+    static int __pyx_py_safe_mtx_lock_release_lock_reacquire(mtx_t* mutex) {
+        // Release the GIL, acquire the lock, then reacquire the GIL.
+        // This is safe provided the user never holds the GIL while trying
+        // to reacquire the lock (i.e. it's safe provided they always use
+        // the py-safe wrappers).
+        int result;
+        Py_BEGIN_ALLOW_THREADS
+        result = mtx_lock(mutex);
+        Py_END_ALLOW_THREADS
+        return result;
+    }
+
+    static int __pyx_py_safe_mtx_lock_impl(mtx_t* mutex) {
+        int lock_result = mtx_trylock(mutex);
+        if (lock_result == thrd_busy) {
+            return __pyx_py_safe_mtx_lock_release_lock_reacquire(mutex);
+        }
+        return lock_result;
+    }
+
+    CYTHON_UNUSED static int __pyx_py_safe_mtx_lock(mtx_t* mutex) {
+        PyGILState_STATE gil_state = __pyx_libc_threads_limited_api_ensure_gil();
+        if (!__pyx_libc_threads_has_gil())
+            return mtx_lock(mutex); /* No GIL, no problem */
+        int result = __pyx_py_safe_mtx_lock_impl(mutex);
+        __pyx_libc_threads_limited_api_release_gil(gil_state);
+        return result;
+    }
+
+    CYTHON_UNUSED static int __pyx_py_safe_cnd_wait( cnd_t* cond, mtx_t* mutex) {
+        __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
+        int result = cnd_wait(cond, mutex);
+        if (__Pyx_UnknownThreadStateMayHaveHadGil(thread_state)) {
+            int unlock_result, relock_result;
+            unlock_result = mtx_unlock(mutex);
+            __Pyx_RestoreUnknownThread(thread_state);
+            PyGILState_STATE gil_state = __pyx_libc_threads_limited_api_ensure_gil();
+            relock_result = __pyx_py_safe_mtx_lock_impl(mutex);
+            __pyx_libc_threads_limited_api_release_gil(gil_state);
+            return relock_result != thrd_success ? relock_result :
+                unlock_result != thrd_success ? unlock_result :
+                result;
+        } else {
+            __Pyx_RestoreUnknownThread(thread_state);
+            return result;
+        }
+    }
+
+    CYTHON_UNUSED static int __pyx_py_safe_cnd_timedwait(cnd_t* cond, mtx_t* mutex, const struct timespec* time_point) {
+        __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
+        int result = cnd_timedwait(cond, mutex, time_point);
+        if (__Pyx_UnknownThreadStateMayHaveHadGil(thread_state)) {
+            int unlock_result, relock_result;
+            unlock_result = mtx_unlock(mutex);
+            __Pyx_RestoreUnknownThread(thread_state);
+            PyGILState_STATE gil_state = __pyx_libc_threads_limited_api_ensure_gil();
+            relock_result = __pyx_py_safe_mtx_lock_impl(mutex);
+            __pyx_libc_threads_limited_api_release_gil(gil_state);
+            return relock_result != thrd_success ? relock_result :
+                unlock_result != thrd_success ? unlock_result :
+                result;
+        } else {
+            __Pyx_RestoreUnknownThread(thread_state);
+            return result;
+        }
+    }
+
+    CYTHON_UNUSED static void __pyx_libc_threads_py_safe_call_once(once_flag* flag, void (*func)(void)) {
+        __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
+        call_once(flag, func);
+        __Pyx_RestoreUnknownThread(thread_state);
+    }
+    """
+    # Acquire the lock without deadlocking on the GIL.
+    # At the end, the GIL will be restored to its original state.
+    int py_safe_mtx_lock "__pyx_py_safe_mtx_lock"(mtx_t* mutex) nogil
+
+    # Wait on the condition variable without deadlocking on the GIL.
+    # At the end, the GIL will be restored to its original state.
+    int py_safe_cnd_wait "__pyx_py_safe_cnd_wait"(cnd_t*, mtx_t*) nogil
+    int py_safe_cnd_timedwait "__pyx_py_safe_cnd_timedwait"(cnd_t*, mtx_t*, const timespec*) nogil
+
+    # call_once making sure not to deadlock on the GIL.
+    # The callable must still be nogil though.
+    void py_safe_once_flag_init "__Pyx_once_flag_init"(py_safe_once_flag*)
+    int py_safe_call_once "__pyx_libc_threads_py_safe_call_once"(py_safe_once_flag* flag, _once_func_type func) nogil

Cython/Includes/libc/time.pxd

@@ -0,0 +1,52 @@
+# https://en.wikipedia.org/wiki/C_date_and_time_functions
+
+from libc.stddef cimport wchar_t
+
+cdef extern from "<time.h>" nogil:
+    ctypedef long clock_t
+    ctypedef long time_t
+    struct timespec:
+        time_t tv_sec
+        long tv_nsec
+    enum: TIME_UTC
+
+    enum: CLOCKS_PER_SEC
+    clock_t clock()             # CPU time
+    time_t  time(time_t *)      # wall clock time since Unix epoch
+
+    cdef struct tm:
+        int  tm_sec
+        int  tm_min
+        int  tm_hour
+        int  tm_mday
+        int  tm_mon
+        int  tm_year
+        int  tm_wday
+        int  tm_yday
+        int  tm_isdst
+        # GNU specific extensions
+        #char *tm_zone
+        #long tm_gmtoff
+
+    int     daylight            # global state
+    long    timezone
+    char    *tzname[2]
+    void    tzset()
+
+    char    *asctime(const tm *)
+    char    *asctime_r(const tm *, char *)
+    char    *ctime(const time_t *)
+    char    *ctime_r(const time_t *, char *)
+    double  difftime(time_t, time_t)
+    tm      *getdate(const char *)
+    tm      *gmtime(const time_t *)
+    tm      *gmtime_r(const time_t *, tm *)
+    tm      *localtime(const time_t *)
+    tm      *localtime_r(const time_t *, tm *)
+    time_t  mktime(tm *)
+    size_t  strftime(char *, size_t, const char *, const tm *)
+    size_t  wcsftime(wchar_t *str, size_t cnt, const wchar_t *fmt, tm *time)
+    int     timespec_get(timespec *spec, int base)
+
+    # POSIX not stdC
+    char    *strptime(const char *, const char *, tm *)

Cython/Includes/libcpp/__init__.pxd

@@ -0,0 +1,4 @@
+cdef extern from *:
+    ctypedef bint bool
+    ctypedef void* nullptr_t
+    nullptr_t nullptr