LCOV - code coverage report
Current view: top level - Modules - _tkinter.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 41 1297 3.2 %
Date: 2023-03-20 08:15:36 Functions: 1 88 1.1 %
Branches: 24 914 2.6 %

           Branch data     Line data    Source code
       1                 :            : /***********************************************************
       2                 :            : Copyright (C) 1994 Steen Lumholt.
       3                 :            : 
       4                 :            :                         All Rights Reserved
       5                 :            : 
       6                 :            : ******************************************************************/
       7                 :            : 
       8                 :            : /* _tkinter.c -- Interface to libtk.a and libtcl.a. */
       9                 :            : 
      10                 :            : /* TCL/TK VERSION INFO:
      11                 :            : 
      12                 :            :     Only Tcl/Tk 8.5.12 and later are supported.  Older versions are not
      13                 :            :     supported. Use Python 3.10 or older if you cannot upgrade your
      14                 :            :     Tcl/Tk libraries.
      15                 :            : */
      16                 :            : 
      17                 :            : /* XXX Further speed-up ideas, involving Tcl 8.0 features:
      18                 :            : 
      19                 :            :    - Register a new Tcl type, "Python callable", which can be called more
      20                 :            :    efficiently and passed to Tcl_EvalObj() directly (if this is possible).
      21                 :            : 
      22                 :            : */
      23                 :            : 
      24                 :            : #define PY_SSIZE_T_CLEAN
      25                 :            : #ifndef Py_BUILD_CORE_BUILTIN
      26                 :            : #  define Py_BUILD_CORE_MODULE 1
      27                 :            : #endif
      28                 :            : 
      29                 :            : #include "Python.h"
      30                 :            : #include <ctype.h>
      31                 :            : #ifdef MS_WINDOWS
      32                 :            : #  include "pycore_fileutils.h"   // _Py_stat()
      33                 :            : #endif
      34                 :            : 
      35                 :            : #ifdef MS_WINDOWS
      36                 :            : #include <windows.h>
      37                 :            : #endif
      38                 :            : 
      39                 :            : #define CHECK_SIZE(size, elemsize) \
      40                 :            :     ((size_t)(size) <= Py_MIN((size_t)INT_MAX, UINT_MAX / (size_t)(elemsize)))
      41                 :            : 
      42                 :            : /* If Tcl is compiled for threads, we must also define TCL_THREAD. We define
      43                 :            :    it always; if Tcl is not threaded, the thread functions in
      44                 :            :    Tcl are empty.  */
      45                 :            : #define TCL_THREADS
      46                 :            : 
      47                 :            : #ifdef TK_FRAMEWORK
      48                 :            : #include <Tcl/tcl.h>
      49                 :            : #include <Tk/tk.h>
      50                 :            : #else
      51                 :            : #include <tcl.h>
      52                 :            : #include <tk.h>
      53                 :            : #endif
      54                 :            : 
      55                 :            : #include "tkinter.h"
      56                 :            : 
      57                 :            : #if TK_HEX_VERSION < 0x0805020c
      58                 :            : #error "Tk older than 8.5.12 not supported"
      59                 :            : #endif
      60                 :            : 
      61                 :            : #include <tclTomMath.h>
      62                 :            : 
      63                 :            : #if !(defined(MS_WINDOWS) || defined(__CYGWIN__))
      64                 :            : #define HAVE_CREATEFILEHANDLER
      65                 :            : #endif
      66                 :            : 
      67                 :            : #ifdef HAVE_CREATEFILEHANDLER
      68                 :            : 
      69                 :            : /* This bit is to ensure that TCL_UNIX_FD is defined and doesn't interfere
      70                 :            :    with the proper calculation of FHANDLETYPE == TCL_UNIX_FD below. */
      71                 :            : #ifndef TCL_UNIX_FD
      72                 :            : #  ifdef TCL_WIN_SOCKET
      73                 :            : #    define TCL_UNIX_FD (! TCL_WIN_SOCKET)
      74                 :            : #  else
      75                 :            : #    define TCL_UNIX_FD 1
      76                 :            : #  endif
      77                 :            : #endif
      78                 :            : 
      79                 :            : /* Tcl_CreateFileHandler() changed several times; these macros deal with the
      80                 :            :    messiness.  In Tcl 8.0 and later, it is not available on Windows (and on
      81                 :            :    Unix, only because Jack added it back); when available on Windows, it only
      82                 :            :    applies to sockets. */
      83                 :            : 
      84                 :            : #ifdef MS_WINDOWS
      85                 :            : #define FHANDLETYPE TCL_WIN_SOCKET
      86                 :            : #else
      87                 :            : #define FHANDLETYPE TCL_UNIX_FD
      88                 :            : #endif
      89                 :            : 
      90                 :            : /* If Tcl can wait for a Unix file descriptor, define the EventHook() routine
      91                 :            :    which uses this to handle Tcl events while the user is typing commands. */
      92                 :            : 
      93                 :            : #if FHANDLETYPE == TCL_UNIX_FD
      94                 :            : #define WAIT_FOR_STDIN
      95                 :            : #endif
      96                 :            : 
      97                 :            : #endif /* HAVE_CREATEFILEHANDLER */
      98                 :            : 
      99                 :            : /* Use OS native encoding for converting between Python strings and
     100                 :            :    Tcl objects.
     101                 :            :    On Windows use UTF-16 (or UTF-32 for 32-bit Tcl_UniChar) with the
     102                 :            :    "surrogatepass" error handler for converting to/from Tcl Unicode objects.
     103                 :            :    On Linux use UTF-8 with the "surrogateescape" error handler for converting
     104                 :            :    to/from Tcl String objects. */
     105                 :            : #ifdef MS_WINDOWS
     106                 :            : #define USE_TCL_UNICODE 1
     107                 :            : #else
     108                 :            : #define USE_TCL_UNICODE 0
     109                 :            : #endif
     110                 :            : 
     111                 :            : #if PY_LITTLE_ENDIAN
     112                 :            : #define NATIVE_BYTEORDER -1
     113                 :            : #else
     114                 :            : #define NATIVE_BYTEORDER 1
     115                 :            : #endif
     116                 :            : 
     117                 :            : #ifdef MS_WINDOWS
     118                 :            : #include <conio.h>
     119                 :            : #define WAIT_FOR_STDIN
     120                 :            : 
     121                 :            : static PyObject *
     122                 :            : _get_tcl_lib_path()
     123                 :            : {
     124                 :            :     static PyObject *tcl_library_path = NULL;
     125                 :            :     static int already_checked = 0;
     126                 :            : 
     127                 :            :     if (already_checked == 0) {
     128                 :            :         PyObject *prefix;
     129                 :            :         struct stat stat_buf;
     130                 :            :         int stat_return_value;
     131                 :            : 
     132                 :            :         prefix = PyUnicode_FromWideChar(Py_GetPrefix(), -1);
     133                 :            :         if (prefix == NULL) {
     134                 :            :             return NULL;
     135                 :            :         }
     136                 :            : 
     137                 :            :         /* Check expected location for an installed Python first */
     138                 :            :         tcl_library_path = PyUnicode_FromString("\\tcl\\tcl" TCL_VERSION);
     139                 :            :         if (tcl_library_path == NULL) {
     140                 :            :             return NULL;
     141                 :            :         }
     142                 :            :         tcl_library_path = PyUnicode_Concat(prefix, tcl_library_path);
     143                 :            :         if (tcl_library_path == NULL) {
     144                 :            :             return NULL;
     145                 :            :         }
     146                 :            :         stat_return_value = _Py_stat(tcl_library_path, &stat_buf);
     147                 :            :         if (stat_return_value == -2) {
     148                 :            :             return NULL;
     149                 :            :         }
     150                 :            :         if (stat_return_value == -1) {
     151                 :            :             /* install location doesn't exist, reset errno and see if
     152                 :            :                we're a repository build */
     153                 :            :             errno = 0;
     154                 :            : #ifdef Py_TCLTK_DIR
     155                 :            :             tcl_library_path = PyUnicode_FromString(
     156                 :            :                                     Py_TCLTK_DIR "\\lib\\tcl" TCL_VERSION);
     157                 :            :             if (tcl_library_path == NULL) {
     158                 :            :                 return NULL;
     159                 :            :             }
     160                 :            :             stat_return_value = _Py_stat(tcl_library_path, &stat_buf);
     161                 :            :             if (stat_return_value == -2) {
     162                 :            :                 return NULL;
     163                 :            :             }
     164                 :            :             if (stat_return_value == -1) {
     165                 :            :                 /* tcltkDir for a repository build doesn't exist either,
     166                 :            :                    reset errno and leave Tcl to its own devices */
     167                 :            :                 errno = 0;
     168                 :            :                 tcl_library_path = NULL;
     169                 :            :             }
     170                 :            : #else
     171                 :            :             tcl_library_path = NULL;
     172                 :            : #endif
     173                 :            :         }
     174                 :            :         already_checked = 1;
     175                 :            :     }
     176                 :            :     return tcl_library_path;
     177                 :            : }
     178                 :            : #endif /* MS_WINDOWS */
     179                 :            : 
     180                 :            : /* The threading situation is complicated.  Tcl is not thread-safe, except
     181                 :            :    when configured with --enable-threads.
     182                 :            : 
     183                 :            :    So we need to use a lock around all uses of Tcl.  Previously, the
     184                 :            :    Python interpreter lock was used for this.  However, this causes
     185                 :            :    problems when other Python threads need to run while Tcl is blocked
     186                 :            :    waiting for events.
     187                 :            : 
     188                 :            :    To solve this problem, a separate lock for Tcl is introduced.
     189                 :            :    Holding it is incompatible with holding Python's interpreter lock.
     190                 :            :    The following four macros manipulate both locks together.
     191                 :            : 
     192                 :            :    ENTER_TCL and LEAVE_TCL are brackets, just like
     193                 :            :    Py_BEGIN_ALLOW_THREADS and Py_END_ALLOW_THREADS.  They should be
     194                 :            :    used whenever a call into Tcl is made that could call an event
     195                 :            :    handler, or otherwise affect the state of a Tcl interpreter.  These
     196                 :            :    assume that the surrounding code has the Python interpreter lock;
     197                 :            :    inside the brackets, the Python interpreter lock has been released
     198                 :            :    and the lock for Tcl has been acquired.
     199                 :            : 
     200                 :            :    Sometimes, it is necessary to have both the Python lock and the Tcl
     201                 :            :    lock.  (For example, when transferring data from the Tcl
     202                 :            :    interpreter result to a Python string object.)  This can be done by
     203                 :            :    using different macros to close the ENTER_TCL block: ENTER_OVERLAP
     204                 :            :    reacquires the Python lock (and restores the thread state) but
     205                 :            :    doesn't release the Tcl lock; LEAVE_OVERLAP_TCL releases the Tcl
     206                 :            :    lock.
     207                 :            : 
     208                 :            :    By contrast, ENTER_PYTHON and LEAVE_PYTHON are used in Tcl event
     209                 :            :    handlers when the handler needs to use Python.  Such event handlers
     210                 :            :    are entered while the lock for Tcl is held; the event handler
     211                 :            :    presumably needs to use Python.  ENTER_PYTHON releases the lock for
     212                 :            :    Tcl and acquires the Python interpreter lock, restoring the
     213                 :            :    appropriate thread state, and LEAVE_PYTHON releases the Python
     214                 :            :    interpreter lock and re-acquires the lock for Tcl.  It is okay for
     215                 :            :    ENTER_TCL/LEAVE_TCL pairs to be contained inside the code between
     216                 :            :    ENTER_PYTHON and LEAVE_PYTHON.
     217                 :            : 
     218                 :            :    These locks expand to several statements and brackets; they should
     219                 :            :    not be used in branches of if statements and the like.
     220                 :            : 
     221                 :            :    If Tcl is threaded, this approach won't work anymore. The Tcl
     222                 :            :    interpreter is only valid in the thread that created it, and all Tk
     223                 :            :    activity must happen in this thread, also. That means that the
     224                 :            :    mainloop must be invoked in the thread that created the
     225                 :            :    interpreter. Invoking commands from other threads is possible;
     226                 :            :    _tkinter will queue an event for the interpreter thread, which will
     227                 :            :    then execute the command and pass back the result. If the main
     228                 :            :    thread is not in the mainloop, and invoking commands causes an
     229                 :            :    exception; if the main loop is running but not processing events,
     230                 :            :    the command invocation will block.
     231                 :            : 
     232                 :            :    In addition, for a threaded Tcl, a single global tcl_tstate won't
     233                 :            :    be sufficient anymore, since multiple Tcl interpreters may
     234                 :            :    simultaneously dispatch in different threads. So we use the Tcl TLS
     235                 :            :    API.
     236                 :            : 
     237                 :            : */
     238                 :            : 
     239                 :            : static PyThread_type_lock tcl_lock = 0;
     240                 :            : 
     241                 :            : #ifdef TCL_THREADS
     242                 :            : static Tcl_ThreadDataKey state_key;
     243                 :            : typedef PyThreadState *ThreadSpecificData;
     244                 :            : #define tcl_tstate \
     245                 :            :     (*(PyThreadState**)Tcl_GetThreadData(&state_key, sizeof(PyThreadState*)))
     246                 :            : #else
     247                 :            : static PyThreadState *tcl_tstate = NULL;
     248                 :            : #endif
     249                 :            : 
     250                 :            : #define ENTER_TCL \
     251                 :            :     { PyThreadState *tstate = PyThreadState_Get(); \
     252                 :            :       Py_BEGIN_ALLOW_THREADS \
     253                 :            :       if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); \
     254                 :            :       tcl_tstate = tstate;
     255                 :            : 
     256                 :            : #define LEAVE_TCL \
     257                 :            :     tcl_tstate = NULL; \
     258                 :            :     if(tcl_lock)PyThread_release_lock(tcl_lock); \
     259                 :            :     Py_END_ALLOW_THREADS}
     260                 :            : 
     261                 :            : #define ENTER_OVERLAP \
     262                 :            :     Py_END_ALLOW_THREADS
     263                 :            : 
     264                 :            : #define LEAVE_OVERLAP_TCL \
     265                 :            :     tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); }
     266                 :            : 
     267                 :            : #define ENTER_PYTHON \
     268                 :            :     { PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \
     269                 :            :       if(tcl_lock) \
     270                 :            :         PyThread_release_lock(tcl_lock); \
     271                 :            :       PyEval_RestoreThread((tstate)); }
     272                 :            : 
     273                 :            : #define LEAVE_PYTHON \
     274                 :            :     { PyThreadState *tstate = PyEval_SaveThread(); \
     275                 :            :       if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); \
     276                 :            :       tcl_tstate = tstate; }
     277                 :            : 
     278                 :            : #define CHECK_TCL_APPARTMENT \
     279                 :            :     if (((TkappObject *)self)->threaded && \
     280                 :            :         ((TkappObject *)self)->thread_id != Tcl_GetCurrentThread()) { \
     281                 :            :         PyErr_SetString(PyExc_RuntimeError, \
     282                 :            :                         "Calling Tcl from different apartment"); \
     283                 :            :         return 0; \
     284                 :            :     }
     285                 :            : 
     286                 :            : #ifndef FREECAST
     287                 :            : #define FREECAST (char *)
     288                 :            : #endif
     289                 :            : 
     290                 :            : /**** Tkapp Object Declaration ****/
     291                 :            : 
     292                 :            : static PyObject *Tkapp_Type;
     293                 :            : 
     294                 :            : typedef struct {
     295                 :            :     PyObject_HEAD
     296                 :            :     Tcl_Interp *interp;
     297                 :            :     int wantobjects;
     298                 :            :     int threaded; /* True if tcl_platform[threaded] */
     299                 :            :     Tcl_ThreadId thread_id;
     300                 :            :     int dispatching;
     301                 :            :     /* We cannot include tclInt.h, as this is internal.
     302                 :            :        So we cache interesting types here. */
     303                 :            :     const Tcl_ObjType *OldBooleanType;
     304                 :            :     const Tcl_ObjType *BooleanType;
     305                 :            :     const Tcl_ObjType *ByteArrayType;
     306                 :            :     const Tcl_ObjType *DoubleType;
     307                 :            :     const Tcl_ObjType *IntType;
     308                 :            :     const Tcl_ObjType *WideIntType;
     309                 :            :     const Tcl_ObjType *BignumType;
     310                 :            :     const Tcl_ObjType *ListType;
     311                 :            :     const Tcl_ObjType *ProcBodyType;
     312                 :            :     const Tcl_ObjType *StringType;
     313                 :            : } TkappObject;
     314                 :            : 
     315                 :            : #define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
     316                 :            : 
     317                 :            : 
     318                 :            : /**** Error Handling ****/
     319                 :            : 
     320                 :            : static PyObject *Tkinter_TclError;
     321                 :            : static int quitMainLoop = 0;
     322                 :            : static int errorInCmd = 0;
     323                 :            : static PyObject *excInCmd;
     324                 :            : 
     325                 :            : #ifdef TKINTER_PROTECT_LOADTK
     326                 :            : static int tk_load_failed = 0;
     327                 :            : #endif
     328                 :            : 
     329                 :            : 
     330                 :            : static PyObject *Tkapp_UnicodeResult(TkappObject *);
     331                 :            : 
     332                 :            : static PyObject *
     333                 :          0 : Tkinter_Error(TkappObject *self)
     334                 :            : {
     335                 :          0 :     PyObject *res = Tkapp_UnicodeResult(self);
     336         [ #  # ]:          0 :     if (res != NULL) {
     337                 :          0 :         PyErr_SetObject(Tkinter_TclError, res);
     338                 :          0 :         Py_DECREF(res);
     339                 :            :     }
     340                 :          0 :     return NULL;
     341                 :            : }
     342                 :            : 
     343                 :            : 
     344                 :            : 
     345                 :            : /**** Utils ****/
     346                 :            : 
     347                 :            : static int Tkinter_busywaitinterval = 20;
     348                 :            : 
     349                 :            : #ifndef MS_WINDOWS
     350                 :            : 
     351                 :            : /* Millisecond sleep() for Unix platforms. */
     352                 :            : 
     353                 :            : static void
     354                 :          0 : Sleep(int milli)
     355                 :            : {
     356                 :            :     /* XXX Too bad if you don't have select(). */
     357                 :            :     struct timeval t;
     358                 :          0 :     t.tv_sec = milli/1000;
     359                 :          0 :     t.tv_usec = (milli%1000) * 1000;
     360                 :          0 :     select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);
     361                 :          0 : }
     362                 :            : #endif /* MS_WINDOWS */
     363                 :            : 
     364                 :            : /* Wait up to 1s for the mainloop to come up. */
     365                 :            : 
     366                 :            : static int
     367                 :          0 : WaitForMainloop(TkappObject* self)
     368                 :            : {
     369                 :            :     int i;
     370         [ #  # ]:          0 :     for (i = 0; i < 10; i++) {
     371         [ #  # ]:          0 :         if (self->dispatching)
     372                 :          0 :             return 1;
     373                 :          0 :         Py_BEGIN_ALLOW_THREADS
     374                 :          0 :         Sleep(100);
     375                 :          0 :         Py_END_ALLOW_THREADS
     376                 :            :     }
     377         [ #  # ]:          0 :     if (self->dispatching)
     378                 :          0 :         return 1;
     379                 :          0 :     PyErr_SetString(PyExc_RuntimeError, "main thread is not in main loop");
     380                 :          0 :     return 0;
     381                 :            : }
     382                 :            : 
     383                 :            : 
     384                 :            : 
     385                 :            : #define ARGSZ 64
     386                 :            : 
     387                 :            : 
     388                 :            : 
     389                 :            : static PyObject *
     390                 :          0 : unicodeFromTclStringAndSize(const char *s, Py_ssize_t size)
     391                 :            : {
     392                 :          0 :     PyObject *r = PyUnicode_DecodeUTF8(s, size, NULL);
     393   [ #  #  #  # ]:          0 :     if (r != NULL || !PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
     394                 :          0 :         return r;
     395                 :            :     }
     396                 :            : 
     397                 :          0 :     char *buf = NULL;
     398                 :          0 :     PyErr_Clear();
     399                 :            :     /* Tcl encodes null character as \xc0\x80.
     400                 :            :        https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8 */
     401         [ #  # ]:          0 :     if (memchr(s, '\xc0', size)) {
     402                 :            :         char *q;
     403                 :          0 :         const char *e = s + size;
     404                 :          0 :         q = buf = (char *)PyMem_Malloc(size);
     405         [ #  # ]:          0 :         if (buf == NULL) {
     406                 :          0 :             PyErr_NoMemory();
     407                 :          0 :             return NULL;
     408                 :            :         }
     409         [ #  # ]:          0 :         while (s != e) {
     410   [ #  #  #  #  :          0 :             if (s + 1 != e && s[0] == '\xc0' && s[1] == '\x80') {
                   #  # ]
     411                 :          0 :                 *q++ = '\0';
     412                 :          0 :                 s += 2;
     413                 :            :             }
     414                 :            :             else
     415                 :          0 :                 *q++ = *s++;
     416                 :            :         }
     417                 :          0 :         s = buf;
     418                 :          0 :         size = q - s;
     419                 :            :     }
     420                 :          0 :     r = PyUnicode_DecodeUTF8(s, size, "surrogateescape");
     421         [ #  # ]:          0 :     if (buf != NULL) {
     422                 :          0 :         PyMem_Free(buf);
     423                 :            :     }
     424   [ #  #  #  # ]:          0 :     if (r == NULL || PyUnicode_KIND(r) == PyUnicode_1BYTE_KIND) {
     425                 :          0 :         return r;
     426                 :            :     }
     427                 :            : 
     428                 :            :     /* In CESU-8 non-BMP characters are represented as a surrogate pair,
     429                 :            :        like in UTF-16, and then each surrogate code point is encoded in UTF-8.
     430                 :            :        https://en.wikipedia.org/wiki/CESU-8 */
     431                 :          0 :     Py_ssize_t len = PyUnicode_GET_LENGTH(r);
     432                 :            :     Py_ssize_t i, j;
     433                 :            :     /* All encoded surrogate characters start with \xED. */
     434                 :          0 :     i = PyUnicode_FindChar(r, 0xdcED, 0, len, 1);
     435         [ #  # ]:          0 :     if (i == -2) {
     436                 :          0 :         Py_DECREF(r);
     437                 :          0 :         return NULL;
     438                 :            :     }
     439         [ #  # ]:          0 :     if (i == -1) {
     440                 :          0 :         return r;
     441                 :            :     }
     442                 :          0 :     Py_UCS4 *u = PyUnicode_AsUCS4Copy(r);
     443                 :          0 :     Py_DECREF(r);
     444         [ #  # ]:          0 :     if (u == NULL) {
     445                 :          0 :         return NULL;
     446                 :            :     }
     447                 :            :     Py_UCS4 ch;
     448         [ #  # ]:          0 :     for (j = i; i < len; i++, u[j++] = ch) {
     449                 :            :         Py_UCS4 ch1, ch2, ch3, high, low;
     450                 :            :         /* Low surrogates U+D800 - U+DBFF are encoded as
     451                 :            :            \xED\xA0\x80 - \xED\xAF\xBF. */
     452                 :          0 :         ch1 = ch = u[i];
     453         [ #  # ]:          0 :         if (ch1 != 0xdcED) continue;
     454                 :          0 :         ch2 = u[i + 1];
     455   [ #  #  #  # ]:          0 :         if (!(0xdcA0 <= ch2 && ch2 <= 0xdcAF)) continue;
     456                 :          0 :         ch3 = u[i + 2];
     457   [ #  #  #  # ]:          0 :         if (!(0xdc80 <= ch3 && ch3 <= 0xdcBF)) continue;
     458                 :          0 :         high = 0xD000 | ((ch2 & 0x3F) << 6) | (ch3 & 0x3F);
     459                 :            :         assert(Py_UNICODE_IS_HIGH_SURROGATE(high));
     460                 :            :         /* High surrogates U+DC00 - U+DFFF are encoded as
     461                 :            :            \xED\xB0\x80 - \xED\xBF\xBF. */
     462                 :          0 :         ch1 = u[i + 3];
     463         [ #  # ]:          0 :         if (ch1 != 0xdcED) continue;
     464                 :          0 :         ch2 = u[i + 4];
     465   [ #  #  #  # ]:          0 :         if (!(0xdcB0 <= ch2 && ch2 <= 0xdcBF)) continue;
     466                 :          0 :         ch3 = u[i + 5];
     467   [ #  #  #  # ]:          0 :         if (!(0xdc80 <= ch3 && ch3 <= 0xdcBF)) continue;
     468                 :          0 :         low = 0xD000 | ((ch2 & 0x3F) << 6) | (ch3 & 0x3F);
     469                 :            :         assert(Py_UNICODE_IS_HIGH_SURROGATE(high));
     470                 :          0 :         ch = Py_UNICODE_JOIN_SURROGATES(high, low);
     471                 :          0 :         i += 5;
     472                 :            :     }
     473                 :          0 :     r = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, u, j);
     474                 :          0 :     PyMem_Free(u);
     475                 :          0 :     return r;
     476                 :            : }
     477                 :            : 
     478                 :            : static PyObject *
     479                 :          0 : unicodeFromTclString(const char *s)
     480                 :            : {
     481                 :          0 :     return unicodeFromTclStringAndSize(s, strlen(s));
     482                 :            : }
     483                 :            : 
     484                 :            : static PyObject *
     485                 :          0 : unicodeFromTclObj(Tcl_Obj *value)
     486                 :            : {
     487                 :            :     int len;
     488                 :            : #if USE_TCL_UNICODE
     489                 :            :     int byteorder = NATIVE_BYTEORDER;
     490                 :            :     const Tcl_UniChar *u = Tcl_GetUnicodeFromObj(value, &len);
     491                 :            :     if (sizeof(Tcl_UniChar) == 2)
     492                 :            :         return PyUnicode_DecodeUTF16((const char *)u, len * 2,
     493                 :            :                                      "surrogatepass", &byteorder);
     494                 :            :     else if (sizeof(Tcl_UniChar) == 4)
     495                 :            :         return PyUnicode_DecodeUTF32((const char *)u, len * 4,
     496                 :            :                                      "surrogatepass", &byteorder);
     497                 :            :     else
     498                 :            :         Py_UNREACHABLE();
     499                 :            : #else
     500                 :          0 :     const char *s = Tcl_GetStringFromObj(value, &len);
     501                 :          0 :     return unicodeFromTclStringAndSize(s, len);
     502                 :            : #endif
     503                 :            : }
     504                 :            : 
     505                 :            : /*[clinic input]
     506                 :            : module _tkinter
     507                 :            : class _tkinter.tkapp "TkappObject *" "&Tkapp_Type_spec"
     508                 :            : class _tkinter.Tcl_Obj "PyTclObject *" "&PyTclObject_Type_spec"
     509                 :            : class _tkinter.tktimertoken "TkttObject *" "&Tktt_Type_spec"
     510                 :            : [clinic start generated code]*/
     511                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b1ebf15c162ee229]*/
     512                 :            : 
     513                 :            : /**** Tkapp Object ****/
     514                 :            : 
     515                 :            : #ifndef WITH_APPINIT
     516                 :            : int
     517                 :            : Tcl_AppInit(Tcl_Interp *interp)
     518                 :            : {
     519                 :            :     const char * _tkinter_skip_tk_init;
     520                 :            : 
     521                 :            :     if (Tcl_Init(interp) == TCL_ERROR) {
     522                 :            :         PySys_WriteStderr("Tcl_Init error: %s\n", Tcl_GetStringResult(interp));
     523                 :            :         return TCL_ERROR;
     524                 :            :     }
     525                 :            : 
     526                 :            :     _tkinter_skip_tk_init = Tcl_GetVar(interp,
     527                 :            :                     "_tkinter_skip_tk_init", TCL_GLOBAL_ONLY);
     528                 :            :     if (_tkinter_skip_tk_init != NULL &&
     529                 :            :                     strcmp(_tkinter_skip_tk_init, "1") == 0) {
     530                 :            :         return TCL_OK;
     531                 :            :     }
     532                 :            : 
     533                 :            : #ifdef TKINTER_PROTECT_LOADTK
     534                 :            :     if (tk_load_failed) {
     535                 :            :         PySys_WriteStderr("Tk_Init error: %s\n", TKINTER_LOADTK_ERRMSG);
     536                 :            :         return TCL_ERROR;
     537                 :            :     }
     538                 :            : #endif
     539                 :            : 
     540                 :            :     if (Tk_Init(interp) == TCL_ERROR) {
     541                 :            : #ifdef TKINTER_PROTECT_LOADTK
     542                 :            :         tk_load_failed = 1;
     543                 :            : #endif
     544                 :            :         PySys_WriteStderr("Tk_Init error: %s\n", Tcl_GetStringResult(interp));
     545                 :            :         return TCL_ERROR;
     546                 :            :     }
     547                 :            : 
     548                 :            :     return TCL_OK;
     549                 :            : }
     550                 :            : #endif /* !WITH_APPINIT */
     551                 :            : 
     552                 :            : 
     553                 :            : 
     554                 :            : 
     555                 :            : /* Initialize the Tk application; see the `main' function in
     556                 :            :  * `tkMain.c'.
     557                 :            :  */
     558                 :            : 
     559                 :            : static void EnableEventHook(void); /* Forward */
     560                 :            : static void DisableEventHook(void); /* Forward */
     561                 :            : 
     562                 :            : static TkappObject *
     563                 :          0 : Tkapp_New(const char *screenName, const char *className,
     564                 :            :           int interactive, int wantobjects, int wantTk, int sync,
     565                 :            :           const char *use)
     566                 :            : {
     567                 :            :     TkappObject *v;
     568                 :            :     char *argv0;
     569                 :            : 
     570                 :          0 :     v = PyObject_New(TkappObject, (PyTypeObject *) Tkapp_Type);
     571         [ #  # ]:          0 :     if (v == NULL)
     572                 :          0 :         return NULL;
     573                 :            : 
     574                 :          0 :     v->interp = Tcl_CreateInterp();
     575                 :          0 :     v->wantobjects = wantobjects;
     576                 :          0 :     v->threaded = Tcl_GetVar2Ex(v->interp, "tcl_platform", "threaded",
     577                 :          0 :                                 TCL_GLOBAL_ONLY) != NULL;
     578                 :          0 :     v->thread_id = Tcl_GetCurrentThread();
     579                 :          0 :     v->dispatching = 0;
     580                 :            : 
     581                 :            : #ifndef TCL_THREADS
     582                 :            :     if (v->threaded) {
     583                 :            :         PyErr_SetString(PyExc_RuntimeError,
     584                 :            :                         "Tcl is threaded but _tkinter is not");
     585                 :            :         Py_DECREF(v);
     586                 :            :         return 0;
     587                 :            :     }
     588                 :            : #endif
     589   [ #  #  #  # ]:          0 :     if (v->threaded && tcl_lock) {
     590                 :            :         /* If Tcl is threaded, we don't need the lock. */
     591                 :          0 :         PyThread_free_lock(tcl_lock);
     592                 :          0 :         tcl_lock = NULL;
     593                 :            :     }
     594                 :            : 
     595                 :          0 :     v->OldBooleanType = Tcl_GetObjType("boolean");
     596                 :          0 :     v->BooleanType = Tcl_GetObjType("booleanString");
     597                 :          0 :     v->ByteArrayType = Tcl_GetObjType("bytearray");
     598                 :          0 :     v->DoubleType = Tcl_GetObjType("double");
     599                 :          0 :     v->IntType = Tcl_GetObjType("int");
     600                 :          0 :     v->WideIntType = Tcl_GetObjType("wideInt");
     601                 :          0 :     v->BignumType = Tcl_GetObjType("bignum");
     602                 :          0 :     v->ListType = Tcl_GetObjType("list");
     603                 :          0 :     v->ProcBodyType = Tcl_GetObjType("procbody");
     604                 :          0 :     v->StringType = Tcl_GetObjType("string");
     605                 :            : 
     606                 :            :     /* Delete the 'exit' command, which can screw things up */
     607                 :          0 :     Tcl_DeleteCommand(v->interp, "exit");
     608                 :            : 
     609         [ #  # ]:          0 :     if (screenName != NULL)
     610                 :          0 :         Tcl_SetVar2(v->interp, "env", "DISPLAY",
     611                 :            :                     screenName, TCL_GLOBAL_ONLY);
     612                 :            : 
     613         [ #  # ]:          0 :     if (interactive)
     614                 :          0 :         Tcl_SetVar(v->interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);
     615                 :            :     else
     616                 :          0 :         Tcl_SetVar(v->interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
     617                 :            : 
     618                 :            :     /* This is used to get the application class for Tk 4.1 and up */
     619                 :          0 :     argv0 = (char*)PyMem_Malloc(strlen(className) + 1);
     620         [ #  # ]:          0 :     if (!argv0) {
     621                 :          0 :         PyErr_NoMemory();
     622                 :          0 :         Py_DECREF(v);
     623                 :          0 :         return NULL;
     624                 :            :     }
     625                 :            : 
     626                 :          0 :     strcpy(argv0, className);
     627         [ #  # ]:          0 :     if (Py_ISUPPER(argv0[0]))
     628                 :          0 :         argv0[0] = Py_TOLOWER(argv0[0]);
     629                 :          0 :     Tcl_SetVar(v->interp, "argv0", argv0, TCL_GLOBAL_ONLY);
     630                 :          0 :     PyMem_Free(argv0);
     631                 :            : 
     632         [ #  # ]:          0 :     if (! wantTk) {
     633                 :          0 :         Tcl_SetVar(v->interp,
     634                 :            :                         "_tkinter_skip_tk_init", "1", TCL_GLOBAL_ONLY);
     635                 :            :     }
     636                 :            : #ifdef TKINTER_PROTECT_LOADTK
     637                 :            :     else if (tk_load_failed) {
     638                 :            :         Tcl_SetVar(v->interp,
     639                 :            :                         "_tkinter_tk_failed", "1", TCL_GLOBAL_ONLY);
     640                 :            :     }
     641                 :            : #endif
     642                 :            : 
     643                 :            :     /* some initial arguments need to be in argv */
     644   [ #  #  #  # ]:          0 :     if (sync || use) {
     645                 :            :         char *args;
     646                 :          0 :         Py_ssize_t len = 0;
     647                 :            : 
     648         [ #  # ]:          0 :         if (sync)
     649                 :          0 :             len += sizeof "-sync";
     650         [ #  # ]:          0 :         if (use)
     651                 :          0 :             len += strlen(use) + sizeof "-use ";  /* never overflows */
     652                 :            : 
     653                 :          0 :         args = (char*)PyMem_Malloc(len);
     654         [ #  # ]:          0 :         if (!args) {
     655                 :          0 :             PyErr_NoMemory();
     656                 :          0 :             Py_DECREF(v);
     657                 :          0 :             return NULL;
     658                 :            :         }
     659                 :            : 
     660                 :          0 :         args[0] = '\0';
     661         [ #  # ]:          0 :         if (sync)
     662                 :          0 :             strcat(args, "-sync");
     663         [ #  # ]:          0 :         if (use) {
     664         [ #  # ]:          0 :             if (sync)
     665                 :          0 :                 strcat(args, " ");
     666                 :          0 :             strcat(args, "-use ");
     667                 :          0 :             strcat(args, use);
     668                 :            :         }
     669                 :            : 
     670                 :          0 :         Tcl_SetVar(v->interp, "argv", args, TCL_GLOBAL_ONLY);
     671                 :          0 :         PyMem_Free(args);
     672                 :            :     }
     673                 :            : 
     674                 :            : #ifdef MS_WINDOWS
     675                 :            :     {
     676                 :            :         PyObject *str_path;
     677                 :            :         PyObject *utf8_path;
     678                 :            :         DWORD ret;
     679                 :            : 
     680                 :            :         ret = GetEnvironmentVariableW(L"TCL_LIBRARY", NULL, 0);
     681                 :            :         if (!ret && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
     682                 :            :             str_path = _get_tcl_lib_path();
     683                 :            :             if (str_path == NULL && PyErr_Occurred()) {
     684                 :            :                 return NULL;
     685                 :            :             }
     686                 :            :             if (str_path != NULL) {
     687                 :            :                 utf8_path = PyUnicode_AsUTF8String(str_path);
     688                 :            :                 if (utf8_path == NULL) {
     689                 :            :                     return NULL;
     690                 :            :                 }
     691                 :            :                 Tcl_SetVar(v->interp,
     692                 :            :                            "tcl_library",
     693                 :            :                            PyBytes_AS_STRING(utf8_path),
     694                 :            :                            TCL_GLOBAL_ONLY);
     695                 :            :                 Py_DECREF(utf8_path);
     696                 :            :             }
     697                 :            :         }
     698                 :            :     }
     699                 :            : #endif
     700                 :            : 
     701         [ #  # ]:          0 :     if (Tcl_AppInit(v->interp) != TCL_OK) {
     702                 :          0 :         PyObject *result = Tkinter_Error(v);
     703                 :            : #ifdef TKINTER_PROTECT_LOADTK
     704                 :            :         if (wantTk) {
     705                 :            :             const char *_tkinter_tk_failed;
     706                 :            :             _tkinter_tk_failed = Tcl_GetVar(v->interp,
     707                 :            :                             "_tkinter_tk_failed", TCL_GLOBAL_ONLY);
     708                 :            : 
     709                 :            :             if ( _tkinter_tk_failed != NULL &&
     710                 :            :                             strcmp(_tkinter_tk_failed, "1") == 0) {
     711                 :            :                 tk_load_failed = 1;
     712                 :            :             }
     713                 :            :         }
     714                 :            : #endif
     715                 :          0 :         Py_DECREF((PyObject *)v);
     716                 :          0 :         return (TkappObject *)result;
     717                 :            :     }
     718                 :            : 
     719                 :          0 :     EnableEventHook();
     720                 :            : 
     721                 :          0 :     return v;
     722                 :            : }
     723                 :            : 
     724                 :            : 
     725                 :            : static void
     726                 :          0 : Tkapp_ThreadSend(TkappObject *self, Tcl_Event *ev,
     727                 :            :                  Tcl_Condition *cond, Tcl_Mutex *mutex)
     728                 :            : {
     729                 :          0 :     Py_BEGIN_ALLOW_THREADS;
     730                 :          0 :     Tcl_MutexLock(mutex);
     731                 :          0 :     Tcl_ThreadQueueEvent(self->thread_id, ev, TCL_QUEUE_TAIL);
     732                 :          0 :     Tcl_ThreadAlert(self->thread_id);
     733                 :          0 :     Tcl_ConditionWait(cond, mutex, NULL);
     734                 :          0 :     Tcl_MutexUnlock(mutex);
     735                 :          0 :     Py_END_ALLOW_THREADS
     736                 :          0 : }
     737                 :            : 
     738                 :            : 
     739                 :            : /** Tcl Eval **/
     740                 :            : 
     741                 :            : typedef struct {
     742                 :            :     PyObject_HEAD
     743                 :            :     Tcl_Obj *value;
     744                 :            :     PyObject *string; /* This cannot cause cycles. */
     745                 :            : } PyTclObject;
     746                 :            : 
     747                 :            : static PyObject *PyTclObject_Type;
     748                 :            : #define PyTclObject_Check(v) Py_IS_TYPE(v, (PyTypeObject *) PyTclObject_Type)
     749                 :            : 
     750                 :            : static PyObject *
     751                 :          0 : newPyTclObject(Tcl_Obj *arg)
     752                 :            : {
     753                 :            :     PyTclObject *self;
     754                 :          0 :     self = PyObject_New(PyTclObject, (PyTypeObject *) PyTclObject_Type);
     755         [ #  # ]:          0 :     if (self == NULL)
     756                 :          0 :         return NULL;
     757                 :          0 :     Tcl_IncrRefCount(arg);
     758                 :          0 :     self->value = arg;
     759                 :          0 :     self->string = NULL;
     760                 :          0 :     return (PyObject*)self;
     761                 :            : }
     762                 :            : 
     763                 :            : static void
     764                 :          0 : PyTclObject_dealloc(PyTclObject *self)
     765                 :            : {
     766                 :          0 :     PyObject *tp = (PyObject *) Py_TYPE(self);
     767         [ #  # ]:          0 :     Tcl_DecrRefCount(self->value);
     768                 :          0 :     Py_XDECREF(self->string);
     769                 :          0 :     PyObject_Free(self);
     770                 :          0 :     Py_DECREF(tp);
     771                 :          0 : }
     772                 :            : 
     773                 :            : /* Like _str, but create Unicode if necessary. */
     774                 :            : PyDoc_STRVAR(PyTclObject_string__doc__,
     775                 :            : "the string representation of this object, either as str or bytes");
     776                 :            : 
     777                 :            : static PyObject *
     778                 :          0 : PyTclObject_string(PyTclObject *self, void *ignored)
     779                 :            : {
     780         [ #  # ]:          0 :     if (!self->string) {
     781                 :          0 :         self->string = unicodeFromTclObj(self->value);
     782         [ #  # ]:          0 :         if (!self->string)
     783                 :          0 :             return NULL;
     784                 :            :     }
     785                 :          0 :     return Py_NewRef(self->string);
     786                 :            : }
     787                 :            : 
     788                 :            : static PyObject *
     789                 :          0 : PyTclObject_str(PyTclObject *self)
     790                 :            : {
     791         [ #  # ]:          0 :     if (self->string) {
     792                 :          0 :         return Py_NewRef(self->string);
     793                 :            :     }
     794                 :            :     /* XXX Could cache result if it is non-ASCII. */
     795                 :          0 :     return unicodeFromTclObj(self->value);
     796                 :            : }
     797                 :            : 
     798                 :            : static PyObject *
     799                 :          0 : PyTclObject_repr(PyTclObject *self)
     800                 :            : {
     801                 :          0 :     PyObject *repr, *str = PyTclObject_str(self);
     802         [ #  # ]:          0 :     if (str == NULL)
     803                 :          0 :         return NULL;
     804                 :          0 :     repr = PyUnicode_FromFormat("<%s object: %R>",
     805                 :          0 :                                 self->value->typePtr->name, str);
     806                 :          0 :     Py_DECREF(str);
     807                 :          0 :     return repr;
     808                 :            : }
     809                 :            : 
     810                 :            : static PyObject *
     811                 :          0 : PyTclObject_richcompare(PyObject *self, PyObject *other, int op)
     812                 :            : {
     813                 :            :     int result;
     814                 :            : 
     815                 :            :     /* neither argument should be NULL, unless something's gone wrong */
     816   [ #  #  #  # ]:          0 :     if (self == NULL || other == NULL) {
     817                 :          0 :         PyErr_BadInternalCall();
     818                 :          0 :         return NULL;
     819                 :            :     }
     820                 :            : 
     821                 :            :     /* both arguments should be instances of PyTclObject */
     822   [ #  #  #  # ]:          0 :     if (!PyTclObject_Check(self) || !PyTclObject_Check(other)) {
     823                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
     824                 :            :     }
     825                 :            : 
     826         [ #  # ]:          0 :     if (self == other)
     827                 :            :         /* fast path when self and other are identical */
     828                 :          0 :         result = 0;
     829                 :            :     else
     830                 :          0 :         result = strcmp(Tcl_GetString(((PyTclObject *)self)->value),
     831                 :          0 :                         Tcl_GetString(((PyTclObject *)other)->value));
     832   [ #  #  #  #  :          0 :     Py_RETURN_RICHCOMPARE(result, 0, op);
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     833                 :            : }
     834                 :            : 
     835                 :            : PyDoc_STRVAR(get_typename__doc__, "name of the Tcl type");
     836                 :            : 
     837                 :            : static PyObject*
     838                 :          0 : get_typename(PyTclObject* obj, void* ignored)
     839                 :            : {
     840                 :          0 :     return unicodeFromTclString(obj->value->typePtr->name);
     841                 :            : }
     842                 :            : 
     843                 :            : 
     844                 :            : static PyGetSetDef PyTclObject_getsetlist[] = {
     845                 :            :     {"typename", (getter)get_typename, NULL, get_typename__doc__},
     846                 :            :     {"string", (getter)PyTclObject_string, NULL,
     847                 :            :      PyTclObject_string__doc__},
     848                 :            :     {0},
     849                 :            : };
     850                 :            : 
     851                 :            : static PyType_Slot PyTclObject_Type_slots[] = {
     852                 :            :     {Py_tp_dealloc, (destructor)PyTclObject_dealloc},
     853                 :            :     {Py_tp_repr, (reprfunc)PyTclObject_repr},
     854                 :            :     {Py_tp_str, (reprfunc)PyTclObject_str},
     855                 :            :     {Py_tp_getattro, PyObject_GenericGetAttr},
     856                 :            :     {Py_tp_richcompare, PyTclObject_richcompare},
     857                 :            :     {Py_tp_getset, PyTclObject_getsetlist},
     858                 :            :     {0, 0}
     859                 :            : };
     860                 :            : 
     861                 :            : static PyType_Spec PyTclObject_Type_spec = {
     862                 :            :     "_tkinter.Tcl_Obj",
     863                 :            :     sizeof(PyTclObject),
     864                 :            :     0,
     865                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
     866                 :            :     PyTclObject_Type_slots,
     867                 :            : };
     868                 :            : 
     869                 :            : 
     870                 :            : #if SIZE_MAX > INT_MAX
     871                 :            : #define CHECK_STRING_LENGTH(s) do {                                     \
     872                 :            :         if (s != NULL && strlen(s) >= INT_MAX) {                        \
     873                 :            :             PyErr_SetString(PyExc_OverflowError, "string is too long"); \
     874                 :            :             return NULL;                                                \
     875                 :            :         } } while(0)
     876                 :            : #else
     877                 :            : #define CHECK_STRING_LENGTH(s)
     878                 :            : #endif
     879                 :            : 
     880                 :            : static Tcl_Obj*
     881                 :          0 : asBignumObj(PyObject *value)
     882                 :            : {
     883                 :            :     Tcl_Obj *result;
     884                 :            :     int neg;
     885                 :            :     PyObject *hexstr;
     886                 :            :     const char *hexchars;
     887                 :            :     mp_int bigValue;
     888                 :            : 
     889                 :          0 :     neg = Py_SIZE(value) < 0;
     890                 :          0 :     hexstr = _PyLong_Format(value, 16);
     891         [ #  # ]:          0 :     if (hexstr == NULL)
     892                 :          0 :         return NULL;
     893                 :          0 :     hexchars = PyUnicode_AsUTF8(hexstr);
     894         [ #  # ]:          0 :     if (hexchars == NULL) {
     895                 :          0 :         Py_DECREF(hexstr);
     896                 :          0 :         return NULL;
     897                 :            :     }
     898                 :          0 :     hexchars += neg + 2; /* skip sign and "0x" */
     899                 :          0 :     mp_init(&bigValue);
     900         [ #  # ]:          0 :     if (mp_read_radix(&bigValue, hexchars, 16) != MP_OKAY) {
     901                 :          0 :         mp_clear(&bigValue);
     902                 :          0 :         Py_DECREF(hexstr);
     903                 :          0 :         PyErr_NoMemory();
     904                 :          0 :         return NULL;
     905                 :            :     }
     906                 :          0 :     Py_DECREF(hexstr);
     907                 :          0 :     bigValue.sign = neg ? MP_NEG : MP_ZPOS;
     908                 :          0 :     result = Tcl_NewBignumObj(&bigValue);
     909                 :          0 :     mp_clear(&bigValue);
     910         [ #  # ]:          0 :     if (result == NULL) {
     911                 :          0 :         PyErr_NoMemory();
     912                 :          0 :         return NULL;
     913                 :            :     }
     914                 :          0 :     return result;
     915                 :            : }
     916                 :            : 
     917                 :            : static Tcl_Obj*
     918                 :          0 : AsObj(PyObject *value)
     919                 :            : {
     920                 :            :     Tcl_Obj *result;
     921                 :            : 
     922         [ #  # ]:          0 :     if (PyBytes_Check(value)) {
     923         [ #  # ]:          0 :         if (PyBytes_GET_SIZE(value) >= INT_MAX) {
     924                 :          0 :             PyErr_SetString(PyExc_OverflowError, "bytes object is too long");
     925                 :          0 :             return NULL;
     926                 :            :         }
     927                 :          0 :         return Tcl_NewByteArrayObj((unsigned char *)PyBytes_AS_STRING(value),
     928                 :          0 :                                    (int)PyBytes_GET_SIZE(value));
     929                 :            :     }
     930                 :            : 
     931         [ #  # ]:          0 :     if (PyBool_Check(value))
     932                 :          0 :         return Tcl_NewBooleanObj(PyObject_IsTrue(value));
     933                 :            : 
     934         [ #  # ]:          0 :     if (PyLong_CheckExact(value)) {
     935                 :            :         int overflow;
     936                 :            :         long longValue;
     937                 :            : #ifdef TCL_WIDE_INT_TYPE
     938                 :            :         Tcl_WideInt wideValue;
     939                 :            : #endif
     940                 :          0 :         longValue = PyLong_AsLongAndOverflow(value, &overflow);
     941         [ #  # ]:          0 :         if (!overflow) {
     942                 :          0 :             return Tcl_NewLongObj(longValue);
     943                 :            :         }
     944                 :            :         /* If there is an overflow in the long conversion,
     945                 :            :            fall through to wideInt handling. */
     946                 :            : #ifdef TCL_WIDE_INT_TYPE
     947         [ #  # ]:          0 :         if (_PyLong_AsByteArray((PyLongObject *)value,
     948                 :            :                                 (unsigned char *)(void *)&wideValue,
     949                 :            :                                 sizeof(wideValue),
     950                 :            :                                 PY_LITTLE_ENDIAN,
     951                 :            :                                 /* signed */ 1) == 0) {
     952                 :          0 :             return Tcl_NewWideIntObj(wideValue);
     953                 :            :         }
     954                 :          0 :         PyErr_Clear();
     955                 :            : #endif
     956                 :            :         /* If there is an overflow in the wideInt conversion,
     957                 :            :            fall through to bignum handling. */
     958                 :          0 :         return asBignumObj(value);
     959                 :            :         /* If there is no wideInt or bignum support,
     960                 :            :            fall through to default object handling. */
     961                 :            :     }
     962                 :            : 
     963         [ #  # ]:          0 :     if (PyFloat_Check(value))
     964                 :          0 :         return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));
     965                 :            : 
     966   [ #  #  #  # ]:          0 :     if (PyTuple_Check(value) || PyList_Check(value)) {
     967                 :            :         Tcl_Obj **argv;
     968                 :            :         Py_ssize_t size, i;
     969                 :            : 
     970         [ #  # ]:          0 :         size = PySequence_Fast_GET_SIZE(value);
     971         [ #  # ]:          0 :         if (size == 0)
     972                 :          0 :             return Tcl_NewListObj(0, NULL);
     973         [ #  # ]:          0 :         if (!CHECK_SIZE(size, sizeof(Tcl_Obj *))) {
     974         [ #  # ]:          0 :             PyErr_SetString(PyExc_OverflowError,
     975                 :          0 :                             PyTuple_Check(value) ? "tuple is too long" :
     976                 :            :                                                    "list is too long");
     977                 :          0 :             return NULL;
     978                 :            :         }
     979                 :          0 :         argv = (Tcl_Obj **) PyMem_Malloc(((size_t)size) * sizeof(Tcl_Obj *));
     980         [ #  # ]:          0 :         if (!argv) {
     981                 :          0 :           PyErr_NoMemory();
     982                 :          0 :           return NULL;
     983                 :            :         }
     984         [ #  # ]:          0 :         for (i = 0; i < size; i++)
     985         [ #  # ]:          0 :           argv[i] = AsObj(PySequence_Fast_GET_ITEM(value,i));
     986                 :          0 :         result = Tcl_NewListObj((int)size, argv);
     987                 :          0 :         PyMem_Free(argv);
     988                 :          0 :         return result;
     989                 :            :     }
     990                 :            : 
     991         [ #  # ]:          0 :     if (PyUnicode_Check(value)) {
     992         [ #  # ]:          0 :         if (PyUnicode_READY(value) == -1)
     993                 :          0 :             return NULL;
     994                 :            : 
     995                 :          0 :         Py_ssize_t size = PyUnicode_GET_LENGTH(value);
     996         [ #  # ]:          0 :         if (size == 0) {
     997                 :          0 :             return Tcl_NewStringObj("", 0);
     998                 :            :         }
     999         [ #  # ]:          0 :         if (!CHECK_SIZE(size, sizeof(Tcl_UniChar))) {
    1000                 :          0 :             PyErr_SetString(PyExc_OverflowError, "string is too long");
    1001                 :          0 :             return NULL;
    1002                 :            :         }
    1003         [ #  # ]:          0 :         if (PyUnicode_IS_ASCII(value)) {
    1004                 :          0 :             return Tcl_NewStringObj((const char *)PyUnicode_DATA(value),
    1005                 :            :                                     (int)size);
    1006                 :            :         }
    1007                 :            : 
    1008                 :            :         PyObject *encoded;
    1009                 :            : #if USE_TCL_UNICODE
    1010                 :            :         if (sizeof(Tcl_UniChar) == 2)
    1011                 :            :             encoded = _PyUnicode_EncodeUTF16(value,
    1012                 :            :                     "surrogatepass", NATIVE_BYTEORDER);
    1013                 :            :         else if (sizeof(Tcl_UniChar) == 4)
    1014                 :            :             encoded = _PyUnicode_EncodeUTF32(value,
    1015                 :            :                     "surrogatepass", NATIVE_BYTEORDER);
    1016                 :            :         else
    1017                 :            :             Py_UNREACHABLE();
    1018                 :            : #else
    1019                 :          0 :         encoded = _PyUnicode_AsUTF8String(value, "surrogateescape");
    1020                 :            : #endif
    1021         [ #  # ]:          0 :         if (!encoded) {
    1022                 :          0 :             return NULL;
    1023                 :            :         }
    1024                 :          0 :         size = PyBytes_GET_SIZE(encoded);
    1025         [ #  # ]:          0 :         if (size > INT_MAX) {
    1026                 :          0 :             Py_DECREF(encoded);
    1027                 :          0 :             PyErr_SetString(PyExc_OverflowError, "string is too long");
    1028                 :          0 :             return NULL;
    1029                 :            :         }
    1030                 :            : #if USE_TCL_UNICODE
    1031                 :            :         result = Tcl_NewUnicodeObj((const Tcl_UniChar *)PyBytes_AS_STRING(encoded),
    1032                 :            :                                    (int)(size / sizeof(Tcl_UniChar)));
    1033                 :            : #else
    1034                 :          0 :         result = Tcl_NewStringObj(PyBytes_AS_STRING(encoded), (int)size);
    1035                 :            : #endif
    1036                 :          0 :         Py_DECREF(encoded);
    1037                 :          0 :         return result;
    1038                 :            :     }
    1039                 :            : 
    1040         [ #  # ]:          0 :     if (PyTclObject_Check(value)) {
    1041                 :          0 :         return ((PyTclObject*)value)->value;
    1042                 :            :     }
    1043                 :            : 
    1044                 :            :     {
    1045                 :          0 :         PyObject *v = PyObject_Str(value);
    1046         [ #  # ]:          0 :         if (!v)
    1047                 :          0 :             return 0;
    1048                 :          0 :         result = AsObj(v);
    1049                 :          0 :         Py_DECREF(v);
    1050                 :          0 :         return result;
    1051                 :            :     }
    1052                 :            : }
    1053                 :            : 
    1054                 :            : static PyObject *
    1055                 :          0 : fromBoolean(TkappObject *tkapp, Tcl_Obj *value)
    1056                 :            : {
    1057                 :            :     int boolValue;
    1058         [ #  # ]:          0 :     if (Tcl_GetBooleanFromObj(Tkapp_Interp(tkapp), value, &boolValue) == TCL_ERROR)
    1059                 :          0 :         return Tkinter_Error(tkapp);
    1060                 :          0 :     return PyBool_FromLong(boolValue);
    1061                 :            : }
    1062                 :            : 
    1063                 :            : static PyObject*
    1064                 :          0 : fromWideIntObj(TkappObject *tkapp, Tcl_Obj *value)
    1065                 :            : {
    1066                 :            :         Tcl_WideInt wideValue;
    1067         [ #  # ]:          0 :         if (Tcl_GetWideIntFromObj(Tkapp_Interp(tkapp), value, &wideValue) == TCL_OK) {
    1068                 :            :             if (sizeof(wideValue) <= SIZEOF_LONG_LONG)
    1069                 :          0 :                 return PyLong_FromLongLong(wideValue);
    1070                 :            :             return _PyLong_FromByteArray((unsigned char *)(void *)&wideValue,
    1071                 :            :                                          sizeof(wideValue),
    1072                 :            :                                          PY_LITTLE_ENDIAN,
    1073                 :            :                                          /* signed */ 1);
    1074                 :            :         }
    1075                 :          0 :         return NULL;
    1076                 :            : }
    1077                 :            : 
    1078                 :            : static PyObject*
    1079                 :          0 : fromBignumObj(TkappObject *tkapp, Tcl_Obj *value)
    1080                 :            : {
    1081                 :            :     mp_int bigValue;
    1082                 :            :     unsigned long numBytes;
    1083                 :            :     unsigned char *bytes;
    1084                 :            :     PyObject *res;
    1085                 :            : 
    1086         [ #  # ]:          0 :     if (Tcl_GetBignumFromObj(Tkapp_Interp(tkapp), value, &bigValue) != TCL_OK)
    1087                 :          0 :         return Tkinter_Error(tkapp);
    1088                 :          0 :     numBytes = mp_unsigned_bin_size(&bigValue);
    1089                 :          0 :     bytes = PyMem_Malloc(numBytes);
    1090         [ #  # ]:          0 :     if (bytes == NULL) {
    1091                 :          0 :         mp_clear(&bigValue);
    1092                 :          0 :         return PyErr_NoMemory();
    1093                 :            :     }
    1094         [ #  # ]:          0 :     if (mp_to_unsigned_bin_n(&bigValue, bytes,
    1095                 :            :                                 &numBytes) != MP_OKAY) {
    1096                 :          0 :         mp_clear(&bigValue);
    1097                 :          0 :         PyMem_Free(bytes);
    1098                 :          0 :         return PyErr_NoMemory();
    1099                 :            :     }
    1100                 :          0 :     res = _PyLong_FromByteArray(bytes, numBytes,
    1101                 :            :                                 /* big-endian */ 0,
    1102                 :            :                                 /* unsigned */ 0);
    1103                 :          0 :     PyMem_Free(bytes);
    1104   [ #  #  #  # ]:          0 :     if (res != NULL && bigValue.sign == MP_NEG) {
    1105                 :          0 :         PyObject *res2 = PyNumber_Negative(res);
    1106                 :          0 :         Py_SETREF(res, res2);
    1107                 :            :     }
    1108                 :          0 :     mp_clear(&bigValue);
    1109                 :          0 :     return res;
    1110                 :            : }
    1111                 :            : 
    1112                 :            : static PyObject*
    1113                 :          0 : FromObj(TkappObject *tkapp, Tcl_Obj *value)
    1114                 :            : {
    1115                 :          0 :     PyObject *result = NULL;
    1116                 :          0 :     Tcl_Interp *interp = Tkapp_Interp(tkapp);
    1117                 :            : 
    1118         [ #  # ]:          0 :     if (value->typePtr == NULL) {
    1119                 :          0 :         return unicodeFromTclObj(value);
    1120                 :            :     }
    1121                 :            : 
    1122         [ #  # ]:          0 :     if (value->typePtr == tkapp->BooleanType ||
    1123         [ #  # ]:          0 :         value->typePtr == tkapp->OldBooleanType) {
    1124                 :          0 :         return fromBoolean(tkapp, value);
    1125                 :            :     }
    1126                 :            : 
    1127         [ #  # ]:          0 :     if (value->typePtr == tkapp->ByteArrayType) {
    1128                 :            :         int size;
    1129                 :          0 :         char *data = (char*)Tcl_GetByteArrayFromObj(value, &size);
    1130                 :          0 :         return PyBytes_FromStringAndSize(data, size);
    1131                 :            :     }
    1132                 :            : 
    1133         [ #  # ]:          0 :     if (value->typePtr == tkapp->DoubleType) {
    1134                 :          0 :         return PyFloat_FromDouble(value->internalRep.doubleValue);
    1135                 :            :     }
    1136                 :            : 
    1137         [ #  # ]:          0 :     if (value->typePtr == tkapp->IntType) {
    1138                 :            :         long longValue;
    1139         [ #  # ]:          0 :         if (Tcl_GetLongFromObj(interp, value, &longValue) == TCL_OK)
    1140                 :          0 :             return PyLong_FromLong(longValue);
    1141                 :            :         /* If there is an error in the long conversion,
    1142                 :            :            fall through to wideInt handling. */
    1143                 :            :     }
    1144                 :            : 
    1145         [ #  # ]:          0 :     if (value->typePtr == tkapp->IntType ||
    1146         [ #  # ]:          0 :         value->typePtr == tkapp->WideIntType) {
    1147                 :          0 :         result = fromWideIntObj(tkapp, value);
    1148   [ #  #  #  # ]:          0 :         if (result != NULL || PyErr_Occurred())
    1149                 :          0 :             return result;
    1150                 :          0 :         Tcl_ResetResult(interp);
    1151                 :            :         /* If there is an error in the wideInt conversion,
    1152                 :            :            fall through to bignum handling. */
    1153                 :            :     }
    1154                 :            : 
    1155         [ #  # ]:          0 :     if (value->typePtr == tkapp->IntType ||
    1156         [ #  # ]:          0 :         value->typePtr == tkapp->WideIntType ||
    1157         [ #  # ]:          0 :         value->typePtr == tkapp->BignumType) {
    1158                 :          0 :         return fromBignumObj(tkapp, value);
    1159                 :            :     }
    1160                 :            : 
    1161         [ #  # ]:          0 :     if (value->typePtr == tkapp->ListType) {
    1162                 :            :         int size;
    1163                 :            :         int i, status;
    1164                 :            :         PyObject *elem;
    1165                 :            :         Tcl_Obj *tcl_elem;
    1166                 :            : 
    1167                 :          0 :         status = Tcl_ListObjLength(interp, value, &size);
    1168         [ #  # ]:          0 :         if (status == TCL_ERROR)
    1169                 :          0 :             return Tkinter_Error(tkapp);
    1170                 :          0 :         result = PyTuple_New(size);
    1171         [ #  # ]:          0 :         if (!result)
    1172                 :          0 :             return NULL;
    1173         [ #  # ]:          0 :         for (i = 0; i < size; i++) {
    1174                 :          0 :             status = Tcl_ListObjIndex(interp, value, i, &tcl_elem);
    1175         [ #  # ]:          0 :             if (status == TCL_ERROR) {
    1176                 :          0 :                 Py_DECREF(result);
    1177                 :          0 :                 return Tkinter_Error(tkapp);
    1178                 :            :             }
    1179                 :          0 :             elem = FromObj(tkapp, tcl_elem);
    1180         [ #  # ]:          0 :             if (!elem) {
    1181                 :          0 :                 Py_DECREF(result);
    1182                 :          0 :                 return NULL;
    1183                 :            :             }
    1184                 :          0 :             PyTuple_SET_ITEM(result, i, elem);
    1185                 :            :         }
    1186                 :          0 :         return result;
    1187                 :            :     }
    1188                 :            : 
    1189                 :          0 :     if (value->typePtr == tkapp->ProcBodyType) {
    1190                 :            :       /* fall through: return tcl object. */
    1191                 :            :     }
    1192                 :            : 
    1193         [ #  # ]:          0 :     if (value->typePtr == tkapp->StringType) {
    1194                 :          0 :         return unicodeFromTclObj(value);
    1195                 :            :     }
    1196                 :            : 
    1197         [ #  # ]:          0 :     if (tkapp->BooleanType == NULL &&
    1198         [ #  # ]:          0 :         strcmp(value->typePtr->name, "booleanString") == 0) {
    1199                 :            :         /* booleanString type is not registered in Tcl */
    1200                 :          0 :         tkapp->BooleanType = value->typePtr;
    1201                 :          0 :         return fromBoolean(tkapp, value);
    1202                 :            :     }
    1203                 :            : 
    1204         [ #  # ]:          0 :     if (tkapp->BignumType == NULL &&
    1205         [ #  # ]:          0 :         strcmp(value->typePtr->name, "bignum") == 0) {
    1206                 :            :         /* bignum type is not registered in Tcl */
    1207                 :          0 :         tkapp->BignumType = value->typePtr;
    1208                 :          0 :         return fromBignumObj(tkapp, value);
    1209                 :            :     }
    1210                 :            : 
    1211                 :          0 :     return newPyTclObject(value);
    1212                 :            : }
    1213                 :            : 
    1214                 :            : /* This mutex synchronizes inter-thread command calls. */
    1215                 :            : TCL_DECLARE_MUTEX(call_mutex)
    1216                 :            : 
    1217                 :            : typedef struct Tkapp_CallEvent {
    1218                 :            :     Tcl_Event ev;            /* Must be first */
    1219                 :            :     TkappObject *self;
    1220                 :            :     PyObject *args;
    1221                 :            :     int flags;
    1222                 :            :     PyObject **res;
    1223                 :            :     PyObject **exc;
    1224                 :            :     Tcl_Condition *done;
    1225                 :            : } Tkapp_CallEvent;
    1226                 :            : 
    1227                 :            : void
    1228                 :          0 : Tkapp_CallDeallocArgs(Tcl_Obj** objv, Tcl_Obj** objStore, int objc)
    1229                 :            : {
    1230                 :            :     int i;
    1231         [ #  # ]:          0 :     for (i = 0; i < objc; i++)
    1232         [ #  # ]:          0 :         Tcl_DecrRefCount(objv[i]);
    1233         [ #  # ]:          0 :     if (objv != objStore)
    1234                 :          0 :         PyMem_Free(objv);
    1235                 :          0 : }
    1236                 :            : 
    1237                 :            : /* Convert Python objects to Tcl objects. This must happen in the
    1238                 :            :    interpreter thread, which may or may not be the calling thread. */
    1239                 :            : 
    1240                 :            : static Tcl_Obj**
    1241                 :          0 : Tkapp_CallArgs(PyObject *args, Tcl_Obj** objStore, int *pobjc)
    1242                 :            : {
    1243                 :          0 :     Tcl_Obj **objv = objStore;
    1244                 :          0 :     Py_ssize_t objc = 0, i;
    1245         [ #  # ]:          0 :     if (args == NULL)
    1246                 :            :         /* do nothing */;
    1247                 :            : 
    1248   [ #  #  #  # ]:          0 :     else if (!(PyTuple_Check(args) || PyList_Check(args))) {
    1249                 :          0 :         objv[0] = AsObj(args);
    1250         [ #  # ]:          0 :         if (objv[0] == NULL)
    1251                 :          0 :             goto finally;
    1252                 :          0 :         objc = 1;
    1253                 :          0 :         Tcl_IncrRefCount(objv[0]);
    1254                 :            :     }
    1255                 :            :     else {
    1256         [ #  # ]:          0 :         objc = PySequence_Fast_GET_SIZE(args);
    1257                 :            : 
    1258         [ #  # ]:          0 :         if (objc > ARGSZ) {
    1259         [ #  # ]:          0 :             if (!CHECK_SIZE(objc, sizeof(Tcl_Obj *))) {
    1260         [ #  # ]:          0 :                 PyErr_SetString(PyExc_OverflowError,
    1261                 :          0 :                                 PyTuple_Check(args) ? "tuple is too long" :
    1262                 :            :                                                       "list is too long");
    1263                 :          0 :                 return NULL;
    1264                 :            :             }
    1265                 :          0 :             objv = (Tcl_Obj **)PyMem_Malloc(((size_t)objc) * sizeof(Tcl_Obj *));
    1266         [ #  # ]:          0 :             if (objv == NULL) {
    1267                 :          0 :                 PyErr_NoMemory();
    1268                 :          0 :                 objc = 0;
    1269                 :          0 :                 goto finally;
    1270                 :            :             }
    1271                 :            :         }
    1272                 :            : 
    1273         [ #  # ]:          0 :         for (i = 0; i < objc; i++) {
    1274         [ #  # ]:          0 :             PyObject *v = PySequence_Fast_GET_ITEM(args, i);
    1275         [ #  # ]:          0 :             if (v == Py_None) {
    1276                 :          0 :                 objc = i;
    1277                 :          0 :                 break;
    1278                 :            :             }
    1279                 :          0 :             objv[i] = AsObj(v);
    1280         [ #  # ]:          0 :             if (!objv[i]) {
    1281                 :            :                 /* Reset objc, so it attempts to clear
    1282                 :            :                    objects only up to i. */
    1283                 :          0 :                 objc = i;
    1284                 :          0 :                 goto finally;
    1285                 :            :             }
    1286                 :          0 :             Tcl_IncrRefCount(objv[i]);
    1287                 :            :         }
    1288                 :            :     }
    1289                 :          0 :     *pobjc = (int)objc;
    1290                 :          0 :     return objv;
    1291                 :          0 : finally:
    1292                 :          0 :     Tkapp_CallDeallocArgs(objv, objStore, (int)objc);
    1293                 :          0 :     return NULL;
    1294                 :            : }
    1295                 :            : 
    1296                 :            : /* Convert the results of a command call into a Python string. */
    1297                 :            : 
    1298                 :            : static PyObject *
    1299                 :          0 : Tkapp_UnicodeResult(TkappObject *self)
    1300                 :            : {
    1301                 :          0 :     return unicodeFromTclObj(Tcl_GetObjResult(self->interp));
    1302                 :            : }
    1303                 :            : 
    1304                 :            : 
    1305                 :            : /* Convert the results of a command call into a Python objects. */
    1306                 :            : 
    1307                 :            : static PyObject *
    1308                 :          0 : Tkapp_ObjectResult(TkappObject *self)
    1309                 :            : {
    1310                 :          0 :     PyObject *res = NULL;
    1311                 :          0 :     Tcl_Obj *value = Tcl_GetObjResult(self->interp);
    1312         [ #  # ]:          0 :     if (self->wantobjects) {
    1313                 :            :         /* Not sure whether the IncrRef is necessary, but something
    1314                 :            :            may overwrite the interpreter result while we are
    1315                 :            :            converting it. */
    1316                 :          0 :         Tcl_IncrRefCount(value);
    1317                 :          0 :         res = FromObj(self, value);
    1318         [ #  # ]:          0 :         Tcl_DecrRefCount(value);
    1319                 :            :     } else {
    1320                 :          0 :         res = unicodeFromTclObj(value);
    1321                 :            :     }
    1322                 :          0 :     return res;
    1323                 :            : }
    1324                 :            : 
    1325                 :            : 
    1326                 :            : /* Tkapp_CallProc is the event procedure that is executed in the context of
    1327                 :            :    the Tcl interpreter thread. Initially, it holds the Tcl lock, and doesn't
    1328                 :            :    hold the Python lock. */
    1329                 :            : 
    1330                 :            : static int
    1331                 :          0 : Tkapp_CallProc(Tkapp_CallEvent *e, int flags)
    1332                 :            : {
    1333                 :            :     Tcl_Obj *objStore[ARGSZ];
    1334                 :            :     Tcl_Obj **objv;
    1335                 :            :     int objc;
    1336                 :            :     int i;
    1337         [ #  # ]:          0 :     ENTER_PYTHON
    1338                 :          0 :     objv = Tkapp_CallArgs(e->args, objStore, &objc);
    1339         [ #  # ]:          0 :     if (!objv) {
    1340                 :          0 :         *(e->exc) = PyErr_GetRaisedException();
    1341                 :          0 :         *(e->res) = NULL;
    1342                 :            :     }
    1343         [ #  # ]:          0 :     LEAVE_PYTHON
    1344         [ #  # ]:          0 :     if (!objv)
    1345                 :          0 :         goto done;
    1346                 :          0 :     i = Tcl_EvalObjv(e->self->interp, objc, objv, e->flags);
    1347         [ #  # ]:          0 :     ENTER_PYTHON
    1348         [ #  # ]:          0 :     if (i == TCL_ERROR) {
    1349                 :          0 :         *(e->res) = Tkinter_Error(e->self);
    1350                 :            :     }
    1351                 :            :     else {
    1352                 :          0 :         *(e->res) = Tkapp_ObjectResult(e->self);
    1353                 :            :     }
    1354         [ #  # ]:          0 :     if (*(e->res) == NULL) {
    1355                 :          0 :         *(e->exc) = PyErr_GetRaisedException();
    1356                 :            :     }
    1357         [ #  # ]:          0 :     LEAVE_PYTHON
    1358                 :            : 
    1359                 :          0 :     Tkapp_CallDeallocArgs(objv, objStore, objc);
    1360                 :          0 : done:
    1361                 :            :     /* Wake up calling thread. */
    1362                 :          0 :     Tcl_MutexLock(&call_mutex);
    1363                 :          0 :     Tcl_ConditionNotify(e->done);
    1364                 :          0 :     Tcl_MutexUnlock(&call_mutex);
    1365                 :          0 :     return 1;
    1366                 :            : }
    1367                 :            : 
    1368                 :            : 
    1369                 :            : /* This is the main entry point for calling a Tcl command.
    1370                 :            :    It supports three cases, with regard to threading:
    1371                 :            :    1. Tcl is not threaded: Must have the Tcl lock, then can invoke command in
    1372                 :            :       the context of the calling thread.
    1373                 :            :    2. Tcl is threaded, caller of the command is in the interpreter thread:
    1374                 :            :       Execute the command in the calling thread. Since the Tcl lock will
    1375                 :            :       not be used, we can merge that with case 1.
    1376                 :            :    3. Tcl is threaded, caller is in a different thread: Must queue an event to
    1377                 :            :       the interpreter thread. Allocation of Tcl objects needs to occur in the
    1378                 :            :       interpreter thread, so we ship the PyObject* args to the target thread,
    1379                 :            :       and perform processing there. */
    1380                 :            : 
    1381                 :            : static PyObject *
    1382                 :          0 : Tkapp_Call(PyObject *selfptr, PyObject *args)
    1383                 :            : {
    1384                 :            :     Tcl_Obj *objStore[ARGSZ];
    1385                 :          0 :     Tcl_Obj **objv = NULL;
    1386                 :            :     int objc, i;
    1387                 :          0 :     PyObject *res = NULL;
    1388                 :          0 :     TkappObject *self = (TkappObject*)selfptr;
    1389                 :          0 :     int flags = TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL;
    1390                 :            : 
    1391                 :            :     /* If args is a single tuple, replace with contents of tuple */
    1392         [ #  # ]:          0 :     if (PyTuple_GET_SIZE(args) == 1) {
    1393                 :          0 :         PyObject *item = PyTuple_GET_ITEM(args, 0);
    1394         [ #  # ]:          0 :         if (PyTuple_Check(item))
    1395                 :          0 :             args = item;
    1396                 :            :     }
    1397   [ #  #  #  # ]:          0 :     if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
    1398                 :            :         /* We cannot call the command directly. Instead, we must
    1399                 :            :            marshal the parameters to the interpreter thread. */
    1400                 :            :         Tkapp_CallEvent *ev;
    1401                 :          0 :         Tcl_Condition cond = NULL;
    1402                 :            :         PyObject *exc;
    1403         [ #  # ]:          0 :         if (!WaitForMainloop(self))
    1404                 :          0 :             return NULL;
    1405                 :          0 :         ev = (Tkapp_CallEvent*)attemptckalloc(sizeof(Tkapp_CallEvent));
    1406         [ #  # ]:          0 :         if (ev == NULL) {
    1407                 :          0 :             PyErr_NoMemory();
    1408                 :          0 :             return NULL;
    1409                 :            :         }
    1410                 :          0 :         ev->ev.proc = (Tcl_EventProc*)Tkapp_CallProc;
    1411                 :          0 :         ev->self = self;
    1412                 :          0 :         ev->args = args;
    1413                 :          0 :         ev->res = &res;
    1414                 :          0 :         ev->exc = &exc;
    1415                 :          0 :         ev->done = &cond;
    1416                 :            : 
    1417                 :          0 :         Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond, &call_mutex);
    1418                 :            : 
    1419         [ #  # ]:          0 :         if (res == NULL) {
    1420         [ #  # ]:          0 :             if (exc) {
    1421                 :          0 :                 PyErr_SetRaisedException(exc);
    1422                 :            :             }
    1423                 :            :             else {
    1424                 :          0 :                 PyErr_SetObject(Tkinter_TclError, exc);
    1425                 :            :             }
    1426                 :            :         }
    1427                 :          0 :         Tcl_ConditionFinalize(&cond);
    1428                 :            :     }
    1429                 :            :     else
    1430                 :            :     {
    1431                 :            : 
    1432                 :          0 :         objv = Tkapp_CallArgs(args, objStore, &objc);
    1433         [ #  # ]:          0 :         if (!objv)
    1434                 :          0 :             return NULL;
    1435                 :            : 
    1436         [ #  # ]:          0 :         ENTER_TCL
    1437                 :            : 
    1438                 :          0 :         i = Tcl_EvalObjv(self->interp, objc, objv, flags);
    1439                 :            : 
    1440                 :          0 :         ENTER_OVERLAP
    1441                 :            : 
    1442         [ #  # ]:          0 :         if (i == TCL_ERROR)
    1443                 :          0 :             Tkinter_Error(self);
    1444                 :            :         else
    1445                 :          0 :             res = Tkapp_ObjectResult(self);
    1446                 :            : 
    1447         [ #  # ]:          0 :         LEAVE_OVERLAP_TCL
    1448                 :            : 
    1449                 :          0 :         Tkapp_CallDeallocArgs(objv, objStore, objc);
    1450                 :            :     }
    1451                 :          0 :     return res;
    1452                 :            : }
    1453                 :            : 
    1454                 :            : 
    1455                 :            : /*[clinic input]
    1456                 :            : _tkinter.tkapp.eval
    1457                 :            : 
    1458                 :            :     script: str
    1459                 :            :     /
    1460                 :            : 
    1461                 :            : [clinic start generated code]*/
    1462                 :            : 
    1463                 :            : static PyObject *
    1464                 :          0 : _tkinter_tkapp_eval_impl(TkappObject *self, const char *script)
    1465                 :            : /*[clinic end generated code: output=24b79831f700dea0 input=481484123a455f22]*/
    1466                 :            : {
    1467                 :          0 :     PyObject *res = NULL;
    1468                 :            :     int err;
    1469                 :            : 
    1470   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(script);
    1471   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    1472                 :            : 
    1473         [ #  # ]:          0 :     ENTER_TCL
    1474                 :          0 :     err = Tcl_Eval(Tkapp_Interp(self), script);
    1475                 :          0 :     ENTER_OVERLAP
    1476         [ #  # ]:          0 :     if (err == TCL_ERROR)
    1477                 :          0 :         res = Tkinter_Error(self);
    1478                 :            :     else
    1479                 :          0 :         res = Tkapp_UnicodeResult(self);
    1480         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1481                 :          0 :     return res;
    1482                 :            : }
    1483                 :            : 
    1484                 :            : /*[clinic input]
    1485                 :            : _tkinter.tkapp.evalfile
    1486                 :            : 
    1487                 :            :     fileName: str
    1488                 :            :     /
    1489                 :            : 
    1490                 :            : [clinic start generated code]*/
    1491                 :            : 
    1492                 :            : static PyObject *
    1493                 :          0 : _tkinter_tkapp_evalfile_impl(TkappObject *self, const char *fileName)
    1494                 :            : /*[clinic end generated code: output=63be88dcee4f11d3 input=873ab707e5e947e1]*/
    1495                 :            : {
    1496                 :          0 :     PyObject *res = NULL;
    1497                 :            :     int err;
    1498                 :            : 
    1499   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(fileName);
    1500   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    1501                 :            : 
    1502         [ #  # ]:          0 :     ENTER_TCL
    1503                 :          0 :     err = Tcl_EvalFile(Tkapp_Interp(self), fileName);
    1504                 :          0 :     ENTER_OVERLAP
    1505         [ #  # ]:          0 :     if (err == TCL_ERROR)
    1506                 :          0 :         res = Tkinter_Error(self);
    1507                 :            :     else
    1508                 :          0 :         res = Tkapp_UnicodeResult(self);
    1509         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1510                 :          0 :     return res;
    1511                 :            : }
    1512                 :            : 
    1513                 :            : /*[clinic input]
    1514                 :            : _tkinter.tkapp.record
    1515                 :            : 
    1516                 :            :     script: str
    1517                 :            :     /
    1518                 :            : 
    1519                 :            : [clinic start generated code]*/
    1520                 :            : 
    1521                 :            : static PyObject *
    1522                 :          0 : _tkinter_tkapp_record_impl(TkappObject *self, const char *script)
    1523                 :            : /*[clinic end generated code: output=0ffe08a0061730df input=c0b0db5a21412cac]*/
    1524                 :            : {
    1525                 :          0 :     PyObject *res = NULL;
    1526                 :            :     int err;
    1527                 :            : 
    1528   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(script);
    1529   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    1530                 :            : 
    1531         [ #  # ]:          0 :     ENTER_TCL
    1532                 :          0 :     err = Tcl_RecordAndEval(Tkapp_Interp(self), script, TCL_NO_EVAL);
    1533                 :          0 :     ENTER_OVERLAP
    1534         [ #  # ]:          0 :     if (err == TCL_ERROR)
    1535                 :          0 :         res = Tkinter_Error(self);
    1536                 :            :     else
    1537                 :          0 :         res = Tkapp_UnicodeResult(self);
    1538         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1539                 :          0 :     return res;
    1540                 :            : }
    1541                 :            : 
    1542                 :            : /*[clinic input]
    1543                 :            : _tkinter.tkapp.adderrorinfo
    1544                 :            : 
    1545                 :            :     msg: str
    1546                 :            :     /
    1547                 :            : 
    1548                 :            : [clinic start generated code]*/
    1549                 :            : 
    1550                 :            : static PyObject *
    1551                 :          0 : _tkinter_tkapp_adderrorinfo_impl(TkappObject *self, const char *msg)
    1552                 :            : /*[clinic end generated code: output=52162eaca2ee53cb input=f4b37aec7c7e8c77]*/
    1553                 :            : {
    1554   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(msg);
    1555   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    1556                 :            : 
    1557         [ #  # ]:          0 :     ENTER_TCL
    1558                 :          0 :     Tcl_AddErrorInfo(Tkapp_Interp(self), msg);
    1559         [ #  # ]:          0 :     LEAVE_TCL
    1560                 :            : 
    1561                 :          0 :     Py_RETURN_NONE;
    1562                 :            : }
    1563                 :            : 
    1564                 :            : 
    1565                 :            : 
    1566                 :            : /** Tcl Variable **/
    1567                 :            : 
    1568                 :            : typedef PyObject* (*EventFunc)(TkappObject *, PyObject *, int);
    1569                 :            : 
    1570                 :            : TCL_DECLARE_MUTEX(var_mutex)
    1571                 :            : 
    1572                 :            : typedef struct VarEvent {
    1573                 :            :     Tcl_Event ev; /* must be first */
    1574                 :            :     TkappObject *self;
    1575                 :            :     PyObject *args;
    1576                 :            :     int flags;
    1577                 :            :     EventFunc func;
    1578                 :            :     PyObject **res;
    1579                 :            :     PyObject **exc;
    1580                 :            :     Tcl_Condition *cond;
    1581                 :            : } VarEvent;
    1582                 :            : 
    1583                 :            : /*[python]
    1584                 :            : 
    1585                 :            : class varname_converter(CConverter):
    1586                 :            :     type = 'const char *'
    1587                 :            :     converter = 'varname_converter'
    1588                 :            : 
    1589                 :            : [python]*/
    1590                 :            : /*[python checksum: da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
    1591                 :            : 
    1592                 :            : static int
    1593                 :          0 : varname_converter(PyObject *in, void *_out)
    1594                 :            : {
    1595                 :            :     const char *s;
    1596                 :          0 :     const char **out = (const char**)_out;
    1597         [ #  # ]:          0 :     if (PyBytes_Check(in)) {
    1598         [ #  # ]:          0 :         if (PyBytes_GET_SIZE(in) > INT_MAX) {
    1599                 :          0 :             PyErr_SetString(PyExc_OverflowError, "bytes object is too long");
    1600                 :          0 :             return 0;
    1601                 :            :         }
    1602                 :          0 :         s = PyBytes_AS_STRING(in);
    1603         [ #  # ]:          0 :         if (strlen(s) != (size_t)PyBytes_GET_SIZE(in)) {
    1604                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null byte");
    1605                 :          0 :             return 0;
    1606                 :            :         }
    1607                 :          0 :         *out = s;
    1608                 :          0 :         return 1;
    1609                 :            :     }
    1610         [ #  # ]:          0 :     if (PyUnicode_Check(in)) {
    1611                 :            :         Py_ssize_t size;
    1612                 :          0 :         s = PyUnicode_AsUTF8AndSize(in, &size);
    1613         [ #  # ]:          0 :         if (s == NULL) {
    1614                 :          0 :             return 0;
    1615                 :            :         }
    1616         [ #  # ]:          0 :         if (size > INT_MAX) {
    1617                 :          0 :             PyErr_SetString(PyExc_OverflowError, "string is too long");
    1618                 :          0 :             return 0;
    1619                 :            :         }
    1620         [ #  # ]:          0 :         if (strlen(s) != (size_t)size) {
    1621                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
    1622                 :          0 :             return 0;
    1623                 :            :         }
    1624                 :          0 :         *out = s;
    1625                 :          0 :         return 1;
    1626                 :            :     }
    1627         [ #  # ]:          0 :     if (PyTclObject_Check(in)) {
    1628                 :          0 :         *out = Tcl_GetString(((PyTclObject *)in)->value);
    1629                 :          0 :         return 1;
    1630                 :            :     }
    1631                 :          0 :     PyErr_Format(PyExc_TypeError,
    1632                 :            :                  "must be str, bytes or Tcl_Obj, not %.50s",
    1633                 :          0 :                  Py_TYPE(in)->tp_name);
    1634                 :          0 :     return 0;
    1635                 :            : }
    1636                 :            : 
    1637                 :            : 
    1638                 :            : static void
    1639                 :          0 : var_perform(VarEvent *ev)
    1640                 :            : {
    1641                 :          0 :     *(ev->res) = ev->func(ev->self, ev->args, ev->flags);
    1642         [ #  # ]:          0 :     if (!*(ev->res)) {
    1643                 :          0 :         *(ev->exc) = PyErr_GetRaisedException();;
    1644                 :            :     }
    1645                 :            : 
    1646                 :          0 : }
    1647                 :            : 
    1648                 :            : static int
    1649                 :          0 : var_proc(VarEvent* ev, int flags)
    1650                 :            : {
    1651         [ #  # ]:          0 :     ENTER_PYTHON
    1652                 :          0 :     var_perform(ev);
    1653                 :          0 :     Tcl_MutexLock(&var_mutex);
    1654                 :          0 :     Tcl_ConditionNotify(ev->cond);
    1655                 :          0 :     Tcl_MutexUnlock(&var_mutex);
    1656         [ #  # ]:          0 :     LEAVE_PYTHON
    1657                 :          0 :     return 1;
    1658                 :            : }
    1659                 :            : 
    1660                 :            : 
    1661                 :            : static PyObject*
    1662                 :          0 : var_invoke(EventFunc func, PyObject *selfptr, PyObject *args, int flags)
    1663                 :            : {
    1664                 :          0 :     TkappObject *self = (TkappObject*)selfptr;
    1665   [ #  #  #  # ]:          0 :     if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
    1666                 :            :         VarEvent *ev;
    1667                 :            :         PyObject *res, *exc;
    1668                 :          0 :         Tcl_Condition cond = NULL;
    1669                 :            : 
    1670                 :            :         /* The current thread is not the interpreter thread.  Marshal
    1671                 :            :            the call to the interpreter thread, then wait for
    1672                 :            :            completion. */
    1673         [ #  # ]:          0 :         if (!WaitForMainloop(self))
    1674                 :          0 :             return NULL;
    1675                 :            : 
    1676                 :          0 :         ev = (VarEvent*)attemptckalloc(sizeof(VarEvent));
    1677         [ #  # ]:          0 :         if (ev == NULL) {
    1678                 :          0 :             PyErr_NoMemory();
    1679                 :          0 :             return NULL;
    1680                 :            :         }
    1681                 :          0 :         ev->self = self;
    1682                 :          0 :         ev->args = args;
    1683                 :          0 :         ev->flags = flags;
    1684                 :          0 :         ev->func = func;
    1685                 :          0 :         ev->res = &res;
    1686                 :          0 :         ev->exc = &exc;
    1687                 :          0 :         ev->cond = &cond;
    1688                 :          0 :         ev->ev.proc = (Tcl_EventProc*)var_proc;
    1689                 :          0 :         Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond, &var_mutex);
    1690                 :          0 :         Tcl_ConditionFinalize(&cond);
    1691         [ #  # ]:          0 :         if (!res) {
    1692                 :          0 :             PyErr_SetObject((PyObject*)Py_TYPE(exc), exc);
    1693                 :          0 :             Py_DECREF(exc);
    1694                 :          0 :             return NULL;
    1695                 :            :         }
    1696                 :          0 :         return res;
    1697                 :            :     }
    1698                 :            :     /* Tcl is not threaded, or this is the interpreter thread. */
    1699                 :          0 :     return func(self, args, flags);
    1700                 :            : }
    1701                 :            : 
    1702                 :            : static PyObject *
    1703                 :          0 : SetVar(TkappObject *self, PyObject *args, int flags)
    1704                 :            : {
    1705                 :            :     const char *name1, *name2;
    1706                 :            :     PyObject *newValue;
    1707                 :          0 :     PyObject *res = NULL;
    1708                 :            :     Tcl_Obj *newval, *ok;
    1709                 :            : 
    1710      [ #  #  # ]:          0 :     switch (PyTuple_GET_SIZE(args)) {
    1711                 :          0 :     case 2:
    1712         [ #  # ]:          0 :         if (!PyArg_ParseTuple(args, "O&O:setvar",
    1713                 :            :                               varname_converter, &name1, &newValue))
    1714                 :          0 :             return NULL;
    1715                 :            :         /* XXX Acquire tcl lock??? */
    1716                 :          0 :         newval = AsObj(newValue);
    1717         [ #  # ]:          0 :         if (newval == NULL)
    1718                 :          0 :             return NULL;
    1719         [ #  # ]:          0 :         ENTER_TCL
    1720                 :          0 :         ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, NULL,
    1721                 :            :                            newval, flags);
    1722                 :          0 :         ENTER_OVERLAP
    1723         [ #  # ]:          0 :         if (!ok)
    1724                 :          0 :             Tkinter_Error(self);
    1725                 :            :         else {
    1726                 :          0 :             res = Py_NewRef(Py_None);
    1727                 :            :         }
    1728         [ #  # ]:          0 :         LEAVE_OVERLAP_TCL
    1729                 :          0 :         break;
    1730                 :          0 :     case 3:
    1731         [ #  # ]:          0 :         if (!PyArg_ParseTuple(args, "ssO:setvar",
    1732                 :            :                               &name1, &name2, &newValue))
    1733                 :          0 :             return NULL;
    1734   [ #  #  #  # ]:          0 :         CHECK_STRING_LENGTH(name1);
    1735   [ #  #  #  # ]:          0 :         CHECK_STRING_LENGTH(name2);
    1736                 :            :         /* XXX must hold tcl lock already??? */
    1737                 :          0 :         newval = AsObj(newValue);
    1738         [ #  # ]:          0 :         ENTER_TCL
    1739                 :          0 :         ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, name2, newval, flags);
    1740                 :          0 :         ENTER_OVERLAP
    1741         [ #  # ]:          0 :         if (!ok)
    1742                 :          0 :             Tkinter_Error(self);
    1743                 :            :         else {
    1744                 :          0 :             res = Py_NewRef(Py_None);
    1745                 :            :         }
    1746         [ #  # ]:          0 :         LEAVE_OVERLAP_TCL
    1747                 :          0 :         break;
    1748                 :          0 :     default:
    1749                 :          0 :         PyErr_SetString(PyExc_TypeError, "setvar requires 2 to 3 arguments");
    1750                 :          0 :         return NULL;
    1751                 :            :     }
    1752                 :          0 :     return res;
    1753                 :            : }
    1754                 :            : 
    1755                 :            : static PyObject *
    1756                 :          0 : Tkapp_SetVar(PyObject *self, PyObject *args)
    1757                 :            : {
    1758                 :          0 :     return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG);
    1759                 :            : }
    1760                 :            : 
    1761                 :            : static PyObject *
    1762                 :          0 : Tkapp_GlobalSetVar(PyObject *self, PyObject *args)
    1763                 :            : {
    1764                 :          0 :     return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
    1765                 :            : }
    1766                 :            : 
    1767                 :            : 
    1768                 :            : 
    1769                 :            : static PyObject *
    1770                 :          0 : GetVar(TkappObject *self, PyObject *args, int flags)
    1771                 :            : {
    1772                 :          0 :     const char *name1, *name2=NULL;
    1773                 :          0 :     PyObject *res = NULL;
    1774                 :            :     Tcl_Obj *tres;
    1775                 :            : 
    1776         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "O&|s:getvar",
    1777                 :            :                           varname_converter, &name1, &name2))
    1778                 :          0 :         return NULL;
    1779                 :            : 
    1780   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(name2);
    1781         [ #  # ]:          0 :     ENTER_TCL
    1782                 :          0 :     tres = Tcl_GetVar2Ex(Tkapp_Interp(self), name1, name2, flags);
    1783                 :          0 :     ENTER_OVERLAP
    1784         [ #  # ]:          0 :     if (tres == NULL) {
    1785                 :          0 :         Tkinter_Error(self);
    1786                 :            :     } else {
    1787         [ #  # ]:          0 :         if (self->wantobjects) {
    1788                 :          0 :             res = FromObj(self, tres);
    1789                 :            :         }
    1790                 :            :         else {
    1791                 :          0 :             res = unicodeFromTclObj(tres);
    1792                 :            :         }
    1793                 :            :     }
    1794         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1795                 :          0 :     return res;
    1796                 :            : }
    1797                 :            : 
    1798                 :            : static PyObject *
    1799                 :          0 : Tkapp_GetVar(PyObject *self, PyObject *args)
    1800                 :            : {
    1801                 :          0 :     return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG);
    1802                 :            : }
    1803                 :            : 
    1804                 :            : static PyObject *
    1805                 :          0 : Tkapp_GlobalGetVar(PyObject *self, PyObject *args)
    1806                 :            : {
    1807                 :          0 :     return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
    1808                 :            : }
    1809                 :            : 
    1810                 :            : 
    1811                 :            : 
    1812                 :            : static PyObject *
    1813                 :          0 : UnsetVar(TkappObject *self, PyObject *args, int flags)
    1814                 :            : {
    1815                 :          0 :     char *name1, *name2=NULL;
    1816                 :            :     int code;
    1817                 :          0 :     PyObject *res = NULL;
    1818                 :            : 
    1819         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "s|s:unsetvar", &name1, &name2))
    1820                 :          0 :         return NULL;
    1821                 :            : 
    1822   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(name1);
    1823   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(name2);
    1824         [ #  # ]:          0 :     ENTER_TCL
    1825                 :          0 :     code = Tcl_UnsetVar2(Tkapp_Interp(self), name1, name2, flags);
    1826                 :          0 :     ENTER_OVERLAP
    1827         [ #  # ]:          0 :     if (code == TCL_ERROR)
    1828                 :          0 :         res = Tkinter_Error(self);
    1829                 :            :     else {
    1830                 :          0 :         res = Py_NewRef(Py_None);
    1831                 :            :     }
    1832         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1833                 :          0 :     return res;
    1834                 :            : }
    1835                 :            : 
    1836                 :            : static PyObject *
    1837                 :          0 : Tkapp_UnsetVar(PyObject *self, PyObject *args)
    1838                 :            : {
    1839                 :          0 :     return var_invoke(UnsetVar, self, args, TCL_LEAVE_ERR_MSG);
    1840                 :            : }
    1841                 :            : 
    1842                 :            : static PyObject *
    1843                 :          0 : Tkapp_GlobalUnsetVar(PyObject *self, PyObject *args)
    1844                 :            : {
    1845                 :          0 :     return var_invoke(UnsetVar, self, args,
    1846                 :            :                       TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
    1847                 :            : }
    1848                 :            : 
    1849                 :            : 
    1850                 :            : 
    1851                 :            : /** Tcl to Python **/
    1852                 :            : 
    1853                 :            : /*[clinic input]
    1854                 :            : _tkinter.tkapp.getint
    1855                 :            : 
    1856                 :            :     arg: object
    1857                 :            :     /
    1858                 :            : 
    1859                 :            : [clinic start generated code]*/
    1860                 :            : 
    1861                 :            : static PyObject *
    1862                 :          0 : _tkinter_tkapp_getint(TkappObject *self, PyObject *arg)
    1863                 :            : /*[clinic end generated code: output=88cf293fae307cfe input=034026997c5b91f8]*/
    1864                 :            : {
    1865                 :            :     char *s;
    1866                 :            :     Tcl_Obj *value;
    1867                 :            :     PyObject *result;
    1868                 :            : 
    1869         [ #  # ]:          0 :     if (PyLong_Check(arg)) {
    1870                 :          0 :         return Py_NewRef(arg);
    1871                 :            :     }
    1872                 :            : 
    1873         [ #  # ]:          0 :     if (PyTclObject_Check(arg)) {
    1874                 :          0 :         value = ((PyTclObject*)arg)->value;
    1875                 :          0 :         Tcl_IncrRefCount(value);
    1876                 :            :     }
    1877                 :            :     else {
    1878         [ #  # ]:          0 :         if (!PyArg_Parse(arg, "s:getint", &s))
    1879                 :          0 :             return NULL;
    1880   [ #  #  #  # ]:          0 :         CHECK_STRING_LENGTH(s);
    1881                 :          0 :         value = Tcl_NewStringObj(s, -1);
    1882         [ #  # ]:          0 :         if (value == NULL)
    1883                 :          0 :             return Tkinter_Error(self);
    1884                 :            :     }
    1885                 :            :     /* Don't use Tcl_GetInt() because it returns ambiguous result for value
    1886                 :            :        in ranges -2**32..-2**31-1 and 2**31..2**32-1 (on 32-bit platform).
    1887                 :            : 
    1888                 :            :        Prefer bignum because Tcl_GetWideIntFromObj returns ambiguous result for
    1889                 :            :        value in ranges -2**64..-2**63-1 and 2**63..2**64-1 (on 32-bit platform).
    1890                 :            :      */
    1891                 :          0 :     result = fromBignumObj(self, value);
    1892         [ #  # ]:          0 :     Tcl_DecrRefCount(value);
    1893   [ #  #  #  # ]:          0 :     if (result != NULL || PyErr_Occurred())
    1894                 :          0 :         return result;
    1895                 :          0 :     return Tkinter_Error(self);
    1896                 :            : }
    1897                 :            : 
    1898                 :            : /*[clinic input]
    1899                 :            : _tkinter.tkapp.getdouble
    1900                 :            : 
    1901                 :            :     arg: object
    1902                 :            :     /
    1903                 :            : 
    1904                 :            : [clinic start generated code]*/
    1905                 :            : 
    1906                 :            : static PyObject *
    1907                 :          0 : _tkinter_tkapp_getdouble(TkappObject *self, PyObject *arg)
    1908                 :            : /*[clinic end generated code: output=c52b138bd8b956b9 input=22015729ce9ef7f8]*/
    1909                 :            : {
    1910                 :            :     char *s;
    1911                 :            :     double v;
    1912                 :            : 
    1913         [ #  # ]:          0 :     if (PyFloat_Check(arg)) {
    1914                 :          0 :         return Py_NewRef(arg);
    1915                 :            :     }
    1916                 :            : 
    1917         [ #  # ]:          0 :     if (PyNumber_Check(arg)) {
    1918                 :          0 :         return PyNumber_Float(arg);
    1919                 :            :     }
    1920                 :            : 
    1921         [ #  # ]:          0 :     if (PyTclObject_Check(arg)) {
    1922         [ #  # ]:          0 :         if (Tcl_GetDoubleFromObj(Tkapp_Interp(self),
    1923                 :            :                                  ((PyTclObject*)arg)->value,
    1924                 :            :                                  &v) == TCL_ERROR)
    1925                 :          0 :             return Tkinter_Error(self);
    1926                 :          0 :         return PyFloat_FromDouble(v);
    1927                 :            :     }
    1928                 :            : 
    1929         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "s:getdouble", &s))
    1930                 :          0 :         return NULL;
    1931   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    1932         [ #  # ]:          0 :     if (Tcl_GetDouble(Tkapp_Interp(self), s, &v) == TCL_ERROR)
    1933                 :          0 :         return Tkinter_Error(self);
    1934                 :          0 :     return PyFloat_FromDouble(v);
    1935                 :            : }
    1936                 :            : 
    1937                 :            : /*[clinic input]
    1938                 :            : _tkinter.tkapp.getboolean
    1939                 :            : 
    1940                 :            :     arg: object
    1941                 :            :     /
    1942                 :            : 
    1943                 :            : [clinic start generated code]*/
    1944                 :            : 
    1945                 :            : static PyObject *
    1946                 :          0 : _tkinter_tkapp_getboolean(TkappObject *self, PyObject *arg)
    1947                 :            : /*[clinic end generated code: output=726a9ae445821d91 input=7f11248ef8f8776e]*/
    1948                 :            : {
    1949                 :            :     char *s;
    1950                 :            :     int v;
    1951                 :            : 
    1952         [ #  # ]:          0 :     if (PyLong_Check(arg)) { /* int or bool */
    1953                 :          0 :         return PyBool_FromLong(Py_SIZE(arg) != 0);
    1954                 :            :     }
    1955                 :            : 
    1956         [ #  # ]:          0 :     if (PyTclObject_Check(arg)) {
    1957         [ #  # ]:          0 :         if (Tcl_GetBooleanFromObj(Tkapp_Interp(self),
    1958                 :            :                                   ((PyTclObject*)arg)->value,
    1959                 :            :                                   &v) == TCL_ERROR)
    1960                 :          0 :             return Tkinter_Error(self);
    1961                 :          0 :         return PyBool_FromLong(v);
    1962                 :            :     }
    1963                 :            : 
    1964         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "s:getboolean", &s))
    1965                 :          0 :         return NULL;
    1966   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    1967         [ #  # ]:          0 :     if (Tcl_GetBoolean(Tkapp_Interp(self), s, &v) == TCL_ERROR)
    1968                 :          0 :         return Tkinter_Error(self);
    1969                 :          0 :     return PyBool_FromLong(v);
    1970                 :            : }
    1971                 :            : 
    1972                 :            : /*[clinic input]
    1973                 :            : _tkinter.tkapp.exprstring
    1974                 :            : 
    1975                 :            :     s: str
    1976                 :            :     /
    1977                 :            : 
    1978                 :            : [clinic start generated code]*/
    1979                 :            : 
    1980                 :            : static PyObject *
    1981                 :          0 : _tkinter_tkapp_exprstring_impl(TkappObject *self, const char *s)
    1982                 :            : /*[clinic end generated code: output=beda323d3ed0abb1 input=fa78f751afb2f21b]*/
    1983                 :            : {
    1984                 :          0 :     PyObject *res = NULL;
    1985                 :            :     int retval;
    1986                 :            : 
    1987   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    1988   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    1989                 :            : 
    1990         [ #  # ]:          0 :     ENTER_TCL
    1991                 :          0 :     retval = Tcl_ExprString(Tkapp_Interp(self), s);
    1992                 :          0 :     ENTER_OVERLAP
    1993         [ #  # ]:          0 :     if (retval == TCL_ERROR)
    1994                 :          0 :         res = Tkinter_Error(self);
    1995                 :            :     else
    1996                 :          0 :         res = Tkapp_UnicodeResult(self);
    1997         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    1998                 :          0 :     return res;
    1999                 :            : }
    2000                 :            : 
    2001                 :            : /*[clinic input]
    2002                 :            : _tkinter.tkapp.exprlong
    2003                 :            : 
    2004                 :            :     s: str
    2005                 :            :     /
    2006                 :            : 
    2007                 :            : [clinic start generated code]*/
    2008                 :            : 
    2009                 :            : static PyObject *
    2010                 :          0 : _tkinter_tkapp_exprlong_impl(TkappObject *self, const char *s)
    2011                 :            : /*[clinic end generated code: output=5d6a46b63c6ebcf9 input=11bd7eee0c57b4dc]*/
    2012                 :            : {
    2013                 :          0 :     PyObject *res = NULL;
    2014                 :            :     int retval;
    2015                 :            :     long v;
    2016                 :            : 
    2017   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    2018   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2019                 :            : 
    2020         [ #  # ]:          0 :     ENTER_TCL
    2021                 :          0 :     retval = Tcl_ExprLong(Tkapp_Interp(self), s, &v);
    2022                 :          0 :     ENTER_OVERLAP
    2023         [ #  # ]:          0 :     if (retval == TCL_ERROR)
    2024                 :          0 :         res = Tkinter_Error(self);
    2025                 :            :     else
    2026                 :          0 :         res = PyLong_FromLong(v);
    2027         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    2028                 :          0 :     return res;
    2029                 :            : }
    2030                 :            : 
    2031                 :            : /*[clinic input]
    2032                 :            : _tkinter.tkapp.exprdouble
    2033                 :            : 
    2034                 :            :     s: str
    2035                 :            :     /
    2036                 :            : 
    2037                 :            : [clinic start generated code]*/
    2038                 :            : 
    2039                 :            : static PyObject *
    2040                 :          0 : _tkinter_tkapp_exprdouble_impl(TkappObject *self, const char *s)
    2041                 :            : /*[clinic end generated code: output=ff78df1081ea4158 input=ff02bc11798832d5]*/
    2042                 :            : {
    2043                 :          0 :     PyObject *res = NULL;
    2044                 :            :     double v;
    2045                 :            :     int retval;
    2046                 :            : 
    2047   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    2048   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2049         [ #  # ]:          0 :     ENTER_TCL
    2050                 :          0 :     retval = Tcl_ExprDouble(Tkapp_Interp(self), s, &v);
    2051                 :          0 :     ENTER_OVERLAP
    2052         [ #  # ]:          0 :     if (retval == TCL_ERROR)
    2053                 :          0 :         res = Tkinter_Error(self);
    2054                 :            :     else
    2055                 :          0 :         res = PyFloat_FromDouble(v);
    2056         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    2057                 :          0 :     return res;
    2058                 :            : }
    2059                 :            : 
    2060                 :            : /*[clinic input]
    2061                 :            : _tkinter.tkapp.exprboolean
    2062                 :            : 
    2063                 :            :     s: str
    2064                 :            :     /
    2065                 :            : 
    2066                 :            : [clinic start generated code]*/
    2067                 :            : 
    2068                 :            : static PyObject *
    2069                 :          0 : _tkinter_tkapp_exprboolean_impl(TkappObject *self, const char *s)
    2070                 :            : /*[clinic end generated code: output=8b28038c22887311 input=c8c66022bdb8d5d3]*/
    2071                 :            : {
    2072                 :          0 :     PyObject *res = NULL;
    2073                 :            :     int retval;
    2074                 :            :     int v;
    2075                 :            : 
    2076   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(s);
    2077   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2078         [ #  # ]:          0 :     ENTER_TCL
    2079                 :          0 :     retval = Tcl_ExprBoolean(Tkapp_Interp(self), s, &v);
    2080                 :          0 :     ENTER_OVERLAP
    2081         [ #  # ]:          0 :     if (retval == TCL_ERROR)
    2082                 :          0 :         res = Tkinter_Error(self);
    2083                 :            :     else
    2084                 :          0 :         res = PyLong_FromLong(v);
    2085         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    2086                 :          0 :     return res;
    2087                 :            : }
    2088                 :            : 
    2089                 :            : 
    2090                 :            : 
    2091                 :            : /*[clinic input]
    2092                 :            : _tkinter.tkapp.splitlist
    2093                 :            : 
    2094                 :            :     arg: object
    2095                 :            :     /
    2096                 :            : 
    2097                 :            : [clinic start generated code]*/
    2098                 :            : 
    2099                 :            : static PyObject *
    2100                 :          0 : _tkinter_tkapp_splitlist(TkappObject *self, PyObject *arg)
    2101                 :            : /*[clinic end generated code: output=13b51d34386d36fb input=2b2e13351e3c0b53]*/
    2102                 :            : {
    2103                 :            :     char *list;
    2104                 :            :     int argc;
    2105                 :            :     const char **argv;
    2106                 :            :     PyObject *v;
    2107                 :            :     int i;
    2108                 :            : 
    2109         [ #  # ]:          0 :     if (PyTclObject_Check(arg)) {
    2110                 :            :         int objc;
    2111                 :            :         Tcl_Obj **objv;
    2112         [ #  # ]:          0 :         if (Tcl_ListObjGetElements(Tkapp_Interp(self),
    2113                 :            :                                    ((PyTclObject*)arg)->value,
    2114                 :            :                                    &objc, &objv) == TCL_ERROR) {
    2115                 :          0 :             return Tkinter_Error(self);
    2116                 :            :         }
    2117         [ #  # ]:          0 :         if (!(v = PyTuple_New(objc)))
    2118                 :          0 :             return NULL;
    2119         [ #  # ]:          0 :         for (i = 0; i < objc; i++) {
    2120                 :          0 :             PyObject *s = FromObj(self, objv[i]);
    2121         [ #  # ]:          0 :             if (!s) {
    2122                 :          0 :                 Py_DECREF(v);
    2123                 :          0 :                 return NULL;
    2124                 :            :             }
    2125                 :          0 :             PyTuple_SET_ITEM(v, i, s);
    2126                 :            :         }
    2127                 :          0 :         return v;
    2128                 :            :     }
    2129         [ #  # ]:          0 :     if (PyTuple_Check(arg)) {
    2130                 :          0 :         return Py_NewRef(arg);
    2131                 :            :     }
    2132         [ #  # ]:          0 :     if (PyList_Check(arg)) {
    2133                 :          0 :         return PySequence_Tuple(arg);
    2134                 :            :     }
    2135                 :            : 
    2136         [ #  # ]:          0 :     if (!PyArg_Parse(arg, "et:splitlist", "utf-8", &list))
    2137                 :          0 :         return NULL;
    2138                 :            : 
    2139         [ #  # ]:          0 :     if (strlen(list) >= INT_MAX) {
    2140                 :          0 :         PyErr_SetString(PyExc_OverflowError, "string is too long");
    2141                 :          0 :         PyMem_Free(list);
    2142                 :          0 :         return NULL;
    2143                 :            :     }
    2144         [ #  # ]:          0 :     if (Tcl_SplitList(Tkapp_Interp(self), list,
    2145                 :            :                       &argc, &argv) == TCL_ERROR)  {
    2146                 :          0 :         PyMem_Free(list);
    2147                 :          0 :         return Tkinter_Error(self);
    2148                 :            :     }
    2149                 :            : 
    2150         [ #  # ]:          0 :     if (!(v = PyTuple_New(argc)))
    2151                 :          0 :         goto finally;
    2152                 :            : 
    2153         [ #  # ]:          0 :     for (i = 0; i < argc; i++) {
    2154                 :          0 :         PyObject *s = unicodeFromTclString(argv[i]);
    2155         [ #  # ]:          0 :         if (!s) {
    2156                 :          0 :             Py_SETREF(v, NULL);
    2157                 :          0 :             goto finally;
    2158                 :            :         }
    2159                 :          0 :         PyTuple_SET_ITEM(v, i, s);
    2160                 :            :     }
    2161                 :            : 
    2162                 :          0 :   finally:
    2163                 :          0 :     ckfree(FREECAST argv);
    2164                 :          0 :     PyMem_Free(list);
    2165                 :          0 :     return v;
    2166                 :            : }
    2167                 :            : 
    2168                 :            : 
    2169                 :            : /** Tcl Command **/
    2170                 :            : 
    2171                 :            : /* Client data struct */
    2172                 :            : typedef struct {
    2173                 :            :     PyObject *self;
    2174                 :            :     PyObject *func;
    2175                 :            : } PythonCmd_ClientData;
    2176                 :            : 
    2177                 :            : static int
    2178                 :          0 : PythonCmd_Error(Tcl_Interp *interp)
    2179                 :            : {
    2180                 :          0 :     errorInCmd = 1;
    2181                 :          0 :     excInCmd = PyErr_GetRaisedException();
    2182         [ #  # ]:          0 :     LEAVE_PYTHON
    2183                 :          0 :     return TCL_ERROR;
    2184                 :            : }
    2185                 :            : 
    2186                 :            : /* This is the Tcl command that acts as a wrapper for Python
    2187                 :            :  * function or method.
    2188                 :            :  */
    2189                 :            : static int
    2190                 :          0 : PythonCmd(ClientData clientData, Tcl_Interp *interp,
    2191                 :            :           int objc, Tcl_Obj *const objv[])
    2192                 :            : {
    2193                 :          0 :     PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
    2194                 :            :     PyObject *args, *res;
    2195                 :            :     int i;
    2196                 :            :     Tcl_Obj *obj_res;
    2197                 :            : 
    2198         [ #  # ]:          0 :     ENTER_PYTHON
    2199                 :            : 
    2200                 :            :     /* Create argument tuple (objv1, ..., objvN) */
    2201         [ #  # ]:          0 :     if (!(args = PyTuple_New(objc - 1)))
    2202                 :          0 :         return PythonCmd_Error(interp);
    2203                 :            : 
    2204         [ #  # ]:          0 :     for (i = 0; i < (objc - 1); i++) {
    2205                 :          0 :         PyObject *s = unicodeFromTclObj(objv[i + 1]);
    2206         [ #  # ]:          0 :         if (!s) {
    2207                 :          0 :             Py_DECREF(args);
    2208                 :          0 :             return PythonCmd_Error(interp);
    2209                 :            :         }
    2210                 :          0 :         PyTuple_SET_ITEM(args, i, s);
    2211                 :            :     }
    2212                 :            : 
    2213                 :          0 :     res = PyObject_Call(data->func, args, NULL);
    2214                 :          0 :     Py_DECREF(args);
    2215                 :            : 
    2216         [ #  # ]:          0 :     if (res == NULL)
    2217                 :          0 :         return PythonCmd_Error(interp);
    2218                 :            : 
    2219                 :          0 :     obj_res = AsObj(res);
    2220         [ #  # ]:          0 :     if (obj_res == NULL) {
    2221                 :          0 :         Py_DECREF(res);
    2222                 :          0 :         return PythonCmd_Error(interp);
    2223                 :            :     }
    2224                 :          0 :     Tcl_SetObjResult(interp, obj_res);
    2225                 :          0 :     Py_DECREF(res);
    2226                 :            : 
    2227         [ #  # ]:          0 :     LEAVE_PYTHON
    2228                 :            : 
    2229                 :          0 :     return TCL_OK;
    2230                 :            : }
    2231                 :            : 
    2232                 :            : 
    2233                 :            : static void
    2234                 :          0 : PythonCmdDelete(ClientData clientData)
    2235                 :            : {
    2236                 :          0 :     PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
    2237                 :            : 
    2238         [ #  # ]:          0 :     ENTER_PYTHON
    2239                 :          0 :     Py_XDECREF(data->self);
    2240                 :          0 :     Py_XDECREF(data->func);
    2241                 :          0 :     PyMem_Free(data);
    2242         [ #  # ]:          0 :     LEAVE_PYTHON
    2243                 :          0 : }
    2244                 :            : 
    2245                 :            : 
    2246                 :            : 
    2247                 :            : 
    2248                 :            : TCL_DECLARE_MUTEX(command_mutex)
    2249                 :            : 
    2250                 :            : typedef struct CommandEvent{
    2251                 :            :     Tcl_Event ev;
    2252                 :            :     Tcl_Interp* interp;
    2253                 :            :     const char *name;
    2254                 :            :     int create;
    2255                 :            :     int *status;
    2256                 :            :     ClientData *data;
    2257                 :            :     Tcl_Condition *done;
    2258                 :            : } CommandEvent;
    2259                 :            : 
    2260                 :            : static int
    2261                 :          0 : Tkapp_CommandProc(CommandEvent *ev, int flags)
    2262                 :            : {
    2263         [ #  # ]:          0 :     if (ev->create)
    2264                 :          0 :         *ev->status = Tcl_CreateObjCommand(
    2265                 :            :             ev->interp, ev->name, PythonCmd,
    2266                 :          0 :             ev->data, PythonCmdDelete) == NULL;
    2267                 :            :     else
    2268                 :          0 :         *ev->status = Tcl_DeleteCommand(ev->interp, ev->name);
    2269                 :          0 :     Tcl_MutexLock(&command_mutex);
    2270                 :          0 :     Tcl_ConditionNotify(ev->done);
    2271                 :          0 :     Tcl_MutexUnlock(&command_mutex);
    2272                 :          0 :     return 1;
    2273                 :            : }
    2274                 :            : 
    2275                 :            : /*[clinic input]
    2276                 :            : _tkinter.tkapp.createcommand
    2277                 :            : 
    2278                 :            :     name: str
    2279                 :            :     func: object
    2280                 :            :     /
    2281                 :            : 
    2282                 :            : [clinic start generated code]*/
    2283                 :            : 
    2284                 :            : static PyObject *
    2285                 :          0 : _tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
    2286                 :            :                                   PyObject *func)
    2287                 :            : /*[clinic end generated code: output=2a1c79a4ee2af410 input=255785cb70edc6a0]*/
    2288                 :            : {
    2289                 :            :     PythonCmd_ClientData *data;
    2290                 :            :     int err;
    2291                 :            : 
    2292   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(name);
    2293         [ #  # ]:          0 :     if (!PyCallable_Check(func)) {
    2294                 :          0 :         PyErr_SetString(PyExc_TypeError, "command not callable");
    2295                 :          0 :         return NULL;
    2296                 :            :     }
    2297                 :            : 
    2298   [ #  #  #  #  :          0 :     if (self->threaded && self->thread_id != Tcl_GetCurrentThread() &&
                   #  # ]
    2299                 :          0 :         !WaitForMainloop(self))
    2300                 :          0 :         return NULL;
    2301                 :            : 
    2302                 :          0 :     data = PyMem_NEW(PythonCmd_ClientData, 1);
    2303         [ #  # ]:          0 :     if (!data)
    2304                 :          0 :         return PyErr_NoMemory();
    2305                 :          0 :     data->self = Py_NewRef(self);
    2306                 :          0 :     data->func = Py_NewRef(func);
    2307   [ #  #  #  # ]:          0 :     if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
    2308                 :          0 :         Tcl_Condition cond = NULL;
    2309                 :          0 :         CommandEvent *ev = (CommandEvent*)attemptckalloc(sizeof(CommandEvent));
    2310         [ #  # ]:          0 :         if (ev == NULL) {
    2311                 :          0 :             PyErr_NoMemory();
    2312                 :          0 :             PyMem_Free(data);
    2313                 :          0 :             return NULL;
    2314                 :            :         }
    2315                 :          0 :         ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
    2316                 :          0 :         ev->interp = self->interp;
    2317                 :          0 :         ev->create = 1;
    2318                 :          0 :         ev->name = name;
    2319                 :          0 :         ev->data = (ClientData)data;
    2320                 :          0 :         ev->status = &err;
    2321                 :          0 :         ev->done = &cond;
    2322                 :          0 :         Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond, &command_mutex);
    2323                 :          0 :         Tcl_ConditionFinalize(&cond);
    2324                 :            :     }
    2325                 :            :     else
    2326                 :            :     {
    2327         [ #  # ]:          0 :         ENTER_TCL
    2328                 :          0 :         err = Tcl_CreateObjCommand(
    2329                 :            :             Tkapp_Interp(self), name, PythonCmd,
    2330                 :          0 :             (ClientData)data, PythonCmdDelete) == NULL;
    2331         [ #  # ]:          0 :         LEAVE_TCL
    2332                 :            :     }
    2333         [ #  # ]:          0 :     if (err) {
    2334                 :          0 :         PyErr_SetString(Tkinter_TclError, "can't create Tcl command");
    2335                 :          0 :         PyMem_Free(data);
    2336                 :          0 :         return NULL;
    2337                 :            :     }
    2338                 :            : 
    2339                 :          0 :     Py_RETURN_NONE;
    2340                 :            : }
    2341                 :            : 
    2342                 :            : 
    2343                 :            : 
    2344                 :            : /*[clinic input]
    2345                 :            : _tkinter.tkapp.deletecommand
    2346                 :            : 
    2347                 :            :     name: str
    2348                 :            :     /
    2349                 :            : 
    2350                 :            : [clinic start generated code]*/
    2351                 :            : 
    2352                 :            : static PyObject *
    2353                 :          0 : _tkinter_tkapp_deletecommand_impl(TkappObject *self, const char *name)
    2354                 :            : /*[clinic end generated code: output=a67e8cb5845e0d2d input=53e9952eae1f85f5]*/
    2355                 :            : {
    2356                 :            :     int err;
    2357                 :            : 
    2358   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(name);
    2359                 :            : 
    2360   [ #  #  #  # ]:          0 :     if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
    2361                 :          0 :         Tcl_Condition cond = NULL;
    2362                 :            :         CommandEvent *ev;
    2363                 :          0 :         ev = (CommandEvent*)attemptckalloc(sizeof(CommandEvent));
    2364         [ #  # ]:          0 :         if (ev == NULL) {
    2365                 :          0 :             PyErr_NoMemory();
    2366                 :          0 :             return NULL;
    2367                 :            :         }
    2368                 :          0 :         ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
    2369                 :          0 :         ev->interp = self->interp;
    2370                 :          0 :         ev->create = 0;
    2371                 :          0 :         ev->name = name;
    2372                 :          0 :         ev->status = &err;
    2373                 :          0 :         ev->done = &cond;
    2374                 :          0 :         Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond,
    2375                 :            :                          &command_mutex);
    2376                 :          0 :         Tcl_ConditionFinalize(&cond);
    2377                 :            :     }
    2378                 :            :     else
    2379                 :            :     {
    2380         [ #  # ]:          0 :         ENTER_TCL
    2381                 :          0 :         err = Tcl_DeleteCommand(self->interp, name);
    2382         [ #  # ]:          0 :         LEAVE_TCL
    2383                 :            :     }
    2384         [ #  # ]:          0 :     if (err == -1) {
    2385                 :          0 :         PyErr_SetString(Tkinter_TclError, "can't delete Tcl command");
    2386                 :          0 :         return NULL;
    2387                 :            :     }
    2388                 :          0 :     Py_RETURN_NONE;
    2389                 :            : }
    2390                 :            : 
    2391                 :            : 
    2392                 :            : 
    2393                 :            : #ifdef HAVE_CREATEFILEHANDLER
    2394                 :            : /** File Handler **/
    2395                 :            : 
    2396                 :            : typedef struct _fhcdata {
    2397                 :            :     PyObject *func;
    2398                 :            :     PyObject *file;
    2399                 :            :     int id;
    2400                 :            :     struct _fhcdata *next;
    2401                 :            : } FileHandler_ClientData;
    2402                 :            : 
    2403                 :            : static FileHandler_ClientData *HeadFHCD;
    2404                 :            : 
    2405                 :            : static FileHandler_ClientData *
    2406                 :          0 : NewFHCD(PyObject *func, PyObject *file, int id)
    2407                 :            : {
    2408                 :            :     FileHandler_ClientData *p;
    2409                 :          0 :     p = PyMem_NEW(FileHandler_ClientData, 1);
    2410         [ #  # ]:          0 :     if (p != NULL) {
    2411                 :          0 :         p->func = Py_XNewRef(func);
    2412                 :          0 :         p->file = Py_XNewRef(file);
    2413                 :          0 :         p->id = id;
    2414                 :          0 :         p->next = HeadFHCD;
    2415                 :          0 :         HeadFHCD = p;
    2416                 :            :     }
    2417                 :          0 :     return p;
    2418                 :            : }
    2419                 :            : 
    2420                 :            : static void
    2421                 :          0 : DeleteFHCD(int id)
    2422                 :            : {
    2423                 :            :     FileHandler_ClientData *p, **pp;
    2424                 :            : 
    2425                 :          0 :     pp = &HeadFHCD;
    2426         [ #  # ]:          0 :     while ((p = *pp) != NULL) {
    2427         [ #  # ]:          0 :         if (p->id == id) {
    2428                 :          0 :             *pp = p->next;
    2429                 :          0 :             Py_XDECREF(p->func);
    2430                 :          0 :             Py_XDECREF(p->file);
    2431                 :          0 :             PyMem_Free(p);
    2432                 :            :         }
    2433                 :            :         else
    2434                 :          0 :             pp = &p->next;
    2435                 :            :     }
    2436                 :          0 : }
    2437                 :            : 
    2438                 :            : static void
    2439                 :          0 : FileHandler(ClientData clientData, int mask)
    2440                 :            : {
    2441                 :          0 :     FileHandler_ClientData *data = (FileHandler_ClientData *)clientData;
    2442                 :            :     PyObject *func, *file, *res;
    2443                 :            : 
    2444         [ #  # ]:          0 :     ENTER_PYTHON
    2445                 :          0 :     func = data->func;
    2446                 :          0 :     file = data->file;
    2447                 :            : 
    2448                 :          0 :     res = PyObject_CallFunction(func, "Oi", file, mask);
    2449         [ #  # ]:          0 :     if (res == NULL) {
    2450                 :          0 :         errorInCmd = 1;
    2451                 :          0 :         excInCmd = PyErr_GetRaisedException();
    2452                 :            :     }
    2453                 :          0 :     Py_XDECREF(res);
    2454         [ #  # ]:          0 :     LEAVE_PYTHON
    2455                 :          0 : }
    2456                 :            : 
    2457                 :            : /*[clinic input]
    2458                 :            : _tkinter.tkapp.createfilehandler
    2459                 :            : 
    2460                 :            :     file: object
    2461                 :            :     mask: int
    2462                 :            :     func: object
    2463                 :            :     /
    2464                 :            : 
    2465                 :            : [clinic start generated code]*/
    2466                 :            : 
    2467                 :            : static PyObject *
    2468                 :          0 : _tkinter_tkapp_createfilehandler_impl(TkappObject *self, PyObject *file,
    2469                 :            :                                       int mask, PyObject *func)
    2470                 :            : /*[clinic end generated code: output=f73ce82de801c353 input=84943a5286e47947]*/
    2471                 :            : {
    2472                 :            :     FileHandler_ClientData *data;
    2473                 :            :     int tfile;
    2474                 :            : 
    2475   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2476                 :            : 
    2477                 :          0 :     tfile = PyObject_AsFileDescriptor(file);
    2478         [ #  # ]:          0 :     if (tfile < 0)
    2479                 :          0 :         return NULL;
    2480         [ #  # ]:          0 :     if (!PyCallable_Check(func)) {
    2481                 :          0 :         PyErr_SetString(PyExc_TypeError, "bad argument list");
    2482                 :          0 :         return NULL;
    2483                 :            :     }
    2484                 :            : 
    2485                 :          0 :     data = NewFHCD(func, file, tfile);
    2486         [ #  # ]:          0 :     if (data == NULL)
    2487                 :          0 :         return NULL;
    2488                 :            : 
    2489                 :            :     /* Ought to check for null Tcl_File object... */
    2490         [ #  # ]:          0 :     ENTER_TCL
    2491                 :          0 :     Tcl_CreateFileHandler(tfile, mask, FileHandler, (ClientData) data);
    2492         [ #  # ]:          0 :     LEAVE_TCL
    2493                 :          0 :     Py_RETURN_NONE;
    2494                 :            : }
    2495                 :            : 
    2496                 :            : /*[clinic input]
    2497                 :            : _tkinter.tkapp.deletefilehandler
    2498                 :            : 
    2499                 :            :     file: object
    2500                 :            :     /
    2501                 :            : 
    2502                 :            : [clinic start generated code]*/
    2503                 :            : 
    2504                 :            : static PyObject *
    2505                 :          0 : _tkinter_tkapp_deletefilehandler(TkappObject *self, PyObject *file)
    2506                 :            : /*[clinic end generated code: output=b53cc96ebf9476fd input=abbec19d66312e2a]*/
    2507                 :            : {
    2508                 :            :     int tfile;
    2509                 :            : 
    2510   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2511                 :            : 
    2512                 :          0 :     tfile = PyObject_AsFileDescriptor(file);
    2513         [ #  # ]:          0 :     if (tfile < 0)
    2514                 :          0 :         return NULL;
    2515                 :            : 
    2516                 :          0 :     DeleteFHCD(tfile);
    2517                 :            : 
    2518                 :            :     /* Ought to check for null Tcl_File object... */
    2519         [ #  # ]:          0 :     ENTER_TCL
    2520                 :          0 :     Tcl_DeleteFileHandler(tfile);
    2521         [ #  # ]:          0 :     LEAVE_TCL
    2522                 :          0 :     Py_RETURN_NONE;
    2523                 :            : }
    2524                 :            : #endif /* HAVE_CREATEFILEHANDLER */
    2525                 :            : 
    2526                 :            : 
    2527                 :            : /**** Tktt Object (timer token) ****/
    2528                 :            : 
    2529                 :            : static PyObject *Tktt_Type;
    2530                 :            : 
    2531                 :            : typedef struct {
    2532                 :            :     PyObject_HEAD
    2533                 :            :     Tcl_TimerToken token;
    2534                 :            :     PyObject *func;
    2535                 :            : } TkttObject;
    2536                 :            : 
    2537                 :            : /*[clinic input]
    2538                 :            : _tkinter.tktimertoken.deletetimerhandler
    2539                 :            : 
    2540                 :            : [clinic start generated code]*/
    2541                 :            : 
    2542                 :            : static PyObject *
    2543                 :          0 : _tkinter_tktimertoken_deletetimerhandler_impl(TkttObject *self)
    2544                 :            : /*[clinic end generated code: output=bd7fe17f328cfa55 input=40bd070ff85f5cf3]*/
    2545                 :            : {
    2546                 :          0 :     TkttObject *v = self;
    2547                 :          0 :     PyObject *func = v->func;
    2548                 :            : 
    2549         [ #  # ]:          0 :     if (v->token != NULL) {
    2550                 :          0 :         Tcl_DeleteTimerHandler(v->token);
    2551                 :          0 :         v->token = NULL;
    2552                 :            :     }
    2553         [ #  # ]:          0 :     if (func != NULL) {
    2554                 :          0 :         v->func = NULL;
    2555                 :          0 :         Py_DECREF(func);
    2556                 :          0 :         Py_DECREF(v); /* See Tktt_New() */
    2557                 :            :     }
    2558                 :          0 :     Py_RETURN_NONE;
    2559                 :            : }
    2560                 :            : 
    2561                 :            : static TkttObject *
    2562                 :          0 : Tktt_New(PyObject *func)
    2563                 :            : {
    2564                 :            :     TkttObject *v;
    2565                 :            : 
    2566                 :          0 :     v = PyObject_New(TkttObject, (PyTypeObject *) Tktt_Type);
    2567         [ #  # ]:          0 :     if (v == NULL)
    2568                 :          0 :         return NULL;
    2569                 :            : 
    2570                 :          0 :     v->token = NULL;
    2571                 :          0 :     v->func = Py_NewRef(func);
    2572                 :            : 
    2573                 :            :     /* Extra reference, deleted when called or when handler is deleted */
    2574                 :          0 :     return (TkttObject*)Py_NewRef(v);
    2575                 :            : }
    2576                 :            : 
    2577                 :            : static void
    2578                 :          0 : Tktt_Dealloc(PyObject *self)
    2579                 :            : {
    2580                 :          0 :     TkttObject *v = (TkttObject *)self;
    2581                 :          0 :     PyObject *func = v->func;
    2582                 :          0 :     PyObject *tp = (PyObject *) Py_TYPE(self);
    2583                 :            : 
    2584                 :          0 :     Py_XDECREF(func);
    2585                 :            : 
    2586                 :          0 :     PyObject_Free(self);
    2587                 :          0 :     Py_DECREF(tp);
    2588                 :          0 : }
    2589                 :            : 
    2590                 :            : static PyObject *
    2591                 :          0 : Tktt_Repr(PyObject *self)
    2592                 :            : {
    2593                 :          0 :     TkttObject *v = (TkttObject *)self;
    2594                 :          0 :     return PyUnicode_FromFormat("<tktimertoken at %p%s>",
    2595                 :            :                                 v,
    2596         [ #  # ]:          0 :                                 v->func == NULL ? ", handler deleted" : "");
    2597                 :            : }
    2598                 :            : 
    2599                 :            : /** Timer Handler **/
    2600                 :            : 
    2601                 :            : static void
    2602                 :          0 : TimerHandler(ClientData clientData)
    2603                 :            : {
    2604                 :          0 :     TkttObject *v = (TkttObject *)clientData;
    2605                 :          0 :     PyObject *func = v->func;
    2606                 :            :     PyObject *res;
    2607                 :            : 
    2608         [ #  # ]:          0 :     if (func == NULL)
    2609                 :          0 :         return;
    2610                 :            : 
    2611                 :          0 :     v->func = NULL;
    2612                 :            : 
    2613         [ #  # ]:          0 :     ENTER_PYTHON
    2614                 :            : 
    2615                 :          0 :     res = PyObject_CallNoArgs(func);
    2616                 :          0 :     Py_DECREF(func);
    2617                 :          0 :     Py_DECREF(v); /* See Tktt_New() */
    2618                 :            : 
    2619         [ #  # ]:          0 :     if (res == NULL) {
    2620                 :          0 :         errorInCmd = 1;
    2621                 :          0 :         excInCmd = PyErr_GetRaisedException();
    2622                 :            :     }
    2623                 :            :     else
    2624                 :          0 :         Py_DECREF(res);
    2625                 :            : 
    2626         [ #  # ]:          0 :     LEAVE_PYTHON
    2627                 :            : }
    2628                 :            : 
    2629                 :            : /*[clinic input]
    2630                 :            : _tkinter.tkapp.createtimerhandler
    2631                 :            : 
    2632                 :            :     milliseconds: int
    2633                 :            :     func: object
    2634                 :            :     /
    2635                 :            : 
    2636                 :            : [clinic start generated code]*/
    2637                 :            : 
    2638                 :            : static PyObject *
    2639                 :          0 : _tkinter_tkapp_createtimerhandler_impl(TkappObject *self, int milliseconds,
    2640                 :            :                                        PyObject *func)
    2641                 :            : /*[clinic end generated code: output=2da5959b9d031911 input=ba6729f32f0277a5]*/
    2642                 :            : {
    2643                 :            :     TkttObject *v;
    2644                 :            : 
    2645         [ #  # ]:          0 :     if (!PyCallable_Check(func)) {
    2646                 :          0 :         PyErr_SetString(PyExc_TypeError, "bad argument list");
    2647                 :          0 :         return NULL;
    2648                 :            :     }
    2649                 :            : 
    2650   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2651                 :            : 
    2652                 :          0 :     v = Tktt_New(func);
    2653         [ #  # ]:          0 :     if (v) {
    2654                 :          0 :         v->token = Tcl_CreateTimerHandler(milliseconds, TimerHandler,
    2655                 :            :                                           (ClientData)v);
    2656                 :            :     }
    2657                 :            : 
    2658                 :          0 :     return (PyObject *) v;
    2659                 :            : }
    2660                 :            : 
    2661                 :            : 
    2662                 :            : /** Event Loop **/
    2663                 :            : 
    2664                 :            : /*[clinic input]
    2665                 :            : _tkinter.tkapp.mainloop
    2666                 :            : 
    2667                 :            :     threshold: int = 0
    2668                 :            :     /
    2669                 :            : 
    2670                 :            : [clinic start generated code]*/
    2671                 :            : 
    2672                 :            : static PyObject *
    2673                 :          0 : _tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold)
    2674                 :            : /*[clinic end generated code: output=0ba8eabbe57841b0 input=036bcdcf03d5eca0]*/
    2675                 :            : {
    2676                 :          0 :     PyThreadState *tstate = PyThreadState_Get();
    2677                 :            : 
    2678   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2679                 :          0 :     self->dispatching = 1;
    2680                 :            : 
    2681                 :          0 :     quitMainLoop = 0;
    2682         [ #  # ]:          0 :     while (Tk_GetNumMainWindows() > threshold &&
    2683         [ #  # ]:          0 :            !quitMainLoop &&
    2684         [ #  # ]:          0 :            !errorInCmd)
    2685                 :            :     {
    2686                 :            :         int result;
    2687                 :            : 
    2688         [ #  # ]:          0 :         if (self->threaded) {
    2689                 :            :             /* Allow other Python threads to run. */
    2690         [ #  # ]:          0 :             ENTER_TCL
    2691                 :          0 :             result = Tcl_DoOneEvent(0);
    2692         [ #  # ]:          0 :             LEAVE_TCL
    2693                 :            :         }
    2694                 :            :         else {
    2695                 :          0 :             Py_BEGIN_ALLOW_THREADS
    2696         [ #  # ]:          0 :             if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
    2697                 :          0 :             tcl_tstate = tstate;
    2698                 :          0 :             result = Tcl_DoOneEvent(TCL_DONT_WAIT);
    2699                 :          0 :             tcl_tstate = NULL;
    2700         [ #  # ]:          0 :             if(tcl_lock)PyThread_release_lock(tcl_lock);
    2701         [ #  # ]:          0 :             if (result == 0)
    2702                 :          0 :                 Sleep(Tkinter_busywaitinterval);
    2703                 :          0 :             Py_END_ALLOW_THREADS
    2704                 :            :         }
    2705                 :            : 
    2706         [ #  # ]:          0 :         if (PyErr_CheckSignals() != 0) {
    2707                 :          0 :             self->dispatching = 0;
    2708                 :          0 :             return NULL;
    2709                 :            :         }
    2710         [ #  # ]:          0 :         if (result < 0)
    2711                 :          0 :             break;
    2712                 :            :     }
    2713                 :          0 :     self->dispatching = 0;
    2714                 :          0 :     quitMainLoop = 0;
    2715                 :            : 
    2716         [ #  # ]:          0 :     if (errorInCmd) {
    2717                 :          0 :         errorInCmd = 0;
    2718                 :          0 :         PyErr_SetRaisedException(excInCmd);
    2719                 :          0 :         excInCmd = NULL;
    2720                 :          0 :         return NULL;
    2721                 :            :     }
    2722                 :          0 :     Py_RETURN_NONE;
    2723                 :            : }
    2724                 :            : 
    2725                 :            : /*[clinic input]
    2726                 :            : _tkinter.tkapp.dooneevent
    2727                 :            : 
    2728                 :            :     flags: int = 0
    2729                 :            :     /
    2730                 :            : 
    2731                 :            : [clinic start generated code]*/
    2732                 :            : 
    2733                 :            : static PyObject *
    2734                 :          0 : _tkinter_tkapp_dooneevent_impl(TkappObject *self, int flags)
    2735                 :            : /*[clinic end generated code: output=27c6b2aa464cac29 input=6542b928e364b793]*/
    2736                 :            : {
    2737                 :            :     int rv;
    2738                 :            : 
    2739         [ #  # ]:          0 :     ENTER_TCL
    2740                 :          0 :     rv = Tcl_DoOneEvent(flags);
    2741         [ #  # ]:          0 :     LEAVE_TCL
    2742                 :          0 :     return PyLong_FromLong(rv);
    2743                 :            : }
    2744                 :            : 
    2745                 :            : /*[clinic input]
    2746                 :            : _tkinter.tkapp.quit
    2747                 :            : [clinic start generated code]*/
    2748                 :            : 
    2749                 :            : static PyObject *
    2750                 :          0 : _tkinter_tkapp_quit_impl(TkappObject *self)
    2751                 :            : /*[clinic end generated code: output=7f21eeff481f754f input=e03020dc38aff23c]*/
    2752                 :            : {
    2753                 :          0 :     quitMainLoop = 1;
    2754                 :          0 :     Py_RETURN_NONE;
    2755                 :            : }
    2756                 :            : 
    2757                 :            : /*[clinic input]
    2758                 :            : _tkinter.tkapp.interpaddr
    2759                 :            : [clinic start generated code]*/
    2760                 :            : 
    2761                 :            : static PyObject *
    2762                 :          0 : _tkinter_tkapp_interpaddr_impl(TkappObject *self)
    2763                 :            : /*[clinic end generated code: output=6caaae3273b3c95a input=2dd32cbddb55a111]*/
    2764                 :            : {
    2765                 :          0 :     return PyLong_FromVoidPtr(Tkapp_Interp(self));
    2766                 :            : }
    2767                 :            : 
    2768                 :            : /*[clinic input]
    2769                 :            : _tkinter.tkapp.loadtk
    2770                 :            : [clinic start generated code]*/
    2771                 :            : 
    2772                 :            : static PyObject *
    2773                 :          0 : _tkinter_tkapp_loadtk_impl(TkappObject *self)
    2774                 :            : /*[clinic end generated code: output=e9e10a954ce46d2a input=b5e82afedd6354f0]*/
    2775                 :            : {
    2776                 :          0 :     Tcl_Interp *interp = Tkapp_Interp(self);
    2777                 :          0 :     const char * _tk_exists = NULL;
    2778                 :            :     int err;
    2779                 :            : 
    2780                 :            : #ifdef TKINTER_PROTECT_LOADTK
    2781                 :            :     /* Up to Tk 8.4.13, Tk_Init deadlocks on the second call when the
    2782                 :            :      * first call failed.
    2783                 :            :      * To avoid the deadlock, we just refuse the second call through
    2784                 :            :      * a static variable.
    2785                 :            :      */
    2786                 :            :     if (tk_load_failed) {
    2787                 :            :         PyErr_SetString(Tkinter_TclError, TKINTER_LOADTK_ERRMSG);
    2788                 :            :         return NULL;
    2789                 :            :     }
    2790                 :            : #endif
    2791                 :            : 
    2792                 :            :     /* We want to guard against calling Tk_Init() multiple times */
    2793   [ #  #  #  # ]:          0 :     CHECK_TCL_APPARTMENT;
    2794         [ #  # ]:          0 :     ENTER_TCL
    2795                 :          0 :     err = Tcl_Eval(Tkapp_Interp(self), "info exists     tk_version");
    2796                 :          0 :     ENTER_OVERLAP
    2797         [ #  # ]:          0 :     if (err == TCL_ERROR) {
    2798                 :            :         /* This sets an exception, but we cannot return right
    2799                 :            :            away because we need to exit the overlap first. */
    2800                 :          0 :         Tkinter_Error(self);
    2801                 :            :     } else {
    2802                 :          0 :         _tk_exists = Tcl_GetStringResult(Tkapp_Interp(self));
    2803                 :            :     }
    2804         [ #  # ]:          0 :     LEAVE_OVERLAP_TCL
    2805         [ #  # ]:          0 :     if (err == TCL_ERROR) {
    2806                 :          0 :         return NULL;
    2807                 :            :     }
    2808   [ #  #  #  # ]:          0 :     if (_tk_exists == NULL || strcmp(_tk_exists, "1") != 0)     {
    2809         [ #  # ]:          0 :         if (Tk_Init(interp)             == TCL_ERROR) {
    2810                 :          0 :             Tkinter_Error(self);
    2811                 :            : #ifdef TKINTER_PROTECT_LOADTK
    2812                 :            :             tk_load_failed = 1;
    2813                 :            : #endif
    2814                 :          0 :             return NULL;
    2815                 :            :         }
    2816                 :            :     }
    2817                 :          0 :     Py_RETURN_NONE;
    2818                 :            : }
    2819                 :            : 
    2820                 :            : static PyObject *
    2821                 :          0 : Tkapp_WantObjects(PyObject *self, PyObject *args)
    2822                 :            : {
    2823                 :            : 
    2824                 :          0 :     int wantobjects = -1;
    2825         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "|p:wantobjects", &wantobjects))
    2826                 :          0 :         return NULL;
    2827         [ #  # ]:          0 :     if (wantobjects == -1)
    2828                 :          0 :         return PyBool_FromLong(((TkappObject*)self)->wantobjects);
    2829                 :          0 :     ((TkappObject*)self)->wantobjects = wantobjects;
    2830                 :            : 
    2831                 :          0 :     Py_RETURN_NONE;
    2832                 :            : }
    2833                 :            : 
    2834                 :            : /*[clinic input]
    2835                 :            : _tkinter.tkapp.willdispatch
    2836                 :            : 
    2837                 :            : [clinic start generated code]*/
    2838                 :            : 
    2839                 :            : static PyObject *
    2840                 :          0 : _tkinter_tkapp_willdispatch_impl(TkappObject *self)
    2841                 :            : /*[clinic end generated code: output=0e3f46d244642155 input=d88f5970843d6dab]*/
    2842                 :            : {
    2843                 :          0 :     self->dispatching = 1;
    2844                 :            : 
    2845                 :          0 :     Py_RETURN_NONE;
    2846                 :            : }
    2847                 :            : 
    2848                 :            : 
    2849                 :            : /**** Tkapp Type Methods ****/
    2850                 :            : 
    2851                 :            : static void
    2852                 :          0 : Tkapp_Dealloc(PyObject *self)
    2853                 :            : {
    2854                 :          0 :     PyObject *tp = (PyObject *) Py_TYPE(self);
    2855                 :            :     /*CHECK_TCL_APPARTMENT;*/
    2856         [ #  # ]:          0 :     ENTER_TCL
    2857                 :          0 :     Tcl_DeleteInterp(Tkapp_Interp(self));
    2858         [ #  # ]:          0 :     LEAVE_TCL
    2859                 :          0 :     PyObject_Free(self);
    2860                 :          0 :     Py_DECREF(tp);
    2861                 :          0 :     DisableEventHook();
    2862                 :          0 : }
    2863                 :            : 
    2864                 :            : 
    2865                 :            : 
    2866                 :            : /**** Tkinter Module ****/
    2867                 :            : 
    2868                 :            : typedef struct {
    2869                 :            :     PyObject* tuple;
    2870                 :            :     Py_ssize_t size; /* current size */
    2871                 :            :     Py_ssize_t maxsize; /* allocated size */
    2872                 :            : } FlattenContext;
    2873                 :            : 
    2874                 :            : static int
    2875                 :          0 : _bump(FlattenContext* context, Py_ssize_t size)
    2876                 :            : {
    2877                 :            :     /* expand tuple to hold (at least) size new items.
    2878                 :            :        return true if successful, false if an exception was raised */
    2879                 :            : 
    2880                 :          0 :     Py_ssize_t maxsize = context->maxsize * 2;  /* never overflows */
    2881                 :            : 
    2882         [ #  # ]:          0 :     if (maxsize < context->size + size)
    2883                 :          0 :         maxsize = context->size + size;  /* never overflows */
    2884                 :            : 
    2885                 :          0 :     context->maxsize = maxsize;
    2886                 :            : 
    2887                 :          0 :     return _PyTuple_Resize(&context->tuple, maxsize) >= 0;
    2888                 :            : }
    2889                 :            : 
    2890                 :            : static int
    2891                 :          0 : _flatten1(FlattenContext* context, PyObject* item, int depth)
    2892                 :            : {
    2893                 :            :     /* add tuple or list to argument tuple (recursively) */
    2894                 :            : 
    2895                 :            :     Py_ssize_t i, size;
    2896                 :            : 
    2897         [ #  # ]:          0 :     if (depth > 1000) {
    2898                 :          0 :         PyErr_SetString(PyExc_ValueError,
    2899                 :            :                         "nesting too deep in _flatten");
    2900                 :          0 :         return 0;
    2901   [ #  #  #  # ]:          0 :     } else if (PyTuple_Check(item) || PyList_Check(item)) {
    2902         [ #  # ]:          0 :         size = PySequence_Fast_GET_SIZE(item);
    2903                 :            :         /* preallocate (assume no nesting) */
    2904   [ #  #  #  # ]:          0 :         if (context->size + size > context->maxsize &&
    2905                 :          0 :             !_bump(context, size))
    2906                 :          0 :             return 0;
    2907                 :            :         /* copy items to output tuple */
    2908         [ #  # ]:          0 :         for (i = 0; i < size; i++) {
    2909         [ #  # ]:          0 :             PyObject *o = PySequence_Fast_GET_ITEM(item, i);
    2910   [ #  #  #  # ]:          0 :             if (PyList_Check(o) || PyTuple_Check(o)) {
    2911         [ #  # ]:          0 :                 if (!_flatten1(context, o, depth + 1))
    2912                 :          0 :                     return 0;
    2913         [ #  # ]:          0 :             } else if (o != Py_None) {
    2914   [ #  #  #  # ]:          0 :                 if (context->size + 1 > context->maxsize &&
    2915                 :          0 :                     !_bump(context, 1))
    2916                 :          0 :                     return 0;
    2917                 :          0 :                 PyTuple_SET_ITEM(context->tuple,
    2918                 :            :                                  context->size++, Py_NewRef(o));
    2919                 :            :             }
    2920                 :            :         }
    2921                 :            :     } else {
    2922                 :          0 :         PyErr_SetString(PyExc_TypeError, "argument must be sequence");
    2923                 :          0 :         return 0;
    2924                 :            :     }
    2925                 :          0 :     return 1;
    2926                 :            : }
    2927                 :            : 
    2928                 :            : /*[clinic input]
    2929                 :            : _tkinter._flatten
    2930                 :            : 
    2931                 :            :     item: object
    2932                 :            :     /
    2933                 :            : 
    2934                 :            : [clinic start generated code]*/
    2935                 :            : 
    2936                 :            : static PyObject *
    2937                 :          0 : _tkinter__flatten(PyObject *module, PyObject *item)
    2938                 :            : /*[clinic end generated code: output=cad02a3f97f29862 input=6b9c12260aa1157f]*/
    2939                 :            : {
    2940                 :            :     FlattenContext context;
    2941                 :            : 
    2942                 :          0 :     context.maxsize = PySequence_Size(item);
    2943         [ #  # ]:          0 :     if (context.maxsize < 0)
    2944                 :          0 :         return NULL;
    2945         [ #  # ]:          0 :     if (context.maxsize == 0)
    2946                 :          0 :         return PyTuple_New(0);
    2947                 :            : 
    2948                 :          0 :     context.tuple = PyTuple_New(context.maxsize);
    2949         [ #  # ]:          0 :     if (!context.tuple)
    2950                 :          0 :         return NULL;
    2951                 :            : 
    2952                 :          0 :     context.size = 0;
    2953                 :            : 
    2954         [ #  # ]:          0 :     if (!_flatten1(&context, item, 0)) {
    2955                 :          0 :         Py_XDECREF(context.tuple);
    2956                 :          0 :         return NULL;
    2957                 :            :     }
    2958                 :            : 
    2959         [ #  # ]:          0 :     if (_PyTuple_Resize(&context.tuple, context.size))
    2960                 :          0 :         return NULL;
    2961                 :            : 
    2962                 :          0 :     return context.tuple;
    2963                 :            : }
    2964                 :            : 
    2965                 :            : /*[clinic input]
    2966                 :            : _tkinter.create
    2967                 :            : 
    2968                 :            :     screenName: str(accept={str, NoneType}) = None
    2969                 :            :     baseName: str = ""
    2970                 :            :     className: str = "Tk"
    2971                 :            :     interactive: bool = False
    2972                 :            :     wantobjects: bool = False
    2973                 :            :     wantTk: bool = True
    2974                 :            :         if false, then Tk_Init() doesn't get called
    2975                 :            :     sync: bool = False
    2976                 :            :         if true, then pass -sync to wish
    2977                 :            :     use: str(accept={str, NoneType}) = None
    2978                 :            :         if not None, then pass -use to wish
    2979                 :            :     /
    2980                 :            : 
    2981                 :            : [clinic start generated code]*/
    2982                 :            : 
    2983                 :            : static PyObject *
    2984                 :          0 : _tkinter_create_impl(PyObject *module, const char *screenName,
    2985                 :            :                      const char *baseName, const char *className,
    2986                 :            :                      int interactive, int wantobjects, int wantTk, int sync,
    2987                 :            :                      const char *use)
    2988                 :            : /*[clinic end generated code: output=e3315607648e6bb4 input=09afef9adea70a19]*/
    2989                 :            : {
    2990                 :            :     /* XXX baseName is not used anymore;
    2991                 :            :      * try getting rid of it. */
    2992   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(screenName);
    2993   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(baseName);
    2994   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(className);
    2995   [ #  #  #  # ]:          0 :     CHECK_STRING_LENGTH(use);
    2996                 :            : 
    2997                 :          0 :     return (PyObject *) Tkapp_New(screenName, className,
    2998                 :            :                                   interactive, wantobjects, wantTk,
    2999                 :            :                                   sync, use);
    3000                 :            : }
    3001                 :            : 
    3002                 :            : /*[clinic input]
    3003                 :            : _tkinter.setbusywaitinterval
    3004                 :            : 
    3005                 :            :     new_val: int
    3006                 :            :     /
    3007                 :            : 
    3008                 :            : Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.
    3009                 :            : 
    3010                 :            : It should be set to a divisor of the maximum time between frames in an animation.
    3011                 :            : [clinic start generated code]*/
    3012                 :            : 
    3013                 :            : static PyObject *
    3014                 :          0 : _tkinter_setbusywaitinterval_impl(PyObject *module, int new_val)
    3015                 :            : /*[clinic end generated code: output=42bf7757dc2d0ab6 input=deca1d6f9e6dae47]*/
    3016                 :            : {
    3017         [ #  # ]:          0 :     if (new_val < 0) {
    3018                 :          0 :         PyErr_SetString(PyExc_ValueError,
    3019                 :            :                         "busywaitinterval must be >= 0");
    3020                 :          0 :         return NULL;
    3021                 :            :     }
    3022                 :          0 :     Tkinter_busywaitinterval = new_val;
    3023                 :          0 :     Py_RETURN_NONE;
    3024                 :            : }
    3025                 :            : 
    3026                 :            : /*[clinic input]
    3027                 :            : _tkinter.getbusywaitinterval -> int
    3028                 :            : 
    3029                 :            : Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.
    3030                 :            : [clinic start generated code]*/
    3031                 :            : 
    3032                 :            : static int
    3033                 :          0 : _tkinter_getbusywaitinterval_impl(PyObject *module)
    3034                 :            : /*[clinic end generated code: output=23b72d552001f5c7 input=a695878d2d576a84]*/
    3035                 :            : {
    3036                 :          0 :     return Tkinter_busywaitinterval;
    3037                 :            : }
    3038                 :            : 
    3039                 :            : #include "clinic/_tkinter.c.h"
    3040                 :            : 
    3041                 :            : static PyMethodDef Tktt_methods[] =
    3042                 :            : {
    3043                 :            :     _TKINTER_TKTIMERTOKEN_DELETETIMERHANDLER_METHODDEF
    3044                 :            :     {NULL, NULL}
    3045                 :            : };
    3046                 :            : 
    3047                 :            : static PyType_Slot Tktt_Type_slots[] = {
    3048                 :            :     {Py_tp_dealloc, Tktt_Dealloc},
    3049                 :            :     {Py_tp_repr, Tktt_Repr},
    3050                 :            :     {Py_tp_methods, Tktt_methods},
    3051                 :            :     {0, 0}
    3052                 :            : };
    3053                 :            : 
    3054                 :            : static PyType_Spec Tktt_Type_spec = {
    3055                 :            :     "_tkinter.tktimertoken",
    3056                 :            :     sizeof(TkttObject),
    3057                 :            :     0,
    3058                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
    3059                 :            :     Tktt_Type_slots,
    3060                 :            : };
    3061                 :            : 
    3062                 :            : 
    3063                 :            : /**** Tkapp Method List ****/
    3064                 :            : 
    3065                 :            : static PyMethodDef Tkapp_methods[] =
    3066                 :            : {
    3067                 :            :     _TKINTER_TKAPP_WILLDISPATCH_METHODDEF
    3068                 :            :     {"wantobjects",            Tkapp_WantObjects, METH_VARARGS},
    3069                 :            :     {"call",                   Tkapp_Call, METH_VARARGS},
    3070                 :            :     _TKINTER_TKAPP_EVAL_METHODDEF
    3071                 :            :     _TKINTER_TKAPP_EVALFILE_METHODDEF
    3072                 :            :     _TKINTER_TKAPP_RECORD_METHODDEF
    3073                 :            :     _TKINTER_TKAPP_ADDERRORINFO_METHODDEF
    3074                 :            :     {"setvar",                 Tkapp_SetVar, METH_VARARGS},
    3075                 :            :     {"globalsetvar",       Tkapp_GlobalSetVar, METH_VARARGS},
    3076                 :            :     {"getvar",       Tkapp_GetVar, METH_VARARGS},
    3077                 :            :     {"globalgetvar",       Tkapp_GlobalGetVar, METH_VARARGS},
    3078                 :            :     {"unsetvar",     Tkapp_UnsetVar, METH_VARARGS},
    3079                 :            :     {"globalunsetvar",     Tkapp_GlobalUnsetVar, METH_VARARGS},
    3080                 :            :     _TKINTER_TKAPP_GETINT_METHODDEF
    3081                 :            :     _TKINTER_TKAPP_GETDOUBLE_METHODDEF
    3082                 :            :     _TKINTER_TKAPP_GETBOOLEAN_METHODDEF
    3083                 :            :     _TKINTER_TKAPP_EXPRSTRING_METHODDEF
    3084                 :            :     _TKINTER_TKAPP_EXPRLONG_METHODDEF
    3085                 :            :     _TKINTER_TKAPP_EXPRDOUBLE_METHODDEF
    3086                 :            :     _TKINTER_TKAPP_EXPRBOOLEAN_METHODDEF
    3087                 :            :     _TKINTER_TKAPP_SPLITLIST_METHODDEF
    3088                 :            :     _TKINTER_TKAPP_CREATECOMMAND_METHODDEF
    3089                 :            :     _TKINTER_TKAPP_DELETECOMMAND_METHODDEF
    3090                 :            :     _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF
    3091                 :            :     _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
    3092                 :            :     _TKINTER_TKAPP_CREATETIMERHANDLER_METHODDEF
    3093                 :            :     _TKINTER_TKAPP_MAINLOOP_METHODDEF
    3094                 :            :     _TKINTER_TKAPP_DOONEEVENT_METHODDEF
    3095                 :            :     _TKINTER_TKAPP_QUIT_METHODDEF
    3096                 :            :     _TKINTER_TKAPP_INTERPADDR_METHODDEF
    3097                 :            :     _TKINTER_TKAPP_LOADTK_METHODDEF
    3098                 :            :     {NULL,                     NULL}
    3099                 :            : };
    3100                 :            : 
    3101                 :            : static PyType_Slot Tkapp_Type_slots[] = {
    3102                 :            :     {Py_tp_dealloc, Tkapp_Dealloc},
    3103                 :            :     {Py_tp_methods, Tkapp_methods},
    3104                 :            :     {0, 0}
    3105                 :            : };
    3106                 :            : 
    3107                 :            : 
    3108                 :            : static PyType_Spec Tkapp_Type_spec = {
    3109                 :            :     "_tkinter.tkapp",
    3110                 :            :     sizeof(TkappObject),
    3111                 :            :     0,
    3112                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
    3113                 :            :     Tkapp_Type_slots,
    3114                 :            : };
    3115                 :            : 
    3116                 :            : static PyMethodDef moduleMethods[] =
    3117                 :            : {
    3118                 :            :     _TKINTER__FLATTEN_METHODDEF
    3119                 :            :     _TKINTER_CREATE_METHODDEF
    3120                 :            :     _TKINTER_SETBUSYWAITINTERVAL_METHODDEF
    3121                 :            :     _TKINTER_GETBUSYWAITINTERVAL_METHODDEF
    3122                 :            :     {NULL,                 NULL}
    3123                 :            : };
    3124                 :            : 
    3125                 :            : #ifdef WAIT_FOR_STDIN
    3126                 :            : 
    3127                 :            : static int stdin_ready = 0;
    3128                 :            : 
    3129                 :            : #ifndef MS_WINDOWS
    3130                 :            : static void
    3131                 :          0 : MyFileProc(void *clientData, int mask)
    3132                 :            : {
    3133                 :          0 :     stdin_ready = 1;
    3134                 :          0 : }
    3135                 :            : #endif
    3136                 :            : 
    3137                 :            : static PyThreadState *event_tstate = NULL;
    3138                 :            : 
    3139                 :            : static int
    3140                 :          0 : EventHook(void)
    3141                 :            : {
    3142                 :            : #ifndef MS_WINDOWS
    3143                 :            :     int tfile;
    3144                 :            : #endif
    3145                 :          0 :     PyEval_RestoreThread(event_tstate);
    3146                 :          0 :     stdin_ready = 0;
    3147                 :          0 :     errorInCmd = 0;
    3148                 :            : #ifndef MS_WINDOWS
    3149                 :          0 :     tfile = fileno(stdin);
    3150                 :          0 :     Tcl_CreateFileHandler(tfile, TCL_READABLE, MyFileProc, NULL);
    3151                 :            : #endif
    3152   [ #  #  #  # ]:          0 :     while (!errorInCmd && !stdin_ready) {
    3153                 :            :         int result;
    3154                 :            : #ifdef MS_WINDOWS
    3155                 :            :         if (_kbhit()) {
    3156                 :            :             stdin_ready = 1;
    3157                 :            :             break;
    3158                 :            :         }
    3159                 :            : #endif
    3160                 :          0 :         Py_BEGIN_ALLOW_THREADS
    3161         [ #  # ]:          0 :         if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
    3162                 :          0 :         tcl_tstate = event_tstate;
    3163                 :            : 
    3164                 :          0 :         result = Tcl_DoOneEvent(TCL_DONT_WAIT);
    3165                 :            : 
    3166                 :          0 :         tcl_tstate = NULL;
    3167         [ #  # ]:          0 :         if(tcl_lock)PyThread_release_lock(tcl_lock);
    3168         [ #  # ]:          0 :         if (result == 0)
    3169                 :          0 :             Sleep(Tkinter_busywaitinterval);
    3170                 :          0 :         Py_END_ALLOW_THREADS
    3171                 :            : 
    3172         [ #  # ]:          0 :         if (result < 0)
    3173                 :          0 :             break;
    3174                 :            :     }
    3175                 :            : #ifndef MS_WINDOWS
    3176                 :          0 :     Tcl_DeleteFileHandler(tfile);
    3177                 :            : #endif
    3178         [ #  # ]:          0 :     if (errorInCmd) {
    3179                 :          0 :         errorInCmd = 0;
    3180                 :          0 :         PyErr_SetRaisedException(excInCmd);
    3181                 :          0 :         excInCmd = NULL;
    3182                 :          0 :         PyErr_Print();
    3183                 :            :     }
    3184                 :          0 :     PyEval_SaveThread();
    3185                 :          0 :     return 0;
    3186                 :            : }
    3187                 :            : 
    3188                 :            : #endif
    3189                 :            : 
    3190                 :            : static void
    3191                 :          0 : EnableEventHook(void)
    3192                 :            : {
    3193                 :            : #ifdef WAIT_FOR_STDIN
    3194         [ #  # ]:          0 :     if (PyOS_InputHook == NULL) {
    3195                 :          0 :         event_tstate = PyThreadState_Get();
    3196                 :          0 :         PyOS_InputHook = EventHook;
    3197                 :            :     }
    3198                 :            : #endif
    3199                 :          0 : }
    3200                 :            : 
    3201                 :            : static void
    3202                 :          0 : DisableEventHook(void)
    3203                 :            : {
    3204                 :            : #ifdef WAIT_FOR_STDIN
    3205   [ #  #  #  # ]:          0 :     if (Tk_GetNumMainWindows() == 0 && PyOS_InputHook == EventHook) {
    3206                 :          0 :         PyOS_InputHook = NULL;
    3207                 :            :     }
    3208                 :            : #endif
    3209                 :          0 : }
    3210                 :            : 
    3211                 :            : 
    3212                 :            : static struct PyModuleDef _tkintermodule = {
    3213                 :            :     PyModuleDef_HEAD_INIT,
    3214                 :            :     "_tkinter",
    3215                 :            :     NULL,
    3216                 :            :     -1,
    3217                 :            :     moduleMethods,
    3218                 :            :     NULL,
    3219                 :            :     NULL,
    3220                 :            :     NULL,
    3221                 :            :     NULL
    3222                 :            : };
    3223                 :            : 
    3224                 :            : PyMODINIT_FUNC
    3225                 :          1 : PyInit__tkinter(void)
    3226                 :            : {
    3227                 :            :   PyObject *m, *uexe, *cexe, *o;
    3228                 :            : 
    3229                 :          1 :     tcl_lock = PyThread_allocate_lock();
    3230         [ -  + ]:          1 :     if (tcl_lock == NULL)
    3231                 :          0 :         return NULL;
    3232                 :            : 
    3233                 :          1 :     m = PyModule_Create(&_tkintermodule);
    3234         [ -  + ]:          1 :     if (m == NULL)
    3235                 :          0 :         return NULL;
    3236                 :            : 
    3237                 :          1 :     o = PyErr_NewException("_tkinter.TclError", NULL, NULL);
    3238         [ -  + ]:          1 :     if (o == NULL) {
    3239                 :          0 :         Py_DECREF(m);
    3240                 :          0 :         return NULL;
    3241                 :            :     }
    3242         [ -  + ]:          1 :     if (PyModule_AddObject(m, "TclError", Py_NewRef(o))) {
    3243                 :          0 :         Py_DECREF(o);
    3244                 :          0 :         Py_DECREF(m);
    3245                 :          0 :         return NULL;
    3246                 :            :     }
    3247                 :          1 :     Tkinter_TclError = o;
    3248                 :            : 
    3249         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "READABLE", TCL_READABLE)) {
    3250                 :          0 :         Py_DECREF(m);
    3251                 :          0 :         return NULL;
    3252                 :            :     }
    3253         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "WRITABLE", TCL_WRITABLE)) {
    3254                 :          0 :         Py_DECREF(m);
    3255                 :          0 :         return NULL;
    3256                 :            :     }
    3257         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "EXCEPTION", TCL_EXCEPTION)) {
    3258                 :          0 :         Py_DECREF(m);
    3259                 :          0 :         return NULL;
    3260                 :            :     }
    3261         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "WINDOW_EVENTS", TCL_WINDOW_EVENTS)) {
    3262                 :          0 :         Py_DECREF(m);
    3263                 :          0 :         return NULL;
    3264                 :            :     }
    3265         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "FILE_EVENTS", TCL_FILE_EVENTS)) {
    3266                 :          0 :         Py_DECREF(m);
    3267                 :          0 :         return NULL;
    3268                 :            :     }
    3269         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "TIMER_EVENTS", TCL_TIMER_EVENTS)) {
    3270                 :          0 :         Py_DECREF(m);
    3271                 :          0 :         return NULL;
    3272                 :            :     }
    3273         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "IDLE_EVENTS", TCL_IDLE_EVENTS)) {
    3274                 :          0 :         Py_DECREF(m);
    3275                 :          0 :         return NULL;
    3276                 :            :     }
    3277         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "ALL_EVENTS", TCL_ALL_EVENTS)) {
    3278                 :          0 :         Py_DECREF(m);
    3279                 :          0 :         return NULL;
    3280                 :            :     }
    3281         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "DONT_WAIT", TCL_DONT_WAIT)) {
    3282                 :          0 :         Py_DECREF(m);
    3283                 :          0 :         return NULL;
    3284                 :            :     }
    3285         [ -  + ]:          1 :     if (PyModule_AddStringConstant(m, "TK_VERSION", TK_VERSION)) {
    3286                 :          0 :         Py_DECREF(m);
    3287                 :          0 :         return NULL;
    3288                 :            :     }
    3289         [ -  + ]:          1 :     if (PyModule_AddStringConstant(m, "TCL_VERSION", TCL_VERSION)) {
    3290                 :          0 :         Py_DECREF(m);
    3291                 :          0 :         return NULL;
    3292                 :            :     }
    3293                 :            : 
    3294                 :          1 :     o = PyType_FromSpec(&Tkapp_Type_spec);
    3295         [ -  + ]:          1 :     if (o == NULL) {
    3296                 :          0 :         Py_DECREF(m);
    3297                 :          0 :         return NULL;
    3298                 :            :     }
    3299         [ -  + ]:          1 :     if (PyModule_AddObject(m, "TkappType", o)) {
    3300                 :          0 :         Py_DECREF(o);
    3301                 :          0 :         Py_DECREF(m);
    3302                 :          0 :         return NULL;
    3303                 :            :     }
    3304                 :          1 :     Tkapp_Type = o;
    3305                 :            : 
    3306                 :          1 :     o = PyType_FromSpec(&Tktt_Type_spec);
    3307         [ -  + ]:          1 :     if (o == NULL) {
    3308                 :          0 :         Py_DECREF(m);
    3309                 :          0 :         return NULL;
    3310                 :            :     }
    3311         [ -  + ]:          1 :     if (PyModule_AddObject(m, "TkttType", o)) {
    3312                 :          0 :         Py_DECREF(o);
    3313                 :          0 :         Py_DECREF(m);
    3314                 :          0 :         return NULL;
    3315                 :            :     }
    3316                 :          1 :     Tktt_Type = o;
    3317                 :            : 
    3318                 :          1 :     o = PyType_FromSpec(&PyTclObject_Type_spec);
    3319         [ -  + ]:          1 :     if (o == NULL) {
    3320                 :          0 :         Py_DECREF(m);
    3321                 :          0 :         return NULL;
    3322                 :            :     }
    3323         [ -  + ]:          1 :     if (PyModule_AddObject(m, "Tcl_Obj", o)) {
    3324                 :          0 :         Py_DECREF(o);
    3325                 :          0 :         Py_DECREF(m);
    3326                 :          0 :         return NULL;
    3327                 :            :     }
    3328                 :          1 :     PyTclObject_Type = o;
    3329                 :            : 
    3330                 :            : #ifdef TK_AQUA
    3331                 :            :     /* Tk_MacOSXSetupTkNotifier must be called before Tcl's subsystems
    3332                 :            :      * start waking up.  Note that Tcl_FindExecutable will do this, this
    3333                 :            :      * code must be above it! The original warning from
    3334                 :            :      * tkMacOSXAppInit.c is copied below.
    3335                 :            :      *
    3336                 :            :      * NB - You have to swap in the Tk Notifier BEFORE you start up the
    3337                 :            :      * Tcl interpreter for now.  It probably should work to do this
    3338                 :            :      * in the other order, but for now it doesn't seem to.
    3339                 :            :      *
    3340                 :            :      */
    3341                 :            :     Tk_MacOSXSetupTkNotifier();
    3342                 :            : #endif
    3343                 :            : 
    3344                 :            : 
    3345                 :            :     /* This helps the dynamic loader; in Unicode aware Tcl versions
    3346                 :            :        it also helps Tcl find its encodings. */
    3347                 :          1 :     uexe = PyUnicode_FromWideChar(Py_GetProgramName(), -1);
    3348         [ +  - ]:          1 :     if (uexe) {
    3349                 :          1 :         cexe = PyUnicode_EncodeFSDefault(uexe);
    3350         [ +  - ]:          1 :         if (cexe) {
    3351                 :            : #ifdef MS_WINDOWS
    3352                 :            :             int set_var = 0;
    3353                 :            :             PyObject *str_path;
    3354                 :            :             wchar_t *wcs_path;
    3355                 :            :             DWORD ret;
    3356                 :            : 
    3357                 :            :             ret = GetEnvironmentVariableW(L"TCL_LIBRARY", NULL, 0);
    3358                 :            : 
    3359                 :            :             if (!ret && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
    3360                 :            :                 str_path = _get_tcl_lib_path();
    3361                 :            :                 if (str_path == NULL && PyErr_Occurred()) {
    3362                 :            :                     Py_DECREF(m);
    3363                 :            :                     return NULL;
    3364                 :            :                 }
    3365                 :            :                 if (str_path != NULL) {
    3366                 :            :                     wcs_path = PyUnicode_AsWideCharString(str_path, NULL);
    3367                 :            :                     if (wcs_path == NULL) {
    3368                 :            :                         Py_DECREF(m);
    3369                 :            :                         return NULL;
    3370                 :            :                     }
    3371                 :            :                     SetEnvironmentVariableW(L"TCL_LIBRARY", wcs_path);
    3372                 :            :                     set_var = 1;
    3373                 :            :                 }
    3374                 :            :             }
    3375                 :            : 
    3376                 :            :             Tcl_FindExecutable(PyBytes_AS_STRING(cexe));
    3377                 :            : 
    3378                 :            :             if (set_var) {
    3379                 :            :                 SetEnvironmentVariableW(L"TCL_LIBRARY", NULL);
    3380                 :            :                 PyMem_Free(wcs_path);
    3381                 :            :             }
    3382                 :            : #else
    3383                 :          1 :             Tcl_FindExecutable(PyBytes_AS_STRING(cexe));
    3384                 :            : #endif /* MS_WINDOWS */
    3385                 :            :         }
    3386                 :          1 :         Py_XDECREF(cexe);
    3387                 :          1 :         Py_DECREF(uexe);
    3388                 :            :     }
    3389                 :            : 
    3390         [ -  + ]:          1 :     if (PyErr_Occurred()) {
    3391                 :          0 :         Py_DECREF(m);
    3392                 :          0 :         return NULL;
    3393                 :            :     }
    3394                 :            : 
    3395                 :          1 :     return m;
    3396                 :            : }

Generated by: LCOV version 1.14