#include "Python.h"

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#ifndef _POSIX_THREADS

# ifdef HAVE_PTHREAD_H

# include <pthread.h> /* _POSIX_THREADS */

#ifndef DONT_HAVE_STDIO_H

#include <stdio.h>

#include <stdlib.h>

#ifndef _POSIX_THREADS

#ifdef __hpux

#ifdef _SC_THREADS

#define _POSIX_THREADS

#endif /* _POSIX_THREADS */

#ifdef Py_DEBUG

static int thread_debug = 0;

#define dprintf(args) (void)((thread_debug & 1) && printf args)

#define d2printf(args) ((thread_debug & 8) && printf args)

#define dprintf(args)

#define d2printf(args)

static int initialized;

static void PyThread__init_thread(void); /* Forward */

PyThread_init_thread(void)

{

#ifdef Py_DEBUG

const char *p = Py_GETENV("PYTHONTHREADDEBUG");

if (p) {

if (*p)

thread_debug = atoi(p);

else

thread_debug = 1;

}

#endif /* Py_DEBUG */

if (initialized)

return;

initialized = 1;

dprintf(("PyThread_init_thread called\n"));

PyThread__init_thread();

}

#if defined(_POSIX_THREADS)

# define PYTHREAD_NAME "pthread"

# include "thread_pthread.h"

#elif defined(NT_THREADS)

# define PYTHREAD_NAME "nt"

# include "thread_nt.h"

# error "Require native threads. See https://bugs.python.org/issue31370"

PyThread_get_stacksize(void)

{

return _PyInterpreterState_GET()->pythread_stacksize;

}

PyThread_set_stacksize(size_t size)

{

#if defined(THREAD_SET_STACKSIZE)

return THREAD_SET_STACKSIZE(size);

return -2;

}

Py_tss_t *

PyThread_tss_alloc(void)

{

Py_tss_t *new_key = (Py_tss_t *)PyMem_RawMalloc(sizeof(Py_tss_t));

if (new_key == NULL) {

return NULL;

}

new_key->_is_initialized = 0;

return new_key;

}

PyThread_tss_free(Py_tss_t *key)

{

if (key != NULL) {

PyThread_tss_delete(key);

PyMem_RawFree((void *)key);

}

}

PyThread_tss_is_created(Py_tss_t *key)

{

assert(key != NULL);

return key->_is_initialized;

}

PyDoc_STRVAR(threadinfo__doc__,

A named tuple holding information about the thread implementation.");

static PyStructSequence_Field threadinfo_fields[] = {

{"name", "name of the thread implementation"},

{"lock", "name of the lock implementation"},

{"version", "name and version of the thread library"},

{0}

};

static PyStructSequence_Desc threadinfo_desc = {

"sys.thread_info", /* name */

threadinfo__doc__, /* doc */

threadinfo_fields, /* fields */

3

};

static PyTypeObject ThreadInfoType;

PyThread_GetInfo(void)

{

PyObject *threadinfo, *value;

int pos = 0;

#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \

&& defined(_CS_GNU_LIBPTHREAD_VERSION))

char buffer[255];

int len;

if (ThreadInfoType.tp_name == 0) {

if (PyStructSequence_InitType2(&ThreadInfoType, &threadinfo_desc) < 0)

return NULL;

}

threadinfo = PyStructSequence_New(&ThreadInfoType);

if (threadinfo == NULL)

return NULL;

value = PyUnicode_FromString(PYTHREAD_NAME);

if (value == NULL) {

Py_DECREF(threadinfo);

return NULL;

}

PyStructSequence_SET_ITEM(threadinfo, pos++, value);

#ifdef _POSIX_THREADS

#ifdef USE_SEMAPHORES

value = PyUnicode_FromString("semaphore");

value = PyUnicode_FromString("mutex+cond");

if (value == NULL) {

Py_DECREF(threadinfo);

return NULL;

}

Py_INCREF(Py_None);

value = Py_None;

PyStructSequence_SET_ITEM(threadinfo, pos++, value);

#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \

&& defined(_CS_GNU_LIBPTHREAD_VERSION))

value = NULL;

len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer));

if (1 < len && (size_t)len < sizeof(buffer)) {

value = PyUnicode_DecodeFSDefaultAndSize(buffer, len-1);

if (value == NULL)

PyErr_Clear();

}

if (value == NULL)

{

Py_INCREF(Py_None);

value = Py_None;

}

PyStructSequence_SET_ITEM(threadinfo, pos++, value);

return threadinfo;

}