/***********************************************************

Copyright (C) 1994 Steen Lumholt.

All Rights Reserved

******************************************************************/

/* _tkinter.c -- Interface to libtk.a and libtcl.a. */

/* TCL/TK VERSION INFO:

Only Tcl/Tk 8.5.12 and later are supported. Older versions are not

supported. Use Python 3.10 or older if you cannot upgrade your

Tcl/Tk libraries.

*/

/* XXX Further speed-up ideas, involving Tcl 8.0 features:

- Register a new Tcl type, "Python callable", which can be called more

efficiently and passed to Tcl_EvalObj() directly (if this is possible).

*/

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

#ifdef MS_WINDOWS

# include "pycore_fileutils.h" // _Py_stat()

#endif

#include "pycore_long.h" // _PyLong_IsNegative()

#include "pycore_unicodeobject.h" // _PyUnicode_AsUTF8String

#ifdef MS_WINDOWS

# include <windows.h>

#endif

#define CHECK_SIZE(size, elemsize) \

((size_t)(size) <= Py_MIN((size_t)INT_MAX, UINT_MAX / (size_t)(elemsize)))

/* If Tcl is compiled for threads, we must also define TCL_THREAD. We define

it always; if Tcl is not threaded, the thread functions in

Tcl are empty. */

#define TCL_THREADS

#ifdef TK_FRAMEWORK

# include <Tcl/tcl.h>

# include <Tk/tk.h>

#else

# include <tcl.h>

# include <tk.h>

#endif

#include "tkinter.h"

#if TK_HEX_VERSION < 0x0805020c

#error "Tk older than 8.5.12 not supported"

#endif

#ifndef TCL_WITH_EXTERNAL_TOMMATH

#define TCL_NO_TOMMATH_H

#endif

#include <tclTomMath.h>

#if defined(TCL_WITH_EXTERNAL_TOMMATH) || (TK_HEX_VERSION >= 0x08070000)

#define USE_DEPRECATED_TOMMATH_API 0

#else

#define USE_DEPRECATED_TOMMATH_API 1

#endif

// As suggested by https://core.tcl-lang.org/tcl/wiki?name=Migrating+C+extensions+to+Tcl+9

#ifndef TCL_SIZE_MAX

typedef int Tcl_Size;

#define TCL_SIZE_MAX INT_MAX

#endif

#if !(defined(MS_WINDOWS) || defined(__CYGWIN__))

#define HAVE_CREATEFILEHANDLER

#endif

#ifdef HAVE_CREATEFILEHANDLER

/* This bit is to ensure that TCL_UNIX_FD is defined and doesn't interfere

with the proper calculation of FHANDLETYPE == TCL_UNIX_FD below. */

#ifndef TCL_UNIX_FD

# ifdef TCL_WIN_SOCKET

# define TCL_UNIX_FD (! TCL_WIN_SOCKET)

# else

# define TCL_UNIX_FD 1

# endif

#endif

/* Tcl_CreateFileHandler() changed several times; these macros deal with the

messiness. In Tcl 8.0 and later, it is not available on Windows (and on

Unix, only because Jack added it back); when available on Windows, it only

applies to sockets. */

#ifdef MS_WINDOWS

#define FHANDLETYPE TCL_WIN_SOCKET

#else

#define FHANDLETYPE TCL_UNIX_FD

#endif

/* If Tcl can wait for a Unix file descriptor, define the EventHook() routine

which uses this to handle Tcl events while the user is typing commands. */

#if FHANDLETYPE == TCL_UNIX_FD

#define WAIT_FOR_STDIN

#endif

#endif /* HAVE_CREATEFILEHANDLER */

/* Use OS native encoding for converting between Python strings and

Tcl objects.

On Windows use UTF-16 (or UTF-32 for 32-bit Tcl_UniChar) with the

"surrogatepass" error handler for converting to/from Tcl Unicode objects.

On Linux use UTF-8 with the "surrogateescape" error handler for converting

to/from Tcl String objects. */

#ifdef MS_WINDOWS

