#include "Python.h"

#include <ctype.h>

#ifdef WITH_THREAD

#include "pythread.h"

#ifdef MS_WINDOWS

#include <windows.h>

#define CHECK_SIZE(size, elemsize) \

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

#define USE_COMPAT_CONST

#define TCL_THREADS

#ifdef TK_FRAMEWORK

#include <Tcl/tcl.h>

#include <Tk/tk.h>

#include <tcl.h>

#include <tk.h>

#include "tkinter.h"

#ifndef CONST84_RETURN

#define CONST84_RETURN

#undef CONST

#define CONST

#if TK_VERSION_HEX < 0x08030102

#error "Tk older than 8.3.1 not supported"

#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

#include <conio.h>

#define WAIT_FOR_STDIN

#ifdef WITH_THREAD

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 \

{ 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; }

#define CHECK_TCL_APPARTMENT \

#define ENTER_TCL

#define LEAVE_TCL

#define ENTER_OVERLAP

#define LEAVE_OVERLAP_TCL

#define ENTER_PYTHON

#define LEAVE_PYTHON

#define CHECK_TCL_APPARTMENT

#ifndef FREECAST

#define FREECAST (char *)

static PyTypeObject 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.

Tcl_ObjType *BooleanType;

Tcl_ObjType *ByteArrayType;

Tcl_ObjType *DoubleType;

Tcl_ObjType *IntType;

Tcl_ObjType *ListType;

Tcl_ObjType *ProcBodyType;

Tcl_ObjType *StringType;

} TkappObject;

#define Tkapp_Check(v) (Py_TYPE(v) == &Tkapp_Type)

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

#define Tkapp_Result(v) Tcl_GetStringResult(Tkapp_Interp(v))

#define DEBUG_REFCNT(v) (printf("DEBUG: id=%p, refcnt=%i\n", \

(void *) v, Py_REFCNT(v)))

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 *

Tkinter_Error(PyObject *v)

{

PyErr_SetString(Tkinter_TclError, Tkapp_Result(v));

return NULL;

}

static int Tkinter_busywaitinterval = 20;

#ifdef WITH_THREAD

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

}

#endif /* WITH_THREAD */

static char *

AsString(PyObject *value, PyObject *tmp)

{

if (PyBytes_Check(value))

return PyBytes_AsString(value);

else if (PyUnicode_Check(value))

return PyUnicode_AsUTF8(value);

else {

PyObject *v = PyObject_Str(value);

if (v == NULL)

return NULL;

if (PyList_Append(tmp, v) != 0) {

Py_DECREF(v);

return NULL;

}

Py_DECREF(v);

return PyUnicode_AsUTF8(v);

}

}

#define ARGSZ 64

static char *

Merge(PyObject *args)

{

PyObject *tmp = NULL;

char *argvStore[ARGSZ];

char **argv = NULL;

int fvStore[ARGSZ];

int *fv = NULL;

Py_ssize_t argc = 0, fvc = 0, i;

char *res = NULL;

if (!(tmp = PyList_New(0)))

return NULL;

argv = argvStore;

fv = fvStore;

if (args == NULL)

argc = 0;

else if (!PyTuple_Check(args)) {

argc = 1;

fv[0] = 0;

if (!(argv[0] = AsString(args, tmp)))

goto finally;

}

else {

argc = PyTuple_Size(args);

if (argc > ARGSZ) {

if (!CHECK_SIZE(argc, sizeof(char *))) {

PyErr_SetString(PyExc_OverflowError, "tuple is too long");

goto finally;

}

argv = (char **)ckalloc((size_t)argc * sizeof(char *));

fv = (int *)ckalloc((size_t)argc * sizeof(int));

if (argv == NULL || fv == NULL) {

PyErr_NoMemory();

goto finally;

}

}

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

PyObject *v = PyTuple_GetItem(args, i);

if (PyTuple_Check(v)) {

fv[i] = 1;

if (!(argv[i] = Merge(v)))

goto finally;

fvc++;

}

else if (v == Py_None) {

argc = i;

break;

}

else {

fv[i] = 0;

if (!(argv[i] = AsString(v, tmp)))

goto finally;

fvc++;

}

}

}

