Add files using upload-large-folder tool

.gitattributes

@@ -1233,3 +1233,6 @@ evalkit_tf449/lib/python3.10/site-packages/pandas/io/formats/__pycache__/style.c
 evalkit_tf449/lib/python3.10/site-packages/pandas/io/__pycache__/stata.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_tf449/lib/python3.10/site-packages/pandas/io/__pycache__/pytables.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_cambrian/lib/python3.10/site-packages/scipy/integrate/_test_odeint_banded.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_cambrian/lib/python3.10/site-packages/scipy/sparse/csgraph/_flow.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_tf449/lib/python3.10/site-packages/opencv_python.libs/libavformat-3ff1be5b.so.59.27.100 filter=lfs diff=lfs merge=lfs -text
+evalkit_tf449/lib/python3.10/site-packages/opencv_python.libs/libQt5Core-e6d3f451.so.5.15.13 filter=lfs diff=lfs merge=lfs -text

evalkit_cambrian/include/cursesapp.h

@@ -0,0 +1,191 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+/****************************************************************************
+ * Copyright 2019-2020,2021 Thomas E. Dickey                                *
+ * Copyright 1998-2005,2011 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursesapp.h,v 1.18 2021/06/17 21:26:02 tom Exp $
+
+#ifndef NCURSES_CURSESAPP_H_incl
+#define NCURSES_CURSESAPP_H_incl
+
+#include <ncursesw/cursslk.h>
+
+#if (defined(_WIN32) || defined(_WIN64))
+# define NCURSES_CXX_MAIN_NAME cursespp_main
+# define NCURSES_CXX_MAIN \
+  int main(int argc, char *argv[]) { \
+  	return NCURSES_CXX_MAIN_NAME(argc, argv); \
+  }
+#else
+# define NCURSES_CXX_MAIN_NAME main
+#endif
+NCURSES_CXX_IMPEXP int NCURSES_CXX_MAIN_NAME(int argc, char *argv[]);
+
+class NCURSES_CXX_IMPEXP NCursesApplication {
+public:
+  typedef struct _slk_link {          // This structure is used to maintain
+    struct _slk_link* prev;           // a stack of SLKs
+    Soft_Label_Key_Set* SLKs;
+  } SLK_Link;
+private:
+  static int rinit(NCursesWindow& w); // Internal Init function for title
+  static NCursesApplication* theApp;  // Global ref. to the application
+
+  static SLK_Link* slk_stack;
+
+protected:
+  static NCursesWindow* titleWindow;  // The Title Window (if any)
+
+  bool b_Colors;                      // Is this a color application?
+  NCursesWindow* Root_Window;         // This is the stdscr equiv.
+
+  // Initialization of attributes;
+  // Rewrite this in your derived class if you prefer other settings
+  virtual void init(bool bColors);
+
+  // The number of lines for the title window. Default is no title window
+  // You may rewrite this in your derived class
+  virtual int titlesize() const {
+    return 0;
+  }
+
+  // This method is called to put something into the title window initially
+  // You may rewrite this in your derived class
+  virtual void title() {
+  }
+
+  // The layout used for the Soft Label Keys. Default is to have no SLKs.
+  // You may rewrite this in your derived class
+  virtual Soft_Label_Key_Set::Label_Layout useSLKs() const {
+    return Soft_Label_Key_Set::None;
+  }
+
+  // This method is called to initialize the SLKs. Default is nothing.
+  // You may rewrite this in your derived class
+  virtual void init_labels(Soft_Label_Key_Set& S) const {
+    (void) S;
+  }
+
+  // Your derived class must implement this method. The return value must
+  // be the exit value of your application.
+  virtual int run() = 0;
+
+  // The constructor is protected, so you may use it in your derived
+  // class constructor. The argument tells whether or not you want colors.
+  NCursesApplication(bool wantColors = FALSE);
+
+  NCursesApplication& operator=(const NCursesApplication& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesApplication(const NCursesApplication& rhs)
+    : b_Colors(rhs.b_Colors),
+      Root_Window(rhs.Root_Window)
+  {
+  }
+
+  static NCursesWindow *&getTitleWindow();
+
+public:
+  virtual ~NCursesApplication() THROWS(NCursesException);
+
+  // Get a pointer to the current application object
+  static NCursesApplication* getApplication();
+
+  // This method runs the application and returns its exit value
+  int operator()(void);
+
+  // Process the commandline arguments. The default implementation simply
+  // ignores them. Your derived class may rewrite this.
+  virtual void handleArgs(int argc, char* argv[]) {
+    (void) argc;
+    (void) argv;
+  }
+
+  // Does this application use colors?
+  inline bool useColors() const {
+    return b_Colors;
+  }
+
+  // Push the Key Set S onto the SLK Stack. S then becomes the current set
+  // of Soft Labelled Keys.
+  void push(Soft_Label_Key_Set& S);
+
+  // Throw away the current set of SLKs and make the previous one the
+  // new current set.
+  bool pop();
+
+  // Retrieve the current set of Soft Labelled Keys.
+  Soft_Label_Key_Set* top() const;
+
+  // Attributes to use for menu and forms foregrounds
+  virtual chtype foregrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(1)) : A_BOLD;
+  }
+
+  // Attributes to use for menu and forms backgrounds
+  virtual chtype backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(2)) : A_NORMAL;
+  }
+
+  // Attributes to use for inactive (menu) elements
+  virtual chtype inactives() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(3)|A_DIM) : A_DIM;
+  }
+
+  // Attributes to use for (form) labels and SLKs
+  virtual chtype labels() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(4)) : A_NORMAL;
+  }
+
+  // Attributes to use for form backgrounds
+  virtual chtype dialog_backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(4)) : A_NORMAL;
+  }
+
+  // Attributes to use as default for (form) window backgrounds
+  virtual chtype window_backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(5)) : A_NORMAL;
+  }
+
+  // Attributes to use for the title window
+  virtual chtype screen_titles() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(6)) : A_BOLD;
+  }
+
+};
+
+#endif /* NCURSES_CURSESAPP_H_incl */

evalkit_cambrian/include/cursesw.h

@@ -0,0 +1,1581 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+// vile:cppmode
+/****************************************************************************
+ * Copyright 2019-2021,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2014,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+#ifndef NCURSES_CURSESW_H_incl
+#define NCURSES_CURSESW_H_incl 1
+
+// $Id: cursesw.h,v 1.59 2022/08/20 20:52:15 tom Exp $
+
+extern "C" {
+#  include   <ncursesw/curses.h>
+}
+
+#if defined(BUILDING_NCURSES_CXX)
+# define NCURSES_CXX_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define NCURSES_CXX_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define NCURSES_CXX_WRAPPED_VAR(type,name) extern NCURSES_CXX_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define NCURSES_CXX_EXPORT(type) NCURSES_CXX_IMPEXP type NCURSES_API
+#define NCURSES_CXX_EXPORT_VAR(type) NCURSES_CXX_IMPEXP type
+
+#include <ncursesw/etip.h>
+
+/* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
+   Undefine it here, because NCursesWindow uses lines as a method.  */
+#undef lines
+
+/* "Convert" macros to inlines. We'll define it as another symbol to avoid
+ * conflict with library symbols.
+ */
+#undef UNDEF
+#define UNDEF(name) CUR_ ##name
+
+#ifdef addch
+inline int UNDEF(addch)(chtype ch)  { return addch(ch); }
+#undef addch
+#define addch UNDEF(addch)
+#endif
+
+#ifdef addchstr
+inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); }
+#undef addchstr
+#define addchstr UNDEF(addchstr)
+#endif
+
+#ifdef addnstr
+inline int UNDEF(addnstr)(const char *str, int n)
+{ return addnstr(str, n); }
+#undef addnstr
+#define addnstr UNDEF(addnstr)
+#endif
+
+#ifdef addstr
+inline int UNDEF(addstr)(const char * str)  { return addstr(str); }
+#undef addstr
+#define addstr UNDEF(addstr)
+#endif
+
+#ifdef attroff
+inline int UNDEF(attroff)(chtype at) { return attroff(at); }
+#undef attroff
+#define attroff UNDEF(attroff)
+#endif
+
+#ifdef attron
+inline int UNDEF(attron)(chtype at) { return attron(at); }
+#undef attron
+#define attron UNDEF(attron)
+#endif
+
+#ifdef attrset
+inline chtype UNDEF(attrset)(chtype at) { return attrset(at); }
+#undef attrset
+#define attrset UNDEF(attrset)
+#endif
+
+#ifdef bkgd
+inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }
+#undef bkgd
+#define bkgd UNDEF(bkgd)
+#endif
+
+#ifdef bkgdset
+inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }
+#undef bkgdset
+#define bkgdset UNDEF(bkgdset)
+#endif
+
+#ifdef border
+inline int UNDEF(border)(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br)
+{ return border(ls, rs, ts, bs, tl, tr, bl, br); }
+#undef border
+#define border UNDEF(border)
+#endif
+
+#ifdef box
+inline int UNDEF(box)(WINDOW *win, int v, int h) { return box(win, v, h); }
+#undef box
+#define box UNDEF(box)
+#endif
+
+#ifdef chgat
+inline int UNDEF(chgat)(int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return chgat(n, attr, color, opts); }
+#undef chgat
+#define chgat UNDEF(chgat)
+#endif
+
+#ifdef clear
+inline int UNDEF(clear)()  { return clear(); }
+#undef clear
+#define clear UNDEF(clear)
+#endif
+
+#ifdef clearok
+inline int UNDEF(clearok)(WINDOW* win, bool bf)  { return clearok(win, bf); }
+#undef clearok
+#define clearok UNDEF(clearok)
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API clearok(WINDOW*, bool);
+#endif
+
+#ifdef clrtobot
+inline int UNDEF(clrtobot)()  { return clrtobot(); }
+#undef clrtobot
+#define clrtobot UNDEF(clrtobot)
+#endif
+
+#ifdef clrtoeol
+inline int UNDEF(clrtoeol)()  { return clrtoeol(); }
+#undef clrtoeol
+#define clrtoeol UNDEF(clrtoeol)
+#endif
+
+#ifdef color_set
+inline chtype UNDEF(color_set)(NCURSES_PAIRS_T p, void* opts) { return color_set(p, opts); }
+#undef color_set
+#define color_set UNDEF(color_set)
+#endif
+
+#ifdef crmode
+inline int UNDEF(crmode)(void) { return crmode(); }
+#undef crmode
+#define crmode UNDEF(crmode)
+#endif
+
+#ifdef delch
+inline int UNDEF(delch)()  { return delch(); }
+#undef delch
+#define delch UNDEF(delch)
+#endif
+
+#ifdef deleteln
+inline int UNDEF(deleteln)()  { return deleteln(); }
+#undef deleteln
+#define deleteln UNDEF(deleteln)
+#endif
+
+#ifdef echochar
+inline int UNDEF(echochar)(chtype ch)  { return echochar(ch); }
+#undef echochar
+#define echochar UNDEF(echochar)
+#endif
+
+#ifdef erase
+inline int UNDEF(erase)()  { return erase(); }
+#undef erase
+#define erase UNDEF(erase)
+#endif
+
+#ifdef fixterm
+inline int UNDEF(fixterm)(void) { return fixterm(); }
+#undef fixterm
+#define fixterm UNDEF(fixterm)
+#endif
+
+#ifdef flushok
+inline int UNDEF(flushok)(WINDOW* _win, bool _bf)  {
+  return flushok(_win, _bf); }
+#undef flushok
+#define flushok UNDEF(flushok)
+#else
+#define _no_flushok
+#endif
+
+#ifdef getattrs
+inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); }
+#undef getattrs
+#define getattrs UNDEF(getattrs)
+#endif
+
+#ifdef getbegyx
+inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y, x); }
+#undef getbegyx
+#define getbegyx UNDEF(getbegyx)
+#endif
+
+#ifdef getbkgd
+inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }
+#undef getbkgd
+#define getbkgd UNDEF(getbkgd)
+#endif
+
+#ifdef getch
+inline int UNDEF(getch)()  { return getch(); }
+#undef getch
+#define getch UNDEF(getch)
+#endif
+
+#ifdef getmaxyx
+inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y, x); }
+#undef getmaxyx
+#define getmaxyx UNDEF(getmaxyx)
+#endif
+
+#ifdef getnstr
+inline int UNDEF(getnstr)(char *_str, int n)  { return getnstr(_str, n); }
+#undef getnstr
+#define getnstr UNDEF(getnstr)
+#endif
+
+#ifdef getparyx
+inline void UNDEF(getparyx)(WINDOW* win, int& y, int& x) { getparyx(win, y, x); }
+#undef getparyx
+#define getparyx UNDEF(getparyx)
+#endif
+
+#ifdef getstr
+inline int UNDEF(getstr)(char *_str)  { return getstr(_str); }
+#undef getstr
+#define getstr UNDEF(getstr)
+#endif
+
+#ifdef getyx
+inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) {
+  getyx(win, y, x); }
+#undef getyx
+#define getyx UNDEF(getyx)
+#endif
+
+#ifdef hline
+inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); }
+#undef hline
+#define hline UNDEF(hline)
+#endif
+
+#ifdef inch
+inline chtype UNDEF(inch)()  { return inch(); }
+#undef inch
+#define inch UNDEF(inch)
+#endif
+
+#ifdef inchstr
+inline int UNDEF(inchstr)(chtype *str)  { return inchstr(str); }
+#undef inchstr
+#define inchstr UNDEF(inchstr)
+#endif
+
+#ifdef innstr
+inline int UNDEF(innstr)(char *_str, int n)  { return innstr(_str, n); }
+#undef innstr
+#define innstr UNDEF(innstr)
+#endif
+
+#ifdef insch
+inline int UNDEF(insch)(chtype c)  { return insch(c); }
+#undef insch
+#define insch UNDEF(insch)
+#endif
+
+#ifdef insdelln
+inline int UNDEF(insdelln)(int n)  { return insdelln(n); }
+#undef insdelln
+#define insdelln UNDEF(insdelln)
+#endif
+
+#ifdef insertln
+inline int UNDEF(insertln)()  { return insertln(); }
+#undef insertln
+#define insertln UNDEF(insertln)
+#endif
+
+#ifdef insnstr
+inline int UNDEF(insnstr)(const char *_str, int n)  {
+  return insnstr(_str, n); }
+#undef insnstr
+#define insnstr UNDEF(insnstr)
+#endif
+
+#ifdef insstr
+inline int UNDEF(insstr)(const char *_str)  {
+  return insstr(_str); }
+#undef insstr
+#define insstr UNDEF(insstr)
+#endif
+
+#ifdef instr
+inline int UNDEF(instr)(char *_str)  { return instr(_str); }
+#undef instr
+#define instr UNDEF(instr)
+#endif
+
+#ifdef intrflush
+inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); }
+#undef intrflush
+#define intrflush UNDEF(intrflush)
+#endif
+
+#ifdef is_linetouched
+inline int UNDEF(is_linetouched)(WINDOW *w, int l)  { return is_linetouched(w,l); }
+#undef is_linetouched
+#define is_linetouched UNDEF(is_linetouched)
+#endif
+
+#ifdef leaveok
+inline int UNDEF(leaveok)(WINDOW* win, bool bf)  { return leaveok(win, bf); }
+#undef leaveok
+#define leaveok UNDEF(leaveok)
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf);
+#endif
+
+#ifdef move
+inline int UNDEF(move)(int x, int y)  { return move(x, y); }
+#undef move
+#define move UNDEF(move)
+#endif
+
+#ifdef mvaddch
+inline int UNDEF(mvaddch)(int y, int x, chtype ch)
+{ return mvaddch(y, x, ch); }
+#undef mvaddch
+#define mvaddch UNDEF(mvaddch)
+#endif
+
+#ifdef mvaddnstr
+inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)
+{ return mvaddnstr(y, x, str, n); }
+#undef mvaddnstr
+#define mvaddnstr UNDEF(mvaddnstr)
+#endif
+
+#ifdef mvaddstr
+inline int UNDEF(mvaddstr)(int y, int x, const char * str)
+{ return mvaddstr(y, x, str); }
+#undef mvaddstr
+#define mvaddstr UNDEF(mvaddstr)
+#endif
+
+#ifdef mvchgat
+inline int UNDEF(mvchgat)(int y, int x, int n,
+			  attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return mvchgat(y, x, n, attr, color, opts); }
+#undef mvchgat
+#define mvchgat UNDEF(mvchgat)
+#endif
+
+#ifdef mvdelch
+inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}
+#undef mvdelch
+#define mvdelch UNDEF(mvdelch)
+#endif
+
+#ifdef mvgetch
+inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}
+#undef mvgetch
+#define mvgetch UNDEF(mvgetch)
+#endif
+
+#ifdef mvgetnstr
+inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {
+  return mvgetnstr(y, x, str, n);}
+#undef mvgetnstr
+#define mvgetnstr UNDEF(mvgetnstr)
+#endif
+
+#ifdef mvgetstr
+inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
+#undef mvgetstr
+#define mvgetstr UNDEF(mvgetstr)
+#endif
+
+#ifdef mvinch
+inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}
+#undef mvinch
+#define mvinch UNDEF(mvinch)
+#endif
+
+#ifdef mvinnstr
+inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
+  return mvinnstr(y, x, _str, n); }
+#undef mvinnstr
+#define mvinnstr UNDEF(mvinnstr)
+#endif
+
+#ifdef mvinsch
+inline int UNDEF(mvinsch)(int y, int x, chtype c)
+{ return mvinsch(y, x, c); }
+#undef mvinsch
+#define mvinsch UNDEF(mvinsch)
+#endif
+
+#ifdef mvinsnstr
+inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {
+  return mvinsnstr(y, x, _str, n); }
+#undef mvinsnstr
+#define mvinsnstr UNDEF(mvinsnstr)
+#endif
+
+#ifdef mvinsstr
+inline int UNDEF(mvinsstr)(int y, int x, const char *_str)  {
+  return mvinsstr(y, x, _str); }
+#undef mvinsstr
+#define mvinsstr UNDEF(mvinsstr)
+#endif
+
+#ifdef mvwaddch
+inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)
+{ return mvwaddch(win, y, x, ch); }
+#undef mvwaddch
+#define mvwaddch UNDEF(mvwaddch)
+#endif
+
+#ifdef mvwaddchnstr
+inline int UNDEF(mvwaddchnstr)(WINDOW *win, int y, int x, const chtype *str, int n)
+{ return mvwaddchnstr(win, y, x, str, n); }
+#undef mvwaddchnstr
+#define mvwaddchnstr UNDEF(mvwaddchnstr)
+#endif
+
+#ifdef mvwaddchstr
+inline int UNDEF(mvwaddchstr)(WINDOW *win, int y, int x, const chtype *str)
+{ return mvwaddchstr(win, y, x, str); }
+#undef mvwaddchstr
+#define mvwaddchstr UNDEF(mvwaddchstr)
+#endif
+
+#ifdef mvwaddnstr
+inline int UNDEF(mvwaddnstr)(WINDOW *win, int y, int x, const char *str, int n)
+{ return mvwaddnstr(win, y, x, str, n); }
+#undef mvwaddnstr
+#define mvwaddnstr UNDEF(mvwaddnstr)
+#endif
+
+#ifdef mvwaddstr
+inline int UNDEF(mvwaddstr)(WINDOW *win, int y, int x, const char * str)
+{ return mvwaddstr(win, y, x, str); }
+#undef mvwaddstr
+#define mvwaddstr UNDEF(mvwaddstr)
+#endif
+
+#ifdef mvwchgat
+inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,
+			   attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return mvwchgat(win, y, x, n, attr, color, opts); }
+#undef mvwchgat
+#define mvwchgat UNDEF(mvwchgat)
+#endif
+
+#ifdef mvwdelch
+inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)
+{ return mvwdelch(win, y, x); }
+#undef mvwdelch
+#define mvwdelch UNDEF(mvwdelch)
+#endif
+
+#ifdef mvwgetch
+inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
+#undef mvwgetch
+#define mvwgetch UNDEF(mvwgetch)
+#endif
+
+#ifdef mvwgetnstr
+inline int UNDEF(mvwgetnstr)(WINDOW *win, int y, int x, char *str, int n)
+{return mvwgetnstr(win, y, x, str, n);}
+#undef mvwgetnstr
+#define mvwgetnstr UNDEF(mvwgetnstr)
+#endif
+
+#ifdef mvwgetstr
+inline int UNDEF(mvwgetstr)(WINDOW *win, int y, int x, char *str)
+{return mvwgetstr(win, y, x, str);}
+#undef mvwgetstr
+#define mvwgetstr UNDEF(mvwgetstr)
+#endif
+
+#ifdef mvwhline
+inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {
+  return mvwhline(win, y, x, c, n); }
+#undef mvwhline
+#define mvwhline UNDEF(mvwhline)
+#endif
+
+#ifdef mvwinch
+inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {
+  return mvwinch(win, y, x);}
+#undef mvwinch
+#define mvwinch UNDEF(mvwinch)
+#endif
+
+#ifdef mvwinchnstr
+inline int UNDEF(mvwinchnstr)(WINDOW *win, int y, int x, chtype *str, int n)  { return mvwinchnstr(win, y, x, str, n); }
+#undef mvwinchnstr
+#define mvwinchnstr UNDEF(mvwinchnstr)
+#endif
+
+#ifdef mvwinchstr
+inline int UNDEF(mvwinchstr)(WINDOW *win, int y, int x, chtype *str)  { return mvwinchstr(win, y, x, str); }
+#undef mvwinchstr
+#define mvwinchstr UNDEF(mvwinchstr)
+#endif
+
+#ifdef mvwinnstr
+inline int UNDEF(mvwinnstr)(WINDOW *win, int y, int x, char *_str, int n) {
+  return mvwinnstr(win, y, x, _str, n); }
+#undef mvwinnstr
+#define mvwinnstr UNDEF(mvwinnstr)
+#endif
+
+#ifdef mvwinsch
+inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)
+{ return mvwinsch(win, y, x, c); }
+#undef mvwinsch
+#define mvwinsch UNDEF(mvwinsch)
+#endif
+
+#ifdef mvwinsnstr
+inline int UNDEF(mvwinsnstr)(WINDOW *w, int y, int x, const char *_str, int n) {
+  return mvwinsnstr(w, y, x, _str, n); }
+#undef mvwinsnstr
+#define mvwinsnstr UNDEF(mvwinsnstr)
+#endif
+
+#ifdef mvwinsstr
+inline int UNDEF(mvwinsstr)(WINDOW *w, int y, int x,  const char *_str)  {
+  return mvwinsstr(w, y, x, _str); }
+#undef mvwinsstr
+#define mvwinsstr UNDEF(mvwinsstr)
+#endif
+
+#ifdef mvwvline
+inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
+  return mvwvline(win, y, x, c, n); }
+#undef mvwvline
+#define mvwvline UNDEF(mvwvline)
+#endif
+
+#ifdef napms
+inline void UNDEF(napms)(unsigned long x) { napms(x); }
+#undef napms
+#define napms UNDEF(napms)
+#endif
+
+#ifdef nocrmode
+inline int UNDEF(nocrmode)(void) { return nocrmode(); }
+#undef nocrmode
+#define nocrmode UNDEF(nocrmode)
+#endif
+
+#ifdef nodelay
+inline void UNDEF(nodelay)() { nodelay(); }
+#undef nodelay
+#define nodelay UNDEF(nodelay)
+#endif
+
+#ifdef redrawwin
+inline int UNDEF(redrawwin)(WINDOW *win)  { return redrawwin(win); }
+#undef redrawwin
+#define redrawwin UNDEF(redrawwin)
+#endif
+
+#ifdef refresh
+inline int UNDEF(refresh)()  { return refresh(); }
+#undef refresh
+#define refresh UNDEF(refresh)
+#endif
+
+#ifdef resetterm
+inline int UNDEF(resetterm)(void) { return resetterm(); }
+#undef resetterm
+#define resetterm UNDEF(resetterm)
+#endif
+
+#ifdef saveterm
+inline int UNDEF(saveterm)(void) { return saveterm(); }
+#undef saveterm
+#define saveterm UNDEF(saveterm)
+#endif
+
+#ifdef scrl
+inline int UNDEF(scrl)(int l) { return scrl(l); }
+#undef scrl
+#define scrl UNDEF(scrl)
+#endif
+
+#ifdef scroll
+inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); }
+#undef scroll
+#define scroll UNDEF(scroll)
+#endif
+
+#ifdef scrollok
+inline int UNDEF(scrollok)(WINDOW* win, bool bf)  { return scrollok(win, bf); }
+#undef scrollok
+#define scrollok UNDEF(scrollok)
+#else
+#if	defined(__NCURSES_H)
+extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool);
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char);
+#endif
+#endif
+
+#ifdef setscrreg
+inline int UNDEF(setscrreg)(int t, int b) { return setscrreg(t, b); }
+#undef setscrreg
+#define setscrreg UNDEF(setscrreg)
+#endif
+
+#ifdef standend
+inline int UNDEF(standend)()  { return standend(); }
+#undef standend
+#define standend UNDEF(standend)
+#endif
+
+#ifdef standout
+inline int UNDEF(standout)()  { return standout(); }
+#undef standout
+#define standout UNDEF(standout)
+#endif
+
+#ifdef subpad
+inline WINDOW *UNDEF(subpad)(WINDOW *p, int l, int c, int y, int x)
+{ return derwin(p, l, c, y, x); }
+#undef subpad
+#define subpad UNDEF(subpad)
+#endif
+
+#ifdef timeout
+inline void UNDEF(timeout)(int delay) { timeout(delay); }
+#undef timeout
+#define timeout UNDEF(timeout)
+#endif
+
+#ifdef touchline
+inline int UNDEF(touchline)(WINDOW *win, int s, int c)
+{ return touchline(win, s, c); }
+#undef touchline
+#define touchline UNDEF(touchline)
+#endif
+
+#ifdef touchwin
+inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); }
+#undef touchwin
+#define touchwin UNDEF(touchwin)
+#endif
+
+#ifdef untouchwin
+inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); }
+#undef untouchwin
+#define untouchwin UNDEF(untouchwin)
+#endif
+
+#ifdef vline
+inline int UNDEF(vline)(chtype ch, int n) { return vline(ch, n); }
+#undef vline
+#define vline UNDEF(vline)
+#endif
+
+#ifdef waddchstr
+inline int UNDEF(waddchstr)(WINDOW *win, chtype *at) { return waddchstr(win, at); }
+#undef waddchstr
+#define waddchstr UNDEF(waddchstr)
+#endif
+
+#ifdef waddstr
+inline int UNDEF(waddstr)(WINDOW *win, char *str) { return waddstr(win, str); }
+#undef waddstr
+#define waddstr UNDEF(waddstr)
+#endif
+
+#ifdef wattroff
+inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att); }
+#undef wattroff
+#define wattroff UNDEF(wattroff)
+#endif
+
+#ifdef wattrset
+inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att); }
+#undef wattrset
+#define wattrset UNDEF(wattrset)
+#endif
+
+#ifdef winch
+inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); }
+#undef winch
+#define winch UNDEF(winch)
+#endif
+
+#ifdef winchnstr
+inline int UNDEF(winchnstr)(WINDOW *win, chtype *str, int n)  { return winchnstr(win, str, n); }
+#undef winchnstr
+#define winchnstr UNDEF(winchnstr)
+#endif
+
+#ifdef winchstr
+inline int UNDEF(winchstr)(WINDOW *win, chtype *str)  { return winchstr(win, str); }
+#undef winchstr
+#define winchstr UNDEF(winchstr)
+#endif
+
+#ifdef winsstr
+inline int UNDEF(winsstr)(WINDOW *w, const char *_str)  {
+  return winsstr(w, _str); }
+#undef winsstr
+#define winsstr UNDEF(winsstr)
+#endif
+
+#ifdef wstandend
+inline int UNDEF(wstandend)(WINDOW *win)  { return wstandend(win); }
+#undef wstandend
+#define wstandend UNDEF(wstandend)
+#endif
+
+#ifdef wstandout
+inline int UNDEF(wstandout)(WINDOW *win)  { return wstandout(win); }
+#undef wstandout
+#define wstandout UNDEF(wstandout)
+#endif
+
+/*
+ *
+ * C++ class for windows.
+ *
+ */
+
+extern "C" int     _nc_ripoffline(int, int (*init)(WINDOW*, int));
+extern "C" int     _nc_xx_ripoff_init(WINDOW *, int);
+extern "C" int     _nc_has_mouse(void);
+
+class NCURSES_CXX_IMPEXP NCursesWindow
+{
+  friend class NCursesMenu;
+  friend class NCursesForm;
+
+private:
+  static bool    b_initialized;
+  static void    initialize();
+  void           constructing();
+  friend int     _nc_xx_ripoff_init(WINDOW *, int);
+
+  void           set_keyboard();
+
+  NCURSES_COLOR_T getcolor(int getback) const;
+  NCURSES_PAIRS_T getPair() const;
+
+  static int     setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back, NCURSES_PAIRS_T pair);
+  static int     colorInitialized;
+
+  // This private constructor is only used during the initialization
+  // of windows generated by ripoffline() calls.
+  NCursesWindow(WINDOW* win, int ncols);
+
+protected:
+  virtual void   err_handler(const char *) const THROWS(NCursesException);
+  // Signal an error with the given message text.
+
+  static long count;        // count of all active windows:
+  //   We rely on the c++ promise that
+  //   all otherwise uninitialized
+  //   static class vars are set to 0
+
+  WINDOW*        w;                // the curses WINDOW
+
+  bool           alloced;          // TRUE if we own the WINDOW
+
+  NCursesWindow* par;              // parent, if subwindow
+  NCursesWindow* subwins;          // head of subwindows list
+  NCursesWindow* sib;              // next subwindow of parent
+
+  void           kill_subwindows(); // disable all subwindows
+  // Destroy all subwindows.
+
+  /* Only for use by derived classes. They are then in charge to
+     fill the member variables correctly. */
+  NCursesWindow();
+
+public:
+  explicit NCursesWindow(WINDOW* window);   // useful only for stdscr
+
+  NCursesWindow(int nlines,        // number of lines
+		int ncols,         // number of columns
+		int begin_y,       // line origin
+		int begin_x);      // col origin
+
+  NCursesWindow(NCursesWindow& par,// parent window
+		int nlines,        // number of lines
+		int ncols,         // number of columns
+		int begin_y,       // absolute or relative
+		int begin_x,       //   origins:
+		char absrel = 'a');// if `a', begin_y & begin_x are
+  // absolute screen pos, else if `r', they are relative to par origin
+
+  NCursesWindow(NCursesWindow& par,// parent window
+		bool do_box = TRUE);
+  // this is the very common case that we want to create the subwindow that
+  // is two lines and two columns smaller and begins at (1,1).
+  // We may automatically request the box around it.
+
+  NCursesWindow& operator=(const NCursesWindow& rhs)
+  {
+    if (this != &rhs)
+      *this = rhs;
+    return *this;
+  }
+
+  NCursesWindow(const NCursesWindow& rhs)
+    : w(rhs.w), alloced(rhs.alloced), par(rhs.par), subwins(rhs.subwins), sib(rhs.sib)
+  {
+  }
+
+  virtual ~NCursesWindow() THROWS(NCursesException);
+
+  NCursesWindow Clone();
+  // Make an exact copy of the window.
+
+  // Initialization.
+  static void    useColors(void);
+  // Call this routine very early if you want to have colors.
+
+  static int ripoffline(int ripoff_lines,
+			int (*init)(NCursesWindow& win));
+  // This function is used to generate a window of ripped-of lines.
+  // If the argument is positive, lines are removed from the top, if it
+  // is negative lines are removed from the bottom. This enhances the
+  // lowlevel ripoffline() function because it uses the internal
+  // implementation that allows to remove more than just a single line.
+  // This function must be called before any other ncurses function. The
+  // creation of the window is deferred until ncurses gets initialized.
+  // The initialization function is then called.
+
+  // -------------------------------------------------------------------------
+  // terminal status
+  // -------------------------------------------------------------------------
+  int            lines() const { initialize(); return LINES; }
+  // Number of lines on terminal, *not* window
+
+  int            cols() const { initialize(); return COLS; }
+  // Number of cols  on terminal, *not* window
+
+  int            tabsize() const { initialize(); return TABSIZE; }
+  // Size of a tab on terminal, *not* window
+
+  static int     NumberOfColors();
+  // Number of available colors
+
+  int            colors() const { return NumberOfColors(); }
+  // Number of available colors
+
+  // -------------------------------------------------------------------------
+  // window status
+  // -------------------------------------------------------------------------
+  int            height() const { return maxy() + 1; }
+  // Number of lines in this window
+
+  int            width() const { return maxx() + 1; }
+  // Number of columns in this window
+
+  int            begx() const { return getbegx(w); }
+  // Column of top left corner relative to stdscr
+
+  int            begy() const { return getbegy(w); }
+  // Line of top left corner relative to stdscr
+
+  int            curx() const { return getcurx(w); }
+  // Column of top left corner relative to stdscr
+
+  int            cury() const { return getcury(w); }
+  // Line of top left corner relative to stdscr
+
+  int            maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)-1; }
+  // Largest x coord in window
+
+  int            maxy() const { return getmaxy(w) == ERR ? ERR : getmaxy(w)-1; }
+  // Largest y coord in window
+
+  NCURSES_PAIRS_T getcolor() const;
+  // Actual color pair
+
+  NCURSES_COLOR_T foreground() const { return getcolor(0); }
+  // Actual foreground color
+
+  NCURSES_COLOR_T background() const { return getcolor(1); }
+  // Actual background color
+
+  int            setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back);
+  // Set color palette entry
+
+  int            setcolor(NCURSES_PAIRS_T pair);
+  // Set actually used palette entry
+
+  // -------------------------------------------------------------------------
+  // window positioning
+  // -------------------------------------------------------------------------
+  virtual int    mvwin(int begin_y, int begin_x) {
+    return ::mvwin(w, begin_y, begin_x); }
+  // Move window to new position with the new position as top left corner.
+  // This is virtual because it is redefined in NCursesPanel.
+
+  // -------------------------------------------------------------------------
+  // coordinate positioning
+  // -------------------------------------------------------------------------
+  int            move(int y, int x) { return ::wmove(w, y, x); }
+  // Move cursor the this position
+
+  void           getyx(int& y, int& x) const { ::getyx(w, y, x); }
+  // Get current position of the cursor
+
+  void           getbegyx(int& y, int& x) const { ::getbegyx(w, y, x); }
+  // Get beginning of the window
+
+  void           getmaxyx(int& y, int& x) const { ::getmaxyx(w, y, x); }
+  // Get size of the window
+
+  void           getparyx(int& y, int& x) const { ::getparyx(w, y, x); }
+  // Get parent's beginning of the window
+
+  int            mvcur(int oldrow, int oldcol, int newrow, int newcol) const {
+    return ::mvcur(oldrow, oldcol, newrow, newcol); }
+  // Perform lowlevel cursor motion that takes effect immediately.
+
+  // -------------------------------------------------------------------------
+  // input
+  // -------------------------------------------------------------------------
+  int            getch() { return ::wgetch(w); }
+  // Get a keystroke from the window.
+
+  int            getch(int y, int x) { return ::mvwgetch(w, y, x); }
+  // Move cursor to position and get a keystroke from the window
+
+  int            getstr(char* str, int n=-1) {
+    return ::wgetnstr(w, str, n); }
+  // Read a series of characters into str until a newline or carriage return
+  // is received. Read at most n characters. If n is negative, the limit is
+  // ignored.
+
+  int            getstr(int y, int x, char* str, int n=-1) {
+    return ::mvwgetnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the getstr()
+  // as described above.
+
+  int            instr(char *s, int n=-1) { return ::winnstr(w, s, n); }
+  // Get a string of characters from the window into the buffer s. Retrieve
+  // at most n characters, if n is negative retrieve all characters up to the
+  // end of the current line. Attributes are stripped from the characters.
+
+  int            instr(int y, int x, char *s, int n=-1) {
+    return ::mvwinnstr(w, y, x, s, n); }
+  // Move the cursor to the requested position and then perform the instr()
+  // as described above.
+
+  int            scanw(const char* fmt, ...)
+    // Perform a scanw function from the window.
+#if __GNUG__ >= 2
+    __attribute__ ((format (scanf, 2, 3)));
+#else
+  ;
+#endif
+
+  int            scanw(const char*, va_list);
+    // Perform a scanw function from the window.
+
+  int            scanw(int y, int x, const char* fmt, ...)
+    // Move the cursor to the requested position and then perform a scanw
+    // from the window.
+#if __GNUG__ >= 2
+    __attribute__ ((format (scanf, 4, 5)));
+#else
+  ;
+#endif
+
+  int            scanw(int y, int x, const char* fmt, va_list);
+    // Move the cursor to the requested position and then perform a scanw
+    // from the window.
+
+  // -------------------------------------------------------------------------
+  // output
+  // -------------------------------------------------------------------------
+  int            addch(const chtype ch) { return ::waddch(w, ch); }
+  // Put attributed character to the window.
+
+  int            addch(int y, int x, const chtype ch) {
+    return ::mvwaddch(w, y, x, ch); }
+  // Move cursor to the requested position and then put attributed character
+  // to the window.
+
+  int            echochar(const chtype ch) { return ::wechochar(w, ch); }
+  // Put attributed character to the window and refresh it immediately.
+
+  int            addstr(const char* str, int n=-1) {
+    return ::waddnstr(w, str, n); }
+  // Write the string str to the window, stop writing if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            addstr(int y, int x, const char * str, int n=-1) {
+    return ::mvwaddnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the addchstr
+  // as described above.
+
+  int            addchstr(const chtype* str, int n=-1) {
+    return ::waddchnstr(w, str, n); }
+  // Write the string str to the window, stop writing if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            addchstr(int y, int x, const chtype * str, int n=-1) {
+    return ::mvwaddchnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the addchstr
+  // as described above.
+
+  int            printw(const char* fmt, ...)
+    // Do a formatted print to the window.
+#if (__GNUG__ >= 2) && !defined(printf)
+    __attribute__ ((format (printf, 2, 3)));
+#else
+  ;
+#endif
+
+  int            printw(int y, int x, const char * fmt, ...)
+    // Move the cursor and then do a formatted print to the window.
+#if (__GNUG__ >= 2) && !defined(printf)
+    __attribute__ ((format (printf, 4, 5)));
+#else
+  ;
+#endif
+
+  int            printw(const char* fmt, va_list args);
+    // Do a formatted print to the window.
+
+  int            printw(int y, int x, const char * fmt, va_list args);
+    // Move the cursor and then do a formatted print to the window.
+
+  chtype         inch() const { return ::winch(w); }
+  // Retrieve attributed character under the current cursor position.
+
+  chtype         inch(int y, int x) { return ::mvwinch(w, y, x); }
+  // Move cursor to requested position and then retrieve attributed character
+  // at this position.
+
+  int            inchstr(chtype* str, int n=-1) {
+    return ::winchnstr(w, str, n); }
+  // Read the string str from the window, stop reading if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            inchstr(int y, int x, chtype * str, int n=-1) {
+    return ::mvwinchnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the inchstr
+  // as described above.
+
+  int            insch(chtype ch) { return ::winsch(w, ch); }
+  // Insert attributed character into the window before current cursor
+  // position.
+
+  int            insch(int y, int x, chtype ch) {
+    return ::mvwinsch(w, y, x, ch); }
+  // Move cursor to requested position and then insert the attributed
+  // character before that position.
+
+  int            insertln() { return ::winsdelln(w, 1); }
+  // Insert an empty line above the current line.
+
+  int            insdelln(int n=1) { return ::winsdelln(w, n); }
+  // If n>0 insert that many lines above the current line. If n<0 delete
+  // that many lines beginning with the current line.
+
+  int            insstr(const char *s, int n=-1) {
+    return ::winsnstr(w, s, n); }
+  // Insert the string into the window before the current cursor position.
+  // Insert stops at end of string or when the limit n is reached. If n is
+  // negative, it is ignored.
+
+  int            insstr(int y, int x, const char *s, int n=-1) {
+    return ::mvwinsnstr(w, y, x, s, n); }
+  // Move the cursor to the requested position and then perform the insstr()
+  // as described above.
+
+  int            attron (chtype at) { return ::wattron (w, at); }
+  // Switch on the window attributes;
+
+  int            attroff(chtype at) { return ::wattroff(w, static_cast<int>(at)); }
+  // Switch off the window attributes;
+
+  int            attrset(chtype at) { return ::wattrset(w, static_cast<int>(at)); }
+  // Set the window attributes;
+
+  chtype         attrget() { return ::getattrs(w); }
+  // Get the window attributes;
+
+  int            color_set(NCURSES_PAIRS_T color_pair_number, void* opts=NULL) {
+    return ::wcolor_set(w, color_pair_number, opts); }
+  // Set the window color attribute;
+
+  int            chgat(int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts=NULL) {
+    return ::wchgat(w, n, attr, color, opts); }
+  // Change the attributes of the next n characters in the current line. If
+  // n is negative or greater than the number of remaining characters in the
+  // line, the attributes will be changed up to the end of the line.
+
+  int            chgat(int y, int x,
+		       int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts=NULL) {
+    return ::mvwchgat(w, y, x, n, attr, color, opts); }
+  // Move the cursor to the requested position and then perform chgat() as
+  // described above.
+
+  // -------------------------------------------------------------------------
+  // background
+  // -------------------------------------------------------------------------
+  chtype         getbkgd() const { return ::getbkgd(w); }
+  // Get current background setting.
+
+  int            bkgd(const chtype ch) { return ::wbkgd(w, ch); }
+  // Set the background property and apply it to the window.
+
+  void           bkgdset(chtype ch) { ::wbkgdset(w, ch); }
+  // Set the background property.
+
+  // -------------------------------------------------------------------------
+  // borders
+  // -------------------------------------------------------------------------
+  int            box(chtype vert=0, chtype  hor=0) {
+    return ::wborder(w, vert, vert, hor, hor, 0, 0, 0, 0); }
+  // Draw a box around the window with the given vertical and horizontal
+  // drawing characters. If you specify a zero as character, curses will try
+  // to find a "nice" character.
+
+  int            border(chtype left=0, chtype right=0,
+			chtype top =0, chtype bottom=0,
+			chtype top_left =0, chtype top_right=0,
+			chtype bottom_left =0, chtype bottom_right=0) {
+    return ::wborder(w, left, right, top, bottom, top_left, top_right,
+		     bottom_left, bottom_right); }
+  // Draw a border around the window with the given characters for the
+  // various parts of the border. If you pass zero for a character, curses
+  // will try to find "nice" characters.
+
+  // -------------------------------------------------------------------------
+  // lines and boxes
+  // -------------------------------------------------------------------------
+  int            hline(int len, chtype ch=0) { return ::whline(w, ch, len); }
+  // Draw a horizontal line of len characters with the given character. If
+  // you pass zero for the character, curses will try to find a "nice" one.
+
+  int            hline(int y, int x, int len, chtype ch=0) {
+    return ::mvwhline(w, y, x, ch, len); }
+  // Move the cursor to the requested position and then draw a horizontal line.
+
+  int            vline(int len, chtype ch=0) { return ::wvline(w, ch, len); }
+  // Draw a vertical line of len characters with the given character. If
+  // you pass zero for the character, curses will try to find a "nice" one.
+
+  int            vline(int y, int x, int len, chtype ch=0) {
+    return ::mvwvline(w, y, x, ch, len); }
+  // Move the cursor to the requested position and then draw a vertical line.
+
+  // -------------------------------------------------------------------------
+  // erasure
+  // -------------------------------------------------------------------------
+  int            erase() { return ::werase(w); }
+  // Erase the window.
+
+  int            clear() { return ::wclear(w); }
+  // Clear the window.
+
+  int            clearok(bool bf) { return ::clearok(w, bf); }
+  // Set/Reset the clear flag. If set, the next refresh() will clear the
+  // screen.
+
+  int            clrtobot() { return ::wclrtobot(w); }
+  // Clear to the end of the window.
+
+  int            clrtoeol() { return ::wclrtoeol(w); }
+  // Clear to the end of the line.
+
+  int            delch() { return ::wdelch(w); }
+  // Delete character under the cursor.
+
+  int            delch(int y, int x) { return ::mvwdelch(w, y, x); }
+  // Move cursor to requested position and delete the character under the
+  // cursor.
+
+  int            deleteln() { return ::winsdelln(w, -1); }
+  // Delete the current line.
+
+  // -------------------------------------------------------------------------
+  // screen control
+  // -------------------------------------------------------------------------
+  int            scroll(int amount=1) { return ::wscrl(w, amount); }
+  // Scroll amount lines. If amount is positive, scroll up, otherwise
+  // scroll down.
+
+  int            scrollok(bool bf) { return ::scrollok(w, bf); }
+  // If bf is TRUE, window scrolls if cursor is moved off the bottom
+  // edge of the window or a scrolling region, otherwise the cursor is left
+  // at the bottom line.
+
+  int            setscrreg(int from, int to) {
+    return ::wsetscrreg(w, from, to); }
+  // Define a soft scrolling region.
+
+  int            idlok(bool bf) { return ::idlok(w, bf); }
+  // If bf is TRUE, use insert/delete line hardware support if possible.
+  // Otherwise do it in software.
+
+  void           idcok(bool bf) { ::idcok(w, bf); }
+  // If bf is TRUE, use insert/delete character hardware support if possible.
+  // Otherwise do it in software.
+
+  int            touchline(int s, int c) { return ::touchline(w, s, c); }
+  // Mark the given lines as modified.
+
+  int            touchwin()   { return ::wtouchln(w, 0, height(), 1); }
+  // Mark the whole window as modified.
+
+  int            untouchwin() { return ::wtouchln(w, 0, height(), 0); }
+  // Mark the whole window as unmodified.
+
+  int            touchln(int s, int cnt, bool changed=TRUE) {
+    return ::wtouchln(w, s, cnt, static_cast<int>(changed ? 1 : 0)); }
+  // Mark cnt lines beginning from line s as changed or unchanged, depending
+  // on the value of the changed flag.
+
+  bool           is_linetouched(int line) const {
+    return (::is_linetouched(w, line) == TRUE ? TRUE:FALSE); }
+  // Return TRUE if line is marked as changed, FALSE otherwise
+
+  bool           is_wintouched() const {
+    return (::is_wintouched(w) ? TRUE:FALSE); }
+  // Return TRUE if window is marked as changed, FALSE otherwise
+
+  int            leaveok(bool bf) { return ::leaveok(w, bf); }
+  // If bf is TRUE, curses will leave the cursor after an update wherever
+  // it is after the update.
+
+  int            redrawln(int from, int n) { return ::wredrawln(w, from, n); }
+  // Redraw n lines starting from the requested line
+
+  int            redrawwin() { return ::wredrawln(w, 0, height()); }
+  // Redraw the whole window
+
+  int            doupdate()  { return ::doupdate(); }
+  // Do all outputs to make the physical screen looking like the virtual one
+
+  void           syncdown()  { ::wsyncdown(w); }
+  // Propagate the changes down to all descendant windows
+
+  void           syncup()    { ::wsyncup(w); }
+  // Propagate the changes up in the hierarchy
+
+  void           cursyncup() { ::wcursyncup(w); }
+  // Position the cursor in all ancestor windows corresponding to our setting
+
+  int            syncok(bool bf) { return ::syncok(w, bf); }
+  // If called with bf=TRUE, syncup() is called whenever the window is changed
+
+#ifndef _no_flushok
+  int            flushok(bool bf) { return ::flushok(w, bf); }
+#endif
+
+  void           immedok(bool bf) { ::immedok(w, bf); }
+  // If called with bf=TRUE, any change in the window will cause an
+  // automatic immediate refresh()
+
+  int            intrflush(bool bf) { return ::intrflush(w, bf); }
+
+  int            keypad(bool bf) { return ::keypad(w, bf); }
+  // If called with bf=TRUE, the application will interpret function keys.
+
+  int            nodelay(bool bf) { return ::nodelay(w, bf); }
+
+  int            meta(bool bf) { return ::meta(w, bf); }
+  // If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise
+  // 7-Bit characters are generated.
+
+  int            standout() { return ::wstandout(w); }
+  // Enable "standout" attributes
+
+  int            standend() { return ::wstandend(w); }
+  // Disable "standout" attributes
+
+  // -------------------------------------------------------------------------
+  // The next two are virtual, because we redefine them in the
+  // NCursesPanel class.
+  // -------------------------------------------------------------------------
+  virtual int    refresh() { return ::wrefresh(w); }
+  // Propagate the changes in this window to the virtual screen and call
+  // doupdate(). This is redefined in NCursesPanel.
+
+  virtual int    noutrefresh() { return ::wnoutrefresh(w); }
+  // Propagate the changes in this window to the virtual screen. This is
+  // redefined in NCursesPanel.
+
+  // -------------------------------------------------------------------------
+  // multiple window control
+  // -------------------------------------------------------------------------
+  int            overlay(NCursesWindow& win) {
+    return ::overlay(w, win.w); }
+  // Overlay this window over win.
+
+  int            overwrite(NCursesWindow& win) {
+    return ::overwrite(w, win.w); }
+  // Overwrite win with this window.
+
+  int            copywin(NCursesWindow& win,
+			 int sminrow, int smincol,
+			 int dminrow, int dmincol,
+			 int dmaxrow, int dmaxcol, bool overlaywin=TRUE) {
+    return ::copywin(w, win.w, sminrow, smincol, dminrow, dmincol,
+		     dmaxrow, dmaxcol, static_cast<int>(overlaywin ? 1 : 0)); }
+  // Overlay or overwrite the rectangle in win given by dminrow,dmincol,
+  // dmaxrow,dmaxcol with the rectangle in this window beginning at
+  // sminrow,smincol.
+
+  // -------------------------------------------------------------------------
+  // Extended functions
+  // -------------------------------------------------------------------------
+#if defined(NCURSES_EXT_FUNCS) && (NCURSES_EXT_FUNCS != 0)
+  int            wresize(int newLines, int newColumns) {
+    return ::wresize(w, newLines, newColumns); }
+#endif
+
+  // -------------------------------------------------------------------------
+  // Mouse related
+  // -------------------------------------------------------------------------
+  bool has_mouse() const;
+  // Return TRUE if terminal supports a mouse, FALSE otherwise
+
+  // -------------------------------------------------------------------------
+  // traversal support
+  // -------------------------------------------------------------------------
+  NCursesWindow*  child() { return subwins; }
+  // Get the first child window.
+
+  NCursesWindow*  sibling() { return sib; }
+  // Get the next child of my parent.
+
+  NCursesWindow*  parent() { return par; }
+  // Get my parent.
+
+  bool isDescendant(NCursesWindow& win);
+  // Return TRUE if win is a descendant of this.
+};
+
+// -------------------------------------------------------------------------
+// We leave this here for compatibility reasons.
+// -------------------------------------------------------------------------
+class NCURSES_CXX_IMPEXP NCursesColorWindow : public NCursesWindow
+{
+public:
+  explicit NCursesColorWindow(WINDOW* &window)   // useful only for stdscr
+    : NCursesWindow(window) {
+      useColors(); }
+
+  NCursesColorWindow(int nlines,        // number of lines
+		     int ncols,         // number of columns
+		     int begin_y,       // line origin
+		     int begin_x)       // col origin
+    : NCursesWindow(nlines, ncols, begin_y, begin_x) {
+      useColors(); }
+
+  NCursesColorWindow(NCursesWindow& parentWin,// parent window
+		     int nlines,        // number of lines
+		     int ncols,         // number of columns
+		     int begin_y,       // absolute or relative
+		     int begin_x,       //   origins:
+		     char absrel = 'a') // if `a', by & bx are
+    : NCursesWindow(parentWin,
+		    nlines, ncols,	// absolute screen pos,
+		    begin_y, begin_x,   // else if `r', they are
+		    absrel ) {          // relative to par origin
+      useColors(); }
+};
+
+// These enum definitions really belong inside the NCursesPad class, but only
+// recent compilers support that feature.
+
+  typedef enum {
+    REQ_PAD_REFRESH = KEY_MAX + 1,
+    REQ_PAD_UP,
+    REQ_PAD_DOWN,
+    REQ_PAD_LEFT,
+    REQ_PAD_RIGHT,
+    REQ_PAD_EXIT
+  } Pad_Request;
+
+  const Pad_Request PAD_LOW  = REQ_PAD_REFRESH;   // lowest  op-code
+  const Pad_Request PAD_HIGH = REQ_PAD_EXIT;      // highest op-code
+
+// -------------------------------------------------------------------------
+// Pad Support. We allow an association of a pad with a "real" window
+// through which the pad may be viewed.
+// -------------------------------------------------------------------------
+class NCURSES_CXX_IMPEXP NCursesPad : public NCursesWindow
+{
+private:
+  NCursesWindow* viewWin;       // the "viewport" window
+  NCursesWindow* viewSub;       // the "viewport" subwindow
+
+  int h_gridsize, v_gridsize;
+
+protected:
+  int min_row, min_col;         // top left row/col of the pads display area
+
+  NCursesWindow* Win(void) const {
+    // Get the window into which the pad should be copied (if any)
+    return (viewSub?viewSub:(viewWin?viewWin:0));
+  }
+
+  NCursesWindow* getWindow(void) const {
+    return viewWin;
+  }
+
+  NCursesWindow* getSubWindow(void) const {
+    return viewSub;
+  }
+
+  virtual int driver (int key);      // Virtualize keystroke key
+  // The driver translates the keystroke c into an Pad_Request
+
+  virtual void OnUnknownOperation(int pad_req) {
+    (void) pad_req;
+    ::beep();
+  }
+  // This is called if the driver returns an unknown op-code
+
+  virtual void OnNavigationError(int pad_req) {
+    (void) pad_req;
+    ::beep();
+  }
+  // This is called if a navigation request couldn't be satisfied
+
+  virtual void OnOperation(int pad_req) {
+    (void) pad_req;
+  };
+  // OnOperation is called if a Pad_Operation was executed and just before
+  // the refresh() operation is done.
+
+public:
+  NCursesPad(int nlines, int ncols);
+  // create a pad with the given size
+
+  NCursesPad& operator=(const NCursesPad& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesWindow::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesPad(const NCursesPad& rhs)
+    : NCursesWindow(rhs),
+      viewWin(rhs.viewWin),
+      viewSub(rhs.viewSub),
+      h_gridsize(rhs.h_gridsize),
+      v_gridsize(rhs.v_gridsize),
+      min_row(rhs.min_row),
+      min_col(rhs.min_col)
+  {
+  }
+
+  virtual ~NCursesPad() THROWS(NCursesException) {}
+
+  int echochar(const chtype ch) { return ::pechochar(w, ch); }
+  // Put the attributed character onto the pad and immediately do a
+  // prefresh().
+
+  int refresh() NCURSES_OVERRIDE;
+  // If a viewport is defined the pad is displayed in this window, otherwise
+  // this is a noop.
+
+  int refresh(int pminrow, int pmincol,
+	      int sminrow, int smincol,
+	      int smaxrow, int smaxcol) {
+    return ::prefresh(w, pminrow, pmincol,
+		      sminrow, smincol, smaxrow, smaxcol);
+  }
+  // The coordinates sminrow,smincol,smaxrow,smaxcol describe a rectangle
+  // on the screen. <b>refresh</b> copies a rectangle of this size beginning
+  // with top left corner pminrow,pmincol onto the screen and calls doupdate().
+
+  int noutrefresh() NCURSES_OVERRIDE;
+  // If a viewport is defined the pad is displayed in this window, otherwise
+  // this is a noop.
+
+  int noutrefresh(int pminrow, int pmincol,
+		  int sminrow, int smincol,
+		  int smaxrow, int smaxcol) {
+    return ::pnoutrefresh(w, pminrow, pmincol,
+			  sminrow, smincol, smaxrow, smaxcol);
+  }
+  // Does the same as refresh() but without calling doupdate().
+
+  virtual void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1);
+  // Add the window "view" as viewing window to the pad.
+
+  virtual void setSubWindow(NCursesWindow& sub);
+  // Use the subwindow "sub" of the viewport window for the actual viewing.
+  // The full viewport window is usually used to provide some decorations
+  // like frames, titles etc.
+
+  virtual void operator() (void);
+  // Perform Pad's operation
+};
+
+// A FramedPad is constructed always with a viewport window. This viewport
+// will be framed (by a box() command) and the interior of the box is the
+// viewport subwindow. On the frame we display scrollbar sliders.
+class NCURSES_CXX_IMPEXP NCursesFramedPad : public NCursesPad
+{
+protected:
+  virtual void OnOperation(int pad_req) NCURSES_OVERRIDE;
+
+public:
+  NCursesFramedPad(NCursesWindow& win, int nlines, int ncols,
+		   int v_grid = 1, int h_grid = 1)
+    : NCursesPad(nlines, ncols) {
+    NCursesPad::setWindow(win, v_grid, h_grid);
+    NCursesPad::setSubWindow(*(new NCursesWindow(win)));
+  }
+  // Construct the FramedPad with the given Window win as viewport.
+
+  virtual ~NCursesFramedPad() THROWS(NCursesException) {
+    delete getSubWindow();
+  }
+
+  void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1) NCURSES_OVERRIDE {
+    (void) view;
+    (void) v_grid;
+    (void) h_grid;
+    err_handler("Operation not allowed");
+  }
+  // Disable this call; the viewport is already defined
+
+  void setSubWindow(NCursesWindow& sub) NCURSES_OVERRIDE {
+    (void) sub;
+    err_handler("Operation not allowed");
+  }
+  // Disable this call; the viewport subwindow is already defined
+
+};
+
+#endif /* NCURSES_CURSESW_H_incl */

evalkit_cambrian/include/eti.h

@@ -0,0 +1,55 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2002,2003 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author:  Juergen Pfeifer, 1995,1997                                    *
+ ****************************************************************************/
+
+/* $Id: eti.h,v 1.9 2020/02/02 23:34:34 tom Exp $ */
+
+#ifndef NCURSES_ETI_H_incl
+#define NCURSES_ETI_H_incl 1
+
+#define	E_OK			(0)
+#define	E_SYSTEM_ERROR	 	(-1)
+#define	E_BAD_ARGUMENT	 	(-2)
+#define	E_POSTED	 	(-3)
+#define	E_CONNECTED	 	(-4)
+#define	E_BAD_STATE	 	(-5)
+#define	E_NO_ROOM	 	(-6)
+#define	E_NOT_POSTED		(-7)
+#define	E_UNKNOWN_COMMAND	(-8)
+#define	E_NO_MATCH		(-9)
+#define	E_NOT_SELECTABLE	(-10)
+#define	E_NOT_CONNECTED	        (-11)
+#define	E_REQUEST_DENIED	(-12)
+#define	E_INVALID_FIELD	        (-13)
+#define	E_CURRENT		(-14)
+
+#endif

evalkit_cambrian/include/fakemysql.h

@@ -0,0 +1,335 @@
+/*
+ * fakemysql.h --
+ *
+ *	Fake definitions of the MySQL API sufficient to build tdbc::mysql
+ *	without having an MySQL installation on the build system. This file
+ *	comprises only data type, constant and function definitions.
+ *
+ * The programmers of this file believe that it contains material not
+ * subject to copyright under the doctrines of scenes a faire and
+ * of merger of idea and expression. Accordingly, this file is in the
+ * public domain.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#ifndef FAKEMYSQL_H_INCLUDED
+#define FAKEMYSQL_H_INCLUDED
+
+#include <stddef.h>
+
+#ifndef MODULE_SCOPE
+#define MODULE_SCOPE extern
+#endif
+
+MODULE_SCOPE Tcl_LoadHandle MysqlInitStubs(Tcl_Interp*);
+
+#ifdef _WIN32
+#define STDCALL __stdcall
+#else
+#define STDCALL /* nothing */
+#endif
+
+enum enum_field_types {
+    MYSQL_TYPE_DECIMAL=0,
+    MYSQL_TYPE_TINY=1,
+    MYSQL_TYPE_SHORT=2,
+    MYSQL_TYPE_LONG=3,
+    MYSQL_TYPE_FLOAT=4,
+    MYSQL_TYPE_DOUBLE=5,
+    MYSQL_TYPE_NULL=6,
+    MYSQL_TYPE_TIMESTAMP=7,
+    MYSQL_TYPE_LONGLONG=8,
+    MYSQL_TYPE_INT24=9,
+    MYSQL_TYPE_DATE=10,
+    MYSQL_TYPE_TIME=11,
+    MYSQL_TYPE_DATETIME=12,
+    MYSQL_TYPE_YEAR=13,
+    MYSQL_TYPE_NEWDATE=14,
+    MYSQL_TYPE_VARCHAR=15,
+    MYSQL_TYPE_BIT=16,
+    MYSQL_TYPE_NEWDECIMAL=246,
+    MYSQL_TYPE_ENUM=247,
+    MYSQL_TYPE_SET=248,
+    MYSQL_TYPE_TINY_BLOB=249,
+    MYSQL_TYPE_MEDIUM_BLOB=250,
+    MYSQL_TYPE_LONG_BLOB=251,
+    MYSQL_TYPE_BLOB=252,
+    MYSQL_TYPE_VAR_STRING=253,
+    MYSQL_TYPE_STRING=254,
+    MYSQL_TYPE_GEOMETRY=255
+};
+
+enum mysql_option {
+    MYSQL_SET_CHARSET_NAME=7,
+};
+
+enum mysql_status {
+    MYSQL_STATUS_READY=0,
+};
+
+#define CLIENT_COMPRESS 	32
+#define CLIENT_INTERACTIVE 1024
+#define MYSQL_DATA_TRUNCATED 101
+#define MYSQL_ERRMSG_SIZE 512
+#define MYSQL_NO_DATA 100
+#define SCRAMBLE_LENGTH 20
+#define SQLSTATE_LENGTH 5
+
+typedef struct st_list LIST;
+typedef struct st_mem_root MEM_ROOT;
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_bind MYSQL_BIND;
+typedef struct st_mysql_field MYSQL_FIELD;
+typedef struct st_mysql_res MYSQL_RES;
+typedef char** MYSQL_ROW;
+typedef struct st_mysql_stmt MYSQL_STMT;
+typedef char my_bool;
+#ifndef Socket_defined
+typedef int	my_socket;
+#define INVALID_SOCKET -1
+#endif
+typedef Tcl_WideUInt my_ulonglong;
+typedef struct st_net NET;
+typedef struct st_used_mem USED_MEM;
+typedef struct st_vio Vio;
+
+struct st_mem_root {
+  USED_MEM *free;
+  USED_MEM *used;
+  USED_MEM *pre_alloc;
+  size_t min_malloc;
+  size_t block_size;
+  unsigned int block_num;
+  unsigned int first_block_usage;
+  void (*error_handler)(void);
+};
+
+struct st_mysql_options {
+    unsigned int connect_timeout;
+    unsigned int read_timeout;
+    unsigned int write_timeout;
+    unsigned int port;
+    unsigned int protocol;
+    unsigned long client_flag;
+    char *host;
+    char *user;
+    char *password;
+    char *unix_socket;
+    char *db;
+    struct st_dynamic_array *init_commands;
+    char *my_cnf_file;
+    char *my_cnf_group;
+    char *charset_dir;
+    char *charset_name;
+    char *ssl_key;
+    char *ssl_cert;
+    char *ssl_ca;
+    char *ssl_capath;
+    char *ssl_cipher;
+    char *shared_memory_base_name;
+    unsigned long max_allowed_packet;
+    my_bool use_ssl;
+    my_bool compress,named_pipe;
+    my_bool rpl_probe;
+    my_bool rpl_parse;
+    my_bool no_master_reads;
+#if !defined(CHECK_EMBEDDED_DIFFERENCES) || defined(EMBEDDED_LIBRARY)
+    my_bool separate_thread;
+#endif
+    enum mysql_option methods_to_use;
+    char *client_ip;
+    my_bool secure_auth;
+    my_bool report_data_truncation;
+    int (*local_infile_init)(void **, const char *, void *);
+    int (*local_infile_read)(void *, char *, unsigned int);
+    void (*local_infile_end)(void *);
+    int (*local_infile_error)(void *, char *, unsigned int);
+    void *local_infile_userdata;
+    void *extension;
+};
+
+struct st_net {
+#if !defined(CHECK_EMBEDDED_DIFFERENCES) || !defined(EMBEDDED_LIBRARY)
+    Vio *vio;
+    unsigned char *buff;
+    unsigned char *buff_end;
+    unsigned char *write_pos;
+    unsigned char *read_pos;
+    my_socket fd;
+    unsigned long remain_in_buf;
+    unsigned long length;
+    unsigned long buf_length;
+    unsigned long where_b;
+    unsigned long max_packet;
+    unsigned long max_packet_size;
+    unsigned int pkt_nr;
+    unsigned int compress_pkt_nr;
+    unsigned int write_timeout;
+    unsigned int read_timeout;
+    unsigned int retry_count;
+    int fcntl;
+    unsigned int *return_status;
+    unsigned char reading_or_writing;
+    char save_char;
+    my_bool unused0;
+    my_bool unused;
+    my_bool compress;
+    my_bool unused1;
+#endif
+    unsigned char *query_cache_query;
+    unsigned int last_errno;
+    unsigned char error;
+    my_bool unused2;
+    my_bool return_errno;
+    char last_error[MYSQL_ERRMSG_SIZE];
+    char sqlstate[SQLSTATE_LENGTH+1];
+    void *extension;
+#if defined(MYSQL_SERVER) && !defined(EMBEDDED_LIBRARY)
+    my_bool skip_big_packet;
+#endif
+};
+
+/*
+ * st_mysql differs between 5.0 and 5.1, but the 5.0 version is a
+ * strict subset, we don't use any of the 5.1 fields, and we don't
+ * ever allocate the structure ourselves.
+ */
+
+struct st_mysql {
+    NET net;
+    unsigned char *connector_fd;
+    char *host;
+    char *user;
+    char *passwd;
+    char *unix_socket;
+    char *server_version;
+    char *host_info;
+    char *info;
+    char *db;
+    struct charset_info_st *charset;
+    MYSQL_FIELD *fields;
+    MEM_ROOT field_alloc;
+    my_ulonglong affected_rows;
+    my_ulonglong insert_id;
+    my_ulonglong extra_info;
+    unsigned long thread_id;
+    unsigned long packet_length;
+    unsigned int port;
+    unsigned long client_flag;
+    unsigned long server_capabilities;
+    unsigned int protocol_version;
+    unsigned int field_count;
+    unsigned int server_status;
+    unsigned int server_language;
+    unsigned int warning_count;
+    struct st_mysql_options options;
+    enum mysql_status status;
+    my_bool free_me;
+    my_bool reconnect;
+    char scramble[SCRAMBLE_LENGTH+1];
+    my_bool rpl_pivot;
+    struct st_mysql *master;
+    struct st_mysql *next_slave;
+    struct st_mysql* last_used_slave;
+    struct st_mysql* last_used_con;
+    LIST  *stmts;
+    const struct st_mysql_methods *methods;
+    void *thd;
+    my_bool *unbuffered_fetch_owner;
+    char *info_buffer;
+};
+
+/*
+ * There are different version of the MYSQL_BIND structure before and after
+ * MySQL 5.1. We go after the fields of the structure using accessor functions
+ * so that the code in this file is compatible with both versions.
+ */
+
+struct st_mysql_bind_51 {	/* Post-5.1 */
+    unsigned long* length;
+    my_bool* is_null;
+    void* buffer;
+    my_bool* error;
+    unsigned char* row_ptr;
+    void (*store_param_func)(NET* net, MYSQL_BIND* param);
+    void (*fetch_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    void (*skip_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    unsigned long buffer_length;
+    unsigned long offset;
+    unsigned long length_value;
+    unsigned int param_number;
+    unsigned int pack_length;
+    enum enum_field_types buffer_type;
+    my_bool error_value;
+    my_bool is_unsigned;
+    my_bool long_data_used;
+    my_bool is_null_value;
+    void* extension;
+};
+
+struct st_mysql_bind_50 {	/* Pre-5.1 */
+    unsigned long* length;
+    my_bool* is_null;
+    void* buffer;
+    my_bool* error;
+    enum enum_field_types buffer_type;
+    unsigned long buffer_length;
+    unsigned char* row_ptr;
+    unsigned long offset;
+    unsigned long length_value;
+    unsigned int param_number;
+    unsigned int pack_length;
+    my_bool error_value;
+    my_bool is_unsigned;
+    my_bool long_data_used;
+    my_bool is_null_value;
+    void (*store_param_func)(NET* net, MYSQL_BIND* param);
+    void (*fetch_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    void (*skip_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+};
+
+/*
+ * There are also different versions of the MYSQL_FIELD structure; fortunately,
+ * the 5.1 version is a strict extension of the 5.0 version.
+ */
+
+struct st_mysql_field {
+    char* name;
+    char *org_name;
+    char* table;
+    char* org_table;
+    char* db;
+    char* catalog;
+    char* def;
+    unsigned long length;
+    unsigned long max_length;
+    unsigned int name_length;
+    unsigned int org_name_length;
+    unsigned int table_length;
+    unsigned int org_table_length;
+    unsigned int db_length;
+    unsigned int catalog_length;
+    unsigned int def_length;
+    unsigned int flags;
+    unsigned int decimals;
+    unsigned int charsetnr;
+    enum enum_field_types type;
+};
+struct st_mysql_field_50 {
+    struct st_mysql_field field;
+};
+struct st_mysql_field_51 {
+    struct st_mysql_field field;
+    void* extension;
+};
+#define NOT_NULL_FLAG 1
+
+#define IS_NUM(t)	((t) <= MYSQL_TYPE_INT24 || (t) == MYSQL_TYPE_YEAR || (t) == MYSQL_TYPE_NEWDECIMAL)
+
+#define mysql_library_init mysql_server_init
+#define mysql_library_end mysql_server_end
+
+#include "mysqlStubs.h"
+
+#endif /* not FAKEMYSQL_H_INCLUDED */

evalkit_cambrian/include/itclTclIntStubsFcn.h

@@ -0,0 +1,38 @@
+/* these functions are Tcl internal stubs so make an Itcl_* wrapper */
+MODULE_SCOPE void Itcl_GetVariableFullName (Tcl_Interp * interp,
+                Tcl_Var variable, Tcl_Obj * objPtr);
+MODULE_SCOPE Tcl_Var Itcl_FindNamespaceVar (Tcl_Interp * interp,
+                 const char * name, Tcl_Namespace * contextNsPtr, int flags);
+MODULE_SCOPE void Itcl_SetNamespaceResolvers (Tcl_Namespace * namespacePtr,
+        Tcl_ResolveCmdProc * cmdProc, Tcl_ResolveVarProc * varProc,
+        Tcl_ResolveCompiledVarProc * compiledVarProc);
+
+#ifndef _TCL_PROC_DEFINED
+typedef struct Tcl_Proc_ *Tcl_Proc;
+#define _TCL_PROC_DEFINED 1
+#endif
+#ifndef _TCL_RESOLVE_DEFINED
+struct Tcl_Resolve;
+#endif
+
+#define Tcl_GetOriginalCommand _Tcl_GetOriginalCommand
+#define Tcl_CreateProc _Tcl_CreateProc
+#define Tcl_ProcDeleteProc _Tcl_ProcDeleteProc
+#define Tcl_GetObjInterpProc _Tcl_GetObjInterpProc
+
+MODULE_SCOPE Tcl_Command _Tcl_GetOriginalCommand(Tcl_Command command);
+MODULE_SCOPE int _Tcl_CreateProc(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+	 const char *procName, Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr,
+        Tcl_Proc *procPtrPtr);
+MODULE_SCOPE void _Tcl_ProcDeleteProc(void *clientData);
+MODULE_SCOPE Tcl_ObjCmdProc *_Tcl_GetObjInterpProc(void);
+MODULE_SCOPE int Tcl_RenameCommand(Tcl_Interp *interp, const char *oldName,
+	const char *newName);
+MODULE_SCOPE Tcl_HashTable *Itcl_GetNamespaceChildTable(Tcl_Namespace *nsPtr);
+MODULE_SCOPE Tcl_HashTable *Itcl_GetNamespaceCommandTable(Tcl_Namespace *nsPtr);
+MODULE_SCOPE int Itcl_InitRewriteEnsemble(Tcl_Interp *interp, size_t numRemoved,
+	size_t numInserted, size_t objc, Tcl_Obj *const *objv);
+MODULE_SCOPE void Itcl_ResetRewriteEnsemble(Tcl_Interp *interp,
+        int isRootEnsemble);
+
+

evalkit_cambrian/include/menu.h

@@ -0,0 +1,281 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author:  Juergen Pfeifer, 1995,1997                                    *
+ ****************************************************************************/
+
+/* $Id: menu.h,v 1.26 2020/12/12 00:38:02 tom Exp $ */
+
+#ifndef ETI_MENU
+#define ETI_MENU
+
+#ifdef AMIGA
+#define TEXT TEXT_ncurses
+#endif
+
+#include <ncursesw/curses.h>
+#include <ncursesw/eti.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if defined(BUILDING_MENU)
+# define MENU_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define MENU_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define MENU_WRAPPED_VAR(type,name) extern MENU_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define MENU_EXPORT(type) MENU_IMPEXP type NCURSES_API
+#define MENU_EXPORT_VAR(type) MENU_IMPEXP type
+
+  typedef int Menu_Options;
+  typedef int Item_Options;
+
+/* Menu options: */
+#define O_ONEVALUE      (0x01)
+#define O_SHOWDESC      (0x02)
+#define O_ROWMAJOR      (0x04)
+#define O_IGNORECASE    (0x08)
+#define O_SHOWMATCH     (0x10)
+#define O_NONCYCLIC     (0x20)
+#define O_MOUSE_MENU    (0x40)
+
+/* Item options: */
+#define O_SELECTABLE    (0x01)
+
+#if !NCURSES_OPAQUE_MENU
+  typedef struct
+    {
+      const char *str;
+      unsigned short length;
+    }
+  TEXT;
+#endif				/* !NCURSES_OPAQUE_MENU */
+
+  struct tagMENU;
+
+  typedef struct tagITEM
+#if !NCURSES_OPAQUE_MENU
+    {
+      TEXT name;		/* name of menu item                         */
+      TEXT description;		/* description of item, optional in display  */
+      struct tagMENU *imenu;	/* Pointer to parent menu                    */
+      void *userptr;		/* Pointer to user defined per item data     */
+      Item_Options opt;		/* Item options                              */
+      short index;		/* Item number if connected to a menu        */
+      short y;			/* y and x location of item in menu          */
+      short x;
+      bool value;		/* Selection value                           */
+
+      struct tagITEM *left;	/* neighbor items                            */
+      struct tagITEM *right;
+      struct tagITEM *up;
+      struct tagITEM *down;
+
+    }
+#endif				/* !NCURSES_OPAQUE_MENU */
+  ITEM;
+
+  typedef void (*Menu_Hook) (struct tagMENU *);
+
+  typedef struct tagMENU
+#if 1				/* not yet: !NCURSES_OPAQUE_MENU   */
+    {
+      short height;		/* Nr. of chars high               */
+      short width;		/* Nr. of chars wide               */
+      short rows;		/* Nr. of items high               */
+      short cols;		/* Nr. of items wide               */
+      short frows;		/* Nr. of formatted items high     */
+      short fcols;		/* Nr. of formatted items wide     */
+      short arows;		/* Nr. of items high (actual)      */
+      short namelen;		/* Max. name length                */
+      short desclen;		/* Max. description length         */
+      short marklen;		/* Length of mark, if any          */
+      short itemlen;		/* Length of one item              */
+      short spc_desc;		/* Spacing for descriptor          */
+      short spc_cols;		/* Spacing for columns             */
+      short spc_rows;		/* Spacing for rows                */
+      char *pattern;		/* Buffer to store match chars     */
+      short pindex;		/* Index into pattern buffer       */
+      WINDOW *win;		/* Window containing menu          */
+      WINDOW *sub;		/* Subwindow for menu display      */
+      WINDOW *userwin;		/* User's window                   */
+      WINDOW *usersub;		/* User's subwindow                */
+      ITEM **items;		/* array of items                  */
+      short nitems;		/* Nr. of items in menu            */
+      ITEM *curitem;		/* Current item                    */
+      short toprow;		/* Top row of menu                 */
+      chtype fore;		/* Selection attribute             */
+      chtype back;		/* Nonselection attribute          */
+      chtype grey;		/* Inactive attribute              */
+      unsigned char pad;	/* Pad character                   */
+
+      Menu_Hook menuinit;	/* User hooks                      */
+      Menu_Hook menuterm;
+      Menu_Hook iteminit;
+      Menu_Hook itemterm;
+
+      void *userptr;		/* Pointer to menus user data      */
+      char *mark;		/* Pointer to marker string        */
+
+      Menu_Options opt;		/* Menu options                    */
+      unsigned short status;	/* Internal state of menu          */
+    }
+#endif				/* !NCURSES_OPAQUE_MENU */
+  MENU;
+
+/* Define keys */
+
+#define REQ_LEFT_ITEM           (KEY_MAX + 1)
+#define REQ_RIGHT_ITEM          (KEY_MAX + 2)
+#define REQ_UP_ITEM             (KEY_MAX + 3)
+#define REQ_DOWN_ITEM           (KEY_MAX + 4)
+#define REQ_SCR_ULINE           (KEY_MAX + 5)
+#define REQ_SCR_DLINE           (KEY_MAX + 6)
+#define REQ_SCR_DPAGE           (KEY_MAX + 7)
+#define REQ_SCR_UPAGE           (KEY_MAX + 8)
+#define REQ_FIRST_ITEM          (KEY_MAX + 9)
+#define REQ_LAST_ITEM           (KEY_MAX + 10)
+#define REQ_NEXT_ITEM           (KEY_MAX + 11)
+#define REQ_PREV_ITEM           (KEY_MAX + 12)
+#define REQ_TOGGLE_ITEM         (KEY_MAX + 13)
+#define REQ_CLEAR_PATTERN       (KEY_MAX + 14)
+#define REQ_BACK_PATTERN        (KEY_MAX + 15)
+#define REQ_NEXT_MATCH          (KEY_MAX + 16)
+#define REQ_PREV_MATCH          (KEY_MAX + 17)
+
+#define MIN_MENU_COMMAND        (KEY_MAX + 1)
+#define MAX_MENU_COMMAND        (KEY_MAX + 17)
+
+/*
+ * Some AT&T code expects MAX_COMMAND to be out-of-band not
+ * just for menu commands but for forms ones as well.
+ */
+#if defined(MAX_COMMAND)
+#  if (MAX_MENU_COMMAND > MAX_COMMAND)
+#    error Something is wrong -- MAX_MENU_COMMAND is greater than MAX_COMMAND
+#  elif (MAX_COMMAND != (KEY_MAX + 128))
+#    error Something is wrong -- MAX_COMMAND is already inconsistently defined.
+#  endif
+#else
+#  define MAX_COMMAND (KEY_MAX + 128)
+#endif
+
+/* --------- prototypes for libmenu functions ----------------------------- */
+
+  extern MENU_EXPORT(ITEM **) menu_items(const MENU *);
+  extern MENU_EXPORT(ITEM *) current_item(const MENU *);
+  extern MENU_EXPORT(ITEM *) new_item(const char *, const char *);
+
+  extern MENU_EXPORT(MENU *) new_menu(ITEM **);
+
+  extern MENU_EXPORT(Item_Options) item_opts(const ITEM *);
+  extern MENU_EXPORT(Menu_Options) menu_opts(const MENU *);
+
+  extern MENU_EXPORT(Menu_Hook) item_init(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) item_term(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) menu_init(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) menu_term(const MENU *);
+
+  extern MENU_EXPORT(WINDOW *) menu_sub(const MENU *);
+  extern MENU_EXPORT(WINDOW *) menu_win(const MENU *);
+
+  extern MENU_EXPORT(const char *) item_description(const ITEM *);
+  extern MENU_EXPORT(const char *) item_name(const ITEM *);
+  extern MENU_EXPORT(const char *) menu_mark(const MENU *);
+  extern MENU_EXPORT(const char *) menu_request_name(int);
+
+  extern MENU_EXPORT(char *) menu_pattern(const MENU *);
+
+  extern MENU_EXPORT(void *) menu_userptr(const MENU *);
+  extern MENU_EXPORT(void *) item_userptr(const ITEM *);
+
+  extern MENU_EXPORT(chtype) menu_back(const MENU *);
+  extern MENU_EXPORT(chtype) menu_fore(const MENU *);
+  extern MENU_EXPORT(chtype) menu_grey(const MENU *);
+
+  extern MENU_EXPORT(int) free_item(ITEM *);
+  extern MENU_EXPORT(int) free_menu(MENU *);
+  extern MENU_EXPORT(int) item_count(const MENU *);
+  extern MENU_EXPORT(int) item_index(const ITEM *);
+  extern MENU_EXPORT(int) item_opts_off(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) item_opts_on(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) menu_driver(MENU *, int);
+  extern MENU_EXPORT(int) menu_opts_off(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) menu_opts_on(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) menu_pad(const MENU *);
+  extern MENU_EXPORT(int) pos_menu_cursor(const MENU *);
+  extern MENU_EXPORT(int) post_menu(MENU *);
+  extern MENU_EXPORT(int) scale_menu(const MENU *, int *, int *);
+  extern MENU_EXPORT(int) set_current_item(MENU *menu, ITEM *item);
+  extern MENU_EXPORT(int) set_item_init(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_item_opts(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) set_item_term(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_item_userptr(ITEM *, void *);
+  extern MENU_EXPORT(int) set_item_value(ITEM *, bool);
+  extern MENU_EXPORT(int) set_menu_back(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_fore(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_format(MENU *, int, int);
+  extern MENU_EXPORT(int) set_menu_grey(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_init(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_menu_items(MENU *, ITEM **);
+  extern MENU_EXPORT(int) set_menu_mark(MENU *, const char *);
+  extern MENU_EXPORT(int) set_menu_opts(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) set_menu_pad(MENU *, int);
+  extern MENU_EXPORT(int) set_menu_pattern(MENU *, const char *);
+  extern MENU_EXPORT(int) set_menu_sub(MENU *, WINDOW *);
+  extern MENU_EXPORT(int) set_menu_term(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_menu_userptr(MENU *, void *);
+  extern MENU_EXPORT(int) set_menu_win(MENU *, WINDOW *);
+  extern MENU_EXPORT(int) set_top_row(MENU *, int);
+  extern MENU_EXPORT(int) top_row(const MENU *);
+  extern MENU_EXPORT(int) unpost_menu(MENU *);
+  extern MENU_EXPORT(int) menu_request_by_name(const char *);
+  extern MENU_EXPORT(int) set_menu_spacing(MENU *, int, int, int);
+  extern MENU_EXPORT(int) menu_spacing(const MENU *, int *, int *, int *);
+
+  extern MENU_EXPORT(bool) item_value(const ITEM *);
+  extern MENU_EXPORT(bool) item_visible(const ITEM *);
+
+  extern MENU_EXPORT(void) menu_format(const MENU *, int *, int *);
+
+#if NCURSES_SP_FUNCS
+  extern MENU_EXPORT(MENU *) NCURSES_SP_NAME(new_menu) (SCREEN *, ITEM **);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif				/* ETI_MENU */

evalkit_cambrian/include/pqStubs.h

@@ -0,0 +1,85 @@
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * ../generic/pqStubs.h --
+ *
+ *	Stubs for procedures in pqStubDefs.txt
+ *
+ * Generated by genExtStubs.tcl: DO NOT EDIT
+ * 2015-06-26 12:55:15Z
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+typedef struct pqStubDefs {
+
+    /* Functions from libraries: pq */
+
+    const char* (*pg_encoding_to_charPtr)(int);
+    void (*PQclearPtr)(PGresult*);
+    int (*PQclientEncodingPtr)(const PGconn*);
+    char* (*PQcmdTuplesPtr)(PGresult*);
+    PGconn* (*PQconnectdbPtr)(const char*);
+    char* (*PQerrorMessagePtr)(const PGconn*);
+    PGresult* (*PQdescribePreparedPtr)(PGconn*, const char*);
+    PGresult* (*PQexecPtr)(PGconn*, const char*);
+    PGresult* (*PQexecPreparedPtr)(PGconn*, const char*, int, const char *const*, const int*, const int*, int);
+    char* (*PQdbPtr)(const PGconn *);
+    void (*PQfinishPtr)(PGconn*);
+    char* (*PQfnamePtr)(PGresult*, int);
+    int (*PQfnumberPtr)(const PGresult*, const char*);
+    Oid (*PQftypePtr)(const PGresult*, int);
+    int (*PQgetisnullPtr)(const PGresult*, int, int);
+    int (*PQgetlengthPtr)(const PGresult*, int, int);
+    char* (*PQgetvaluePtr)(const PGresult*, int, int);
+    char* (*PQhostPtr)(const PGconn*);
+    int (*PQnfieldsPtr)(const PGresult*);
+    int (*PQnparamsPtr)(const PGresult*);
+    int (*PQntuplesPtr)(const PGresult*);
+    char* (*PQoptionsPtr)(const PGconn*);
+    Oid (*PQparamtypePtr)(const PGresult*, int);
+    char* (*PQpassPtr)(const PGconn*);
+    char* (*PQportPtr)(const PGconn*);
+    PGresult* (*PQpreparePtr)(PGconn*, const char*, const char*, int, const Oid*);
+    char* (*PQresultErrorFieldPtr)(const PGresult*, int);
+    ExecStatusType (*PQresultStatusPtr)(const PGresult*);
+    int (*PQsetClientEncodingPtr)(PGconn*, const char*);
+    PQnoticeProcessor (*PQsetNoticeProcessorPtr)(PGconn*, PQnoticeProcessor, void*);
+    ConnStatusType (*PQstatusPtr)(PGconn*);
+    char* (*PQuserPtr)(const PGconn*);
+    char* (*PQttyPtr)(const PGconn*);
+} pqStubDefs;
+#define pg_encoding_to_char (pqStubs->pg_encoding_to_charPtr)
+#define PQclear (pqStubs->PQclearPtr)
+#define PQclientEncoding (pqStubs->PQclientEncodingPtr)
+#define PQcmdTuples (pqStubs->PQcmdTuplesPtr)
+#define PQconnectdb (pqStubs->PQconnectdbPtr)
+#define PQerrorMessage (pqStubs->PQerrorMessagePtr)
+#define PQdescribePrepared (pqStubs->PQdescribePreparedPtr)
+#define PQexec (pqStubs->PQexecPtr)
+#define PQexecPrepared (pqStubs->PQexecPreparedPtr)
+#define PQdb (pqStubs->PQdbPtr)
+#define PQfinish (pqStubs->PQfinishPtr)
+#define PQfname (pqStubs->PQfnamePtr)
+#define PQfnumber (pqStubs->PQfnumberPtr)
+#define PQftype (pqStubs->PQftypePtr)
+#define PQgetisnull (pqStubs->PQgetisnullPtr)
+#define PQgetlength (pqStubs->PQgetlengthPtr)
+#define PQgetvalue (pqStubs->PQgetvaluePtr)
+#define PQhost (pqStubs->PQhostPtr)
+#define PQnfields (pqStubs->PQnfieldsPtr)
+#define PQnparams (pqStubs->PQnparamsPtr)
+#define PQntuples (pqStubs->PQntuplesPtr)
+#define PQoptions (pqStubs->PQoptionsPtr)
+#define PQparamtype (pqStubs->PQparamtypePtr)
+#define PQpass (pqStubs->PQpassPtr)
+#define PQport (pqStubs->PQportPtr)
+#define PQprepare (pqStubs->PQpreparePtr)
+#define PQresultErrorField (pqStubs->PQresultErrorFieldPtr)
+#define PQresultStatus (pqStubs->PQresultStatusPtr)
+#define PQsetClientEncoding (pqStubs->PQsetClientEncodingPtr)
+#define PQsetNoticeProcessor (pqStubs->PQsetNoticeProcessorPtr)
+#define PQstatus (pqStubs->PQstatusPtr)
+#define PQuser (pqStubs->PQuserPtr)
+#define PQtty (pqStubs->PQttyPtr)
+MODULE_SCOPE const pqStubDefs *pqStubs;

evalkit_cambrian/include/python3.10/boolobject.h

@@ -0,0 +1,43 @@
+/* Boolean object interface */
+
+#ifndef Py_BOOLOBJECT_H
+#define Py_BOOLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_DATA(PyTypeObject) PyBool_Type;
+
+#define PyBool_Check(x) Py_IS_TYPE(x, &PyBool_Type)
+
+/* Py_False and Py_True are the only two bools in existence.
+Don't forget to apply Py_INCREF() when returning either!!! */
+
+/* Don't use these directly */
+PyAPI_DATA(struct _longobject) _Py_FalseStruct;
+PyAPI_DATA(struct _longobject) _Py_TrueStruct;
+
+/* Use these macros */
+#define Py_False ((PyObject *) &_Py_FalseStruct)
+#define Py_True ((PyObject *) &_Py_TrueStruct)
+
+// Test if an object is the True singleton, the same as "x is True" in Python.
+PyAPI_FUNC(int) Py_IsTrue(PyObject *x);
+#define Py_IsTrue(x) Py_Is((x), Py_True)
+
+// Test if an object is the False singleton, the same as "x is False" in Python.
+PyAPI_FUNC(int) Py_IsFalse(PyObject *x);
+#define Py_IsFalse(x) Py_Is((x), Py_False)
+
+/* Macros for returning Py_True or Py_False, respectively */
+#define Py_RETURN_TRUE return Py_NewRef(Py_True)
+#define Py_RETURN_FALSE return Py_NewRef(Py_False)
+
+/* Function to return a bool from a C long */
+PyAPI_FUNC(PyObject *) PyBool_FromLong(long);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BOOLOBJECT_H */

evalkit_cambrian/include/python3.10/cellobject.h

@@ -0,0 +1,29 @@
+/* Cell object interface */
+#ifndef Py_LIMITED_API
+#ifndef Py_CELLOBJECT_H
+#define Py_CELLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *ob_ref;       /* Content of the cell or NULL when empty */
+} PyCellObject;
+
+PyAPI_DATA(PyTypeObject) PyCell_Type;
+
+#define PyCell_Check(op) Py_IS_TYPE(op, &PyCell_Type)
+
+PyAPI_FUNC(PyObject *) PyCell_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
+PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *);
+
+#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
+#define PyCell_SET(op, v) ((void)(((PyCellObject *)(op))->ob_ref = v))
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TUPLEOBJECT_H */
+#endif /* Py_LIMITED_API */

evalkit_cambrian/include/python3.10/ceval.h

@@ -0,0 +1,158 @@
+#ifndef Py_CEVAL_H
+#define Py_CEVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Interface to random parts in ceval.c */
+
+/* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction
+ * and PyEval_CallMethod are deprecated. Since they are officially part of the
+ * stable ABI (PEP 384), they must be kept for backward compatibility.
+ * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are
+ * recommended to call a callable object.
+ */
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
+    PyObject *callable,
+    PyObject *args,
+    PyObject *kwargs);
+
+/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */
+#define PyEval_CallObject(callable, arg) \
+    PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL)
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction(
+    PyObject *callable, const char *format, ...);
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod(
+    PyObject *obj, const char *name, const char *format, ...);
+
+PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
+PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
+PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
+PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void);
+
+PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
+PyAPI_FUNC(int) Py_MakePendingCalls(void);
+
+/* Protection against deeply nested recursive calls
+
+   In Python 3.0, this protection has two levels:
+   * normal anti-recursion protection is triggered when the recursion level
+     exceeds the current recursion limit. It raises a RecursionError, and sets
+     the "overflowed" flag in the thread state structure. This flag
+     temporarily *disables* the normal protection; this allows cleanup code
+     to potentially outgrow the recursion limit while processing the
+     RecursionError.
+   * "last chance" anti-recursion protection is triggered when the recursion
+     level exceeds "current recursion limit + 50". By construction, this
+     protection can only be triggered when the "overflowed" flag is set. It
+     means the cleanup code has itself gone into an infinite loop, or the
+     RecursionError has been mistakingly ignored. When this protection is
+     triggered, the interpreter aborts with a Fatal Error.
+
+   In addition, the "overflowed" flag is automatically reset when the
+   recursion level drops below "current recursion limit - 50". This heuristic
+   is meant to ensure that the normal anti-recursion protection doesn't get
+   disabled too long.
+
+   Please note: this scheme has its own limitations. See:
+   http://mail.python.org/pipermail/python-dev/2008-August/082106.html
+   for some observations.
+*/
+PyAPI_FUNC(void) Py_SetRecursionLimit(int);
+PyAPI_FUNC(int) Py_GetRecursionLimit(void);
+
+PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where);
+PyAPI_FUNC(void) Py_LeaveRecursiveCall(void);
+
+PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
+PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *);
+PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc);
+
+/* Interface for threads.
+
+   A module that plans to do a blocking system call (or something else
+   that lasts a long time and doesn't touch Python data) can allow other
+   threads to run as follows:
+
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
+
+   The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
+   {}-surrounded block.
+   To leave the block in the middle (e.g., with return), you must insert
+   a line containing Py_BLOCK_THREADS before the return, e.g.
+
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+
+   An alternative is:
+
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
+
+   For convenience, that the value of 'errno' is restored across
+   Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
+
+   WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
+   Py_END_ALLOW_THREADS!!!
+
+   Note that not yet all candidates have been converted to use this
+   mechanism!
+*/
+
+PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
+PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
+Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void);
+/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI.
+ * They will be removed from this header file in the future version.
+ * But they will be remained in ABI until Python 4.0.
+ */
+Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void);
+Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void);
+PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
+PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
+
+#define Py_BEGIN_ALLOW_THREADS { \
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
+
+/* Masks and values used by FORMAT_VALUE opcode. */
+#define FVC_MASK      0x3
+#define FVC_NONE      0x0
+#define FVC_STR       0x1
+#define FVC_REPR      0x2
+#define FVC_ASCII     0x3
+#define FVS_MASK      0x4
+#define FVS_HAVE_SPEC 0x4
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_CEVAL_H
+#  include  "cpython/ceval.h"
+#  undef Py_CPYTHON_CEVAL_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CEVAL_H */

evalkit_cambrian/include/python3.10/context.h

@@ -0,0 +1,81 @@
+#ifndef Py_CONTEXT_H
+#define Py_CONTEXT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+
+
+PyAPI_DATA(PyTypeObject) PyContext_Type;
+typedef struct _pycontextobject PyContext;
+
+PyAPI_DATA(PyTypeObject) PyContextVar_Type;
+typedef struct _pycontextvarobject PyContextVar;
+
+PyAPI_DATA(PyTypeObject) PyContextToken_Type;
+typedef struct _pycontexttokenobject PyContextToken;
+
+
+#define PyContext_CheckExact(o) Py_IS_TYPE(o, &PyContext_Type)
+#define PyContextVar_CheckExact(o) Py_IS_TYPE(o, &PyContextVar_Type)
+#define PyContextToken_CheckExact(o) Py_IS_TYPE(o, &PyContextToken_Type)
+
+
+PyAPI_FUNC(PyObject *) PyContext_New(void);
+PyAPI_FUNC(PyObject *) PyContext_Copy(PyObject *);
+PyAPI_FUNC(PyObject *) PyContext_CopyCurrent(void);
+
+PyAPI_FUNC(int) PyContext_Enter(PyObject *);
+PyAPI_FUNC(int) PyContext_Exit(PyObject *);
+
+
+/* Create a new context variable.
+
+   default_value can be NULL.
+*/
+PyAPI_FUNC(PyObject *) PyContextVar_New(
+    const char *name, PyObject *default_value);
+
+
+/* Get a value for the variable.
+
+   Returns -1 if an error occurred during lookup.
+
+   Returns 0 if value either was or was not found.
+
+   If value was found, *value will point to it.
+   If not, it will point to:
+
+   - default_value, if not NULL;
+   - the default value of "var", if not NULL;
+   - NULL.
+
+   '*value' will be a new ref, if not NULL.
+*/
+PyAPI_FUNC(int) PyContextVar_Get(
+    PyObject *var, PyObject *default_value, PyObject **value);
+
+
+/* Set a new value for the variable.
+   Returns NULL if an error occurs.
+*/
+PyAPI_FUNC(PyObject *) PyContextVar_Set(PyObject *var, PyObject *value);
+
+
+/* Reset a variable to its previous value.
+   Returns 0 on success, -1 on error.
+*/
+PyAPI_FUNC(int) PyContextVar_Reset(PyObject *var, PyObject *token);
+
+
+/* This method is exposed only for CPython tests. Don not use it. */
+PyAPI_FUNC(PyObject *) _PyContext_NewHamtForTests(void);
+
+
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CONTEXT_H */

evalkit_cambrian/include/python3.10/cpython/interpreteridobject.h

@@ -0,0 +1,11 @@
+#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+/* Interpreter ID Object */
+
+PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type;
+
+PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t);
+PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *);
+PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *);

evalkit_cambrian/include/python3.10/enumobject.h

@@ -0,0 +1,17 @@
+#ifndef Py_ENUMOBJECT_H
+#define Py_ENUMOBJECT_H
+
+/* Enumerate Object */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyEnum_Type;
+PyAPI_DATA(PyTypeObject) PyReversed_Type;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_ENUMOBJECT_H */

evalkit_cambrian/include/python3.10/errcode.h

@@ -0,0 +1,38 @@
+#ifndef Py_ERRCODE_H
+#define Py_ERRCODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Error codes passed around between file input, tokenizer, parser and
+   interpreter.  This is necessary so we can turn them into Python
+   exceptions at a higher level.  Note that some errors have a
+   slightly different meaning when passed from the tokenizer to the
+   parser than when passed from the parser to the interpreter; e.g.
+   the parser only returns E_EOF when it hits EOF immediately, and it
+   never returns E_OK. */
+
+#define E_OK            10      /* No error */
+#define E_EOF           11      /* End Of File */
+#define E_INTR          12      /* Interrupted */
+#define E_TOKEN         13      /* Bad token */
+#define E_SYNTAX        14      /* Syntax error */
+#define E_NOMEM         15      /* Ran out of memory */
+#define E_DONE          16      /* Parsing complete */
+#define E_ERROR         17      /* Execution error */
+#define E_TABSPACE      18      /* Inconsistent mixing of tabs and spaces */
+#define E_OVERFLOW      19      /* Node had too many children */
+#define E_TOODEEP       20      /* Too many indentation levels */
+#define E_DEDENT        21      /* No matching outer block for dedent */
+#define E_DECODE        22      /* Error in decoding into Unicode */
+#define E_EOFS          23      /* EOF in triple-quoted string */
+#define E_EOLS          24      /* EOL in single-quoted string */
+#define E_LINECONT      25      /* Unexpected characters after a line continuation */
+#define E_BADSINGLE     27      /* Ill-formed single statement input */
+#define E_INTERACT_STOP 28      /* Interactive mode stopped tokenization */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ERRCODE_H */

evalkit_cambrian/include/python3.10/eval.h

@@ -0,0 +1,27 @@
+
+/* Interface to execute compiled code */
+
+#ifndef Py_EVAL_H
+#define Py_EVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co,
+                                         PyObject *globals,
+                                         PyObject *locals,
+                                         PyObject *const *args, int argc,
+                                         PyObject *const *kwds, int kwdc,
+                                         PyObject *const *defs, int defc,
+                                         PyObject *kwdefs, PyObject *closure);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_EVAL_H */

evalkit_cambrian/include/python3.10/exports.h

@@ -0,0 +1,30 @@
+#ifndef Py_EXPORTS_H
+#define Py_EXPORTS_H
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+    #define Py_IMPORTED_SYMBOL __declspec(dllimport)
+    #define Py_EXPORTED_SYMBOL __declspec(dllexport)
+    #define Py_LOCAL_SYMBOL
+#else
+/*
+ * If we only ever used gcc >= 5, we could use __has_attribute(visibility)
+ * as a cross-platform way to determine if visibility is supported. However,
+ * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions
+ * have 4 < gcc < 5.
+ */
+    #ifndef __has_attribute
+      #define __has_attribute(x) 0  // Compatibility with non-clang compilers.
+    #endif
+    #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\
+        (defined(__clang__) && __has_attribute(visibility))
+        #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default")))
+        #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default")))
+        #define Py_LOCAL_SYMBOL  __attribute__ ((visibility ("hidden")))
+    #else
+        #define Py_IMPORTED_SYMBOL
+        #define Py_EXPORTED_SYMBOL
+        #define Py_LOCAL_SYMBOL
+    #endif
+#endif
+
+#endif /* Py_EXPORTS_H */

evalkit_cambrian/include/python3.10/frameobject.h

@@ -0,0 +1,20 @@
+/* Frame object interface */
+
+#ifndef Py_FRAMEOBJECT_H
+#define Py_FRAMEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "pyframe.h"
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_FRAMEOBJECT_H
+#  include  "cpython/frameobject.h"
+#  undef Py_CPYTHON_FRAMEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FRAMEOBJECT_H */

evalkit_cambrian/include/python3.10/interpreteridobject.h

@@ -0,0 +1,17 @@
+#ifndef Py_INTERPRETERIDOBJECT_H
+#define Py_INTERPRETERIDOBJECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_INTERPRETERIDOBJECT_H
+#  include  "cpython/interpreteridobject.h"
+#  undef Py_CPYTHON_INTERPRETERIDOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERPRETERIDOBJECT_H */

evalkit_cambrian/include/python3.10/listobject.h

@@ -0,0 +1,52 @@
+/* List object interface
+
+   Another generally useful object type is a list of object pointers.
+   This is a mutable type: the list items can be changed, and items can be
+   added or removed. Out-of-range indices or non-list objects are ignored.
+
+   WARNING: PyList_SetItem does not increment the new item's reference count,
+   but does decrement the reference count of the item it replaces, if not nil.
+   It does *decrement* the reference count if it is *not* inserted in the list.
+   Similarly, PyList_GetItem does not increment the returned item's reference
+   count.
+*/
+
+#ifndef Py_LISTOBJECT_H
+#define Py_LISTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyList_Type;
+PyAPI_DATA(PyTypeObject) PyListIter_Type;
+PyAPI_DATA(PyTypeObject) PyListRevIter_Type;
+
+#define PyList_Check(op) \
+    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
+#define PyList_CheckExact(op) Py_IS_TYPE(op, &PyList_Type)
+
+PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
+PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
+
+PyAPI_FUNC(int) PyList_Sort(PyObject *);
+PyAPI_FUNC(int) PyList_Reverse(PyObject *);
+PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_LISTOBJECT_H
+#  include  "cpython/listobject.h"
+#  undef Py_CPYTHON_LISTOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LISTOBJECT_H */

evalkit_cambrian/include/python3.10/longintrepr.h

@@ -0,0 +1,99 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_LONGINTREPR_H
+#define Py_LONGINTREPR_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* This is published for the benefit of "friends" marshal.c and _decimal.c. */
+
+/* Parameters of the integer representation.  There are two different
+   sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit
+   integer type, and one set for 15-bit digits with each digit stored in an
+   unsigned short.  The value of PYLONG_BITS_IN_DIGIT, defined either at
+   configure time or in pyport.h, is used to decide which digit size to use.
+
+   Type 'digit' should be able to hold 2*PyLong_BASE-1, and type 'twodigits'
+   should be an unsigned integer type able to hold all integers up to
+   PyLong_BASE*PyLong_BASE-1.  x_sub assumes that 'digit' is an unsigned type,
+   and that overflow is handled by taking the result modulo 2**N for some N >
+   PyLong_SHIFT.  The majority of the code doesn't care about the precise
+   value of PyLong_SHIFT, but there are some notable exceptions:
+
+   - long_pow() requires that PyLong_SHIFT be divisible by 5
+
+   - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8
+
+   - long_hash() requires that PyLong_SHIFT is *strictly* less than the number
+     of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
+     conversion functions
+
+   - the Python int <-> size_t/Py_ssize_t conversion functions expect that
+     PyLong_SHIFT is strictly less than the number of bits in a size_t
+
+   - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
+
+   - NSMALLNEGINTS and NSMALLPOSINTS should be small enough to fit in a single
+     digit; with the current values this forces PyLong_SHIFT >= 9
+
+  The values 15 and 30 should fit all of the above requirements, on any
+  platform.
+*/
+
+#if PYLONG_BITS_IN_DIGIT == 30
+typedef uint32_t digit;
+typedef int32_t sdigit; /* signed variant of digit */
+typedef uint64_t twodigits;
+typedef int64_t stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    30
+#define _PyLong_DECIMAL_SHIFT   9 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)1000000000) /* 10 ** DECIMAL_SHIFT */
+#elif PYLONG_BITS_IN_DIGIT == 15
+typedef unsigned short digit;
+typedef short sdigit; /* signed variant of digit */
+typedef unsigned long twodigits;
+typedef long stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    15
+#define _PyLong_DECIMAL_SHIFT   4 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)10000) /* 10 ** DECIMAL_SHIFT */
+#else
+#error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
+#endif
+#define PyLong_BASE     ((digit)1 << PyLong_SHIFT)
+#define PyLong_MASK     ((digit)(PyLong_BASE - 1))
+
+#if PyLong_SHIFT % 5 != 0
+#error "longobject.c requires that PyLong_SHIFT be divisible by 5"
+#endif
+
+/* Long integer representation.
+   The absolute value of a number is equal to
+        SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i)
+   Negative numbers are represented with ob_size < 0;
+   zero is represented by ob_size == 0.
+   In a normalized number, ob_digit[abs(ob_size)-1] (the most significant
+   digit) is never zero.  Also, in all cases, for all valid i,
+        0 <= ob_digit[i] <= MASK.
+   The allocation function takes care of allocating extra memory
+   so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available.
+
+   CAUTION:  Generic code manipulating subtypes of PyVarObject has to
+   aware that ints abuse  ob_size's sign bit.
+*/
+
+struct _longobject {
+    PyObject_VAR_HEAD
+    digit ob_digit[1];
+};
+
+PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
+
+/* Return a copy of src. */
+PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LONGINTREPR_H */
+#endif /* Py_LIMITED_API */

evalkit_cambrian/include/python3.10/marshal.h

@@ -0,0 +1,28 @@
+
+/* Interface for marshal.c */
+
+#ifndef Py_MARSHAL_H
+#define Py_MARSHAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define Py_MARSHAL_VERSION 4
+
+PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int);
+PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int);
+PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *);
+PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *);
+PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *);
+PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *);
+#endif
+PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *,
+                                                      Py_ssize_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MARSHAL_H */

evalkit_cambrian/include/python3.10/moduleobject.h

@@ -0,0 +1,96 @@
+
+/* Module object interface */
+
+#ifndef Py_MODULEOBJECT_H
+#define Py_MODULEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyModule_Type;
+
+#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
+#define PyModule_CheckExact(op) Py_IS_TYPE(op, &PyModule_Type)
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyModule_NewObject(
+    PyObject *name
+    );
+#endif
+PyAPI_FUNC(PyObject *) PyModule_New(
+    const char *name            /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *);
+#endif
+PyAPI_FUNC(const char *) PyModule_GetName(PyObject *);
+Py_DEPRECATED(3.2) PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *);
+PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) _PyModule_Clear(PyObject *);
+PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *);
+PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(PyObject *);
+#endif
+PyAPI_FUNC(struct PyModuleDef*) PyModule_GetDef(PyObject*);
+PyAPI_FUNC(void*) PyModule_GetState(PyObject*);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+PyAPI_FUNC(PyObject *) PyModuleDef_Init(struct PyModuleDef*);
+PyAPI_DATA(PyTypeObject) PyModuleDef_Type;
+#endif
+
+typedef struct PyModuleDef_Base {
+  PyObject_HEAD
+  PyObject* (*m_init)(void);
+  Py_ssize_t m_index;
+  PyObject* m_copy;
+} PyModuleDef_Base;
+
+#define PyModuleDef_HEAD_INIT { \
+    PyObject_HEAD_INIT(NULL)    \
+    NULL, /* m_init */          \
+    0,    /* m_index */         \
+    NULL, /* m_copy */          \
+  }
+
+struct PyModuleDef_Slot;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+typedef struct PyModuleDef_Slot{
+    int slot;
+    void *value;
+} PyModuleDef_Slot;
+
+#define Py_mod_create 1
+#define Py_mod_exec 2
+
+#ifndef Py_LIMITED_API
+#define _Py_mod_LAST_SLOT 2
+#endif
+
+#endif /* New in 3.5 */
+
+typedef struct PyModuleDef{
+  PyModuleDef_Base m_base;
+  const char* m_name;
+  const char* m_doc;
+  Py_ssize_t m_size;
+  PyMethodDef *m_methods;
+  struct PyModuleDef_Slot* m_slots;
+  traverseproc m_traverse;
+  inquiry m_clear;
+  freefunc m_free;
+} PyModuleDef;
+
+
+// Internal C API
+#ifdef Py_BUILD_CORE
+extern int _PyModule_IsExtension(PyObject *obj);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MODULEOBJECT_H */

evalkit_cambrian/include/python3.10/namespaceobject.h

@@ -0,0 +1,19 @@
+
+/* simple namespace object interface */
+
+#ifndef NAMESPACEOBJECT_H
+#define NAMESPACEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyTypeObject) _PyNamespace_Type;
+
+PyAPI_FUNC(PyObject *) _PyNamespace_New(PyObject *kwds);
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !NAMESPACEOBJECT_H */

evalkit_cambrian/include/python3.10/py_curses.h

@@ -0,0 +1,99 @@
+
+#ifndef Py_CURSES_H
+#define Py_CURSES_H
+
+#ifdef __APPLE__
+/*
+** On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards
+** against multiple definition of wchar_t.
+*/
+#ifdef _BSD_WCHAR_T_DEFINED_
+#define _WCHAR_T
+#endif
+#endif /* __APPLE__ */
+
+/* On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards
+   against multiple definition of wchar_t and wint_t. */
+#if defined(__FreeBSD__) && defined(_XOPEN_SOURCE_EXTENDED)
+# ifndef __wchar_t
+#   define __wchar_t
+# endif
+# ifndef __wint_t
+#   define __wint_t
+# endif
+#endif
+
+#if !defined(HAVE_CURSES_IS_PAD) && defined(WINDOW_HAS_FLAGS)
+/* The following definition is necessary for ncurses 5.7; without it,
+   some of [n]curses.h set NCURSES_OPAQUE to 1, and then Python
+   can't get at the WINDOW flags field. */
+#define NCURSES_OPAQUE 0
+#endif
+
+#ifdef HAVE_NCURSES_H
+#include <ncurses.h>
+#else
+#include <curses.h>
+#endif
+
+#ifdef HAVE_NCURSES_H
+/* configure was checking <curses.h>, but we will
+   use <ncurses.h>, which has some or all these features. */
+#if !defined(WINDOW_HAS_FLAGS) && !(NCURSES_OPAQUE+0)
+#define WINDOW_HAS_FLAGS 1
+#endif
+#if !defined(HAVE_CURSES_IS_PAD) && NCURSES_VERSION_PATCH+0 >= 20090906
+#define HAVE_CURSES_IS_PAD 1
+#endif
+#ifndef MVWDELCH_IS_EXPRESSION
+#define MVWDELCH_IS_EXPRESSION 1
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PyCurses_API_pointers 4
+
+/* Type declarations */
+
+typedef struct {
+    PyObject_HEAD
+    WINDOW *win;
+    char *encoding;
+} PyCursesWindowObject;
+
+#define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type)
+
+#define PyCurses_CAPSULE_NAME "_curses._C_API"
+
+
+#ifdef CURSES_MODULE
+/* This section is used when compiling _cursesmodule.c */
+
+#else
+/* This section is used in modules that use the _cursesmodule API */
+
+static void **PyCurses_API;
+
+#define PyCursesWindow_Type (*(PyTypeObject *) PyCurses_API[0])
+#define PyCursesSetupTermCalled  {if (! ((int (*)(void))PyCurses_API[1]) () ) return NULL;}
+#define PyCursesInitialised      {if (! ((int (*)(void))PyCurses_API[2]) () ) return NULL;}
+#define PyCursesInitialisedColor {if (! ((int (*)(void))PyCurses_API[3]) () ) return NULL;}
+
+#define import_curses() \
+    PyCurses_API = (void **)PyCapsule_Import(PyCurses_CAPSULE_NAME, 1);
+
+#endif
+
+/* general error messages */
+static const char catchall_ERR[]  = "curses function returned ERR";
+static const char catchall_NULL[] = "curses function returned NULL";
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !defined(Py_CURSES_H) */
+

evalkit_cambrian/include/python3.10/pycapsule.h

@@ -0,0 +1,59 @@
+
+/* Capsule objects let you wrap a C "void *" pointer in a Python
+   object.  They're a way of passing data through the Python interpreter
+   without creating your own custom type.
+
+   Capsules are used for communication between extension modules.
+   They provide a way for an extension module to export a C interface
+   to other extension modules, so that extension modules can use the
+   Python import mechanism to link to one another.
+
+   For more information, please see "c-api/capsule.html" in the
+   documentation.
+*/
+
+#ifndef Py_CAPSULE_H
+#define Py_CAPSULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyCapsule_Type;
+
+typedef void (*PyCapsule_Destructor)(PyObject *);
+
+#define PyCapsule_CheckExact(op) Py_IS_TYPE(op, &PyCapsule_Type)
+
+
+PyAPI_FUNC(PyObject *) PyCapsule_New(
+    void *pointer,
+    const char *name,
+    PyCapsule_Destructor destructor);
+
+PyAPI_FUNC(void *) PyCapsule_GetPointer(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(PyCapsule_Destructor) PyCapsule_GetDestructor(PyObject *capsule);
+
+PyAPI_FUNC(const char *) PyCapsule_GetName(PyObject *capsule);
+
+PyAPI_FUNC(void *) PyCapsule_GetContext(PyObject *capsule);
+
+PyAPI_FUNC(int) PyCapsule_IsValid(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(int) PyCapsule_SetPointer(PyObject *capsule, void *pointer);
+
+PyAPI_FUNC(int) PyCapsule_SetDestructor(PyObject *capsule, PyCapsule_Destructor destructor);
+
+PyAPI_FUNC(int) PyCapsule_SetName(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(int) PyCapsule_SetContext(PyObject *capsule, void *context);
+
+PyAPI_FUNC(void *) PyCapsule_Import(
+    const char *name,           /* UTF-8 encoded string */
+    int no_block);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CAPSULE_H */

evalkit_cambrian/include/python3.10/pyconfig.h

@@ -0,0 +1,1703 @@
+/* pyconfig.h.  Generated from pyconfig.h.in by configure.  */
+/* pyconfig.h.in.  Generated from configure.ac by autoheader.  */
+
+
+#ifndef Py_PYCONFIG_H
+#define Py_PYCONFIG_H
+
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* BUILD_GNU_TYPE + AIX_BUILDDATE are used to construct the PEP425 tag of the
+   build system. */
+/* #undef AIX_BUILDDATE */
+
+/* Define for AIX if your compiler is a genuine IBM xlC/xlC_r and you want
+   support for AIX C++ shared extension modules. */
+/* #undef AIX_GENUINE_CPLUSPLUS */
+
+/* The normal alignment of `long', in bytes. */
+#define ALIGNOF_LONG 8
+
+/* The normal alignment of `size_t', in bytes. */
+#define ALIGNOF_SIZE_T 8
+
+/* Alternative SOABI used in debug build to load C extensions built in release
+   mode */
+/* #undef ALT_SOABI */
+
+/* The Android API level. */
+/* #undef ANDROID_API_LEVEL */
+
+/* Define if C doubles are 64-bit IEEE 754 binary format, stored in ARM
+   mixed-endian order (byte order 45670123) */
+/* #undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754 */
+
+/* Define if C doubles are 64-bit IEEE 754 binary format, stored with the most
+   significant byte first */
+/* #undef DOUBLE_IS_BIG_ENDIAN_IEEE754 */
+
+/* Define if C doubles are 64-bit IEEE 754 binary format, stored with the
+   least significant byte first */
+#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 1
+
+/* Define if --enable-ipv6 is specified */
+#define ENABLE_IPV6 1
+
+/* Better isolate subinterpreters, experimental build mode. */
+/* #undef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS */
+
+/* Define to 1 if your system stores words within floats with the most
+   significant word first */
+/* #undef FLOAT_WORDS_BIGENDIAN */
+
+/* Define if flock needs to be linked with bsd library. */
+/* #undef FLOCK_NEEDS_LIBBSD */
+
+/* Define if getpgrp() must be called as getpgrp(0). */
+/* #undef GETPGRP_HAVE_ARG */
+
+/* Define to 1 if you have the `accept4' function. */
+#define HAVE_ACCEPT4 1
+
+/* Define to 1 if you have the `acosh' function. */
+#define HAVE_ACOSH 1
+
+/* struct addrinfo (netdb.h) */
+#define HAVE_ADDRINFO 1
+
+/* Define to 1 if you have the `alarm' function. */
+#define HAVE_ALARM 1
+
+/* Define if aligned memory access is required */
+/* #undef HAVE_ALIGNED_REQUIRED */
+
+/* Define to 1 if you have the <alloca.h> header file. */
+#define HAVE_ALLOCA_H 1
+
+/* Define this if your time.h defines altzone. */
+/* #undef HAVE_ALTZONE */
+
+/* Define to 1 if you have the `asinh' function. */
+#define HAVE_ASINH 1
+
+/* Define to 1 if you have the <asm/types.h> header file. */
+#define HAVE_ASM_TYPES_H 1
+
+/* Define to 1 if you have the `atanh' function. */
+#define HAVE_ATANH 1
+
+/* Define to 1 if you have the `bind_textdomain_codeset' function. */
+#define HAVE_BIND_TEXTDOMAIN_CODESET 1
+
+/* Define to 1 if you have the <bluetooth/bluetooth.h> header file. */
+/* #undef HAVE_BLUETOOTH_BLUETOOTH_H */
+
+/* Define to 1 if you have the <bluetooth.h> header file. */
+/* #undef HAVE_BLUETOOTH_H */
+
+/* Define if mbstowcs(NULL, "text", 0) does not return the number of wide
+   chars that would be converted. */
+/* #undef HAVE_BROKEN_MBSTOWCS */
+
+/* Define if nice() returns success/failure instead of the new priority. */
+/* #undef HAVE_BROKEN_NICE */
+
+/* Define if the system reports an invalid PIPE_BUF value. */
+/* #undef HAVE_BROKEN_PIPE_BUF */
+
+/* Define if poll() sets errno on invalid file descriptors. */
+/* #undef HAVE_BROKEN_POLL */
+
+/* Define if the Posix semaphores do not work on your system */
+/* #undef HAVE_BROKEN_POSIX_SEMAPHORES */
+
+/* Define if pthread_sigmask() does not work on your system. */
+/* #undef HAVE_BROKEN_PTHREAD_SIGMASK */
+
+/* define to 1 if your sem_getvalue is broken. */
+/* #undef HAVE_BROKEN_SEM_GETVALUE */
+
+/* Define if `unsetenv` does not return an int. */
+/* #undef HAVE_BROKEN_UNSETENV */
+
+/* Has builtin __atomic_load_n() and __atomic_store_n() functions */
+#define HAVE_BUILTIN_ATOMIC 1
+
+/* Define to 1 if you have the 'chflags' function. */
+/* #undef HAVE_CHFLAGS */
+
+/* Define to 1 if you have the `chown' function. */
+#define HAVE_CHOWN 1
+
+/* Define if you have the 'chroot' function. */
+#define HAVE_CHROOT 1
+
+/* Define to 1 if you have the `clock' function. */
+#define HAVE_CLOCK 1
+
+/* Define to 1 if you have the `clock_getres' function. */
+#define HAVE_CLOCK_GETRES 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if you have the `clock_settime' function. */
+#define HAVE_CLOCK_SETTIME 1
+
+/* Define to 1 if you have the `close_range' function. */
+/* #undef HAVE_CLOSE_RANGE */
+
+/* Define if the C compiler supports computed gotos. */
+#define HAVE_COMPUTED_GOTOS 1
+
+/* Define to 1 if you have the `confstr' function. */
+#define HAVE_CONFSTR 1
+
+/* Define to 1 if you have the <conio.h> header file. */
+/* #undef HAVE_CONIO_H */
+
+/* Define to 1 if you have the `copysign' function. */
+#define HAVE_COPYSIGN 1
+
+/* Define to 1 if you have the `copy_file_range' function. */
+/* #undef HAVE_COPY_FILE_RANGE */
+
+/* Define to 1 if you have the <crypt.h> header file. */
+#define HAVE_CRYPT_H 1
+
+/* Define if you have the crypt_r() function. */
+#define HAVE_CRYPT_R 1
+
+/* Define to 1 if you have the `ctermid' function. */
+#define HAVE_CTERMID 1
+
+/* Define if you have the 'ctermid_r' function. */
+/* #undef HAVE_CTERMID_R */
+
+/* Define if you have the 'filter' function. */
+#define HAVE_CURSES_FILTER 1
+
+/* Define to 1 if you have the <curses.h> header file. */
+#define HAVE_CURSES_H 1
+
+/* Define if you have the 'has_key' function. */
+#define HAVE_CURSES_HAS_KEY 1
+
+/* Define if you have the 'immedok' function. */
+#define HAVE_CURSES_IMMEDOK 1
+
+/* Define if you have the 'is_pad' function or macro. */
+#define HAVE_CURSES_IS_PAD 1
+
+/* Define if you have the 'is_term_resized' function. */
+#define HAVE_CURSES_IS_TERM_RESIZED 1
+
+/* Define if you have the 'resizeterm' function. */
+#define HAVE_CURSES_RESIZETERM 1
+
+/* Define if you have the 'resize_term' function. */
+#define HAVE_CURSES_RESIZE_TERM 1
+
+/* Define if you have the 'syncok' function. */
+#define HAVE_CURSES_SYNCOK 1
+
+/* Define if you have the 'typeahead' function. */
+#define HAVE_CURSES_TYPEAHEAD 1
+
+/* Define if you have the 'use_env' function. */
+#define HAVE_CURSES_USE_ENV 1
+
+/* Define if you have the 'wchgat' function. */
+#define HAVE_CURSES_WCHGAT 1
+
+/* Define to 1 if you have the declaration of `isfinite', and to 0 if you
+   don't. */
+#define HAVE_DECL_ISFINITE 1
+
+/* Define to 1 if you have the declaration of `isinf', and to 0 if you don't.
+   */
+#define HAVE_DECL_ISINF 1
+
+/* Define to 1 if you have the declaration of `isnan', and to 0 if you don't.
+   */
+#define HAVE_DECL_ISNAN 1
+
+/* Define to 1 if you have the declaration of `RTLD_DEEPBIND', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_DEEPBIND 1
+
+/* Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_GLOBAL 1
+
+/* Define to 1 if you have the declaration of `RTLD_LAZY', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_LAZY 1
+
+/* Define to 1 if you have the declaration of `RTLD_LOCAL', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_LOCAL 1
+
+/* Define to 1 if you have the declaration of `RTLD_MEMBER', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_MEMBER 0
+
+/* Define to 1 if you have the declaration of `RTLD_NODELETE', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_NODELETE 1
+
+/* Define to 1 if you have the declaration of `RTLD_NOLOAD', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_NOLOAD 1
+
+/* Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you
+   don't. */
+#define HAVE_DECL_RTLD_NOW 1
+
+/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't.
+   */
+/* #undef HAVE_DECL_TZNAME */
+
+/* Define to 1 if you have the device macros. */
+#define HAVE_DEVICE_MACROS 1
+
+/* Define to 1 if you have the /dev/ptc device file. */
+/* #undef HAVE_DEV_PTC */
+
+/* Define to 1 if you have the /dev/ptmx device file. */
+#define HAVE_DEV_PTMX 1
+
+/* Define to 1 if you have the <direct.h> header file. */
+/* #undef HAVE_DIRECT_H */
+
+/* Define to 1 if the dirent structure has a d_type field */
+#define HAVE_DIRENT_D_TYPE 1
+
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+   */
+#define HAVE_DIRENT_H 1
+
+/* Define if you have the 'dirfd' function or macro. */
+#define HAVE_DIRFD 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the `dlopen' function. */
+#define HAVE_DLOPEN 1
+
+/* Define to 1 if you have the `dup2' function. */
+#define HAVE_DUP2 1
+
+/* Define to 1 if you have the `dup3' function. */
+#define HAVE_DUP3 1
+
+/* Define if you have the '_dyld_shared_cache_contains_path' function. */
+/* #undef HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH */
+
+/* Defined when any dynamic module loading is enabled. */
+#define HAVE_DYNAMIC_LOADING 1
+
+/* Define to 1 if you have the <endian.h> header file. */
+#define HAVE_ENDIAN_H 1
+
+/* Define if you have the 'epoll' functions. */
+#define HAVE_EPOLL 1
+
+/* Define if you have the 'epoll_create1' function. */
+#define HAVE_EPOLL_CREATE1 1
+
+/* Define to 1 if you have the `erf' function. */
+#define HAVE_ERF 1
+
+/* Define to 1 if you have the `erfc' function. */
+#define HAVE_ERFC 1
+
+/* Define to 1 if you have the <errno.h> header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define if you have the 'eventfd' function. */
+#define HAVE_EVENTFD 1
+
+/* Define to 1 if you have the `execv' function. */
+#define HAVE_EXECV 1
+
+/* Define to 1 if you have the `explicit_bzero' function. */
+/* #undef HAVE_EXPLICIT_BZERO */
+
+/* Define to 1 if you have the `explicit_memset' function. */
+/* #undef HAVE_EXPLICIT_MEMSET */
+
+/* Define to 1 if you have the `expm1' function. */
+#define HAVE_EXPM1 1
+
+/* Define to 1 if you have the `faccessat' function. */
+#define HAVE_FACCESSAT 1
+
+/* Define if you have the 'fchdir' function. */
+#define HAVE_FCHDIR 1
+
+/* Define to 1 if you have the `fchmod' function. */
+#define HAVE_FCHMOD 1
+
+/* Define to 1 if you have the `fchmodat' function. */
+#define HAVE_FCHMODAT 1
+
+/* Define to 1 if you have the `fchown' function. */
+#define HAVE_FCHOWN 1
+
+/* Define to 1 if you have the `fchownat' function. */
+#define HAVE_FCHOWNAT 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define if you have the 'fdatasync' function. */
+#define HAVE_FDATASYNC 1
+
+/* Define to 1 if you have the `fdopendir' function. */
+#define HAVE_FDOPENDIR 1
+
+/* Define to 1 if you have the `fdwalk' function. */
+/* #undef HAVE_FDWALK */
+
+/* Define to 1 if you have the `fexecve' function. */
+#define HAVE_FEXECVE 1
+
+/* Define to 1 if you have the `finite' function. */
+#define HAVE_FINITE 1
+
+/* Define to 1 if you have the `flock' function. */
+#define HAVE_FLOCK 1
+
+/* Define to 1 if you have the `fork' function. */
+#define HAVE_FORK 1
+
+/* Define to 1 if you have the `forkpty' function. */
+#define HAVE_FORKPTY 1
+
+/* Define to 1 if you have the `fpathconf' function. */
+#define HAVE_FPATHCONF 1
+
+/* Define to 1 if you have the `fseek64' function. */
+/* #undef HAVE_FSEEK64 */
+
+/* Define to 1 if you have the `fseeko' function. */
+#define HAVE_FSEEKO 1
+
+/* Define to 1 if you have the `fstatat' function. */
+#define HAVE_FSTATAT 1
+
+/* Define to 1 if you have the `fstatvfs' function. */
+#define HAVE_FSTATVFS 1
+
+/* Define if you have the 'fsync' function. */
+#define HAVE_FSYNC 1
+
+/* Define to 1 if you have the `ftell64' function. */
+/* #undef HAVE_FTELL64 */
+
+/* Define to 1 if you have the `ftello' function. */
+#define HAVE_FTELLO 1
+
+/* Define to 1 if you have the `ftime' function. */
+#define HAVE_FTIME 1
+
+/* Define to 1 if you have the `ftruncate' function. */
+#define HAVE_FTRUNCATE 1
+
+/* Define to 1 if you have the `futimens' function. */
+#define HAVE_FUTIMENS 1
+
+/* Define to 1 if you have the `futimes' function. */
+#define HAVE_FUTIMES 1
+
+/* Define to 1 if you have the `futimesat' function. */
+#define HAVE_FUTIMESAT 1
+
+/* Define to 1 if you have the `gai_strerror' function. */
+#define HAVE_GAI_STRERROR 1
+
+/* Define to 1 if you have the `gamma' function. */
+#define HAVE_GAMMA 1
+
+/* Define if we can use gcc inline assembler to get and set mc68881 fpcr */
+/* #undef HAVE_GCC_ASM_FOR_MC68881 */
+
+/* Define if we can use x64 gcc inline assembler */
+#define HAVE_GCC_ASM_FOR_X64 1
+
+/* Define if we can use gcc inline assembler to get and set x87 control word
+   */
+#define HAVE_GCC_ASM_FOR_X87 1
+
+/* Define if your compiler provides __uint128_t */
+#define HAVE_GCC_UINT128_T 1
+
+/* Define if you have the getaddrinfo function. */
+#define HAVE_GETADDRINFO 1
+
+/* Define this if you have flockfile(), getc_unlocked(), and funlockfile() */
+#define HAVE_GETC_UNLOCKED 1
+
+/* Define to 1 if you have the `getentropy' function. */
+/* #undef HAVE_GETENTROPY */
+
+/* Define to 1 if you have the `getgrgid_r' function. */
+#define HAVE_GETGRGID_R 1
+
+/* Define to 1 if you have the `getgrnam_r' function. */
+#define HAVE_GETGRNAM_R 1
+
+/* Define to 1 if you have the `getgrouplist' function. */
+#define HAVE_GETGROUPLIST 1
+
+/* Define to 1 if you have the `getgroups' function. */
+#define HAVE_GETGROUPS 1
+
+/* Define to 1 if you have the `gethostbyname' function. */
+/* #undef HAVE_GETHOSTBYNAME */
+
+/* Define this if you have some version of gethostbyname_r() */
+#define HAVE_GETHOSTBYNAME_R 1
+
+/* Define this if you have the 3-arg version of gethostbyname_r(). */
+/* #undef HAVE_GETHOSTBYNAME_R_3_ARG */
+
+/* Define this if you have the 5-arg version of gethostbyname_r(). */
+/* #undef HAVE_GETHOSTBYNAME_R_5_ARG */
+
+/* Define this if you have the 6-arg version of gethostbyname_r(). */
+#define HAVE_GETHOSTBYNAME_R_6_ARG 1
+
+/* Define to 1 if you have the `getitimer' function. */
+#define HAVE_GETITIMER 1
+
+/* Define to 1 if you have the `getloadavg' function. */
+#define HAVE_GETLOADAVG 1
+
+/* Define to 1 if you have the `getlogin' function. */
+#define HAVE_GETLOGIN 1
+
+/* Define to 1 if you have the `getnameinfo' function. */
+#define HAVE_GETNAMEINFO 1
+
+/* Define if you have the 'getpagesize' function. */
+#define HAVE_GETPAGESIZE 1
+
+/* Define to 1 if you have the `getpeername' function. */
+#define HAVE_GETPEERNAME 1
+
+/* Define to 1 if you have the `getpgid' function. */
+#define HAVE_GETPGID 1
+
+/* Define to 1 if you have the `getpgrp' function. */
+#define HAVE_GETPGRP 1
+
+/* Define to 1 if you have the `getpid' function. */
+#define HAVE_GETPID 1
+
+/* Define to 1 if you have the `getpriority' function. */
+#define HAVE_GETPRIORITY 1
+
+/* Define to 1 if you have the `getpwent' function. */
+#define HAVE_GETPWENT 1
+
+/* Define to 1 if you have the `getpwnam_r' function. */
+#define HAVE_GETPWNAM_R 1
+
+/* Define to 1 if you have the `getpwuid_r' function. */
+#define HAVE_GETPWUID_R 1
+
+/* Define to 1 if the getrandom() function is available */
+/* #undef HAVE_GETRANDOM */
+
+/* Define to 1 if the Linux getrandom() syscall is available */
+#define HAVE_GETRANDOM_SYSCALL 1
+
+/* Define to 1 if you have the `getresgid' function. */
+#define HAVE_GETRESGID 1
+
+/* Define to 1 if you have the `getresuid' function. */
+#define HAVE_GETRESUID 1
+
+/* Define to 1 if you have the `getsid' function. */
+#define HAVE_GETSID 1
+
+/* Define to 1 if you have the `getspent' function. */
+#define HAVE_GETSPENT 1
+
+/* Define to 1 if you have the `getspnam' function. */
+#define HAVE_GETSPNAM 1
+
+/* Define to 1 if you have the `getwd' function. */
+#define HAVE_GETWD 1
+
+/* Define if glibc has incorrect _FORTIFY_SOURCE wrappers for memmove and
+   bcopy. */
+/* #undef HAVE_GLIBC_MEMMOVE_BUG */
+
+/* Define to 1 if you have the <grp.h> header file. */
+#define HAVE_GRP_H 1
+
+/* Define if you have the 'hstrerror' function. */
+#define HAVE_HSTRERROR 1
+
+/* Define this if you have le64toh() */
+#define HAVE_HTOLE64 1
+
+/* Define to 1 if you have the `hypot' function. */
+#define HAVE_HYPOT 1
+
+/* Define to 1 if you have the <ieeefp.h> header file. */
+/* #undef HAVE_IEEEFP_H */
+
+/* Define to 1 if you have the `if_nameindex' function. */
+#define HAVE_IF_NAMEINDEX 1
+
+/* Define if you have the 'inet_aton' function. */
+#define HAVE_INET_ATON 1
+
+/* Define if you have the 'inet_pton' function. */
+#define HAVE_INET_PTON 1
+
+/* Define to 1 if you have the `initgroups' function. */
+#define HAVE_INITGROUPS 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <io.h> header file. */
+/* #undef HAVE_IO_H */
+
+/* Define if gcc has the ipa-pure-const bug. */
+/* #undef HAVE_IPA_PURE_CONST_BUG */
+
+/* Define to 1 if you have the `kill' function. */
+#define HAVE_KILL 1
+
+/* Define to 1 if you have the `killpg' function. */
+#define HAVE_KILLPG 1
+
+/* Define if you have the 'kqueue' functions. */
+/* #undef HAVE_KQUEUE */
+
+/* Define to 1 if you have the <langinfo.h> header file. */
+#define HAVE_LANGINFO_H 1
+
+/* Defined to enable large file support when an off_t is bigger than a long
+   and long long is at least as big as an off_t. You may need to add some
+   flags for configuration and compilation to enable this mode. (For Solaris
+   and Linux, the necessary defines are already defined.) */
+/* #undef HAVE_LARGEFILE_SUPPORT */
+
+/* Define to 1 if you have the 'lchflags' function. */
+/* #undef HAVE_LCHFLAGS */
+
+/* Define to 1 if you have the `lchmod' function. */
+/* #undef HAVE_LCHMOD */
+
+/* Define to 1 if you have the `lchown' function. */
+#define HAVE_LCHOWN 1
+
+/* Define to 1 if you have the `lgamma' function. */
+#define HAVE_LGAMMA 1
+
+/* Define to 1 if you have the `dl' library (-ldl). */
+#define HAVE_LIBDL 1
+
+/* Define to 1 if you have the `dld' library (-ldld). */
+/* #undef HAVE_LIBDLD */
+
+/* Define to 1 if you have the `ieee' library (-lieee). */
+/* #undef HAVE_LIBIEEE */
+
+/* Define to 1 if you have the <libintl.h> header file. */
+#define HAVE_LIBINTL_H 1
+
+/* Define to build the readline module. */
+#define HAVE_LIBREADLINE 1
+
+/* Define to 1 if you have the `resolv' library (-lresolv). */
+/* #undef HAVE_LIBRESOLV */
+
+/* Define to 1 if you have the `sendfile' library (-lsendfile). */
+/* #undef HAVE_LIBSENDFILE */
+
+/* Define to 1 if you have the <libutil.h> header file. */
+/* #undef HAVE_LIBUTIL_H */
+
+/* Define to 1 if you have the `uuid' library (-luuid). */
+#define HAVE_LIBUUID 1
+
+/* Define if you have the 'link' function. */
+#define HAVE_LINK 1
+
+/* Define to 1 if you have the `linkat' function. */
+#define HAVE_LINKAT 1
+
+/* Define to 1 if you have the <linux/auxvec.h> header file. */
+#define HAVE_LINUX_AUXVEC_H 1
+
+/* Define to 1 if you have the <linux/can/bcm.h> header file. */
+#define HAVE_LINUX_CAN_BCM_H 1
+
+/* Define to 1 if you have the <linux/can.h> header file. */
+#define HAVE_LINUX_CAN_H 1
+
+/* Define to 1 if you have the <linux/can/j1939.h> header file. */
+/* #undef HAVE_LINUX_CAN_J1939_H */
+
+/* Define if compiling using Linux 3.6 or later. */
+#define HAVE_LINUX_CAN_RAW_FD_FRAMES 1
+
+/* Define to 1 if you have the <linux/can/raw.h> header file. */
+#define HAVE_LINUX_CAN_RAW_H 1
+
+/* Define if compiling using Linux 4.1 or later. */
+#define HAVE_LINUX_CAN_RAW_JOIN_FILTERS 1
+
+/* Define to 1 if you have the <linux/memfd.h> header file. */
+#define HAVE_LINUX_MEMFD_H 1
+
+/* Define to 1 if you have the <linux/netlink.h> header file. */
+#define HAVE_LINUX_NETLINK_H 1
+
+/* Define to 1 if you have the <linux/qrtr.h> header file. */
+/* #undef HAVE_LINUX_QRTR_H */
+
+/* Define to 1 if you have the <linux/random.h> header file. */
+#define HAVE_LINUX_RANDOM_H 1
+
+/* Define to 1 if you have the <linux/tipc.h> header file. */
+#define HAVE_LINUX_TIPC_H 1
+
+/* Define to 1 if you have the <linux/vm_sockets.h> header file. */
+#define HAVE_LINUX_VM_SOCKETS_H 1
+
+/* Define to 1 if you have the <linux/wait.h> header file. */
+#define HAVE_LINUX_WAIT_H 1
+
+/* Define to 1 if you have the `lockf' function. */
+#define HAVE_LOCKF 1
+
+/* Define to 1 if you have the `log1p' function. */
+#define HAVE_LOG1P 1
+
+/* Define to 1 if you have the `log2' function. */
+#define HAVE_LOG2 1
+
+/* Define to 1 if the system has the type `long double'. */
+#define HAVE_LONG_DOUBLE 1
+
+/* Define to 1 if you have the `lstat' function. */
+#define HAVE_LSTAT 1
+
+/* Define to 1 if you have the `lutimes' function. */
+#define HAVE_LUTIMES 1
+
+/* Define to 1 if you have the `madvise' function. */
+#define HAVE_MADVISE 1
+
+/* Define this if you have the makedev macro. */
+#define HAVE_MAKEDEV 1
+
+/* Define to 1 if you have the `mbrtowc' function. */
+#define HAVE_MBRTOWC 1
+
+/* Define if you have the 'memfd_create' function. */
+/* #undef HAVE_MEMFD_CREATE */
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memrchr' function. */
+#define HAVE_MEMRCHR 1
+
+/* Define to 1 if you have the `mkdirat' function. */
+#define HAVE_MKDIRAT 1
+
+/* Define to 1 if you have the `mkfifo' function. */
+#define HAVE_MKFIFO 1
+
+/* Define to 1 if you have the `mkfifoat' function. */
+#define HAVE_MKFIFOAT 1
+
+/* Define to 1 if you have the `mknod' function. */
+#define HAVE_MKNOD 1
+
+/* Define to 1 if you have the `mknodat' function. */
+#define HAVE_MKNODAT 1
+
+/* Define to 1 if you have the `mktime' function. */
+#define HAVE_MKTIME 1
+
+/* Define to 1 if you have the `mmap' function. */
+#define HAVE_MMAP 1
+
+/* Define to 1 if you have the `mremap' function. */
+#define HAVE_MREMAP 1
+
+/* Define to 1 if you have the <ncurses.h> header file. */
+#define HAVE_NCURSES_H 1
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* #undef HAVE_NDIR_H */
+
+/* Define to 1 if you have the <netpacket/packet.h> header file. */
+#define HAVE_NETPACKET_PACKET_H 1
+
+/* Define to 1 if you have the <net/if.h> header file. */
+#define HAVE_NET_IF_H 1
+
+/* Define to 1 if you have the `nice' function. */
+#define HAVE_NICE 1
+
+/* Define if the internal form of wchar_t in non-Unicode locales is not
+   Unicode. */
+/* #undef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION */
+
+/* Define to 1 if you have the `openat' function. */
+#define HAVE_OPENAT 1
+
+/* Define to 1 if you have the `openpty' function. */
+#define HAVE_OPENPTY 1
+
+/* Define to 1 if you have the `pathconf' function. */
+#define HAVE_PATHCONF 1
+
+/* Define to 1 if you have the `pause' function. */
+#define HAVE_PAUSE 1
+
+/* Define to 1 if you have the `pipe2' function. */
+#define HAVE_PIPE2 1
+
+/* Define to 1 if you have the `plock' function. */
+/* #undef HAVE_PLOCK */
+
+/* Define to 1 if you have the `poll' function. */
+#define HAVE_POLL 1
+
+/* Define to 1 if you have the <poll.h> header file. */
+#define HAVE_POLL_H 1
+
+/* Define to 1 if you have the `posix_fadvise' function. */
+#define HAVE_POSIX_FADVISE 1
+
+/* Define to 1 if you have the `posix_fallocate' function. */
+#define HAVE_POSIX_FALLOCATE 1
+
+/* Define to 1 if you have the `posix_spawn' function. */
+#define HAVE_POSIX_SPAWN 1
+
+/* Define to 1 if you have the `posix_spawnp' function. */
+#define HAVE_POSIX_SPAWNP 1
+
+/* Define to 1 if you have the `pread' function. */
+#define HAVE_PREAD 1
+
+/* Define to 1 if you have the `preadv' function. */
+#define HAVE_PREADV 1
+
+/* Define to 1 if you have the `preadv2' function. */
+/* #undef HAVE_PREADV2 */
+
+/* Define if you have the 'prlimit' functions. */
+#define HAVE_PRLIMIT 1
+
+/* Define to 1 if you have the <process.h> header file. */
+/* #undef HAVE_PROCESS_H */
+
+/* Define if your compiler supports function prototype */
+#define HAVE_PROTOTYPES 1
+
+/* Define to 1 if you have the `pthread_condattr_setclock' function. */
+#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1
+
+/* Defined for Solaris 2.6 bug in pthread header. */
+/* #undef HAVE_PTHREAD_DESTRUCTOR */
+
+/* Define to 1 if you have the `pthread_getcpuclockid' function. */
+#define HAVE_PTHREAD_GETCPUCLOCKID 1
+
+/* Define to 1 if you have the <pthread.h> header file. */
+#define HAVE_PTHREAD_H 1
+
+/* Define to 1 if you have the `pthread_init' function. */
+/* #undef HAVE_PTHREAD_INIT */
+
+/* Define to 1 if you have the `pthread_kill' function. */
+#define HAVE_PTHREAD_KILL 1
+
+/* Define to 1 if you have the `pthread_sigmask' function. */
+#define HAVE_PTHREAD_SIGMASK 1
+
+/* Define to 1 if you have the <pty.h> header file. */
+#define HAVE_PTY_H 1
+
+/* Define to 1 if you have the `pwrite' function. */
+#define HAVE_PWRITE 1
+
+/* Define to 1 if you have the `pwritev' function. */
+#define HAVE_PWRITEV 1
+
+/* Define to 1 if you have the `pwritev2' function. */
+/* #undef HAVE_PWRITEV2 */
+
+/* Define to 1 if you have the `readlink' function. */
+#define HAVE_READLINK 1
+
+/* Define to 1 if you have the `readlinkat' function. */
+#define HAVE_READLINKAT 1
+
+/* Define to 1 if you have the `readv' function. */
+#define HAVE_READV 1
+
+/* Define to 1 if you have the `realpath' function. */
+#define HAVE_REALPATH 1
+
+/* Define to 1 if you have the `renameat' function. */
+#define HAVE_RENAMEAT 1
+
+/* Define if readline supports append_history */
+#define HAVE_RL_APPEND_HISTORY 1
+
+/* Define if you can turn off readline's signal handling. */
+#define HAVE_RL_CATCH_SIGNAL 1
+
+/* Define if you have readline 2.2 */
+#define HAVE_RL_COMPLETION_APPEND_CHARACTER 1
+
+/* Define if you have readline 4.0 */
+#define HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK 1
+
+/* Define if you have readline 4.2 */
+#define HAVE_RL_COMPLETION_MATCHES 1
+
+/* Define if you have rl_completion_suppress_append */
+#define HAVE_RL_COMPLETION_SUPPRESS_APPEND 1
+
+/* Define if you have readline 4.0 */
+#define HAVE_RL_PRE_INPUT_HOOK 1
+
+/* Define if you have readline 4.0 */
+#define HAVE_RL_RESIZE_TERMINAL 1
+
+/* Define to 1 if you have the `round' function. */
+#define HAVE_ROUND 1
+
+/* Define to 1 if you have the `rtpSpawn' function. */
+/* #undef HAVE_RTPSPAWN */
+
+/* Define to 1 if you have the `sched_get_priority_max' function. */
+#define HAVE_SCHED_GET_PRIORITY_MAX 1
+
+/* Define to 1 if you have the <sched.h> header file. */
+#define HAVE_SCHED_H 1
+
+/* Define to 1 if you have the `sched_rr_get_interval' function. */
+#define HAVE_SCHED_RR_GET_INTERVAL 1
+
+/* Define to 1 if you have the `sched_setaffinity' function. */
+#define HAVE_SCHED_SETAFFINITY 1
+
+/* Define to 1 if you have the `sched_setparam' function. */
+#define HAVE_SCHED_SETPARAM 1
+
+/* Define to 1 if you have the `sched_setscheduler' function. */
+#define HAVE_SCHED_SETSCHEDULER 1
+
+/* Define to 1 if you have the `sem_clockwait' function. */
+/* #undef HAVE_SEM_CLOCKWAIT */
+
+/* Define to 1 if you have the `sem_getvalue' function. */
+#define HAVE_SEM_GETVALUE 1
+
+/* Define to 1 if you have the `sem_open' function. */
+#define HAVE_SEM_OPEN 1
+
+/* Define to 1 if you have the `sem_timedwait' function. */
+#define HAVE_SEM_TIMEDWAIT 1
+
+/* Define to 1 if you have the `sem_unlink' function. */
+#define HAVE_SEM_UNLINK 1
+
+/* Define to 1 if you have the `sendfile' function. */
+#define HAVE_SENDFILE 1
+
+/* Define to 1 if you have the `setegid' function. */
+#define HAVE_SETEGID 1
+
+/* Define to 1 if you have the `seteuid' function. */
+#define HAVE_SETEUID 1
+
+/* Define to 1 if you have the `setgid' function. */
+#define HAVE_SETGID 1
+
+/* Define if you have the 'setgroups' function. */
+#define HAVE_SETGROUPS 1
+
+/* Define to 1 if you have the `sethostname' function. */
+#define HAVE_SETHOSTNAME 1
+
+/* Define to 1 if you have the `setitimer' function. */
+#define HAVE_SETITIMER 1
+
+/* Define to 1 if you have the `setlocale' function. */
+#define HAVE_SETLOCALE 1
+
+/* Define to 1 if you have the `setpgid' function. */
+#define HAVE_SETPGID 1
+
+/* Define to 1 if you have the `setpgrp' function. */
+#define HAVE_SETPGRP 1
+
+/* Define to 1 if you have the `setpriority' function. */
+#define HAVE_SETPRIORITY 1
+
+/* Define to 1 if you have the `setregid' function. */
+#define HAVE_SETREGID 1
+
+/* Define to 1 if you have the `setresgid' function. */
+#define HAVE_SETRESGID 1
+
+/* Define to 1 if you have the `setresuid' function. */
+#define HAVE_SETRESUID 1
+
+/* Define to 1 if you have the `setreuid' function. */
+#define HAVE_SETREUID 1
+
+/* Define to 1 if you have the `setsid' function. */
+#define HAVE_SETSID 1
+
+/* Define to 1 if you have the `setuid' function. */
+#define HAVE_SETUID 1
+
+/* Define to 1 if you have the `setvbuf' function. */
+#define HAVE_SETVBUF 1
+
+/* Define to 1 if you have the <shadow.h> header file. */
+#define HAVE_SHADOW_H 1
+
+/* Define to 1 if you have the `shm_open' function. */
+#define HAVE_SHM_OPEN 1
+
+/* Define to 1 if you have the `shm_unlink' function. */
+#define HAVE_SHM_UNLINK 1
+
+/* Define to 1 if you have the `sigaction' function. */
+#define HAVE_SIGACTION 1
+
+/* Define to 1 if you have the `sigaltstack' function. */
+#define HAVE_SIGALTSTACK 1
+
+/* Define to 1 if you have the `sigfillset' function. */
+#define HAVE_SIGFILLSET 1
+
+/* Define to 1 if `si_band' is a member of `siginfo_t'. */
+#define HAVE_SIGINFO_T_SI_BAND 1
+
+/* Define to 1 if you have the `siginterrupt' function. */
+#define HAVE_SIGINTERRUPT 1
+
+/* Define to 1 if you have the <signal.h> header file. */
+#define HAVE_SIGNAL_H 1
+
+/* Define to 1 if you have the `sigpending' function. */
+#define HAVE_SIGPENDING 1
+
+/* Define to 1 if you have the `sigrelse' function. */
+#define HAVE_SIGRELSE 1
+
+/* Define to 1 if you have the `sigtimedwait' function. */
+#define HAVE_SIGTIMEDWAIT 1
+
+/* Define to 1 if you have the `sigwait' function. */
+#define HAVE_SIGWAIT 1
+
+/* Define to 1 if you have the `sigwaitinfo' function. */
+#define HAVE_SIGWAITINFO 1
+
+/* Define to 1 if you have the `snprintf' function. */
+#define HAVE_SNPRINTF 1
+
+/* struct sockaddr_alg (linux/if_alg.h) */
+#define HAVE_SOCKADDR_ALG 1
+
+/* Define if sockaddr has sa_len member */
+/* #undef HAVE_SOCKADDR_SA_LEN */
+
+/* struct sockaddr_storage (sys/socket.h) */
+#define HAVE_SOCKADDR_STORAGE 1
+
+/* Define if you have the 'socketpair' function. */
+#define HAVE_SOCKETPAIR 1
+
+/* Define to 1 if you have the <spawn.h> header file. */
+#define HAVE_SPAWN_H 1
+
+/* Define to 1 if you have the `splice' function. */
+#define HAVE_SPLICE 1
+
+/* Define if your compiler provides ssize_t */
+#define HAVE_SSIZE_T 1
+
+/* Define to 1 if you have the `statvfs' function. */
+#define HAVE_STATVFS 1
+
+/* Define if you have struct stat.st_mtim.tv_nsec */
+#define HAVE_STAT_TV_NSEC 1
+
+/* Define if you have struct stat.st_mtimensec */
+/* #undef HAVE_STAT_TV_NSEC2 */
+
+/* Define if your compiler supports variable length function prototypes (e.g.
+   void fprintf(FILE *, char *, ...);) *and* <stdarg.h> */
+#define HAVE_STDARG_PROTOTYPES 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Has stdatomic.h with atomic_int and atomic_uintptr_t */
+#define HAVE_STD_ATOMIC 1
+
+/* Define to 1 if you have the `strftime' function. */
+#define HAVE_STRFTIME 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strlcpy' function. */
+/* #undef HAVE_STRLCPY */
+
+/* Define to 1 if you have the <stropts.h> header file. */
+/* #undef HAVE_STROPTS_H */
+
+/* Define to 1 if you have the `strsignal' function. */
+#define HAVE_STRSIGNAL 1
+
+/* Define to 1 if `pw_gecos' is a member of `struct passwd'. */
+#define HAVE_STRUCT_PASSWD_PW_GECOS 1
+
+/* Define to 1 if `pw_passwd' is a member of `struct passwd'. */
+#define HAVE_STRUCT_PASSWD_PW_PASSWD 1
+
+/* Define to 1 if `st_birthtime' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_BIRTHTIME */
+
+/* Define to 1 if `st_blksize' is a member of `struct stat'. */
+#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
+
+/* Define to 1 if `st_blocks' is a member of `struct stat'. */
+#define HAVE_STRUCT_STAT_ST_BLOCKS 1
+
+/* Define to 1 if `st_flags' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_FLAGS */
+
+/* Define to 1 if `st_gen' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_GEN */
+
+/* Define to 1 if `st_rdev' is a member of `struct stat'. */
+#define HAVE_STRUCT_STAT_ST_RDEV 1
+
+/* Define to 1 if `tm_zone' is a member of `struct tm'. */
+#define HAVE_STRUCT_TM_TM_ZONE 1
+
+/* Define if you have the 'symlink' function. */
+#define HAVE_SYMLINK 1
+
+/* Define to 1 if you have the `symlinkat' function. */
+#define HAVE_SYMLINKAT 1
+
+/* Define to 1 if you have the `sync' function. */
+#define HAVE_SYNC 1
+
+/* Define to 1 if you have the `sysconf' function. */
+#define HAVE_SYSCONF 1
+
+/* Define to 1 if you have the <sysexits.h> header file. */
+#define HAVE_SYSEXITS_H 1
+
+/* Define to 1 if you have the <sys/audioio.h> header file. */
+/* #undef HAVE_SYS_AUDIOIO_H */
+
+/* Define to 1 if you have the <sys/auxv.h> header file. */
+#define HAVE_SYS_AUXV_H 1
+
+/* Define to 1 if you have the <sys/bsdtty.h> header file. */
+/* #undef HAVE_SYS_BSDTTY_H */
+
+/* Define to 1 if you have the <sys/devpoll.h> header file. */
+/* #undef HAVE_SYS_DEVPOLL_H */
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_DIR_H */
+
+/* Define to 1 if you have the <sys/endian.h> header file. */
+/* #undef HAVE_SYS_ENDIAN_H */
+
+/* Define to 1 if you have the <sys/epoll.h> header file. */
+#define HAVE_SYS_EPOLL_H 1
+
+/* Define to 1 if you have the <sys/eventfd.h> header file. */
+#define HAVE_SYS_EVENTFD_H 1
+
+/* Define to 1 if you have the <sys/event.h> header file. */
+/* #undef HAVE_SYS_EVENT_H */
+
+/* Define to 1 if you have the <sys/file.h> header file. */
+#define HAVE_SYS_FILE_H 1
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#define HAVE_SYS_IOCTL_H 1
+
+/* Define to 1 if you have the <sys/kern_control.h> header file. */
+/* #undef HAVE_SYS_KERN_CONTROL_H */
+
+/* Define to 1 if you have the <sys/loadavg.h> header file. */
+/* #undef HAVE_SYS_LOADAVG_H */
+
+/* Define to 1 if you have the <sys/lock.h> header file. */
+/* #undef HAVE_SYS_LOCK_H */
+
+/* Define to 1 if you have the <sys/memfd.h> header file. */
+/* #undef HAVE_SYS_MEMFD_H */
+
+/* Define to 1 if you have the <sys/mkdev.h> header file. */
+/* #undef HAVE_SYS_MKDEV_H */
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#define HAVE_SYS_MMAN_H 1
+
+/* Define to 1 if you have the <sys/modem.h> header file. */
+/* #undef HAVE_SYS_MODEM_H */
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_NDIR_H */
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#define HAVE_SYS_PARAM_H 1
+
+/* Define to 1 if you have the <sys/poll.h> header file. */
+#define HAVE_SYS_POLL_H 1
+
+/* Define to 1 if you have the <sys/random.h> header file. */
+/* #undef HAVE_SYS_RANDOM_H */
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#define HAVE_SYS_RESOURCE_H 1
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#define HAVE_SYS_SELECT_H 1
+
+/* Define to 1 if you have the <sys/sendfile.h> header file. */
+#define HAVE_SYS_SENDFILE_H 1
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#define HAVE_SYS_SOCKET_H 1
+
+/* Define to 1 if you have the <sys/statvfs.h> header file. */
+#define HAVE_SYS_STATVFS_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/syscall.h> header file. */
+#define HAVE_SYS_SYSCALL_H 1
+
+/* Define to 1 if you have the <sys/sysmacros.h> header file. */
+#define HAVE_SYS_SYSMACROS_H 1
+
+/* Define to 1 if you have the <sys/sys_domain.h> header file. */
+/* #undef HAVE_SYS_SYS_DOMAIN_H */
+
+/* Define to 1 if you have the <sys/termio.h> header file. */
+/* #undef HAVE_SYS_TERMIO_H */
+
+/* Define to 1 if you have the <sys/times.h> header file. */
+#define HAVE_SYS_TIMES_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <sys/uio.h> header file. */
+#define HAVE_SYS_UIO_H 1
+
+/* Define to 1 if you have the <sys/un.h> header file. */
+#define HAVE_SYS_UN_H 1
+
+/* Define to 1 if you have the <sys/utsname.h> header file. */
+#define HAVE_SYS_UTSNAME_H 1
+
+/* Define to 1 if you have the <sys/wait.h> header file. */
+#define HAVE_SYS_WAIT_H 1
+
+/* Define to 1 if you have the <sys/xattr.h> header file. */
+#define HAVE_SYS_XATTR_H 1
+
+/* Define to 1 if you have the `tcgetpgrp' function. */
+#define HAVE_TCGETPGRP 1
+
+/* Define to 1 if you have the `tcsetpgrp' function. */
+#define HAVE_TCSETPGRP 1
+
+/* Define to 1 if you have the `tempnam' function. */
+#define HAVE_TEMPNAM 1
+
+/* Define to 1 if you have the <termios.h> header file. */
+#define HAVE_TERMIOS_H 1
+
+/* Define to 1 if you have the <term.h> header file. */
+#define HAVE_TERM_H 1
+
+/* Define to 1 if you have the `tgamma' function. */
+#define HAVE_TGAMMA 1
+
+/* Define to 1 if you have the `timegm' function. */
+#define HAVE_TIMEGM 1
+
+/* Define to 1 if you have the `times' function. */
+#define HAVE_TIMES 1
+
+/* Define to 1 if you have the `tmpfile' function. */
+#define HAVE_TMPFILE 1
+
+/* Define to 1 if you have the `tmpnam' function. */
+#define HAVE_TMPNAM 1
+
+/* Define to 1 if you have the `tmpnam_r' function. */
+#define HAVE_TMPNAM_R 1
+
+/* Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use
+   `HAVE_STRUCT_TM_TM_ZONE' instead. */
+#define HAVE_TM_ZONE 1
+
+/* Define to 1 if you have the `truncate' function. */
+#define HAVE_TRUNCATE 1
+
+/* Define to 1 if you don't have `tm_zone' but do have the external array
+   `tzname'. */
+/* #undef HAVE_TZNAME */
+
+/* Define this if you have tcl and TCL_UTF_MAX==6 */
+/* #undef HAVE_UCS4_TCL */
+
+/* Define to 1 if you have the `uname' function. */
+#define HAVE_UNAME 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `unlinkat' function. */
+#define HAVE_UNLINKAT 1
+
+/* Define if you have a useable wchar_t type defined in wchar.h; useable means
+   wchar_t must be an unsigned type with at least 16 bits. (see
+   Include/unicodeobject.h). */
+/* #undef HAVE_USABLE_WCHAR_T */
+
+/* Define to 1 if you have the <util.h> header file. */
+/* #undef HAVE_UTIL_H */
+
+/* Define to 1 if you have the `utimensat' function. */
+#define HAVE_UTIMENSAT 1
+
+/* Define to 1 if you have the `utimes' function. */
+#define HAVE_UTIMES 1
+
+/* Define to 1 if you have the <utime.h> header file. */
+#define HAVE_UTIME_H 1
+
+/* Define if uuid_create() exists. */
+/* #undef HAVE_UUID_CREATE */
+
+/* Define if uuid_enc_be() exists. */
+/* #undef HAVE_UUID_ENC_BE */
+
+/* Define if uuid_generate_time_safe() exists. */
+#define HAVE_UUID_GENERATE_TIME_SAFE 1
+
+/* Define to 1 if you have the <uuid.h> header file. */
+#define HAVE_UUID_H 1
+
+/* Define to 1 if you have the <uuid/uuid.h> header file. */
+#define HAVE_UUID_UUID_H 1
+
+/* Define to 1 if you have the `vfork' function. */
+#define HAVE_VFORK 1
+
+/* Define to 1 if you have the `wait3' function. */
+#define HAVE_WAIT3 1
+
+/* Define to 1 if you have the `wait4' function. */
+#define HAVE_WAIT4 1
+
+/* Define to 1 if you have the `waitid' function. */
+#define HAVE_WAITID 1
+
+/* Define to 1 if you have the `waitpid' function. */
+#define HAVE_WAITPID 1
+
+/* Define if the compiler provides a wchar.h header file. */
+#define HAVE_WCHAR_H 1
+
+/* Define to 1 if you have the `wcscoll' function. */
+#define HAVE_WCSCOLL 1
+
+/* Define to 1 if you have the `wcsftime' function. */
+#define HAVE_WCSFTIME 1
+
+/* Define to 1 if you have the `wcsxfrm' function. */
+#define HAVE_WCSXFRM 1
+
+/* Define to 1 if you have the `wmemcmp' function. */
+#define HAVE_WMEMCMP 1
+
+/* Define if tzset() actually switches the local timezone in a meaningful way.
+   */
+#define HAVE_WORKING_TZSET 1
+
+/* Define to 1 if you have the `writev' function. */
+#define HAVE_WRITEV 1
+
+/* Define if the zlib library has inflateCopy */
+#define HAVE_ZLIB_COPY 1
+
+/* Define to 1 if you have the `_getpty' function. */
+/* #undef HAVE__GETPTY */
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in <mkdev.h>.
+   */
+/* #undef MAJOR_IN_MKDEV */
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in
+   <sysmacros.h>. */
+/* #undef MAJOR_IN_SYSMACROS */
+
+/* Define if mvwdelch in curses.h is an expression. */
+#define MVWDELCH_IS_EXPRESSION 1
+
+/* Define to the address where bug reports for this package should be sent. */
+/* #undef PACKAGE_BUGREPORT */
+
+/* Define to the full name of this package. */
+/* #undef PACKAGE_NAME */
+
+/* Define to the full name and version of this package. */
+/* #undef PACKAGE_STRING */
+
+/* Define to the one symbol short name of this package. */
+/* #undef PACKAGE_TARNAME */
+
+/* Define to the home page for this package. */
+/* #undef PACKAGE_URL */
+
+/* Define to the version of this package. */
+/* #undef PACKAGE_VERSION */
+
+/* Define if POSIX semaphores aren't enabled on your system */
+/* #undef POSIX_SEMAPHORES_NOT_ENABLED */
+
+/* Define if pthread_key_t is compatible with int. */
+#define PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT 1
+
+/* Defined if PTHREAD_SCOPE_SYSTEM supported. */
+#define PTHREAD_SYSTEM_SCHED_SUPPORTED 1
+
+/* Define as the preferred size in bits of long digits */
+/* #undef PYLONG_BITS_IN_DIGIT */
+
+/* enabled builtin hash modules */
+#define PY_BUILTIN_HASHLIB_HASHES "md5,sha1,sha256,sha512,sha3,blake2"
+
+/* Define if you want to coerce the C locale to a UTF-8 based locale */
+#define PY_COERCE_C_LOCALE 1
+
+/* Define to printf format modifier for Py_ssize_t */
+#define PY_FORMAT_SIZE_T "z"
+
+/* Default cipher suites list for ssl module. 1: Python's preferred selection,
+   2: leave OpenSSL defaults untouched, 0: custom string */
+#define PY_SSL_DEFAULT_CIPHERS 1
+
+/* Cipher suite string for PY_SSL_DEFAULT_CIPHERS=0 */
+/* #undef PY_SSL_DEFAULT_CIPHER_STRING */
+
+/* Define if you want to build an interpreter with many run-time checks. */
+/* #undef Py_DEBUG */
+
+/* Defined if Python is built as a shared library. */
+/* #undef Py_ENABLE_SHARED */
+
+/* Define hash algorithm for str, bytes and memoryview. SipHash24: 1, FNV: 2,
+   externally defined: 0 */
+/* #undef Py_HASH_ALGORITHM */
+
+/* Define if you want to enable tracing references for debugging purpose */
+/* #undef Py_TRACE_REFS */
+
+/* assume C89 semantics that RETSIGTYPE is always void */
+#define RETSIGTYPE void
+
+/* Define if setpgrp() must be called as setpgrp(0, 0). */
+/* #undef SETPGRP_HAVE_ARG */
+
+/* Define to 1 if you must link with -lrt for shm_open(). */
+#define SHM_NEEDS_LIBRT 1
+
+/* Define if i>>j for signed int i does not extend the sign bit when i < 0 */
+/* #undef SIGNED_RIGHT_SHIFT_ZERO_FILLS */
+
+/* The size of `double', as computed by sizeof. */
+#define SIZEOF_DOUBLE 8
+
+/* The size of `float', as computed by sizeof. */
+#define SIZEOF_FLOAT 4
+
+/* The size of `fpos_t', as computed by sizeof. */
+#define SIZEOF_FPOS_T 16
+
+/* The size of `int', as computed by sizeof. */
+#define SIZEOF_INT 4
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `long double', as computed by sizeof. */
+#define SIZEOF_LONG_DOUBLE 16
+
+/* The size of `long long', as computed by sizeof. */
+#define SIZEOF_LONG_LONG 8
+
+/* The size of `off_t', as computed by sizeof. */
+#define SIZEOF_OFF_T 8
+
+/* The size of `pid_t', as computed by sizeof. */
+#define SIZEOF_PID_T 4
+
+/* The size of `pthread_key_t', as computed by sizeof. */
+#define SIZEOF_PTHREAD_KEY_T 4
+
+/* The size of `pthread_t', as computed by sizeof. */
+#define SIZEOF_PTHREAD_T 8
+
+/* The size of `short', as computed by sizeof. */
+#define SIZEOF_SHORT 2
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T 8
+
+/* The size of `time_t', as computed by sizeof. */
+#define SIZEOF_TIME_T 8
+
+/* The size of `uintptr_t', as computed by sizeof. */
+#define SIZEOF_UINTPTR_T 8
+
+/* The size of `void *', as computed by sizeof. */
+#define SIZEOF_VOID_P 8
+
+/* The size of `wchar_t', as computed by sizeof. */
+#define SIZEOF_WCHAR_T 4
+
+/* The size of `_Bool', as computed by sizeof. */
+#define SIZEOF__BOOL 1
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define if you can safely include both <sys/select.h> and <sys/time.h>
+   (which you can't on SCO ODT 3.0). */
+#define SYS_SELECT_WITH_SYS_TIME 1
+
+/* Custom thread stack size depending on chosen sanitizer runtimes. */
+/* #undef THREAD_STACK_SIZE */
+
+/* Library needed by timemodule.c: librt may be needed for clock_gettime() */
+/* #undef TIMEMODULE_LIB */
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
+
+/* Define to 1 if your <sys/time.h> declares `struct tm'. */
+/* #undef TM_IN_SYS_TIME */
+
+/* Define if you want to use computed gotos in ceval.c. */
+#define USE_COMPUTED_GOTOS 1
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
+
+/* Define if WINDOW in curses.h offers a field _flags. */
+#define WINDOW_HAS_FLAGS 1
+
+/* Define if you want build the _decimal module using a coroutine-local rather
+   than a thread-local context */
+#define WITH_DECIMAL_CONTEXTVAR 1
+
+/* Define if you want documentation strings in extension modules */
+#define WITH_DOC_STRINGS 1
+
+/* Define if you want to compile in DTrace support */
+/* #undef WITH_DTRACE */
+
+/* Define if you want to use the new-style (Openstep, Rhapsody, MacOS) dynamic
+   linker (dyld) instead of the old-style (NextStep) dynamic linker (rld).
+   Dyld is necessary to support frameworks. */
+/* #undef WITH_DYLD */
+
+/* Define to build the readline module against Editline. */
+/* #undef WITH_EDITLINE */
+
+/* Define to 1 if libintl is needed for locale functions. */
+/* #undef WITH_LIBINTL */
+
+/* Define if you want to produce an OpenStep/Rhapsody framework (shared
+   library plus accessory files). */
+/* #undef WITH_NEXT_FRAMEWORK */
+
+/* Define if you want to compile in Python-specific mallocs */
+#define WITH_PYMALLOC 1
+
+/* Define if you want pymalloc to be disabled when running under valgrind */
+/* #undef WITH_VALGRIND */
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Define if arithmetic is subject to x87-style double rounding issue */
+/* #undef X87_DOUBLE_ROUNDING */
+
+/* Define on OpenBSD to activate all library features */
+/* #undef _BSD_SOURCE */
+
+/* Define on Darwin to activate all library features */
+#define _DARWIN_C_SOURCE 1
+
+/* This must be set to 64 on some systems to enable large file support. */
+#define _FILE_OFFSET_BITS 64
+
+/* Define on Linux to activate all library features */
+#define _GNU_SOURCE 1
+
+/* Define to include mbstate_t for mbrtowc */
+/* #undef _INCLUDE__STDC_A1_SOURCE */
+
+/* This must be defined on some systems to enable large file support. */
+#define _LARGEFILE_SOURCE 1
+
+/* This must be defined on AIX systems to enable large file support. */
+/* #undef _LARGE_FILES */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* Define on NetBSD to activate all library features */
+#define _NETBSD_SOURCE 1
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to activate features from IEEE Stds 1003.1-2008 */
+#define _POSIX_C_SOURCE 200809L
+
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Define if you have POSIX threads, and your system does not define that. */
+/* #undef _POSIX_THREADS */
+
+/* framework name */
+#define _PYTHONFRAMEWORK ""
+
+/* Define to force use of thread-safe errno, h_errno, and other functions */
+/* #undef _REENTRANT */
+
+/* Define to the level of X/Open that your system supports */
+#define _XOPEN_SOURCE 700
+
+/* Define to activate Unix95-and-earlier features */
+#define _XOPEN_SOURCE_EXTENDED 1
+
+/* Define on FreeBSD to activate all library features */
+#define __BSD_VISIBLE 1
+
+/* Define to 'long' if <time.h> doesn't define. */
+/* #undef clock_t */
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `int' if <sys/types.h> doesn't define. */
+/* #undef gid_t */
+
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef mode_t */
+
+/* Define to `long int' if <sys/types.h> does not define. */
+/* #undef off_t */
+
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef pid_t */
+
+/* Define to empty if the keyword does not work. */
+/* #undef signed */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
+
+/* Define to `int' if <sys/socket.h> does not define. */
+/* #undef socklen_t */
+
+/* Define to `int' if <sys/types.h> doesn't define. */
+/* #undef uid_t */
+
+
+/* Define the macros needed if on a UnixWare 7.x system. */
+#if defined(__USLC__) && defined(__SCO_VERSION__)
+#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
+#endif
+
+#endif /*Py_PYCONFIG_H*/
+

evalkit_cambrian/include/python3.10/pydtrace.h

@@ -0,0 +1,59 @@
+/* Static DTrace probes interface */
+
+#ifndef Py_DTRACE_H
+#define Py_DTRACE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WITH_DTRACE
+
+#include "pydtrace_probes.h"
+
+/* pydtrace_probes.h, on systems with DTrace, is auto-generated to include
+   `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe
+   defined in pydtrace_provider.d.
+
+   Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()`
+   check to minimize performance impact when probing is off. For example:
+
+       if (PyDTrace_FUNCTION_ENTRY_ENABLED())
+           PyDTrace_FUNCTION_ENTRY(f);
+*/
+
+#else
+
+/* Without DTrace, compile to nothing. */
+
+static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_FUNCTION_ENTRY(const char *arg0, const char *arg1, int arg2)  {}
+static inline void PyDTrace_FUNCTION_RETURN(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_GC_START(int arg0) {}
+static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {}
+static inline void PyDTrace_AUDIT(const char *arg0, void *arg1) {}
+
+static inline int PyDTrace_LINE_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; }
+
+#endif /* !WITH_DTRACE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DTRACE_H */

evalkit_cambrian/include/python3.10/pyerrors.h

@@ -0,0 +1,324 @@
+#ifndef Py_ERRORS_H
+#define Py_ERRORS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>               // va_list
+
+/* Error handling definitions */
+
+PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
+PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);
+PyAPI_FUNC(void) PyErr_SetString(
+    PyObject *exception,
+    const char *string   /* decoded from utf-8 */
+    );
+PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
+PyAPI_FUNC(void) PyErr_Clear(void);
+PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
+PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **);
+PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *);
+#endif
+
+/* Defined in Python/pylifecycle.c
+
+   The Py_FatalError() function is replaced with a macro which logs
+   automatically the name of the current function, unless the Py_LIMITED_API
+   macro is defined. */
+PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char *message);
+
+/* Error testing and normalization */
+PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);
+PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
+PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
+
+/* Traceback manipulation (PEP 3134) */
+PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *);
+
+/* Cause manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *);
+PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *);
+
+/* Context manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *);
+PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
+
+/* */
+
+#define PyExceptionClass_Check(x)                                       \
+    (PyType_Check((x)) &&                                               \
+     PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
+
+#define PyExceptionInstance_Check(x)                    \
+    PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)
+
+PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *);
+
+#define PyExceptionInstance_Class(x) ((PyObject*)Py_TYPE(x))
+
+
+/* Predefined exceptions */
+
+PyAPI_DATA(PyObject *) PyExc_BaseException;
+PyAPI_DATA(PyObject *) PyExc_Exception;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration;
+#endif
+PyAPI_DATA(PyObject *) PyExc_StopIteration;
+PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
+PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
+PyAPI_DATA(PyObject *) PyExc_LookupError;
+
+PyAPI_DATA(PyObject *) PyExc_AssertionError;
+PyAPI_DATA(PyObject *) PyExc_AttributeError;
+PyAPI_DATA(PyObject *) PyExc_BufferError;
+PyAPI_DATA(PyObject *) PyExc_EOFError;
+PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
+PyAPI_DATA(PyObject *) PyExc_OSError;
+PyAPI_DATA(PyObject *) PyExc_ImportError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError;
+#endif
+PyAPI_DATA(PyObject *) PyExc_IndexError;
+PyAPI_DATA(PyObject *) PyExc_KeyError;
+PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
+PyAPI_DATA(PyObject *) PyExc_MemoryError;
+PyAPI_DATA(PyObject *) PyExc_NameError;
+PyAPI_DATA(PyObject *) PyExc_OverflowError;
+PyAPI_DATA(PyObject *) PyExc_RuntimeError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_DATA(PyObject *) PyExc_RecursionError;
+#endif
+PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
+PyAPI_DATA(PyObject *) PyExc_SyntaxError;
+PyAPI_DATA(PyObject *) PyExc_IndentationError;
+PyAPI_DATA(PyObject *) PyExc_TabError;
+PyAPI_DATA(PyObject *) PyExc_ReferenceError;
+PyAPI_DATA(PyObject *) PyExc_SystemError;
+PyAPI_DATA(PyObject *) PyExc_SystemExit;
+PyAPI_DATA(PyObject *) PyExc_TypeError;
+PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
+PyAPI_DATA(PyObject *) PyExc_ValueError;
+PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_DATA(PyObject *) PyExc_BlockingIOError;
+PyAPI_DATA(PyObject *) PyExc_BrokenPipeError;
+PyAPI_DATA(PyObject *) PyExc_ChildProcessError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionResetError;
+PyAPI_DATA(PyObject *) PyExc_FileExistsError;
+PyAPI_DATA(PyObject *) PyExc_FileNotFoundError;
+PyAPI_DATA(PyObject *) PyExc_InterruptedError;
+PyAPI_DATA(PyObject *) PyExc_IsADirectoryError;
+PyAPI_DATA(PyObject *) PyExc_NotADirectoryError;
+PyAPI_DATA(PyObject *) PyExc_PermissionError;
+PyAPI_DATA(PyObject *) PyExc_ProcessLookupError;
+PyAPI_DATA(PyObject *) PyExc_TimeoutError;
+#endif
+
+
+/* Compatibility aliases */
+PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
+PyAPI_DATA(PyObject *) PyExc_IOError;
+#ifdef MS_WINDOWS
+PyAPI_DATA(PyObject *) PyExc_WindowsError;
+#endif
+
+/* Predefined warning categories */
+PyAPI_DATA(PyObject *) PyExc_Warning;
+PyAPI_DATA(PyObject *) PyExc_UserWarning;
+PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
+PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
+PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
+PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
+PyAPI_DATA(PyObject *) PyExc_FutureWarning;
+PyAPI_DATA(PyObject *) PyExc_ImportWarning;
+PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
+PyAPI_DATA(PyObject *) PyExc_BytesWarning;
+PyAPI_DATA(PyObject *) PyExc_EncodingWarning;
+PyAPI_DATA(PyObject *) PyExc_ResourceWarning;
+
+
+/* Convenience functions */
+
+PyAPI_FUNC(int) PyErr_BadArgument(void);
+PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
+    PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects(
+    PyObject *, PyObject *, PyObject *);
+#endif
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
+    PyObject *exc,
+    const char *filename   /* decoded from the filesystem encoding */
+    );
+
+PyAPI_FUNC(PyObject *) PyErr_Format(
+    PyObject *exception,
+    const char *format,   /* ASCII-encoded string  */
+    ...
+    );
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(PyObject *) PyErr_FormatV(
+    PyObject *exception,
+    const char *format,
+    va_list vargs);
+#endif
+
+#ifdef MS_WINDOWS
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
+    int ierr,
+    const char *filename        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
+    PyObject *,int, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects(
+    PyObject *,int, PyObject *, PyObject *);
+#endif
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
+    PyObject *exc,
+    int ierr,
+    const char *filename        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
+#endif /* MS_WINDOWS */
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *,
+    PyObject *, PyObject *);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *,
+    PyObject *);
+#endif
+
+/* Export the old function so that the existing API remains available: */
+PyAPI_FUNC(void) PyErr_BadInternalCall(void);
+PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno);
+/* Mask the old API with a call to the new API for code compiled under
+   Python 2.0: */
+#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
+
+/* Function to create a new exception */
+PyAPI_FUNC(PyObject *) PyErr_NewException(
+    const char *name, PyObject *base, PyObject *dict);
+PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc(
+    const char *name, const char *doc, PyObject *base, PyObject *dict);
+PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
+
+
+/* In signalmodule.c */
+PyAPI_FUNC(int) PyErr_CheckSignals(void);
+PyAPI_FUNC(void) PyErr_SetInterrupt(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
+PyAPI_FUNC(int) PyErr_SetInterruptEx(int signum);
+#endif
+
+/* Support for adding program text to SyntaxErrors */
+PyAPI_FUNC(void) PyErr_SyntaxLocation(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno);
+PyAPI_FUNC(void) PyErr_SyntaxLocationEx(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno,
+    int col_offset);
+PyAPI_FUNC(PyObject *) PyErr_ProgramText(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno);
+
+/* The following functions are used to create and modify unicode
+   exceptions from C */
+
+/* create a UnicodeDecodeError object */
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
+    const char *encoding,       /* UTF-8 encoded string */
+    const char *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+/* get the encoding attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);
+
+/* get the object attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
+
+/* get the value of the start attribute (the int * may not be NULL)
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
+
+/* assign a new value to the start attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
+
+/* get the value of the end attribute (the int *may not be NULL)
+ return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
+
+/* assign a new value to the end attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
+
+/* get the value of the reason attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
+
+/* assign a new value to the reason attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
+PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_ERRORS_H
+#  include  "cpython/pyerrors.h"
+#  undef Py_CPYTHON_ERRORS_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ERRORS_H */

evalkit_cambrian/include/python3.10/pylifecycle.h

@@ -0,0 +1,74 @@
+
+/* Interfaces to configure, query, create & destroy the Python runtime */
+
+#ifndef Py_PYLIFECYCLE_H
+#define Py_PYLIFECYCLE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Initialization and finalization */
+PyAPI_FUNC(void) Py_Initialize(void);
+PyAPI_FUNC(void) Py_InitializeEx(int);
+PyAPI_FUNC(void) Py_Finalize(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(int) Py_FinalizeEx(void);
+#endif
+PyAPI_FUNC(int) Py_IsInitialized(void);
+
+/* Subinterpreter support */
+PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void);
+PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *);
+
+
+/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
+ * exit functions.
+ */
+PyAPI_FUNC(int) Py_AtExit(void (*func)(void));
+
+PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int);
+
+/* Bootstrap __main__ (defined in Modules/main.c) */
+PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
+PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv);
+
+/* In pathconfig.c */
+PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *);
+PyAPI_FUNC(wchar_t *) Py_GetProgramName(void);
+
+PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *);
+PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void);
+
+PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);
+
+PyAPI_FUNC(wchar_t *) Py_GetPrefix(void);
+PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void);
+PyAPI_FUNC(wchar_t *) Py_GetPath(void);
+PyAPI_FUNC(void)      Py_SetPath(const wchar_t *);
+#ifdef MS_WINDOWS
+int _Py_CheckPython3(void);
+#endif
+
+/* In their own files */
+PyAPI_FUNC(const char *) Py_GetVersion(void);
+PyAPI_FUNC(const char *) Py_GetPlatform(void);
+PyAPI_FUNC(const char *) Py_GetCopyright(void);
+PyAPI_FUNC(const char *) Py_GetCompiler(void);
+PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
+
+/* Signals */
+typedef void (*PyOS_sighandler_t)(int);
+PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int);
+PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_PYLIFECYCLE_H
+#  include  "cpython/pylifecycle.h"
+#  undef Py_CPYTHON_PYLIFECYCLE_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYLIFECYCLE_H */

evalkit_cambrian/include/python3.10/pymem.h

@@ -0,0 +1,104 @@
+/* The PyMem_ family:  low-level memory allocation interfaces.
+   See objimpl.h for the PyObject_ memory family.
+*/
+
+#ifndef Py_PYMEM_H
+#define Py_PYMEM_H
+
+#include "pyport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEWARE:
+
+   Each interface exports both functions and macros.  Extension modules should
+   use the functions, to ensure binary compatibility across Python versions.
+   Because the Python implementation is free to change internal details, and
+   the macros may (or may not) expose details for speed, if you do use the
+   macros you must recompile your extensions with each Python release.
+
+   Never mix calls to PyMem_ with calls to the platform malloc/realloc/
+   calloc/free.  For example, on Windows different DLLs may end up using
+   different heaps, and if you use PyMem_Malloc you'll get the memory from the
+   heap used by the Python DLL; it could be a disaster if you free()'ed that
+   directly in your own extension.  Using PyMem_Free instead ensures Python
+   can return the memory to the proper heap.  As another example, in
+   a debug build (Py_DEBUG macro), Python wraps all calls to all PyMem_ and
+   PyObject_ memory functions in special debugging wrappers that add additional
+   debugging info to dynamic memory blocks.  The system routines have no idea
+   what to do with that stuff, and the Python wrappers have no idea what to do
+   with raw blocks obtained directly by the system routines then.
+
+   The GIL must be held when using these APIs.
+*/
+
+/*
+ * Raw memory interface
+ * ====================
+ */
+
+/* Functions
+
+   Functions supplying platform-independent semantics for malloc/realloc/
+   free.  These functions make sure that allocating 0 bytes returns a distinct
+   non-NULL pointer (whenever possible -- if we're flat out of memory, NULL
+   may be returned), even if the platform malloc and realloc don't.
+   Returned pointers must be checked for NULL explicitly.  No action is
+   performed on failure (no exception is set, no warning is printed, etc).
+*/
+
+PyAPI_FUNC(void *) PyMem_Malloc(size_t size);
+PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyMem_Free(void *ptr);
+
+/*
+ * Type-oriented memory interface
+ * ==============================
+ *
+ * Allocate memory for n objects of the given type.  Returns a new pointer
+ * or NULL if the request was too large or memory allocation failed.  Use
+ * these macros rather than doing the multiplication yourself so that proper
+ * overflow checking is always done.
+ */
+
+#define PyMem_New(type, n) \
+  ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :      \
+        ( (type *) PyMem_Malloc((n) * sizeof(type)) ) )
+
+/*
+ * The value of (p) is always clobbered by this macro regardless of success.
+ * The caller MUST check if (p) is NULL afterwards and deal with the memory
+ * error if so.  This means the original value of (p) MUST be saved for the
+ * caller's memory error handler to not lose track of it.
+ */
+#define PyMem_Resize(p, type, n) \
+  ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :        \
+        (type *) PyMem_Realloc((p), (n) * sizeof(type)) )
+
+
+// Deprecated aliases only kept for backward compatibility.
+// PyMem_Del and PyMem_DEL are defined with no parameter to be able to use
+// them as function pointers (ex: dealloc = PyMem_Del).
+#define PyMem_MALLOC(n)           PyMem_Malloc(n)
+#define PyMem_NEW(type, n)        PyMem_New(type, n)
+#define PyMem_REALLOC(p, n)       PyMem_Realloc(p, n)
+#define PyMem_RESIZE(p, type, n)  PyMem_Resize(p, type, n)
+#define PyMem_FREE(p)             PyMem_Free(p)
+#define PyMem_Del                 PyMem_Free
+#define PyMem_DEL                 PyMem_Free
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_PYMEM_H
+#  include  "cpython/pymem.h"
+#  undef Py_CPYTHON_PYMEM_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_PYMEM_H */

evalkit_cambrian/include/python3.10/pystrhex.h

@@ -0,0 +1,22 @@
+#ifndef Py_STRHEX_H
+#define Py_STRHEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+/* Returns a str() containing the hex representation of argbuf. */
+PyAPI_FUNC(PyObject*) _Py_strhex(const char* argbuf, const Py_ssize_t arglen);
+/* Returns a bytes() containing the ASCII hex representation of argbuf. */
+PyAPI_FUNC(PyObject*) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen);
+/* These variants include support for a separator between every N bytes: */
+PyAPI_FUNC(PyObject*) _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
+PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRHEX_H */

evalkit_cambrian/include/python3.10/tupleobject.h

@@ -0,0 +1,46 @@
+/* Tuple object interface */
+
+#ifndef Py_TUPLEOBJECT_H
+#define Py_TUPLEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+Another generally useful object type is a tuple of object pointers.
+For Python, this is an immutable type.  C code can change the tuple items
+(but not their number), and even use tuples as general-purpose arrays of
+object references, but in general only brand new tuples should be mutated,
+not ones that might already have been exposed to Python code.
+
+*** WARNING *** PyTuple_SetItem does not increment the new item's reference
+count, but does decrement the reference count of the item it replaces,
+if not nil.  It does *decrement* the reference count if it is *not*
+inserted in the tuple.  Similarly, PyTuple_GetItem does not increment the
+returned item's reference count.
+*/
+
+PyAPI_DATA(PyTypeObject) PyTuple_Type;
+PyAPI_DATA(PyTypeObject) PyTupleIter_Type;
+
+#define PyTuple_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
+#define PyTuple_CheckExact(op) Py_IS_TYPE(op, &PyTuple_Type)
+
+PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
+PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
+PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_TUPLEOBJECT_H
+#  include  "cpython/tupleobject.h"
+#  undef Py_CPYTHON_TUPLEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TUPLEOBJECT_H */

evalkit_cambrian/include/python3.10/typeslots.h

@@ -0,0 +1,94 @@
+/* Do not renumber the file; these numbers are part of the stable ABI. */
+#if defined(Py_LIMITED_API)
+/* Disabled, see #10181 */
+#undef Py_bf_getbuffer
+#undef Py_bf_releasebuffer
+#else
+#define Py_bf_getbuffer 1
+#define Py_bf_releasebuffer 2
+#endif
+#define Py_mp_ass_subscript 3
+#define Py_mp_length 4
+#define Py_mp_subscript 5
+#define Py_nb_absolute 6
+#define Py_nb_add 7
+#define Py_nb_and 8
+#define Py_nb_bool 9
+#define Py_nb_divmod 10
+#define Py_nb_float 11
+#define Py_nb_floor_divide 12
+#define Py_nb_index 13
+#define Py_nb_inplace_add 14
+#define Py_nb_inplace_and 15
+#define Py_nb_inplace_floor_divide 16
+#define Py_nb_inplace_lshift 17
+#define Py_nb_inplace_multiply 18
+#define Py_nb_inplace_or 19
+#define Py_nb_inplace_power 20
+#define Py_nb_inplace_remainder 21
+#define Py_nb_inplace_rshift 22
+#define Py_nb_inplace_subtract 23
+#define Py_nb_inplace_true_divide 24
+#define Py_nb_inplace_xor 25
+#define Py_nb_int 26
+#define Py_nb_invert 27
+#define Py_nb_lshift 28
+#define Py_nb_multiply 29
+#define Py_nb_negative 30
+#define Py_nb_or 31
+#define Py_nb_positive 32
+#define Py_nb_power 33
+#define Py_nb_remainder 34
+#define Py_nb_rshift 35
+#define Py_nb_subtract 36
+#define Py_nb_true_divide 37
+#define Py_nb_xor 38
+#define Py_sq_ass_item 39
+#define Py_sq_concat 40
+#define Py_sq_contains 41
+#define Py_sq_inplace_concat 42
+#define Py_sq_inplace_repeat 43
+#define Py_sq_item 44
+#define Py_sq_length 45
+#define Py_sq_repeat 46
+#define Py_tp_alloc 47
+#define Py_tp_base 48
+#define Py_tp_bases 49
+#define Py_tp_call 50
+#define Py_tp_clear 51
+#define Py_tp_dealloc 52
+#define Py_tp_del 53
+#define Py_tp_descr_get 54
+#define Py_tp_descr_set 55
+#define Py_tp_doc 56
+#define Py_tp_getattr 57
+#define Py_tp_getattro 58
+#define Py_tp_hash 59
+#define Py_tp_init 60
+#define Py_tp_is_gc 61
+#define Py_tp_iter 62
+#define Py_tp_iternext 63
+#define Py_tp_methods 64
+#define Py_tp_new 65
+#define Py_tp_repr 66
+#define Py_tp_richcompare 67
+#define Py_tp_setattr 68
+#define Py_tp_setattro 69
+#define Py_tp_str 70
+#define Py_tp_traverse 71
+#define Py_tp_members 72
+#define Py_tp_getset 73
+#define Py_tp_free 74
+#define Py_nb_matrix_multiply 75
+#define Py_nb_inplace_matrix_multiply 76
+#define Py_am_await 77
+#define Py_am_aiter 78
+#define Py_am_anext 79
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+#define Py_tp_finalize 80
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
+/* New in 3.10 */
+#define Py_am_send 81
+#endif

evalkit_cambrian/include/tclIntDecls.h

@@ -0,0 +1,1434 @@
+/*
+ * tclIntDecls.h --
+ *
+ *	This file contains the declarations for all unsupported
+ *	functions that are exported by the Tcl library.  These
+ *	interfaces are not guaranteed to remain the same between
+ *	versions.  Use at your own risk.
+ *
+ * Copyright (c) 1998-1999 by Scriptics Corporation.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef _TCLINTDECLS
+#define _TCLINTDECLS
+
+
+#undef TCL_STORAGE_CLASS
+#ifdef BUILD_tcl
+#   define TCL_STORAGE_CLASS DLLEXPORT
+#else
+#   ifdef USE_TCL_STUBS
+#      define TCL_STORAGE_CLASS
+#   else
+#      define TCL_STORAGE_CLASS DLLIMPORT
+#   endif
+#endif
+
+/* [Bug #803489] Tcl_FindNamespace problem in the Stubs table */
+#undef Tcl_CreateNamespace
+#undef Tcl_DeleteNamespace
+#undef Tcl_AppendExportList
+#undef Tcl_Export
+#undef Tcl_Import
+#undef Tcl_ForgetImport
+#undef Tcl_GetCurrentNamespace
+#undef Tcl_GetGlobalNamespace
+#undef Tcl_FindNamespace
+#undef Tcl_FindCommand
+#undef Tcl_GetCommandFromObj
+#undef Tcl_GetCommandFullName
+#undef Tcl_SetStartupScript
+#undef Tcl_GetStartupScript
+
+/*
+ * WARNING: This file is automatically generated by the tools/genStubs.tcl
+ * script.  Any modifications to the function declarations below should be made
+ * in the generic/tclInt.decls script.
+ */
+
+/* !BEGIN!: Do not edit below this line. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Exported function declarations:
+ */
+
+/* Slot 0 is reserved */
+/* Slot 1 is reserved */
+/* Slot 2 is reserved */
+/* 3 */
+EXTERN void		TclAllocateFreeObjects(void);
+/* Slot 4 is reserved */
+/* 5 */
+EXTERN int		TclCleanupChildren(Tcl_Interp *interp, int numPids,
+				Tcl_Pid *pidPtr, Tcl_Channel errorChan);
+/* 6 */
+EXTERN void		TclCleanupCommand(Command *cmdPtr);
+/* 7 */
+EXTERN int		TclCopyAndCollapse(int count, const char *src,
+				char *dst);
+/* 8 */
+EXTERN int		TclCopyChannelOld(Tcl_Interp *interp,
+				Tcl_Channel inChan, Tcl_Channel outChan,
+				int toRead, Tcl_Obj *cmdPtr);
+/* 9 */
+EXTERN int		TclCreatePipeline(Tcl_Interp *interp, int argc,
+				const char **argv, Tcl_Pid **pidArrayPtr,
+				TclFile *inPipePtr, TclFile *outPipePtr,
+				TclFile *errFilePtr);
+/* 10 */
+EXTERN int		TclCreateProc(Tcl_Interp *interp, Namespace *nsPtr,
+				const char *procName, Tcl_Obj *argsPtr,
+				Tcl_Obj *bodyPtr, Proc **procPtrPtr);
+/* 11 */
+EXTERN void		TclDeleteCompiledLocalVars(Interp *iPtr,
+				CallFrame *framePtr);
+/* 12 */
+EXTERN void		TclDeleteVars(Interp *iPtr,
+				TclVarHashTable *tablePtr);
+/* Slot 13 is reserved */
+/* 14 */
+EXTERN int		TclDumpMemoryInfo(ClientData clientData, int flags);
+/* Slot 15 is reserved */
+/* 16 */
+EXTERN void		TclExprFloatError(Tcl_Interp *interp, double value);
+/* Slot 17 is reserved */
+/* Slot 18 is reserved */
+/* Slot 19 is reserved */
+/* Slot 20 is reserved */
+/* Slot 21 is reserved */
+/* 22 */
+EXTERN int		TclFindElement(Tcl_Interp *interp,
+				const char *listStr, int listLength,
+				const char **elementPtr,
+				const char **nextPtr, int *sizePtr,
+				int *bracePtr);
+/* 23 */
+EXTERN Proc *		TclFindProc(Interp *iPtr, const char *procName);
+/* 24 */
+EXTERN int		TclFormatInt(char *buffer, long n);
+/* 25 */
+EXTERN void		TclFreePackageInfo(Interp *iPtr);
+/* Slot 26 is reserved */
+/* Slot 27 is reserved */
+/* 28 */
+EXTERN Tcl_Channel	TclpGetDefaultStdChannel(int type);
+/* Slot 29 is reserved */
+/* Slot 30 is reserved */
+/* 31 */
+EXTERN const char *	TclGetExtension(const char *name);
+/* 32 */
+EXTERN int		TclGetFrame(Tcl_Interp *interp, const char *str,
+				CallFrame **framePtrPtr);
+/* Slot 33 is reserved */
+/* 34 */
+EXTERN int		TclGetIntForIndex(Tcl_Interp *interp,
+				Tcl_Obj *objPtr, int endValue, int *indexPtr);
+/* Slot 35 is reserved */
+/* Slot 36 is reserved */
+/* 37 */
+EXTERN int		TclGetLoadedPackages(Tcl_Interp *interp,
+				const char *targetName);
+/* 38 */
+EXTERN int		TclGetNamespaceForQualName(Tcl_Interp *interp,
+				const char *qualName, Namespace *cxtNsPtr,
+				int flags, Namespace **nsPtrPtr,
+				Namespace **altNsPtrPtr,
+				Namespace **actualCxtPtrPtr,
+				const char **simpleNamePtr);
+/* 39 */
+EXTERN Tcl_ObjCmdProc *	 TclGetObjInterpProc(void);
+/* 40 */
+EXTERN int		TclGetOpenMode(Tcl_Interp *interp, const char *str,
+				int *seekFlagPtr);
+/* 41 */
+EXTERN Tcl_Command	TclGetOriginalCommand(Tcl_Command command);
+/* 42 */
+EXTERN CONST86 char *	TclpGetUserHome(const char *name,
+				Tcl_DString *bufferPtr);
+/* Slot 43 is reserved */
+/* 44 */
+EXTERN int		TclGuessPackageName(const char *fileName,
+				Tcl_DString *bufPtr);
+/* 45 */
+EXTERN int		TclHideUnsafeCommands(Tcl_Interp *interp);
+/* 46 */
+EXTERN int		TclInExit(void);
+/* Slot 47 is reserved */
+/* Slot 48 is reserved */
+/* Slot 49 is reserved */
+/* 50 */
+EXTERN void		TclInitCompiledLocals(Tcl_Interp *interp,
+				CallFrame *framePtr, Namespace *nsPtr);
+/* 51 */
+EXTERN int		TclInterpInit(Tcl_Interp *interp);
+/* Slot 52 is reserved */
+/* 53 */
+EXTERN int		TclInvokeObjectCommand(ClientData clientData,
+				Tcl_Interp *interp, int argc,
+				CONST84 char **argv);
+/* 54 */
+EXTERN int		TclInvokeStringCommand(ClientData clientData,
+				Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[]);
+/* 55 */
+EXTERN Proc *		TclIsProc(Command *cmdPtr);
+/* Slot 56 is reserved */
+/* Slot 57 is reserved */
+/* 58 */
+EXTERN Var *		TclLookupVar(Tcl_Interp *interp, const char *part1,
+				const char *part2, int flags,
+				const char *msg, int createPart1,
+				int createPart2, Var **arrayPtrPtr);
+/* Slot 59 is reserved */
+/* 60 */
+EXTERN int		TclNeedSpace(const char *start, const char *end);
+/* 61 */
+EXTERN Tcl_Obj *	TclNewProcBodyObj(Proc *procPtr);
+/* 62 */
+EXTERN int		TclObjCommandComplete(Tcl_Obj *cmdPtr);
+/* 63 */
+EXTERN int		TclObjInterpProc(ClientData clientData,
+				Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[]);
+/* 64 */
+EXTERN int		TclObjInvoke(Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[], int flags);
+/* Slot 65 is reserved */
+/* Slot 66 is reserved */
+/* Slot 67 is reserved */
+/* Slot 68 is reserved */
+/* 69 */
+EXTERN char *		TclpAlloc(unsigned int size);
+/* Slot 70 is reserved */
+/* Slot 71 is reserved */
+/* Slot 72 is reserved */
+/* Slot 73 is reserved */
+/* 74 */
+EXTERN void		TclpFree(char *ptr);
+/* 75 */
+EXTERN unsigned long	TclpGetClicks(void);
+/* 76 */
+EXTERN unsigned long	TclpGetSeconds(void);
+/* 77 */
+EXTERN void		TclpGetTime(Tcl_Time *time);
+/* Slot 78 is reserved */
+/* Slot 79 is reserved */
+/* Slot 80 is reserved */
+/* 81 */
+EXTERN char *		TclpRealloc(char *ptr, unsigned int size);
+/* Slot 82 is reserved */
+/* Slot 83 is reserved */
+/* Slot 84 is reserved */
+/* Slot 85 is reserved */
+/* Slot 86 is reserved */
+/* Slot 87 is reserved */
+/* 88 */
+EXTERN char *		TclPrecTraceProc(ClientData clientData,
+				Tcl_Interp *interp, const char *name1,
+				const char *name2, int flags);
+/* 89 */
+EXTERN int		TclPreventAliasLoop(Tcl_Interp *interp,
+				Tcl_Interp *cmdInterp, Tcl_Command cmd);
+/* Slot 90 is reserved */
+/* 91 */
+EXTERN void		TclProcCleanupProc(Proc *procPtr);
+/* 92 */
+EXTERN int		TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr,
+				Tcl_Obj *bodyPtr, Namespace *nsPtr,
+				const char *description,
+				const char *procName);
+/* 93 */
+EXTERN void		TclProcDeleteProc(ClientData clientData);
+/* Slot 94 is reserved */
+/* Slot 95 is reserved */
+/* 96 */
+EXTERN int		TclRenameCommand(Tcl_Interp *interp,
+				const char *oldName, const char *newName);
+/* 97 */
+EXTERN void		TclResetShadowedCmdRefs(Tcl_Interp *interp,
+				Command *newCmdPtr);
+/* 98 */
+EXTERN int		TclServiceIdle(void);
+/* Slot 99 is reserved */
+/* Slot 100 is reserved */
+/* 101 */
+EXTERN CONST86 char *	TclSetPreInitScript(const char *string);
+/* 102 */
+EXTERN void		TclSetupEnv(Tcl_Interp *interp);
+/* 103 */
+EXTERN int		TclSockGetPort(Tcl_Interp *interp, const char *str,
+				const char *proto, int *portPtr);
+/* 104 */
+EXTERN int		TclSockMinimumBuffersOld(int sock, int size);
+/* Slot 105 is reserved */
+/* Slot 106 is reserved */
+/* Slot 107 is reserved */
+/* 108 */
+EXTERN void		TclTeardownNamespace(Namespace *nsPtr);
+/* 109 */
+EXTERN int		TclUpdateReturnInfo(Interp *iPtr);
+/* 110 */
+EXTERN int		TclSockMinimumBuffers(void *sock, int size);
+/* 111 */
+EXTERN void		Tcl_AddInterpResolvers(Tcl_Interp *interp,
+				const char *name,
+				Tcl_ResolveCmdProc *cmdProc,
+				Tcl_ResolveVarProc *varProc,
+				Tcl_ResolveCompiledVarProc *compiledVarProc);
+/* 112 */
+EXTERN int		Tcl_AppendExportList(Tcl_Interp *interp,
+				Tcl_Namespace *nsPtr, Tcl_Obj *objPtr);
+/* 113 */
+EXTERN Tcl_Namespace *	Tcl_CreateNamespace(Tcl_Interp *interp,
+				const char *name, ClientData clientData,
+				Tcl_NamespaceDeleteProc *deleteProc);
+/* 114 */
+EXTERN void		Tcl_DeleteNamespace(Tcl_Namespace *nsPtr);
+/* 115 */
+EXTERN int		Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+				const char *pattern, int resetListFirst);
+/* 116 */
+EXTERN Tcl_Command	Tcl_FindCommand(Tcl_Interp *interp, const char *name,
+				Tcl_Namespace *contextNsPtr, int flags);
+/* 117 */
+EXTERN Tcl_Namespace *	Tcl_FindNamespace(Tcl_Interp *interp,
+				const char *name,
+				Tcl_Namespace *contextNsPtr, int flags);
+/* 118 */
+EXTERN int		Tcl_GetInterpResolvers(Tcl_Interp *interp,
+				const char *name, Tcl_ResolverInfo *resInfo);
+/* 119 */
+EXTERN int		Tcl_GetNamespaceResolvers(
+				Tcl_Namespace *namespacePtr,
+				Tcl_ResolverInfo *resInfo);
+/* 120 */
+EXTERN Tcl_Var		Tcl_FindNamespaceVar(Tcl_Interp *interp,
+				const char *name,
+				Tcl_Namespace *contextNsPtr, int flags);
+/* 121 */
+EXTERN int		Tcl_ForgetImport(Tcl_Interp *interp,
+				Tcl_Namespace *nsPtr, const char *pattern);
+/* 122 */
+EXTERN Tcl_Command	Tcl_GetCommandFromObj(Tcl_Interp *interp,
+				Tcl_Obj *objPtr);
+/* 123 */
+EXTERN void		Tcl_GetCommandFullName(Tcl_Interp *interp,
+				Tcl_Command command, Tcl_Obj *objPtr);
+/* 124 */
+EXTERN Tcl_Namespace *	Tcl_GetCurrentNamespace(Tcl_Interp *interp);
+/* 125 */
+EXTERN Tcl_Namespace *	Tcl_GetGlobalNamespace(Tcl_Interp *interp);
+/* 126 */
+EXTERN void		Tcl_GetVariableFullName(Tcl_Interp *interp,
+				Tcl_Var variable, Tcl_Obj *objPtr);
+/* 127 */
+EXTERN int		Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+				const char *pattern, int allowOverwrite);
+/* 128 */
+EXTERN void		Tcl_PopCallFrame(Tcl_Interp *interp);
+/* 129 */
+EXTERN int		Tcl_PushCallFrame(Tcl_Interp *interp,
+				Tcl_CallFrame *framePtr,
+				Tcl_Namespace *nsPtr, int isProcCallFrame);
+/* 130 */
+EXTERN int		Tcl_RemoveInterpResolvers(Tcl_Interp *interp,
+				const char *name);
+/* 131 */
+EXTERN void		Tcl_SetNamespaceResolvers(
+				Tcl_Namespace *namespacePtr,
+				Tcl_ResolveCmdProc *cmdProc,
+				Tcl_ResolveVarProc *varProc,
+				Tcl_ResolveCompiledVarProc *compiledVarProc);
+/* 132 */
+EXTERN int		TclpHasSockets(Tcl_Interp *interp);
+/* 133 */
+EXTERN struct tm *	TclpGetDate(const time_t *time, int useGMT);
+/* Slot 134 is reserved */
+/* Slot 135 is reserved */
+/* Slot 136 is reserved */
+/* Slot 137 is reserved */
+/* 138 */
+EXTERN CONST84_RETURN char * TclGetEnv(const char *name,
+				Tcl_DString *valuePtr);
+/* Slot 139 is reserved */
+/* Slot 140 is reserved */
+/* 141 */
+EXTERN CONST84_RETURN char * TclpGetCwd(Tcl_Interp *interp,
+				Tcl_DString *cwdPtr);
+/* 142 */
+EXTERN int		TclSetByteCodeFromAny(Tcl_Interp *interp,
+				Tcl_Obj *objPtr, CompileHookProc *hookProc,
+				ClientData clientData);
+/* 143 */
+EXTERN int		TclAddLiteralObj(struct CompileEnv *envPtr,
+				Tcl_Obj *objPtr, LiteralEntry **litPtrPtr);
+/* 144 */
+EXTERN void		TclHideLiteral(Tcl_Interp *interp,
+				struct CompileEnv *envPtr, int index);
+/* 145 */
+EXTERN const struct AuxDataType * TclGetAuxDataType(const char *typeName);
+/* 146 */
+EXTERN TclHandle	TclHandleCreate(void *ptr);
+/* 147 */
+EXTERN void		TclHandleFree(TclHandle handle);
+/* 148 */
+EXTERN TclHandle	TclHandlePreserve(TclHandle handle);
+/* 149 */
+EXTERN void		TclHandleRelease(TclHandle handle);
+/* 150 */
+EXTERN int		TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re);
+/* 151 */
+EXTERN void		TclRegExpRangeUniChar(Tcl_RegExp re, int index,
+				int *startPtr, int *endPtr);
+/* 152 */
+EXTERN void		TclSetLibraryPath(Tcl_Obj *pathPtr);
+/* 153 */
+EXTERN Tcl_Obj *	TclGetLibraryPath(void);
+/* Slot 154 is reserved */
+/* Slot 155 is reserved */
+/* 156 */
+EXTERN void		TclRegError(Tcl_Interp *interp, const char *msg,
+				int status);
+/* 157 */
+EXTERN Var *		TclVarTraceExists(Tcl_Interp *interp,
+				const char *varName);
+/* 158 */
+EXTERN void		TclSetStartupScriptFileName(const char *filename);
+/* 159 */
+EXTERN const char *	TclGetStartupScriptFileName(void);
+/* Slot 160 is reserved */
+/* 161 */
+EXTERN int		TclChannelTransform(Tcl_Interp *interp,
+				Tcl_Channel chan, Tcl_Obj *cmdObjPtr);
+/* 162 */
+EXTERN void		TclChannelEventScriptInvoker(ClientData clientData,
+				int flags);
+/* 163 */
+EXTERN const void *	TclGetInstructionTable(void);
+/* 164 */
+EXTERN void		TclExpandCodeArray(void *envPtr);
+/* 165 */
+EXTERN void		TclpSetInitialEncodings(void);
+/* 166 */
+EXTERN int		TclListObjSetElement(Tcl_Interp *interp,
+				Tcl_Obj *listPtr, int index,
+				Tcl_Obj *valuePtr);
+/* 167 */
+EXTERN void		TclSetStartupScriptPath(Tcl_Obj *pathPtr);
+/* 168 */
+EXTERN Tcl_Obj *	TclGetStartupScriptPath(void);
+/* 169 */
+EXTERN int		TclpUtfNcmp2(const char *s1, const char *s2,
+				unsigned long n);
+/* 170 */
+EXTERN int		TclCheckInterpTraces(Tcl_Interp *interp,
+				const char *command, int numChars,
+				Command *cmdPtr, int result, int traceFlags,
+				int objc, Tcl_Obj *const objv[]);
+/* 171 */
+EXTERN int		TclCheckExecutionTraces(Tcl_Interp *interp,
+				const char *command, int numChars,
+				Command *cmdPtr, int result, int traceFlags,
+				int objc, Tcl_Obj *const objv[]);
+/* 172 */
+EXTERN int		TclInThreadExit(void);
+/* 173 */
+EXTERN int		TclUniCharMatch(const Tcl_UniChar *string,
+				int strLen, const Tcl_UniChar *pattern,
+				int ptnLen, int flags);
+/* Slot 174 is reserved */
+/* 175 */
+EXTERN int		TclCallVarTraces(Interp *iPtr, Var *arrayPtr,
+				Var *varPtr, const char *part1,
+				const char *part2, int flags,
+				int leaveErrMsg);
+/* 176 */
+EXTERN void		TclCleanupVar(Var *varPtr, Var *arrayPtr);
+/* 177 */
+EXTERN void		TclVarErrMsg(Tcl_Interp *interp, const char *part1,
+				const char *part2, const char *operation,
+				const char *reason);
+/* 178 */
+EXTERN void		Tcl_SetStartupScript(Tcl_Obj *pathPtr,
+				const char *encodingName);
+/* 179 */
+EXTERN Tcl_Obj *	Tcl_GetStartupScript(const char **encodingNamePtr);
+/* Slot 180 is reserved */
+/* Slot 181 is reserved */
+/* 182 */
+EXTERN struct tm *	TclpLocaltime(const time_t *clock);
+/* 183 */
+EXTERN struct tm *	TclpGmtime(const time_t *clock);
+/* Slot 184 is reserved */
+/* Slot 185 is reserved */
+/* Slot 186 is reserved */
+/* Slot 187 is reserved */
+/* Slot 188 is reserved */
+/* Slot 189 is reserved */
+/* Slot 190 is reserved */
+/* Slot 191 is reserved */
+/* Slot 192 is reserved */
+/* Slot 193 is reserved */
+/* Slot 194 is reserved */
+/* Slot 195 is reserved */
+/* Slot 196 is reserved */
+/* Slot 197 is reserved */
+/* 198 */
+EXTERN int		TclObjGetFrame(Tcl_Interp *interp, Tcl_Obj *objPtr,
+				CallFrame **framePtrPtr);
+/* Slot 199 is reserved */
+/* 200 */
+EXTERN int		TclpObjRemoveDirectory(Tcl_Obj *pathPtr,
+				int recursive, Tcl_Obj **errorPtr);
+/* 201 */
+EXTERN int		TclpObjCopyDirectory(Tcl_Obj *srcPathPtr,
+				Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr);
+/* 202 */
+EXTERN int		TclpObjCreateDirectory(Tcl_Obj *pathPtr);
+/* 203 */
+EXTERN int		TclpObjDeleteFile(Tcl_Obj *pathPtr);
+/* 204 */
+EXTERN int		TclpObjCopyFile(Tcl_Obj *srcPathPtr,
+				Tcl_Obj *destPathPtr);
+/* 205 */
+EXTERN int		TclpObjRenameFile(Tcl_Obj *srcPathPtr,
+				Tcl_Obj *destPathPtr);
+/* 206 */
+EXTERN int		TclpObjStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
+/* 207 */
+EXTERN int		TclpObjAccess(Tcl_Obj *pathPtr, int mode);
+/* 208 */
+EXTERN Tcl_Channel	TclpOpenFileChannel(Tcl_Interp *interp,
+				Tcl_Obj *pathPtr, int mode, int permissions);
+/* Slot 209 is reserved */
+/* Slot 210 is reserved */
+/* Slot 211 is reserved */
+/* 212 */
+EXTERN void		TclpFindExecutable(const char *argv0);
+/* 213 */
+EXTERN Tcl_Obj *	TclGetObjNameOfExecutable(void);
+/* 214 */
+EXTERN void		TclSetObjNameOfExecutable(Tcl_Obj *name,
+				Tcl_Encoding encoding);
+/* 215 */
+EXTERN void *		TclStackAlloc(Tcl_Interp *interp, int numBytes);
+/* 216 */
+EXTERN void		TclStackFree(Tcl_Interp *interp, void *freePtr);
+/* 217 */
+EXTERN int		TclPushStackFrame(Tcl_Interp *interp,
+				Tcl_CallFrame **framePtrPtr,
+				Tcl_Namespace *namespacePtr,
+				int isProcCallFrame);
+/* 218 */
+EXTERN void		TclPopStackFrame(Tcl_Interp *interp);
+/* Slot 219 is reserved */
+/* Slot 220 is reserved */
+/* Slot 221 is reserved */
+/* Slot 222 is reserved */
+/* 223 */
+EXTERN void *		TclGetCStackPtr(void);
+/* 224 */
+EXTERN TclPlatformType * TclGetPlatform(void);
+/* 225 */
+EXTERN Tcl_Obj *	TclTraceDictPath(Tcl_Interp *interp,
+				Tcl_Obj *rootPtr, int keyc,
+				Tcl_Obj *const keyv[], int flags);
+/* 226 */
+EXTERN int		TclObjBeingDeleted(Tcl_Obj *objPtr);
+/* 227 */
+EXTERN void		TclSetNsPath(Namespace *nsPtr, int pathLength,
+				Tcl_Namespace *pathAry[]);
+/* Slot 228 is reserved */
+/* 229 */
+EXTERN int		TclPtrMakeUpvar(Tcl_Interp *interp, Var *otherP1Ptr,
+				const char *myName, int myFlags, int index);
+/* 230 */
+EXTERN Var *		TclObjLookupVar(Tcl_Interp *interp,
+				Tcl_Obj *part1Ptr, const char *part2,
+				int flags, const char *msg, int createPart1,
+				int createPart2, Var **arrayPtrPtr);
+/* 231 */
+EXTERN int		TclGetNamespaceFromObj(Tcl_Interp *interp,
+				Tcl_Obj *objPtr, Tcl_Namespace **nsPtrPtr);
+/* 232 */
+EXTERN int		TclEvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr,
+				int flags, const CmdFrame *invoker, int word);
+/* 233 */
+EXTERN void		TclGetSrcInfoForPc(CmdFrame *contextPtr);
+/* 234 */
+EXTERN Var *		TclVarHashCreateVar(TclVarHashTable *tablePtr,
+				const char *key, int *newPtr);
+/* 235 */
+EXTERN void		TclInitVarHashTable(TclVarHashTable *tablePtr,
+				Namespace *nsPtr);
+/* 236 */
+EXTERN void		TclBackgroundException(Tcl_Interp *interp, int code);
+/* 237 */
+EXTERN int		TclResetCancellation(Tcl_Interp *interp, int force);
+/* 238 */
+EXTERN int		TclNRInterpProc(ClientData clientData,
+				Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[]);
+/* 239 */
+EXTERN int		TclNRInterpProcCore(Tcl_Interp *interp,
+				Tcl_Obj *procNameObj, int skip,
+				ProcErrorProc *errorProc);
+/* 240 */
+EXTERN int		TclNRRunCallbacks(Tcl_Interp *interp, int result,
+				struct NRE_callback *rootPtr);
+/* 241 */
+EXTERN int		TclNREvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr,
+				int flags, const CmdFrame *invoker, int word);
+/* 242 */
+EXTERN int		TclNREvalObjv(Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[], int flags,
+				Command *cmdPtr);
+/* 243 */
+EXTERN void		TclDbDumpActiveObjects(FILE *outFile);
+/* 244 */
+EXTERN Tcl_HashTable *	TclGetNamespaceChildTable(Tcl_Namespace *nsPtr);
+/* 245 */
+EXTERN Tcl_HashTable *	TclGetNamespaceCommandTable(Tcl_Namespace *nsPtr);
+/* 246 */
+EXTERN int		TclInitRewriteEnsemble(Tcl_Interp *interp,
+				int numRemoved, int numInserted,
+				Tcl_Obj *const *objv);
+/* 247 */
+EXTERN void		TclResetRewriteEnsemble(Tcl_Interp *interp,
+				int isRootEnsemble);
+/* 248 */
+EXTERN int		TclCopyChannel(Tcl_Interp *interp,
+				Tcl_Channel inChan, Tcl_Channel outChan,
+				Tcl_WideInt toRead, Tcl_Obj *cmdPtr);
+/* 249 */
+EXTERN char *		TclDoubleDigits(double dv, int ndigits, int flags,
+				int *decpt, int *signum, char **endPtr);
+/* 250 */
+EXTERN void		TclSetSlaveCancelFlags(Tcl_Interp *interp, int flags,
+				int force);
+/* 251 */
+EXTERN int		TclRegisterLiteral(void *envPtr, char *bytes,
+				int length, int flags);
+/* 252 */
+EXTERN Tcl_Obj *	TclPtrGetVar(Tcl_Interp *interp, Tcl_Var varPtr,
+				Tcl_Var arrayPtr, Tcl_Obj *part1Ptr,
+				Tcl_Obj *part2Ptr, int flags);
+/* 253 */
+EXTERN Tcl_Obj *	TclPtrSetVar(Tcl_Interp *interp, Tcl_Var varPtr,
+				Tcl_Var arrayPtr, Tcl_Obj *part1Ptr,
+				Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr,
+				int flags);
+/* 254 */
+EXTERN Tcl_Obj *	TclPtrIncrObjVar(Tcl_Interp *interp, Tcl_Var varPtr,
+				Tcl_Var arrayPtr, Tcl_Obj *part1Ptr,
+				Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr,
+				int flags);
+/* 255 */
+EXTERN int		TclPtrObjMakeUpvar(Tcl_Interp *interp,
+				Tcl_Var otherPtr, Tcl_Obj *myNamePtr,
+				int myFlags);
+/* 256 */
+EXTERN int		TclPtrUnsetVar(Tcl_Interp *interp, Tcl_Var varPtr,
+				Tcl_Var arrayPtr, Tcl_Obj *part1Ptr,
+				Tcl_Obj *part2Ptr, int flags);
+/* 257 */
+EXTERN void		TclStaticPackage(Tcl_Interp *interp,
+				const char *prefix,
+				Tcl_PackageInitProc *initProc,
+				Tcl_PackageInitProc *safeInitProc);
+/* Slot 258 is reserved */
+/* Slot 259 is reserved */
+/* Slot 260 is reserved */
+/* 261 */
+EXTERN void		TclUnusedStubEntry(void);
+
+typedef struct TclIntStubs {
+    int magic;
+    void *hooks;
+
+    void (*reserved0)(void);
+    void (*reserved1)(void);
+    void (*reserved2)(void);
+    void (*tclAllocateFreeObjects) (void); /* 3 */
+    void (*reserved4)(void);
+    int (*tclCleanupChildren) (Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr, Tcl_Channel errorChan); /* 5 */
+    void (*tclCleanupCommand) (Command *cmdPtr); /* 6 */
+    int (*tclCopyAndCollapse) (int count, const char *src, char *dst); /* 7 */
+    int (*tclCopyChannelOld) (Tcl_Interp *interp, Tcl_Channel inChan, Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr); /* 8 */
+    int (*tclCreatePipeline) (Tcl_Interp *interp, int argc, const char **argv, Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr, TclFile *errFilePtr); /* 9 */
+    int (*tclCreateProc) (Tcl_Interp *interp, Namespace *nsPtr, const char *procName, Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr); /* 10 */
+    void (*tclDeleteCompiledLocalVars) (Interp *iPtr, CallFrame *framePtr); /* 11 */
+    void (*tclDeleteVars) (Interp *iPtr, TclVarHashTable *tablePtr); /* 12 */
+    void (*reserved13)(void);
+    int (*tclDumpMemoryInfo) (ClientData clientData, int flags); /* 14 */
+    void (*reserved15)(void);
+    void (*tclExprFloatError) (Tcl_Interp *interp, double value); /* 16 */
+    void (*reserved17)(void);
+    void (*reserved18)(void);
+    void (*reserved19)(void);
+    void (*reserved20)(void);
+    void (*reserved21)(void);
+    int (*tclFindElement) (Tcl_Interp *interp, const char *listStr, int listLength, const char **elementPtr, const char **nextPtr, int *sizePtr, int *bracePtr); /* 22 */
+    Proc * (*tclFindProc) (Interp *iPtr, const char *procName); /* 23 */
+    int (*tclFormatInt) (char *buffer, long n); /* 24 */
+    void (*tclFreePackageInfo) (Interp *iPtr); /* 25 */
+    void (*reserved26)(void);
+    void (*reserved27)(void);
+    Tcl_Channel (*tclpGetDefaultStdChannel) (int type); /* 28 */
+    void (*reserved29)(void);
+    void (*reserved30)(void);
+    const char * (*tclGetExtension) (const char *name); /* 31 */
+    int (*tclGetFrame) (Tcl_Interp *interp, const char *str, CallFrame **framePtrPtr); /* 32 */
+    void (*reserved33)(void);
+    int (*tclGetIntForIndex) (Tcl_Interp *interp, Tcl_Obj *objPtr, int endValue, int *indexPtr); /* 34 */
+    void (*reserved35)(void);
+    void (*reserved36)(void);
+    int (*tclGetLoadedPackages) (Tcl_Interp *interp, const char *targetName); /* 37 */
+    int (*tclGetNamespaceForQualName) (Tcl_Interp *interp, const char *qualName, Namespace *cxtNsPtr, int flags, Namespace **nsPtrPtr, Namespace **altNsPtrPtr, Namespace **actualCxtPtrPtr, const char **simpleNamePtr); /* 38 */
+    Tcl_ObjCmdProc * (*tclGetObjInterpProc) (void); /* 39 */
+    int (*tclGetOpenMode) (Tcl_Interp *interp, const char *str, int *seekFlagPtr); /* 40 */
+    Tcl_Command (*tclGetOriginalCommand) (Tcl_Command command); /* 41 */
+    CONST86 char * (*tclpGetUserHome) (const char *name, Tcl_DString *bufferPtr); /* 42 */
+    void (*reserved43)(void);
+    int (*tclGuessPackageName) (const char *fileName, Tcl_DString *bufPtr); /* 44 */
+    int (*tclHideUnsafeCommands) (Tcl_Interp *interp); /* 45 */
+    int (*tclInExit) (void); /* 46 */
+    void (*reserved47)(void);
+    void (*reserved48)(void);
+    void (*reserved49)(void);
+    void (*tclInitCompiledLocals) (Tcl_Interp *interp, CallFrame *framePtr, Namespace *nsPtr); /* 50 */
+    int (*tclInterpInit) (Tcl_Interp *interp); /* 51 */
+    void (*reserved52)(void);
+    int (*tclInvokeObjectCommand) (ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char **argv); /* 53 */
+    int (*tclInvokeStringCommand) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 54 */
+    Proc * (*tclIsProc) (Command *cmdPtr); /* 55 */
+    void (*reserved56)(void);
+    void (*reserved57)(void);
+    Var * (*tclLookupVar) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, const char *msg, int createPart1, int createPart2, Var **arrayPtrPtr); /* 58 */
+    void (*reserved59)(void);
+    int (*tclNeedSpace) (const char *start, const char *end); /* 60 */
+    Tcl_Obj * (*tclNewProcBodyObj) (Proc *procPtr); /* 61 */
+    int (*tclObjCommandComplete) (Tcl_Obj *cmdPtr); /* 62 */
+    int (*tclObjInterpProc) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 63 */
+    int (*tclObjInvoke) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 64 */
+    void (*reserved65)(void);
+    void (*reserved66)(void);
+    void (*reserved67)(void);
+    void (*reserved68)(void);
+    char * (*tclpAlloc) (unsigned int size); /* 69 */
+    void (*reserved70)(void);
+    void (*reserved71)(void);
+    void (*reserved72)(void);
+    void (*reserved73)(void);
+    void (*tclpFree) (char *ptr); /* 74 */
+    unsigned long (*tclpGetClicks) (void); /* 75 */
+    unsigned long (*tclpGetSeconds) (void); /* 76 */
+    void (*tclpGetTime) (Tcl_Time *time); /* 77 */
+    void (*reserved78)(void);
+    void (*reserved79)(void);
+    void (*reserved80)(void);
+    char * (*tclpRealloc) (char *ptr, unsigned int size); /* 81 */
+    void (*reserved82)(void);
+    void (*reserved83)(void);
+    void (*reserved84)(void);
+    void (*reserved85)(void);
+    void (*reserved86)(void);
+    void (*reserved87)(void);
+    char * (*tclPrecTraceProc) (ClientData clientData, Tcl_Interp *interp, const char *name1, const char *name2, int flags); /* 88 */
+    int (*tclPreventAliasLoop) (Tcl_Interp *interp, Tcl_Interp *cmdInterp, Tcl_Command cmd); /* 89 */
+    void (*reserved90)(void);
+    void (*tclProcCleanupProc) (Proc *procPtr); /* 91 */
+    int (*tclProcCompileProc) (Tcl_Interp *interp, Proc *procPtr, Tcl_Obj *bodyPtr, Namespace *nsPtr, const char *description, const char *procName); /* 92 */
+    void (*tclProcDeleteProc) (ClientData clientData); /* 93 */
+    void (*reserved94)(void);
+    void (*reserved95)(void);
+    int (*tclRenameCommand) (Tcl_Interp *interp, const char *oldName, const char *newName); /* 96 */
+    void (*tclResetShadowedCmdRefs) (Tcl_Interp *interp, Command *newCmdPtr); /* 97 */
+    int (*tclServiceIdle) (void); /* 98 */
+    void (*reserved99)(void);
+    void (*reserved100)(void);
+    CONST86 char * (*tclSetPreInitScript) (const char *string); /* 101 */
+    void (*tclSetupEnv) (Tcl_Interp *interp); /* 102 */
+    int (*tclSockGetPort) (Tcl_Interp *interp, const char *str, const char *proto, int *portPtr); /* 103 */
+    int (*tclSockMinimumBuffersOld) (int sock, int size); /* 104 */
+    void (*reserved105)(void);
+    void (*reserved106)(void);
+    void (*reserved107)(void);
+    void (*tclTeardownNamespace) (Namespace *nsPtr); /* 108 */
+    int (*tclUpdateReturnInfo) (Interp *iPtr); /* 109 */
+    int (*tclSockMinimumBuffers) (void *sock, int size); /* 110 */
+    void (*tcl_AddInterpResolvers) (Tcl_Interp *interp, const char *name, Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, Tcl_ResolveCompiledVarProc *compiledVarProc); /* 111 */
+    int (*tcl_AppendExportList) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *objPtr); /* 112 */
+    Tcl_Namespace * (*tcl_CreateNamespace) (Tcl_Interp *interp, const char *name, ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc); /* 113 */
+    void (*tcl_DeleteNamespace) (Tcl_Namespace *nsPtr); /* 114 */
+    int (*tcl_Export) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int resetListFirst); /* 115 */
+    Tcl_Command (*tcl_FindCommand) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 116 */
+    Tcl_Namespace * (*tcl_FindNamespace) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 117 */
+    int (*tcl_GetInterpResolvers) (Tcl_Interp *interp, const char *name, Tcl_ResolverInfo *resInfo); /* 118 */
+    int (*tcl_GetNamespaceResolvers) (Tcl_Namespace *namespacePtr, Tcl_ResolverInfo *resInfo); /* 119 */
+    Tcl_Var (*tcl_FindNamespaceVar) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 120 */
+    int (*tcl_ForgetImport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern); /* 121 */
+    Tcl_Command (*tcl_GetCommandFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 122 */
+    void (*tcl_GetCommandFullName) (Tcl_Interp *interp, Tcl_Command command, Tcl_Obj *objPtr); /* 123 */
+    Tcl_Namespace * (*tcl_GetCurrentNamespace) (Tcl_Interp *interp); /* 124 */
+    Tcl_Namespace * (*tcl_GetGlobalNamespace) (Tcl_Interp *interp); /* 125 */
+    void (*tcl_GetVariableFullName) (Tcl_Interp *interp, Tcl_Var variable, Tcl_Obj *objPtr); /* 126 */
+    int (*tcl_Import) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int allowOverwrite); /* 127 */
+    void (*tcl_PopCallFrame) (Tcl_Interp *interp); /* 128 */
+    int (*tcl_PushCallFrame) (Tcl_Interp *interp, Tcl_CallFrame *framePtr, Tcl_Namespace *nsPtr, int isProcCallFrame); /* 129 */
+    int (*tcl_RemoveInterpResolvers) (Tcl_Interp *interp, const char *name); /* 130 */
+    void (*tcl_SetNamespaceResolvers) (Tcl_Namespace *namespacePtr, Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, Tcl_ResolveCompiledVarProc *compiledVarProc); /* 131 */
+    int (*tclpHasSockets) (Tcl_Interp *interp); /* 132 */
+    struct tm * (*tclpGetDate) (const time_t *time, int useGMT); /* 133 */
+    void (*reserved134)(void);
+    void (*reserved135)(void);
+    void (*reserved136)(void);
+    void (*reserved137)(void);
+    CONST84_RETURN char * (*tclGetEnv) (const char *name, Tcl_DString *valuePtr); /* 138 */
+    void (*reserved139)(void);
+    void (*reserved140)(void);
+    CONST84_RETURN char * (*tclpGetCwd) (Tcl_Interp *interp, Tcl_DString *cwdPtr); /* 141 */
+    int (*tclSetByteCodeFromAny) (Tcl_Interp *interp, Tcl_Obj *objPtr, CompileHookProc *hookProc, ClientData clientData); /* 142 */
+    int (*tclAddLiteralObj) (struct CompileEnv *envPtr, Tcl_Obj *objPtr, LiteralEntry **litPtrPtr); /* 143 */
+    void (*tclHideLiteral) (Tcl_Interp *interp, struct CompileEnv *envPtr, int index); /* 144 */
+    const struct AuxDataType * (*tclGetAuxDataType) (const char *typeName); /* 145 */
+    TclHandle (*tclHandleCreate) (void *ptr); /* 146 */
+    void (*tclHandleFree) (TclHandle handle); /* 147 */
+    TclHandle (*tclHandlePreserve) (TclHandle handle); /* 148 */
+    void (*tclHandleRelease) (TclHandle handle); /* 149 */
+    int (*tclRegAbout) (Tcl_Interp *interp, Tcl_RegExp re); /* 150 */
+    void (*tclRegExpRangeUniChar) (Tcl_RegExp re, int index, int *startPtr, int *endPtr); /* 151 */
+    void (*tclSetLibraryPath) (Tcl_Obj *pathPtr); /* 152 */
+    Tcl_Obj * (*tclGetLibraryPath) (void); /* 153 */
+    void (*reserved154)(void);
+    void (*reserved155)(void);
+    void (*tclRegError) (Tcl_Interp *interp, const char *msg, int status); /* 156 */
+    Var * (*tclVarTraceExists) (Tcl_Interp *interp, const char *varName); /* 157 */
+    void (*tclSetStartupScriptFileName) (const char *filename); /* 158 */
+    const char * (*tclGetStartupScriptFileName) (void); /* 159 */
+    void (*reserved160)(void);
+    int (*tclChannelTransform) (Tcl_Interp *interp, Tcl_Channel chan, Tcl_Obj *cmdObjPtr); /* 161 */
+    void (*tclChannelEventScriptInvoker) (ClientData clientData, int flags); /* 162 */
+    const void * (*tclGetInstructionTable) (void); /* 163 */
+    void (*tclExpandCodeArray) (void *envPtr); /* 164 */
+    void (*tclpSetInitialEncodings) (void); /* 165 */
+    int (*tclListObjSetElement) (Tcl_Interp *interp, Tcl_Obj *listPtr, int index, Tcl_Obj *valuePtr); /* 166 */
+    void (*tclSetStartupScriptPath) (Tcl_Obj *pathPtr); /* 167 */
+    Tcl_Obj * (*tclGetStartupScriptPath) (void); /* 168 */
+    int (*tclpUtfNcmp2) (const char *s1, const char *s2, unsigned long n); /* 169 */
+    int (*tclCheckInterpTraces) (Tcl_Interp *interp, const char *command, int numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 170 */
+    int (*tclCheckExecutionTraces) (Tcl_Interp *interp, const char *command, int numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 171 */
+    int (*tclInThreadExit) (void); /* 172 */
+    int (*tclUniCharMatch) (const Tcl_UniChar *string, int strLen, const Tcl_UniChar *pattern, int ptnLen, int flags); /* 173 */
+    void (*reserved174)(void);
+    int (*tclCallVarTraces) (Interp *iPtr, Var *arrayPtr, Var *varPtr, const char *part1, const char *part2, int flags, int leaveErrMsg); /* 175 */
+    void (*tclCleanupVar) (Var *varPtr, Var *arrayPtr); /* 176 */
+    void (*tclVarErrMsg) (Tcl_Interp *interp, const char *part1, const char *part2, const char *operation, const char *reason); /* 177 */
+    void (*tcl_SetStartupScript) (Tcl_Obj *pathPtr, const char *encodingName); /* 178 */
+    Tcl_Obj * (*tcl_GetStartupScript) (const char **encodingNamePtr); /* 179 */
+    void (*reserved180)(void);
+    void (*reserved181)(void);
+    struct tm * (*tclpLocaltime) (const time_t *clock); /* 182 */
+    struct tm * (*tclpGmtime) (const time_t *clock); /* 183 */
+    void (*reserved184)(void);
+    void (*reserved185)(void);
+    void (*reserved186)(void);
+    void (*reserved187)(void);
+    void (*reserved188)(void);
+    void (*reserved189)(void);
+    void (*reserved190)(void);
+    void (*reserved191)(void);
+    void (*reserved192)(void);
+    void (*reserved193)(void);
+    void (*reserved194)(void);
+    void (*reserved195)(void);
+    void (*reserved196)(void);
+    void (*reserved197)(void);
+    int (*tclObjGetFrame) (Tcl_Interp *interp, Tcl_Obj *objPtr, CallFrame **framePtrPtr); /* 198 */
+    void (*reserved199)(void);
+    int (*tclpObjRemoveDirectory) (Tcl_Obj *pathPtr, int recursive, Tcl_Obj **errorPtr); /* 200 */
+    int (*tclpObjCopyDirectory) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr); /* 201 */
+    int (*tclpObjCreateDirectory) (Tcl_Obj *pathPtr); /* 202 */
+    int (*tclpObjDeleteFile) (Tcl_Obj *pathPtr); /* 203 */
+    int (*tclpObjCopyFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 204 */
+    int (*tclpObjRenameFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 205 */
+    int (*tclpObjStat) (Tcl_Obj *pathPtr, Tcl_StatBuf *buf); /* 206 */
+    int (*tclpObjAccess) (Tcl_Obj *pathPtr, int mode); /* 207 */
+    Tcl_Channel (*tclpOpenFileChannel) (Tcl_Interp *interp, Tcl_Obj *pathPtr, int mode, int permissions); /* 208 */
+    void (*reserved209)(void);
+    void (*reserved210)(void);
+    void (*reserved211)(void);
+    void (*tclpFindExecutable) (const char *argv0); /* 212 */
+    Tcl_Obj * (*tclGetObjNameOfExecutable) (void); /* 213 */
+    void (*tclSetObjNameOfExecutable) (Tcl_Obj *name, Tcl_Encoding encoding); /* 214 */
+    void * (*tclStackAlloc) (Tcl_Interp *interp, int numBytes); /* 215 */
+    void (*tclStackFree) (Tcl_Interp *interp, void *freePtr); /* 216 */
+    int (*tclPushStackFrame) (Tcl_Interp *interp, Tcl_CallFrame **framePtrPtr, Tcl_Namespace *namespacePtr, int isProcCallFrame); /* 217 */
+    void (*tclPopStackFrame) (Tcl_Interp *interp); /* 218 */
+    void (*reserved219)(void);
+    void (*reserved220)(void);
+    void (*reserved221)(void);
+    void (*reserved222)(void);
+    void * (*tclGetCStackPtr) (void); /* 223 */
+    TclPlatformType * (*tclGetPlatform) (void); /* 224 */
+    Tcl_Obj * (*tclTraceDictPath) (Tcl_Interp *interp, Tcl_Obj *rootPtr, int keyc, Tcl_Obj *const keyv[], int flags); /* 225 */
+    int (*tclObjBeingDeleted) (Tcl_Obj *objPtr); /* 226 */
+    void (*tclSetNsPath) (Namespace *nsPtr, int pathLength, Tcl_Namespace *pathAry[]); /* 227 */
+    void (*reserved228)(void);
+    int (*tclPtrMakeUpvar) (Tcl_Interp *interp, Var *otherP1Ptr, const char *myName, int myFlags, int index); /* 229 */
+    Var * (*tclObjLookupVar) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, const char *part2, int flags, const char *msg, int createPart1, int createPart2, Var **arrayPtrPtr); /* 230 */
+    int (*tclGetNamespaceFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Namespace **nsPtrPtr); /* 231 */
+    int (*tclEvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, const CmdFrame *invoker, int word); /* 232 */
+    void (*tclGetSrcInfoForPc) (CmdFrame *contextPtr); /* 233 */
+    Var * (*tclVarHashCreateVar) (TclVarHashTable *tablePtr, const char *key, int *newPtr); /* 234 */
+    void (*tclInitVarHashTable) (TclVarHashTable *tablePtr, Namespace *nsPtr); /* 235 */
+    void (*tclBackgroundException) (Tcl_Interp *interp, int code); /* 236 */
+    int (*tclResetCancellation) (Tcl_Interp *interp, int force); /* 237 */
+    int (*tclNRInterpProc) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 238 */
+    int (*tclNRInterpProcCore) (Tcl_Interp *interp, Tcl_Obj *procNameObj, int skip, ProcErrorProc *errorProc); /* 239 */
+    int (*tclNRRunCallbacks) (Tcl_Interp *interp, int result, struct NRE_callback *rootPtr); /* 240 */
+    int (*tclNREvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, const CmdFrame *invoker, int word); /* 241 */
+    int (*tclNREvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags, Command *cmdPtr); /* 242 */
+    void (*tclDbDumpActiveObjects) (FILE *outFile); /* 243 */
+    Tcl_HashTable * (*tclGetNamespaceChildTable) (Tcl_Namespace *nsPtr); /* 244 */
+    Tcl_HashTable * (*tclGetNamespaceCommandTable) (Tcl_Namespace *nsPtr); /* 245 */
+    int (*tclInitRewriteEnsemble) (Tcl_Interp *interp, int numRemoved, int numInserted, Tcl_Obj *const *objv); /* 246 */
+    void (*tclResetRewriteEnsemble) (Tcl_Interp *interp, int isRootEnsemble); /* 247 */
+    int (*tclCopyChannel) (Tcl_Interp *interp, Tcl_Channel inChan, Tcl_Channel outChan, Tcl_WideInt toRead, Tcl_Obj *cmdPtr); /* 248 */
+    char * (*tclDoubleDigits) (double dv, int ndigits, int flags, int *decpt, int *signum, char **endPtr); /* 249 */
+    void (*tclSetSlaveCancelFlags) (Tcl_Interp *interp, int flags, int force); /* 250 */
+    int (*tclRegisterLiteral) (void *envPtr, char *bytes, int length, int flags); /* 251 */
+    Tcl_Obj * (*tclPtrGetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags); /* 252 */
+    Tcl_Obj * (*tclPtrSetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags); /* 253 */
+    Tcl_Obj * (*tclPtrIncrObjVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr, int flags); /* 254 */
+    int (*tclPtrObjMakeUpvar) (Tcl_Interp *interp, Tcl_Var otherPtr, Tcl_Obj *myNamePtr, int myFlags); /* 255 */
+    int (*tclPtrUnsetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags); /* 256 */
+    void (*tclStaticPackage) (Tcl_Interp *interp, const char *prefix, Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc); /* 257 */
+    void (*reserved258)(void);
+    void (*reserved259)(void);
+    void (*reserved260)(void);
+    void (*tclUnusedStubEntry) (void); /* 261 */
+} TclIntStubs;
+
+extern const TclIntStubs *tclIntStubsPtr;
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(USE_TCL_STUBS)
+
+/*
+ * Inline function declarations:
+ */
+
+/* Slot 0 is reserved */
+/* Slot 1 is reserved */
+/* Slot 2 is reserved */
+#define TclAllocateFreeObjects \
+	(tclIntStubsPtr->tclAllocateFreeObjects) /* 3 */
+/* Slot 4 is reserved */
+#define TclCleanupChildren \
+	(tclIntStubsPtr->tclCleanupChildren) /* 5 */
+#define TclCleanupCommand \
+	(tclIntStubsPtr->tclCleanupCommand) /* 6 */
+#define TclCopyAndCollapse \
+	(tclIntStubsPtr->tclCopyAndCollapse) /* 7 */
+#define TclCopyChannelOld \
+	(tclIntStubsPtr->tclCopyChannelOld) /* 8 */
+#define TclCreatePipeline \
+	(tclIntStubsPtr->tclCreatePipeline) /* 9 */
+#define TclCreateProc \
+	(tclIntStubsPtr->tclCreateProc) /* 10 */
+#define TclDeleteCompiledLocalVars \
+	(tclIntStubsPtr->tclDeleteCompiledLocalVars) /* 11 */
+#define TclDeleteVars \
+	(tclIntStubsPtr->tclDeleteVars) /* 12 */
+/* Slot 13 is reserved */
+#define TclDumpMemoryInfo \
+	(tclIntStubsPtr->tclDumpMemoryInfo) /* 14 */
+/* Slot 15 is reserved */
+#define TclExprFloatError \
+	(tclIntStubsPtr->tclExprFloatError) /* 16 */
+/* Slot 17 is reserved */
+/* Slot 18 is reserved */
+/* Slot 19 is reserved */
+/* Slot 20 is reserved */
+/* Slot 21 is reserved */
+#define TclFindElement \
+	(tclIntStubsPtr->tclFindElement) /* 22 */
+#define TclFindProc \
+	(tclIntStubsPtr->tclFindProc) /* 23 */
+#define TclFormatInt \
+	(tclIntStubsPtr->tclFormatInt) /* 24 */
+#define TclFreePackageInfo \
+	(tclIntStubsPtr->tclFreePackageInfo) /* 25 */
+/* Slot 26 is reserved */
+/* Slot 27 is reserved */
+#define TclpGetDefaultStdChannel \
+	(tclIntStubsPtr->tclpGetDefaultStdChannel) /* 28 */
+/* Slot 29 is reserved */
+/* Slot 30 is reserved */
+#define TclGetExtension \
+	(tclIntStubsPtr->tclGetExtension) /* 31 */
+#define TclGetFrame \
+	(tclIntStubsPtr->tclGetFrame) /* 32 */
+/* Slot 33 is reserved */
+#define TclGetIntForIndex \
+	(tclIntStubsPtr->tclGetIntForIndex) /* 34 */
+/* Slot 35 is reserved */
+/* Slot 36 is reserved */
+#define TclGetLoadedPackages \
+	(tclIntStubsPtr->tclGetLoadedPackages) /* 37 */
+#define TclGetNamespaceForQualName \
+	(tclIntStubsPtr->tclGetNamespaceForQualName) /* 38 */
+#define TclGetObjInterpProc \
+	(tclIntStubsPtr->tclGetObjInterpProc) /* 39 */
+#define TclGetOpenMode \
+	(tclIntStubsPtr->tclGetOpenMode) /* 40 */
+#define TclGetOriginalCommand \
+	(tclIntStubsPtr->tclGetOriginalCommand) /* 41 */
+#define TclpGetUserHome \
+	(tclIntStubsPtr->tclpGetUserHome) /* 42 */
+/* Slot 43 is reserved */
+#define TclGuessPackageName \
+	(tclIntStubsPtr->tclGuessPackageName) /* 44 */
+#define TclHideUnsafeCommands \
+	(tclIntStubsPtr->tclHideUnsafeCommands) /* 45 */
+#define TclInExit \
+	(tclIntStubsPtr->tclInExit) /* 46 */
+/* Slot 47 is reserved */
+/* Slot 48 is reserved */
+/* Slot 49 is reserved */
+#define TclInitCompiledLocals \
+	(tclIntStubsPtr->tclInitCompiledLocals) /* 50 */
+#define TclInterpInit \
+	(tclIntStubsPtr->tclInterpInit) /* 51 */
+/* Slot 52 is reserved */
+#define TclInvokeObjectCommand \
+	(tclIntStubsPtr->tclInvokeObjectCommand) /* 53 */
+#define TclInvokeStringCommand \
+	(tclIntStubsPtr->tclInvokeStringCommand) /* 54 */
+#define TclIsProc \
+	(tclIntStubsPtr->tclIsProc) /* 55 */
+/* Slot 56 is reserved */
+/* Slot 57 is reserved */
+#define TclLookupVar \
+	(tclIntStubsPtr->tclLookupVar) /* 58 */
+/* Slot 59 is reserved */
+#define TclNeedSpace \
+	(tclIntStubsPtr->tclNeedSpace) /* 60 */
+#define TclNewProcBodyObj \
+	(tclIntStubsPtr->tclNewProcBodyObj) /* 61 */
+#define TclObjCommandComplete \
+	(tclIntStubsPtr->tclObjCommandComplete) /* 62 */
+#define TclObjInterpProc \
+	(tclIntStubsPtr->tclObjInterpProc) /* 63 */
+#define TclObjInvoke \
+	(tclIntStubsPtr->tclObjInvoke) /* 64 */
+/* Slot 65 is reserved */
+/* Slot 66 is reserved */
+/* Slot 67 is reserved */
+/* Slot 68 is reserved */
+#define TclpAlloc \
+	(tclIntStubsPtr->tclpAlloc) /* 69 */
+/* Slot 70 is reserved */
+/* Slot 71 is reserved */
+/* Slot 72 is reserved */
+/* Slot 73 is reserved */
+#define TclpFree \
+	(tclIntStubsPtr->tclpFree) /* 74 */
+#define TclpGetClicks \
+	(tclIntStubsPtr->tclpGetClicks) /* 75 */
+#define TclpGetSeconds \
+	(tclIntStubsPtr->tclpGetSeconds) /* 76 */
+#define TclpGetTime \
+	(tclIntStubsPtr->tclpGetTime) /* 77 */
+/* Slot 78 is reserved */
+/* Slot 79 is reserved */
+/* Slot 80 is reserved */
+#define TclpRealloc \
+	(tclIntStubsPtr->tclpRealloc) /* 81 */
+/* Slot 82 is reserved */
+/* Slot 83 is reserved */
+/* Slot 84 is reserved */
+/* Slot 85 is reserved */
+/* Slot 86 is reserved */
+/* Slot 87 is reserved */
+#define TclPrecTraceProc \
+	(tclIntStubsPtr->tclPrecTraceProc) /* 88 */
+#define TclPreventAliasLoop \
+	(tclIntStubsPtr->tclPreventAliasLoop) /* 89 */
+/* Slot 90 is reserved */
+#define TclProcCleanupProc \
+	(tclIntStubsPtr->tclProcCleanupProc) /* 91 */
+#define TclProcCompileProc \
+	(tclIntStubsPtr->tclProcCompileProc) /* 92 */
+#define TclProcDeleteProc \
+	(tclIntStubsPtr->tclProcDeleteProc) /* 93 */
+/* Slot 94 is reserved */
+/* Slot 95 is reserved */
+#define TclRenameCommand \
+	(tclIntStubsPtr->tclRenameCommand) /* 96 */
+#define TclResetShadowedCmdRefs \
+	(tclIntStubsPtr->tclResetShadowedCmdRefs) /* 97 */
+#define TclServiceIdle \
+	(tclIntStubsPtr->tclServiceIdle) /* 98 */
+/* Slot 99 is reserved */
+/* Slot 100 is reserved */
+#define TclSetPreInitScript \
+	(tclIntStubsPtr->tclSetPreInitScript) /* 101 */
+#define TclSetupEnv \
+	(tclIntStubsPtr->tclSetupEnv) /* 102 */
+#define TclSockGetPort \
+	(tclIntStubsPtr->tclSockGetPort) /* 103 */
+#define TclSockMinimumBuffersOld \
+	(tclIntStubsPtr->tclSockMinimumBuffersOld) /* 104 */
+/* Slot 105 is reserved */
+/* Slot 106 is reserved */
+/* Slot 107 is reserved */
+#define TclTeardownNamespace \
+	(tclIntStubsPtr->tclTeardownNamespace) /* 108 */
+#define TclUpdateReturnInfo \
+	(tclIntStubsPtr->tclUpdateReturnInfo) /* 109 */
+#define TclSockMinimumBuffers \
+	(tclIntStubsPtr->tclSockMinimumBuffers) /* 110 */
+#define Tcl_AddInterpResolvers \
+	(tclIntStubsPtr->tcl_AddInterpResolvers) /* 111 */
+#define Tcl_AppendExportList \
+	(tclIntStubsPtr->tcl_AppendExportList) /* 112 */
+#define Tcl_CreateNamespace \
+	(tclIntStubsPtr->tcl_CreateNamespace) /* 113 */
+#define Tcl_DeleteNamespace \
+	(tclIntStubsPtr->tcl_DeleteNamespace) /* 114 */
+#define Tcl_Export \
+	(tclIntStubsPtr->tcl_Export) /* 115 */
+#define Tcl_FindCommand \
+	(tclIntStubsPtr->tcl_FindCommand) /* 116 */
+#define Tcl_FindNamespace \
+	(tclIntStubsPtr->tcl_FindNamespace) /* 117 */
+#define Tcl_GetInterpResolvers \
+	(tclIntStubsPtr->tcl_GetInterpResolvers) /* 118 */
+#define Tcl_GetNamespaceResolvers \
+	(tclIntStubsPtr->tcl_GetNamespaceResolvers) /* 119 */
+#define Tcl_FindNamespaceVar \
+	(tclIntStubsPtr->tcl_FindNamespaceVar) /* 120 */
+#define Tcl_ForgetImport \
+	(tclIntStubsPtr->tcl_ForgetImport) /* 121 */
+#define Tcl_GetCommandFromObj \
+	(tclIntStubsPtr->tcl_GetCommandFromObj) /* 122 */
+#define Tcl_GetCommandFullName \
+	(tclIntStubsPtr->tcl_GetCommandFullName) /* 123 */
+#define Tcl_GetCurrentNamespace \
+	(tclIntStubsPtr->tcl_GetCurrentNamespace) /* 124 */
+#define Tcl_GetGlobalNamespace \
+	(tclIntStubsPtr->tcl_GetGlobalNamespace) /* 125 */
+#define Tcl_GetVariableFullName \
+	(tclIntStubsPtr->tcl_GetVariableFullName) /* 126 */
+#define Tcl_Import \
+	(tclIntStubsPtr->tcl_Import) /* 127 */
+#define Tcl_PopCallFrame \
+	(tclIntStubsPtr->tcl_PopCallFrame) /* 128 */
+#define Tcl_PushCallFrame \
+	(tclIntStubsPtr->tcl_PushCallFrame) /* 129 */
+#define Tcl_RemoveInterpResolvers \
+	(tclIntStubsPtr->tcl_RemoveInterpResolvers) /* 130 */
+#define Tcl_SetNamespaceResolvers \
+	(tclIntStubsPtr->tcl_SetNamespaceResolvers) /* 131 */
+#define TclpHasSockets \
+	(tclIntStubsPtr->tclpHasSockets) /* 132 */
+#define TclpGetDate \
+	(tclIntStubsPtr->tclpGetDate) /* 133 */
+/* Slot 134 is reserved */
+/* Slot 135 is reserved */
+/* Slot 136 is reserved */
+/* Slot 137 is reserved */
+#define TclGetEnv \
+	(tclIntStubsPtr->tclGetEnv) /* 138 */
+/* Slot 139 is reserved */
+/* Slot 140 is reserved */
+#define TclpGetCwd \
+	(tclIntStubsPtr->tclpGetCwd) /* 141 */
+#define TclSetByteCodeFromAny \
+	(tclIntStubsPtr->tclSetByteCodeFromAny) /* 142 */
+#define TclAddLiteralObj \
+	(tclIntStubsPtr->tclAddLiteralObj) /* 143 */
+#define TclHideLiteral \
+	(tclIntStubsPtr->tclHideLiteral) /* 144 */
+#define TclGetAuxDataType \
+	(tclIntStubsPtr->tclGetAuxDataType) /* 145 */
+#define TclHandleCreate \
+	(tclIntStubsPtr->tclHandleCreate) /* 146 */
+#define TclHandleFree \
+	(tclIntStubsPtr->tclHandleFree) /* 147 */
+#define TclHandlePreserve \
+	(tclIntStubsPtr->tclHandlePreserve) /* 148 */
+#define TclHandleRelease \
+	(tclIntStubsPtr->tclHandleRelease) /* 149 */
+#define TclRegAbout \
+	(tclIntStubsPtr->tclRegAbout) /* 150 */
+#define TclRegExpRangeUniChar \
+	(tclIntStubsPtr->tclRegExpRangeUniChar) /* 151 */
+#define TclSetLibraryPath \
+	(tclIntStubsPtr->tclSetLibraryPath) /* 152 */
+#define TclGetLibraryPath \
+	(tclIntStubsPtr->tclGetLibraryPath) /* 153 */
+/* Slot 154 is reserved */
+/* Slot 155 is reserved */
+#define TclRegError \
+	(tclIntStubsPtr->tclRegError) /* 156 */
+#define TclVarTraceExists \
+	(tclIntStubsPtr->tclVarTraceExists) /* 157 */
+#define TclSetStartupScriptFileName \
+	(tclIntStubsPtr->tclSetStartupScriptFileName) /* 158 */
+#define TclGetStartupScriptFileName \
+	(tclIntStubsPtr->tclGetStartupScriptFileName) /* 159 */
+/* Slot 160 is reserved */
+#define TclChannelTransform \
+	(tclIntStubsPtr->tclChannelTransform) /* 161 */
+#define TclChannelEventScriptInvoker \
+	(tclIntStubsPtr->tclChannelEventScriptInvoker) /* 162 */
+#define TclGetInstructionTable \
+	(tclIntStubsPtr->tclGetInstructionTable) /* 163 */
+#define TclExpandCodeArray \
+	(tclIntStubsPtr->tclExpandCodeArray) /* 164 */
+#define TclpSetInitialEncodings \
+	(tclIntStubsPtr->tclpSetInitialEncodings) /* 165 */
+#define TclListObjSetElement \
+	(tclIntStubsPtr->tclListObjSetElement) /* 166 */
+#define TclSetStartupScriptPath \
+	(tclIntStubsPtr->tclSetStartupScriptPath) /* 167 */
+#define TclGetStartupScriptPath \
+	(tclIntStubsPtr->tclGetStartupScriptPath) /* 168 */
+#define TclpUtfNcmp2 \
+	(tclIntStubsPtr->tclpUtfNcmp2) /* 169 */
+#define TclCheckInterpTraces \
+	(tclIntStubsPtr->tclCheckInterpTraces) /* 170 */
+#define TclCheckExecutionTraces \
+	(tclIntStubsPtr->tclCheckExecutionTraces) /* 171 */
+#define TclInThreadExit \
+	(tclIntStubsPtr->tclInThreadExit) /* 172 */
+#define TclUniCharMatch \
+	(tclIntStubsPtr->tclUniCharMatch) /* 173 */
+/* Slot 174 is reserved */
+#define TclCallVarTraces \
+	(tclIntStubsPtr->tclCallVarTraces) /* 175 */
+#define TclCleanupVar \
+	(tclIntStubsPtr->tclCleanupVar) /* 176 */
+#define TclVarErrMsg \
+	(tclIntStubsPtr->tclVarErrMsg) /* 177 */
+#define Tcl_SetStartupScript \
+	(tclIntStubsPtr->tcl_SetStartupScript) /* 178 */
+#define Tcl_GetStartupScript \
+	(tclIntStubsPtr->tcl_GetStartupScript) /* 179 */
+/* Slot 180 is reserved */
+/* Slot 181 is reserved */
+#define TclpLocaltime \
+	(tclIntStubsPtr->tclpLocaltime) /* 182 */
+#define TclpGmtime \
+	(tclIntStubsPtr->tclpGmtime) /* 183 */
+/* Slot 184 is reserved */
+/* Slot 185 is reserved */
+/* Slot 186 is reserved */
+/* Slot 187 is reserved */
+/* Slot 188 is reserved */
+/* Slot 189 is reserved */
+/* Slot 190 is reserved */
+/* Slot 191 is reserved */
+/* Slot 192 is reserved */
+/* Slot 193 is reserved */
+/* Slot 194 is reserved */
+/* Slot 195 is reserved */
+/* Slot 196 is reserved */
+/* Slot 197 is reserved */
+#define TclObjGetFrame \
+	(tclIntStubsPtr->tclObjGetFrame) /* 198 */
+/* Slot 199 is reserved */
+#define TclpObjRemoveDirectory \
+	(tclIntStubsPtr->tclpObjRemoveDirectory) /* 200 */
+#define TclpObjCopyDirectory \
+	(tclIntStubsPtr->tclpObjCopyDirectory) /* 201 */
+#define TclpObjCreateDirectory \
+	(tclIntStubsPtr->tclpObjCreateDirectory) /* 202 */
+#define TclpObjDeleteFile \
+	(tclIntStubsPtr->tclpObjDeleteFile) /* 203 */
+#define TclpObjCopyFile \
+	(tclIntStubsPtr->tclpObjCopyFile) /* 204 */
+#define TclpObjRenameFile \
+	(tclIntStubsPtr->tclpObjRenameFile) /* 205 */
+#define TclpObjStat \
+	(tclIntStubsPtr->tclpObjStat) /* 206 */
+#define TclpObjAccess \
+	(tclIntStubsPtr->tclpObjAccess) /* 207 */
+#define TclpOpenFileChannel \
+	(tclIntStubsPtr->tclpOpenFileChannel) /* 208 */
+/* Slot 209 is reserved */
+/* Slot 210 is reserved */
+/* Slot 211 is reserved */
+#define TclpFindExecutable \
+	(tclIntStubsPtr->tclpFindExecutable) /* 212 */
+#define TclGetObjNameOfExecutable \
+	(tclIntStubsPtr->tclGetObjNameOfExecutable) /* 213 */
+#define TclSetObjNameOfExecutable \
+	(tclIntStubsPtr->tclSetObjNameOfExecutable) /* 214 */
+#define TclStackAlloc \
+	(tclIntStubsPtr->tclStackAlloc) /* 215 */
+#define TclStackFree \
+	(tclIntStubsPtr->tclStackFree) /* 216 */
+#define TclPushStackFrame \
+	(tclIntStubsPtr->tclPushStackFrame) /* 217 */
+#define TclPopStackFrame \
+	(tclIntStubsPtr->tclPopStackFrame) /* 218 */
+/* Slot 219 is reserved */
+/* Slot 220 is reserved */
+/* Slot 221 is reserved */
+/* Slot 222 is reserved */
+#define TclGetCStackPtr \
+	(tclIntStubsPtr->tclGetCStackPtr) /* 223 */
+#define TclGetPlatform \
+	(tclIntStubsPtr->tclGetPlatform) /* 224 */
+#define TclTraceDictPath \
+	(tclIntStubsPtr->tclTraceDictPath) /* 225 */
+#define TclObjBeingDeleted \
+	(tclIntStubsPtr->tclObjBeingDeleted) /* 226 */
+#define TclSetNsPath \
+	(tclIntStubsPtr->tclSetNsPath) /* 227 */
+/* Slot 228 is reserved */
+#define TclPtrMakeUpvar \
+	(tclIntStubsPtr->tclPtrMakeUpvar) /* 229 */
+#define TclObjLookupVar \
+	(tclIntStubsPtr->tclObjLookupVar) /* 230 */
+#define TclGetNamespaceFromObj \
+	(tclIntStubsPtr->tclGetNamespaceFromObj) /* 231 */
+#define TclEvalObjEx \
+	(tclIntStubsPtr->tclEvalObjEx) /* 232 */
+#define TclGetSrcInfoForPc \
+	(tclIntStubsPtr->tclGetSrcInfoForPc) /* 233 */
+#define TclVarHashCreateVar \
+	(tclIntStubsPtr->tclVarHashCreateVar) /* 234 */
+#define TclInitVarHashTable \
+	(tclIntStubsPtr->tclInitVarHashTable) /* 235 */
+#define TclBackgroundException \
+	(tclIntStubsPtr->tclBackgroundException) /* 236 */
+#define TclResetCancellation \
+	(tclIntStubsPtr->tclResetCancellation) /* 237 */
+#define TclNRInterpProc \
+	(tclIntStubsPtr->tclNRInterpProc) /* 238 */
+#define TclNRInterpProcCore \
+	(tclIntStubsPtr->tclNRInterpProcCore) /* 239 */
+#define TclNRRunCallbacks \
+	(tclIntStubsPtr->tclNRRunCallbacks) /* 240 */
+#define TclNREvalObjEx \
+	(tclIntStubsPtr->tclNREvalObjEx) /* 241 */
+#define TclNREvalObjv \
+	(tclIntStubsPtr->tclNREvalObjv) /* 242 */
+#define TclDbDumpActiveObjects \
+	(tclIntStubsPtr->tclDbDumpActiveObjects) /* 243 */
+#define TclGetNamespaceChildTable \
+	(tclIntStubsPtr->tclGetNamespaceChildTable) /* 244 */
+#define TclGetNamespaceCommandTable \
+	(tclIntStubsPtr->tclGetNamespaceCommandTable) /* 245 */
+#define TclInitRewriteEnsemble \
+	(tclIntStubsPtr->tclInitRewriteEnsemble) /* 246 */
+#define TclResetRewriteEnsemble \
+	(tclIntStubsPtr->tclResetRewriteEnsemble) /* 247 */
+#define TclCopyChannel \
+	(tclIntStubsPtr->tclCopyChannel) /* 248 */
+#define TclDoubleDigits \
+	(tclIntStubsPtr->tclDoubleDigits) /* 249 */
+#define TclSetSlaveCancelFlags \
+	(tclIntStubsPtr->tclSetSlaveCancelFlags) /* 250 */
+#define TclRegisterLiteral \
+	(tclIntStubsPtr->tclRegisterLiteral) /* 251 */
+#define TclPtrGetVar \
+	(tclIntStubsPtr->tclPtrGetVar) /* 252 */
+#define TclPtrSetVar \
+	(tclIntStubsPtr->tclPtrSetVar) /* 253 */
+#define TclPtrIncrObjVar \
+	(tclIntStubsPtr->tclPtrIncrObjVar) /* 254 */
+#define TclPtrObjMakeUpvar \
+	(tclIntStubsPtr->tclPtrObjMakeUpvar) /* 255 */
+#define TclPtrUnsetVar \
+	(tclIntStubsPtr->tclPtrUnsetVar) /* 256 */
+#define TclStaticPackage \
+	(tclIntStubsPtr->tclStaticPackage) /* 257 */
+/* Slot 258 is reserved */
+/* Slot 259 is reserved */
+/* Slot 260 is reserved */
+#define TclUnusedStubEntry \
+	(tclIntStubsPtr->tclUnusedStubEntry) /* 261 */
+
+#endif /* defined(USE_TCL_STUBS) */
+
+/* !END!: Do not edit above this line. */
+
+#undef TCL_STORAGE_CLASS
+#define TCL_STORAGE_CLASS DLLIMPORT
+
+#undef TclGetStartupScriptFileName
+#undef TclSetStartupScriptFileName
+#undef TclGetStartupScriptPath
+#undef TclSetStartupScriptPath
+#undef TclBackgroundException
+#undef TclUnusedStubEntry
+#undef TclObjInterpProc
+#define TclObjInterpProc TclGetObjInterpProc()
+
+#if defined(USE_TCL_STUBS) && defined(TCL_NO_DEPRECATED)
+#   undef Tcl_SetStartupScript
+#   define Tcl_SetStartupScript \
+	    (tclStubsPtr->tcl_SetStartupScript) /* 622 */
+#   undef Tcl_GetStartupScript
+#   define Tcl_GetStartupScript \
+	    (tclStubsPtr->tcl_GetStartupScript) /* 623 */
+#   undef Tcl_CreateNamespace
+#   define Tcl_CreateNamespace \
+	   (tclStubsPtr->tcl_CreateNamespace) /* 506 */
+#   undef Tcl_DeleteNamespace
+#   define Tcl_DeleteNamespace \
+	   (tclStubsPtr->tcl_DeleteNamespace) /* 507 */
+#   undef Tcl_AppendExportList
+#   define Tcl_AppendExportList \
+	   (tclStubsPtr->tcl_AppendExportList) /* 508 */
+#   undef Tcl_Export
+#   define Tcl_Export \
+	   (tclStubsPtr->tcl_Export) /* 509 */
+#   undef Tcl_Import
+#   define Tcl_Import \
+	   (tclStubsPtr->tcl_Import) /* 510 */
+#   undef Tcl_ForgetImport
+#   define Tcl_ForgetImport \
+	   (tclStubsPtr->tcl_ForgetImport) /* 511 */
+#   undef Tcl_GetCurrentNamespace
+#   define Tcl_GetCurrentNamespace \
+	   (tclStubsPtr->tcl_GetCurrentNamespace) /* 512 */
+#   undef Tcl_GetGlobalNamespace
+#   define Tcl_GetGlobalNamespace \
+	   (tclStubsPtr->tcl_GetGlobalNamespace) /* 513 */
+#   undef Tcl_FindNamespace
+#   define Tcl_FindNamespace \
+	   (tclStubsPtr->tcl_FindNamespace) /* 514 */
+#   undef Tcl_FindCommand
+#   define Tcl_FindCommand \
+	   (tclStubsPtr->tcl_FindCommand) /* 515 */
+#   undef Tcl_GetCommandFromObj
+#   define Tcl_GetCommandFromObj \
+	   (tclStubsPtr->tcl_GetCommandFromObj) /* 516 */
+#   undef Tcl_GetCommandFullName
+#   define Tcl_GetCommandFullName \
+	   (tclStubsPtr->tcl_GetCommandFullName) /* 517 */
+#endif
+
+#undef TclCopyChannelOld
+#undef TclSockMinimumBuffersOld
+
+#define TclSetChildCancelFlags TclSetSlaveCancelFlags
+
+#endif /* _TCLINTDECLS */

evalkit_cambrian/include/tclOOInt.h

@@ -0,0 +1,607 @@
+/*
+ * tclOOInt.h --
+ *
+ *	This file contains the structure definitions and some of the function
+ *	declarations for the object-system (NB: not Tcl_Obj, but ::oo).
+ *
+ * Copyright (c) 2006-2012 by Donal K. Fellows
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef TCL_OO_INTERNAL_H
+#define TCL_OO_INTERNAL_H 1
+
+#include "tclInt.h"
+#include "tclOO.h"
+
+/*
+ * Hack to make things work with Objective C. Note that ObjC isn't really
+ * supported, but we don't want to to be actively hostile to it. [Bug 2163447]
+ */
+
+#ifdef __OBJC__
+#define Class	TclOOClass
+#define Object	TclOOObject
+#endif /* __OBJC__ */
+
+/*
+ * Forward declarations.
+ */
+
+struct CallChain;
+struct Class;
+struct Foundation;
+struct Object;
+
+/*
+ * The data that needs to be stored per method. This record is used to collect
+ * information about all sorts of methods, including forwards, constructors
+ * and destructors.
+ */
+
+typedef struct Method {
+    const Tcl_MethodType *typePtr;
+				/* The type of method. If NULL, this is a
+				 * special flag record which is just used for
+				 * the setting of the flags field. */
+    int refCount;
+    void *clientData;	/* Type-specific data. */
+    Tcl_Obj *namePtr;		/* Name of the method. */
+    struct Object *declaringObjectPtr;
+				/* The object that declares this method, or
+				 * NULL if it was declared by a class. */
+    struct Class *declaringClassPtr;
+				/* The class that declares this method, or
+				 * NULL if it was declared directly on an
+				 * object. */
+    int flags;			/* Assorted flags. Includes whether this
+				 * method is public/exported or not. */
+} Method;
+
+/*
+ * Pre- and post-call callbacks, to allow procedure-like methods to be fine
+ * tuned in their behaviour.
+ */
+
+typedef int (TclOO_PreCallProc)(void *clientData, Tcl_Interp *interp,
+	Tcl_ObjectContext context, Tcl_CallFrame *framePtr, int *isFinished);
+typedef int (TclOO_PostCallProc)(void *clientData, Tcl_Interp *interp,
+	Tcl_ObjectContext context, Tcl_Namespace *namespacePtr, int result);
+typedef void (TclOO_PmCDDeleteProc)(void *clientData);
+typedef void *(TclOO_PmCDCloneProc)(void *clientData);
+
+/*
+ * Procedure-like methods have the following extra information.
+ */
+
+typedef struct ProcedureMethod {
+    int version;		/* Version of this structure. Currently must
+				 * be 0. */
+    Proc *procPtr;		/* Core of the implementation of the method;
+				 * includes the argument definition and the
+				 * body bytecodes. */
+    int flags;			/* Flags to control features. */
+    int refCount;
+    void *clientData;
+    TclOO_PmCDDeleteProc *deleteClientdataProc;
+    TclOO_PmCDCloneProc *cloneClientdataProc;
+    ProcErrorProc *errProc;	/* Replacement error handler. */
+    TclOO_PreCallProc *preCallProc;
+				/* Callback to allow for additional setup
+				 * before the method executes. */
+    TclOO_PostCallProc *postCallProc;
+				/* Callback to allow for additional cleanup
+				 * after the method executes. */
+    GetFrameInfoValueProc *gfivProc;
+				/* Callback to allow for fine tuning of how
+				 * the method reports itself. */
+} ProcedureMethod;
+
+#define TCLOO_PROCEDURE_METHOD_VERSION 0
+
+/*
+ * Flags for use in a ProcedureMethod.
+ *
+ * When the USE_DECLARER_NS flag is set, the method will use the namespace of
+ * the object or class that declared it (or the clone of it, if it was from
+ * such that the implementation of the method came to the particular use)
+ * instead of the namespace of the object on which the method was invoked.
+ * This flag must be distinct from all others that are associated with
+ * methods.
+ */
+
+#define USE_DECLARER_NS		0x80
+
+/*
+ * Forwarded methods have the following extra information.
+ */
+
+typedef struct ForwardMethod {
+    Tcl_Obj *prefixObj;		/* The list of values to use to replace the
+				 * object and method name with. Will be a
+				 * non-empty list. */
+} ForwardMethod;
+
+/*
+ * Helper definitions that declare a "list" array. The two varieties are
+ * either optimized for simplicity (in the case that the whole array is
+ * typically assigned at once) or efficiency (in the case that the array is
+ * expected to be expanded over time). These lists are designed to be iterated
+ * over with the help of the FOREACH macro (see later in this file).
+ *
+ * The "num" field always counts the number of listType_t elements used in the
+ * "list" field. When a "size" field exists, it describes how many elements
+ * are present in the list; when absent, exactly "num" elements are present.
+ */
+
+#define LIST_STATIC(listType_t) \
+    struct { int num; listType_t *list; }
+#define LIST_DYNAMIC(listType_t) \
+    struct { int num, size; listType_t *list; }
+
+/*
+ * Now, the definition of what an object actually is.
+ */
+
+typedef struct Object {
+    struct Foundation *fPtr;	/* The basis for the object system. Putting
+				 * this here allows the avoidance of quite a
+				 * lot of hash lookups on the critical path
+				 * for object invocation and creation. */
+    Tcl_Namespace *namespacePtr;/* This object's namespace. */
+    Tcl_Command command;	/* Reference to this object's public
+				 * command. */
+    Tcl_Command myCommand;	/* Reference to this object's internal
+				 * command. */
+    struct Class *selfCls;	/* This object's class. */
+    Tcl_HashTable *methodsPtr;	/* Object-local Tcl_Obj (method name) to
+				 * Method* mapping. */
+    LIST_STATIC(struct Class *) mixins;
+				/* Classes mixed into this object. */
+    LIST_STATIC(Tcl_Obj *) filters;
+				/* List of filter names. */
+    struct Class *classPtr;	/* This is non-NULL for all classes, and NULL
+				 *  for everything else. It points to the class
+				 *  structure. */
+    int refCount;		/* Number of strong references to this object.
+				 * Note that there may be many more weak
+				 * references; this mechanism exists to
+				 * avoid Tcl_Preserve. */
+    int flags;
+    int creationEpoch;		/* Unique value to make comparisons of objects
+				 * easier. */
+    int epoch;			/* Per-object epoch, incremented when the way
+				 * an object should resolve call chains is
+				 * changed. */
+    Tcl_HashTable *metadataPtr;	/* Mapping from pointers to metadata type to
+				 * the ClientData values that are the values
+				 * of each piece of attached metadata. This
+				 * field starts out as NULL and is only
+				 * allocated if metadata is attached. */
+    Tcl_Obj *cachedNameObj;	/* Cache of the name of the object. */
+    Tcl_HashTable *chainCache;	/* Place to keep unused contexts. This table
+				 * is indexed by method name as Tcl_Obj. */
+    Tcl_ObjectMapMethodNameProc *mapMethodNameProc;
+				/* Function to allow remapping of method
+				 * names. For itcl-ng. */
+    LIST_STATIC(Tcl_Obj *) variables;
+} Object;
+
+#define OBJECT_DESTRUCTING	1	/* Indicates that an object is being or has
+								 *  been destroyed  */
+#define DESTRUCTOR_CALLED 2	/* Indicates that evaluation of destructor script for the
+							   object has began */
+#define OO_UNUSED_4	4	/* No longer used.  */
+#define ROOT_OBJECT 0x1000	/* Flag to say that this object is the root of
+				 * the class hierarchy and should be treated
+				 * specially during teardown. */
+#define FILTER_HANDLING 0x2000	/* Flag set when the object is processing a
+				 * filter; when set, filters are *not*
+				 * processed on the object, preventing nasty
+				 * recursive filtering problems. */
+#define USE_CLASS_CACHE 0x4000	/* Flag set to say that the object is a pure
+				 * instance of the class, and has had nothing
+				 * added that changes the dispatch chain (i.e.
+				 * no methods, mixins, or filters. */
+#define ROOT_CLASS 0x8000	/* Flag to say that this object is the root
+				 * class of classes, and should be treated
+				 * specially during teardown (and in a few
+				 * other spots). */
+#define FORCE_UNKNOWN 0x10000	/* States that we are *really* looking up the
+				 * unknown method handler at that point. */
+#define DONT_DELETE 0x20000	/* Inhibit deletion of this object. */
+
+/*
+ * And the definition of a class. Note that every class also has an associated
+ * object, through which it is manipulated.
+ */
+
+typedef struct Class {
+    Object *thisPtr;		/* Reference to the object associated with
+				 * this class. */
+    int flags;			/* Assorted flags. */
+    LIST_STATIC(struct Class *) superclasses;
+				/* List of superclasses, used for generation
+				 * of method call chains. */
+    LIST_DYNAMIC(struct Class *) subclasses;
+				/* List of subclasses, used to ensure deletion
+				 * of dependent entities happens properly when
+				 * the class itself is deleted. */
+    LIST_DYNAMIC(Object *) instances;
+				/* List of instances, used to ensure deletion
+				 * of dependent entities happens properly when
+				 * the class itself is deleted. */
+    LIST_STATIC(Tcl_Obj *) filters;
+				/* List of filter names, used for generation
+				 * of method call chains. */
+    LIST_STATIC(struct Class *) mixins;
+				/* List of mixin classes, used for generation
+				 * of method call chains. */
+    LIST_DYNAMIC(struct Class *) mixinSubs;
+				/* List of classes that this class is mixed
+				 * into, used to ensure deletion of dependent
+				 * entities happens properly when the class
+				 * itself is deleted. */
+    Tcl_HashTable classMethods;	/* Hash table of all methods. Hash maps from
+				 * the (Tcl_Obj*) method name to the (Method*)
+				 * method record. */
+    Method *constructorPtr;	/* Method record of the class constructor (if
+				 * any). */
+    Method *destructorPtr;	/* Method record of the class destructor (if
+				 * any). */
+    Tcl_HashTable *metadataPtr;	/* Mapping from pointers to metadata type to
+				 * the ClientData values that are the values
+				 * of each piece of attached metadata. This
+				 * field starts out as NULL and is only
+				 * allocated if metadata is attached. */
+    struct CallChain *constructorChainPtr;
+    struct CallChain *destructorChainPtr;
+    Tcl_HashTable *classChainCache;
+				/* Places where call chains are stored. For
+				 * constructors, the class chain is always
+				 * used. For destructors and ordinary methods,
+				 * the class chain is only used when the
+				 * object doesn't override with its own mixins
+				 * (and filters and method implementations for
+				 * when getting method chains). */
+    LIST_STATIC(Tcl_Obj *) variables;
+} Class;
+
+/*
+ * The foundation of the object system within an interpreter contains
+ * references to the key classes and namespaces, together with a few other
+ * useful bits and pieces. Probably ought to eventually go in the Interp
+ * structure itself.
+ */
+
+typedef struct ThreadLocalData {
+    int nsCount;		/* Epoch counter is used for keeping
+				 * the values used in Tcl_Obj internal
+				 * representations sane. Must be thread-local
+				 * because Tcl_Objs can cross interpreter
+				 * boundaries within a thread (objects don't
+				 * generally cross threads). */
+} ThreadLocalData;
+
+typedef struct Foundation {
+    Tcl_Interp *interp;
+    Class *objectCls;		/* The root of the object system. */
+    Class *classCls;		/* The class of all classes. */
+    Tcl_Namespace *ooNs;	/* ::oo namespace. */
+    Tcl_Namespace *defineNs;	/* Namespace containing special commands for
+				 * manipulating objects and classes. The
+				 * "oo::define" command acts as a special kind
+				 * of ensemble for this namespace. */
+    Tcl_Namespace *objdefNs;	/* Namespace containing special commands for
+				 * manipulating objects and classes. The
+				 * "oo::objdefine" command acts as a special
+				 * kind of ensemble for this namespace. */
+    Tcl_Namespace *helpersNs;	/* Namespace containing the commands that are
+				 * only valid when executing inside a
+				 * procedural method. */
+    int epoch;			/* Used to invalidate method chains when the
+				 * class structure changes. */
+    ThreadLocalData *tsdPtr;	/* Counter so we can allocate a unique
+				 * namespace to each object. */
+    Tcl_Obj *unknownMethodNameObj;
+				/* Shared object containing the name of the
+				 * unknown method handler method. */
+    Tcl_Obj *constructorName;	/* Shared object containing the "name" of a
+				 * constructor. */
+    Tcl_Obj *destructorName;	/* Shared object containing the "name" of a
+				 * destructor. */
+    Tcl_Obj *clonedName;	/* Shared object containing the name of a
+				 * "<cloned>" pseudo-constructor. */
+    Tcl_Obj *defineName;	/* Fully qualified name of oo::define. */
+} Foundation;
+
+/*
+ * A call context structure is built when a method is called. It contains the
+ * chain of method implementations that are to be invoked by a particular
+ * call, and the process of calling walks the chain, with the [next] command
+ * proceeding to the next entry in the chain.
+ */
+
+#define CALL_CHAIN_STATIC_SIZE 4
+
+struct MInvoke {
+    Method *mPtr;		/* Reference to the method implementation
+				 * record. */
+    int isFilter;		/* Whether this is a filter invocation. */
+    Class *filterDeclarer;	/* What class decided to add the filter; if
+				 * NULL, it was added by the object. */
+};
+
+typedef struct CallChain {
+    int objectCreationEpoch;	/* The object's creation epoch. Note that the
+				 * object reference is not stored in the call
+				 * chain; it is in the call context. */
+    int objectEpoch;		/* Local (object structure) epoch counter
+				 * snapshot. */
+    int epoch;			/* Global (class structure) epoch counter
+				 * snapshot. */
+    int flags;			/* Assorted flags, see below. */
+    int refCount;		/* Reference count. */
+    int numChain;		/* Size of the call chain. */
+    struct MInvoke *chain;	/* Array of call chain entries. May point to
+				 * staticChain if the number of entries is
+				 * small. */
+    struct MInvoke staticChain[CALL_CHAIN_STATIC_SIZE];
+} CallChain;
+
+typedef struct CallContext {
+    Object *oPtr;		/* The object associated with this call. */
+    int index;			/* Index into the call chain of the currently
+				 * executing method implementation. */
+    int skip;			/* Current number of arguments to skip; can
+				 * vary depending on whether it is a direct
+				 * method call or a continuation via the
+				 * [next] command. */
+    CallChain *callPtr;		/* The actual call chain. */
+} CallContext;
+
+/*
+ * Bits for the 'flags' field of the call chain.
+ */
+
+#define PUBLIC_METHOD     0x01	/* This is a public (exported) method. */
+#define PRIVATE_METHOD    0x02	/* This is a private (class's direct instances
+				 * only) method. Supports itcl. */
+#define OO_UNKNOWN_METHOD 0x04	/* This is an unknown method. */
+#define CONSTRUCTOR	  0x08	/* This is a constructor. */
+#define DESTRUCTOR	  0x10	/* This is a destructor. */
+
+/*
+ * Structure containing definition information about basic class methods.
+ */
+
+typedef struct {
+    const char *name;		/* Name of the method in question. */
+    int isPublic;		/* Whether the method is public by default. */
+    Tcl_MethodType definition;	/* How to call the method. */
+} DeclaredClassMethod;
+
+/*
+ *----------------------------------------------------------------
+ * Commands relating to OO support.
+ *----------------------------------------------------------------
+ */
+
+MODULE_SCOPE int	TclOOInit(Tcl_Interp *interp);
+MODULE_SCOPE int	TclOODefineObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOObjDefObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineConstructorObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineDeleteMethodObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineDestructorObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineExportObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineForwardObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineMethodObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineRenameMethodObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineUnexportObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineClassObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineSelfObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOUnknownDefinition(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOCopyObjectCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOONextObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOONextToObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOSelfObjCmd(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+
+/*
+ * Method implementations (in tclOOBasic.c).
+ */
+
+MODULE_SCOPE int	TclOO_Class_Constructor(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_Create(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_CreateNs(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_New(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Destroy(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Eval(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_LinkVar(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Unknown(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_VarName(void *clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+
+/*
+ * Private definitions, some of which perhaps ought to be exposed properly or
+ * maybe just put in the internal stubs table.
+ */
+
+MODULE_SCOPE void	TclOOAddToInstances(Object *oPtr, Class *clsPtr);
+MODULE_SCOPE void	TclOOAddToMixinSubs(Class *subPtr, Class *mixinPtr);
+MODULE_SCOPE void	TclOOAddToSubclasses(Class *subPtr, Class *superPtr);
+MODULE_SCOPE Class *	TclOOAllocClass(Tcl_Interp *interp,
+			    Object *useThisObj);
+MODULE_SCOPE int	TclNRNewObjectInstance(Tcl_Interp *interp,
+			    Tcl_Class cls, const char *nameStr,
+			    const char *nsNameStr, int objc,
+			    Tcl_Obj *const *objv, int skip,
+			    Tcl_Object *objectPtr);
+MODULE_SCOPE Object *	TclNewObjectInstanceCommon(Tcl_Interp *interp,
+			    Class *classPtr,
+			    const char *nameStr,
+			    const char *nsNameStr);
+MODULE_SCOPE int	TclOODecrRefCount(Object *oPtr);
+MODULE_SCOPE int	TclOOObjectDestroyed(Object *oPtr);
+MODULE_SCOPE int	TclOODefineSlots(Foundation *fPtr);
+MODULE_SCOPE void	TclOODeleteChain(CallChain *callPtr);
+MODULE_SCOPE void	TclOODeleteChainCache(Tcl_HashTable *tablePtr);
+MODULE_SCOPE void	TclOODeleteContext(CallContext *contextPtr);
+MODULE_SCOPE void	TclOODeleteDescendants(Tcl_Interp *interp,
+			    Object *oPtr);
+MODULE_SCOPE void	TclOODelMethodRef(Method *method);
+MODULE_SCOPE CallContext *TclOOGetCallContext(Object *oPtr,
+			    Tcl_Obj *methodNameObj, int flags,
+			    Tcl_Obj *cacheInThisObj);
+MODULE_SCOPE CallChain *TclOOGetStereotypeCallChain(Class *clsPtr,
+			    Tcl_Obj *methodNameObj, int flags);
+MODULE_SCOPE Foundation	*TclOOGetFoundation(Tcl_Interp *interp);
+MODULE_SCOPE Tcl_Obj *	TclOOGetFwdFromMethod(Method *mPtr);
+MODULE_SCOPE Proc *	TclOOGetProcFromMethod(Method *mPtr);
+MODULE_SCOPE Tcl_Obj *	TclOOGetMethodBody(Method *mPtr);
+MODULE_SCOPE int	TclOOGetSortedClassMethodList(Class *clsPtr,
+			    int flags, const char ***stringsPtr);
+MODULE_SCOPE int	TclOOGetSortedMethodList(Object *oPtr, int flags,
+			    const char ***stringsPtr);
+MODULE_SCOPE int	TclOOInit(Tcl_Interp *interp);
+MODULE_SCOPE void	TclOOInitInfo(Tcl_Interp *interp);
+MODULE_SCOPE int	TclOOInvokeContext(void *clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	TclNRObjectContextInvokeNext(Tcl_Interp *interp,
+			    Tcl_ObjectContext context, int objc,
+			    Tcl_Obj *const *objv, int skip);
+MODULE_SCOPE void	TclOONewBasicMethod(Tcl_Interp *interp, Class *clsPtr,
+			    const DeclaredClassMethod *dcm);
+MODULE_SCOPE Tcl_Obj *	TclOOObjectName(Tcl_Interp *interp, Object *oPtr);
+MODULE_SCOPE void	TclOOReleaseClassContents(Tcl_Interp *interp,
+			    Object *oPtr);
+MODULE_SCOPE int	TclOORemoveFromInstances(Object *oPtr, Class *clsPtr);
+MODULE_SCOPE int	TclOORemoveFromMixins(Class *mixinPtr, Object *oPtr);
+MODULE_SCOPE int	TclOORemoveFromMixinSubs(Class *subPtr,
+			    Class *mixinPtr);
+MODULE_SCOPE int	TclOORemoveFromSubclasses(Class *subPtr,
+			    Class *superPtr);
+MODULE_SCOPE Tcl_Obj *	TclOORenderCallChain(Tcl_Interp *interp,
+			    CallChain *callPtr);
+MODULE_SCOPE void	TclOOStashContext(Tcl_Obj *objPtr,
+			    CallContext *contextPtr);
+MODULE_SCOPE void	TclOOSetupVariableResolver(Tcl_Namespace *nsPtr);
+
+/*
+ * Include all the private API, generated from tclOO.decls.
+ */
+
+#include "tclOOIntDecls.h"
+
+/*
+ * Alternatives to Tcl_Preserve/Tcl_EventuallyFree/Tcl_Release.
+ */
+
+#define AddRef(ptr) ((ptr)->refCount++)
+
+/*
+ * A convenience macro for iterating through the lists used in the internal
+ * memory management of objects.
+ * REQUIRES DECLARATION: int i;
+ */
+
+#define FOREACH(var,ary) \
+    for(i=0 ; i<(ary).num; i++) if ((ary).list[i] == NULL) { \
+	continue; \
+    } else if ((var) = (ary).list[i], 1)
+
+/*
+ * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
+ * sets up the declarations needed for the main macro, FOREACH_HASH, which
+ * does the actual iteration. FOREACH_HASH_VALUE is a restricted version that
+ * only iterates over values.
+ */
+
+#define FOREACH_HASH_DECLS \
+    Tcl_HashEntry *hPtr;Tcl_HashSearch search
+#define FOREACH_HASH(key,val,tablePtr) \
+    for(hPtr=Tcl_FirstHashEntry((tablePtr),&search); hPtr!=NULL ? \
+	    ((key)=(void *)Tcl_GetHashKey((tablePtr),hPtr),\
+	    (val)=Tcl_GetHashValue(hPtr),1):0; hPtr=Tcl_NextHashEntry(&search))
+#define FOREACH_HASH_VALUE(val,tablePtr) \
+    for(hPtr=Tcl_FirstHashEntry((tablePtr),&search); hPtr!=NULL ? \
+	    ((val)=Tcl_GetHashValue(hPtr),1):0;hPtr=Tcl_NextHashEntry(&search))
+
+/*
+ * Convenience macro for duplicating a list. Needs no external declaration,
+ * but all arguments are used multiple times and so must have no side effects.
+ */
+
+#undef DUPLICATE /* prevent possible conflict with definition in WINAPI nb30.h */
+#define DUPLICATE(target,source,type) \
+    do { \
+	size_t len = sizeof(type) * ((target).num=(source).num);\
+	if (len != 0) { \
+	    memcpy(((target).list=(type*)ckalloc(len)), (source).list, len); \
+	} else { \
+	    (target).list = NULL; \
+	} \
+    } while(0)
+
+#endif /* TCL_OO_INTERNAL_H */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */

evalkit_cambrian/include/tclUnixPort.h

@@ -0,0 +1,732 @@
+/*
+ * tclUnixPort.h --
+ *
+ *	This header file handles porting issues that occur because of
+ *	differences between systems. It reads in UNIX-related header files and
+ *	sets up UNIX-related macros for Tcl's UNIX core. It should be the only
+ *	file that contains #ifdefs to handle different flavors of UNIX. This
+ *	file sets up the union of all UNIX-related things needed by any of the
+ *	Tcl core files. This file depends on configuration #defines such as
+ *	NO_DIRENT_H that are set up by the "configure" script.
+ *
+ *	Much of the material in this file was originally contributed by Karl
+ *	Lehenbauer, Mark Diekhans and Peter da Silva.
+ *
+ * Copyright (c) 1991-1994 The Regents of the University of California.
+ * Copyright (c) 1994-1997 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef _TCLUNIXPORT
+#define _TCLUNIXPORT
+
+/*
+ *---------------------------------------------------------------------------
+ * The following sets of #includes and #ifdefs are required to get Tcl to
+ * compile under the various flavors of unix.
+ *---------------------------------------------------------------------------
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#ifdef HAVE_NET_ERRNO_H
+#   include <net/errno.h>
+#endif
+#include <pwd.h>
+#include <signal.h>
+#ifdef HAVE_SYS_PARAM_H
+#   include <sys/param.h>
+#endif
+#include <sys/types.h>
+#ifdef USE_DIRENT2_H
+#   include "../compat/dirent2.h"
+#else
+#ifdef NO_DIRENT_H
+#   include "../compat/dirent.h"
+#else
+#   include <dirent.h>
+#endif
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Parameterize for 64-bit filesystem support.
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef HAVE_STRUCT_DIRENT64
+typedef struct dirent64		Tcl_DirEntry;
+#   define TclOSreaddir		readdir64
+#else
+typedef struct dirent		Tcl_DirEntry;
+#   define TclOSreaddir		readdir
+#endif
+#ifdef HAVE_DIR64
+typedef DIR64			TclDIR;
+#   define TclOSopendir		opendir64
+#   define TclOSrewinddir	rewinddir64
+#   define TclOSclosedir	closedir64
+#else
+typedef DIR			TclDIR;
+#   define TclOSopendir		opendir
+#   define TclOSrewinddir	rewinddir
+#   define TclOSclosedir	closedir
+#endif
+
+#ifdef HAVE_TYPE_OFF64_T
+typedef off64_t		Tcl_SeekOffset;
+#   define TclOSseek		lseek64
+#   define TclOSopen		open64
+#else
+typedef off_t		Tcl_SeekOffset;
+#   define TclOSseek		lseek
+#   define TclOSopen		open
+#endif
+
+#ifdef __CYGWIN__
+#ifdef __cplusplus
+extern "C" {
+#endif
+    /* Make some symbols available without including <windows.h> */
+#   define DWORD unsigned int
+#   define CP_UTF8 65001
+#   define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 0x00000004
+#   define HANDLE void *
+#   define HINSTANCE void *
+#   define SOCKET unsigned int
+#   define WSAEWOULDBLOCK 10035
+    typedef unsigned short WCHAR;
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wignored-attributes"
+#endif
+    __declspec(dllimport) extern __stdcall int GetModuleHandleExW(unsigned int, const void *, void *);
+    __declspec(dllimport) extern __stdcall int GetModuleFileNameW(void *, const void *, int);
+    __declspec(dllimport) extern __stdcall int WideCharToMultiByte(int, int, const void *, int,
+	    char *, int, const char *, void *);
+    __declspec(dllimport) extern __stdcall int MultiByteToWideChar(int, int, const char *, int,
+	    WCHAR *, int);
+    __declspec(dllimport) extern __stdcall void OutputDebugStringW(const WCHAR *);
+    __declspec(dllimport) extern __stdcall int IsDebuggerPresent(void);
+    __declspec(dllimport) extern __stdcall int GetLastError(void);
+    __declspec(dllimport) extern __stdcall int GetFileAttributesW(const WCHAR *);
+    __declspec(dllimport) extern __stdcall int SetFileAttributesW(const WCHAR *, int);
+    __declspec(dllimport) extern int cygwin_conv_path(int, const void *, void *, int);
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#   define timezone _timezone
+    extern int TclOSstat(const char *name, void *statBuf);
+    extern int TclOSlstat(const char *name, void *statBuf);
+#ifdef __cplusplus
+}
+#endif
+#elif defined(HAVE_STRUCT_STAT64) && !defined(__APPLE__)
+#   define TclOSstat(name, buf) stat64(name, (struct stat64 *)buf)
+#   define TclOSlstat(name,buf) lstat64(name, (struct stat64 *)buf)
+#else
+#   define TclOSstat(name, buf) stat(name, (struct stat *)buf)
+#   define TclOSlstat(name, buf) lstat(name, (struct stat *)buf)
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Miscellaneous includes that might be missing.
+ *---------------------------------------------------------------------------
+ */
+
+#include <sys/file.h>
+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#endif
+#include <sys/stat.h>
+#ifdef TIME_WITH_SYS_TIME
+#   include <sys/time.h>
+#   include <time.h>
+#else
+#ifdef HAVE_SYS_TIME_H
+#   include <sys/time.h>
+#else
+#   include <time.h>
+#endif
+#endif
+#ifndef NO_SYS_WAIT_H
+#   include <sys/wait.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+#   include <inttypes.h>
+#endif
+#include <limits.h>
+#ifdef HAVE_STDINT_H
+#   include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#   include <unistd.h>
+#else
+#   include "../compat/unistd.h"
+#endif
+
+extern int TclUnixSetBlockingMode(int fd, int mode);
+
+#include <utime.h>
+
+/*
+ *---------------------------------------------------------------------------
+ * Socket support stuff: This likely needs more work to parameterize for each
+ * system.
+ *---------------------------------------------------------------------------
+ */
+
+#include <sys/socket.h>		/* struct sockaddr, SOCK_STREAM, ... */
+#ifndef NO_UNAME
+#   include <sys/utsname.h>	/* uname system call. */
+#endif
+#include <netinet/in.h>		/* struct in_addr, struct sockaddr_in */
+#include <arpa/inet.h>		/* inet_ntoa() */
+#include <netdb.h>		/* getaddrinfo() */
+#ifdef NEED_FAKE_RFC2553
+# include "../compat/fake-rfc2553.h"
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Some platforms (e.g. SunOS) don't define FLT_MAX and FLT_MIN, so we look
+ * for an alternative definition. If no other alternative is available we use
+ * a reasonable guess.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef NO_FLOAT_H
+#   include <float.h>
+#else
+#ifndef NO_VALUES_H
+#   include <values.h>
+#endif
+#endif
+
+#ifndef FLT_MAX
+#   ifdef MAXFLOAT
+#	define FLT_MAX	MAXFLOAT
+#   else
+#	define FLT_MAX	3.402823466E+38F
+#   endif
+#endif
+#ifndef FLT_MIN
+#   ifdef MINFLOAT
+#	define FLT_MIN	MINFLOAT
+#   else
+#	define FLT_MIN	1.175494351E-38F
+#   endif
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * NeXT doesn't define O_NONBLOCK, so #define it here if necessary.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef O_NONBLOCK
+#   define O_NONBLOCK 0x80
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * The type of the status returned by wait varies from UNIX system to UNIX
+ * system. The macro below defines it:
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef _AIX
+#   define WAIT_STATUS_TYPE	pid_t
+#else
+#ifndef NO_UNION_WAIT
+#   define WAIT_STATUS_TYPE	union wait
+#else
+#   define WAIT_STATUS_TYPE	int
+#endif
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Supply definitions for macros to query wait status, if not already defined
+ * in header files above.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef WIFEXITED
+#   define WIFEXITED(stat)	(((*((int *) &(stat))) & 0xFF) == 0)
+#endif
+
+#ifndef WEXITSTATUS
+#   define WEXITSTATUS(stat)	(((*((int *) &(stat))) >> 8) & 0xFF)
+#endif
+
+#ifndef WIFSIGNALED
+#   define WIFSIGNALED(stat) \
+	(((*((int *) &(stat)))) && ((*((int *) &(stat))) \
+		== ((*((int *) &(stat))) & 0x00FF)))
+#endif
+
+#ifndef WTERMSIG
+#   define WTERMSIG(stat)	((*((int *) &(stat))) & 0x7F)
+#endif
+
+#ifndef WIFSTOPPED
+#   define WIFSTOPPED(stat)	(((*((int *) &(stat))) & 0xFF) == 0177)
+#endif
+
+#ifndef WSTOPSIG
+#   define WSTOPSIG(stat)	(((*((int *) &(stat))) >> 8) & 0xFF)
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Define constants for waitpid() system call if they aren't defined by a
+ * system header file.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef WNOHANG
+#   define WNOHANG 1
+#endif
+#ifndef WUNTRACED
+#   define WUNTRACED 2
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Supply macros for seek offsets, if they're not already provided by an
+ * include file.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef SEEK_SET
+#   define SEEK_SET 0
+#endif
+#ifndef SEEK_CUR
+#   define SEEK_CUR 1
+#endif
+#ifndef SEEK_END
+#   define SEEK_END 2
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * The stuff below is needed by the "time" command. If this system has no
+ * gettimeofday call, then must use times() instead.
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef NO_GETTOD
+#   include <sys/times.h>
+#else
+#   ifdef HAVE_BSDGETTIMEOFDAY
+#	define gettimeofday BSDgettimeofday
+#   endif
+#endif
+
+#ifdef GETTOD_NOT_DECLARED
+extern int	gettimeofday(struct timeval *tp,
+			    struct timezone *tzp);
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Define access mode constants if they aren't already defined.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef F_OK
+#   define F_OK		00
+#endif
+#ifndef X_OK
+#   define X_OK		01
+#endif
+#ifndef W_OK
+#   define W_OK		02
+#endif
+#ifndef R_OK
+#   define R_OK		04
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Define FD_CLOEEXEC (the close-on-exec flag bit) if it isn't already
+ * defined.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef FD_CLOEXEC
+#   define FD_CLOEXEC	1
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * On systems without symbolic links (i.e. S_IFLNK isn't defined) define
+ * "lstat" to use "stat" instead.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef S_IFLNK
+#   undef TclOSlstat
+#   define lstat	stat
+#   define lstat64	stat64
+#   define TclOSlstat	TclOSstat
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Define macros to query file type bits, if they're not already defined.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef S_ISREG
+#   ifdef S_IFREG
+#	define S_ISREG(m)	(((m) & S_IFMT) == S_IFREG)
+#   else
+#	define S_ISREG(m)	0
+#   endif
+#endif /* !S_ISREG */
+#ifndef S_ISDIR
+#   ifdef S_IFDIR
+#	define S_ISDIR(m)	(((m) & S_IFMT) == S_IFDIR)
+#   else
+#	define S_ISDIR(m)	0
+#   endif
+#endif /* !S_ISDIR */
+#ifndef S_ISCHR
+#   ifdef S_IFCHR
+#	define S_ISCHR(m)	(((m) & S_IFMT) == S_IFCHR)
+#   else
+#	define S_ISCHR(m)	0
+#   endif
+#endif /* !S_ISCHR */
+
+#ifndef S_ISBLK
+#   ifdef S_IFBLK
+#	define S_ISBLK(m)	(((m) & S_IFMT) == S_IFBLK)
+#   else
+#	define S_ISBLK(m)	0
+#   endif
+#endif /* !S_ISBLK */
+
+#ifndef S_ISFIFO
+#   ifdef S_IFIFO
+#	define S_ISFIFO(m)	(((m) & S_IFMT) == S_IFIFO)
+#   else
+#	define S_ISFIFO(m)	0
+#   endif
+#endif /* !S_ISFIFO */
+
+#ifndef S_ISLNK
+#   ifdef S_IFLNK
+#	define S_ISLNK(m)	(((m) & S_IFMT) == S_IFLNK)
+#   else
+#	define S_ISLNK(m)	0
+#   endif
+#endif /* !S_ISLNK */
+
+#ifndef S_ISSOCK
+#   ifdef S_IFSOCK
+#	define S_ISSOCK(m)	(((m) & S_IFMT) == S_IFSOCK)
+#   else
+#	define S_ISSOCK(m)	0
+#   endif
+#endif /* !S_ISSOCK */
+
+/*
+ *---------------------------------------------------------------------------
+ * Make sure that MAXPATHLEN and MAXNAMLEN are defined.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef MAXPATHLEN
+#   ifdef PATH_MAX
+#	define MAXPATHLEN	PATH_MAX
+#   else
+#	define MAXPATHLEN	2048
+#   endif
+#endif
+
+#ifndef MAXNAMLEN
+#   ifdef NAME_MAX
+#	define MAXNAMLEN	NAME_MAX
+#   else
+#	define MAXNAMLEN	255
+#   endif
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * The following macro defines the type of the mask arguments to select:
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef NO_FD_SET
+#   define SELECT_MASK	fd_set
+#else /* NO_FD_SET */
+#   ifndef _AIX
+	typedef long	fd_mask;
+#   endif /* !AIX */
+#   if defined(_IBMR2)
+#	define SELECT_MASK	void
+#   else /* !defined(_IBMR2) */
+#	define SELECT_MASK	int
+#   endif /* defined(_IBMR2) */
+#endif /* !NO_FD_SET */
+
+/*
+ *---------------------------------------------------------------------------
+ * Define "NBBY" (number of bits per byte) if it's not already defined.
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef NBBY
+#   define NBBY		8
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * The following macro defines the number of fd_masks in an fd_set:
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef FD_SETSIZE
+#   ifdef OPEN_MAX
+#	define FD_SETSIZE	OPEN_MAX
+#   else
+#	define FD_SETSIZE	256
+#   endif
+#endif /* FD_SETSIZE */
+
+#ifndef howmany
+#   define howmany(x, y)	(((x)+((y)-1))/(y))
+#endif /* !defined(howmany) */
+
+#ifndef NFDBITS
+#   define NFDBITS	NBBY*sizeof(fd_mask)
+#endif /* NFDBITS */
+
+#define MASK_SIZE	howmany(FD_SETSIZE, NFDBITS)
+
+/*
+ *---------------------------------------------------------------------------
+ * Not all systems declare the errno variable in errno.h, so this file does it
+ * explicitly. The list of system error messages also isn't generally declared
+ * in a header file anywhere.
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef NO_ERRNO
+extern int errno;
+#endif /* NO_ERRNO */
+
+/*
+ *---------------------------------------------------------------------------
+ * Not all systems declare all the errors that Tcl uses! Provide some
+ * work-arounds...
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef EOVERFLOW
+#   ifdef EFBIG
+#	define EOVERFLOW	EFBIG
+#   else /* !EFBIG */
+#	define EOVERFLOW	EINVAL
+#   endif /* EFBIG */
+#endif /* EOVERFLOW */
+
+/*
+ *---------------------------------------------------------------------------
+ * Variables provided by the C library:
+ *---------------------------------------------------------------------------
+ */
+
+#if defined(__APPLE__) && defined(__DYNAMIC__)
+#   include <crt_externs.h>
+#   define environ	(*_NSGetEnviron())
+#   define USE_PUTENV	1
+#else
+#   if defined(_sgi) || defined(__sgi)
+#	define environ	_environ
+#   endif
+extern char **		environ;
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Darwin specifc configure overrides.
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef __APPLE__
+
+/*
+ *---------------------------------------------------------------------------
+ * Support for fat compiles: configure runs only once for multiple architectures
+ *---------------------------------------------------------------------------
+ */
+
+#   if defined(__LP64__) && defined (NO_COREFOUNDATION_64)
+#	undef HAVE_COREFOUNDATION
+#   endif /* __LP64__ && NO_COREFOUNDATION_64 */
+#   include <sys/cdefs.h>
+#   ifdef __DARWIN_UNIX03
+#	if __DARWIN_UNIX03
+#	    undef HAVE_PUTENV_THAT_COPIES
+#	else
+#	    define HAVE_PUTENV_THAT_COPIES	1
+#	endif
+#   endif /* __DARWIN_UNIX03 */
+
+/*
+ *---------------------------------------------------------------------------
+ * Include AvailabilityMacros.h here (when available) to ensure any symbolic
+ * MAC_OS_X_VERSION_* constants passed on the command line are translated.
+ *---------------------------------------------------------------------------
+ */
+
+#   ifdef HAVE_AVAILABILITYMACROS_H
+#	include <AvailabilityMacros.h>
+#   endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Support for weak import.
+ *---------------------------------------------------------------------------
+ */
+
+#   ifdef HAVE_WEAK_IMPORT
+#	if !defined(HAVE_AVAILABILITYMACROS_H) || !defined(MAC_OS_X_VERSION_MIN_REQUIRED)
+#	    undef HAVE_WEAK_IMPORT
+#	else
+#	    ifndef WEAK_IMPORT_ATTRIBUTE
+#		define WEAK_IMPORT_ATTRIBUTE	__attribute__((weak_import))
+#	    endif
+#	endif
+#   endif /* HAVE_WEAK_IMPORT */
+
+/*
+ *---------------------------------------------------------------------------
+ * Support for MAC_OS_X_VERSION_MAX_ALLOWED define from AvailabilityMacros.h:
+ * only use API available in the indicated OS version or earlier.
+ *---------------------------------------------------------------------------
+ */
+
+#   ifdef MAC_OS_X_VERSION_MAX_ALLOWED
+#	if MAC_OS_X_VERSION_MAX_ALLOWED < 1050 && defined(__LP64__)
+#	    undef HAVE_COREFOUNDATION
+#	endif
+#	if MAC_OS_X_VERSION_MAX_ALLOWED < 1040
+#	    undef HAVE_OSSPINLOCKLOCK
+#	    undef HAVE_PTHREAD_ATFORK
+#	    undef HAVE_COPYFILE
+#	endif
+#	if MAC_OS_X_VERSION_MAX_ALLOWED < 1030
+#	    ifdef TCL_THREADS
+		/* prior to 10.3, realpath is not threadsafe, c.f. bug 711232 */
+#		define NO_REALPATH 1
+#	    endif
+#	    undef HAVE_LANGINFO
+#	endif
+#   endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
+#   if defined(HAVE_COREFOUNDATION) && defined(__LP64__) && \
+	    defined(HAVE_WEAK_IMPORT) && MAC_OS_X_VERSION_MIN_REQUIRED < 1050
+#	warning "Weak import of 64-bit CoreFoundation is not supported, will not run on Mac OS X < 10.5."
+#   endif
+    /*
+     * For now, test exec-17.1 fails (I/O setup after closing stdout) with
+     * posix_spawnp(), but the classic implementation (based on fork()+execvp())
+     * works well under macOS.
+     */
+#   undef HAVE_POSIX_SPAWNP
+#   undef HAVE_VFORK
+#endif /* __APPLE__ */
+
+/*
+ *---------------------------------------------------------------------------
+ * The following macros and declarations represent the interface between
+ * generic and unix-specific parts of Tcl. Some of the macros may override
+ * functions declared in tclInt.h.
+ *---------------------------------------------------------------------------
+ */
+
+/*
+ * The default platform eol translation on Unix is TCL_TRANSLATE_LF.
+ */
+
+#ifdef DJGPP
+#define	TCL_PLATFORM_TRANSLATION	TCL_TRANSLATE_CRLF
+typedef int socklen_t;
+#else
+#define	TCL_PLATFORM_TRANSLATION	TCL_TRANSLATE_LF
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * The following macros have trivial definitions, allowing generic code to
+ * address platform-specific issues.
+ *---------------------------------------------------------------------------
+ */
+
+#define TclpReleaseFile(file)	/* Nothing. */
+
+/*
+ *---------------------------------------------------------------------------
+ * The following defines wrap the system memory allocation routines.
+ *---------------------------------------------------------------------------
+ */
+
+#define TclpSysAlloc(size, isBin)	malloc((size_t)(size))
+#define TclpSysFree(ptr)		free((char *)(ptr))
+#define TclpSysRealloc(ptr, size)	realloc((char *)(ptr), (size_t)(size))
+
+/*
+ *---------------------------------------------------------------------------
+ * The following macros and declaration wrap the C runtime library functions.
+ *---------------------------------------------------------------------------
+ */
+
+#define TclpExit	exit
+
+#ifdef TCL_THREADS
+#   include <pthread.h>
+#endif /* TCL_THREADS */
+
+/* FIXME - Hyper-enormous platform assumption! */
+#ifndef AF_INET6
+#   define AF_INET6	10
+#endif
+
+/*
+ *---------------------------------------------------------------------------
+ * Set of MT-safe implementations of some known-to-be-MT-unsafe library calls.
+ * Instead of returning pointers to the static storage, those return pointers
+ * to the TSD data.
+ *---------------------------------------------------------------------------
+ */
+
+#include <pwd.h>
+#include <grp.h>
+
+extern struct passwd *	TclpGetPwNam(const char *name);
+extern struct group *	TclpGetGrNam(const char *name);
+extern struct passwd *	TclpGetPwUid(uid_t uid);
+extern struct group *	TclpGetGrGid(gid_t gid);
+extern struct hostent *	TclpGetHostByName(const char *name);
+extern struct hostent *	TclpGetHostByAddr(const char *addr,
+				    int length, int type);
+extern void *TclpMakeTcpClientChannelMode(
+				    void *tcpSocket, int mode);
+
+#endif /* _TCLUNIXPORT */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */

evalkit_cambrian/include/tkBusy.h

@@ -0,0 +1,41 @@
+/*
+ * tkBusy.h --
+ *
+ *	This file defines the type of the structure describing a busy window.
+ *
+ * Copyright 1993-1998 Lucent Technologies, Inc.
+ *
+ *	The "busy" command was created by George Howlett. Adapted for
+ *	integration into Tk by Jos Decoster and Donal K. Fellows.
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+typedef struct Busy {
+    Display *display;		/* Display of busy window */
+    Tcl_Interp *interp;		/* Interpreter where "busy" command was
+				 * created. It's used to key the searches in
+				 * the window hierarchy. See the "windows"
+				 * command. */
+    Tk_Window tkBusy;		/* Busy window: Transparent window used to
+				 * block delivery of events to windows
+				 * underneath it. */
+    Tk_Window tkParent;		/* Parent window of the busy window. It may be
+				 * the reference window (if the reference is a
+				 * toplevel) or a mutual ancestor of the
+				 * reference window */
+    Tk_Window tkRef;		/* Reference window of the busy window. It is
+				 * used to manage the size and position of the
+				 * busy window. */
+    int x, y;			/* Position of the reference window */
+    int width, height;		/* Size of the reference window. Retained to
+				 * know if the reference window has been
+				 * reconfigured to a new size. */
+    int menuBar;		/* Menu bar flag. */
+    Tk_Cursor cursor;		/* Cursor for the busy window. */
+    Tcl_HashEntry *hashPtr;	/* Used the delete the busy window entry out
+				 * of the global hash table. */
+    Tcl_HashTable *tablePtr;
+    Tk_OptionTable optionTable;
+} Busy;

evalkit_cambrian/include/tkMacOSX.h

@@ -0,0 +1,34 @@
+/*
+ * tkMacOSX.h --
+ *
+ *	Declarations of Macintosh specific exported variables and procedures.
+ *
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Copyright 2001-2009, Apple Inc.
+ * Copyright (c) 2005-2009 Daniel A. Steffen <das@users.sourceforge.net>
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef _TKMAC
+#define _TKMAC
+
+#ifndef _TK
+#include "tk.h"
+#endif
+
+/*
+ * Structures and function types for handling Netscape-type in process
+ * embedding where Tk does not control the top-level
+ */
+
+typedef int (Tk_MacOSXEmbedRegisterWinProc) (long winID, Tk_Window window);
+typedef void* (Tk_MacOSXEmbedGetGrafPortProc) (Tk_Window window);
+typedef int (Tk_MacOSXEmbedMakeContainerExistProc) (Tk_Window window);
+typedef void (Tk_MacOSXEmbedGetClipProc) (Tk_Window window, void *rgn);
+typedef void (Tk_MacOSXEmbedGetOffsetInParentProc) (Tk_Window window, void *ulCorner);
+
+#include "tkPlatDecls.h"
+
+#endif /* _TKMAC */

evalkit_cambrian/include/tkUnixPort.h

@@ -0,0 +1,197 @@
+/*
+ * tkUnixPort.h --
+ *
+ *	This file is included by all of the Tk C files.  It contains
+ *	information that may be configuration-dependent, such as
+ *	#includes for system include files and a few other things.
+ *
+ * Copyright (c) 1991-1993 The Regents of the University of California.
+ * Copyright (c) 1994-1996 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef _UNIXPORT
+#define _UNIXPORT
+
+#define __UNIX__ 1
+
+#include <stdio.h>
+#include <pwd.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <math.h>
+#include <string.h>
+#include <limits.h>
+#ifdef NO_STDLIB_H
+#   include "../compat/stdlib.h"
+#else
+#   include <stdlib.h>
+#endif
+#include <sys/types.h>
+#include <sys/file.h>
+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#endif
+#include <sys/stat.h>
+#ifndef _TCL
+#   include <tcl.h>
+#endif
+#ifdef TIME_WITH_SYS_TIME
+#   include <sys/time.h>
+#   include <time.h>
+#else
+#   ifdef HAVE_SYS_TIME_H
+#	include <sys/time.h>
+#   else
+#	include <time.h>
+#   endif
+#endif
+#ifdef HAVE_INTTYPES_H
+#    include <inttypes.h>
+#endif
+#ifndef NO_UNISTD_H
+#   include <unistd.h>
+#else
+#   include "../compat/unistd.h"
+#endif
+#if defined(__GNUC__) && !defined(__cplusplus)
+#   pragma GCC diagnostic ignored "-Wc++-compat"
+#endif
+#include <X11/Xlib.h>
+#include <X11/cursorfont.h>
+#include <X11/keysym.h>
+#include <X11/Xatom.h>
+#include <X11/Xproto.h>
+#include <X11/Xresource.h>
+#include <X11/Xutil.h>
+
+/*
+ * The following macro defines the type of the mask arguments to
+ * select:
+ */
+
+#ifndef NO_FD_SET
+#   define SELECT_MASK fd_set
+#else
+#   ifndef _AIX
+	typedef long fd_mask;
+#   endif
+#   if defined(_IBMR2)
+#	define SELECT_MASK void
+#   else
+#	define SELECT_MASK int
+#   endif
+#endif
+
+/*
+ * The following macro defines the number of fd_masks in an fd_set:
+ */
+
+#ifndef FD_SETSIZE
+#   ifdef OPEN_MAX
+#	define FD_SETSIZE OPEN_MAX
+#   else
+#	define FD_SETSIZE 256
+#   endif
+#endif
+#if !defined(howmany)
+#   define howmany(x, y) (((x)+((y)-1))/(y))
+#endif
+#ifndef NFDBITS
+#   define NFDBITS NBBY*sizeof(fd_mask)
+#endif
+#define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
+
+/*
+ * Define "NBBY" (number of bits per byte) if it's not already defined.
+ */
+
+#ifndef NBBY
+#   define NBBY 8
+#endif
+
+#ifdef __CYGWIN__
+#   include "tkIntXlibDecls.h"
+#   define UINT unsigned int
+#   define HWND void *
+#   define HDC void *
+#   define HINSTANCE void *
+#   define COLORREF void *
+#   define HMENU void *
+#   define TkWinDCState void
+#   define HPALETTE void *
+#   define WNDPROC void *
+#   define WPARAM void *
+#   define LPARAM void *
+#   define LRESULT void *
+
+#else /* !__CYGWIN__ */
+    /*
+     * The TkPutImage macro strips off the color table information, which isn't
+     * needed for X.
+     */
+
+#   define TkPutImage(colors, ncolors, display, pixels, gc, image, srcx, srcy, destx, desty, width, height) \
+		XPutImage(display, pixels, gc, image, srcx, srcy, destx, \
+		desty, width, height);
+
+#endif /* !__CYGWIN__ */
+
+/*
+ * Supply macros for seek offsets, if they're not already provided by
+ * an include file.
+ */
+
+#ifndef SEEK_SET
+#   define SEEK_SET 0
+#endif
+
+#ifndef SEEK_CUR
+#   define SEEK_CUR 1
+#endif
+
+#ifndef SEEK_END
+#   define SEEK_END 2
+#endif
+
+/*
+ * Declarations for various library procedures that may not be declared
+ * in any other header file.
+ */
+
+
+/*
+ * These functions do nothing under Unix, so we just eliminate calls to them.
+ */
+
+#define TkpButtonSetDefaults() {}
+#define TkpDestroyButton(butPtr) {}
+#define TkSelUpdateClipboard(a,b) {}
+#ifndef __CYGWIN__
+#define TkSetPixmapColormap(p,c) {}
+#endif
+
+/*
+ * These calls implement native bitmaps which are not supported under
+ * UNIX.  The macros eliminate the calls.
+ */
+
+#define TkpDefineNativeBitmaps()
+#define TkpCreateNativeBitmap(display, source) None
+#define TkpGetNativeAppBitmap(display, name, w, h) None
+
+/*
+ * This macro stores a representation of the window handle in a string.
+ * This should perhaps use the real size of an XID.
+ */
+
+#ifndef __CYGWIN__
+#define TkpPrintWindowId(buf,w) \
+	snprintf((buf), TCL_INTEGER_SPACE, "0x%08lx", (unsigned long) (w))
+#endif
+
+#endif /* _UNIXPORT */

evalkit_cambrian/lib/python3.10/site-packages/scipy/sparse/csgraph/_flow.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70c4ace45253414e81052736c442dc374b1a77957faa64b63e137e212614d75f
+size 354320

evalkit_tf449/lib/python3.10/site-packages/antlr4/CommonTokenStream.py

@@ -0,0 +1,87 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+#
+# This class extends {@link BufferedTokenStream} with functionality to filter
+# token streams to tokens on a particular channel (tokens where
+# {@link Token#getChannel} returns a particular value).
+#
+# <p>
+# This token stream provides access to all tokens by index or when calling
+# methods like {@link #getText}. The channel filtering is only used for code
+# accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
+# {@link #LB}.</p>
+#
+# <p>
+# By default, tokens are placed on the default channel
+# ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
+# {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+# call {@link Lexer#setChannel}.
+# </p>
+#
+# <p>
+# Note: lexer rules which use the {@code ->skip} lexer command or call
+# {@link Lexer#skip} do not produce tokens at all, so input text matched by
+# such a rule will not be available as part of the token stream, regardless of
+# channel.</p>
+#/
+
+from antlr4.BufferedTokenStream import BufferedTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Token import Token
+
+
+class CommonTokenStream(BufferedTokenStream):
+    __slots__ = 'channel'
+
+    def __init__(self, lexer:Lexer, channel:int=Token.DEFAULT_CHANNEL):
+        super().__init__(lexer)
+        self.channel = channel
+
+    def adjustSeekIndex(self, i:int):
+        return self.nextTokenOnChannel(i, self.channel)
+
+    def LB(self, k:int):
+        if k==0 or (self.index-k)<0:
+            return None
+        i = self.index
+        n = 1
+        # find k good tokens looking backwards
+        while n <= k:
+            # skip off-channel tokens
+            i = self.previousTokenOnChannel(i - 1, self.channel)
+            n += 1
+        if i < 0:
+            return None
+        return self.tokens[i]
+
+    def LT(self, k:int):
+        self.lazyInit()
+        if k == 0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index
+        n = 1 # we know tokens[pos] is a good one
+        # find k good tokens
+        while n < k:
+            # skip off-channel tokens, but make sure to not look past EOF
+            if self.sync(i + 1):
+                i = self.nextTokenOnChannel(i + 1, self.channel)
+            n += 1
+        return self.tokens[i]
+
+    # Count EOF just once.#/
+    def getNumberOfOnChannelTokens(self):
+        n = 0
+        self.fill()
+        for i in range(0, len(self.tokens)):
+            t = self.tokens[i]
+            if t.channel==self.channel:
+                n += 1
+            if t.type==Token.EOF:
+                break
+        return n

evalkit_tf449/lib/python3.10/site-packages/antlr4/InputStream.py

@@ -0,0 +1,87 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+#
+#  Vacuum all input from a string and then treat it like a buffer.
+#
+from antlr4.Token import Token
+
+
+class InputStream (object):
+    __slots__ = ('name', 'strdata', '_index', 'data', '_size')
+
+    def __init__(self, data: str):
+        self.name = "<empty>"
+        self.strdata = data
+        self._loadString()
+
+    def _loadString(self):
+        self._index = 0
+        self.data = [ord(c) for c in self.strdata]
+        self._size = len(self.data)
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def size(self):
+        return self._size
+
+    # Reset the stream so that it's in the same state it was
+    #  when the object was created *except* the data array is not
+    #  touched.
+    #
+    def reset(self):
+        self._index = 0
+
+    def consume(self):
+        if self._index >= self._size:
+            assert self.LA(1) == Token.EOF
+            raise Exception("cannot consume EOF")
+        self._index += 1
+
+    def LA(self, offset: int):
+        if offset==0:
+            return 0 # undefined
+        if offset<0:
+            offset += 1 # e.g., translate LA(-1) to use offset=0
+        pos = self._index + offset - 1
+        if pos < 0 or pos >= self._size: # invalid
+            return Token.EOF
+        return self.data[pos]
+
+    def LT(self, offset: int):
+        return self.LA(offset)
+
+    # mark/release do nothing; we have entire buffer
+    def mark(self):
+        return -1
+
+    def release(self, marker: int):
+        pass
+
+    # consume() ahead until p==_index; can't just set p=_index as we must
+    # update line and column. If we seek backwards, just set p
+    #
+    def seek(self, _index: int):
+        if _index<=self._index:
+            self._index = _index # just jump; don't update stream state (line, ...)
+            return
+        # seek forward
+        self._index = min(_index, self._size)
+
+    def getText(self, start :int, stop: int):
+        if stop >= self._size:
+            stop = self._size-1
+        if start >= self._size:
+            return ""
+        else:
+            return self.strdata[start:stop+1]
+
+    def __str__(self):
+        return self.strdata

evalkit_tf449/lib/python3.10/site-packages/antlr4/IntervalSet.py

@@ -0,0 +1,180 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+from io import StringIO
+from antlr4.Token import Token
+
+# need forward declarations
+IntervalSet = None
+
+class IntervalSet(object):
+    __slots__ = ('intervals', 'readonly')
+
+    def __init__(self):
+        self.intervals = None
+        self.readonly = False
+
+    def __iter__(self):
+        if self.intervals is not None:
+            for i in self.intervals:
+                for c in i:
+                    yield c
+
+    def __getitem__(self, item):
+        i = 0
+        for k in self:
+            if i==item:
+                return k
+            else:
+                i += 1
+        return Token.INVALID_TYPE
+
+    def addOne(self, v:int):
+        self.addRange(range(v, v+1))
+
+    def addRange(self, v:range):
+        if self.intervals is None:
+            self.intervals = list()
+            self.intervals.append(v)
+        else:
+            # find insert pos
+            k = 0
+            for i in self.intervals:
+                # distinct range -> insert
+                if v.stop<i.start:
+                    self.intervals.insert(k, v)
+                    return
+                # contiguous range -> adjust
+                elif v.stop==i.start:
+                    self.intervals[k] = range(v.start, i.stop)
+                    return
+                # overlapping range -> adjust and reduce
+                elif v.start<=i.stop:
+                    self.intervals[k] = range(min(i.start,v.start), max(i.stop,v.stop))
+                    self.reduce(k)
+                    return
+                k += 1
+            # greater than any existing
+            self.intervals.append(v)
+
+    def addSet(self, other:IntervalSet):
+        if other.intervals is not None:
+            for i in other.intervals:
+                self.addRange(i)
+        return self
+
+    def reduce(self, k:int):
+        # only need to reduce if k is not the last
+        if k<len(self.intervals)-1:
+            l = self.intervals[k]
+            r = self.intervals[k+1]
+            # if r contained in l
+            if l.stop >= r.stop:
+                self.intervals.pop(k+1)
+                self.reduce(k)
+            elif l.stop >= r.start:
+                self.intervals[k] = range(l.start, r.stop)
+                self.intervals.pop(k+1)
+
+    def complement(self, start, stop):
+        result = IntervalSet()
+        result.addRange(range(start,stop+1))
+        for i in self.intervals:
+            result.removeRange(i)
+        return result
+
+    def __contains__(self, item):
+        if self.intervals is None:
+            return False
+        else:
+            return any(item in i for i in self.intervals)
+
+    def __len__(self):
+        return sum(len(i) for i in self.intervals)
+
+    def removeRange(self, v):
+        if v.start==v.stop-1:
+            self.removeOne(v.start)
+        elif self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals are ordered
+                if v.stop<=i.start:
+                    return
+                # check for including range, split it
+                elif v.start>i.start and v.stop<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                    x = range(v.stop, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                # check for included range, remove it
+                elif v.start<=i.start and v.stop>=i.stop:
+                    self.intervals.pop(k)
+                    k -= 1  # need another pass
+                # check for lower boundary
+                elif v.start<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                # check for upper boundary
+                elif v.stop<i.stop:
+                    self.intervals[k] = range(v.stop, i.stop)
+                k += 1
+
+    def removeOne(self, v):
+        if self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals is ordered
+                if v<i.start:
+                    return
+                # check for single value range
+                elif v==i.start and v==i.stop-1:
+                    self.intervals.pop(k)
+                    return
+                # check for lower boundary
+                elif v==i.start:
+                    self.intervals[k] = range(i.start+1, i.stop)
+                    return
+                # check for upper boundary
+                elif v==i.stop-1:
+                    self.intervals[k] = range(i.start, i.stop-1)
+                    return
+                # split existing range
+                elif v<i.stop-1:
+                    x = range(i.start, v)
+                    self.intervals[k] = range(v + 1, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                k += 1
+
+
+    def toString(self, literalNames:list, symbolicNames:list):
+        if self.intervals is None:
+            return "{}"
+        with StringIO() as buf:
+            if len(self)>1:
+                buf.write("{")
+            first = True
+            for i in self.intervals:
+                for j in i:
+                    if not first:
+                        buf.write(", ")
+                    buf.write(self.elementName(literalNames, symbolicNames, j))
+                    first = False
+            if len(self)>1:
+                buf.write("}")
+            return buf.getvalue()
+
+    def elementName(self, literalNames:list, symbolicNames:list, a:int):
+        if a==Token.EOF:
+            return "<EOF>"
+        elif a==Token.EPSILON:
+            return "<EPSILON>"
+        else:
+            if a<len(literalNames) and literalNames[a] != "<INVALID>":
+                return literalNames[a]
+            if a<len(symbolicNames):
+                return symbolicNames[a]
+            return "<UNKNOWN>"

evalkit_tf449/lib/python3.10/site-packages/antlr4/ListTokenSource.py

@@ -0,0 +1,144 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# Provides an implementation of {@link TokenSource} as a wrapper around a list
+# of {@link Token} objects.
+#
+# <p>If the final token in the list is an {@link Token#EOF} token, it will be used
+# as the EOF token for every call to {@link #nextToken} after the end of the
+# list is reached. Otherwise, an EOF token will be created.</p>
+#
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.Lexer import TokenSource
+from antlr4.Token import Token
+
+
+class ListTokenSource(TokenSource):
+    __slots__ = ('tokens', 'sourceName', 'pos', 'eofToken', '_factory')
+
+    # Constructs a new {@link ListTokenSource} instance from the specified
+    # collection of {@link Token} objects and source name.
+    #
+    # @param tokens The collection of {@link Token} objects to provide as a
+    # {@link TokenSource}.
+    # @param sourceName The name of the {@link TokenSource}. If this value is
+    # {@code null}, {@link #getSourceName} will attempt to infer the name from
+    # the next {@link Token} (or the previous token if the end of the input has
+    # been reached).
+    #
+    # @exception NullPointerException if {@code tokens} is {@code null}
+    #
+    def __init__(self, tokens:list, sourceName:str=None):
+        if tokens is None:
+            raise ReferenceError("tokens cannot be null")
+        self.tokens = tokens
+        self.sourceName = sourceName
+        # The index into {@link #tokens} of token to return by the next call to
+        # {@link #nextToken}. The end of the input is indicated by this value
+        # being greater than or equal to the number of items in {@link #tokens}.
+        self.pos = 0
+        # This field caches the EOF token for the token source.
+        self.eofToken = None
+        # This is the backing field for {@link #getTokenFactory} and
+        self._factory = CommonTokenFactory.DEFAULT
+
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def column(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].column
+        elif self.eofToken is not None:
+            return self.eofToken.column
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            tokenText = lastToken.text
+            if tokenText is not None:
+                lastNewLine = tokenText.rfind('\n')
+                if lastNewLine >= 0:
+                    return len(tokenText) - lastNewLine - 1
+            return lastToken.column + lastToken.stop - lastToken.start + 1
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 0
+
+    #
+    # {@inheritDoc}
+    #
+    def nextToken(self):
+        if self.pos >= len(self.tokens):
+            if self.eofToken is None:
+                start = -1
+                if len(self.tokens) > 0:
+                    previousStop = self.tokens[len(self.tokens) - 1].stop
+                    if previousStop != -1:
+                        start = previousStop + 1
+                stop = max(-1, start - 1)
+                self.eofToken = self._factory.create((self, self.getInputStream()),
+                            Token.EOF, "EOF", Token.DEFAULT_CHANNEL, start, stop, self.line, self.column)
+            return self.eofToken
+        t = self.tokens[self.pos]
+        if self.pos == len(self.tokens) - 1 and t.type == Token.EOF:
+            self.eofToken = t
+        self.pos += 1
+        return t
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def line(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].line
+        elif self.eofToken is not None:
+            return self.eofToken.line
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            line = lastToken.line
+            tokenText = lastToken.text
+            if tokenText is not None:
+                line += tokenText.count('\n')
+
+            # if no text is available, assume the token did not contain any newline characters.
+            return line
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 1
+
+    #
+    # {@inheritDoc}
+    #
+    def getInputStream(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].getInputStream()
+        elif self.eofToken is not None:
+            return self.eofToken.getInputStream()
+        elif len(self.tokens) > 0:
+            return self.tokens[len(self.tokens) - 1].getInputStream()
+        else:
+            # no input stream information is available
+            return None
+
+    #
+    # {@inheritDoc}
+    #
+    def getSourceName(self):
+        if self.sourceName is not None:
+            return self.sourceName
+        inputStream = self.getInputStream()
+        if inputStream is not None:
+            return inputStream.getSourceName()
+        else:
+            return "List"

evalkit_tf449/lib/python3.10/site-packages/antlr4/Parser.py

@@ -0,0 +1,580 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenFactory import TokenFactory
+from antlr4.error.ErrorStrategy import DefaultErrorStrategy
+from antlr4.InputStream import InputStream
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Token import Token
+from antlr4.Lexer import Lexer
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+from antlr4.error.Errors import UnsupportedOperationException, RecognitionException
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTreeListener, TerminalNode, ErrorNode
+
+class TraceListener(ParseTreeListener):
+    __slots__ = '_parser'
+
+    def __init__(self, parser):
+        self._parser = parser
+
+    def enterEveryRule(self, ctx):
+        print("enter   " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text, file=self._parser._output)
+
+    def visitTerminal(self, node):
+
+        print("consume " + str(node.symbol) + " rule " + self._parser.ruleNames[self._parser._ctx.getRuleIndex()], file=self._parser._output)
+
+    def visitErrorNode(self, node):
+        pass
+
+
+    def exitEveryRule(self, ctx):
+        print("exit    " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text, file=self._parser._output)
+
+
+# self is all the parsing support code essentially; most of it is error recovery stuff.#
+class Parser (Recognizer):
+    __slots__ = (
+        '_input', '_output', '_errHandler', '_precedenceStack', '_ctx',
+        'buildParseTrees', '_tracer', '_parseListeners', '_syntaxErrors'
+
+    )
+    # self field maps from the serialized ATN string to the deserialized {@link ATN} with
+    # bypass alternatives.
+    #
+    # @see ATNDeserializationOptions#isGenerateRuleBypassTransitions()
+    #
+    bypassAltsAtnCache = dict()
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__()
+        # The input stream.
+        self._input = None
+        self._output = output
+        # The error handling strategy for the parser. The default value is a new
+        # instance of {@link DefaultErrorStrategy}.
+        self._errHandler = DefaultErrorStrategy()
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        # The {@link ParserRuleContext} object for the currently executing rule.
+        # self is always non-null during the parsing process.
+        self._ctx = None
+        # Specifies whether or not the parser should construct a parse tree during
+        # the parsing process. The default value is {@code true}.
+        self.buildParseTrees = True
+        # When {@link #setTrace}{@code (true)} is called, a reference to the
+        # {@link TraceListener} is stored here so it can be easily removed in a
+        # later call to {@link #setTrace}{@code (false)}. The listener itself is
+        # implemented as a parser listener so self field is not directly used by
+        # other parser methods.
+        self._tracer = None
+        # The list of {@link ParseTreeListener} listeners registered to receive
+        # events during the parse.
+        self._parseListeners = None
+        # The number of syntax errors reported during parsing. self value is
+        # incremented each time {@link #notifyErrorListeners} is called.
+        self._syntaxErrors = 0
+        self.setInputStream(input)
+
+    # reset the parser's state#
+    def reset(self):
+        if self._input is not None:
+            self._input.seek(0)
+        self._errHandler.reset(self)
+        self._ctx = None
+        self._syntaxErrors = 0
+        self.setTrace(False)
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        if self._interp is not None:
+            self._interp.reset()
+
+    # Match current input symbol against {@code ttype}. If the symbol type
+    # matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
+    # called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @param ttype the token type to match
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # {@code ttype} and the error strategy could not recover from the
+    # mismatched symbol
+
+    def match(self, ttype:int):
+        t = self.getCurrentToken()
+        if t.type==ttype:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex==-1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+        return t
+
+    # Match current input symbol as a wildcard. If the symbol type matches
+    # (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
+    # and {@link #consume} are called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # a wildcard and the error strategy could not recover from the mismatched
+    # symbol
+
+    def matchWildcard(self):
+        t = self.getCurrentToken()
+        if t.type > 0:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex == -1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+
+        return t
+
+    def getParseListeners(self):
+        return list() if self._parseListeners is None else self._parseListeners
+
+    # Registers {@code listener} to receive events during the parsing process.
+    #
+    # <p>To support output-preserving grammar transformations (including but not
+    # limited to left-recursion removal, automated left-factoring, and
+    # optimized code generation), calls to listener methods during the parse
+    # may differ substantially from calls made by
+    # {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
+    # particular, rule entry and exit events may occur in a different order
+    # during the parse than after the parser. In addition, calls to certain
+    # rule entry methods may be omitted.</p>
+    #
+    # <p>With the following specific exceptions, calls to listener events are
+    # <em>deterministic</em>, i.e. for identical input the calls to listener
+    # methods will be the same.</p>
+    #
+    # <ul>
+    # <li>Alterations to the grammar used to generate code may change the
+    # behavior of the listener calls.</li>
+    # <li>Alterations to the command line options passed to ANTLR 4 when
+    # generating the parser may change the behavior of the listener calls.</li>
+    # <li>Changing the version of the ANTLR Tool used to generate the parser
+    # may change the behavior of the listener calls.</li>
+    # </ul>
+    #
+    # @param listener the listener to add
+    #
+    # @throws NullPointerException if {@code} listener is {@code null}
+    #
+    def addParseListener(self, listener:ParseTreeListener):
+        if listener is None:
+            raise ReferenceError("listener")
+        if self._parseListeners is None:
+            self._parseListeners = []
+        self._parseListeners.append(listener)
+
+    #
+    # Remove {@code listener} from the list of parse listeners.
+    #
+    # <p>If {@code listener} is {@code null} or has not been added as a parse
+    # listener, self method does nothing.</p>
+    # @param listener the listener to remove
+    #
+    def removeParseListener(self, listener:ParseTreeListener):
+        if self._parseListeners is not None:
+            self._parseListeners.remove(listener)
+            if len(self._parseListeners)==0:
+                    self._parseListeners = None
+
+    # Remove all parse listeners.
+    def removeParseListeners(self):
+        self._parseListeners = None
+
+    # Notify any parse listeners of an enter rule event.
+    def triggerEnterRuleEvent(self):
+        if self._parseListeners is not None:
+            for listener in self._parseListeners:
+                listener.enterEveryRule(self._ctx)
+                self._ctx.enterRule(listener)
+
+    #
+    # Notify any parse listeners of an exit rule event.
+    #
+    # @see #addParseListener
+    #
+    def triggerExitRuleEvent(self):
+        if self._parseListeners is not None:
+            # reverse order walk of listeners
+            for listener in reversed(self._parseListeners):
+                self._ctx.exitRule(listener)
+                listener.exitEveryRule(self._ctx)
+
+
+    # Gets the number of syntax errors reported during parsing. This value is
+    # incremented each time {@link #notifyErrorListeners} is called.
+    #
+    # @see #notifyErrorListeners
+    #
+    def getNumberOfSyntaxErrors(self):
+        return self._syntaxErrors
+
+    def getTokenFactory(self):
+        return self._input.tokenSource._factory
+
+    # Tell our token source and error strategy about a new way to create tokens.#
+    def setTokenFactory(self, factory:TokenFactory):
+        self._input.tokenSource._factory = factory
+
+    # The ATN with bypass alternatives is expensive to create so we create it
+    # lazily.
+    #
+    # @throws UnsupportedOperationException if the current parser does not
+    # implement the {@link #getSerializedATN()} method.
+    #
+    def getATNWithBypassAlts(self):
+        serializedAtn = self.getSerializedATN()
+        if serializedAtn is None:
+            raise UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.")
+        result = self.bypassAltsAtnCache.get(serializedAtn, None)
+        if result is None:
+            deserializationOptions = ATNDeserializationOptions()
+            deserializationOptions.generateRuleBypassTransitions = True
+            result = ATNDeserializer(deserializationOptions).deserialize(serializedAtn)
+            self.bypassAltsAtnCache[serializedAtn] = result
+        return result
+
+    # The preferred method of getting a tree pattern. For example, here's a
+    # sample use:
+    #
+    # <pre>
+    # ParseTree t = parser.expr();
+    # ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
+    # ParseTreeMatch m = p.match(t);
+    # String id = m.get("ID");
+    # </pre>
+    #
+    def compileParseTreePattern(self, pattern:str, patternRuleIndex:int, lexer:Lexer = None):
+        if lexer is None:
+            if self.getTokenStream() is not None:
+                tokenSource = self.getTokenStream().tokenSource
+                if isinstance( tokenSource, Lexer ):
+                    lexer = tokenSource
+        if lexer is None:
+            raise UnsupportedOperationException("Parser can't discover a lexer to use")
+
+        m = ParseTreePatternMatcher(lexer, self)
+        return m.compile(pattern, patternRuleIndex)
+
+
+    def getInputStream(self):
+        return self.getTokenStream()
+
+    def setInputStream(self, input:InputStream):
+        self.setTokenStream(input)
+
+    def getTokenStream(self):
+        return self._input
+
+    # Set the token stream and reset the parser.#
+    def setTokenStream(self, input:TokenStream):
+        self._input = None
+        self.reset()
+        self._input = input
+
+    # Match needs to return the current input symbol, which gets put
+    #  into the label for the associated token ref; e.g., x=ID.
+    #
+    def getCurrentToken(self):
+        return self._input.LT(1)
+
+    def notifyErrorListeners(self, msg:str, offendingToken:Token = None, e:RecognitionException = None):
+        if offendingToken is None:
+            offendingToken = self.getCurrentToken()
+        self._syntaxErrors += 1
+        line = offendingToken.line
+        column = offendingToken.column
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, offendingToken, line, column, msg, e)
+
+    #
+    # Consume and return the {@linkplain #getCurrentToken current symbol}.
+    #
+    # <p>E.g., given the following input with {@code A} being the current
+    # lookahead symbol, self function moves the cursor to {@code B} and returns
+    # {@code A}.</p>
+    #
+    # <pre>
+    #  A B
+    #  ^
+    # </pre>
+    #
+    # If the parser is not in error recovery mode, the consumed symbol is added
+    # to the parse tree using {@link ParserRuleContext#addChild(Token)}, and
+    # {@link ParseTreeListener#visitTerminal} is called on any parse listeners.
+    # If the parser <em>is</em> in error recovery mode, the consumed symbol is
+    # added to the parse tree using
+    # {@link ParserRuleContext#addErrorNode(Token)}, and
+    # {@link ParseTreeListener#visitErrorNode} is called on any parse
+    # listeners.
+    #
+    def consume(self):
+        o = self.getCurrentToken()
+        if o.type != Token.EOF:
+            self.getInputStream().consume()
+        hasListener = self._parseListeners is not None and len(self._parseListeners)>0
+        if self.buildParseTrees or hasListener:
+            if self._errHandler.inErrorRecoveryMode(self):
+                node = self._ctx.addErrorNode(o)
+            else:
+                node = self._ctx.addTokenNode(o)
+            if hasListener:
+                for listener in self._parseListeners:
+                    if isinstance(node, ErrorNode):
+                        listener.visitErrorNode(node)
+                    elif isinstance(node, TerminalNode):
+                        listener.visitTerminal(node)
+        return o
+
+    def addContextToParseTree(self):
+        # add current context to parent if we have a parent
+        if self._ctx.parentCtx is not None:
+            self._ctx.parentCtx.addChild(self._ctx)
+
+    # Always called by generated parsers upon entry to a rule. Access field
+    # {@link #_ctx} get the current context.
+    #
+    def enterRule(self, localctx:ParserRuleContext , state:int , ruleIndex:int):
+        self.state = state
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self.buildParseTrees:
+            self.addContextToParseTree()
+        if self._parseListeners  is not None:
+            self.triggerEnterRuleEvent()
+
+    def exitRule(self):
+        self._ctx.stop = self._input.LT(-1)
+        # trigger event on _ctx, before it reverts to parent
+        if self._parseListeners is not None:
+            self.triggerExitRuleEvent()
+        self.state = self._ctx.invokingState
+        self._ctx = self._ctx.parentCtx
+
+    def enterOuterAlt(self, localctx:ParserRuleContext, altNum:int):
+        localctx.setAltNumber(altNum)
+        # if we have new localctx, make sure we replace existing ctx
+        # that is previous child of parse tree
+        if self.buildParseTrees and self._ctx != localctx:
+            if self._ctx.parentCtx is not None:
+                self._ctx.parentCtx.removeLastChild()
+                self._ctx.parentCtx.addChild(localctx)
+        self._ctx = localctx
+
+    # Get the precedence level for the top-most precedence rule.
+    #
+    # @return The precedence level for the top-most precedence rule, or -1 if
+    # the parser context is not nested within a precedence rule.
+    #
+    def getPrecedence(self):
+        if len(self._precedenceStack)==0:
+            return -1
+        else:
+            return self._precedenceStack[-1]
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self.state = state
+        self._precedenceStack.append(precedence)
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    #
+    # Like {@link #enterRule} but for recursive rules.
+    #
+    def pushNewRecursionContext(self, localctx:ParserRuleContext, state:int, ruleIndex:int):
+        previous = self._ctx
+        previous.parentCtx = localctx
+        previous.invokingState = state
+        previous.stop = self._input.LT(-1)
+
+        self._ctx = localctx
+        self._ctx.start = previous.start
+        if self.buildParseTrees:
+            self._ctx.addChild(previous)
+
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    def unrollRecursionContexts(self, parentCtx:ParserRuleContext):
+        self._precedenceStack.pop()
+        self._ctx.stop = self._input.LT(-1)
+        retCtx = self._ctx # save current ctx (return value)
+        # unroll so _ctx is as it was before call to recursive method
+        if self._parseListeners is not None:
+            while self._ctx is not parentCtx:
+                self.triggerExitRuleEvent()
+                self._ctx = self._ctx.parentCtx
+        else:
+            self._ctx = parentCtx
+
+        # hook into tree
+        retCtx.parentCtx = parentCtx
+
+        if self.buildParseTrees and parentCtx is not None:
+            # add return ctx into invoking rule's tree
+            parentCtx.addChild(retCtx)
+
+    def getInvokingContext(self, ruleIndex:int):
+        ctx = self._ctx
+        while ctx is not None:
+            if ctx.getRuleIndex() == ruleIndex:
+                return ctx
+            ctx = ctx.parentCtx
+        return None
+
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return precedence >= self._precedenceStack[-1]
+
+    def inContext(self, context:str):
+        # TODO: useful in parser?
+        return False
+
+    #
+    # Checks whether or not {@code symbol} can follow the current state in the
+    # ATN. The behavior of self method is equivalent to the following, but is
+    # implemented such that the complete context-sensitive follow set does not
+    # need to be explicitly constructed.
+    #
+    # <pre>
+    # return getExpectedTokens().contains(symbol);
+    # </pre>
+    #
+    # @param symbol the symbol type to check
+    # @return {@code true} if {@code symbol} can follow the current state in
+    # the ATN, otherwise {@code false}.
+    #
+    def isExpectedToken(self, symbol:int):
+        atn = self._interp.atn
+        ctx = self._ctx
+        s = atn.states[self.state]
+        following = atn.nextTokens(s)
+        if symbol in following:
+            return True
+        if not Token.EPSILON in following:
+            return False
+
+        while ctx is not None and ctx.invokingState>=0 and Token.EPSILON in following:
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = atn.nextTokens(rt.followState)
+            if symbol in following:
+                return True
+            ctx = ctx.parentCtx
+
+        if Token.EPSILON in following and symbol == Token.EOF:
+            return True
+        else:
+            return False
+
+    # Computes the set of input symbols which could follow the current parser
+    # state and context, as given by {@link #getState} and {@link #getContext},
+    # respectively.
+    #
+    # @see ATN#getExpectedTokens(int, RuleContext)
+    #
+    def getExpectedTokens(self):
+        return self._interp.atn.getExpectedTokens(self.state, self._ctx)
+
+    def getExpectedTokensWithinCurrentRule(self):
+        atn = self._interp.atn
+        s = atn.states[self.state]
+        return atn.nextTokens(s)
+
+    # Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.#
+    def getRuleIndex(self, ruleName:str):
+        ruleIndex = self.getRuleIndexMap().get(ruleName, None)
+        if ruleIndex is not None:
+            return ruleIndex
+        else:
+            return -1
+
+    # Return List&lt;String&gt; of the rule names in your parser instance
+    #  leading up to a call to the current rule.  You could override if
+    #  you want more details such as the file/line info of where
+    #  in the ATN a rule is invoked.
+    #
+    #  this is very useful for error messages.
+    #
+    def getRuleInvocationStack(self, p:RuleContext=None):
+        if p is None:
+            p = self._ctx
+        stack = list()
+        while p is not None:
+            # compute what follows who invoked us
+            ruleIndex = p.getRuleIndex()
+            if ruleIndex<0:
+                stack.append("n/a")
+            else:
+                stack.append(self.ruleNames[ruleIndex])
+            p = p.parentCtx
+        return stack
+
+    # For debugging and other purposes.#
+    def getDFAStrings(self):
+        return [ str(dfa) for dfa in self._interp.decisionToDFA]
+
+    # For debugging and other purposes.#
+    def dumpDFA(self):
+        seenOne = False
+        for i in range(0, len(self._interp.decisionToDFA)):
+            dfa = self._interp.decisionToDFA[i]
+            if len(dfa.states)>0:
+                if seenOne:
+                    print(file=self._output)
+                print("Decision " + str(dfa.decision) + ":", file=self._output)
+                print(dfa.toString(self.literalNames, self.symbolicNames), end='', file=self._output)
+                seenOne = True
+
+
+    def getSourceName(self):
+        return self._input.sourceName
+
+    # During a parse is sometimes useful to listen in on the rule entry and exit
+    #  events as well as token matches. self is for quick and dirty debugging.
+    #
+    def setTrace(self, trace:bool):
+        if not trace:
+            self.removeParseListener(self._tracer)
+            self._tracer = None
+        else:
+            if self._tracer is not None:
+                self.removeParseListener(self._tracer)
+            self._tracer = TraceListener(self)
+            self.addParseListener(self._tracer)

evalkit_tf449/lib/python3.10/site-packages/antlr4/ParserInterpreter.py

@@ -0,0 +1,170 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+# A parser simulator that mimics what ANTLR's generated
+#  parser code does. A ParserATNSimulator is used to make
+#  predictions via adaptivePredict but this class moves a pointer through the
+#  ATN to simulate parsing. ParserATNSimulator just
+#  makes us efficient rather than having to backtrack, for example.
+#
+#  This properly creates parse trees even for left recursive rules.
+#
+#  We rely on the left recursive rule invocation and special predicate
+#  transitions to make left recursive rules work.
+#
+#  See TestParserInterpreter for examples.
+#
+from antlr4.dfa.DFA import DFA
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import InterpreterRuleContext, ParserRuleContext
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNState import StarLoopEntryState, ATNState, LoopEndState
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.atn.Transition import Transition
+from antlr4.error.Errors import RecognitionException, UnsupportedOperationException, FailedPredicateException
+
+
+class ParserInterpreter(Parser):
+    __slots__ = (
+        'grammarFileName', 'atn', 'tokenNames', 'ruleNames', 'decisionToDFA',
+        'sharedContextCache', '_parentContextStack',
+        'pushRecursionContextStates'
+    )
+
+    def __init__(self, grammarFileName:str, tokenNames:list, ruleNames:list, atn:ATN, input:TokenStream):
+        super().__init__(input)
+        self.grammarFileName = grammarFileName
+        self.atn = atn
+        self.tokenNames = tokenNames
+        self.ruleNames = ruleNames
+        self.decisionToDFA = [ DFA(state) for state in atn.decisionToState ]
+        self.sharedContextCache = PredictionContextCache()
+        self._parentContextStack = list()
+        # identify the ATN states where pushNewRecursionContext must be called
+        self.pushRecursionContextStates = set()
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+            if state.isPrecedenceDecision:
+                self.pushRecursionContextStates.add(state.stateNumber)
+        # get atn simulator that knows how to do predictions
+        self._interp = ParserATNSimulator(self, atn, self.decisionToDFA, self.sharedContextCache)
+
+    # Begin parsing at startRuleIndex#
+    def parse(self, startRuleIndex:int):
+        startRuleStartState = self.atn.ruleToStartState[startRuleIndex]
+        rootContext = InterpreterRuleContext(None, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+        if startRuleStartState.isPrecedenceRule:
+            self.enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+        else:
+            self.enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
+        while True:
+            p = self.getATNState()
+            if p.stateType==ATNState.RULE_STOP :
+                # pop; return from rule
+                if len(self._ctx)==0:
+                    if startRuleStartState.isPrecedenceRule:
+                        result = self._ctx
+                        parentContext = self._parentContextStack.pop()
+                        self.unrollRecursionContexts(parentContext.a)
+                        return result
+                    else:
+                        self.exitRule()
+                        return rootContext
+                self.visitRuleStopState(p)
+
+            else:
+                try:
+                    self.visitState(p)
+                except RecognitionException as e:
+                    self.state = self.atn.ruleToStopState[p.ruleIndex].stateNumber
+                    self._ctx.exception = e
+                    self._errHandler.reportError(self, e)
+                    self._errHandler.recover(self, e)
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self._parentContextStack.append((self._ctx, localctx.invokingState))
+        super().enterRecursionRule(localctx, state, ruleIndex, precedence)
+
+    def getATNState(self):
+        return self.atn.states[self.state]
+
+    def visitState(self, p:ATNState):
+        edge = 0
+        if len(p.transitions) > 1:
+            self._errHandler.sync(self)
+            edge = self._interp.adaptivePredict(self._input, p.decision, self._ctx)
+        else:
+            edge = 1
+
+        transition = p.transitions[edge - 1]
+        tt = transition.serializationType
+        if tt==Transition.EPSILON:
+
+            if self.pushRecursionContextStates[p.stateNumber] and not isinstance(transition.target, LoopEndState):
+                t = self._parentContextStack[-1]
+                ctx = InterpreterRuleContext(t[0], t[1], self._ctx.ruleIndex)
+                self.pushNewRecursionContext(ctx, self.atn.ruleToStartState[p.ruleIndex].stateNumber, self._ctx.ruleIndex)
+
+        elif tt==Transition.ATOM:
+
+            self.match(transition.label)
+
+        elif tt in [ Transition.RANGE, Transition.SET, Transition.NOT_SET]:
+
+            if not transition.matches(self._input.LA(1), Token.MIN_USER_TOKEN_TYPE, Lexer.MAX_CHAR_VALUE):
+                self._errHandler.recoverInline(self)
+            self.matchWildcard()
+
+        elif tt==Transition.WILDCARD:
+
+            self.matchWildcard()
+
+        elif tt==Transition.RULE:
+
+            ruleStartState = transition.target
+            ruleIndex = ruleStartState.ruleIndex
+            ctx = InterpreterRuleContext(self._ctx, p.stateNumber, ruleIndex)
+            if ruleStartState.isPrecedenceRule:
+                self.enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, transition.precedence)
+            else:
+                self.enterRule(ctx, transition.target.stateNumber, ruleIndex)
+
+        elif tt==Transition.PREDICATE:
+
+            if not self.sempred(self._ctx, transition.ruleIndex, transition.predIndex):
+                raise FailedPredicateException(self)
+
+        elif tt==Transition.ACTION:
+
+            self.action(self._ctx, transition.ruleIndex, transition.actionIndex)
+
+        elif tt==Transition.PRECEDENCE:
+
+            if not self.precpred(self._ctx, transition.precedence):
+                msg = "precpred(_ctx, " + str(transition.precedence) + ")"
+                raise FailedPredicateException(self, msg)
+
+        else:
+            raise UnsupportedOperationException("Unrecognized ATN transition type.")
+
+        self.state = transition.target.stateNumber
+
+    def visitRuleStopState(self, p:ATNState):
+        ruleStartState = self.atn.ruleToStartState[p.ruleIndex]
+        if ruleStartState.isPrecedenceRule:
+            parentContext = self._parentContextStack.pop()
+            self.unrollRecursionContexts(parentContext.a)
+            self.state = parentContext[1]
+        else:
+            self.exitRule()
+
+        ruleTransition = self.atn.states[self.state].transitions[0]
+        self.state = ruleTransition.followState.stateNumber

evalkit_tf449/lib/python3.10/site-packages/antlr4/ParserRuleContext.py

@@ -0,0 +1,186 @@
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+
+#* A rule invocation record for parsing.
+#
+#  Contains all of the information about the current rule not stored in the
+#  RuleContext. It handles parse tree children list, Any ATN state
+#  tracing, and the default values available for rule indications:
+#  start, stop, rule index, current alt number, current
+#  ATN state.
+#
+#  Subclasses made for each rule and grammar track the parameters,
+#  return values, locals, and labels specific to that rule. These
+#  are the objects that are returned from rules.
+#
+#  Note text is not an actual field of a rule return value; it is computed
+#  from start and stop using the input stream's toString() method.  I
+#  could add a ctor to this so that we can pass in and store the input
+#  stream, but I'm not sure we want to do that.  It would seem to be undefined
+#  to get the .text property anyway if the rule matches tokens from multiple
+#  input streams.
+#
+#  I do not use getters for fields of objects that are used simply to
+#  group values such as this aggregate.  The getters/setters are there to
+#  satisfy the superclass interface.
+
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.tree.Tree import ParseTreeListener, ParseTree, TerminalNodeImpl, ErrorNodeImpl, TerminalNode, \
+    INVALID_INTERVAL
+
+# need forward declaration
+ParserRuleContext = None
+
+class ParserRuleContext(RuleContext):
+    __slots__ = ('children', 'start', 'stop', 'exception')
+    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):
+        super().__init__(parent, invokingStateNumber)
+        #* If we are debugging or building a parse tree for a visitor,
+        #  we need to track all of the tokens and rule invocations associated
+        #  with this rule's context. This is empty for parsing w/o tree constr.
+        #  operation because we don't the need to track the details about
+        #  how we parse this rule.
+        #/
+        self.children = None
+        self.start = None
+        self.stop = None
+        # The exception that forced this rule to return. If the rule successfully
+        # completed, this is {@code null}.
+        self.exception = None
+
+    #* COPY a ctx (I'm deliberately not using copy constructor)#/
+    #
+    # This is used in the generated parser code to flip a generic XContext
+    # node for rule X to a YContext for alt label Y. In that sense, it is
+    # not really a generic copy function.
+    #
+    # If we do an error sync() at start of a rule, we might add error nodes
+    # to the generic XContext so this function must copy those nodes to
+    # the YContext as well else they are lost!
+    #/
+    def copyFrom(self, ctx:ParserRuleContext):
+        # from RuleContext
+        self.parentCtx = ctx.parentCtx
+        self.invokingState = ctx.invokingState
+        self.children = None
+        self.start = ctx.start
+        self.stop = ctx.stop
+
+        # copy any error nodes to alt label node
+        if ctx.children is not None:
+            self.children = []
+            # reset parent pointer for any error nodes
+            for child in ctx.children:
+                if isinstance(child, ErrorNodeImpl):
+                    self.children.append(child)
+                    child.parentCtx = self
+
+    # Double dispatch methods for listeners
+    def enterRule(self, listener:ParseTreeListener):
+        pass
+
+    def exitRule(self, listener:ParseTreeListener):
+        pass
+
+    #* Does not set parent link; other add methods do that#/
+    def addChild(self, child:ParseTree):
+        if self.children is None:
+            self.children = []
+        self.children.append(child)
+        return child
+
+    #* Used by enterOuterAlt to toss out a RuleContext previously added as
+    #  we entered a rule. If we have # label, we will need to remove
+    #  generic ruleContext object.
+    #/
+    def removeLastChild(self):
+        if self.children is not None:
+            del self.children[len(self.children)-1]
+
+    def addTokenNode(self, token:Token):
+        node = TerminalNodeImpl(token)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def addErrorNode(self, badToken:Token):
+        node = ErrorNodeImpl(badToken)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def getChild(self, i:int, ttype:type = None):
+        if ttype is None:
+            return self.children[i] if len(self.children)>i else None
+        else:
+            for child in self.getChildren():
+                if not isinstance(child, ttype):
+                    continue
+                if i==0:
+                    return child
+                i -= 1
+            return None
+
+    def getChildren(self, predicate = None):
+        if self.children is not None:
+            for child in self.children:
+                if predicate is not None and not predicate(child):
+                    continue
+                yield child
+
+    def getToken(self, ttype:int, i:int):
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            if i==0:
+                return child
+            i -= 1
+        return None
+
+    def getTokens(self, ttype:int ):
+        if self.getChildren() is None:
+            return []
+        tokens = []
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            tokens.append(child)
+        return tokens
+
+    def getTypedRuleContext(self, ctxType:type, i:int):
+        return self.getChild(i, ctxType)
+
+    def getTypedRuleContexts(self, ctxType:type):
+        children = self.getChildren()
+        if children is None:
+            return []
+        contexts = []
+        for child in children:
+            if not isinstance(child, ctxType):
+                continue
+            contexts.append(child)
+        return contexts
+
+    def getChildCount(self):
+        return len(self.children) if self.children else 0
+
+    def getSourceInterval(self):
+        if self.start is None or self.stop is None:
+            return INVALID_INTERVAL
+        else:
+            return (self.start.tokenIndex, self.stop.tokenIndex)
+
+
+RuleContext.EMPTY = ParserRuleContext()
+
+class InterpreterRuleContext(ParserRuleContext):
+
+    def __init__(self, parent:ParserRuleContext, invokingStateNumber:int, ruleIndex:int):
+        super().__init__(parent, invokingStateNumber)
+        self.ruleIndex = ruleIndex

evalkit_tf449/lib/python3.10/site-packages/antlr4/Recognizer.py

@@ -0,0 +1,147 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ProxyErrorListener, ConsoleErrorListener
+
+# need forward delcaration
+RecognitionException = None
+
+class Recognizer(object):
+    __slots__ = ('_listeners', '_interp', '_stateNumber')
+
+    tokenTypeMapCache = dict()
+    ruleIndexMapCache = dict()
+
+    def __init__(self):
+        self._listeners = [ ConsoleErrorListener.INSTANCE ]
+        self._interp = None
+        self._stateNumber = -1
+
+    def extractVersion(self, version):
+        pos = version.find(".")
+        major = version[0:pos]
+        version = version[pos+1:]
+        pos = version.find(".")
+        if pos==-1:
+            pos = version.find("-")
+        if pos==-1:
+            pos = len(version)
+        minor = version[0:pos]
+        return major, minor
+
+    def checkVersion(self, toolVersion):
+        runtimeVersion = "4.9.3"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor:
+            print("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion)
+
+    def addErrorListener(self, listener):
+        self._listeners.append(listener)
+
+    def removeErrorListener(self, listener):
+        self._listeners.remove(listener)
+
+    def removeErrorListeners(self):
+        self._listeners = []
+
+    def getTokenTypeMap(self):
+        tokenNames = self.getTokenNames()
+        if tokenNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of token names.")
+        result = self.tokenTypeMapCache.get(tokenNames, None)
+        if result is None:
+            result = zip( tokenNames, range(0, len(tokenNames)))
+            result["EOF"] = Token.EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        return result
+
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap(self):
+        ruleNames = self.getRuleNames()
+        if ruleNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of rule names.")
+        result = self.ruleIndexMapCache.get(ruleNames, None)
+        if result is None:
+            result = zip( ruleNames, range(0, len(ruleNames)))
+            self.ruleIndexMapCache[ruleNames] = result
+        return result
+
+    def getTokenType(self, tokenName:str):
+        ttype = self.getTokenTypeMap().get(tokenName, None)
+        if ttype is not None:
+            return ttype
+        else:
+            return Token.INVALID_TYPE
+
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(self, e:RecognitionException):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return "line "+line+":"+column
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    def getErrorListenerDispatch(self):
+        return ProxyErrorListener(self._listeners)
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        return True
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return True
+
+    @property
+    def state(self):
+        return self._stateNumber
+
+    # Indicate that the recognizer has changed internal state that is
+    #  consistent with the ATN state passed in.  This way we always know
+    #  where we are in the ATN as the parser goes along. The rule
+    #  context objects form a stack that lets us see the stack of
+    #  invoking rules. Combine this and we have complete ATN
+    #  configuration information.
+
+    @state.setter
+    def state(self, atnState:int):
+        self._stateNumber = atnState
+
+del RecognitionException

evalkit_tf449/lib/python3.10/site-packages/antlr4/RuleContext.py

@@ -0,0 +1,227 @@
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+
+#  A rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  The parent contexts are useful for computing lookahead sets and
+#  getting error information.
+#
+#  These objects are used during parsing and prediction.
+#  For the special case of parsers, we use the subclass
+#  ParserRuleContext.
+#
+#  @see ParserRuleContext
+#/
+from io import StringIO
+from antlr4.tree.Tree import RuleNode, INVALID_INTERVAL, ParseTreeVisitor
+from antlr4.tree.Trees import Trees
+
+# need forward declarations
+RuleContext = None
+Parser = None
+
+class RuleContext(RuleNode):
+    __slots__ = ('parentCtx', 'invokingState')
+    EMPTY = None
+
+    def __init__(self, parent:RuleContext=None, invokingState:int=-1):
+        super().__init__()
+        # What context invoked this rule?
+        self.parentCtx = parent
+        # What state invoked the rule associated with this context?
+        #  The "return address" is the followState of invokingState
+        #  If parent is null, this should be -1.
+        self.invokingState = invokingState
+
+
+    def depth(self):
+        n = 0
+        p = self
+        while p is not None:
+            p = p.parentCtx
+            n += 1
+        return n
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty(self):
+        return self.invokingState == -1
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval(self):
+        return INVALID_INTERVAL
+
+    def getRuleContext(self):
+        return self
+
+    def getPayload(self):
+        return self
+
+   # Return the combined text of all child nodes. This method only considers
+    #  tokens which have been added to the parse tree.
+    #  <p>
+    #  Since tokens on hidden channels (e.g. whitespace or comments) are not
+    #  added to the parse trees, they will not appear in the output of this
+    #  method.
+    #/
+    def getText(self):
+        if self.getChildCount() == 0:
+            return ""
+        with StringIO() as builder:
+            for child in self.getChildren():
+                builder.write(child.getText())
+            return builder.getvalue()
+
+    def getRuleIndex(self):
+        return -1
+
+    # For rule associated with this parse tree internal node, return
+    # the outer alternative number used to match the input. Default
+    # implementation does not compute nor store this alt num. Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    # to set it.
+    def getAltNumber(self):
+        return 0 # should use ATN.INVALID_ALT_NUMBER but won't compile
+
+    # Set the outer alternative number for this context node. Default
+    # implementation does nothing to avoid backing field overhead for
+    # trees that don't need it.  Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    def setAltNumber(self, altNumber:int):
+        pass
+
+    def getChild(self, i:int):
+        return None
+
+    def getChildCount(self):
+        return 0
+
+    def getChildren(self):
+        for c in []:
+            yield c
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitChildren(self)
+
+   # # Call this method to view a parse tree in a dialog box visually.#/
+   #  public Future<JDialog> inspect(@Nullable Parser parser) {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      return inspect(ruleNames);
+   #  }
+   #
+   #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+   #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+   #      return viewer.open();
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable Parser parser, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable Parser parser, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Print out a whole tree, not just a node, in LISP format
+   #  #  (root child1 .. childN). Print just a node if this is a leaf.
+   #  #  We have to know the recognizer so we can get rule names.
+   #  #/
+   #  @Override
+   #  public String toStringTree(@Nullable Parser recog) {
+   #      return Trees.toStringTree(this, recog);
+   #  }
+   #
+   # Print out a whole tree, not just a node, in LISP format
+   #  (root child1 .. childN). Print just a node if this is a leaf.
+   #
+    def toStringTree(self, ruleNames:list=None, recog:Parser=None):
+        return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
+   #  }
+   #
+   #  @Override
+   #  public String toStringTree() {
+   #      return toStringTree((List<String>)null);
+   #  }
+   #
+    def __str__(self):
+        return self.toString(None, None)
+
+   #  @Override
+   #  public String toString() {
+   #      return toString((List<String>)null, (RuleContext)null);
+   #  }
+   #
+   #  public final String toString(@Nullable Recognizer<?,?> recog) {
+   #      return toString(recog, ParserRuleContext.EMPTY);
+   #  }
+   #
+   #  public final String toString(@Nullable List<String> ruleNames) {
+   #      return toString(ruleNames, null);
+   #  }
+   #
+   #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+   #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+   #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+   #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+   #      return toString(ruleNamesList, stop);
+   #  }
+
+    def toString(self, ruleNames:list, stop:RuleContext)->str:
+        with StringIO() as buf:
+            p = self
+            buf.write("[")
+            while p is not None and p is not stop:
+                if ruleNames is None:
+                    if not p.isEmpty():
+                        buf.write(str(p.invokingState))
+                else:
+                    ri = p.getRuleIndex()
+                    ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else str(ri)
+                    buf.write(ruleName)
+
+                if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
+                    buf.write(" ")
+
+                p = p.parentCtx
+
+            buf.write("]")
+            return buf.getvalue()