#define USE_TCL_UNICODE 1

#else

#define USE_TCL_UNICODE 0

#endif

#if PY_LITTLE_ENDIAN

#define NATIVE_BYTEORDER -1

#else

#define NATIVE_BYTEORDER 1

#endif

#ifdef MS_WINDOWS

#include <conio.h>

#define WAIT_FOR_STDIN

static PyObject *

_get_tcl_lib_path(void)

{

static PyObject *tcl_library_path = NULL;

static int already_checked = 0;

if (already_checked == 0) {

struct stat stat_buf;

int stat_return_value;

PyObject *prefix;

(void) PySys_GetOptionalAttrString("base_prefix", &prefix);

if (prefix == NULL) {

return NULL;

}

/* Check expected location for an installed Python first */

tcl_library_path = PyUnicode_FromString("\\tcl\\tcl" TCL_VERSION);

if (tcl_library_path == NULL) {

Py_DECREF(prefix);

return NULL;

}

tcl_library_path = PyUnicode_Concat(prefix, tcl_library_path);

Py_DECREF(prefix);

if (tcl_library_path == NULL) {

return NULL;

}

stat_return_value = _Py_stat(tcl_library_path, &stat_buf);

if (stat_return_value == -2) {

return NULL;

}

if (stat_return_value == -1) {

/* install location doesn't exist, reset errno and see if

we're a repository build */

errno = 0;

#ifdef Py_TCLTK_DIR

tcl_library_path = PyUnicode_FromString(

Py_TCLTK_DIR "\\lib\\tcl" TCL_VERSION);

if (tcl_library_path == NULL) {

return NULL;

}

stat_return_value = _Py_stat(tcl_library_path, &stat_buf);

if (stat_return_value == -2) {

return NULL;

}

if (stat_return_value == -1) {

/* tcltkDir for a repository build doesn't exist either,

reset errno and leave Tcl to its own devices */

errno = 0;

tcl_library_path = NULL;

}

#else

tcl_library_path = NULL;

#endif

}

already_checked = 1;

}

return tcl_library_path;

}

#endif /* MS_WINDOWS */

/* The threading situation is complicated. Tcl is not thread-safe, except

when configured with --enable-threads.

So we need to use a lock around all uses of Tcl. Previously, the

Python interpreter lock was used for this. However, this causes

problems when other Python threads need to run while Tcl is blocked

waiting for events.

To solve this problem, a separate lock for Tcl is introduced.

Holding it is incompatible with holding Python's interpreter lock.

The following four macros manipulate both locks together.

ENTER_TCL and LEAVE_TCL are brackets, just like

Py_BEGIN_ALLOW_THREADS and Py_END_ALLOW_THREADS. They should be

used whenever a call into Tcl is made that could call an event

handler, or otherwise affect the state of a Tcl interpreter. These

assume that the surrounding code has the Python interpreter lock;

inside the brackets, the Python interpreter lock has been released

and the lock for Tcl has been acquired.

Sometimes, it is necessary to have both the Python lock and the Tcl

lock. (For example, when transferring data from the Tcl

interpreter result to a Python string object.) This can be done by

using different macros to close the ENTER_TCL block: ENTER_OVERLAP

reacquires the Python lock (and restores the thread state) but

doesn't release the Tcl lock; LEAVE_OVERLAP_TCL releases the Tcl

lock.

By contrast, ENTER_PYTHON and LEAVE_PYTHON are used in Tcl event

handlers when the handler needs to use Python. Such event handlers

are entered while the lock for Tcl is held; the event handler

presumably needs to use Python. ENTER_PYTHON releases the lock for

Tcl and acquires the Python interpreter lock, restoring the

appropriate thread state, and LEAVE_PYTHON releases the Python

interpreter lock and re-acquires the lock for Tcl. It is okay for

ENTER_TCL/LEAVE_TCL pairs to be contained inside the code between

ENTER_PYTHON and LEAVE_PYTHON.

These locks expand to several statements and brackets; they should

not be used in branches of if statements and the like.

If Tcl is threaded, this approach won't work anymore. The Tcl

interpreter is only valid in the thread that created it, and all Tk

activity must happen in this thread, also. That means that the

mainloop must be invoked in the thread that created the

interpreter. Invoking commands from other threads is possible;

_tkinter will queue an event for the interpreter thread, which will

then execute the command and pass back the result. If the main

thread is not in the mainloop, and invoking commands causes an

exception; if the main loop is running but not processing events,

the command invocation will block.

In addition, for a threaded Tcl, a single global tcl_tstate won't

be sufficient anymore, since multiple Tcl interpreters may

simultaneously dispatch in different threads. So we use the Tcl TLS

API.

*/

