mirror of
https://github.com/johndoe6345789/typthon.git
synced 2026-04-24 13:45:05 +00:00
71cf7bf14f
Fixed additional patterns: - _PyOpcode_* → _TyOpcode_* (all opcode metadata) - _PyUOpName → _TyUOpName - _PyFunction_* → _TyFunction_* - _PyListIterObject → _TyListIterObject - _Py_T_OBJECT → _Ty_T_OBJECT - Py_BEGIN_ALLOW_THREADS, Py_END_ALLOW_THREADS → Ty_* - PyDoc_STRVAR, PyDoc_STR → TyDoc_* - PyInterpreterState, PyThread_*, PyTime_t → Ty* - PyStructSequence_* → TyStructSequence_* - PyLockStatus → TyLockStatus - PyVarObject_HEAD_INIT → TyVarObject_HEAD_INIT - PyBaseExceptionObject → TyBaseExceptionObject - Fixed _PyExc_ → _TyExc_ in exception macros Build is progressing further. Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>
132 lines
4.7 KiB
C
132 lines
4.7 KiB
C
#ifndef Ty_PYTHREAD_H
|
|
#define Ty_PYTHREAD_H
|
|
|
|
typedef void *TyThread_type_lock;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* Return status codes for Python lock acquisition. Chosen for maximum
|
|
* backwards compatibility, ie failure -> 0, success -> 1. */
|
|
typedef enum TyLockStatus {
|
|
PY_LOCK_FAILURE = 0,
|
|
PY_LOCK_ACQUIRED = 1,
|
|
PY_LOCK_INTR
|
|
} TyLockStatus;
|
|
|
|
PyAPI_FUNC(void) TyThread_init_thread(void);
|
|
PyAPI_FUNC(unsigned long) TyThread_start_new_thread(void (*)(void *), void *);
|
|
/* Terminates the current thread. Considered unsafe.
|
|
*
|
|
* WARNING: This function is only safe to call if all functions in the full call
|
|
* stack are written to safely allow it. Additionally, the behavior is
|
|
* platform-dependent. This function should be avoided, and is no longer called
|
|
* by Python itself. It is retained only for compatibility with existing C
|
|
* extension code.
|
|
*
|
|
* With pthreads, calls `pthread_exit` causes some libcs (glibc?) to attempt to
|
|
* unwind the stack and call C++ destructors; if a `noexcept` function is
|
|
* reached, they may terminate the process. Others (macOS) do unwinding.
|
|
*
|
|
* On Windows, calls `_endthreadex` which kills the thread without calling C++
|
|
* destructors.
|
|
*
|
|
* In either case there is a risk of invalid references remaining to data on the
|
|
* thread stack.
|
|
*/
|
|
Ty_DEPRECATED(3.14) PyAPI_FUNC(void) _Ty_NO_RETURN TyThread_exit_thread(void);
|
|
|
|
PyAPI_FUNC(unsigned long) TyThread_get_thread_ident(void);
|
|
|
|
#if (defined(__APPLE__) || defined(__linux__) || defined(_WIN32) \
|
|
|| defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
|
|
|| defined(__OpenBSD__) || defined(__NetBSD__) \
|
|
|| defined(__DragonFly__) || defined(_AIX))
|
|
#define PY_HAVE_THREAD_NATIVE_ID
|
|
PyAPI_FUNC(unsigned long) TyThread_get_thread_native_id(void);
|
|
#endif
|
|
|
|
PyAPI_FUNC(TyThread_type_lock) TyThread_allocate_lock(void);
|
|
PyAPI_FUNC(void) TyThread_free_lock(TyThread_type_lock);
|
|
PyAPI_FUNC(int) TyThread_acquire_lock(TyThread_type_lock, int);
|
|
#define WAIT_LOCK 1
|
|
#define NOWAIT_LOCK 0
|
|
|
|
// PY_TIMEOUT_T is the integral type used to specify timeouts when waiting
|
|
// on a lock (see TyThread_acquire_lock_timed() below).
|
|
#define PY_TIMEOUT_T long long
|
|
|
|
|
|
/* If microseconds == 0, the call is non-blocking: it returns immediately
|
|
even when the lock can't be acquired.
|
|
If microseconds > 0, the call waits up to the specified duration.
|
|
If microseconds < 0, the call waits until success (or abnormal failure)
|
|
|
|
If *microseconds* is greater than PY_TIMEOUT_MAX, clamp the timeout to
|
|
PY_TIMEOUT_MAX microseconds.
|
|
|
|
If intr_flag is true and the acquire is interrupted by a signal, then the
|
|
call will return PY_LOCK_INTR. The caller may reattempt to acquire the
|
|
lock.
|
|
*/
|
|
PyAPI_FUNC(TyLockStatus) TyThread_acquire_lock_timed(TyThread_type_lock,
|
|
PY_TIMEOUT_T microseconds,
|
|
int intr_flag);
|
|
|
|
PyAPI_FUNC(void) TyThread_release_lock(TyThread_type_lock);
|
|
|
|
PyAPI_FUNC(size_t) TyThread_get_stacksize(void);
|
|
PyAPI_FUNC(int) TyThread_set_stacksize(size_t);
|
|
|
|
#if !defined(Ty_LIMITED_API) || Ty_LIMITED_API+0 >= 0x03030000
|
|
PyAPI_FUNC(TyObject*) TyThread_GetInfo(void);
|
|
#endif
|
|
|
|
|
|
/* Thread Local Storage (TLS) API
|
|
TLS API is DEPRECATED. Use Thread Specific Storage (TSS) API.
|
|
|
|
The existing TLS API has used int to represent TLS keys across all
|
|
platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses
|
|
opaque data type to represent TSS keys to be compatible (see PEP 539).
|
|
*/
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(int) TyThread_create_key(void);
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(void) TyThread_delete_key(int key);
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(int) TyThread_set_key_value(int key,
|
|
void *value);
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(void *) TyThread_get_key_value(int key);
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(void) TyThread_delete_key_value(int key);
|
|
|
|
/* Cleanup after a fork */
|
|
Ty_DEPRECATED(3.7) PyAPI_FUNC(void) TyThread_ReInitTLS(void);
|
|
|
|
|
|
#if !defined(Ty_LIMITED_API) || Ty_LIMITED_API+0 >= 0x03070000
|
|
/* New in 3.7 */
|
|
/* Thread Specific Storage (TSS) API */
|
|
|
|
typedef struct _Ty_tss_t Ty_tss_t; /* opaque */
|
|
|
|
PyAPI_FUNC(Ty_tss_t *) TyThread_tss_alloc(void);
|
|
PyAPI_FUNC(void) TyThread_tss_free(Ty_tss_t *key);
|
|
|
|
/* The parameter key must not be NULL. */
|
|
PyAPI_FUNC(int) TyThread_tss_is_created(Ty_tss_t *key);
|
|
PyAPI_FUNC(int) TyThread_tss_create(Ty_tss_t *key);
|
|
PyAPI_FUNC(void) TyThread_tss_delete(Ty_tss_t *key);
|
|
PyAPI_FUNC(int) TyThread_tss_set(Ty_tss_t *key, void *value);
|
|
PyAPI_FUNC(void *) TyThread_tss_get(Ty_tss_t *key);
|
|
#endif /* New in 3.7 */
|
|
|
|
#ifndef Ty_LIMITED_API
|
|
# define Ty_CPYTHON_PYTHREAD_H
|
|
# include "cpython/pythread.h"
|
|
# undef Ty_CPYTHON_PYTHREAD_H
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* !Ty_PYTHREAD_H */
|