res = Tcl_Merge(argc, argv);

if (res == NULL)

PyErr_SetString(Tkinter_TclError, "merge failed");

finally:

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

if (fv[i]) {

ckfree(argv[i]);

}

if (argv != argvStore)

ckfree(FREECAST argv);

if (fv != fvStore)

ckfree(FREECAST fv);

Py_DECREF(tmp);

return res;

}

static PyObject *

unicodeFromTclStringAndSize(const char *s, Py_ssize_t size)

{

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

if (!r && PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {

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

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

char *buf, *q;

const char *e = s + size;

PyErr_Clear();

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

if (buf == NULL)

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, NULL);

PyMem_Free(buf);

}

}

return r;

}

static PyObject *

unicodeFromTclString(const char *s)

{

return unicodeFromTclStringAndSize(s, strlen(s));

}

static PyObject *

unicodeFromTclObj(Tcl_Obj *value)

{

int len;

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

return unicodeFromTclStringAndSize(s, len);

}

static PyObject *

Split(char *list)

{

int argc;

char **argv;

PyObject *v;

if (list == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {

/* Not a list.

return unicodeFromTclString(list);

}

if (argc == 0)

v = PyUnicode_FromString("");

else if (argc == 1)

v = unicodeFromTclString(argv[0]);

else if ((v = PyTuple_New(argc)) != NULL) {

int i;

PyObject *w;

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

if ((w = Split(argv[i])) == NULL) {

Py_DECREF(v);

v = NULL;

break;

}

PyTuple_SetItem(v, i, w);

}

}

Tcl_Free(FREECAST argv);

return v;

}

static PyObject *

SplitObj(PyObject *arg)

{

if (PyTuple_Check(arg)) {

int i, size;

PyObject *elem, *newelem, *result;

size = PyTuple_Size(arg);

result = NULL;

/* Recursively invoke SplitObj for all tuple items.

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

elem = PyTuple_GetItem(arg, i);

newelem = SplitObj(elem);

if (!newelem) {

Py_XDECREF(result);

return NULL;

}

if (!result) {

int k;

if (newelem == elem) {

Py_DECREF(newelem);

continue;

}

result = PyTuple_New(size);

if (!result)

return NULL;

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

elem = PyTuple_GetItem(arg, k);

Py_INCREF(elem);

PyTuple_SetItem(result, k, elem);

}

}

PyTuple_SetItem(result, i, newelem);

}

if (result)

return result;

/* Fall through, returning arg. */

}

else if (PyUnicode_Check(arg)) {

int argc;

char **argv;

char *list = PyUnicode_AsUTF8(arg);

if (list == NULL ||

Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {

Py_INCREF(arg);

return arg;

}

Tcl_Free(FREECAST argv);

if (argc > 1)

return Split(list);

/* Fall through, returning arg. */

}

else if (PyBytes_Check(arg)) {

int argc;

char **argv;

char *list = PyBytes_AsString(arg);

if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {

Py_INCREF(arg);

return arg;

}

Tcl_Free(FREECAST argv);

if (argc > 1)

return Split(PyBytes_AsString(arg));

/* Fall through, returning arg. */

}

Py_INCREF(arg);

return arg;

}

#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(char *screenName, char *className,

int interactive, int wantobjects, int wantTk, int sync, char *use)

{

TkappObject *v;

char *argv0;

v = PyObject_New(TkappObject, &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;

}

#ifdef WITH_THREAD

if (v->threaded && tcl_lock) {

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

PyThread_free_lock(tcl_lock);

tcl_lock = NULL;

}

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

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

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

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

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*)ckalloc(strlen(className) + 1);

if (!argv0) {

PyErr_NoMemory();

Py_DECREF(v);

return NULL;

}

strcpy(argv0, className);

if (Py_ISUPPER(Py_CHARMASK(argv0[0])))

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

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

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

int len = 0;

if (sync)

len += sizeof "-sync";

if (use)

len += strlen(use) + sizeof "-use ";

args = (char*)ckalloc(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);

ckfree(args);

}

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