static PyThread_type_lock tcl_lock = 0;

#ifdef TCL_THREADS

static Tcl_ThreadDataKey state_key;

typedef PyThreadState *ThreadSpecificData;

#define tcl_tstate \

(*(PyThreadState**)Tcl_GetThreadData(&state_key, sizeof(PyThreadState*)))

#else

static PyThreadState *tcl_tstate = NULL;

#endif

#define ENTER_TCL \

{ PyThreadState *tstate = PyThreadState_Get(); \

Py_BEGIN_ALLOW_THREADS \

if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); \

tcl_tstate = tstate;

#define LEAVE_TCL \

tcl_tstate = NULL; \

if(tcl_lock)PyThread_release_lock(tcl_lock); \

Py_END_ALLOW_THREADS}

#define ENTER_OVERLAP \

Py_END_ALLOW_THREADS

#define LEAVE_OVERLAP_TCL \

tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); }

#define ENTER_PYTHON \

{ PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \

if(tcl_lock) \

PyThread_release_lock(tcl_lock); \

PyEval_RestoreThread((tstate)); }

#define LEAVE_PYTHON \

{ PyThreadState *tstate = PyEval_SaveThread(); \

if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); \

tcl_tstate = tstate; }

#ifndef FREECAST

#define FREECAST (char *)

#endif

/**** Tkapp Object Declaration ****/

static PyObject *Tkapp_Type;

typedef struct {

PyObject_HEAD

Tcl_Interp *interp;

int wantobjects;

int threaded; /* True if tcl_platform[threaded] */

Tcl_ThreadId thread_id;

int dispatching;

PyObject *trace;

/* We cannot include tclInt.h, as this is internal.

So we cache interesting types here. */

const Tcl_ObjType *OldBooleanType;

const Tcl_ObjType *BooleanType;

const Tcl_ObjType *ByteArrayType;

const Tcl_ObjType *DoubleType;

const Tcl_ObjType *IntType;

const Tcl_ObjType *WideIntType;

const Tcl_ObjType *BignumType;

const Tcl_ObjType *ListType;

const Tcl_ObjType *StringType;

const Tcl_ObjType *UTF32StringType;

const Tcl_ObjType *PixelType;

} TkappObject;

#define TkappObject_CAST(op) ((TkappObject *)(op))

#define Tkapp_Interp(v) (TkappObject_CAST(v)->interp)

static inline int

check_tcl_appartment(TkappObject *app)

{

if (app->threaded && app->thread_id != Tcl_GetCurrentThread()) {

PyErr_SetString(PyExc_RuntimeError,

"Calling Tcl from different apartment");

return -1;

}

return 0;

}

#define CHECK_TCL_APPARTMENT(APP) \

do { \

if (check_tcl_appartment(APP) < 0) { \

return 0; \

} \

} while (0)

/**** Error Handling ****/

static PyObject *Tkinter_TclError;

static int quitMainLoop = 0;

static int errorInCmd = 0;

static PyObject *excInCmd;

static PyObject *Tkapp_UnicodeResult(TkappObject *);

static PyObject *

Tkinter_Error(TkappObject *self)

{

PyObject *res = Tkapp_UnicodeResult(self);

if (res != NULL) {

PyErr_SetObject(Tkinter_TclError, res);

Py_DECREF(res);

}

return NULL;

}

