#define PY_SSIZE_T_CLEAN

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include <ctype.h>

#ifdef MS_WINDOWS

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

#ifdef MS_WINDOWS

#include <windows.h>

#define CHECK_SIZE(size, elemsize) \

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

#define TCL_THREADS

#ifdef TK_FRAMEWORK

#include <Tcl/tcl.h>

#include <Tk/tk.h>

#include <tcl.h>

#include <tk.h>

#include "tkinter.h"

#if TK_HEX_VERSION < 0x0805020c

#error "Tk older than 8.5.12 not supported"

#include <tclTomMath.h>

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

#define HAVE_CREATEFILEHANDLER

#ifdef HAVE_CREATEFILEHANDLER

#ifndef TCL_UNIX_FD

# ifdef TCL_WIN_SOCKET

# define TCL_UNIX_FD (! TCL_WIN_SOCKET)

# define TCL_UNIX_FD 1

#ifdef MS_WINDOWS

#define FHANDLETYPE TCL_WIN_SOCKET

#define FHANDLETYPE TCL_UNIX_FD

#if FHANDLETYPE == TCL_UNIX_FD

#define WAIT_FOR_STDIN

#endif /* HAVE_CREATEFILEHANDLER */

#ifdef MS_WINDOWS

#define USE_TCL_UNICODE 1

#define USE_TCL_UNICODE 0

#if PY_LITTLE_ENDIAN

#define NATIVE_BYTEORDER -1

#define NATIVE_BYTEORDER 1

#ifdef MS_WINDOWS

#include <conio.h>

#define WAIT_FOR_STDIN

static PyObject *

_get_tcl_lib_path()

{

static PyObject *tcl_library_path = NULL;

static int already_checked = 0;

if (already_checked == 0) {

PyObject *prefix;

struct stat stat_buf;

int stat_return_value;

prefix = PyUnicode_FromWideChar(Py_GetPrefix(), -1);

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) {

return NULL;

}

tcl_library_path = PyUnicode_Concat(prefix, tcl_library_path);

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

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,

errno = 0;

tcl_library_path = NULL;

}

tcl_library_path = NULL;

}

already_checked = 1;

}

return tcl_library_path;

}

#endif /* MS_WINDOWS */

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*)))

static PyThreadState *tcl_tstate = NULL;

#define ENTER_TCL \

#define LEAVE_TCL \

#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 \

#define LEAVE_PYTHON \

#define CHECK_TCL_APPARTMENT \

#ifndef FREECAST

#define FREECAST (char *)

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;

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

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 *ProcBodyType;

const Tcl_ObjType *StringType;

} TkappObject;

#define Tkapp_Interp(v) (((TkappObject *) (v))->interp)

static PyObject *Tkinter_TclError;

static int quitMainLoop = 0;

static int errorInCmd = 0;

static PyObject *excInCmd;

static PyObject *valInCmd;

static PyObject *trbInCmd;

#ifdef TKINTER_PROTECT_LOADTK

static int tk_load_failed = 0;

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;

}

static int Tkinter_busywaitinterval = 20;

#ifndef MS_WINDOWS

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 */

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.

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,

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

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

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(Tcl_Obj *value)

{

int len;

#if USE_TCL_UNICODE

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();

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

return unicodeFromTclStringAndSize(s, len);

}

#ifndef WITH_APPINIT

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;

}

#ifdef TKINTER_PROTECT_LOADTK

if (tk_load_failed) {

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

return TCL_ERROR;

}

if (Tk_Init(interp) == TCL_ERROR) {

#ifdef TKINTER_PROTECT_LOADTK

tk_load_failed = 1;

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

return TCL_ERROR;

}

return TCL_OK;

}

#endif /* !WITH_APPINIT */

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)