PyObject *result = Tkinter_Error((PyObject *)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;

}

#ifdef WITH_THREAD

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 PyTypeObject PyTclObject_Type;

#define PyTclObject_Check(v) ((v)->ob_type == &PyTclObject_Type)

static PyObject *

newPyTclObject(Tcl_Obj *arg)

{

PyTclObject *self;

self = PyObject_New(PyTclObject, &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)

{

Tcl_DecrRefCount(self->value);

Py_XDECREF(self->string);

PyObject_Del(self);

}

static char*

PyTclObject_TclString(PyObject *self)

{

return Tcl_GetString(((PyTclObject*)self)->value);

}

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

{

if (self->string) {

Py_INCREF(self->string);

return self->string;

}

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

return unicodeFromTclObj(self->value);

}

static PyObject *

PyTclObject_repr(PyTclObject *self)

{

return PyUnicode_FromFormat("<%s object at %p>",

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

}

#define TEST_COND(cond) ((cond) ? Py_True : Py_False)

static PyObject *

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

{

int result;

PyObject *v;

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

v = Py_NotImplemented;

goto finished;

}

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

/* Convert return value to a Boolean */

switch (op) {

case Py_EQ:

v = TEST_COND(result == 0);

break;

case Py_NE:

v = TEST_COND(result != 0);

break;

case Py_LE:

v = TEST_COND(result <= 0);

break;

case Py_GE:

v = TEST_COND(result >= 0);

break;

case Py_LT:

v = TEST_COND(result < 0);

break;

case Py_GT:

v = TEST_COND(result > 0);

break;

default:

PyErr_BadArgument();

return NULL;

}

finished:

Py_INCREF(v);

return v;

}

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 PyTypeObject PyTclObject_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_tkinter.Tcl_Obj", /*tp_name*/

sizeof(PyTclObject), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor)PyTclObject_dealloc,/*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_reserved*/

(reprfunc)PyTclObject_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash*/

0, /*tp_call*/

(reprfunc)PyTclObject_str, /*tp_str*/

PyObject_GenericGetAttr, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT, /*tp_flags*/

0, /*tp_doc*/

0, /*tp_traverse*/

0, /*tp_clear*/

PyTclObject_richcompare, /*tp_richcompare*/

0, /*tp_weaklistoffset*/

0, /*tp_iter*/

0, /*tp_iternext*/

0, /*tp_methods*/

0, /*tp_members*/

PyTclObject_getsetlist, /*tp_getset*/

0, /*tp_base*/

0, /*tp_dict*/

0, /*tp_descr_get*/

0, /*tp_descr_set*/

0, /*tp_dictoffset*/

0, /*tp_init*/

0, /*tp_alloc*/

0, /*tp_new*/

0, /*tp_free*/

0, /*tp_is_gc*/

};

static Tcl_Obj*

AsObj(PyObject *value)

{

Tcl_Obj *result;

long longVal;

int overflow;

if (PyBytes_Check(value))

return Tcl_NewStringObj(PyBytes_AS_STRING(value),

PyBytes_GET_SIZE(value));

else if (PyBool_Check(value))

return Tcl_NewBooleanObj(PyObject_IsTrue(value));

else if (PyLong_CheckExact(value) &&

((longVal = PyLong_AsLongAndOverflow(value, &overflow)),

!overflow)) {

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

return Tcl_NewLongObj(longVal);

}

else if (PyFloat_Check(value))

return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));

else if (PyTuple_Check(value)) {

Tcl_Obj **argv;

Py_ssize_t size, i;

size = PyTuple_Size(value);

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

PyErr_SetString(PyExc_OverflowError, "tuple is too long");

return NULL;

}

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