/**** Utils ****/

static int Tkinter_busywaitinterval = 20;

#ifndef MS_WINDOWS

/* Millisecond sleep() for Unix platforms. */

static void

Sleep(int milli)

{

/* XXX Too bad if you don't have select(). */

struct timeval t;

t.tv_sec = milli/1000;

t.tv_usec = (milli%1000) * 1000;

select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);

}

#endif /* MS_WINDOWS */

/* Wait up to 1s for the mainloop to come up. */

static int

WaitForMainloop(TkappObject* self)

{

int i;

for (i = 0; i < 10; i++) {

if (self->dispatching)

return 1;

Py_BEGIN_ALLOW_THREADS

Sleep(100);

Py_END_ALLOW_THREADS

}

if (self->dispatching)

return 1;

PyErr_SetString(PyExc_RuntimeError, "main thread is not in main loop");

return 0;

}

#define ARGSZ 64

static PyObject *

unicodeFromTclStringAndSize(const char *s, Py_ssize_t size)

{

PyObject *r = PyUnicode_DecodeUTF8(s, size, NULL);

if (r != NULL || !PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {

return r;

}

char *buf = NULL;

PyErr_Clear();

/* Tcl encodes null character as \xc0\x80.

https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8 */

if (memchr(s, '\xc0', size)) {

char *q;

const char *e = s + size;

q = buf = (char *)PyMem_Malloc(size);

if (buf == NULL) {

PyErr_NoMemory();

return NULL;

}

while (s != e) {

if (s + 1 != e && s[0] == '\xc0' && s[1] == '\x80') {

*q++ = '\0';

s += 2;

}

else

*q++ = *s++;

}

s = buf;

size = q - s;

}

r = PyUnicode_DecodeUTF8(s, size, "surrogateescape");

if (buf != NULL) {

PyMem_Free(buf);

}

if (r == NULL || PyUnicode_KIND(r) == PyUnicode_1BYTE_KIND) {

return r;

}

/* In CESU-8 non-BMP characters are represented as a surrogate pair,

like in UTF-16, and then each surrogate code point is encoded in UTF-8.

https://en.wikipedia.org/wiki/CESU-8 */

Py_ssize_t len = PyUnicode_GET_LENGTH(r);

Py_ssize_t i, j;

/* All encoded surrogate characters start with \xED. */

i = PyUnicode_FindChar(r, 0xdcED, 0, len, 1);

if (i == -2) {

Py_DECREF(r);

return NULL;

}

if (i == -1) {

return r;

}

Py_UCS4 *u = PyUnicode_AsUCS4Copy(r);

Py_DECREF(r);

if (u == NULL) {

return NULL;

}

Py_UCS4 ch;

for (j = i; i < len; i++, u[j++] = ch) {

Py_UCS4 ch1, ch2, ch3, high, low;

/* Low surrogates U+D800 - U+DBFF are encoded as

\xED\xA0\x80 - \xED\xAF\xBF. */

ch1 = ch = u[i];

if (ch1 != 0xdcED) continue;

ch2 = u[i + 1];

if (!(0xdcA0 <= ch2 && ch2 <= 0xdcAF)) continue;

ch3 = u[i + 2];

if (!(0xdc80 <= ch3 && ch3 <= 0xdcBF)) continue;

high = 0xD000 | ((ch2 & 0x3F) << 6) | (ch3 & 0x3F);

assert(Py_UNICODE_IS_HIGH_SURROGATE(high));

/* High surrogates U+DC00 - U+DFFF are encoded as

\xED\xB0\x80 - \xED\xBF\xBF. */

ch1 = u[i + 3];

if (ch1 != 0xdcED) continue;

ch2 = u[i + 4];

if (!(0xdcB0 <= ch2 && ch2 <= 0xdcBF)) continue;

ch3 = u[i + 5];

if (!(0xdc80 <= ch3 && ch3 <= 0xdcBF)) continue;

low = 0xD000 | ((ch2 & 0x3F) << 6) | (ch3 & 0x3F);

assert(Py_UNICODE_IS_HIGH_SURROGATE(high));

ch = Py_UNICODE_JOIN_SURROGATES(high, low);

i += 5;

}

r = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, u, j);

PyMem_Free(u);

return r;

}