{

TkappObject *v;

char *argv0;

v = PyObject_New(TkappObject, (PyTypeObject *) Tkapp_Type);

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;

#ifndef TCL_THREADS

if (v->threaded) {

PyErr_SetString(PyExc_RuntimeError,

"Tcl is threaded but _tkinter is not");

Py_DECREF(v);

return 0;

}

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");

v->BooleanType = Tcl_GetObjType("booleanString");

v->ByteArrayType = Tcl_GetObjType("bytearray");

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

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

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

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

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

v->ProcBodyType = Tcl_GetObjType("procbody");

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

/* 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);

}

#ifdef TKINTER_PROTECT_LOADTK

else if (tk_load_failed) {

Tcl_SetVar(v->interp,

"_tkinter_tk_failed", "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);

}

}

}

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

PyObject *result = Tkinter_Error(v);

#ifdef TKINTER_PROTECT_LOADTK

if (wantTk) {

const char *_tkinter_tk_failed;

_tkinter_tk_failed = Tcl_GetVar(v->interp,

"_tkinter_tk_failed", TCL_GLOBAL_ONLY);

if ( _tkinter_tk_failed != NULL &&

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

tk_load_failed = 1;

}

}

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

}

typedef struct {

PyObject_HEAD

Tcl_Obj *value;

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

} PyTclObject;

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(PyTclObject *self)

{

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

Tcl_DecrRefCount(self->value);

Py_XDECREF(self->string);

PyObject_Free(self);

Py_DECREF(tp);

}

PyDoc_STRVAR(PyTclObject_string__doc__,

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

static PyObject *

PyTclObject_string(PyTclObject *self, void *ignored)

{

if (!self->string) {

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

if (!self->string)

return NULL;

}

Py_INCREF(self->string);

return self->string;

}

static PyObject *

PyTclObject_str(PyTclObject *self)

{

if (self->string) {

Py_INCREF(self->string);

return self->string;

}

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

return unicodeFromTclObj(self->value);

}

static PyObject *

PyTclObject_repr(PyTclObject *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

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(PyTclObject* obj, void* ignored)

{

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

}

static PyGetSetDef PyTclObject_getsetlist[] = {

{"typename", (getter)get_typename, NULL, get_typename__doc__},

{"string", (getter)PyTclObject_string, NULL,

PyTclObject_string__doc__},

{0},

};

static PyType_Slot PyTclObject_Type_slots[] = {

{Py_tp_dealloc, (destructor)PyTclObject_dealloc},

{Py_tp_repr, (reprfunc)PyTclObject_repr},

{Py_tp_str, (reprfunc)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 = {

"_tkinter.Tcl_Obj",

sizeof(PyTclObject),

0,

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,

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)

#define CHECK_STRING_LENGTH(s)

static Tcl_Obj*

asBignumObj(PyObject *value)

{

Tcl_Obj *result;

int neg;

PyObject *hexstr;

const char *hexchars;

mp_int bigValue;

neg = Py_SIZE(value) < 0;

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" */

mp_init(&bigValue);

if (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;

#ifdef TCL_WIDE_INT_TYPE

Tcl_WideInt wideValue;

longValue = PyLong_AsLongAndOverflow(value, &overflow);

if (!overflow) {

return Tcl_NewLongObj(longValue);

}

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

#ifdef TCL_WIDE_INT_TYPE

if (_PyLong_AsByteArray((PyLongObject *)value,

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

sizeof(wideValue),

PY_LITTLE_ENDIAN,

/* signed */ 1) == 0) {

return Tcl_NewWideIntObj(wideValue);

}

PyErr_Clear();

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

return asBignumObj(value);

/* If there is no wideInt or bignum support,

}

if (PyFloat_Check(value))

return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));

if (PyTuple_Check(value) || PyList_Check(value)) {

Tcl_Obj **argv;

Py_ssize_t size, i;

size = PySequence_Fast_GET_SIZE(value);

if (size == 0)

return Tcl_NewListObj(0, NULL);

if (!CHECK_SIZE(size, sizeof(Tcl_Obj *))) {

PyErr_SetString(PyExc_OverflowError,

PyTuple_Check(value) ? "tuple is too long" :

"list is too long");

return NULL;

}

argv = (Tcl_Obj **) PyMem_Malloc(((size_t)size) * sizeof(Tcl_Obj *));

if (!argv) {

PyErr_NoMemory();

return NULL;

}

for (i = 0; i < size; i++)

argv[i] = AsObj(PySequence_Fast_GET_ITEM(value,i));

result = Tcl_NewListObj((int)size, argv);

PyMem_Free(argv);

return result;

}

if (PyUnicode_Check(value)) {

if (PyUnicode_READY(value) == -1)

return NULL;

Py_ssize_t size = PyUnicode_GET_LENGTH(value);

if (size == 0) {