add ydb deps

1 files changed, 267 insertions, 0 deletions

diff --git a/contrib/tools/python/src/Python/thread_os2.h b/contrib/tools/python/src/Python/thread_os2.h
new file mode 100644
index 0000000000..1b264b5ad5
--- /dev/null
+++ b/contrib/tools/python/src/Python/thread_os2.h
@@ -0,0 +1,267 @@
+/* This code implemented by cvale@netcom.com */
+
+#define INCL_DOSPROCESS
+#define INCL_DOSSEMAPHORES
+#include "os2.h"
+#include "limits.h"
+
+#include "process.h"
+
+#if defined(PYCC_GCC)
+#include <sys/builtin.h>
+#include <sys/fmutex.h>
+#else
+long PyThread_get_thread_ident(void);
+#endif
+
+/* default thread stack size of 64kB */
+#if !defined(THREAD_STACK_SIZE)
+#define THREAD_STACK_SIZE       0x10000
+#endif
+
+#define OS2_STACKSIZE(x)        (x ? x : THREAD_STACK_SIZE)
+
+/*
+ * Initialization of the C package, should not be needed.
+ */
+static void
+PyThread__init_thread(void)
+{
+}
+
+/*
+ * Thread support.
+ */
+long
+PyThread_start_new_thread(void (*func)(void *), void *arg)
+{
+    int thread_id;
+
+    thread_id = _beginthread(func,
+                            NULL,
+                            OS2_STACKSIZE(_pythread_stacksize),
+                            arg);
+
+    if (thread_id == -1) {
+        dprintf(("_beginthread failed. return %ld\n", errno));
+    }
+
+    return thread_id;
+}
+
+long
+PyThread_get_thread_ident(void)
+{
+#if !defined(PYCC_GCC)
+    PPIB pib;
+    PTIB tib;
+#endif
+
+    if (!initialized)
+        PyThread_init_thread();
+
+#if defined(PYCC_GCC)
+    return _gettid();
+#else
+    DosGetInfoBlocks(&tib, &pib);
+    return tib->tib_ptib2->tib2_ultid;
+#endif
+}
+
+void
+PyThread_exit_thread(void)
+{
+    dprintf(("%ld: PyThread_exit_thread called\n",
+             PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
+    _endthread();
+}
+
+/*
+ * Lock support.  This is implemented with an event semaphore and critical
+ * sections to make it behave more like a posix mutex than its OS/2
+ * counterparts.
+ */
+
+typedef struct os2_lock_t {
+    int is_set;
+    HEV changed;
+} *type_os2_lock;
+
+PyThread_type_lock
+PyThread_allocate_lock(void)
+{
+#if defined(PYCC_GCC)
+    _fmutex *sem = malloc(sizeof(_fmutex));
+    if (!initialized)
+        PyThread_init_thread();
+    dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
+             PyThread_get_thread_ident(),
+             (long)sem));
+    if (_fmutex_create(sem, 0)) {
+        free(sem);
+        sem = NULL;
+    }
+    return (PyThread_type_lock)sem;
+#else
+    APIRET rc;
+    type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock->is_set = 0;
+
+    DosCreateEventSem(NULL, &lock->changed, 0, 0);
+
+    dprintf(("%ld: PyThread_allocate_lock() -> %p\n",
+             PyThread_get_thread_ident(),
+             lock->changed));
+
+    return (PyThread_type_lock)lock;
+#endif
+}
+
+void
+PyThread_free_lock(PyThread_type_lock aLock)
+{
+#if !defined(PYCC_GCC)
+    type_os2_lock lock = (type_os2_lock)aLock;
+#endif
+
+    dprintf(("%ld: PyThread_free_lock(%p) called\n",
+             PyThread_get_thread_ident(),aLock));
+
+#if defined(PYCC_GCC)
+    if (aLock) {
+        _fmutex_close((_fmutex *)aLock);
+        free((_fmutex *)aLock);
+    }
+#else
+    DosCloseEventSem(lock->changed);
+    free(aLock);
+#endif
+}
+
+/*
+ * Return 1 on success if the lock was acquired
+ *
+ * and 0 if the lock was not acquired.
+ */
+int
+PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
+{
+#if !defined(PYCC_GCC)
+    int   done = 0;
+    ULONG count;
+    PID   pid = 0;
+    TID   tid = 0;
+    type_os2_lock lock = (type_os2_lock)aLock;
+#endif
+
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
+             PyThread_get_thread_ident(),
+             aLock,
+             waitflag));
+
+#if defined(PYCC_GCC)
+    /* always successful if the lock doesn't exist */
+    if (aLock &&
+        _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
+        return 0;
+#else
+    while (!done) {
+        /* if the lock is currently set, we have to wait for
+         * the state to change
+         */
+        if (lock->is_set) {
+            if (!waitflag)
+                return 0;
+            DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
+        }
+
+        /* enter a critical section and try to get the semaphore.  If
+         * it is still locked, we will try again.
+         */
+        if (DosEnterCritSec())
+            return 0;
+
+        if (!lock->is_set) {
+            lock->is_set = 1;
+            DosResetEventSem(lock->changed, &count);
+            done = 1;
+        }
+
+        DosExitCritSec();
+    }
+#endif
+
+    return 1;
+}
+
+void
+PyThread_release_lock(PyThread_type_lock aLock)
+{
+#if !defined(PYCC_GCC)
+    type_os2_lock lock = (type_os2_lock)aLock;
+#endif
+
+    dprintf(("%ld: PyThread_release_lock(%p) called\n",
+             PyThread_get_thread_ident(),
+             aLock));
+
+#if defined(PYCC_GCC)
+    if (aLock)
+        _fmutex_release((_fmutex *)aLock);
+#else
+    if (!lock->is_set) {
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+                 PyThread_get_thread_ident(),
+                 aLock,
+                 GetLastError()));
+        return;
+    }
+
+    if (DosEnterCritSec()) {
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+                 PyThread_get_thread_ident(),
+                 aLock,
+                 GetLastError()));
+        return;
+    }
+
+    lock->is_set = 0;
+    DosPostEventSem(lock->changed);
+
+    DosExitCritSec();
+#endif
+}
+
+/* minimum/maximum thread stack sizes supported */
+#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
+#define THREAD_MAX_STACKSIZE    0x2000000       /* 32MB */
+
+/* set the thread stack size.
+ * Return 0 if size is valid, -1 otherwise.
+ */
+static int
+_pythread_os2_set_stacksize(size_t size)
+{
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
+
+    /* valid range? */
+    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+        _pythread_stacksize = size;
+        return 0;
+    }
+
+    return -1;
+}
+
+#define THREAD_SET_STACKSIZE(x) _pythread_os2_set_stacksize(x)