static PyObject *

unicodeFromTclString(const char *s)

{

return unicodeFromTclStringAndSize(s, strlen(s));

}

static PyObject *

unicodeFromTclObj(TkappObject *tkapp, Tcl_Obj *value)

{

Tcl_Size len;

#if USE_TCL_UNICODE

if (value->typePtr != NULL && tkapp != NULL &&

(value->typePtr == tkapp->StringType ||

value->typePtr == tkapp->UTF32StringType))

{

int byteorder = NATIVE_BYTEORDER;

const Tcl_UniChar *u = Tcl_GetUnicodeFromObj(value, &len);

if (sizeof(Tcl_UniChar) == 2)

return PyUnicode_DecodeUTF16((const char *)u, len * 2,

"surrogatepass", &byteorder);

else if (sizeof(Tcl_UniChar) == 4)

return PyUnicode_DecodeUTF32((const char *)u, len * 4,

"surrogatepass", &byteorder);

else

Py_UNREACHABLE();

}

#endif /* USE_TCL_UNICODE */

const char *s = Tcl_GetStringFromObj(value, &len);

return unicodeFromTclStringAndSize(s, len);

}

/*[clinic input]

module _tkinter

class _tkinter.tkapp "TkappObject *" "&Tkapp_Type_spec"

class _tkinter.Tcl_Obj "PyTclObject *" "&PyTclObject_Type_spec"

class _tkinter.tktimertoken "TkttObject *" "&Tktt_Type_spec"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b1ebf15c162ee229]*/

/**** Tkapp Object ****/

#if TK_MAJOR_VERSION >= 9

int Tcl_AppInit(Tcl_Interp *);

#endif

#ifndef WITH_APPINIT

int

Tcl_AppInit(Tcl_Interp *interp)

{

const char * _tkinter_skip_tk_init;

if (Tcl_Init(interp) == TCL_ERROR) {

PySys_WriteStderr("Tcl_Init error: %s\n", Tcl_GetStringResult(interp));

return TCL_ERROR;

}

_tkinter_skip_tk_init = Tcl_GetVar(interp,

"_tkinter_skip_tk_init", TCL_GLOBAL_ONLY);

if (_tkinter_skip_tk_init != NULL &&

strcmp(_tkinter_skip_tk_init, "1") == 0) {

return TCL_OK;

}

if (Tk_Init(interp) == TCL_ERROR) {

PySys_WriteStderr("Tk_Init error: %s\n", Tcl_GetStringResult(interp));

return TCL_ERROR;

}

return TCL_OK;

}

#endif /* !WITH_APPINIT */

/* Initialize the Tk application; see the `main' function in

* `tkMain.c'.

*/

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

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

static TkappObject *

Tkapp_New(const char *screenName, const char *className,

int interactive, int wantobjects, int wantTk, int sync,

const char *use)

{

PyTypeObject *type = (PyTypeObject *)Tkapp_Type;

TkappObject *v;

char *argv0;

v = (TkappObject *)type->tp_alloc(type, 0);

if (v == NULL)

return NULL;

v->interp = Tcl_CreateInterp();

v->wantobjects = wantobjects;

v->threaded = Tcl_GetVar2Ex(v->interp, "tcl_platform", "threaded",

TCL_GLOBAL_ONLY) != NULL;

v->thread_id = Tcl_GetCurrentThread();

v->dispatching = 0;

v->trace = NULL;

#ifndef TCL_THREADS

if (v->threaded) {

PyErr_SetString(PyExc_RuntimeError,

"Tcl is threaded but _tkinter is not");

Py_DECREF(v);

return 0;

}

#endif

if (v->threaded && tcl_lock) {

/* If Tcl is threaded, we don't need the lock. */

PyThread_free_lock(tcl_lock);

tcl_lock = NULL;

}

v->OldBooleanType = Tcl_GetObjType("boolean");

{

Tcl_Obj *value;

int boolValue;

/* Tcl 8.5 "booleanString" type is not registered

and is renamed to "boolean" in Tcl 9.0.

Based on approach suggested at

https://core.tcl-lang.org/tcl/info/3bb3bcf2da5b */

value = Tcl_NewStringObj("true", -1);

Tcl_GetBooleanFromObj(NULL, value, &boolValue);

v->BooleanType = value->typePtr;

Tcl_DecrRefCount(value);

// "bytearray" type is not registered in Tcl 9.0

value = Tcl_NewByteArrayObj(NULL, 0);

v->ByteArrayType = value->typePtr;

Tcl_DecrRefCount(value);

}

v->DoubleType = Tcl_GetObjType("double");

/* TIP 484 suggests retrieving the "int" type without Tcl_GetObjType("int")

since it is no longer registered in Tcl 9.0. But even though Tcl 8.7

only uses the "wideInt" type on platforms with 32-bit long, it still has

a registered "int" type, which FromObj() should recognize just in case. */

v->IntType = Tcl_GetObjType("int");

if (v->IntType == NULL) {

Tcl_Obj *value = Tcl_NewIntObj(0);

v->IntType = value->typePtr;

Tcl_DecrRefCount(value);

}

v->WideIntType = Tcl_GetObjType("wideInt");

v->BignumType = Tcl_GetObjType("bignum");

v->ListType = Tcl_GetObjType("list");

v->StringType = Tcl_GetObjType("string");

v->UTF32StringType = Tcl_GetObjType("utf32string");

v->PixelType = Tcl_GetObjType("pixel");

/* Delete the 'exit' command, which can screw things up */

Tcl_DeleteCommand(v->interp, "exit");

if (screenName != NULL)

Tcl_SetVar2(v->interp, "env", "DISPLAY",

screenName, TCL_GLOBAL_ONLY);

if (interactive)

Tcl_SetVar(v->interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);

else

Tcl_SetVar(v->interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);

/* This is used to get the application class for Tk 4.1 and up */

argv0 = (char*)PyMem_Malloc(strlen(className) + 1);

if (!argv0) {

PyErr_NoMemory();

Py_DECREF(v);

return NULL;

}

strcpy(argv0, className);

if (Py_ISUPPER(argv0[0]))

argv0[0] = Py_TOLOWER(argv0[0]);

Tcl_SetVar(v->interp, "argv0", argv0, TCL_GLOBAL_ONLY);

PyMem_Free(argv0);

if (! wantTk) {

Tcl_SetVar(v->interp,

"_tkinter_skip_tk_init", "1", TCL_GLOBAL_ONLY);

}

/* some initial arguments need to be in argv */

if (sync || use) {

char *args;

Py_ssize_t len = 0;

if (sync)

len += sizeof "-sync";

if (use)

len += strlen(use) + sizeof "-use "; /* never overflows */

args = (char*)PyMem_Malloc(len);

if (!args) {

PyErr_NoMemory();

Py_DECREF(v);

return NULL;

}

args[0] = '\0';

if (sync)

strcat(args, "-sync");

if (use) {

if (sync)

strcat(args, " ");

strcat(args, "-use ");

strcat(args, use);

}

Tcl_SetVar(v->interp, "argv", args, TCL_GLOBAL_ONLY);

PyMem_Free(args);

}

#ifdef MS_WINDOWS

{

PyObject *str_path;

PyObject *utf8_path;

DWORD ret;

ret = GetEnvironmentVariableW(L"TCL_LIBRARY", NULL, 0);

if (!ret && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {

str_path = _get_tcl_lib_path();

if (str_path == NULL && PyErr_Occurred()) {

return NULL;

}

if (str_path != NULL) {

utf8_path = PyUnicode_AsUTF8String(str_path);

if (utf8_path == NULL) {

return NULL;

}

Tcl_SetVar(v->interp,

"tcl_library",

PyBytes_AS_STRING(utf8_path),

TCL_GLOBAL_ONLY);

Py_DECREF(utf8_path);

}

}

}

#endif

if (Tcl_AppInit(v->interp) != TCL_OK) {

PyObject *result = Tkinter_Error(v);

Py_DECREF((PyObject *)v);

return (TkappObject *)result;

}

EnableEventHook();

return v;

}

static void

Tkapp_ThreadSend(TkappObject *self, Tcl_Event *ev,

Tcl_Condition *cond, Tcl_Mutex *mutex)

{

Py_BEGIN_ALLOW_THREADS;

Tcl_MutexLock(mutex);

Tcl_ThreadQueueEvent(self->thread_id, ev, TCL_QUEUE_TAIL);

Tcl_ThreadAlert(self->thread_id);

Tcl_ConditionWait(cond, mutex, NULL);

Tcl_MutexUnlock(mutex);

Py_END_ALLOW_THREADS

}

/** Tcl Eval **/

typedef struct {

PyObject_HEAD

Tcl_Obj *value;

PyObject *string; /* This cannot cause cycles. */

} PyTclObject;

// TODO(picnixz): maybe assert that 'op' is really a PyTclObject (we might want

// to also add a FAST_CAST macro to bypass the check if needed).

#define PyTclObject_CAST(op) ((PyTclObject *)(op))

static PyObject *PyTclObject_Type;

#define PyTclObject_Check(v) Py_IS_TYPE(v, (PyTypeObject *)PyTclObject_Type)

static PyObject *

newPyTclObject(Tcl_Obj *arg)

{

PyTclObject *self;

self = PyObject_New(PyTclObject, (PyTypeObject *) PyTclObject_Type);

if (self == NULL)

return NULL;

Tcl_IncrRefCount(arg);

self->value = arg;

self->string = NULL;

return (PyObject*)self;

}

static void

PyTclObject_dealloc(PyObject *_self)

{

PyTclObject *self = PyTclObject_CAST(_self);

PyObject *tp = (PyObject *) Py_TYPE(self);

Tcl_DecrRefCount(self->value);

Py_XDECREF(self->string);

PyObject_Free(self);

Py_DECREF(tp);

}

/* Like _str, but create Unicode if necessary. */

PyDoc_STRVAR(PyTclObject_string__doc__,

"the string representation of this object, either as str or bytes");

static PyObject *

PyTclObject_string(PyObject *_self, void *Py_UNUSED(closure))

{

PyTclObject *self = PyTclObject_CAST(_self);

if (!self->string) {

self->string = unicodeFromTclObj(NULL, self->value);

if (!self->string)

return NULL;

}

return Py_NewRef(self->string);

}

static PyObject *

PyTclObject_str(PyObject *_self)

{

PyTclObject *self = PyTclObject_CAST(_self);

if (self->string) {

return Py_NewRef(self->string);

}

/* XXX Could cache result if it is non-ASCII. */

return unicodeFromTclObj(NULL, self->value);

}

static PyObject *

PyTclObject_repr(PyObject *_self)

{

PyTclObject *self = PyTclObject_CAST(_self);

PyObject *repr, *str = PyTclObject_str(_self);

if (str == NULL)

return NULL;

repr = PyUnicode_FromFormat("<%s object: %R>",

self->value->typePtr->name, str);

Py_DECREF(str);

return repr;

}

static PyObject *

PyTclObject_richcompare(PyObject *self, PyObject *other, int op)

{

int result;

/* neither argument should be NULL, unless something's gone wrong */

if (self == NULL || other == NULL) {

PyErr_BadInternalCall();

return NULL;

}

/* both arguments should be instances of PyTclObject */

if (!PyTclObject_Check(self) || !PyTclObject_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

if (self == other) {

/* fast path when self and other are identical */

result = 0;

}

else {

// 'self' and 'other' are known to be of correct type,

// so we can fast cast them (no need to use the macro)

result = strcmp(Tcl_GetString(((PyTclObject *)self)->value),

Tcl_GetString(((PyTclObject *)other)->value));

}

Py_RETURN_RICHCOMPARE(result, 0, op);

}

PyDoc_STRVAR(get_typename__doc__, "name of the Tcl type");

static PyObject*

get_typename(PyObject *self, void *Py_UNUSED(closure))

{

PyTclObject *obj = PyTclObject_CAST(self);

return unicodeFromTclString(obj->value->typePtr->name);

}

static PyGetSetDef PyTclObject_getsetlist[] = {

{"typename", get_typename, NULL, get_typename__doc__},

{"string", PyTclObject_string, NULL,

PyTclObject_string__doc__},

{0},

};

static PyType_Slot PyTclObject_Type_slots[] = {

{Py_tp_dealloc, PyTclObject_dealloc},

{Py_tp_repr, PyTclObject_repr},

{Py_tp_str, PyTclObject_str},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_richcompare, PyTclObject_richcompare},

{Py_tp_getset, PyTclObject_getsetlist},

{0, 0}

};

static PyType_Spec PyTclObject_Type_spec = {

.name = "_tkinter.Tcl_Obj",

.basicsize = sizeof(PyTclObject),

.flags = (

Py_TPFLAGS_DEFAULT

| Py_TPFLAGS_DISALLOW_INSTANTIATION

| Py_TPFLAGS_IMMUTABLETYPE

),

.slots = PyTclObject_Type_slots,

};

#if SIZE_MAX > INT_MAX

#define CHECK_STRING_LENGTH(s) do { \

if (s != NULL && strlen(s) >= INT_MAX) { \

PyErr_SetString(PyExc_OverflowError, "string is too long"); \

return NULL; \

} } while(0)

#else

#define CHECK_STRING_LENGTH(s)

#endif

static Tcl_Obj*

asBignumObj(PyObject *value)

{

Tcl_Obj *result;

int neg;

PyObject *hexstr;

const char *hexchars;

mp_int bigValue;

assert(PyLong_Check(value));

neg = _PyLong_IsNegative((PyLongObject *)value);

hexstr = _PyLong_Format(value, 16);

if (hexstr == NULL)

return NULL;

hexchars = PyUnicode_AsUTF8(hexstr);

if (hexchars == NULL) {

Py_DECREF(hexstr);

return NULL;

}

hexchars += neg + 2; /* skip sign and "0x" */

if (mp_init(&bigValue) != MP_OKAY ||

mp_read_radix(&bigValue, hexchars, 16) != MP_OKAY)

{

mp_clear(&bigValue);

Py_DECREF(hexstr);

PyErr_NoMemory();

return NULL;

}

Py_DECREF(hexstr);

bigValue.sign = neg ? MP_NEG : MP_ZPOS;

result = Tcl_NewBignumObj(&bigValue);

mp_clear(&bigValue);

if (result == NULL) {

PyErr_NoMemory();

return NULL;

}

return result;

}

static Tcl_Obj*

AsObj(PyObject *value)

{

Tcl_Obj *result;

if (PyBytes_Check(value)) {

if (PyBytes_GET_SIZE(value) >= INT_MAX) {

PyErr_SetString(PyExc_OverflowError, "bytes object is too long");

return NULL;

}

return Tcl_NewByteArrayObj((unsigned char *)PyBytes_AS_STRING(value),

(int)PyBytes_GET_SIZE(value));

}

if (PyBool_Check(value))

return Tcl_NewBooleanObj(PyObject_IsTrue(value));

if (PyLong_CheckExact(value)) {

int overflow;

long longValue;

Tcl_WideInt wideValue;

longValue = PyLong_AsLongAndOverflow(value, &overflow);

if (!overflow) {

return Tcl_NewLongObj(longValue);

}

/* If there is an overflow in the long conversion,

fall through to wideInt handling. */

if (_PyLong_AsByteArray((PyLongObject *)value,

(unsigned char *)(void *)&wideValue,

sizeof(wideValue),

PY_LITTLE_ENDIAN,